@ryuenn3123/agentic-senior-core 2.0.25 → 2.0.27

package/lib/cli/commands/init.mjs

@@ -12,6 +12,13 @@ import {
   INIT_PRESETS,
   PROFILE_PRESETS,
   BLUEPRINT_RECOMMENDATIONS,
+  PROJECT_SCOPE_CHOICES,
+  PROJECT_SCOPE_STACK_FILTERS,
+  WEB_FRONTEND_STACK_CANDIDATES,
+  WEB_BACKEND_STACK_CANDIDATES,
+  WEB_FRONTEND_BLUEPRINT_CANDIDATES,
+  WEB_BACKEND_BLUEPRINT_CANDIDATES,
+  RUNTIME_ENVIRONMENT_CHOICES,
 } from '../constants.mjs';
 
 import {
@@ -70,6 +77,8 @@ export function parseInitArguments(commandArguments) {
     docsLang: 'en',
     docsLangProvided: false,
     projectConfig: undefined,
+    runtimeEnv: 'auto',
+    runtimeEnvProvided: false,
   };
 
   for (let argumentIndex = 0; argumentIndex < commandArguments.length; argumentIndex++) {
@@ -212,6 +221,19 @@ export function parseInitArguments(commandArguments) {
       continue;
     }
 
+    if (currentArgument === '--runtime-env') {
+      parsedInitOptions.runtimeEnv = commandArguments[argumentIndex + 1] || 'auto';
+      parsedInitOptions.runtimeEnvProvided = true;
+      argumentIndex += 1;
+      continue;
+    }
+
+    if (currentArgument.startsWith('--runtime-env=')) {
+      parsedInitOptions.runtimeEnv = currentArgument.split('=')[1] || 'auto';
+      parsedInitOptions.runtimeEnvProvided = true;
+      continue;
+    }
+
     throw new Error(`Unknown option: ${currentArgument}`);
   }
 
@@ -224,12 +246,163 @@ export function parseInitArguments(commandArguments) {
     throw new Error('--docs-lang must be one of: en, id');
   }
 
+  const normalizedRuntimeEnvironment = normalizeRuntimeEnvironmentKey(parsedInitOptions.runtimeEnv || 'auto');
+  if (!normalizedRuntimeEnvironment) {
+    throw new Error('--runtime-env must be one of: auto, linux-wsl, linux, windows, macos');
+  }
+
   parsedInitOptions.docsLang = normalizedDocsLanguage;
+  parsedInitOptions.runtimeEnv = normalizedRuntimeEnvironment;
   parsedInitOptions.tokenAgent = normalizeAgentName(parsedInitOptions.tokenAgent);
 
   return parsedInitOptions;
 }
 
