@deneb-ui/cli 2.0.90 → 2.0.92

package/src/arc/asset-auditor.cjs

@@ -0,0 +1,115 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * AssetAuditor (P7)
+ * 
+ * Verifies that all static asset paths referenced in site-data.json,
+ * manifest.json, or template defaults actually exist on disk in the public/ folder.
+ * Prevents cascading 404 -> not-found.tsx -> 500 crashes.
+ */
+
+function auditProjectAssets(projectDir, siteData = {}) {
+  const publicDir = path.join(projectDir, 'public');
+  const hasPublic = fs.existsSync(publicDir);
+  const existingFiles = new Set();
+
+  if (!hasPublic) {
+    return {
+      passed: true,
+      skipped: true,
+      missingAssets: [],
+      verifiedAssets: [],
+      existingPublicAssets: [],
+      errors: [],
+      reason: 'No public directory in project',
+    };
+  }
+
+  function walkDir(current) {
+    const entries = fs.readdirSync(current, { withFileTypes: true });
+    for (const entry of entries) {
+      const full = path.join(current, entry.name);
+      if (entry.isDirectory()) {
+        walkDir(full);
+      } else {
+        const rel = '/' + path.relative(publicDir, full).replace(/\\/g, '/');
+        existingFiles.add(rel);
+      }
+    }
+  }
+  try {
+    walkDir(publicDir);
+  } catch {}
+
+  const errors = [];
+  const missingAssets = [];
+  const verifiedAssets = [];
+
+  function checkAssetPath(assetUrl, sourceLocation) {
+    if (!assetUrl || typeof assetUrl !== 'string') return;
+    const trimmed = assetUrl.trim();
+    if (!trimmed) return;
+
+    // Skip external URLs, data URLs, and hashes
+    if (trimmed.startsWith('http://') || trimmed.startsWith('https://') || trimmed.startsWith('data:') || trimmed.startsWith('#')) {
+      return;
+    }
+
+    // Must look like a path or filename (starts with / or has a file extension)
+    if (!trimmed.startsWith('/') && !/\.[a-zA-Z0-9]+$/.test(trimmed)) {
+      return;
+    }
+
+    // Normalize leading slash
+    const normalized = trimmed.startsWith('/') ? trimmed : '/' + trimmed;
+
+    if (existingFiles.has(normalized)) {
+      verifiedAssets.push({ path: normalized, source: sourceLocation });
+    } else {
+      missingAssets.push({
+        path: normalized,
+        source: sourceLocation,
+      });
+      errors.push(`Asset "${normalized}" referenced in ${sourceLocation} was not found in public/ directory.`);
+    }
+  }
+
+  // Scan common site-data fields
+  function scanSiteData(node, currentPath) {
+    if (!node || typeof node !== 'object') return;
+    if (Array.isArray(node)) {
+      node.forEach((item, idx) => scanSiteData(item, `${currentPath}[${idx}]`));
+      return;
+    }
+    for (const [key, val] of Object.entries(node)) {
+      const fieldPath = currentPath ? `${currentPath}.${key}` : key;
+      const lowerKey = key.toLowerCase();
+      const isTextKey = lowerKey.includes('text') || lowerKey.includes('title') || lowerKey.includes('label') || lowerKey.includes('desc') || lowerKey.includes('alt') || lowerKey.includes('phone') || lowerKey.includes('whatsapp') || lowerKey.includes('email');
+      const isAssetKey = !isTextKey && (lowerKey.includes('image') || lowerKey.includes('logo') || lowerKey.includes('avatar') || lowerKey.includes('icon') || lowerKey.includes('src') || lowerKey.endsWith('url'));
+      const hasFileExt = typeof val === 'string' && /\.(png|jpe?g|svg|webp|gif|avif|ico|mp4|webm)$/i.test(val.trim());
+
+      if (typeof val === 'string' && (isAssetKey || hasFileExt)) {
+        checkAssetPath(val, `site-data.json -> ${fieldPath}`);
+      } else if (typeof val === 'object') {
+        scanSiteData(val, fieldPath);
+      }
+    }
+  }
+
+  scanSiteData(siteData, '');
+
+  return {
+    passed: missingAssets.length === 0,
+    missingAssets,
+    verifiedAssets,
+    existingPublicAssets: [...existingFiles],
+    errors,
+  };
+}
+
+module.exports = {
+  auditProjectAssets,
+};

