@ryuenn3123/agentic-senior-core 2.0.24 → 2.0.26

package/.agent-context/review-checklists/frontend-excellence-rubric.md

@@ -0,0 +1,54 @@
+# Frontend Excellence Rubric (Designer-Grade)
+
+Use this rubric to prevent template-like UI output and enforce intentional product design quality.
+
+## Scoring Model
+
+Score each dimension from 1 to 5.
+- 1: weak or generic quality
+- 3: acceptable production baseline
+- 5: standout quality comparable to top manual design teams
+
+Release recommendation:
+- Minimum average score: 4.0
+- No dimension below: 3
+
+## 1. Visual Direction and Identity
+- [ ] The page has a clear visual direction, not a generic starter layout.
+- [ ] Composition, rhythm, and hierarchy feel intentional across sections.
+- [ ] The output avoids obvious design-template repetition.
+
+## 2. Typography Quality
+- [ ] Font pairing is intentional and role-based (display, body, utility).
+- [ ] Type scale is coherent across mobile and desktop.
+- [ ] Line length, spacing, and emphasis improve readability and scanning.
+
+## 3. Color System Diversity and Contrast
+- [ ] Color palette is purposeful, with semantic roles and contrast-safe pairings.
+- [ ] The result is not a default AI palette or copied trendy scheme without adaptation.
+- [ ] Accent usage supports product intent and interaction priority.
+
+## 4. Interaction Choreography
+- [ ] Motion supports comprehension and hierarchy, not decorative noise.
+- [ ] Entrance and transition timing are consistent and measured.
+- [ ] Reduced-motion fallback preserves usability.
+
+## 5. Responsiveness and Layout Intelligence
+- [ ] Mobile layout is designed, not desktop squeezed into a narrow viewport.
+- [ ] Breakpoint transitions preserve hierarchy, spacing rhythm, and action clarity.
+- [ ] Navigation and key CTA remain explicit across viewport sizes.
+
+## 6. UX Narrative and Conversion Clarity
+- [ ] First viewport communicates value proposition and primary action immediately.
+- [ ] Error, empty, and loading states provide clear next actions.
+- [ ] User journey avoids dead ends and hidden critical actions.
+
+## Benchmark Expectation
+- Treat MiniMax frontend references as baseline, not target ceiling.
+- Target visual and interaction quality aligned with top award-grade manual design workflows (Awwwards-level reference quality).
+- Prefer original composition and branded design systems over template cloning.
+
+## Evidence for Release
+- [ ] Rubric scorecard attached to release artifact.
+- [ ] Screenshot set across key breakpoints attached.
+- [ ] Accessibility and performance evidence attached alongside rubric score.

package/.agent-context/review-checklists/frontend-skill-parity.md

@@ -25,4 +25,5 @@ Use this checklist to enforce mandatory frontend parity aligned with benchmark-d
 ## Release Evidence
 - [ ] Frontend parity checklist artifact is attached to release evidence.
 - [ ] Frontend usability audit report is attached to release evidence.
+- [ ] Frontend excellence rubric scorecard is attached to release evidence.
 - [ ] Any parity waiver includes owner, expiry, and risk statement.

package/.agent-context/review-checklists/frontend-usability.md

@@ -31,3 +31,4 @@ Run this checklist before claiming frontend work is production-ready.
 - [ ] Frontend architecture decision is documented.
 - [ ] Visual baseline update process is documented.
 - [ ] Release note includes usability and responsiveness evidence.
+- [ ] Frontend excellence rubric scorecard is attached with release evidence.

package/.agent-context/rules/docker-runtime.md

@@ -0,0 +1,29 @@
+# Docker Runtime Strategy (Dynamic Generation Required)
+
+Use this rule when Docker is enabled in project context.
+
+## 1. Dynamic Generation Only
+- Do not copy generic Docker templates blindly.
+- Generate Docker assets based on actual stack, package manager, and runtime dependencies in the repository.
+- Re-evaluate Docker instructions when dependencies, build tools, or runtime assumptions change.
+
+## 2. Separate Development and Production Lanes
+- Development lane and production lane are separate concerns.
+- Development lane priorities: fast rebuild, hot reload support, debugger-friendly startup, local volume strategy.
+- Production lane priorities: minimal image size, reproducible build, non-root runtime, strict startup command.
+
+## 3. Security and Supply Chain
+- Use minimal trusted base images with explicit versions.
+- Use multi-stage builds for production images when possible.
+- Avoid baking secrets into image layers.
+- Keep runtime image free from build-only tooling.
+
+## 4. Operational Clarity
+- Docker instructions must document expected entrypoint and exposed ports.
+- Local development command and production deployment command must be explicit.
+- If Docker is not selected for the project, do not force containerization tasks.
+
+## 5. Review Requirements
+- Verify the generated Docker workflow matches selected runtime environment (Linux/WSL, Windows, macOS).
+- Verify development and production instructions are not mixed into one unsafe image path.
+- Ensure API and service health checks are compatible with container startup behavior.