+export function filterStackFileNamesByCandidates(allStackFileNames, preferredStackFileNames) {
+  if (!Array.isArray(preferredStackFileNames) || preferredStackFileNames.length === 0) {
+    return allStackFileNames;
+  }
+
+  const filteredStackFileNames = preferredStackFileNames.filter((stackFileName) => allStackFileNames.includes(stackFileName));
+  return filteredStackFileNames.length > 0 ? filteredStackFileNames : allStackFileNames;
+}
+
+export function filterBlueprintFileNamesByCandidates(allBlueprintFileNames, preferredBlueprintFileNames) {
+  if (!Array.isArray(preferredBlueprintFileNames) || preferredBlueprintFileNames.length === 0) {
+    return allBlueprintFileNames;
+  }
+
+  const filteredBlueprintFileNames = preferredBlueprintFileNames.filter(
+    (blueprintFileName) => allBlueprintFileNames.includes(blueprintFileName)
+  );
+
+  return filteredBlueprintFileNames.length > 0 ? filteredBlueprintFileNames : allBlueprintFileNames;
+}
+
+export function normalizeRuntimeEnvironmentKey(rawRuntimeEnvironmentKey) {
+  const normalizedRuntimeEnvironmentKey = normalizeChoiceInput(String(rawRuntimeEnvironmentKey || 'auto'));
+  const supportedRuntimeEnvironmentKeys = new Set(['auto', 'linux-wsl', 'linux', 'windows', 'macos']);
+  return supportedRuntimeEnvironmentKeys.has(normalizedRuntimeEnvironmentKey) ? normalizedRuntimeEnvironmentKey : null;
+}
+
+export function resolveRuntimeEnvironmentKeyFromLabel(selectedRuntimeEnvironmentLabel) {
+  const runtimeEnvironmentEntry = RUNTIME_ENVIRONMENT_CHOICES.find(
+    (runtimeEnvironmentChoice) => runtimeEnvironmentChoice.label === selectedRuntimeEnvironmentLabel
+  );
+
+  return runtimeEnvironmentEntry?.key || null;
+}
+
+export function resolveRuntimeEnvironmentLabelFromKey(runtimeEnvironmentKey) {
+  const runtimeEnvironmentEntry = RUNTIME_ENVIRONMENT_CHOICES.find(
+    (runtimeEnvironmentChoice) => runtimeEnvironmentChoice.key === runtimeEnvironmentKey
+  );
+
+  return runtimeEnvironmentEntry?.label || runtimeEnvironmentKey;
+}
+
+export function detectRuntimeEnvironment() {
+  const isWslEnvironment = Boolean(process.env.WSL_DISTRO_NAME || process.env.WSL_INTEROP || process.env.__IS_WSL_TEST__);
+
+  if (isWslEnvironment) {
+    return {
+      key: 'linux-wsl',
+      label: resolveRuntimeEnvironmentLabelFromKey('linux-wsl'),
+      shellFamily: 'bash',
+      isAutoDetected: true,
+      source: 'WSL environment markers',
+    };
+  }
+
+  if (process.platform === 'win32') {
+    return {
+      key: 'windows',
+      label: resolveRuntimeEnvironmentLabelFromKey('windows'),
+      shellFamily: 'powershell',
+      isAutoDetected: true,
+      source: 'process.platform',
+    };
+  }
+
+  if (process.platform === 'darwin') {
+    return {
+      key: 'macos',
+      label: resolveRuntimeEnvironmentLabelFromKey('macos'),
+      shellFamily: 'bash',
+      isAutoDetected: true,
+      source: 'process.platform',
+    };
+  }
+
+  return {
+    key: 'linux',
+    label: resolveRuntimeEnvironmentLabelFromKey('linux'),
+    shellFamily: 'bash',
+    isAutoDetected: true,
+    source: 'process.platform',
+  };
+}
+
+export function resolveProjectScopeKeyFromLabel(selectedProjectScopeLabel) {
+  const projectScopeEntry = PROJECT_SCOPE_CHOICES.find((scopeChoice) => scopeChoice.label === selectedProjectScopeLabel);
+  return projectScopeEntry?.key || 'other';
+}
+
+export function normalizeAdditionalStackSelection(selectedStackFileName, additionalStackFileNames) {
+  if (!Array.isArray(additionalStackFileNames) || additionalStackFileNames.length === 0) {
+    return [];
+  }
+
+  return Array.from(new Set(additionalStackFileNames.filter((stackFileName) => stackFileName && stackFileName !== selectedStackFileName)));
+}
+
+export function normalizeAdditionalBlueprintSelection(selectedBlueprintFileName, additionalBlueprintFileNames) {
+  if (!Array.isArray(additionalBlueprintFileNames) || additionalBlueprintFileNames.length === 0) {
+    return [];
+  }
+
+  return Array.from(new Set(additionalBlueprintFileNames.filter(
+    (blueprintFileName) => blueprintFileName && blueprintFileName !== selectedBlueprintFileName
+  )));
+}
+
+function deriveAdditionalBlueprintFileNamesFromStacks(additionalStackFileNames, allBlueprintFileNames, selectedBlueprintFileName) {
+  const derivedBlueprintFileNames = [];
+
+  for (const additionalStackFileName of additionalStackFileNames || []) {
+    const mappedBlueprintFileName = BLUEPRINT_RECOMMENDATIONS[additionalStackFileName];
+    if (!mappedBlueprintFileName) {
+      continue;
+    }
+
+    if (!allBlueprintFileNames.includes(mappedBlueprintFileName)) {
+      continue;
+    }
+
+    if (mappedBlueprintFileName === selectedBlueprintFileName) {
+      continue;
+    }
+
+    derivedBlueprintFileNames.push(mappedBlueprintFileName);
+  }
+
+  return Array.from(new Set(derivedBlueprintFileNames));
+}
+
+async function askStackSelection(promptMessage, selectableStackFileNames, userInterface) {
+  const stackDisplayChoices = selectableStackFileNames.map((stackFileName) => toTitleCase(stackFileName));
+  const selectedDisplayChoice = await askChoice(promptMessage, stackDisplayChoices, userInterface);
+  const selectedIndex = stackDisplayChoices.indexOf(selectedDisplayChoice);
+  return selectableStackFileNames[selectedIndex] || selectableStackFileNames[0] || null;
+}
+
+async function askBlueprintSelection(promptMessage, selectableBlueprintFileNames, userInterface) {
+  const blueprintDisplayChoices = selectableBlueprintFileNames.map((blueprintFileName) => toTitleCase(blueprintFileName));
+  const selectedDisplayChoice = await askChoice(promptMessage, blueprintDisplayChoices, userInterface);
+  const selectedIndex = blueprintDisplayChoices.indexOf(selectedDisplayChoice);
+  return selectableBlueprintFileNames[selectedIndex] || selectableBlueprintFileNames[0] || null;
+}
+
 export async function runInitCommand(targetDirectoryArgument, initOptions = {}) {
   const resolvedTargetDirectoryPath = path.resolve(targetDirectoryArgument || '.');
   const isTokenOptimizationEnabled = typeof initOptions.tokenOptimize === 'boolean'
@@ -326,6 +499,30 @@ export async function runInitCommand(targetDirectoryArgument, initOptions = {})
       console.log('The target directory is empty, so I will guide you through a fresh setup.');
     }
 