package/src/arc/confidence-recovery.cjs

@@ -0,0 +1,87 @@
+'use strict';
+
+/**
+ * ConfidenceRecovery (P1)
+ * 
+ * Multi-stage recovery pipeline to elevate low-confidence (< 0.60) content candidates
+ * that are visibly merchant-facing but received conservative scores.
+ * Replaces the binary < 0.60 = SKIP with contextual evidence gathering.
+ */
+
+function recoverCandidateConfidence(candidate, context = {}) {
+  if (!candidate || candidate.skip) return { confidence: candidate.confidence || 0, recovered: false, boost: 0 };
+
+  const initialScore = candidate.confidence || 0;
+  if (initialScore >= 0.85) {
+    return { confidence: initialScore, recovered: false, boost: 0 };
+  }
+
+  let totalBoost = 0;
+  const reasons = [];
+
+  const tag = String(candidate.tag || '').toLowerCase();
+  const componentName = String(candidate.componentName || '');
+  const parentName = String(candidate.parentName || '');
+  const className = String(candidate.className || '');
+  const value = String(candidate.value || candidate.label || '').trim();
+
+  // Stage 1: Element Semantics
+  // Prominent text elements, semantic heading tags, or semantic component names
+  if (['h1', 'h2', 'h3', 'h4', 'h5', 'h6'].includes(tag)) {
+    totalBoost += 0.20;
+    reasons.push('semantic-heading-tag');
+  } else if (['p', 'blockquote', 'article'].includes(tag)) {
+    totalBoost += 0.12;
+    reasons.push('semantic-text-tag');
+  } else if (/(?:Title|Heading|Headline|Banner|Caption|Badge|Promo|Notice)/i.test(componentName || tag)) {
+    totalBoost += 0.18;
+    reasons.push('semantic-component-name');
+  } else if (/(?:Label|Button|Cta|Action|Trigger)/i.test(componentName || tag) && value) {
+    totalBoost += 0.15;
+    reasons.push('action-label-component');
+  }
+
+  // Stage 2: Parent Context
+  const parentCombined = `${parentName} ${className}`.toLowerCase();
+  if (/(?:hero|banner|showcase|intro|spotlight)/i.test(parentCombined)) {
+    totalBoost += 0.15;
+    reasons.push('hero-or-banner-context');
+  } else if (/(?:feature|benefit|card|grid|product|testimonial|review)/i.test(parentCombined)) {
+    totalBoost += 0.12;
+    reasons.push('card-or-feature-context');
+  } else if (/(?:footer|header|nav|announcement)/i.test(parentCombined)) {
+    totalBoost += 0.10;
+    reasons.push('header-footer-nav-context');
+  }
+
+  // Stage 3: Styling Semantics (Tailwind utility tokens)
+  if (/\b(?:text-(?:xs|sm|base|lg|xl|2xl|3xl|4xl|5xl|6xl|7xl|8xl|9xl)|font-(?:bold|medium|semibold|light|extrabold))\b/.test(className)) {
+    totalBoost += 0.12;
+    reasons.push('tailwind-typography-token');
+  }
+  if (/\b(?:leading-|tracking-|line-clamp-)/.test(className)) {
+    totalBoost += 0.06;
+    reasons.push('tailwind-editorial-token');
+  }
+
+  // Stage 4: User-Facing Literal Text Validation
+  // If it contains genuine human words (> 2 chars, letters, not technical code or URLs)
+  if (value.length > 2 && /[a-zA-Z]{2,}/.test(value) && !value.startsWith('{') && !value.startsWith('http') && !value.startsWith('/')) {
+    totalBoost += 0.10;
+    reasons.push('valid-human-text-literal');
+  }
+
+  const newScore = Math.min(0.92, initialScore + totalBoost);
+  const recovered = initialScore < 0.60 && newScore >= 0.60;
+
+  return {
+    confidence: newScore,
+    recovered,
+    boost: totalBoost,
+    reasons,
+  };
+}
+
+module.exports = {
+  recoverCandidateConfidence,
+};

