universal-dev-standards 3.5.1-beta.16 → 3.5.1-beta.17

package/src/commands/check.js

@@ -12,7 +12,8 @@ import {
 import {
   computeFileHash,
   compareFileHash,
-  hasFileHashes
+  hasFileHashes,
+  compareIntegrationBlockHash
 } from '../utils/hasher.js';
 import { downloadFromGitHub, getMarketplaceSkillsInfo } from '../utils/github.js';
 import {
@@ -21,7 +22,9 @@ import {
 } from '../utils/skills-installer.js';
 import {
   getAgentConfig,
-  getAgentDisplayName
+  getAgentDisplayName,
+  getSkillsDirForAgent,
+  getCommandsDirForAgent
 } from '../config/ai-agent-paths.js';
 import {
   parseReferences,
@@ -44,6 +47,12 @@ export async function checkCommand(options = {}) {
   const msg = t().commands.check;
   const common = t().commands.common;
 
+  // Handle --summary option (compact status for other commands)
+  if (options.summary) {
+    await displaySummary(projectPath, options);
+    return;
+  }
+
   console.log();
   console.log(chalk.bold(msg.title));
   console.log(chalk.gray('─'.repeat(50)));
@@ -198,6 +207,17 @@ export async function checkCommand(options = {}) {
     (fileStatus.noHash.length > 0 ? `, ${fileStatus.noHash.length} no hash` : '')));
   console.log();
 
+  // === Enhanced Integrity Checks (v3.3.0+) ===
+
+  // Check Skills integrity if skillHashes exist
+  checkSkillsIntegrity(manifest, projectPath, msg);
+
+  // Check Commands integrity if commandHashes exist
+  checkCommandsIntegrity(manifest, projectPath, msg);
+
+  // Check Integration blocks integrity if integrationBlockHashes exist
+  checkIntegrationBlocksIntegrity(manifest, projectPath, msg);
+
   // Handle --restore option
   if (options.restore) {
     await restoreFiles(projectPath, manifest, [...fileStatus.modified, ...fileStatus.missing]);
@@ -248,7 +268,7 @@ export async function checkCommand(options = {}) {
   const { missingSkills, missingCommands } = displaySkillsStatus(manifest, projectPath, msg);
 
   // Coverage report
-  displayCoverageReport(manifest, msg, common);
+  displayCoverageReport(manifest, msg, common, projectPath);
 
   // Final status
   const allGood = fileStatus.missing.length === 0 &&
@@ -790,7 +810,7 @@ function displaySkillsStatus(manifest, projectPath, msg) {
 /**
  * Display coverage report
  */
-function displayCoverageReport(manifest, msg, _common) {
+function displayCoverageReport(manifest, msg, _common, projectPath) {
   console.log(chalk.cyan(msg.coverageSummary));
   const expectedStandards = getStandardsByLevel(manifest.level);
   const skillStandards = expectedStandards.filter(s => s.skillName);
@@ -800,7 +820,19 @@ function displayCoverageReport(manifest, msg, _common) {
   console.log(chalk.gray(`    ${msg.withSkills.replace('{count}', skillStandards.length)}`));
   console.log(chalk.gray(`    ${msg.referenceDocs.replace('{count}', refStandards.length)}`));
 
-  const coveredBySkills = manifest.skills.installed ? skillStandards.length : 0;
+  // Dynamically check if any AI tool has skills installed
+  let hasInstalledSkills = false;
+  if (manifest.aiTools && manifest.aiTools.length > 0) {
+    for (const tool of manifest.aiTools) {
+      const projectSkillsInfo = getInstalledSkillsInfoForAgent(tool, 'project', projectPath);
+      const userSkillsInfo = getInstalledSkillsInfoForAgent(tool, 'user', projectPath);
+      if (projectSkillsInfo?.installed || userSkillsInfo?.installed) {
+        hasInstalledSkills = true;
+        break;
+      }
+    }
+  }
+  const coveredBySkills = hasInstalledSkills ? skillStandards.length : 0;
   const coveredByDocs = manifest.standards.length;
 
   console.log(chalk.gray(`  ${msg.yourCoverage}`));
@@ -824,22 +856,6 @@ function checkIntegrationFiles(manifest, projectPath, msg) {
   let hasIssues = false;
   let checkedCount = 0;
 
-  // Standard filename to task mapping for coverage check
-  const STANDARD_TASK_MAPPING = {
-    'anti-hallucination.md': 'AI collaboration',
-    'commit-message.ai.yaml': 'Writing commits',
-    'checkin-standards.md': 'Committing code',
-    'logging-standards.md': 'Adding logging',
-    'error-code-standards.md': 'Error handling',
-    'testing.ai.yaml': 'Writing tests',
-    'versioning.md': 'Version bumping',
-    'changelog-standards.md': 'Updating changelog',
-    'code-review-checklist.md': 'Code review',
-    'spec-driven-development.md': 'Feature development',
-    'test-completeness-dimensions.md': 'Test coverage',
-    'git-workflow.ai.yaml': 'Git workflow'
-  };
-
   for (const tool of manifest.aiTools) {
     const toolFile = getToolFilePath(tool);
     if (!toolFile) continue;
@@ -883,21 +899,19 @@ function checkIntegrationFiles(manifest, projectPath, msg) {
 
       if (isReferenced) {
         referencedStandards.push(stdFile);
-      } else if (STANDARD_TASK_MAPPING[stdFile]) {
-        // Only report as missing if it's a known trackable standard
+      } else {
+        // Track all installed standards from manifest
         missingStandards.push(stdFile);
       }
     }
 
-    // Report status
-    const totalTrackable = Object.keys(STANDARD_TASK_MAPPING).filter(s =>
-      standardsFiles.includes(s)
-    ).length;
+    // Report status - use all installed standards as the total
+    const totalTrackable = standardsFiles.length;
 
     if (hasStandardsIndex && missingStandards.length === 0) {
       console.log(chalk.green(`  ✓ ${toolFile}:`));
       console.log(chalk.gray(`    ${msg.standardsIndexPresent}`));
-      console.log(chalk.gray(`    ${msg.standardsReferenced.replace('{count}', referencedStandards.length).replace('{total}', totalTrackable || standardsFiles.length)}`));
+      console.log(chalk.gray(`    ${msg.standardsReferenced.replace('{count}', referencedStandards.length).replace('{total}', totalTrackable)}`));
     } else if (hasStandardsIndex) {
       console.log(chalk.yellow(`  ⚠ ${toolFile}:`));
       console.log(chalk.gray(`    ${msg.standardsIndexPresent}`));
@@ -1054,3 +1068,416 @@ async function checkCliVersion(bundledVersion) {
     // Silent failure - don't disrupt main functionality
   }
 }
+
+// ============================================================
+// Enhanced Integrity Check Functions (v3.3.0+)
+// ============================================================
+
+/**
+ * Check Skills files integrity against stored hashes
+ * @param {Object} manifest - Manifest object
+ * @param {string} projectPath - Project root path
+ * @param {Object} msg - Localized messages
+ * @returns {Object} Status { unchanged: [], modified: [], missing: [] }
+ */
+function checkSkillsIntegrity(manifest, projectPath, msg) {
+  const skillHashes = manifest.skillHashes;
+
+  // Skip if no skill hashes tracked
+  if (!skillHashes || Object.keys(skillHashes).length === 0) {
+    return { unchanged: [], modified: [], missing: [], tracked: false };
+  }
+
+  console.log(chalk.cyan(msg.skillsIntegrityCheck || 'Skills File Integrity'));
+
+  const status = { unchanged: [], modified: [], missing: [], tracked: true };
+
+  for (const [hashKey, hashInfo] of Object.entries(skillHashes)) {
+    // Parse key format: agent/level/skillName/filename
+    const keyParts = hashKey.split('/');
+    if (keyParts.length < 3) continue;
+
+    const [agent, level] = keyParts;
+    const relativePath = keyParts.slice(2).join('/');
+
+    // Get actual file path
+    const skillsDir = getSkillsDirForAgent(agent, level, projectPath);
+    if (!skillsDir) {
+      status.missing.push(hashKey);
+      continue;
+    }
+
+    const fullPath = join(skillsDir, relativePath);
+
+    if (!existsSync(fullPath)) {
+      status.missing.push(hashKey);
+      console.log(chalk.red(`  ✗ ${hashKey} (${msg.missing || 'missing'})`));
+      continue;
+    }
+
+    // Compare hash
+    const currentHash = computeFileHash(fullPath);
+    if (!currentHash) {
+      status.missing.push(hashKey);
+      continue;
+    }
+
+    if (currentHash.hash === hashInfo.hash && currentHash.size === hashInfo.size) {
+      status.unchanged.push(hashKey);
+    } else {
+      status.modified.push(hashKey);
+      console.log(chalk.yellow(`  ⚠ ${hashKey} (${msg.modified || 'modified'})`));
+    }
+  }
+
+  // Summary
+  if (status.modified.length === 0 && status.missing.length === 0) {
+    console.log(chalk.green(`  ✓ ${msg.allSkillsIntact || 'All skill files intact'} (${status.unchanged.length} files)`));
+  } else {
+    console.log(chalk.gray(`  ${(msg.skillsIntegritySummary || '{unchanged} unchanged, {modified} modified, {missing} missing')
+      .replace('{unchanged}', status.unchanged.length)
+      .replace('{modified}', status.modified.length)
+      .replace('{missing}', status.missing.length)}`));
+  }
+
+  console.log();
+  return status;
+}
+
+/**
+ * Check Commands files integrity against stored hashes
+ * @param {Object} manifest - Manifest object
+ * @param {string} projectPath - Project root path
+ * @param {Object} msg - Localized messages
+ * @returns {Object} Status { unchanged: [], modified: [], missing: [] }
+ */
+function checkCommandsIntegrity(manifest, projectPath, msg) {
+  const commandHashes = manifest.commandHashes;
+
+  // Skip if no command hashes tracked
+  if (!commandHashes || Object.keys(commandHashes).length === 0) {
+    return { unchanged: [], modified: [], missing: [], tracked: false };
+  }
+
+  console.log(chalk.cyan(msg.commandsIntegrityCheck || 'Commands File Integrity'));
+
+  const status = { unchanged: [], modified: [], missing: [], tracked: true };
+
+  for (const [hashKey, hashInfo] of Object.entries(commandHashes)) {
+    // Parse key format: agent/filename.md
+    const keyParts = hashKey.split('/');
+    if (keyParts.length < 2) continue;
+
+    const agent = keyParts[0];
+    const filename = keyParts.slice(1).join('/');
+
+    // Get actual file path
+    const commandsDir = getCommandsDirForAgent(agent, projectPath);
+    if (!commandsDir) {
+      status.missing.push(hashKey);
+      continue;
+    }
+
+    const fullPath = join(commandsDir, filename);
+
+    if (!existsSync(fullPath)) {
+      status.missing.push(hashKey);
+      console.log(chalk.red(`  ✗ ${hashKey} (${msg.missing || 'missing'})`));
+      continue;
+    }
+
+    // Compare hash
+    const currentHash = computeFileHash(fullPath);
+    if (!currentHash) {
+      status.missing.push(hashKey);
+      continue;
+    }
+
+    if (currentHash.hash === hashInfo.hash && currentHash.size === hashInfo.size) {
+      status.unchanged.push(hashKey);
+    } else {
+      status.modified.push(hashKey);
+      console.log(chalk.yellow(`  ⚠ ${hashKey} (${msg.modified || 'modified'})`));
+    }
+  }
+
+  // Summary
+  if (status.modified.length === 0 && status.missing.length === 0) {
+    console.log(chalk.green(`  ✓ ${msg.allCommandsIntact || 'All command files intact'} (${status.unchanged.length} files)`));
+  } else {
+    console.log(chalk.gray(`  ${(msg.commandsIntegritySummary || '{unchanged} unchanged, {modified} modified, {missing} missing')
+      .replace('{unchanged}', status.unchanged.length)
+      .replace('{modified}', status.modified.length)
+      .replace('{missing}', status.missing.length)}`));
+  }
+
+  console.log();
+  return status;
+}
+
+/**
+ * Check Integration files' UDS block integrity against stored hashes
+ * Only checks the UDS marker block content, not user customizations outside the block
+ * @param {Object} manifest - Manifest object
+ * @param {string} projectPath - Project root path
+ * @param {Object} msg - Localized messages
+ * @returns {Object} Status { unchanged: [], modified: [], missing: [], noMarkers: [] }
+ */
+function checkIntegrationBlocksIntegrity(manifest, projectPath, msg) {
+  const blockHashes = manifest.integrationBlockHashes;
+
+  // Skip if no block hashes tracked
+  if (!blockHashes || Object.keys(blockHashes).length === 0) {
+    return { unchanged: [], modified: [], missing: [], noMarkers: [], tracked: false };
+  }
+
+  console.log(chalk.cyan(msg.integrationBlocksCheck || 'Integration UDS Block Integrity'));
+
+  const status = { unchanged: [], modified: [], missing: [], noMarkers: [], tracked: true };
+
+  for (const [filePath, hashInfo] of Object.entries(blockHashes)) {
+    const fullPath = join(projectPath, filePath);
+
+    if (!existsSync(fullPath)) {
+      status.missing.push(filePath);
+      console.log(chalk.red(`  ✗ ${filePath} (${msg.missing || 'missing'})`));
+      continue;
+    }
+
+    // Compare block hash
+    const blockStatus = compareIntegrationBlockHash(fullPath, hashInfo);
+
+    switch (blockStatus) {
+      case 'unchanged':
+        status.unchanged.push(filePath);
+        break;
+      case 'modified':
+        status.modified.push(filePath);
+        console.log(chalk.yellow(`  ⚠ ${filePath} (${msg.udsBlockModified || 'UDS block modified'})`));
+        break;
+      case 'no_markers':
+        status.noMarkers.push(filePath);
+        console.log(chalk.red(`  ✗ ${filePath} (${msg.udsMarkersRemoved || 'UDS markers removed'})`));
+        break;
+      case 'missing':
+        status.missing.push(filePath);
+        console.log(chalk.red(`  ✗ ${filePath} (${msg.missing || 'missing'})`));
+        break;
+    }
+  }
+
+  // Summary
+  if (status.modified.length === 0 && status.missing.length === 0 && status.noMarkers.length === 0) {
+    console.log(chalk.green(`  ✓ ${msg.allBlocksIntact || 'All UDS blocks intact'} (${status.unchanged.length} files)`));
+    console.log(chalk.gray(`    ${msg.userContentPreserved || 'User customizations outside UDS blocks are preserved'}`));
+  } else {
+    console.log(chalk.gray(`  ${(msg.blocksIntegritySummary || '{unchanged} intact, {modified} modified, {missing} missing')
+      .replace('{unchanged}', status.unchanged.length)
+      .replace('{modified}', status.modified.length)
+      .replace('{missing}', status.missing.length + status.noMarkers.length)}`));
+
+    if (status.modified.length > 0 || status.noMarkers.length > 0) {
+      console.log(chalk.yellow(`    ${msg.runUpdateIntegrations || 'Run "uds update --integrations-only" to restore UDS content'}`));
+    }
+  }
+
+  console.log();
+  return status;
+}
+
+// ============================================================
+// Summary Mode (--summary)
+// ============================================================
+
+/**
+ * Display compact status summary for use by other commands
+ * @param {string} projectPath - Project root path
+ * @param {Object} options - Command options
+ */
+async function displaySummary(projectPath, _options = {}) {
+  const msg = t().commands.check;
+  const common = t().commands.common;
+  const summaryMsg = msg.summary_mode || {};
+
+  console.log();
+  console.log(chalk.bold(summaryMsg.title || 'UDS Status Summary'));
+  console.log(chalk.gray('─'.repeat(50)));
+
+  // Check if initialized
+  if (!isInitialized(projectPath)) {
+    console.log(chalk.red(`  ${summaryMsg.notInitialized || 'Not initialized'}`));
+    console.log(chalk.gray(`  ${common.runInit}`));
+    console.log(chalk.gray('─'.repeat(50)));
+    console.log();
+    return;
+  }
+
+  // Read manifest
+  const manifest = readManifest(projectPath);
+  if (!manifest) {
+    console.log(chalk.red(`  ${summaryMsg.manifestError || 'Manifest error'}`));
+    console.log(chalk.gray('─'.repeat(50)));
+    console.log();
+    return;
+  }
+
+  const levelInfo = getLevelInfo(manifest.level);
+  const repoInfo = getRepositoryInfo();
+  const lang = getLanguage();
+
+  // === Row 1: Version ===
+  const currentVersion = manifest.upstream.version;
+  const latestVersion = repoInfo.standards.version;
+  const hasUpdate = currentVersion !== latestVersion;
+
+  if (hasUpdate) {
+    console.log(chalk.yellow(`  ${summaryMsg.version || 'Version'}: ${currentVersion} → ${latestVersion} ⚠`));
+  } else {
+    console.log(chalk.green(`  ${summaryMsg.version || 'Version'}: ${currentVersion} ✓`));
+  }
+
+  // === Row 2: Level ===
+  const zhName = lang === 'zh-cn' ? levelInfo.nameZhCn : levelInfo.nameZh;
+  const levelDisplay = lang === 'en'
+    ? `${manifest.level} - ${levelInfo.name}`
+    : `${manifest.level} - ${levelInfo.name} (${zhName})`;
+  console.log(chalk.gray(`  ${summaryMsg.level || 'Level'}: ${levelDisplay}`));
+
+  // === Row 3: Files Status ===
+  const fileStatus = getFileStatusCounts(manifest, projectPath);
+  const filesOk = fileStatus.modified === 0 && fileStatus.missing === 0;
+  const filesDisplay = filesOk
+    ? chalk.green(`${fileStatus.unchanged} ✓`)
+    : `${chalk.green(fileStatus.unchanged + ' ✓')} ${chalk.yellow('| ' + fileStatus.modified + ' modified')} ${chalk.red('| ' + fileStatus.missing + ' missing')}`;
+  console.log(`  ${summaryMsg.files || 'Files'}: ${filesDisplay}`);
+
+  // === Row 4: Skills Status ===
+  const aiTools = manifest.aiTools || [];
+  if (aiTools.length > 0) {
+    const skillsStatus = getSkillsStatusSummary(manifest, projectPath);
+    console.log(`  ${summaryMsg.skills || 'Skills'}: ${skillsStatus}`);
+  }
+
+  // === Row 5: Commands Status (if applicable) ===
+  const commandsStatus = getCommandsStatusSummary(manifest, projectPath);
+  if (commandsStatus) {
+    console.log(`  ${summaryMsg.commands || 'Commands'}: ${commandsStatus}`);
+  }
+
+  console.log(chalk.gray('─'.repeat(50)));
+  console.log();
+}
+
+/**
+ * Get file status counts without logging
+ * @param {Object} manifest - Manifest object
+ * @param {string} projectPath - Project root path
+ * @returns {{unchanged: number, modified: number, missing: number}}
+ */
+function getFileStatusCounts(manifest, projectPath) {
+  const counts = { unchanged: 0, modified: 0, missing: 0 };
+
+  if (hasFileHashes(manifest)) {
+    for (const [relativePath, hashInfo] of Object.entries(manifest.fileHashes)) {
+      const fullPath = join(projectPath, relativePath);
+      const status = compareFileHash(fullPath, hashInfo);
+
+      switch (status) {
+        case 'unchanged':
+          counts.unchanged++;
+          break;
+        case 'modified':
+          counts.modified++;
+          break;
+        case 'missing':
+          counts.missing++;
+          break;
+      }
+    }
+  } else {
+    // Legacy manifest - existence check only
+    const allFiles = [
+      ...manifest.standards.map(s => `.standards/${basename(s)}`),
+      ...manifest.extensions.map(e => `.standards/${basename(e)}`),
+      ...manifest.integrations
+    ];
+    for (const relativePath of allFiles) {
+      const fullPath = join(projectPath, relativePath);
+      if (existsSync(fullPath)) {
+        counts.unchanged++;
+      } else {
+        counts.missing++;
+      }
+    }
+  }
+
+  return counts;
+}
+
+/**
+ * Get skills status summary string
+ * @param {Object} manifest - Manifest object
+ * @param {string} projectPath - Project root path
+ * @returns {string} Formatted skills status
+ */
+function getSkillsStatusSummary(manifest, projectPath) {
+  const aiTools = manifest.aiTools || [];
+  const parts = [];
+
+  // Check for Marketplace installation (Claude Code specific)
+  const location = manifest.skills?.location || '';
+  const isMarketplace = location === 'marketplace' ||
+    location.includes('plugins/cache') ||
+    location.includes('plugins\\cache');
+
+  for (const tool of aiTools) {
+    const config = getAgentConfig(tool);
+    if (!config || !config.supportsSkills) continue;
+
+    const displayName = getAgentDisplayName(tool);
+    const usingMarketplace = isMarketplace && tool === 'claude-code';
+
+    if (usingMarketplace) {
+      parts.push(chalk.green(`${displayName} ✓`));
+      continue;
+    }
+
+    const projectSkillsInfo = getInstalledSkillsInfoForAgent(tool, 'project', projectPath);
+    const userSkillsInfo = getInstalledSkillsInfoForAgent(tool, 'user', projectPath);
+
+    if (projectSkillsInfo?.installed || userSkillsInfo?.installed) {
+      parts.push(chalk.green(`${displayName} ✓`));
+    } else {
+      parts.push(chalk.gray(`${displayName} ○`));
+    }
+  }
+
+  return parts.join(' | ') || chalk.gray('None configured');
+}
+
+/**
+ * Get commands status summary string
+ * @param {Object} manifest - Manifest object
+ * @param {string} projectPath - Project root path
+ * @returns {string|null} Formatted commands status or null if no tools support commands
+ */
+function getCommandsStatusSummary(manifest, projectPath) {
+  const aiTools = manifest.aiTools || [];
+  const parts = [];
+
+  for (const tool of aiTools) {
+    const config = getAgentConfig(tool);
+    if (!config || !config.commands) continue;
+
+    const displayName = getAgentDisplayName(tool);
+    const commandsInfo = getInstalledCommandsForAgent(tool, projectPath);
+
+    if (commandsInfo?.installed) {
+      parts.push(chalk.green(`${displayName} ✓`));
+    } else {
+      parts.push(chalk.gray(`${displayName} ○`));
+    }
+  }
+
+  return parts.length > 0 ? parts.join(' | ') : null;
+}

package/src/commands/configure.js

@@ -45,6 +45,7 @@ import {
   getToolFilePath
 } from '../utils/integration-generator.js';
 import { t } from '../i18n/messages.js';
+import { regenerateIntegrations } from './update.js';
 
 /**
  * Configure command - modify options for initialized project
@@ -263,11 +264,13 @@ export async function configureCommand(options) {
   }
   console.log();
 
-  // Confirm
-  const confirmed = await promptConfirm(msg.applyChanges);
-  if (!confirmed) {
-    console.log(chalk.yellow(msg.configCancelled));
-    process.exit(0);
+  // Confirm (skip if --yes flag is provided)
+  if (!options.yes) {
+    const confirmed = await promptConfirm(msg.applyChanges);
+    if (!confirmed) {
+      console.log(chalk.yellow(msg.configCancelled));
+      process.exit(0);
+    }
   }
 
   // Apply changes
@@ -440,6 +443,62 @@ export async function configureCommand(options) {
     }
   }
 
+  // Smart apply: offer to regenerate integrations if config changed but not already regenerated
+  // Skip for types that have their own flow or don't affect integrations
+  const skipApplyTypes = ['skills', 'commands', 'methodology'];
+  const alreadyRegenerated = results.generated.length > 0;
+  const shouldOfferApply = !skipApplyTypes.includes(configType) &&
+                           newAITools.length > 0 &&
+                           !alreadyRegenerated;
+
+  if (shouldOfferApply) {
+    console.log();
+
+    if (options.yes) {
+      // --yes flag: auto-apply without prompting
+      const applySpinner = ora(msg.applyingChanges).start();
+      const applyResults = regenerateIntegrations(projectPath, manifest);
+      applySpinner.succeed(msg.changesApplied || msg.regeneratedIntegrations.replace('{count}', applyResults.updated.length));
+
+      // Update manifest with new file hashes
+      writeManifest(manifest, projectPath);
+
+      if (applyResults.errors.length > 0) {
+        console.log(chalk.yellow(msg.errorsOccurred.replace('{count}', applyResults.errors.length)));
+        for (const err of applyResults.errors) {
+          console.log(chalk.gray(`    ${err}`));
+        }
+      }
+    } else {
+      // Interactive mode: prompt user
+      const inquirer = await import('inquirer');
+      const { apply } = await inquirer.default.prompt([{
+        type: 'confirm',
+        name: 'apply',
+        message: msg.applyChangesNow,
+        default: true
+      }]);
+
+      if (apply) {
+        const applySpinner = ora(msg.applyingChanges).start();
+        const applyResults = regenerateIntegrations(projectPath, manifest);
+        applySpinner.succeed(msg.changesApplied || msg.regeneratedIntegrations.replace('{count}', applyResults.updated.length));
+
+        // Update manifest with new file hashes
+        writeManifest(manifest, projectPath);
+
+        if (applyResults.errors.length > 0) {
+          console.log(chalk.yellow(msg.errorsOccurred.replace('{count}', applyResults.errors.length)));
+          for (const err of applyResults.errors) {
+            console.log(chalk.gray(`    ${err}`));
+          }
+        }
+      } else {
+        console.log(chalk.gray(msg.runUpdateLater));
+      }
+    }
+  }
+
   console.log();
 
   // Exit explicitly to prevent hanging due to inquirer's readline interface