+    const detectedRuntimeEnvironment = detectRuntimeEnvironment();
+    let selectedRuntimeEnvironmentKey = initOptions.runtimeEnv === 'auto'
+      ? detectedRuntimeEnvironment.key
+      : initOptions.runtimeEnv;
+
+    if (isInteractiveSession && !initOptions.runtimeEnvProvided) {
+      const defaultRuntimeEnvironmentLabel = resolveRuntimeEnvironmentLabelFromKey(selectedRuntimeEnvironmentKey);
+      const orderedRuntimeEnvironmentChoices = [
+        defaultRuntimeEnvironmentLabel,
+        ...RUNTIME_ENVIRONMENT_CHOICES
+          .map((runtimeEnvironmentChoice) => runtimeEnvironmentChoice.label)
+          .filter((runtimeEnvironmentLabel) => runtimeEnvironmentLabel !== defaultRuntimeEnvironmentLabel),
+      ];
+
+      const selectedRuntimeEnvironmentLabel = await askChoice(
+        `Runtime environment (auto-detected: ${defaultRuntimeEnvironmentLabel}).`,
+        orderedRuntimeEnvironmentChoices,
+        userInterface
+      );
+
+      selectedRuntimeEnvironmentKey = resolveRuntimeEnvironmentKeyFromLabel(selectedRuntimeEnvironmentLabel)
+        || selectedRuntimeEnvironmentKey;
+    }
+
     const selectedProfileName = initOptions.profile
       ? initOptions.profile
       : selectedPreset?.profile
@@ -353,29 +550,130 @@ export async function runInitCommand(targetDirectoryArgument, initOptions = {})
       console.log(`Pack defaults: stack ${toTitleCase(selectedProfilePack.defaultStackFileName)}, blueprint ${toTitleCase(selectedProfilePack.defaultBlueprintFileName)}.`);
     }
 