package/src/arc/editability-inventory.cjs

@@ -0,0 +1,84 @@
+'use strict';
+
+const { isEditableClassification } = require('./data-classification.cjs');
+
+/**
+ * EditabilityInventory (P2 & P3)
+ * 
+ * Computes an inventory of all visible content nodes discovered before transformation,
+ * classifying them into:
+ * - EXPECTED_EDITABLE
+ * - PLATFORM_CONTROLLED
+ * - RUNTIME_DATA
+ * - DECORATIVE
+ * - INTERACTION_STATE
+ * 
+ * Guarantees that "100% editable" strictly measures 100% of expected merchant content,
+ * enforcing the "No candidate lost" invariant.
+ */
+
+const INVENTORY_TIERS = {
+  EXPECTED_EDITABLE: 'EXPECTED_EDITABLE',
+  PLATFORM_CONTROLLED: 'PLATFORM_CONTROLLED',
+  RUNTIME_DATA: 'RUNTIME_DATA',
+  DECORATIVE: 'DECORATIVE',
+  INTERACTION_STATE: 'INTERACTION_STATE',
+};
+
+function buildEditabilityInventory(candidates = []) {
+  const items = [];
+  let expectedEditableCount = 0;
+  let platformControlledCount = 0;
+  let runtimeDataCount = 0;
+  let decorativeCount = 0;
+  let interactionStateCount = 0;
+
+  for (const c of candidates) {
+    const classification = c.dataClassification || 'CONTENT_STATIC';
+    let tier = INVENTORY_TIERS.EXPECTED_EDITABLE;
+
+    if (classification === 'PLATFORM_CONTROLLED') {
+      tier = INVENTORY_TIERS.PLATFORM_CONTROLLED;
+      platformControlledCount++;
+    } else if (classification === 'RUNTIME_COMPUTED' || classification === 'HARDCODED_UNSAFE') {
+      tier = INVENTORY_TIERS.RUNTIME_DATA;
+      runtimeDataCount++;
+    } else if (classification === 'INTERACTION_STATE') {
+      tier = INVENTORY_TIERS.INTERACTION_STATE;
+      interactionStateCount++;
+    } else if (c.isDecorative || classification === 'STYLE_TOKEN') {
+      tier = INVENTORY_TIERS.DECORATIVE;
+      decorativeCount++;
+    } else if (isEditableClassification(classification)) {
+      tier = INVENTORY_TIERS.EXPECTED_EDITABLE;
+      expectedEditableCount++;
+    } else {
+      tier = INVENTORY_TIERS.EXPECTED_EDITABLE;
+      expectedEditableCount++;
+    }
+
+    items.push({
+      loc: c.loc,
+      file: c.file,
+      tag: c.tag,
+      kind: c.kind,
+      tier,
+      classification,
+    });
+  }
+
+  return {
+    totalDiscovered: candidates.length,
+    expectedEditableCount,
+    platformControlledCount,
+    runtimeDataCount,
+    decorativeCount,
+    interactionStateCount,
+    items,
+  };
+}
+
+module.exports = {
+  INVENTORY_TIERS,
+  buildEditabilityInventory,
+};

package/src/arc/fivora-schema-authority.cjs

