@deneb-ui/cli 2.0.49 → 2.0.51

package/src/arc/ai-evaluator.cjs

@@ -0,0 +1,450 @@
+'use strict';
+
+/**
+ * Deneb ARC — AI Evaluator & Self-Healing Engine
+ *
+ * Automatically audits the transformed project before finalizing `deneb init --ai`
+ * to guarantee that:
+ * 1. React Server Components (RSC) vs Client Component boundaries are strictly respected
+ *    (preventing "Element type is invalid: expected string/function but got: undefined").
+ * 2. Every imported component in page.tsx/layout.tsx is properly exported.
+ * 3. Fivora strict leaf contracts are satisfied (no field-path on broad containers).
+ * 4. Manifest routes correspond 1:1 with real page files on disk.
+ * 5. Uses ChatGPT (OpenAI API) to evaluate, explain, and self-heal any edge cases.
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { parseSource, printSource, getJsxName, b } = require('./ast.cjs');
+const { BROAD_CONTENT_CONTAINERS } = require('./fivora-contract.cjs');
+const { callOpenAI, checkAiReady, loadEnv } = require('./ai-agent.cjs');
+const { recordEvaluatorFix } = require('./learning.cjs');
+
+/**
+ * Audit runtime integrity of the transformed project.
+ *
+ * @param {string} projectDir - Root path of the project being transformed
+ * @param {object} profile - Project profile from scanner.cjs
+ * @returns {Array<{ type: string, file: string, message: string, severity: 'error' | 'warning', meta?: any }>}
+ */
+function auditRuntimeIntegrity(projectDir, profile) {
+  const issues = [];
+
+  // 1. Check RSC Provider Boundaries in layout.tsx
+  const layoutFile = profile.appDir ? path.join(projectDir, 'src', 'app', 'layout.tsx') : null;
+  const altLayout = profile.appDir ? path.join(projectDir, 'app', 'layout.tsx') : null;
+  const targetLayout = (layoutFile && fs.existsSync(layoutFile)) ? layoutFile : ((altLayout && fs.existsSync(altLayout)) ? altLayout : null);
+
+  if (targetLayout) {
+    const layoutCode = fs.readFileSync(targetLayout, 'utf8');
+    const isServerComponent = !/['"]use client['"]/.test(layoutCode.slice(0, 300));
+
+    if (isServerComponent) {
+      // Check if client-only SiteDataProvider or createContext is directly rendered in Server Component
+      const hasSiteDataImport = /import\s+.*?\bSiteDataProvider\b.*?from\s+['"]@deneb-ui\/(?:ui|core)['"]/.test(layoutCode);
+      const rendersSiteDataProvider = /<SiteDataProvider\b/.test(layoutCode);
+      const hasProvidersWrapper = /<Providers\b/.test(layoutCode) || /from\s+['"]@\/components\/providers['"]/.test(layoutCode);
+
+      if (rendersSiteDataProvider && hasProvidersWrapper) {
+        issues.push({
+          type: 'rsc-duplicate-provider',
+          file: path.relative(projectDir, targetLayout).replace(/\\/g, '/'),
+          absPath: targetLayout,
+          message: 'Server layout renders <SiteDataProvider> inside <Providers>, causing undefined component in React Server Components.',
+          severity: 'error',
+          meta: { hasProvidersWrapper, hasSiteDataImport },
+        });
+      } else if (rendersSiteDataProvider && hasSiteDataImport) {
+        issues.push({
+          type: 'rsc-unwrapped-provider',
+          file: path.relative(projectDir, targetLayout).replace(/\\/g, '/'),
+          absPath: targetLayout,
+          message: 'Server layout renders client-only <SiteDataProvider> without a "use client" boundary.',
+          severity: 'error',
+          meta: { hasProvidersWrapper, hasSiteDataImport },
+        });
+      }
+    }
+
+    // Check Global CSS Import in layout.tsx
+    const hasCssImport = /import\s+['"][^'"]+\.css['"]/.test(layoutCode);
+    if (!hasCssImport) {
+      const cssCandidates = [
+        path.join(path.dirname(targetLayout), 'globals.css'),
+        path.join(path.dirname(targetLayout), 'global.css'),
+        path.join(projectDir, 'src', 'app', 'globals.css'),
+        path.join(projectDir, 'src', 'styles', 'globals.css'),
+        path.join(projectDir, 'styles', 'globals.css'),
+      ];
+      const foundCss = cssCandidates.find((c) => fs.existsSync(c));
+      if (foundCss) {
+        const relPath = path.relative(path.dirname(targetLayout), foundCss).replace(/\\/g, '/');
+        const relImport = relPath.startsWith('.') ? relPath : `./${relPath}`;
+        issues.push({
+          type: 'missing-global-css-import',
+          file: path.relative(projectDir, targetLayout).replace(/\\/g, '/'),
+          absPath: targetLayout,
+          message: `Root layout is missing global stylesheet import (${path.basename(foundCss)}), which would cause unstyled HTML.`,
+          severity: 'error',
+          meta: { cssRel: relImport },
+        });
+      }
+    }
+  }
+
+  // 2. Check Component Export / Import Integrity in page.tsx
+  const pageFiles = [
+    path.join(projectDir, 'src', 'app', 'page.tsx'),
+    path.join(projectDir, 'app', 'page.tsx'),
+    path.join(projectDir, 'src', 'pages', 'index.tsx'),
+    path.join(projectDir, 'pages', 'index.tsx'),
+  ];
+  const targetPage = pageFiles.find((p) => fs.existsSync(p));
+
+  if (targetPage) {
+    const pageCode = fs.readFileSync(targetPage, 'utf8');
+    const importRegex = /import\s+([\s\S]*?)\s+from\s+['"]([^'"]+)['"]/g;
+    let match;
+
+    while ((match = importRegex.exec(pageCode)) !== null) {
+      const clause = match[1].trim();
+      const specifier = match[2].trim();
+
+      if (!specifier.startsWith('@/') && !specifier.startsWith('.')) continue;
+
+      let resolvedFile = null;
+      if (specifier.startsWith('@/')) {
+        const candidate = path.join(projectDir, 'src', specifier.slice(2));
+        for (const ext of ['', '.tsx', '.ts', '.jsx', '.js', '/index.tsx', '/index.ts']) {
+          if (fs.existsSync(candidate + ext) && !fs.statSync(candidate + ext).isDirectory()) {
+            resolvedFile = candidate + ext;
+            break;
+          }
+        }
+      } else {
+        const candidate = path.resolve(path.dirname(targetPage), specifier);
+        for (const ext of ['', '.tsx', '.ts', '.jsx', '.js', '/index.tsx', '/index.ts']) {
+          if (fs.existsSync(candidate + ext) && !fs.statSync(candidate + ext).isDirectory()) {
+            resolvedFile = candidate + ext;
+            break;
+          }
+        }
+      }
+
+      if (!resolvedFile || resolvedFile.endsWith('.json') || resolvedFile.endsWith('.css')) continue;
+
+      const targetSrc = fs.readFileSync(resolvedFile, 'utf8');
+
+      // Check named imports
+      const namedMatch = clause.match(/\{([^}]+)\}/);
+      if (namedMatch) {
+        const names = namedMatch[1].split(',').map((s) => s.trim().split(/\s+as\s+/)[0]);
+        for (const name of names) {
+          if (!name || name === 'type') continue;
+          const re = new RegExp(`\\bexport\\s+(?:const|function|class|interface|type)\\s+${name}\\b|\\bexport\\s*\\{[^}]*\\b${name}\\b`);
+          if (!re.test(targetSrc)) {
+            issues.push({
+              type: 'missing-named-export',
+              file: path.relative(projectDir, resolvedFile).replace(/\\/g, '/'),
+              absPath: resolvedFile,
+              message: `Component "${name}" imported in ${path.basename(targetPage)} is not exported from ${path.basename(resolvedFile)}.`,
+              severity: 'error',
+              meta: { componentName: name, importerFile: targetPage },
+            });
+          }
+        }
+      }
+
+      // Check default imports
+      const defaultMatch = clause.match(/^([A-Za-z0-9_$]+)(?:\s*,|\s*$)/);
+      if (defaultMatch && !clause.includes('{')) {
+        const defName = defaultMatch[1];
+        if (defName !== 'type' && !/export\s+default\b/.test(targetSrc)) {
+          issues.push({
+            type: 'missing-default-export',
+            file: path.relative(projectDir, resolvedFile).replace(/\\/g, '/'),
+            absPath: resolvedFile,
+            message: `File ${path.basename(resolvedFile)} lacks a default export for "${defName}".`,
+            severity: 'error',
+            meta: { componentName: defName, importerFile: targetPage },
+          });
+        }
+      }
+    }
+  }
+
+  // 3. Check for broad container markers across all component files
+  for (const relFile of profile.jsxFiles || []) {
+    const absPath = path.join(projectDir, relFile);
+    if (!fs.existsSync(absPath)) continue;
+    const src = fs.readFileSync(absPath, 'utf8');
+
+    const broadRegex = /<(div|section|article|aside|header|footer|nav|main|form|ul|ol|table|thead|tbody|tr)\b([^>]*\bdata-preview-field-path\s*=[^>]*)/gi;
+    let bMatch;
+    while ((bMatch = broadRegex.exec(src)) !== null) {
+      issues.push({
+        type: 'broad-container-field-marker',
+        file: relFile.replace(/\\/g, '/'),
+        absPath,
+        message: `data-preview-field-path cannot be placed on broad <${bMatch[1]}> in ${relFile}.`,
+        severity: 'error',
+        meta: { tag: bMatch[1], snippet: bMatch[0].slice(0, 80) },
+      });
+    }
+  }
+
+  // 4. Check manifest routes vs disk
+  const manifestPath = path.join(projectDir, 'fivora-template.json');
+  if (fs.existsSync(manifestPath)) {
+    try {
+      const manifest = JSON.parse(fs.readFileSync(manifestPath, 'utf8'));
+      for (const p of manifest.pages || []) {
+        if (!p || !p.route) continue;
+        if (p.route === '/') continue;
+
+        const cleanRoute = p.route.replace(/^\/+/, '');
+        const exists =
+          fs.existsSync(path.join(projectDir, 'src', 'app', cleanRoute, 'page.tsx')) ||
+          fs.existsSync(path.join(projectDir, 'src', 'app', cleanRoute, 'page.jsx')) ||
+          fs.existsSync(path.join(projectDir, 'app', cleanRoute, 'page.tsx')) ||
+          fs.existsSync(path.join(projectDir, 'app', cleanRoute, 'page.jsx')) ||
+          fs.existsSync(path.join(projectDir, 'src', 'pages', `${cleanRoute}.tsx`)) ||
+          fs.existsSync(path.join(projectDir, 'src', 'pages', `${cleanRoute}.jsx`)) ||
+          fs.existsSync(path.join(projectDir, 'pages', `${cleanRoute}.tsx`)) ||
+          fs.existsSync(path.join(projectDir, 'pages', `${cleanRoute}.jsx`));
+
+        if (!exists) {
+          issues.push({
+            type: 'orphan-manifest-route',
+            file: 'fivora-template.json',
+            absPath: manifestPath,
+            message: `Manifest page "${p.id}" route "${p.route}" has no page file on disk.`,
+            severity: 'error',
+            meta: { pageId: p.id, route: p.route },
+          });
+        }
+      }
+    } catch {
+      // ignore JSON parse error
+    }
+  }
+
+  return issues;
+}
+
+/**
+ * Heals detected runtime integrity issues automatically.
+ * Applies deterministic AST fixes for known patterns, and uses ChatGPT API for complex self-healing.
+ *
+ * @param {string} projectDir
+ * @param {object} profile
+ * @param {Array} issues
+ * @param {object} options
+ * @returns {Promise<{ healedCount: number, remainingCount: number, log: string[] }>}
+ */
+async function healRuntimeIntegrity(projectDir, profile, issues, options = {}) {
+  let healedCount = 0;
+  const log = [];
+
+  for (const issue of issues) {
+    // Healing Pattern 1: RSC Duplicate or Server-rendered SiteDataProvider in layout.tsx
+    if (issue.type === 'rsc-duplicate-provider' && issue.absPath && fs.existsSync(issue.absPath)) {
+      try {
+        let code = fs.readFileSync(issue.absPath, 'utf8');
+
+        // If <Providers> exists, unwrap the redundant <SiteDataProvider> from layout.tsx
+        code = code.replace(
+          /<SiteDataProvider\s+initialSiteData=\{[^}]+\}>([\s\S]*?)<\/SiteDataProvider>/g,
+          '$1'
+        );
+        // Remove unused SiteDataProvider and initialSiteData imports
+        code = code.replace(/import\s+.*?\bSiteDataProvider\b.*?from\s+['"]@deneb-ui\/(?:ui|core)['"];?\n?/g, '');
+        code = code.replace(/import\s+initialSiteData\s+from\s+['"][^'"]+['"];?\n?/g, '');
+
+        fs.writeFileSync(issue.absPath, code, 'utf8');
+        healedCount++;
+        recordEvaluatorFix({
+          projectDir,
+          issueType: issue.type,
+          file: issue.file,
+          action: 'remove-redundant-server-site-data-provider',
+          success: true,
+        });
+        log.push(`Healed RSC boundary: removed redundant <SiteDataProvider> from server component ${issue.file}`);
+      } catch (err) {
+        log.push(`Failed to heal ${issue.file}: ${err.message}`);
+      }
+      continue;
+    }
+
+    // Healing Pattern 1b: Missing global CSS stylesheet import in layout.tsx
+    if (issue.type === 'missing-global-css-import' && issue.absPath && fs.existsSync(issue.absPath)) {
+      try {
+        let code = fs.readFileSync(issue.absPath, 'utf8');
+        const cssImport = `import "${issue.meta?.cssRel || './globals.css'}";\n`;
+        const firstImportIdx = code.indexOf('import ');
+        if (firstImportIdx !== -1) {
+          const nextLineIdx = code.indexOf('\n', firstImportIdx);
+          code = code.slice(0, nextLineIdx + 1) + cssImport + code.slice(nextLineIdx + 1);
+        } else {
+          code = cssImport + code;
+        }
+        fs.writeFileSync(issue.absPath, code, 'utf8');
+        healedCount++;
+        recordEvaluatorFix({
+          projectDir,
+          issueType: issue.type,
+          file: issue.file,
+          action: 'restore-global-css-import',
+          success: true,
+        });
+        log.push(`Healed layout styles: restored ${issue.meta?.cssRel || './globals.css'} import in ${issue.file}`);
+      } catch (err) {
+        log.push(`Failed to heal global CSS import in ${issue.file}: ${err.message}`);
+      }
+      continue;
+    }
+
+    // Healing Pattern 2: Broad container field path
+    if (issue.type === 'broad-container-field-marker' && issue.absPath && fs.existsSync(issue.absPath)) {
+      try {
+        let code = fs.readFileSync(issue.absPath, 'utf8');
+        // Replace <div ... data-preview-field-path="..."> with <span className="block..." ...>
+        code = code.replace(
+          /<div\b([^>]*\bdata-preview-field-path\s*=[^>]*)>([\s\S]*?)<\/div>/gi,
+          (match, attrs, inner) => {
+            let nextAttrs = attrs;
+            if (/className\s*=\s*['"]/.test(nextAttrs)) {
+              nextAttrs = nextAttrs.replace(/className\s*=\s*(['"])/, 'className=$1block ');
+            } else {
+              nextAttrs = ` className="block"${nextAttrs}`;
+            }
+            return `<span${nextAttrs}>${inner}</span>`;
+          }
+        );
+        fs.writeFileSync(issue.absPath, code, 'utf8');
+        healedCount++;
+        recordEvaluatorFix({
+          projectDir,
+          issueType: issue.type,
+          file: issue.file,
+          action: 'convert-broad-container-to-inline-span',
+          success: true,
+        });
+        log.push(`Healed broad container: converted <${issue.meta?.tag || 'div'}> to inline-block <span data-preview-field-path> in ${issue.file}`);
+      } catch (err) {
+        log.push(`Failed to heal broad container in ${issue.file}: ${err.message}`);
+      }
+      continue;
+    }
+
+    // Healing Pattern 3: Orphan manifest route
+    if (issue.type === 'orphan-manifest-route' && issue.absPath && fs.existsSync(issue.absPath)) {
+      try {
+        const manifest = JSON.parse(fs.readFileSync(issue.absPath, 'utf8'));
+        if (Array.isArray(manifest.pages)) {
+          manifest.pages = manifest.pages.filter((p) => p.id !== issue.meta?.pageId && p.route !== issue.meta?.route);
+          fs.writeFileSync(issue.absPath, JSON.stringify(manifest, null, 2), 'utf8');
+          healedCount++;
+          recordEvaluatorFix({
+            projectDir,
+            issueType: issue.type,
+            file: issue.file,
+            action: 'prune-orphan-manifest-route',
+            success: true,
+          });
+          log.push(`Healed manifest: pruned non-existent route "${issue.meta?.route}" (${issue.meta?.pageId})`);
+        }
+      } catch (err) {
+        log.push(`Failed to heal manifest route: ${err.message}`);
+      }
+      continue;
+    }
+
+    // Healing Pattern 4: AI-Assisted Self-Healing for missing exports or complex issues
+    if (issue.type.startsWith('missing-') && options.aiEnabled && issue.absPath && fs.existsSync(issue.absPath)) {
+      loadEnv(projectDir);
+      const aiReady = checkAiReady();
+      if (aiReady.ready) {
+        try {
+          const fileSrc = fs.readFileSync(issue.absPath, 'utf8');
+          const prompt = `You are a senior React/TypeScript engineer on the DENEB UI team.
+Fix this export error in the file:
+ERROR: ${issue.message}
+
+FILE SOURCE:
+\`\`\`tsx
+${fileSrc}
+\`\`\`
+
+INSTRUCTIONS:
+1. Ensure the component "${issue.meta?.componentName}" is properly exported with a named export \`export function ${issue.meta?.componentName}()\` or proper export syntax.
+2. Preserve all existing JSX, props, logic, and styling.
+3. Output ONLY the raw TypeScript (.tsx) code. No markdown fences, no explanations.`;
+
+          const aiResult = await callOpenAI(prompt);
+          if (aiResult && aiResult.content) {
+            fs.writeFileSync(issue.absPath, aiResult.content, 'utf8');
+            healedCount++;
+            recordEvaluatorFix({
+              projectDir,
+              issueType: issue.type,
+              file: issue.file,
+              action: 'ai-generate-missing-export',
+              success: true,
+            });
+            log.push(`AI healed export in ${issue.file}: added export for ${issue.meta?.componentName}`);
+          }
+        } catch (err) {
+          log.push(`AI heal failed for ${issue.file}: ${err.message}`);
+        }
+      }
+    }
+  }
+
+  // Re-audit after healing to calculate remaining issues
+  const remaining = auditRuntimeIntegrity(projectDir, profile);
+  return {
+    healedCount,
+    remainingCount: remaining.length,
+    remainingIssues: remaining,
+    log,
+  };
+}
+
+/**
+ * Complete evaluation pipeline called by `init --ai`.
+ *
+ * @param {string} projectDir - Project directory
+ * @param {object} profile - Project profile
+ * @param {object} [options] - Options (aiEnabled, etc.)
+ * @returns {Promise<{ passed: boolean, issuesFound: number, healed: number, log: string[] }>}
+ */
+async function runAiEvaluatorPipeline(projectDir, profile, options = {}) {
+  const initialIssues = auditRuntimeIntegrity(projectDir, profile);
+
+  if (initialIssues.length === 0) {
+    return {
+      passed: true,
+      issuesFound: 0,
+      healed: 0,
+      log: ['All runtime integrity checks passed cleanly.'],
+    };
+  }
+
+  const healResult = await healRuntimeIntegrity(projectDir, profile, initialIssues, options);
+
+  return {
+    passed: healResult.remainingCount === 0,
+    issuesFound: initialIssues.length,
+    healed: healResult.healedCount,
+    remainingIssues: healResult.remainingIssues,
+    log: healResult.log,
+  };
+}
+
+module.exports = {
+  auditRuntimeIntegrity,
+  healRuntimeIntegrity,
+  runAiEvaluatorPipeline,
+};

package/src/arc/ai-prompts.cjs

@@ -124,6 +124,7 @@ Your task is to create an editable wrapper component for an existing component.
 10. **Use \`'use strict'\` is NOT needed** — this is a .tsx file.
 11. **Do NOT import React hooks** like useState, useEffect, useContext. The component must be stateless.
 12. **Do NOT import useSiteData** — the wrapper component does not need it directly.
+13. **NEVER place data-preview-field-path on <div>, <section>, <article>, or broad containers**. ` + '`data-preview-field-path`' + ` must ONLY be on leaf text/media/control elements (<span>, <p>, <h1>-<h6>, <a>, <button>, EditableText, EditableImage).
 
 ## REFERENCE PATTERN (follow this structure exactly):
 

package/src/arc/ast.cjs

@@ -20,9 +20,17 @@ const BABEL_PLUGIN_SETS = [
   ['jsx'],
 ];
 
-function parseWithBabel(code) {
+function parseWithBabel(code, filePath = 'file.tsx') {
+  const isTs =
+    /\.(tsx|ts|mts|cts)$/i.test(filePath) ||
+    /(?:interface\s+[A-Za-z0-9_$]+|type\s+[A-Za-z0-9_$]+\s*=|:\s*(?:string|number|boolean|any|void|unknown|React\.)|as\s+[A-Za-z0-9_$]+)/.test(code);
+
+  const pluginSets = isTs
+    ? BABEL_PLUGIN_SETS.filter((set) => set.includes('typescript'))
+    : BABEL_PLUGIN_SETS;
+
   let lastError = null;
-  for (const plugins of BABEL_PLUGIN_SETS) {
+  for (const plugins of pluginSets) {
     try {
       return babelParser.parse(code, {
         sourceType: 'unambiguous',
@@ -52,7 +60,7 @@ function parseSource(code, filePath = 'file.tsx') {
     ...options,
     parser: {
       parse(source) {
-        return parseWithBabel(source);
+        return parseWithBabel(source, filePath);
       },
     },
   });

package/src/arc/field-paths.cjs

@@ -47,6 +47,7 @@ function inferSection(context) {
     ['testimonials', /testimonial/],
     ['map', /map\b|location-map|google-map/],
     ['faq', /faq|accordion/],
+    ['form', /form|booking|inquiry|registration/],
     ['contact', /contact|whatsapp|mailto/],
     ['featuredProducts', /featured|product-grid|collection/],
     ['newsletter', /newsletter|subscribe/],
@@ -65,6 +66,7 @@ function inferSection(context) {
 
 function inferFieldName(kind, tag, text, extra = {}) {
   if (kind === 'url') {
+    if (extra.action === 'form-submit') return 'formWhatsappUrl';
     if (extra.platform) return `${extra.platform}Url`;
     if (extra.action === 'whatsapp') return 'whatsappUrl';
     if (extra.action === 'phone') return 'phoneUrl';
@@ -74,6 +76,7 @@ function inferFieldName(kind, tag, text, extra = {}) {
     return fromText || (extra.action ? `${extra.action}Url` : 'ctaUrl');
   }
   if (kind === 'label' && extra.paired) {
+    if (extra.action === 'form-submit') return 'formSubmitLabel';
     if (extra.action === 'whatsapp') return 'whatsappLabel';
     if (extra.action === 'phone') return 'phoneLabel';
     if (extra.action === 'email') return 'emailLabel';
@@ -100,6 +103,7 @@ function inferFieldName(kind, tag, text, extra = {}) {
     Description: 'description',
     Typography: 'text',
     Badge: 'badge',
+    label: 'label',
     button: 'label',
     Button: 'label',
     span: 'label',

package/src/arc/index.cjs

@@ -39,6 +39,7 @@ const printer = require('./printer.cjs');
 const { classifyComponents } = require('./component-registry.cjs');
 const { checkAiReady, adaptComponent, generateDocsPage, loadEnv } = require('./ai-agent.cjs');
 const { checkGithubReady, createComponentPR } = require('./pr-agent.cjs');
+const { runAiEvaluatorPipeline } = require('./ai-evaluator.cjs');
 
 function parseArcOptions(raw = {}) {
   return {
@@ -255,7 +256,7 @@ async function runDenebArcAsync(projectDir, projectName, options = {}) {
     0
   );
   const actionCount = analyses.reduce(
-    (n, a) => n + (a.candidates || []).filter((c) => c.operation === 'split-action-contract' || c.kind === 'url').length,
+    (n, a) => n + (a.candidates || []).filter((c) => c.operation === 'split-action-contract' || c.operation === 'form-submit-action' || c.kind === 'url').length,
     0
   );
   printer.printScan(profile, graph, candidateCount, actionCount);
@@ -341,7 +342,33 @@ async function runDenebArcAsync(projectDir, projectName, options = {}) {
     }
   }
 
-  return runArcTransformations(projectDir, projectName, opts, profile, graph, analyses, runId, startedAt);
+  const result = runArcTransformations(projectDir, projectName, opts, profile, graph, analyses, runId, startedAt);
+
+  if (!opts.dryRun && result && result.outcome === 'success') {
+    printer.printAiEvaluatorStart();
+    try {
+      const evalResult = await runAiEvaluatorPipeline(projectDir, profile, {
+        dryRun: opts.aiDryRun,
+        aiEnabled: opts.aiEnabled,
+      });
+      if (evalResult.healed > 0) {
+        for (const logItem of evalResult.log) {
+          printer.printAiEvaluatorHealed(logItem);
+        }
+      }
+      if (evalResult.remainingIssues && evalResult.remainingIssues.length > 0) {
+        for (const issue of evalResult.remainingIssues) {
+          printer.printAiEvaluatorIssue(`${issue.file}: ${issue.message}`);
+        }
+      } else {
+        printer.printAiEvaluatorPass('All runtime integrity checks passed (RSC boundaries, exports, Fivora contracts).');
+      }
+    } catch (err) {
+      printer.warn(`AI Evaluator audit encountered an issue: ${err.message}`);
+    }
+  }
+
+  return result;
 }
 
 function runDenebArcSync(projectDir, projectName, options = {}) {
@@ -370,7 +397,7 @@ function runDenebArcSync(projectDir, projectName, options = {}) {
     0
   );
   const actionCount = analyses.reduce(
-    (n, a) => n + (a.candidates || []).filter((c) => c.operation === 'split-action-contract' || c.kind === 'url').length,
+    (n, a) => n + (a.candidates || []).filter((c) => c.operation === 'split-action-contract' || c.operation === 'form-submit-action' || c.kind === 'url').length,
     0
   );
   printer.printScan(profile, graph, candidateCount, actionCount);

package/src/arc/learning.cjs

@@ -118,6 +118,7 @@ function mapOperation(operation) {
     case 'extract-url':
       return 'url-extraction';
     case 'split-action-contract':
+    case 'form-submit-action':
       return 'contract-split';
     case 'style-bind':
       return 'style-bind';
@@ -199,8 +200,38 @@ function redactSecrets(value) {
     .replace(/-----BEGIN [A-Z ]+PRIVATE KEY-----[\s\S]*?-----END [A-Z ]+PRIVATE KEY-----/g, '***REDACTED KEY***');
 }
 
+function recordEvaluatorFix({ projectDir, issueType, file, action, success = true }) {
+  const record = {
+    engineVersion: ARC_VERSION,
+    type: 'evaluator-fix',
+    timestamp: new Date().toISOString(),
+    issueType,
+    file,
+    action,
+    success: Boolean(success),
+  };
+  try {
+    if (projectDir) {
+      fs.mkdirSync(path.dirname(experiencePath(projectDir)), { recursive: true });
+      const local = loadJsonArray(experiencePath(projectDir));
+      writeJson(experiencePath(projectDir), [...local, record].slice(-400));
+    }
+  } catch {
+    // ignore
+  }
+  try {
+    fs.mkdirSync(path.dirname(localStorePath()), { recursive: true });
+    const global = loadJsonArray(localStorePath());
+    writeJson(localStorePath(), [...global, record].slice(-800));
+  } catch {
+    // ignore
+  }
+  return record;
+}
+
 module.exports = {
   recordExperience,
+  recordEvaluatorFix,
   loadFingerprintBoost,
   registryArchitecture,
   redactSecrets,