-    const shouldApplyDetectedStack = projectDetection.recommendedStackFileName && !selectedStackFileNameFromOption
-      ? await askYesNo(
-        `Use the detected stack recommendation (${toTitleCase(projectDetection.recommendedStackFileName)})?`,
-        userInterface,
-        projectDetection.confidenceLabel === 'high'
-      )
-      : false;
+    const hasReliableDetectedStack = projectDetection.hasExistingProjectFiles
+      && projectDetection.recommendedStackFileName
+      && (projectDetection.confidenceLabel === 'high' || projectDetection.confidenceLabel === 'medium');
+
+    const shouldAutoApplyDetectedStack = hasReliableDetectedStack
+      && !selectedStackFileNameFromOption
+      && !selectedPreset?.stack
+      && !selectedProfilePack?.defaultStackFileName;
+
+    let selectedManualStackFileName = null;
+    let selectedManualBlueprintFileName = null;
+    let selectedAdditionalStackFileNames = [];
+    let selectedAdditionalBlueprintFileNames = [];
+
+    const shouldAskManualStackSelection = !selectedStackFileNameFromOption
+      && !selectedPreset?.stack
+      && !shouldAutoApplyDetectedStack
+      && !selectedProfilePack?.defaultStackFileName
+      && !selectedProfile.defaultStackFileName;
+
+    if (shouldAutoApplyDetectedStack) {
+      console.log(`Using detected stack automatically for this existing project: ${toTitleCase(projectDetection.recommendedStackFileName)}.`);
+      if (projectDetection.secondaryStackFileNames?.length) {
+        console.log(`Detected additional stack signals: ${projectDetection.secondaryStackFileNames.map((stackFileName) => toTitleCase(stackFileName)).join(', ')}.`);
+      }
+      selectedAdditionalStackFileNames = projectDetection.secondaryStackFileNames || [];
+    }
+
+    if (shouldAskManualStackSelection) {
+      const selectedProjectScopeLabel = await askChoice(
+        'What are you building?',
+        PROJECT_SCOPE_CHOICES.map((scopeChoice) => scopeChoice.label),
+        userInterface
+      );
+      const selectedProjectScopeKey = resolveProjectScopeKeyFromLabel(selectedProjectScopeLabel);
+      const scopeStackFilter = PROJECT_SCOPE_STACK_FILTERS[selectedProjectScopeKey];
+      const scopedStackFileNames = filterStackFileNamesByCandidates(stackFileNames, scopeStackFilter);
+
+      if (selectedProjectScopeKey === 'web-application') {
+        const usesSplitWebStacks = await askYesNo(
+          'For this web project, do frontend and backend use different primary stacks?',
+          userInterface,
+          false
+        );
+
+        if (usesSplitWebStacks) {
+          const selectableFrontendStacks = filterStackFileNamesByCandidates(scopedStackFileNames, WEB_FRONTEND_STACK_CANDIDATES);
+          const selectableBackendStacks = filterStackFileNamesByCandidates(scopedStackFileNames, WEB_BACKEND_STACK_CANDIDATES);
+
+          const selectedFrontendStackFileName = await askStackSelection(
+            'Which frontend stack should this governance pack target?',
+            selectableFrontendStacks,
+            userInterface
+          );
+          const selectedBackendStackFileName = await askStackSelection(
+            'Which backend stack should this governance pack target?',
+            selectableBackendStacks,
+            userInterface
+          );
+
+          selectedManualStackFileName = selectedBackendStackFileName;
+          if (selectedFrontendStackFileName && selectedFrontendStackFileName !== selectedBackendStackFileName) {
+            selectedAdditionalStackFileNames = [selectedFrontendStackFileName];
+          }
+
+          if (!selectedBlueprintFileNameFromOption && !selectedPreset?.blueprint) {
+            const selectableFrontendBlueprints = filterBlueprintFileNamesByCandidates(
+              blueprintFileNames,
+              WEB_FRONTEND_BLUEPRINT_CANDIDATES
+            );
+            const selectableBackendBlueprints = filterBlueprintFileNamesByCandidates(
+              blueprintFileNames,
+              WEB_BACKEND_BLUEPRINT_CANDIDATES
+            );
+
+            const selectedFrontendBlueprintFileName = await askBlueprintSelection(
+              'Which frontend blueprint should guide UI architecture?',
+              selectableFrontendBlueprints,
+              userInterface
+            );
+            const selectedBackendBlueprintFileName = await askBlueprintSelection(
+              'Which backend blueprint should guide service architecture?',
+              selectableBackendBlueprints,
+              userInterface
+            );
+
+            selectedManualBlueprintFileName = selectedBackendBlueprintFileName;
+            if (selectedFrontendBlueprintFileName && selectedFrontendBlueprintFileName !== selectedBackendBlueprintFileName) {
+              selectedAdditionalBlueprintFileNames = [selectedFrontendBlueprintFileName];
+            }
+          }
+        } else {
+          selectedManualStackFileName = await askStackSelection(
+            'Which stack should this governance pack target?',
+            scopedStackFileNames,
+            userInterface
+          );
+        }
+      } else {
+        selectedManualStackFileName = await askStackSelection(
+          'Which stack should this governance pack target?',
+          scopedStackFileNames,
+          userInterface
+        );
+      }
+    }
 