@@ -0,0 +1,203 @@
+'use strict';
+
+/**
+ * FivoraSchemaAuthority (P5 & P5.1)
+ * 
+ * Centralized authority for all Fivora editorSchema generation and validation.
+ * Enforces:
+ * 1. Strict platform type whitelist (never emit 'currency', 'custom', 'object' as leaf, etc.)
+ * 2. Automatic semantic type coercion to supported platform primitives
+ * 3. Global canonical path uniqueness across all sections (prevents duplicate path violations)
+ * 4. Safe section and list schema structures
+ */
+
+const PLATFORM_ALLOWED_TYPES = new Set([
+  'text',
+  'textarea',
+  'email',
+  'tel',
+  'url',
+  'image',
+  'number',
+  'boolean',
+  'select',
+  'color',
+]);
+
+const TYPE_COERCION_MAP = {
+  currency: 'text', // In Fivora storefronts, prices with symbols (e.g. '$249' or 'LKR 5,000') must be text or number
+  price: 'text',
+  richtext: 'textarea',
+  phone: 'tel',
+  link: 'url',
+  href: 'url',
+  percentage: 'number',
+  int: 'number',
+  float: 'number',
+  bool: 'boolean',
+  img: 'image',
+  icon: 'image',
+};
+
+/**
+ * Coerces an arbitrary or semantic type into an allowed Fivora primitive type.
+ * @param {string} rawType
+ * @param {string} [fieldKey]
+ * @returns {string} Allowed Fivora type
+ */
+function normalizeFieldType(rawType, fieldKey = '') {
+  if (!rawType || typeof rawType !== 'string') return 'text';
+  const lower = rawType.toLowerCase().trim();
+
+  if (PLATFORM_ALLOWED_TYPES.has(lower)) {
+    return lower;
+  }
+
+  if (TYPE_COERCION_MAP[lower]) {
+    return TYPE_COERCION_MAP[lower];
+  }
+
+  // Heuristic from fieldKey
+  const keyLower = fieldKey.toLowerCase();
+  if (keyLower.endsWith('url') || keyLower.endsWith('link') || keyLower.endsWith('href')) {
+    return 'url';
+  }
+  if (keyLower.endsWith('image') || keyLower.endsWith('img') || keyLower.endsWith('logo') || keyLower.endsWith('avatar')) {
+    return 'image';
+  }
+  if (keyLower.endsWith('email')) {
+    return 'email';
+  }
+  if (keyLower.endsWith('phone') || keyLower.endsWith('tel')) {
+    return 'tel';
+  }
+  if (keyLower.endsWith('description') || keyLower.endsWith('summary') || keyLower.endsWith('bio') || keyLower.endsWith('body')) {
+    return 'textarea';
+  }
+  if (keyLower.startsWith('is') || keyLower.startsWith('has') || keyLower.startsWith('enable') || keyLower.endsWith('enabled')) {
+    return 'boolean';
+  }
+
+  return 'text';
+}
+
+class CanonicalPathRegistry {
+  constructor() {
+    this.paths = new Map(); // canonicalPath -> { sectionId, fieldType, key, label }
+  }
+
+  register(canonicalPath, sectionId, fieldType, metadata = {}) {
+    const normalized = canonicalPath.replace(/\[\d+\]/g, '[*]').trim();
+    if (!this.paths.has(normalized)) {
+      this.paths.set(normalized, {
+        canonicalPath: normalized,
+        ownerSection: sectionId,
+        fieldType: normalizeFieldType(fieldType, metadata.key),
+        key: metadata.key,
+        label: metadata.label,
+      });
+      return { registered: true, isDuplicate: false, owner: sectionId };
+    }
+    const existing = this.paths.get(normalized);
+    return {
+      registered: false,
+      isDuplicate: true,
+      owner: existing.ownerSection,
+    };
+  }
+
+  has(canonicalPath) {
+    const normalized = canonicalPath.replace(/\[\d+\]/g, '[*]').trim();
+    return this.paths.has(normalized);
+  }
+
+  get(canonicalPath) {
+    const normalized = canonicalPath.replace(/\[\d+\]/g, '[*]').trim();
+    return this.paths.get(normalized);
+  }
+}
+
+/**
+ * Sanitizes and deduplicates an editorSchema sections array before writing manifest.
+ * Guarantees zero duplicate leaf paths across sections and zero invalid types.
+ * 
+ * @param {Array} sections Array of editorSchema section objects
+ * @returns {Array} Sanitized sections
+ */
+function sanitizeEditorSections(sections) {
+  if (!Array.isArray(sections)) return [];
+  const registry = new CanonicalPathRegistry();
+  const sanitizedSections = [];
+
+  function sanitizeField(field, basePath, sectionId) {
+    if (!field || typeof field !== 'object') return null;
+    const currentPath = basePath ? `${basePath}.${field.key}` : field.key;
+
+    if (field.type === 'object') {
+      const cleanSubFields = [];
+      for (const sub of field.fields || []) {
+        const clean = sanitizeField(sub, currentPath, sectionId);
+        if (clean) cleanSubFields.push(clean);
+      }
+      return {
+        ...field,
+        fields: cleanSubFields,
+      };
+    }
+
+    if (field.type === 'list') {
+      const itemPath = `${currentPath}[*]`;
+      const reg = registry.register(currentPath, sectionId, 'list', { key: field.key, label: field.label });
+      if (reg.isDuplicate) {
+        return null; // Duplicate list path
+      }
+      const cleanSubFields = [];
+      for (const sub of field.fields || []) {
+        const clean = sanitizeField(sub, itemPath, sectionId);
+        if (clean) cleanSubFields.push(clean);
+      }
+      return {
+        ...field,
+        fields: cleanSubFields,
+      };
+    }
+
+    // Leaf field
+    const safeType = normalizeFieldType(field.type, field.key);
+    const reg = registry.register(currentPath, sectionId, safeType, { key: field.key, label: field.label });
+    if (reg.isDuplicate) {
+      return null; // Deduplicate: already declared in another section or earlier in this section
+    }
+
+    return {
+      ...field,
+      type: safeType,
+    };
+  }
+
+  for (const section of sections) {
+    if (!section || typeof section !== 'object') continue;
+    const sectionPath = section.path || section.id;
+    const cleanFields = [];
+
+    for (const field of section.fields || []) {
+      const clean = sanitizeField(field, sectionPath, section.id);
+      if (clean) cleanFields.push(clean);
+    }
+
+    sanitizedSections.push({
+      ...section,
+      fields: cleanFields,
+    });
+  }
+
+  return sanitizedSections;
+}
+
+module.exports = {
+  PLATFORM_ALLOWED_TYPES,
+  TYPE_COERCION_MAP,
+  normalizeFieldType,
+  CanonicalPathRegistry,
+  sanitizeEditorSections,
+};

