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

package/src/commands/init.js

@@ -537,7 +537,11 @@ export async function initCommand(options) {
     integrations: [],
     skills: [],
     commands: [],
-    errors: []
+    errors: [],
+    // New: hash tracking for enhanced file integrity
+    skillHashes: {},
+    commandHashes: {},
+    integrationBlockHashes: {}
   };
 
   // Get standards for the selected level
@@ -702,6 +706,14 @@ export async function initCommand(options) {
       if (result.success) {
         results.integrations.push(result.path);
         generatedFiles.add(targetFile);
+
+        // Capture integration block hash for tracking UDS content
+        if (result.blockHashInfo) {
+          results.integrationBlockHashes[result.path] = {
+            ...result.blockHashInfo,
+            installedAt: new Date().toISOString()
+          };
+        }
       } else {
         // Fall back to legacy static file copy
         const mapping = INTEGRATION_MAPPINGS[tool];
@@ -776,6 +788,11 @@ export async function initCommand(options) {
       }
     }
 
+    // Collect skill file hashes for integrity tracking
+    if (installResult.allFileHashes) {
+      Object.assign(results.skillHashes, installResult.allFileHashes);
+    }
+
     // Build location summary for display
     const targetLocations = skillsConfig.skillsInstallations.map(inst => {
       const displayName = getAgentDisplayName(inst.agent);
@@ -867,6 +884,11 @@ export async function initCommand(options) {
       }
     }
 
+    // Collect command file hashes for integrity tracking
+    if (cmdResult.allFileHashes) {
+      Object.assign(results.commandHashes, cmdResult.allFileHashes);
+    }
+
     // Build location summary
     const cmdLocations = skillsConfig.commandsInstallations.map(agent => {
       const displayName = getAgentDisplayName(agent);
@@ -983,7 +1005,7 @@ export async function initCommand(options) {
   }
 
   const manifest = {
-    version: '3.2.0',
+    version: '3.3.0', // Updated for enhanced file tracking
     upstream: {
       repo: 'AsiaOstrich/universal-dev-standards',
       version: repoInfo.standards.version,
@@ -1021,7 +1043,11 @@ export async function initCommand(options) {
         skipLimit: 3
       }
     } : null,
-    fileHashes
+    fileHashes,
+    // New: enhanced file tracking for Skills, Commands, and Integration blocks
+    skillHashes: results.skillHashes || {},
+    commandHashes: results.commandHashes || {},
+    integrationBlockHashes: results.integrationBlockHashes || {}
   };
 
   writeManifest(manifest, projectPath);

package/src/commands/update.js

@@ -336,6 +336,15 @@ export async function updateCommand(options) {
       if (result.success) {
         results.integrations.push(result.path);
         generatedFiles.add(targetFile);
+
+        // Track integration block hash for UDS content integrity
+        if (result.blockHashInfo) {
+          if (!manifest.integrationBlockHashes) manifest.integrationBlockHashes = {};
+          manifest.integrationBlockHashes[result.path] = {
+            ...result.blockHashInfo,
+            installedAt: new Date().toISOString()
+          };
+        }
       } else {
         results.errors.push(`${tool}: ${result.error}`);
       }
@@ -384,7 +393,7 @@ export async function updateCommand(options) {
   }
 
   // Update manifest
-  manifest.version = '3.2.0';
+  manifest.version = '3.3.0';
   manifest.upstream.version = latestVersion;
   manifest.upstream.installed = new Date().toISOString().split('T')[0];
   writeManifest(manifest, projectPath);
@@ -405,15 +414,17 @@ export async function updateCommand(options) {
     }
   }
 
-  // Check for new features (Skills/Commands) not yet installed
+  // Check for new features (Skills/Commands) not yet installed or outdated
   if (!options.standardsOnly) {
-    const { missingSkills, missingCommands } = checkNewFeatures(projectPath, manifest);
+    const latestSkillsVersion = repoInfo.skills.version;
+    const { missingSkills, outdatedSkills, missingCommands } = checkNewFeatures(projectPath, manifest, latestSkillsVersion);
 
-    if (missingSkills.length > 0 || missingCommands.length > 0) {
+    if (missingSkills.length > 0 || outdatedSkills.length > 0 || missingCommands.length > 0) {
       if (!options.yes) {
-        // Interactive mode: prompt user to install
-        const { installSkills, installCommands } = await promptNewFeatureInstallation(
+        // Interactive mode: prompt user to install/update
+        const { installSkills, updateSkills, installCommands } = await promptNewFeatureInstallation(
           missingSkills,
+          outdatedSkills,
           missingCommands
         );
 
@@ -431,6 +442,12 @@ export async function updateCommand(options) {
             ...installSkills
           ];
 
+          // Update skill hashes for integrity tracking
+          if (skillResult.allFileHashes) {
+            if (!manifest.skillHashes) manifest.skillHashes = {};
+            Object.assign(manifest.skillHashes, skillResult.allFileHashes);
+          }
+
           if (skillResult.totalErrors === 0) {
             skillSpinner.succeed((msg.newSkillsInstalled || 'Installed Skills for {count} AI tools')
               .replace('{count}', installSkills.length));
@@ -440,6 +457,30 @@ export async function updateCommand(options) {
           }
         }
 
+        // Update outdated Skills if user agreed
+        if (updateSkills.length > 0) {
+          const updateSpinner = ora(msg.updatingSkills || 'Updating Skills...').start();
+          const updateResult = await installSkillsToMultipleAgents(updateSkills, null, projectPath);
+
+          // Update manifest version
+          if (!manifest.skills) manifest.skills = {};
+          manifest.skills.version = repoInfo.skills.version;
+
+          // Update skill hashes for integrity tracking
+          if (updateResult.allFileHashes) {
+            if (!manifest.skillHashes) manifest.skillHashes = {};
+            Object.assign(manifest.skillHashes, updateResult.allFileHashes);
+          }
+
+          if (updateResult.totalErrors === 0) {
+            updateSpinner.succeed((msg.skillsUpdated || 'Updated Skills for {count} AI tools')
+              .replace('{count}', updateSkills.length));
+          } else {
+            updateSpinner.warn((msg.skillsUpdatedWithErrors || 'Updated Skills with {errors} errors')
+              .replace('{errors}', updateResult.totalErrors));
+          }
+        }
+
         // Install Commands if user agreed
         if (installCommands.length > 0) {
           const cmdSpinner = ora(msg.installingNewCommands || 'Installing commands...').start();
@@ -453,6 +494,12 @@ export async function updateCommand(options) {
             ...installCommands
           ];
 
+          // Update command hashes for integrity tracking
+          if (cmdResult.allFileHashes) {
+            if (!manifest.commandHashes) manifest.commandHashes = {};
+            Object.assign(manifest.commandHashes, cmdResult.allFileHashes);
+          }
+
           if (cmdResult.totalErrors === 0) {
             cmdSpinner.succeed((msg.newCommandsInstalled || 'Installed commands for {count} AI tools')
               .replace('{count}', installCommands.length));
@@ -462,8 +509,8 @@ export async function updateCommand(options) {
           }
         }
 
-        // Write updated manifest if anything was installed
-        if (installSkills.length > 0 || installCommands.length > 0) {
+        // Write updated manifest if anything was installed or updated
+        if (installSkills.length > 0 || updateSkills.length > 0 || installCommands.length > 0) {
           writeManifest(manifest, projectPath);
         }
       } else {
@@ -474,6 +521,10 @@ export async function updateCommand(options) {
           const toolNames = missingSkills.map(s => s.displayName).join(', ');
           console.log(chalk.gray(`  • Skills (${toolNames}): run "uds update --skills" or "uds init" to install`));
         }
+        if (outdatedSkills.length > 0) {
+          const toolNames = outdatedSkills.map(s => `${s.displayName} (${s.currentVersion} → ${s.latestVersion})`).join(', ');
+          console.log(chalk.gray(`  • Skills update (${toolNames}): run "uds update" interactively to update`));
+        }
         if (missingCommands.length > 0) {
           const toolNames = missingCommands.map(c => c.displayName).join(', ');
           console.log(chalk.gray(`  • Commands (${toolNames}): run "uds update --commands" or "uds init" to install`));
@@ -527,26 +578,19 @@ export async function updateCommand(options) {
 }
 
 /**
- * Update integration files only (without updating standards)
+ * Regenerate integration files for all configured AI tools
+ * Reusable core logic that can be called from both updateIntegrationsOnly and configureCommand
  * @param {string} projectPath - Project path
- * @param {Object} manifest - Manifest object
+ * @param {Object} manifest - Manifest object (will be mutated with updated hashes)
+ * @returns {{success: boolean, updated: string[], errors: string[]}}
  */
-async function updateIntegrationsOnly(projectPath, manifest) {
-  const msg = t().commands.update;
-
-  console.log(chalk.cyan(msg.updatingIntegrationsOnly));
-  console.log();
-
+export function regenerateIntegrations(projectPath, manifest) {
   const aiTools = manifest.aiTools || [];
+
   if (aiTools.length === 0) {
-    console.log(chalk.yellow(msg.noAiToolsConfigured));
-    console.log(chalk.gray(`  ${msg.runConfigure}`));
-    console.log();
-    return;
+    return { success: true, updated: [], errors: [] };
   }
 
-  const spinner = ora(msg.regeneratingIntegrations).start();
-
   // Build installed standards list
   const installedStandardsList = manifest.standards?.map(s => basename(s)) || [];
 
@@ -596,15 +640,55 @@ async function updateIntegrationsOnly(projectPath, manifest) {
         }
         manifest.fileHashes[result.path] = { ...hashInfo, installedAt: now };
       }
+
+      // Track integration block hash for UDS content integrity
+      if (result.blockHashInfo) {
+        if (!manifest.integrationBlockHashes) manifest.integrationBlockHashes = {};
+        manifest.integrationBlockHashes[result.path] = {
+          ...result.blockHashInfo,
+          installedAt: now
+        };
+      }
     } else {
       results.errors.push(`${tool}: ${result.error}`);
     }
   }
 
+  return {
+    success: results.errors.length === 0,
+    updated: results.updated,
+    errors: results.errors
+  };
+}
+
+/**
+ * Update integration files only (without updating standards)
+ * @param {string} projectPath - Project path
+ * @param {Object} manifest - Manifest object
+ */
+async function updateIntegrationsOnly(projectPath, manifest) {
+  const msg = t().commands.update;
+
+  console.log(chalk.cyan(msg.updatingIntegrationsOnly));
+  console.log();
+
+  const aiTools = manifest.aiTools || [];
+  if (aiTools.length === 0) {
+    console.log(chalk.yellow(msg.noAiToolsConfigured));
+    console.log(chalk.gray(`  ${msg.runConfigure}`));
+    console.log();
+    return;
+  }
+
+  const spinner = ora(msg.regeneratingIntegrations).start();
+
+  // Use reusable regeneration function
+  const results = regenerateIntegrations(projectPath, manifest);
+
   spinner.succeed(msg.regeneratedIntegrations.replace('{count}', results.updated.length));
 
   // Update manifest
-  manifest.version = '3.2.0';
+  manifest.version = '3.3.0';
   writeManifest(manifest, projectPath);
 
   // Summary
@@ -715,6 +799,15 @@ async function syncIntegrationReferences(projectPath, manifest) {
         manifest.fileHashes[integrationPath] = { ...hashInfo, installedAt: now };
       }
 
+      // Track integration block hash for UDS content integrity
+      if (result.blockHashInfo) {
+        if (!manifest.integrationBlockHashes) manifest.integrationBlockHashes = {};
+        manifest.integrationBlockHashes[integrationPath] = {
+          ...result.blockHashInfo,
+          installedAt: now
+        };
+      }
+
       updatedCount++;
     } else {
       console.log(chalk.red(`  ${msg.failedToUpdate.replace('{path}', integrationPath).replace('{error}', result.error)}`));
@@ -723,7 +816,7 @@ async function syncIntegrationReferences(projectPath, manifest) {
 
   // Update manifest version and save
   if (updatedCount > 0) {
-    manifest.version = '3.2.0';
+    manifest.version = '3.3.0';
     writeManifest(manifest, projectPath);
   }
 
@@ -840,6 +933,13 @@ async function updateSkillsOnly(projectPath, manifest) {
   // Update manifest
   manifest.skills.version = latestVersion;
   manifest.skills.installations = skillsInstallations;
+
+  // Update skill hashes for integrity tracking
+  if (result.allFileHashes) {
+    if (!manifest.skillHashes) manifest.skillHashes = {};
+    Object.assign(manifest.skillHashes, result.allFileHashes);
+  }
+
   writeManifest(manifest, projectPath);
 
   console.log();
@@ -908,6 +1008,13 @@ async function updateCommandsOnly(projectPath, manifest) {
   manifest.commands = manifest.commands || {};
   manifest.commands.installed = true;
   manifest.commands.installations = commandsInstallations;
+
+  // Update command hashes for integrity tracking
+  if (result.allFileHashes) {
+    if (!manifest.commandHashes) manifest.commandHashes = {};
+    Object.assign(manifest.commandHashes, result.allFileHashes);
+  }
+
   writeManifest(manifest, projectPath);
 
   console.log();
@@ -915,19 +1022,21 @@ async function updateCommandsOnly(projectPath, manifest) {
 }
 
 /**
- * Check manifest.aiTools and detect missing Skills/Commands
+ * Check manifest.aiTools and detect missing/outdated Skills/Commands
  * @param {string} projectPath - Project path
  * @param {Object} manifest - Manifest object
- * @returns {{missingSkills: Array, missingCommands: Array}}
+ * @param {string} latestSkillsVersion - Latest skills version from repository
+ * @returns {{missingSkills: Array, outdatedSkills: Array, missingCommands: Array}}
  */
-function checkNewFeatures(projectPath, manifest) {
+function checkNewFeatures(projectPath, manifest, latestSkillsVersion) {
   const aiTools = manifest.aiTools || [];
 
   if (aiTools.length === 0) {
-    return { missingSkills: [], missingCommands: [] };
+    return { missingSkills: [], outdatedSkills: [], missingCommands: [] };
   }
 
   const missingSkills = [];
+  const outdatedSkills = [];
   const missingCommands = [];
 
   for (const tool of aiTools) {
@@ -936,20 +1045,16 @@ function checkNewFeatures(projectPath, manifest) {
 
     // Check Skills support
     if (config.supportsSkills && config.skills) {
-      // Check if skills are installed for this agent
+      // Check if skills are actually installed for this agent (file-based check)
       const projectInfo = getInstalledSkillsInfoForAgent(tool, 'project', projectPath);
       const userInfo = getInstalledSkillsInfoForAgent(tool, 'user');
 
-      // Check if already in manifest.skills.installations
-      const existingInstallations = manifest.skills?.installations || [];
-      const isInManifest = existingInstallations.some(
-        inst => inst.agent === tool || (inst.agent === 'claude-code' && tool === 'claude-code')
-      );
-
-      // Check if using marketplace (Claude Code only)
+      // Check if using marketplace (Claude Code only) - marketplace auto-updates
       const usingMarketplace = manifest.skills?.location === 'marketplace' && tool === 'claude-code';
 
-      const hasSkills = projectInfo?.installed || userInfo?.installed || isInManifest || usingMarketplace;
+      // Only trust actual file existence, not manifest records
+      // (manifest records can be stale if user deleted the directory)
+      const hasSkills = projectInfo?.installed || userInfo?.installed || usingMarketplace;
 
       if (!hasSkills) {
         missingSkills.push({
@@ -957,6 +1062,23 @@ function checkNewFeatures(projectPath, manifest) {
           displayName: getAgentDisplayName(tool),
           paths: config.skills
         });
+      } else if (latestSkillsVersion) {
+        // Check if installed Skills are outdated
+        const installedInfo = userInfo || projectInfo;
+        const installedVersion = installedInfo?.version;
+
+        // Skip marketplace (auto-updates) and unknown versions
+        if (!usingMarketplace && installedVersion && installedVersion !== latestSkillsVersion) {
+          outdatedSkills.push({
+            agent: tool,
+            displayName: getAgentDisplayName(tool),
+            paths: config.skills,
+            currentVersion: installedVersion,
+            latestVersion: latestSkillsVersion,
+            level: userInfo?.installed ? 'user' : 'project',
+            path: installedInfo?.path
+          });
+        }
       }
     }
 
@@ -964,11 +1086,8 @@ function checkNewFeatures(projectPath, manifest) {
     if (config.commands !== null && config.commands) {
       const cmdInfo = getInstalledCommandsForAgent(tool, projectPath);
 
-      // Check if already in manifest.commands.installations
-      const existingCmdInstallations = manifest.commands?.installations || [];
-      const isInCmdManifest = existingCmdInstallations.includes(tool);
-
-      const hasCommands = cmdInfo?.installed || isInCmdManifest;
+      // Only trust actual file existence, not manifest records
+      const hasCommands = cmdInfo?.installed;
 
       if (!hasCommands) {
         missingCommands.push({
@@ -980,21 +1099,22 @@ function checkNewFeatures(projectPath, manifest) {
     }
   }
 
-  return { missingSkills, missingCommands };
+  return { missingSkills, outdatedSkills, missingCommands };
 }
 
 /**
  * Prompt user to install new features discovered during update
  * @param {Array} missingSkills - Array of {agent, displayName, paths}
+ * @param {Array} outdatedSkills - Array of {agent, displayName, paths, currentVersion, latestVersion, level, path}
  * @param {Array} missingCommands - Array of {agent, displayName, path}
- * @returns {Promise<{installSkills: Array, installCommands: Array}>}
+ * @returns {Promise<{installSkills: Array, updateSkills: Array, installCommands: Array}>}
  */
-async function promptNewFeatureInstallation(missingSkills, missingCommands) {
+async function promptNewFeatureInstallation(missingSkills, outdatedSkills, missingCommands) {
   const msg = t().commands.update;
 
-  // If nothing missing, return empty
-  if (missingSkills.length === 0 && missingCommands.length === 0) {
-    return { installSkills: [], installCommands: [] };
+  // If nothing to do, return empty
+  if (missingSkills.length === 0 && outdatedSkills.length === 0 && missingCommands.length === 0) {
+    return { installSkills: [], updateSkills: [], installCommands: [] };
   }
 
   console.log();
@@ -1003,7 +1123,7 @@ async function promptNewFeatureInstallation(missingSkills, missingCommands) {
   console.log(chalk.cyan('━'.repeat(50)));
   console.log();
 
-  const result = { installSkills: [], installCommands: [] };
+  const result = { installSkills: [], updateSkills: [], installCommands: [] };
 
   // Handle missing Skills with checkbox selection
   if (missingSkills.length > 0) {
@@ -1065,6 +1185,64 @@ async function promptNewFeatureInstallation(missingSkills, missingCommands) {
     console.log();
   }
 
+  // Handle outdated Skills with checkbox selection
+  if (outdatedSkills.length > 0) {
+    console.log(chalk.yellow(msg.skillsOutdatedFor || 'Skills updates available for these AI tools:'));
+    for (const skill of outdatedSkills) {
+      const levelLabel = skill.level === 'user' ? 'user' : 'project';
+      const pathDisplay = skill.path || getSkillsDirForAgent(skill.agent, skill.level);
+      console.log(chalk.gray(`  • ${skill.displayName} (${levelLabel}: ${pathDisplay})`));
+      console.log(chalk.gray(`      ${skill.currentVersion} → ${skill.latestVersion}`));
+    }
+    console.log();
+
+    // Build checkbox choices with path info
+    const updateChoices = outdatedSkills.map(skill => {
+      const levelLabel = skill.level === 'user' ? 'user' : 'project';
+      const pathDisplay = skill.path || getSkillsDirForAgent(skill.agent, skill.level);
+      return {
+        name: `${skill.displayName} ${chalk.gray(`(${levelLabel}: ${pathDisplay}) ${skill.currentVersion} → ${skill.latestVersion}`)}`,
+        value: skill.agent,
+        checked: true  // Default checked for opt-out behavior
+      };
+    });
+
+    // Add skip option
+    updateChoices.push(new inquirer.Separator());
+    updateChoices.push({
+      name: chalk.gray(msg.skipSkillsUpdate || 'Skip Skills update'),
+      value: '__skip__'
+    });
+
+    const { selectedUpdateAgents } = await inquirer.prompt([{
+      type: 'checkbox',
+      name: 'selectedUpdateAgents',
+      message: msg.selectSkillsToUpdate || 'Select AI tools to update Skills for:',
+      choices: updateChoices,
+      validate: (answer) => {
+        if (answer.includes('__skip__') && answer.length > 1) {
+          return msg.skipValidationError || 'Cannot select Skip with other options';
+        }
+        return true;
+      }
+    }]);
+
+    // Filter out skip and map to update info
+    const filteredUpdateAgents = selectedUpdateAgents.filter(a => a !== '__skip__');
+
+    if (filteredUpdateAgents.length > 0) {
+      result.updateSkills = filteredUpdateAgents.map(agent => {
+        const skillInfo = outdatedSkills.find(s => s.agent === agent);
+        return {
+          agent,
+          level: skillInfo.level,
+          path: skillInfo.path
+        };
+      });
+    }
+    console.log();
+  }
+
   // Handle missing Commands with checkbox selection
   if (missingCommands.length > 0) {
     console.log(chalk.yellow(msg.commandsNotInstalledFor || 'Slash commands not yet installed for these AI tools:'));

package/src/i18n/messages.js

@@ -604,7 +604,18 @@ export const messages = {
         skillsInstalledSuccess: 'Installed Skills for {count} AI tools',
         commandsInstalledSuccess: 'Installed commands for {count} AI tools',
         // Read-only hint
-        missingSkillsHint: 'Tip: Run `uds update` to install missing Skills/Commands'
+        missingSkillsHint: 'Tip: Run `uds update` to install missing Skills/Commands',
+        // Summary mode (--summary)
+        summary_mode: {
+          title: 'UDS Status Summary',
+          notInitialized: 'Not initialized',
+          manifestError: 'Manifest error',
+          version: 'Version',
+          level: 'Level',
+          files: 'Files',
+          skills: 'Skills',
+          commands: 'Commands'
+        }
       },
 
       // init command (commands/init.js)
@@ -843,7 +854,12 @@ export const messages = {
         errors: 'Errors',
         noCommandSupportedTools: 'No AI tools with command support configured',
         commandSupportedList: 'Tools that support commands: OpenCode, Copilot, Roo Code, Gemini CLI',
-        commandsInstalled: 'commands'
+        commandsInstalled: 'commands',
+        // Smart apply
+        applyChangesNow: 'Apply changes now? (regenerate integration files)',
+        runUpdateLater: 'Run `uds update --integrations-only` later to apply changes',
+        applyingChanges: 'Applying changes...',
+        changesApplied: 'Changes applied successfully'
       }
     }
   },
@@ -1444,7 +1460,18 @@ export const messages = {
         skillsInstalledSuccess: '已為 {count} 個 AI 工具安裝 Skills',
         commandsInstalledSuccess: '已為 {count} 個 AI 工具安裝斜線命令',
         // Read-only hint
-        missingSkillsHint: '提示：執行 `uds update` 安裝缺少的 Skills/斜線命令'
+        missingSkillsHint: '提示：執行 `uds update` 安裝缺少的 Skills/斜線命令',
+        // Summary mode (--summary)
+        summary_mode: {
+          title: 'UDS 狀態摘要',
+          notInitialized: '尚未初始化',
+          manifestError: 'Manifest 錯誤',
+          version: '版本',
+          level: '等級',
+          files: '檔案',
+          skills: 'Skills',
+          commands: '斜線命令'
+        }
       },
 
       // init command (commands/init.js)
@@ -1683,7 +1710,12 @@ export const messages = {
         errors: '錯誤',
         noCommandSupportedTools: '未設定支援命令的 AI 工具',
         commandSupportedList: '支援命令的工具：OpenCode、Copilot、Roo Code、Gemini CLI',
-        commandsInstalled: '個命令'
+        commandsInstalled: '個命令',
+        // Smart apply
+        applyChangesNow: '是否立即套用變更？（重新產生整合檔案）',
+        runUpdateLater: '稍後執行 `uds update --integrations-only` 以套用變更',
+        applyingChanges: '正在套用變更...',
+        changesApplied: '變更套用成功'
       }
     }
   },
@@ -2187,7 +2219,18 @@ export const messages = {
         skillsInstalledSuccess: '已为 {count} 个 AI 工具安装 Skills',
         commandsInstalledSuccess: '已为 {count} 个 AI 工具安装斜线命令',
         // Read-only hint
-        missingSkillsHint: '提示：执行 `uds update` 安装缺少的 Skills/斜线命令'
+        missingSkillsHint: '提示：执行 `uds update` 安装缺少的 Skills/斜线命令',
+        // Summary mode (--summary)
+        summary_mode: {
+          title: 'UDS 状态摘要',
+          notInitialized: '尚未初始化',
+          manifestError: 'Manifest 错误',
+          version: '版本',
+          level: '等级',
+          files: '文件',
+          skills: 'Skills',
+          commands: '斜线命令'
+        }
       },
 
       // update command
@@ -2355,7 +2398,12 @@ export const messages = {
         errors: '错误',
         noCommandSupportedTools: '未配置支持命令的 AI 工具',
         commandSupportedList: '支持命令的工具：OpenCode、Copilot、Roo Code、Gemini CLI',
-        commandsInstalled: '个命令'
+        commandsInstalled: '个命令',
+        // Smart apply
+        applyChangesNow: '是否立即应用变更？（重新生成集成文件）',
+        runUpdateLater: '稍后执行 `uds update --integrations-only` 以应用变更',
+        applyingChanges: '正在应用变更...',
+        changesApplied: '变更应用成功'
       }
     }
   }