-    const stackDisplayChoices = stackFileNames.map((stackFileName) => toTitleCase(stackFileName));
     const blueprintDisplayChoices = blueprintFileNames.map((blueprintFileName) => toTitleCase(blueprintFileName));
 
     const selectedResolvedStackFileName = selectedStackFileNameFromOption
       || selectedPreset?.stack
-      || (shouldApplyDetectedStack ? projectDetection.recommendedStackFileName : null)
+      || (shouldAutoApplyDetectedStack ? projectDetection.recommendedStackFileName : null)
       || selectedProfilePack?.defaultStackFileName
       || selectedProfile.defaultStackFileName
-      || stackFileNames[
-        stackDisplayChoices.indexOf(
-          await askChoice('Which stack should this governance pack target?', stackDisplayChoices, userInterface)
-        )
-      ];
+      || selectedManualStackFileName
+      || stackFileNames[0];
 
-    const recommendedBlueprintFileName = shouldApplyDetectedStack
+    selectedAdditionalStackFileNames = normalizeAdditionalStackSelection(
+      selectedResolvedStackFileName,
+      selectedAdditionalStackFileNames
+    );
+
+    const recommendedBlueprintFileName = projectDetection.recommendedBlueprintFileName
+      && shouldAutoApplyDetectedStack
       ? projectDetection.recommendedBlueprintFileName
       : BLUEPRINT_RECOMMENDATIONS[selectedResolvedStackFileName] || null;
 
@@ -385,6 +683,7 @@ export async function runInitCommand(targetDirectoryArgument, initOptions = {})
 
     const selectedResolvedBlueprintFileName = selectedBlueprintFileNameFromOption
       || selectedPreset?.blueprint
+      || selectedManualBlueprintFileName
       || recommendedBlueprintFileName
       || selectedProfilePack?.defaultBlueprintFileName
       || selectedProfile.defaultBlueprintFileName
@@ -394,9 +693,24 @@ export async function runInitCommand(targetDirectoryArgument, initOptions = {})
         )
       ];
 