package/.agent-context/skills/frontend/README.md

@@ -16,6 +16,7 @@ The frontend domain covers component architecture, state management, performance
 - Anti-Slop Enforcer (ABOVE LINE) - Detect forbidden visual patterns and style drift
 - Accessibility Auditor (ABOVE LINE) - Detect contrast failures, ARIA issues, and keyboard navigation gaps
 - Performance Budget Enforcer (ABOVE LINE) - Bundle size gates and LCP/FID/CLS thresholds
+- Frontend Excellence Rubric (ABOVE LINE) - Designer-grade scoring for visual direction, typography, color diversity, and interaction choreography
 
 ## Recommended Reading Order
 

package/.agent-context/skills/frontend.md

@@ -4,6 +4,7 @@ Default tier: `advance`
 
 ## Purpose
 Deliver frontend experiences that are visually intentional, accessible, and efficient.
+Target designer-grade quality comparable to high-signal manual design workflows.
 
 ## In Scope
 - UI architecture and component composition
@@ -21,6 +22,8 @@ Deliver frontend experiences that are visually intentional, accessible, and effi
 - Reduced-motion fallback
 - Accessibility baseline pass
 - Responsive behavior verified on mobile and desktop
+- Visual direction is explicit and not a generic AI template pattern
+- Typography and color system choices are intentional and contrast-safe
 - First viewport communicates value proposition and primary action clearly
 - Error and empty states provide explicit next actions
 - Performance budget and regression thresholds are documented per release
@@ -29,6 +32,7 @@ Deliver frontend experiences that are visually intentional, accessible, and effi
 - Usability audit result
 - Visual regression output
 - Accessibility checklist result
+- Frontend excellence rubric scorecard
 - Release notes for motion and interaction changes
 - Performance trend snapshot and remediation notes when regressions occur
 

package/.cursorrules

@@ -1,6 +1,6 @@
 # AGENTIC-SENIOR-CORE DYNAMIC GOVERNANCE RULESET
 
-Generated by Agentic-Senior-Core CLI v2.0.24
+Generated by Agentic-Senior-Core CLI v2.0.26
 Timestamp: 2026-04-15T00:14:51.184Z
 Selected profile: beginner
 Selected policy file: .agent-context/policies/llm-judge-threshold.json

package/.github/workflows/benchmark-detection.yml

@@ -30,9 +30,16 @@ jobs:
           node ./scripts/detection-benchmark.mjs > detection-benchmark-report.json
           test -s detection-benchmark-report.json
 
+      - name: Run benchmark anti-regression gate
+        run: |
+          node ./scripts/benchmark-gate.mjs > benchmark-gate-report.json
+          test -s benchmark-gate-report.json
+
       - name: Upload benchmark artifact
         if: always()
         uses: actions/upload-artifact@v4
         with:
           name: detection-benchmark-report
-          path: detection-benchmark-report.json
+          path: |
+            detection-benchmark-report.json
+            benchmark-gate-report.json

package/.windsurfrules

@@ -1,6 +1,6 @@
 # AGENTIC-SENIOR-CORE DYNAMIC GOVERNANCE RULESET
 
-Generated by Agentic-Senior-Core CLI v2.0.24
+Generated by Agentic-Senior-Core CLI v2.0.26
 Timestamp: 2026-04-15T00:14:51.184Z
 Selected profile: beginner
 Selected policy file: .agent-context/policies/llm-judge-threshold.json

package/README.md

@@ -142,6 +142,13 @@ npx @ryuenn3123/agentic-senior-core init --newbie
 
 - `init` creates governance files **in your project folder** (the folder where you run the command).
 - `init` does not copy repository workflows from this project into your target repository.
+- For fresh projects, `init` asks what you are building first (API, web, mobile, CLI, library) and filters stack choices to match that scope.
+- For mobile scope, stack choices are limited to mobile-relevant options (`react-native`, `flutter`).
+- For existing projects, `init` auto-applies detected stack signals (including additional stack signals for polyglot repositories) so you do not need to re-select language manually.
+- For web projects, `init` can capture separate frontend and backend stacks plus separate frontend/backend blueprints, and keeps this dual architecture context in the onboarding report.
+- `init` detects runtime environment (Linux/WSL, Windows, macOS) and supports explicit override with `--runtime-env`.
+- Project discovery now captures Docker strategy (none, development-only, production-only, both) and keeps development and production container intent separated.
+- Docker setup is expected to be generated dynamically by AI from real project context, not fixed static templates.
 - `init` project discovery accepts answers in any language; prompts stay in English, but non-English answers are supported.
 - Generated docs default to English for consistency; use `--docs-lang` only when you explicitly need a different output language.
 - After docs scaffolding, CLI prints prompt starter examples so users can iterate by prompt without rewriting full project context.

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.`);