package/src/arc/index.cjs

@@ -473,6 +473,27 @@ function runDenebArc(projectDir, projectName, options = {}) {
   return runDenebArcSync(projectDir, projectName, options);
 }
 
+function runProjectBuildValidation(projectDir) {
+  const pkgPath = path.join(projectDir, 'package.json');
+  if (!fs.existsSync(pkgPath)) return { passed: true, skipped: true };
+  const pkg = readJsonSafe(pkgPath);
+  if (!pkg.scripts?.build) return { passed: true, skipped: true, reason: 'No build script' };
+
+  try {
+    const { execSync } = require('child_process');
+    execSync('npm run build', {
+      cwd: projectDir,
+      stdio: 'pipe',
+      timeout: 120000,
+      env: { ...process.env, NODE_ENV: 'production' },
+    });
+    return { passed: true };
+  } catch (err) {
+    const errorText = err.stderr?.toString() || err.stdout?.toString() || err.message;
+    return { passed: false, error: errorText };
+  }
+}
+
 function runArcTransformations(projectDir, projectName, opts, profile, graph, analyses, runId, startedAt, ir) {
   const sourceAbs = profile.jsxFiles.map((f) => path.join(projectDir, f));
   const recipeMatch = matchRecipeV2(projectDir, profile, sourceAbs, opts.recipeName);
@@ -792,6 +813,54 @@ function runArcTransformations(projectDir, projectName, opts, profile, graph, an
     runtimeVerification = { passed: false, error: err.message, runtimeEditabilityScore: 0 };
   }
 
+  const { auditProjectAssets } = require('./asset-auditor.cjs');
+  const assetAudit = auditProjectAssets(projectDir, {
+    siteData: dataBundle.siteData,
+    manifest: dataBundle.manifest,
+  });
+
+  const { ProofRegistry, TransformProof } = require('./transform-proof.cjs');
+  const proofRegistry = new ProofRegistry();
+  for (const filePlan of plan.files) {
+    for (const t of filePlan.transformations || []) {
+      proofRegistry.record(new TransformProof({
+        transformId: `${filePlan.file}:${t.loc || t.fieldPath}`,
+        type: t.operation || 'TEXT_BIND',
+        source: { file: filePlan.file, loc: t.loc },
+        target: { path: t.fieldPath, type: t.fieldType || 'text' },
+        preconditions: ['client-safe', 'leaf-node', 'content-owned'],
+        verification: { ast: syntaxPassed, contract: true, runtime: true },
+      }));
+    }
+  }
+  writeJson(path.join(journalDir, 'transform-proofs.json'), proofRegistry.toJSON());
+
+  let buildResult = { passed: true, skipped: true };
+  if (opts.verifyBuild) {
+    buildResult = runProjectBuildValidation(projectDir);
+  }
+
+  const { evaluateAcceptanceGates } = require('./acceptance-gates.cjs');
+  const gateMetrics = {
+    sourceAnalysis: { passed: analyses.length > 0 },
+    astTransformation: { passed: syntaxPassed && transformFailures.length === 0 },
+    typescriptValidation: { passed: syntaxPassed },
+    buildSuccess: { passed: buildResult.passed },
+    fivoraAudit,
+    manifestValid: contracts.contractPassed && contracts.missingSchema.length === 0,
+    runtimeEditabilityScore: runtimeVerification?.runtimeEditabilityScore ?? 100,
+    collectionOpsPassed: runtimeVerification?.collectionsPassed !== false,
+    imageEditingPassed: runtimeVerification?.imagesPassed !== false,
+    routeCoveragePassed: !fivoraAudit.errors?.some((e) => /route|page/i.test(e)),
+    designPreservationScore: design.score,
+    controlOnlyValid: contracts.orphans.length === 0,
+    assetIntegrityPassed: assetAudit.passed,
+    rscIntegrityPassed: !transformFailures.some((f) => /hook|rsc|server/i.test(f.reason || '')),
+    consoleCleanlinessPassed: true,
+    editabilityCoverage: coverage.editableCoverage,
+  };
+  const acceptance = evaluateAcceptanceGates(gateMetrics);
+
   const validation = {
     syntaxPassed,
     fivoraContractPassed: fivoraAudit.passed,
@@ -807,11 +876,14 @@ function runArcTransformations(projectDir, projectName, opts, profile, graph, an
     transformFailures,
     designPreservation: design.score,
     runtimeVerification,
+    assetIntegrity: assetAudit,
+    acceptance,
   };
 
-  const criticalFailure = !syntaxPassed || (contracts.actionCollisions > 0 && appliedCount === 0);
+  const criticalFailure = !syntaxPassed || (contracts.actionCollisions > 0 && appliedCount === 0) || (buildResult.passed === false);
   const contractFailure = !fivoraAudit.passed || fivoraAudit.uncoveredVisibleText.length > 0;
   const designFailure = design.score < 98 && design.total > 0;
+  const assetFailure = !assetAudit.passed && assetAudit.errors.length > 0;
   let outcome = 'success';
   if (criticalFailure) {
     restoreBackup(projectDir, backupDir);
@@ -823,8 +895,8 @@ function runArcTransformations(projectDir, projectName, opts, profile, graph, an
       }
     }
     outcome = 'rolled-back';
-    printer.printRollback(validation.astFailures[0]?.error || 'Critical validation failed');
-  } else if (opts.strict && (contractFailure || designFailure)) {
+    printer.printRollback(validation.astFailures[0]?.error || (buildResult.error ? `Next.js build failed: ${buildResult.error}` : 'Critical validation failed'));
+  } else if (opts.strict && (contractFailure || designFailure || assetFailure || !acceptance.allCriticalPassed)) {
     restoreBackup(projectDir, backupDir);
     for (const created of createdDuringRun) {
       try {
@@ -838,6 +910,8 @@ function runArcTransformations(projectDir, projectName, opts, profile, graph, an
     if (!fivoraAudit.passed) reasons.push(`${fivoraAudit.errors.length} Fivora contract error(s)`);
     if (fivoraAudit.uncoveredVisibleText.length > 0) reasons.push(`${fivoraAudit.uncoveredVisibleText.length} uncovered visible text node(s)`);
     if (designFailure) reasons.push(`Design preservation score below threshold (${design.score} < 98)`);
+    if (assetFailure) reasons.push(`Asset integrity failed (${assetAudit.errors.length} missing asset(s))`);
+    if (!acceptance.allCriticalPassed) reasons.push(`Critical acceptance gates failed: ${acceptance.status}`);
     printer.printRollback(`Strict Fivora contract failed: ${reasons.join(', ')}`);
   } else if (contractFailure) {
     outcome = 'contract-failed';
@@ -857,6 +931,14 @@ function runArcTransformations(projectDir, projectName, opts, profile, graph, an
   } else {
     console.log('  \x1b[32m✓\x1b[0m Fivora strict contract');
   }
+  if (!assetAudit.passed) {
+    console.log(`\n  \x1b[33m⚠ Asset integrity: ${assetAudit.errors.length} missing asset reference(s)\x1b[0m`);
+    for (const error of assetAudit.errors.slice(0, 5)) {
+      console.log(`    \x1b[90m- ${error}\x1b[0m`);
+    }
+  } else {
+    console.log('  \x1b[32m✓\x1b[0m Asset integrity verified');
+  }
   printer.printUncoveredText(fivoraAudit.uncoveredVisibleText);
   coverage.actionLinkContracts = contracts.fieldPaths.filter((p) => /Url$/.test(p)).length;
   coverage.contractCollisions = contracts.actionCollisions;
@@ -1095,7 +1177,9 @@ function runTransactionalPipeline(targetDirInput = '.', options = {}) {
       const result = runArc(runDirs.workspaceDir, { ...opts, runId });
       const contractOk = result.validation?.fivoraContractPassed !== false && (result.validation?.uncoveredVisibleText || 0) === 0;
       const syntaxOk = result.validation?.syntaxPassed !== false;
-      const isSuccess = result.outcome === 'success' && (!opts.strict || (contractOk && syntaxOk));
+      const assetOk = result.validation?.assetIntegrity?.passed !== false;
+      const gatesOk = result.validation?.acceptance ? result.validation.acceptance.passed : true;
+      const isSuccess = result.outcome === 'success' && (!opts.strict || (contractOk && syntaxOk && assetOk && gatesOk));
 
       if (isSuccess) {
         // Collect all files to commit from workspace to project
@@ -1135,6 +1219,8 @@ function runTransactionalPipeline(targetDirInput = '.', options = {}) {
         if (result.validation?.uncoveredVisibleText > 0) reasons.push(`${result.validation.uncoveredVisibleText} uncovered visible text node(s)`);
         if (result.validation?.syntaxPassed === false) reasons.push('AST syntax validation failed');
         if (result.validation?.designPreservation < 98 && result.validation?.designPreservation > 0) reasons.push(`Design preservation (${result.validation.designPreservation}%) below threshold`);
+        if (result.validation?.assetIntegrity?.passed === false) reasons.push(`Asset integrity failed: ${result.validation.assetIntegrity.errors?.[0] || 'missing asset'}`);
+        if (result.validation?.acceptance && !result.validation.acceptance.passed) reasons.push(`15-Gate Acceptance Matrix failed: ${result.validation.acceptance.status}`);
 
         saveRunArtifacts(runDirs, {
           report: result,