+    const derivedAdditionalBlueprintFileNames = deriveAdditionalBlueprintFileNamesFromStacks(
+      selectedAdditionalStackFileNames,
+      blueprintFileNames,
+      selectedResolvedBlueprintFileName
+    );
+
+    selectedAdditionalBlueprintFileNames = normalizeAdditionalBlueprintSelection(
+      selectedResolvedBlueprintFileName,
+      selectedAdditionalBlueprintFileNames.length > 0
+        ? selectedAdditionalBlueprintFileNames
+        : derivedAdditionalBlueprintFileNames
+    );
+
     const selectedSkillDomainNames = inferSkillDomainNamesFromSelection(
       selectedResolvedStackFileName,
-      selectedResolvedBlueprintFileName
+      selectedResolvedBlueprintFileName,
+      selectedAdditionalStackFileNames,
+      selectedAdditionalBlueprintFileNames
     );
 
     const includeCiGuardrails = typeof initOptions.ci === 'boolean'
@@ -494,7 +808,11 @@ export async function runInitCommand(targetDirectoryArgument, initOptions = {})
           discoveryAnswers,
           {
             stackFileName: selectedResolvedStackFileName,
+            additionalStackFileNames: selectedAdditionalStackFileNames,
             blueprintFileName: selectedResolvedBlueprintFileName,
+            additionalBlueprintFileNames: selectedAdditionalBlueprintFileNames,
+            runtimeEnvironmentKey: selectedRuntimeEnvironmentKey,
+            runtimeEnvironmentLabel: resolveRuntimeEnvironmentLabelFromKey(selectedRuntimeEnvironmentKey),
           },
           {
             docsLanguage: selectedDocsLanguage,
@@ -513,7 +831,9 @@ export async function runInitCommand(targetDirectoryArgument, initOptions = {})
       selectedProfileName,
       selectedProfilePack,
       selectedStackFileName: selectedResolvedStackFileName,
+      selectedAdditionalStackFileNames,
       selectedBlueprintFileName: selectedResolvedBlueprintFileName,
+      selectedAdditionalBlueprintFileNames,
       includeCiGuardrails,
     });
 
@@ -526,12 +846,21 @@ export async function runInitCommand(targetDirectoryArgument, initOptions = {})
       selectedProfilePack,
       selectedPreset: initOptions.preset || null,
       selectedStackFileName: selectedResolvedStackFileName,
+      selectedAdditionalStackFileNames,
       selectedBlueprintFileName: selectedResolvedBlueprintFileName,
+      selectedAdditionalBlueprintFileNames,
       includeCiGuardrails,
       setupDurationMs,
       projectDetection,
       selectedSkillDomains: selectedSkillDomainNames,
       compatibilityWarnings,
+      runtimeEnvironment: {
+        selected: selectedRuntimeEnvironmentKey,
+        selectedLabel: resolveRuntimeEnvironmentLabelFromKey(selectedRuntimeEnvironmentKey),
+        detected: detectedRuntimeEnvironment.key,
+        detectedLabel: detectedRuntimeEnvironment.label,
+        detectionSource: detectedRuntimeEnvironment.source,
+      },
       operationMode: 'init',
     });
 
@@ -545,7 +874,14 @@ export async function runInitCommand(targetDirectoryArgument, initOptions = {})
       console.log(`- Team profile pack: ${selectedProfilePack.displayName}`);
     }
     console.log(`- Stack: ${toTitleCase(selectedResolvedStackFileName)}`);
+    if (selectedAdditionalStackFileNames.length > 0) {
+      console.log(`- Additional stacks: ${selectedAdditionalStackFileNames.map((stackFileName) => toTitleCase(stackFileName)).join(', ')}`);
+    }
     console.log(`- Blueprint: ${toTitleCase(selectedResolvedBlueprintFileName)}`);
+    if (selectedAdditionalBlueprintFileNames.length > 0) {
+      console.log(`- Additional blueprints: ${selectedAdditionalBlueprintFileNames.map((blueprintFileName) => toTitleCase(blueprintFileName)).join(', ')}`);
+    }
+    console.log(`- Runtime environment: ${resolveRuntimeEnvironmentLabelFromKey(selectedRuntimeEnvironmentKey)} (detected: ${detectedRuntimeEnvironment.label})`);
     console.log(`- CI/CD guardrails: ${includeCiGuardrails ? 'enabled' : 'disabled'}`);
     console.log(`- Blocking severities: ${formatBlockingSeverities(selectedProfile.blockingSeverities)}`);
     console.log(`- Setup time: ${formatDuration(setupDurationMs)}`);
