kiro-spec-engine 1.47.12 → 1.47.15

package/CHANGELOG.md

@@ -8,6 +8,9 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 ## [Unreleased]
 
 ### Added
+- **Moqui runtime binding config overrides**: Added `--moqui-config <path>` to `kse scene run` and `kse scene doctor`, allowing runtime binding resolution to use an explicit `moqui-adapter.json` path per execution context.
+- **Moqui client rate-limit resilience tests**: Added dedicated unit coverage for `429 Too Many Requests` retry/exhaustion handling and retryable network error recovery in `tests/unit/scene-runtime/moqui-client.test.js`.
+- **Template ontology contract completeness**: Hardened scene package template contract examples to include ontology entities/relations plus governance lineage/rules/decision sections required by strict lint and ontology validation flows.
 - **Scene ontology impact/path analysis commands**: Added `kse scene ontology impact` (reverse dependency blast-radius analysis with `--relation` and `--max-depth`) and `kse scene ontology path` (shortest relation path between refs with optional `--undirected`) to improve ontology-driven change planning and explainability.
 - **Close-loop quantitative DoD gates**: Added `--dod-max-risk-level`, `--dod-kpi-min-completion-rate`, `--dod-max-success-rate-drop`, and `--dod-baseline-window` so autonomous closure can enforce explicit risk/KPI/baseline thresholds beyond binary checks.
 - **Close-loop conflict/ontology execution planning**: Added lease-conflict scheduling governance and scene ontology scheduling guidance with opt-out controls (`--no-conflict-governance`, `--no-ontology-guidance`), and surfaced planning telemetry in `portfolio.execution_plan` plus agent sync plan output.
@@ -114,6 +117,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - **Live orchestration status streaming**: Added event/interval-driven status persistence callback support in `runOrchestration()` and wired `auto close-loop` live progress output (`--no-stream` to disable).
 
 ### Changed
+- **Default ERP binding routing now prefers Moqui when configured**: Runtime default handler order now resolves `spec.erp.*` through `moqui.adapter` first when adapter config is present, while preserving deterministic fallback to `builtin.erp-sim` when config is unavailable.
+- **Moqui extraction output enriched for AI-native ontology usage**: Extracted manifests/contracts now emit action intent semantics, dependency chains, governance lineage, ontology model entities/relations, and agent hints for downstream planning.
 - **Controller queue hygiene default**: `close-loop-controller` now deduplicates duplicate broad goals by default (`--no-controller-dedupe` to preserve raw duplicates), and summary telemetry includes dedupe/lock/session metadata.
 - **Positioning and onboarding messaging**: Strengthened EN/ZH README and quick-start docs with explicit kse advantage matrix, 90-second value proof, and KPI observability positioning to improve first-contact clarity.
 - **CLI first-screen positioning text**: Updated `kse --help` top description in EN/ZH locales to reflect current core strengths: Spec workflow, orchestration, and KPI observability.
@@ -127,6 +132,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - **Autonomous operator UX**: Expanded docs with semantic decomposition and live stream behavior for close-loop command usage.
 
 ### Fixed
+- **Scene runtime 429 failure behavior under high request pressure**: Moqui HTTP client now retries on `429` with `Retry-After` support and bounded exponential backoff, reducing multi-agent stalls caused by transient service-side request limits.
+- **Moqui adapter matching fallback safety**: `spec.erp.*` bindings no longer get captured by Moqui handler when no adapter config exists, preventing false hard-fail paths and restoring expected simulator fallback behavior.
 - **Controller summary semantics**: `close-loop-controller` now reports final `pending_goals` from the persisted queue snapshot and only marks `cycle-limit-reached` as exhausted when pending work remains (or empty-polling mode explicitly consumes cycle budget).
 - **npm package hygiene**: Excluded transient Python bytecode artifacts (`__pycache__`, `*.pyc/pyo/pyd`) from published package contents to reduce package noise and size.
 - **Documentation contact placeholders**: Replaced `yourusername` placeholder repository links in onboarding docs with the canonical project URL and removed stale example email contact.

package/README.md

@@ -413,6 +413,12 @@ Tip: `kse spec bootstrap|pipeline run|gate run --specs ...` now defaults to this
   "maxParallel": 3,
   "timeoutSeconds": 900,
   "maxRetries": 2,
+  "rateLimitMaxRetries": 6,
+  "rateLimitBackoffBaseMs": 1000,
+  "rateLimitBackoffMaxMs": 30000,
+  "rateLimitAdaptiveParallel": true,
+  "rateLimitParallelFloor": 1,
+  "rateLimitCooldownMs": 30000,
   "apiKeyEnvVar": "CODEX_API_KEY",
   "codexArgs": ["--skip-git-repo-check"],
   "codexCommand": "npx @openai/codex"
@@ -420,6 +426,7 @@ Tip: `kse spec bootstrap|pipeline run|gate run --specs ...` now defaults to this
 ```
 
 If Codex CLI is globally installed, you can set `"codexCommand": "codex"`.
+Use the `rateLimit*` settings to absorb transient 429/too-many-requests failures without stalling orchestration.
 
 ### Spec-Level Steering & Context Sync 🚀 NEW in v1.44.0
 - **Spec Steering (L4)**: Independent `steering.md` per Spec with constraints, notes, and decisions — zero cross-agent conflict

package/README.zh.md

@@ -367,6 +367,12 @@ kse orchestrate stop
   "maxParallel": 3,
   "timeoutSeconds": 900,
   "maxRetries": 2,
+  "rateLimitMaxRetries": 6,
+  "rateLimitBackoffBaseMs": 1000,
+  "rateLimitBackoffMaxMs": 30000,
+  "rateLimitAdaptiveParallel": true,
+  "rateLimitParallelFloor": 1,
+  "rateLimitCooldownMs": 30000,
   "apiKeyEnvVar": "CODEX_API_KEY",
   "codexArgs": ["--skip-git-repo-check"],
   "codexCommand": "npx @openai/codex"
@@ -374,6 +380,7 @@ kse orchestrate stop
 ```
 
 如果你已全局安装 Codex CLI，可将 `"codexCommand"` 改为 `"codex"`。
+可通过 `rateLimit*` 配置吸收 429/too-many-requests 等限流抖动，避免编排流程卡死。
 
 ### Spec 级 Steering 与上下文同步 🚀 v1.44.0 新增
 - **Spec Steering (L4)**: 每个 Spec 独立的 `steering.md`，包含约束、注意事项、决策记录 — 跨 Agent 零冲突