@@ -563,6 +899,12 @@ export async function runInitCommand(targetDirectoryArgument, initOptions = {})
     }
     console.log('\nPlain-language summary:');
     console.log(`I prepared a ${selectedProfile.displayName.toLowerCase()} governance pack for a ${toTitleCase(selectedResolvedStackFileName)} project using the ${toTitleCase(selectedResolvedBlueprintFileName)} blueprint.`);
+    if (selectedAdditionalStackFileNames.length > 0) {
+      console.log(`I also included additional stack context for ${selectedAdditionalStackFileNames.map((stackFileName) => toTitleCase(stackFileName)).join(', ')}.`);
+    }
+    if (selectedAdditionalBlueprintFileNames.length > 0) {
+      console.log(`I also included additional blueprint context for ${selectedAdditionalBlueprintFileNames.map((blueprintFileName) => toTitleCase(blueprintFileName)).join(', ')}.`);
+    }
     if (scaffoldingResult) {
       console.log(`I also generated project documentation (${scaffoldingResult.docsLanguage}) based on your project description. AI agents will use docs/ as project context.`);
 

package/lib/cli/commands/optimize.mjs

@@ -119,7 +119,17 @@ export async function runOptimizeCommand(targetDirectoryArgument, optimizeOption
     ? onboardingReport.selectedProfile
     : 'balanced';
   const selectedStackFileName = normalizeMarkdownFileName(onboardingReport.selectedStack, 'typescript.md');
+  const selectedAdditionalStackFileNames = Array.isArray(onboardingReport.selectedAdditionalStacks)
+    ? onboardingReport.selectedAdditionalStacks
+      .map((stackFileName) => normalizeMarkdownFileName(stackFileName, ''))
+      .filter((stackFileName) => stackFileName && stackFileName !== selectedStackFileName)
+    : [];
   const selectedBlueprintFileName = normalizeMarkdownFileName(onboardingReport.selectedBlueprint, 'api-nextjs.md');
+  const selectedAdditionalBlueprintFileNames = Array.isArray(onboardingReport.selectedAdditionalBlueprints)
+    ? onboardingReport.selectedAdditionalBlueprints
+      .map((blueprintFileName) => normalizeMarkdownFileName(blueprintFileName, ''))
+      .filter((blueprintFileName) => blueprintFileName && blueprintFileName !== selectedBlueprintFileName)
+    : [];
   const includeCiGuardrails = typeof onboardingReport.ciGuardrailsEnabled === 'boolean'
     ? onboardingReport.ciGuardrailsEnabled
     : true;
@@ -128,7 +138,9 @@ export async function runOptimizeCommand(targetDirectoryArgument, optimizeOption
     targetDirectoryPath: resolvedTargetDirectoryPath,
     selectedProfileName,
     selectedStackFileName,
+    selectedAdditionalStackFileNames,
     selectedBlueprintFileName,
+    selectedAdditionalBlueprintFileNames,
     includeCiGuardrails,
   });
 

package/lib/cli/commands/upgrade.mjs

@@ -119,17 +119,35 @@ export async function runUpgradeCommand(targetDirectoryArgument, upgradeOptions
       ? existingOnboardingReport.selectedStack
       : projectDetection.recommendedStackFileName || 'typescript.md';
 
+    const selectedAdditionalStackFileNames = Array.isArray(existingOnboardingReport?.selectedAdditionalStacks)
+      ? Array.from(new Set(existingOnboardingReport.selectedAdditionalStacks.filter(
+        (stackFileName) => stackFileNames.includes(stackFileName) && stackFileName !== selectedStackFileName
+      )))
+      : Array.from(new Set((projectDetection.secondaryStackFileNames || []).filter(
+        (stackFileName) => stackFileNames.includes(stackFileName) && stackFileName !== selectedStackFileName
+      )));
+
     const selectedBlueprintFileName = blueprintFileNames.includes(existingOnboardingReport?.selectedBlueprint)
       ? existingOnboardingReport.selectedBlueprint
       : BLUEPRINT_RECOMMENDATIONS[selectedStackFileName] || 'api-nextjs.md';
 
+    const selectedAdditionalBlueprintFileNames = Array.isArray(existingOnboardingReport?.selectedAdditionalBlueprints)
+      ? Array.from(new Set(existingOnboardingReport.selectedAdditionalBlueprints.filter(
+        (blueprintFileName) => blueprintFileNames.includes(blueprintFileName) && blueprintFileName !== selectedBlueprintFileName
+      )))
+      : Array.from(new Set(selectedAdditionalStackFileNames
+        .map((stackFileName) => BLUEPRINT_RECOMMENDATIONS[stackFileName] || null)
+        .filter((blueprintFileName) => blueprintFileName && blueprintFileName !== selectedBlueprintFileName)));
+
     const includeCiGuardrails = typeof existingOnboardingReport?.ciGuardrailsEnabled === 'boolean'
       ? existingOnboardingReport.ciGuardrailsEnabled
       : true;
 
     const selectedSkillDomainNames = inferSkillDomainNamesFromSelection(
       selectedStackFileName,
-      selectedBlueprintFileName
+      selectedBlueprintFileName,
+      selectedAdditionalStackFileNames,
+      selectedAdditionalBlueprintFileNames
     );
     const compatibilityWarnings = await evaluateSkillDomainCompatibility(
       resolvedTargetDirectoryPath,
@@ -154,7 +172,9 @@ export async function runUpgradeCommand(targetDirectoryArgument, upgradeOptions
       targetDirectoryPath: resolvedTargetDirectoryPath,
       selectedProfileName,
       selectedStackFileName,
+      selectedAdditionalStackFileNames,
       selectedBlueprintFileName,
+      selectedAdditionalBlueprintFileNames,
       includeCiGuardrails,
     });
 
@@ -166,7 +186,13 @@ export async function runUpgradeCommand(targetDirectoryArgument, upgradeOptions
     console.log(`- Target directory: ${resolvedTargetDirectoryPath}`);
     console.log(`- Profile: ${toTitleCase(selectedProfileName)}`);
     console.log(`- Stack: ${toTitleCase(selectedStackFileName)}`);
+    if (selectedAdditionalStackFileNames.length > 0) {
+      console.log(`- Additional stacks: ${selectedAdditionalStackFileNames.map((stackFileName) => toTitleCase(stackFileName)).join(', ')}`);
+    }
     console.log(`- Blueprint: ${toTitleCase(selectedBlueprintFileName)}`);
+    if (selectedAdditionalBlueprintFileNames.length > 0) {
+      console.log(`- Additional blueprints: ${selectedAdditionalBlueprintFileNames.map((blueprintFileName) => toTitleCase(blueprintFileName)).join(', ')}`);
+    }
     console.log(`- CI/CD guardrails: ${includeCiGuardrails ? 'enabled' : 'disabled'}`);
     console.log(`- Existing rules lines: ${currentRuleLineCount}`);
     console.log(`- Planned rules lines: ${plannedRuleLineCount}`);
@@ -213,12 +239,15 @@ export async function runUpgradeCommand(targetDirectoryArgument, upgradeOptions
         selectedProfileName,
         selectedProfilePack: existingOnboardingReport?.selectedProfilePack || null,
         selectedStackFileName,
+        selectedAdditionalStackFileNames,
         selectedBlueprintFileName,
+        selectedAdditionalBlueprintFileNames,
         includeCiGuardrails,
         setupDurationMs,
         projectDetection,
         selectedSkillDomains: selectedSkillDomainNames,
         compatibilityWarnings,
+        runtimeEnvironment: existingOnboardingReport?.runtimeEnvironment || null,
         operationMode: 'upgrade',
       });