package/docs/command-reference.md

@@ -787,12 +787,20 @@ Recommended `.kiro/config/orchestrator.json`:
   "maxParallel": 3,
   "timeoutSeconds": 900,
   "maxRetries": 2,
+  "rateLimitMaxRetries": 6,
+  "rateLimitBackoffBaseMs": 1000,
+  "rateLimitBackoffMaxMs": 30000,
+  "rateLimitAdaptiveParallel": true,
+  "rateLimitParallelFloor": 1,
+  "rateLimitCooldownMs": 30000,
   "apiKeyEnvVar": "CODEX_API_KEY",
   "codexArgs": ["--skip-git-repo-check"],
   "codexCommand": "npx @openai/codex"
 }
 ```
 
+`rateLimit*` settings provide dedicated retry/backoff and adaptive parallel throttling when providers return 429 / too-many-requests errors.
+
 ### Scene Template Engine
 
 ```bash

package/lib/commands/orchestrate.js

@@ -124,6 +124,9 @@ async function runOrchestration(options = {}, dependencies = {}) {
     'spec:start',
     'spec:complete',
     'spec:failed',
+    'spec:rate-limited',
+    'parallel:throttled',
+    'parallel:recovered',
     'orchestration:complete'
   ];
 
@@ -322,6 +325,17 @@ function _printStatus(status) {
   if (status.currentBatch !== undefined && status.totalBatches !== undefined) {
     console.log(`Batch: ${status.currentBatch} / ${status.totalBatches}`);
   }
+  if (status.parallel) {
+    const effective = status.parallel.effectiveMaxParallel ?? '-';
+    const max = status.parallel.maxParallel ?? '-';
+    const adaptive = status.parallel.adaptive === false ? 'off' : 'on';
+    console.log(`Parallel: ${effective} / ${max} (adaptive: ${adaptive})`);
+  }
+  if (status.rateLimit) {
+    const signals = status.rateLimit.signalCount || 0;
+    const backoff = status.rateLimit.totalBackoffMs || 0;
+    console.log(`Rate-limit: ${signals} signal(s), total backoff ${backoff}ms`);
+  }
   if (status.specs) {
     console.log('');
     for (const [name, info] of Object.entries(status.specs)) {

package/lib/commands/scene.js

@@ -183,6 +183,7 @@ function registerSceneCommands(program) {
     .option('--safety-preflight', 'Set context.safetyChecks.preflight=true')
     .option('--safety-stop-channel', 'Set context.safetyChecks.stopChannel=true')
     .option('--check-adapter', 'Run adapter readiness check for robot/hybrid scene')
+    .option('--moqui-config <path>', 'Path to moqui-adapter.json config file for runtime bindings')
     .option('--binding-plugin-dir <path>', 'Binding plugin directory for runtime handler loading')
     .option('--binding-plugin-manifest <path>', 'Binding plugin manifest JSON path')
     .option('--no-binding-plugin-auto-discovery', 'Disable runtime binding plugin auto-discovery under .kiro')
@@ -226,6 +227,7 @@ function registerSceneCommands(program) {
     .option('--allow-hybrid-commit', 'Set context.allowHybridCommit=true')
     .option('--safety-preflight', 'Set context.safetyChecks.preflight=true')
     .option('--safety-stop-channel', 'Set context.safetyChecks.stopChannel=true')
+    .option('--moqui-config <path>', 'Path to moqui-adapter.json config file for runtime bindings')
     .option('--binding-plugin-dir <path>', 'Binding plugin directory for runtime handler loading')
     .option('--binding-plugin-manifest <path>', 'Binding plugin manifest JSON path')
     .option('--no-binding-plugin-auto-discovery', 'Disable runtime binding plugin auto-discovery under .kiro')
@@ -929,6 +931,7 @@ function normalizeRunOptions(options = {}) {
     ...context,
     mode: options.mode || 'dry_run',
     traceId: options.traceId,
+    moquiConfig: options.moquiConfig,
     bindingPluginDir: options.bindingPluginDir,
     bindingPluginManifest: options.bindingPluginManifest,
     bindingPluginAutoDiscovery: options.bindingPluginAutoDiscovery !== false,
@@ -952,6 +955,7 @@ function normalizeDoctorOptions(options = {}) {
     mode: options.mode || 'dry_run',
     traceId: options.traceId,
     checkAdapter: options.checkAdapter === true,
+    moquiConfig: options.moquiConfig,
     bindingPluginDir: options.bindingPluginDir,
     bindingPluginManifest: options.bindingPluginManifest,
     bindingPluginAutoDiscovery: options.bindingPluginAutoDiscovery !== false,
@@ -1226,6 +1230,10 @@ function validateRunOptions(options) {
     return '--binding-plugin-manifest must be a non-empty path';
   }
 
+  if (options.moquiConfig && (typeof options.moquiConfig !== 'string' || String(options.moquiConfig).trim().length === 0)) {
+    return '--moqui-config must be a non-empty path';
+  }
+
   return null;
 }
 
@@ -1252,6 +1260,10 @@ function validateDoctorOptions(options) {
     return '--binding-plugin-manifest must be a non-empty path';
   }
 
+  if (options.moquiConfig && (typeof options.moquiConfig !== 'string' || String(options.moquiConfig).trim().length === 0)) {
+    return '--moqui-config must be a non-empty path';
+  }
+
   return null;
 }
 
@@ -6478,6 +6490,7 @@ async function runSceneDoctorCommand(rawOptions = {}, dependencies = {}) {
 
   const runtimeExecutor = dependencies.runtimeExecutor || new RuntimeExecutor({
     projectRoot,
+    moquiConfigPath: options.moquiConfig,
     bindingPluginDir: options.bindingPluginDir,
     bindingPluginManifest: options.bindingPluginManifest,
     bindingPluginAutoDiscovery: options.bindingPluginAutoDiscovery,
@@ -8234,6 +8247,7 @@ async function runSceneCommand(rawOptions = {}, dependencies = {}) {
 
   const runtimeExecutor = dependencies.runtimeExecutor || new RuntimeExecutor({
     projectRoot,
+    moquiConfigPath: options.moquiConfig,
     bindingPluginDir: options.bindingPluginDir,
     bindingPluginManifest: options.bindingPluginManifest,
     bindingPluginAutoDiscovery: options.bindingPluginAutoDiscovery,

package/lib/orchestrator/orchestration-engine.js

@@ -463,6 +463,12 @@ class OrchestrationEngine extends EventEmitter {
         : 0;
       if (retryDelayMs > 0) {
         this._onRateLimitSignal();
+        this._updateStatusMonitorRateLimit({
+          specName,
+          retryCount,
+          retryDelayMs,
+          error: resolvedError,
+        });
         this.emit('spec:rate-limited', {
           specName,
           retryCount,
@@ -650,6 +656,15 @@ class OrchestrationEngine extends EventEmitter {
     this._baseMaxParallel = boundedMax;
     this._effectiveMaxParallel = boundedMax;
     this._rateLimitCooldownUntil = 0;
+    this._updateStatusMonitorParallelTelemetry({
+      adaptive: this._isAdaptiveParallelEnabled(),
+      maxParallel: boundedMax,
+      effectiveMaxParallel: boundedMax,
+      floor: Math.min(
+        boundedMax,
+        this._toPositiveInteger(this._rateLimitParallelFloor, DEFAULT_RATE_LIMIT_PARALLEL_FLOOR)
+      ),
+    });
   }
 
   /**
@@ -659,20 +674,35 @@ class OrchestrationEngine extends EventEmitter {
    */
   _getEffectiveMaxParallel(maxParallel) {
     const boundedMax = this._toPositiveInteger(maxParallel, 1);
+    const floor = Math.min(
+      boundedMax,
+      this._toPositiveInteger(this._rateLimitParallelFloor, DEFAULT_RATE_LIMIT_PARALLEL_FLOOR)
+    );
+
     if (!this._isAdaptiveParallelEnabled()) {
       this._baseMaxParallel = boundedMax;
+      this._effectiveMaxParallel = boundedMax;
+      this._updateStatusMonitorParallelTelemetry({
+        adaptive: false,
+        maxParallel: boundedMax,
+        effectiveMaxParallel: boundedMax,
+        floor,
+      });
       return boundedMax;
     }
 
     this._baseMaxParallel = boundedMax;
     this._maybeRecoverParallelLimit(boundedMax);
 
-    const floor = Math.min(
-      boundedMax,
-      this._toPositiveInteger(this._rateLimitParallelFloor, DEFAULT_RATE_LIMIT_PARALLEL_FLOOR)
-    );
     const effective = this._toPositiveInteger(this._effectiveMaxParallel, boundedMax);
-    return Math.max(floor, Math.min(boundedMax, effective));
+    const resolved = Math.max(floor, Math.min(boundedMax, effective));
+    this._updateStatusMonitorParallelTelemetry({
+      adaptive: true,
+      maxParallel: boundedMax,
+      effectiveMaxParallel: resolved,
+      floor,
+    });
+    return resolved;
   }
 
   /**
@@ -693,6 +723,14 @@ class OrchestrationEngine extends EventEmitter {
 
     if (next < current) {
       this._effectiveMaxParallel = next;
+      this._updateStatusMonitorParallelTelemetry({
+        event: 'throttled',
+        reason: 'rate-limit',
+        adaptive: true,
+        maxParallel: base,
+        effectiveMaxParallel: next,
+        floor,
+      });
       this.emit('parallel:throttled', {
         reason: 'rate-limit',
         previousMaxParallel: current,
@@ -730,6 +768,12 @@ class OrchestrationEngine extends EventEmitter {
     if (next > current) {
       this._effectiveMaxParallel = next;
       this._rateLimitCooldownUntil = this._getNow() + this._rateLimitCooldownMs;
+      this._updateStatusMonitorParallelTelemetry({
+        event: 'recovered',
+        adaptive: true,
+        maxParallel: boundedMax,
+        effectiveMaxParallel: next,
+      });
       this.emit('parallel:recovered', {
         previousMaxParallel: current,
         effectiveMaxParallel: next,
@@ -841,6 +885,40 @@ class OrchestrationEngine extends EventEmitter {
     return new Promise((resolve) => setTimeout(resolve, ms));
   }
 
+  /**
+   * Safely update StatusMonitor rate-limit telemetry.
+   *
+   * @param {object} payload
+   * @private
+   */
+  _updateStatusMonitorRateLimit(payload) {
+    const handler = this._statusMonitor && this._statusMonitor.recordRateLimitEvent;
+    if (typeof handler === 'function') {
+      try {
+        handler.call(this._statusMonitor, payload);
+      } catch (_err) {
+        // Non-fatal status telemetry update.
+      }
+    }
+  }
+
+  /**
+   * Safely update StatusMonitor adaptive parallel telemetry.
+   *
+   * @param {object} payload
+   * @private
+   */
+  _updateStatusMonitorParallelTelemetry(payload) {
+    const handler = this._statusMonitor && this._statusMonitor.updateParallelTelemetry;
+    if (typeof handler === 'function') {
+      try {
+        handler.call(this._statusMonitor, payload);
+      } catch (_err) {
+        // Non-fatal status telemetry update.
+      }
+    }
+  }
+
   /**
    * Validate that all spec directories exist (Req 6.4).
    *

package/lib/orchestrator/status-monitor.js

@@ -56,6 +56,37 @@ class StatusMonitor {
      * @type {Map<string, {status: string, batch: number, agentId: string|null, retryCount: number, error: string|null, turnCount: number}>}
      */
     this._specs = new Map();
+
+    /**
+     * Rate-limit telemetry summary.
+     * @type {{signalCount: number, retryCount: number, totalBackoffMs: number, lastSignalAt: string|null, lastSpecName: string|null, lastRetryCount: number, lastDelayMs: number, lastError: string|null}}
+     */
+    this._rateLimit = {
+      signalCount: 0,
+      retryCount: 0,
+      totalBackoffMs: 0,
+      lastSignalAt: null,
+      lastSpecName: null,
+      lastRetryCount: 0,
+      lastDelayMs: 0,
+      lastError: null,
+    };
+
+    /**
+     * Parallelism telemetry summary.
+     * @type {{adaptive: boolean|null, maxParallel: number|null, effectiveMaxParallel: number|null, floor: number|null, throttledCount: number, recoveredCount: number, lastReason: string|null, lastThrottledAt: string|null, lastRecoveredAt: string|null}}
+     */
+    this._parallel = {
+      adaptive: null,
+      maxParallel: null,
+      effectiveMaxParallel: null,
+      floor: null,
+      throttledCount: 0,
+      recoveredCount: 0,
+      lastReason: null,
+      lastThrottledAt: null,
+      lastRecoveredAt: null,
+    };
   }
 
   // ---------------------------------------------------------------------------
@@ -125,6 +156,80 @@ class StatusMonitor {
     }
   }
 
+  /**
+   * Record a rate-limit retry/backoff signal.
+   *
+   * @param {object} data
+   * @param {string} [data.specName]
+   * @param {number} [data.retryCount]
+   * @param {number} [data.retryDelayMs]
+   * @param {string} [data.error]
+   */
+  recordRateLimitEvent(data = {}) {
+    const delay = Number(data.retryDelayMs);
+    const retryCount = Number(data.retryCount);
+
+    this._rateLimit.signalCount++;
+    this._rateLimit.retryCount++;
+    this._rateLimit.totalBackoffMs += Number.isFinite(delay) && delay > 0 ? Math.round(delay) : 0;
+    this._rateLimit.lastSignalAt = new Date().toISOString();
+
+    if (typeof data.specName === 'string' && data.specName.trim()) {
+      this._rateLimit.lastSpecName = data.specName.trim();
+    }
+    if (Number.isFinite(retryCount) && retryCount >= 0) {
+      this._rateLimit.lastRetryCount = Math.floor(retryCount);
+    }
+    this._rateLimit.lastDelayMs = Number.isFinite(delay) && delay > 0 ? Math.round(delay) : 0;
+    if (data.error !== undefined && data.error !== null) {
+      this._rateLimit.lastError = `${data.error}`;
+    }
+  }
+
+  /**
+   * Update adaptive parallel telemetry.
+   *
+   * @param {object} data
+   * @param {'throttled'|'recovered'} [data.event]
+   * @param {string} [data.reason]
+   * @param {number} [data.maxParallel]
+   * @param {number} [data.effectiveMaxParallel]
+   * @param {number} [data.floor]
+   * @param {boolean} [data.adaptive]
+   */
+  updateParallelTelemetry(data = {}) {
+    if (typeof data.adaptive === 'boolean') {
+      this._parallel.adaptive = data.adaptive;
+    }
+
+    const maxParallel = Number(data.maxParallel);
+    if (Number.isFinite(maxParallel) && maxParallel > 0) {
+      this._parallel.maxParallel = Math.floor(maxParallel);
+    }
+
+    const effective = Number(data.effectiveMaxParallel);
+    if (Number.isFinite(effective) && effective > 0) {
+      this._parallel.effectiveMaxParallel = Math.floor(effective);
+    }
+
+    const floor = Number(data.floor);
+    if (Number.isFinite(floor) && floor > 0) {
+      this._parallel.floor = Math.floor(floor);
+    }
+
+    if (typeof data.reason === 'string' && data.reason.trim()) {
+      this._parallel.lastReason = data.reason.trim();
+    }
+
+    if (data.event === 'throttled') {
+      this._parallel.throttledCount++;
+      this._parallel.lastThrottledAt = new Date().toISOString();
+    } else if (data.event === 'recovered') {
+      this._parallel.recoveredCount++;
+      this._parallel.lastRecoveredAt = new Date().toISOString();
+    }
+  }
+
   /**
    * Set the overall orchestration state.
    *
@@ -219,6 +324,8 @@ class StatusMonitor {
       currentBatch: this._currentBatch,
       totalBatches: this._totalBatches,
       specs,
+      rateLimit: { ...this._rateLimit },
+      parallel: { ...this._parallel },
     };
   }
 

package/lib/scene-runtime/binding-registry.js

@@ -1,4 +1,6 @@
-const DEFAULT_READINESS_SUCCESS = {
+const { createMoquiAdapterHandler } = require('./moqui-adapter');
+
+const DEFAULT_READINESS_SUCCESS = {
   passed: true,
   reason: 'default-ready'
 };
@@ -130,6 +132,12 @@ function normalizeReadinessResult(rawResult, fallbackName) {
 
 class BindingRegistry {
   constructor(options = {}) {
+    this.projectRoot = options.projectRoot || process.cwd();
+    this.moquiConfigPath = typeof options.moquiConfigPath === 'string' && options.moquiConfigPath.trim().length > 0
+      ? options.moquiConfigPath.trim()
+      : undefined;
+    this.useMoquiAdapter = options.useMoquiAdapter !== false;
+
     this.handlers = [];
     this.fallbackHandler = {
       id: 'builtin.default',
@@ -158,6 +166,14 @@ class BindingRegistry {
   }
 
   registerDefaultHandlers() {
+    if (this.useMoquiAdapter) {
+      this.register(createMoquiAdapterHandler({
+        projectRoot: this.projectRoot,
+        configPath: this.moquiConfigPath,
+        allowSpecErpFallback: true
+      }));
+    }
+
     this.register({
       id: 'builtin.erp-sim',
       match: { refPrefix: 'spec.erp.' },

package/lib/scene-runtime/moqui-adapter.js

@@ -12,6 +12,19 @@ const DEFAULT_CONFIG_FILENAME = 'moqui-adapter.json';
 const ENTITY_OPERATIONS = ['list', 'get', 'create', 'update', 'delete'];
 const SERVICE_OPERATIONS = ['invoke', 'async', 'job-status'];
 
+function resolveAdapterConfigPath(configPath, projectRoot) {
+  if (configPath) {
+    return path.resolve(projectRoot || process.cwd(), configPath);
+  }
+
+  return path.resolve(projectRoot || process.cwd(), DEFAULT_CONFIG_FILENAME);
+}
+
+function hasAdapterConfigFile(configPath, projectRoot) {
+  const resolvedPath = resolveAdapterConfigPath(configPath, projectRoot);
+  return fs.pathExistsSync(resolvedPath);
+}
+
 /**
  * Load and validate adapter config from file.
  * @param {string} [configPath] - Path to moqui-adapter.json
@@ -19,9 +32,7 @@ const SERVICE_OPERATIONS = ['invoke', 'async', 'job-status'];
  * @returns {{ config: Object, error?: string }}
  */
 function loadAdapterConfig(configPath, projectRoot) {
-  const resolvedPath = configPath
-    ? path.resolve(projectRoot || process.cwd(), configPath)
-    : path.resolve(projectRoot || process.cwd(), DEFAULT_CONFIG_FILENAME);
+  const resolvedPath = resolveAdapterConfigPath(configPath, projectRoot);
 
   let rawContent;
 
@@ -404,6 +415,8 @@ function buildHttpRequest(descriptor, payload = {}) {
  */
 function createMoquiAdapterHandler(options = {}) {
   const HANDLER_ID = 'moqui.adapter';
+  const allowSpecErpFallback = options.allowSpecErpFallback !== false;
+  const strictMatch = options.strictMatch === true;
 
   let client = options.client || null;
   let configLoaded = false;
@@ -441,12 +454,36 @@ function createMoquiAdapterHandler(options = {}) {
     return { client };
   }
 
+  function shouldHandleBindingRef(bindingRef) {
+    const ref = String(bindingRef || '').trim();
+
+    if (!ref) {
+      return false;
+    }
+
+    if (ref.startsWith('moqui.')) {
+      return true;
+    }
+
+    if (!ref.startsWith('spec.erp.')) {
+      return false;
+    }
+
+    if (strictMatch || !allowSpecErpFallback) {
+      return true;
+    }
+
+    if (client) {
+      return true;
+    }
+
+    return hasAdapterConfigFile(options.configPath, options.projectRoot);
+  }
+
   return {
     id: HANDLER_ID,
 
-    match: {
-      refPrefix: ['spec.erp.', 'moqui.']
-    },
+    match: (node = {}) => shouldHandleBindingRef(node.binding_ref || node.ref),
 
     /**
      * Execute a binding node against the Moqui REST API.
@@ -571,6 +608,8 @@ module.exports = {
   mapMoquiResponseToResult,
   buildHttpRequest,
   createMoquiAdapterHandler,
+  resolveAdapterConfigPath,
+  hasAdapterConfigFile,
   // Exported for testing
   applyConfigDefaults,
   DEFAULT_TIMEOUT,

package/lib/scene-runtime/moqui-client.js

@@ -5,6 +5,7 @@ const { URL } = require('url');
 const DEFAULT_TIMEOUT = 30000;
 const DEFAULT_RETRY_COUNT = 2;
 const DEFAULT_RETRY_DELAY = 1000;
+const DEFAULT_MAX_RETRY_DELAY = 30000;
 
 const RETRYABLE_NETWORK_ERRORS = [
   'ECONNREFUSED',
@@ -26,7 +27,57 @@ function isRetryableNetworkError(error) {
 }
 
 function isRetryableStatusCode(statusCode) {
-  return statusCode >= 500 && statusCode <= 599;
+  return statusCode === 429 || (statusCode >= 500 && statusCode <= 599);
+}
+
+function parseRetryAfterMs(headers = {}) {
+  if (!headers || typeof headers !== 'object') {
+    return null;
+  }
+
+  const retryAfterValue = headers['retry-after'] || headers['Retry-After'];
+
+  if (retryAfterValue === undefined || retryAfterValue === null) {
+    return null;
+  }
+
+  const asNumber = Number(retryAfterValue);
+  if (Number.isFinite(asNumber) && asNumber >= 0) {
+    return Math.floor(asNumber * 1000);
+  }
+
+  const asDateMs = Date.parse(String(retryAfterValue));
+  if (!Number.isFinite(asDateMs)) {
+    return null;
+  }
+
+  return Math.max(0, asDateMs - Date.now());
+}
+
+function clampRetryDelay(ms, maxRetryDelay) {
+  const parsed = Number(ms);
+
+  if (!Number.isFinite(parsed)) {
+    return 0;
+  }
+
+  const bounded = Math.max(0, parsed);
+  if (!Number.isFinite(maxRetryDelay) || maxRetryDelay <= 0) {
+    return Math.floor(bounded);
+  }
+
+  return Math.floor(Math.min(maxRetryDelay, bounded));
+}
+
+function computeRetryDelayMs(attempt, baseRetryDelay, retryAfterMs, maxRetryDelay) {
+  if (Number.isFinite(retryAfterMs) && retryAfterMs >= 0) {
+    return clampRetryDelay(retryAfterMs, maxRetryDelay);
+  }
+
+  const exponent = Math.max(0, attempt);
+  const backoff = Number(baseRetryDelay) * Math.pow(2, exponent);
+
+  return clampRetryDelay(backoff, maxRetryDelay);
 }
 
 function delay(ms) {
@@ -66,7 +117,8 @@ class MoquiClient {
       credentials: config.credentials || {},
       timeout: typeof config.timeout === 'number' ? config.timeout : DEFAULT_TIMEOUT,
       retryCount: typeof config.retryCount === 'number' ? config.retryCount : DEFAULT_RETRY_COUNT,
-      retryDelay: typeof config.retryDelay === 'number' ? config.retryDelay : DEFAULT_RETRY_DELAY
+      retryDelay: typeof config.retryDelay === 'number' ? config.retryDelay : DEFAULT_RETRY_DELAY,
+      maxRetryDelay: typeof config.maxRetryDelay === 'number' ? config.maxRetryDelay : DEFAULT_MAX_RETRY_DELAY
     };
 
     this.accessToken = null;
@@ -338,10 +390,6 @@ class MoquiClient {
     const maxAttempts = this.config.retryCount + 1;
 
     for (let attempt = 0; attempt < maxAttempts; attempt++) {
-      if (attempt > 0) {
-        await delay(this.config.retryDelay);
-      }
-
       try {
         // Update auth header in case token was refreshed
         if (this.accessToken) {
@@ -381,16 +429,36 @@ class MoquiClient {
           };
         }
 
-        // Retry on 5xx
+        // Retry on 429 and 5xx
         if (isRetryableStatusCode(response.statusCode)) {
+          const isRateLimited = response.statusCode === 429;
+
           lastError = {
             success: false,
             error: {
-              code: 'MOQUI_ERROR',
-              message: `Server error: ${response.statusCode}`,
+              code: isRateLimited ? 'RATE_LIMITED' : 'MOQUI_ERROR',
+              message: isRateLimited
+                ? `Rate limited: ${response.statusCode}`
+                : `Server error: ${response.statusCode}`,
               details: response.body
             }
           };
+
+          if (attempt >= maxAttempts - 1) {
+            break;
+          }
+
+          const retryDelayMs = computeRetryDelayMs(
+            attempt,
+            this.config.retryDelay,
+            parseRetryAfterMs(response.headers),
+            this.config.maxRetryDelay
+          );
+
+          if (retryDelayMs > 0) {
+            await delay(retryDelayMs);
+          }
+
           continue;
         }
 
@@ -415,6 +483,22 @@ class MoquiClient {
               message: `Network error: ${error.message} (${fullUrl})`
             }
           };
+
+          if (attempt >= maxAttempts - 1) {
+            break;
+          }
+
+          const retryDelayMs = computeRetryDelayMs(
+            attempt,
+            this.config.retryDelay,
+            null,
+            this.config.maxRetryDelay
+          );
+
+          if (retryDelayMs > 0) {
+            await delay(retryDelayMs);
+          }
+
           continue;
         }
 

package/lib/scene-runtime/moqui-extractor.js

@@ -1131,44 +1131,15 @@ function analyzeResources(discovery, options = {}) {
   return results;
 }
 
-// ─── Scene Manifest Generation ────────────────────────────────────
-
-/**
- * Generate a scene manifest object for a pattern match.
- * Produces a manifest with correct apiVersion, kind, bindings, model_scope,
- * and governance_contract based on the pattern type.
- *
- * Pattern rules for bindings:
- * - "crud": 5 bindings (list, get = query; create, update, delete = mutation with side_effect)
- * - "query": 2 bindings (list, get = query)
- * - "workflow": service invoke bindings (type: 'invoke', ref from bindingRefs)
- *
- * Governance rules:
- * - "query": risk_level "low", approval.required false, no idempotency
- * - "crud"/"workflow": risk_level "medium", approval.required true, idempotency.required true
- *
- * @param {PatternMatch} match - Matched pattern
- * @returns {Object|null} Scene manifest object, or null for invalid input
- */
-function generateSceneManifest(match) {
-  if (!match || !match.pattern || !match.primaryResource) {
-    return null;
-  }
-
+function buildBaseBindings(match) {
   const pattern = match.pattern;
-  const primaryResource = match.primaryResource;
-  const packageName = derivePackageName(match);
-
-  // Build bindings based on pattern type
   const bindings = [];
 
   if (pattern === 'crud' || pattern === 'query') {
-    // Entity-based patterns use bindingRefs from the match
     const primaryEntity = Array.isArray(match.entities) && match.entities.length > 0
       ? match.entities[0]
-      : primaryResource;
+      : match.primaryResource;
 
-    // Query bindings (list, get)
     bindings.push({
       type: 'query',
       ref: `moqui.${primaryEntity}.list`,
@@ -1183,7 +1154,6 @@ function generateSceneManifest(match) {
     });
 
     if (pattern === 'crud') {
-      // Mutation bindings (create, update, delete)
       bindings.push({
         type: 'mutation',
         ref: `moqui.${primaryEntity}.create`,
@@ -1207,9 +1177,7 @@ function generateSceneManifest(match) {
       });
     }
   } else if (pattern === 'workflow') {
-    // Workflow patterns use service invoke bindings from bindingRefs
     const refs = Array.isArray(match.bindingRefs) ? match.bindingRefs : [];
-
     for (const ref of refs) {
       bindings.push({
         type: 'invoke',
@@ -1220,37 +1188,324 @@ function generateSceneManifest(match) {
     }
   }
 
-  // Build model_scope from match
-  const modelScope = match.modelScope || { read: [], write: [] };
+  return bindings;
+}
 
-  // Build governance_contract based on pattern type
-  let governanceContract;
+function deriveBindingIntent(binding, primaryResource) {
+  const ref = String(binding.ref || '');
 
-  if (pattern === 'query') {
-    governanceContract = {
-      risk_level: 'low',
-      approval: {
-        required: false
-      }
+  if (ref.endsWith('.list')) {
+    return `List ${primaryResource} records from Moqui`;
+  }
+
+  if (ref.endsWith('.get')) {
+    return `Retrieve a single ${primaryResource} record`;
+  }
+
+  if (ref.endsWith('.create')) {
+    return `Create a new ${primaryResource} record`;
+  }
+
+  if (ref.endsWith('.update')) {
+    return `Update an existing ${primaryResource} record`;
+  }
+
+  if (ref.endsWith('.delete')) {
+    return `Delete an existing ${primaryResource} record`;
+  }
+
+  if (ref.endsWith('.invoke')) {
+    return `Invoke workflow service for ${primaryResource}`;
+  }
+
+  return `Execute ${ref}`;
+}
+
+function deriveBindingPreconditions(binding, previousRef) {
+  const checks = ['Moqui adapter authentication is valid'];
+
+  if (binding.type === 'query') {
+    checks.push('Read scope permits this query');
+  } else if (binding.type === 'mutation') {
+    checks.push('Input payload validation passed');
+  } else if (binding.type === 'invoke') {
+    checks.push('Workflow input contract is satisfied');
+  }
+
+  if (previousRef) {
+    checks.push(`Dependency ${previousRef} completed successfully`);
+  }
+
+  return checks;
+}
+
+function deriveBindingPostconditions(binding) {
+  if (binding.type === 'query') {
+    return ['Query result is available for downstream composition'];
+  }
+
+  if (binding.type === 'mutation') {
+    return ['Mutation result is captured and write scope is consistent'];
+  }
+
+  if (binding.type === 'invoke') {
+    return ['Workflow step output is captured for downstream execution'];
+  }
+
+  return ['Binding execution result is available'];
+}
+
+function addBindingSemantics(baseBindings, primaryResource) {
+  const bindings = [];
+
+  for (let i = 0; i < baseBindings.length; i++) {
+    const base = baseBindings[i];
+    const previous = i > 0 ? baseBindings[i - 1] : null;
+    const binding = {
+      ...base,
+      intent: deriveBindingIntent(base, primaryResource),
+      preconditions: deriveBindingPreconditions(base, previous ? previous.ref : null),
+      postconditions: deriveBindingPostconditions(base)
     };
+
+    if (previous && previous.ref) {
+      binding.depends_on = previous.ref;
+    }
+
+    bindings.push(binding);
+  }
+
+  return bindings;
+}
+
+function buildDataLineage(bindings, pattern, primaryResource) {
+  if (!Array.isArray(bindings) || bindings.length === 0) {
+    return {
+      sources: [],
+      transforms: [],
+      sinks: []
+    };
+  }
+
+  const firstRef = bindings[0].ref;
+  const lastRef = bindings[bindings.length - 1].ref;
+  const sourceField = `${toKebabCase(primaryResource)}Id`;
+
+  const transforms = [
+    {
+      operation: 'normalizeInput',
+      description: `Normalize ${primaryResource} request payload for template execution`
+    }
+  ];
+
+  if (pattern === 'workflow') {
+    transforms.push({
+      operation: 'orchestrateWorkflow',
+      description: `Coordinate service chain for ${primaryResource}`
+    });
+  } else if (pattern === 'crud') {
+    transforms.push({
+      operation: 'applyMutationGuard',
+      description: `Apply mutation and idempotency guard for ${primaryResource}`
+    });
   } else {
-    // crud and workflow
-    const gov = match.governance || {};
-    const idempotencyKey = gov.idempotencyKey || deriveIdempotencyKey(
-      Array.isArray(match.entities) && match.entities.length > 0
-        ? match.entities[0]
-        : primaryResource
-    );
-
-    governanceContract = {
-      risk_level: 'medium',
-      approval: {
-        required: true
-      },
-      idempotency: {
-        required: true,
-        key: idempotencyKey
+    transforms.push({
+      operation: 'projectQueryResult',
+      description: `Project query result set for ${primaryResource}`
+    });
+  }
+
+  return {
+    sources: [
+      {
+        ref: firstRef,
+        fields: [sourceField, 'statusId']
+      }
+    ],
+    transforms,
+    sinks: [
+      {
+        ref: lastRef,
+        fields: [sourceField, 'statusId']
       }
+    ]
+  };
+}
+
+function buildEntityRefs(match, primaryResource) {
+  const refs = Array.isArray(match.entities) && match.entities.length > 0
+    ? match.entities.filter(Boolean)
+    : [primaryResource];
+
+  return refs.map((entity, index) => ({
+    id: String(entity),
+    type: index === 0 ? 'primary' : 'related'
+  }));
+}
+
+function buildEntityRelations(entityRefs) {
+  if (!Array.isArray(entityRefs) || entityRefs.length === 0) {
+    return [];
+  }
+
+  const relations = [];
+  const primaryId = entityRefs[0].id;
+
+  for (let i = 1; i < entityRefs.length; i++) {
+    relations.push({
+      source: primaryId,
+      target: entityRefs[i].id,
+      type: 'composes'
+    });
+  }
+
+  if (relations.length === 0) {
+    relations.push({
+      source: primaryId,
+      target: 'metadata_view',
+      type: 'produces'
+    });
+  }
+
+  return relations;
+}
+
+function buildBusinessRules(pattern, bindings, primaryResource) {
+  const firstRef = bindings[0] ? bindings[0].ref : null;
+  const lastRef = bindings[bindings.length - 1] ? bindings[bindings.length - 1].ref : null;
+
+  const rules = [
+    {
+      id: `rule.${toKebabCase(primaryResource)}.binding-order`,
+      description: `Bindings for ${primaryResource} must execute in declared dependency order`,
+      bind_to: firstRef,
+      status: 'enforced'
+    }
+  ];
+
+  if (pattern === 'query') {
+    rules.push({
+      id: `rule.${toKebabCase(primaryResource)}.read-only`,
+      description: `${primaryResource} query template must remain side-effect free`,
+      bind_to: lastRef,
+      status: 'active'
+    });
+  } else {
+    rules.push({
+      id: `rule.${toKebabCase(primaryResource)}.approval-or-idempotency`,
+      description: `${primaryResource} template must enforce approval or idempotency guard`,
+      bind_to: lastRef,
+      status: 'active'
+    });
+  }
+
+  return rules;
+}
+
+function buildDecisionLogic(pattern, bindings, primaryResource) {
+  const lastRef = bindings[bindings.length - 1] ? bindings[bindings.length - 1].ref : null;
+  const riskDecision = pattern === 'query'
+    ? 'Use low-risk dry-run defaults for query execution'
+    : 'Use guarded execution with approval and retry policies';
+
+  return [
+    {
+      id: `decision.${toKebabCase(primaryResource)}.risk-strategy`,
+      description: riskDecision,
+      bind_to: lastRef,
+      status: 'resolved',
+      automated: true
+    },
+    {
+      id: `decision.${toKebabCase(primaryResource)}.retry-strategy`,
+      description: 'Apply timeout/retry profile derived from template contract',
+      bind_to: lastRef,
+      status: 'resolved',
+      automated: true
+    }
+  ];
+}
+
+function buildAgentHints(pattern, primaryResource, bindings) {
+  const complexity = pattern === 'query' ? 'low' : 'medium';
+  const baseDuration = pattern === 'query' ? 1800 : 3000;
+  const permissions = pattern === 'query'
+    ? ['moqui.read']
+    : ['moqui.read', 'moqui.write'];
+
+  return {
+    summary: `${pattern.toUpperCase()} template extracted for ${primaryResource} with Moqui-aware ontology`,
+    complexity,
+    estimated_duration_ms: baseDuration + (bindings.length * 150),
+    required_permissions: permissions,
+    suggested_sequence: bindings.map((binding) => binding.ref),
+    rollback_strategy: pattern === 'query'
+      ? 'Re-run query with previous filters'
+      : 'Reconcile idempotency key and rollback to pre-mutation snapshot'
+  };
+}
+
+// ─── Scene Manifest Generation ────────────────────────────────────
+
+/**
+ * Generate a scene manifest object for a pattern match.
+ * Produces a manifest with correct apiVersion, kind, bindings, model_scope,
+ * and governance_contract based on the pattern type.
+ *
+ * Pattern rules for bindings:
+ * - "crud": 5 bindings (list, get = query; create, update, delete = mutation with side_effect)
+ * - "query": 2 bindings (list, get = query)
+ * - "workflow": service invoke bindings (type: 'invoke', ref from bindingRefs)
+ *
+ * Governance rules:
+ * - "query": risk_level "low", approval.required false, no idempotency
+ * - "crud"/"workflow": risk_level "medium", approval.required true, idempotency.required true
+ *
+ * @param {PatternMatch} match - Matched pattern
+ * @returns {Object|null} Scene manifest object, or null for invalid input
+ */
+function generateSceneManifest(match) {
+  if (!match || !match.pattern || !match.primaryResource) {
+    return null;
+  }
+
+  const pattern = match.pattern;
+  const primaryResource = match.primaryResource;
+  const packageName = derivePackageName(match);
+  const gov = match.governance || {};
+
+  const baseBindings = buildBaseBindings(match);
+  const bindings = addBindingSemantics(baseBindings, primaryResource);
+
+  // Build model_scope from match
+  const modelScope = match.modelScope || { read: [], write: [] };
+
+  // Build governance_contract based on pattern type
+  const riskLevel = gov.riskLevel || (pattern === 'query' ? 'low' : 'medium');
+  const approvalRequired = gov.approvalRequired !== undefined
+    ? gov.approvalRequired
+    : (pattern !== 'query');
+  const idempotencyRequired = gov.idempotencyRequired !== undefined
+    ? gov.idempotencyRequired
+    : (pattern !== 'query');
+  const idempotencyKey = gov.idempotencyKey || deriveIdempotencyKey(
+    Array.isArray(match.entities) && match.entities.length > 0
+      ? match.entities[0]
+      : primaryResource
+  );
+
+  const governanceContract = {
+    risk_level: riskLevel,
+    approval: {
+      required: approvalRequired
+    },
+    data_lineage: buildDataLineage(bindings, pattern, primaryResource)
+  };
+
+  if (idempotencyRequired) {
+    governanceContract.idempotency = {
+      required: true,
+      key: idempotencyKey
     };
   }
 
@@ -1311,6 +1566,41 @@ function generatePackageContract(match) {
   const primaryResource = match.primaryResource;
   const packageName = derivePackageName(match);
   const gov = match.governance || {};
+  const baseBindings = buildBaseBindings(match);
+  const bindings = addBindingSemantics(baseBindings, primaryResource);
+  const riskLevel = gov.riskLevel || (pattern === 'query' ? 'low' : 'medium');
+  const approvalRequired = gov.approvalRequired !== undefined
+    ? gov.approvalRequired
+    : (pattern !== 'query');
+  const idempotencyRequired = gov.idempotencyRequired !== undefined
+    ? gov.idempotencyRequired
+    : (pattern !== 'query');
+  const idempotencyKey = gov.idempotencyKey || deriveIdempotencyKey(
+    Array.isArray(match.entities) && match.entities.length > 0
+      ? match.entities[0]
+      : primaryResource
+  );
+  const entityRefs = buildEntityRefs(match, primaryResource);
+  const relations = buildEntityRelations(entityRefs);
+  const hasMetadataView = entityRefs.some((entity) => entity.id === 'metadata_view');
+
+  if (!hasMetadataView) {
+    entityRefs.push({ id: 'metadata_view', type: 'projection' });
+  }
+
+  const hasMetadataRelation = relations.some((relation) => (
+    relation.source === entityRefs[0].id
+    && relation.target === 'metadata_view'
+    && relation.type === 'produces'
+  ));
+
+  if (!hasMetadataRelation) {
+    relations.push({
+      source: entityRefs[0].id,
+      target: 'metadata_view',
+      type: 'produces'
+    });
+  }
 
   // Derive summary based on pattern type
   let summary;
@@ -1325,11 +1615,22 @@ function generatePackageContract(match) {
     summary = `Template for ${primaryResource} extracted from Moqui ERP`;
   }
 
-  // Determine governance fields from match
-  const riskLevel = gov.riskLevel || (pattern === 'query' ? 'low' : 'medium');
-  const approvalRequired = gov.approvalRequired !== undefined
-    ? gov.approvalRequired
-    : (pattern !== 'query');
+  const governanceContract = {
+    risk_level: riskLevel,
+    approval: {
+      required: approvalRequired
+    },
+    data_lineage: buildDataLineage(bindings, pattern, primaryResource),
+    business_rules: buildBusinessRules(pattern, bindings, primaryResource),
+    decision_logic: buildDecisionLogic(pattern, bindings, primaryResource)
+  };
+
+  if (idempotencyRequired) {
+    governanceContract.idempotency = {
+      required: true,
+      key: idempotencyKey
+    };
+  }
 
   return {
     apiVersion: PACKAGE_API_VERSION,
@@ -1338,7 +1639,8 @@ function generatePackageContract(match) {
       group: 'kse.scene',
       name: packageName,
       version: '0.1.0',
-      summary
+      summary,
+      description: `${summary}. Includes ontology graph hints, lineage tracing, and AI execution metadata.`
     },
     compatibility: {
       kse_version: '>=1.39.0',
@@ -1367,8 +1669,24 @@ function generatePackageContract(match) {
     governance: {
       risk_level: riskLevel,
       approval_required: approvalRequired,
+      approval: {
+        required: approvalRequired
+      },
+      idempotency: {
+        required: idempotencyRequired,
+        key: idempotencyKey
+      },
       rollback_supported: true
-    }
+    },
+    capability_contract: {
+      bindings
+    },
+    governance_contract: governanceContract,
+    ontology_model: {
+      entities: entityRefs,
+      relations
+    },
+    agent_hints: buildAgentHints(pattern, primaryResource, bindings)
   };
 }
 

package/lib/scene-runtime/runtime-executor.js

@@ -15,7 +15,11 @@ class RuntimeExecutor {
     this.policyGate = options.policyGate || new PolicyGate();
     this.auditEmitter = options.auditEmitter || new AuditEmitter(options.projectRoot || process.cwd(), options.audit || {});
     this.evalBridge = options.evalBridge || new EvalBridge();
-    this.bindingRegistry = options.bindingRegistry || new BindingRegistry();
+    this.bindingRegistry = options.bindingRegistry || new BindingRegistry({
+      projectRoot: options.projectRoot || process.cwd(),
+      moquiConfigPath: options.moquiConfigPath,
+      useMoquiAdapter: options.useMoquiAdapter
+    });
     this.bindingExecutor = typeof options.bindingExecutor === 'function' ? options.bindingExecutor : null;
     this.adapterReadinessChecker = options.adapterReadinessChecker || this.defaultAdapterReadinessChecker.bind(this);
     this.bindingPluginLoad = {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kiro-spec-engine",
-  "version": "1.47.12",
+  "version": "1.47.15",
   "description": "kiro-spec-engine (kse) - A CLI tool and npm package for spec-driven development with AI coding assistants. NOT the Kiro IDE desktop application.",
   "main": "index.js",
   "bin": {