fix: normalize skill proxy boolean column

changes/n03-skill-cloud/.superpowers/sdd/progress.md

@@ -27,3 +27,6 @@
 - 2026-09-15T03:29:18Z W3 wave review FAIL: duplicate operationId getMatch and 401 response contract mismatch; full-suite external blocker remains open.
 - 2026-09-15T03:40:12Z W3 rereview FAIL: N-I1 existing cancel operationIds changed by global uniqueness check; restore legacy and scope check to new operations.
 - 2026-09-15T03:46:09Z W3 final review PASS for T8-T10; 73 targeted tests and OpenAPI/package checks pass. W3 code complete. Final closure blocked by unrelated full-suite failures: 2 failures + 9 errors. Waiver or out-of-scope repair authorization required.
+- 2026-09-15T05:48:03Z Runtime startup bug: Hibernate schema validation failed on occupation_skills.importance_is_proxy (found BIT, expected TINYINT). Root cause: forced @JdbcTypeCode(SqlTypes.TINYINT) unlike existing Boolean mappings. Fix dispatched with mapping regression test.
+- 2026-09-15T06:03:54Z Runtime bug fix attempt 2: first fix removed forced TINYINT but H2 still stores TINYINT and expects BOOLEAN; 34 tests failed. New hypothesis: add V37 to normalize column to BOOLEAN (MySQL alias TINYINT(1)) and remove test-only preferred type override.
+- 2026-09-15T06:20:09Z Runtime startup fix PASS: V37 normalizes importance_is_proxy to cross-dialect BOOLEAN, entity uses default Boolean mapping; 74 targeted tests and package pass without extra JVM properties.

changes/n03-skill-cloud/.superpowers/sdd/reviews/runtime-startup-fix-review.md

@@ -0,0 +1,151 @@
+# N03 运行时启动缺陷修复独立复审报告
+
+## Verdict
+
+**PASS**
+
+运行时启动缺陷的本轮修复通过独立复审：实体不再强制 `TINYINT` 映射，V37 将 H2 侧列规范化为 `BOOLEAN`，MySQL 侧保持 `BOOLEAN/TINYINT(1)` 语义；标准 T2–T10 回归和跳过测试的打包均通过。完整 `mvn test` 仍有既有、非本次修复引入的失败，不能据此声称全量回归通过。
+
+## 审查对象
+
+- `mydreamjob-server/src/main/resources/db/migration/V37__skill_cloud_boolean_type.sql`
+- `mydreamjob-server/src/main/java/com/mydreamjob/skill/domain/OccupationSkill.java`
+- `SkillTaxonomyRepositoryTest.java`
+- `SkillTaxonomyMigrationTest.java`
+- `SkillCloudSeedDataIntegrationTest.java`
+- `SkillCloudQueryServiceTest.java`
+- 已有证据日志：`target/skill-cloud-v37-red.log`、`skill-cloud-v37-final-green.log`、`skill-cloud-v37-final-package.log`
+
+## 根因闭环
+
+原始启动失败为：
+
+```text
+Schema-validation: wrong column type encountered in column [importance_is_proxy]
+found [bit (Types#BIT)], but expecting [tinyint (Types#TINYINT)]
+```
+
+闭环判断：
+
+1. `OccupationSkill.importanceIsProxy` 原先使用显式 `@JdbcTypeCode(SqlTypes.TINYINT)`，把 Hibernate 的 JDBC 期望固定为 `TINYINT`。
+2. 本轮已移除该显式注解及其 import；字段仍是 `Boolean`，列名、可空性和其他字段映射未改变。
+3. 新回归测试同时断言：
+   - Hibernate 属性返回类型为 `Boolean.class`；
+   - 字段不再存在显式 `JdbcTypeCode` 注解。
+4. V37 将 `occupation_skills.importance_is_proxy` 规范化为 `BOOLEAN NOT NULL DEFAULT FALSE`，并重建原 CHECK 约束。H2 `MODE=MySQL` 下迁移测试确认元数据为 `BOOLEAN / FALSE / NO`。
+5. MySQL 8.0.43 临时实例实际执行同一 DDL 后，物理元数据为 `tinyint / tinyint(1) / default 0 / NO`，读写结果为默认 `0`、`FALSE=0`、`TRUE=1`。
+
+因此根因修复成立：实体不再强制 TINYINT；H2 使用真正的 BOOLEAN；MySQL 保留 BOOLEAN 别名对应的 TINYINT(1) 物理语义。
+
+## V35/V36 与 Flyway 安全检查
+
+独立比较结果：
+
+- `V35__skill_cloud_taxonomy.sql`：工作区与 `HEAD` 的 Git hash 均为 `db81f934...`，无差异。
+- `V36__skill_cloud_seed.sql`：工作区与 `HEAD` 的 Git hash 均为 `e4a03a40...`，无差异。
+- V35/V36 均未改写，已应用环境的 Flyway checksum 不受影响。
+- V37 为追加迁移，未修改历史迁移内容。
+
+H2 `MODE=MySQL` 兼容性由实际迁移与测试上下文启动验证；MySQL 兼容性由 MySQL 8.0.43 实例实际执行 `DROP CONSTRAINT`、`MODIFY COLUMN BOOLEAN`、`ADD CONSTRAINT` 验证。MySQL 8.4 未在本机安装，未做 8.4 二进制验证；所用 DDL 语法属于 MySQL 8.0/8.4 的通用受支持语法。
+
+## 布尔语义、默认值与 NULL 检查
+
+V37 的顺序为：
+
+1. 删除旧的 `ck_occupation_skills_importance_proxy`；
+2. 将列改为 `BOOLEAN NOT NULL DEFAULT FALSE`；
+3. 重建 `CHECK (importance_is_proxy IN (FALSE, TRUE))`。
+
+经验证：
+
+- 默认值：新行未显式赋值时为 `FALSE/0`。
+- 非空：迁移测试断言 `IS_NULLABLE=NO`，并将 NULL 更新验证为失败。
+- 布尔读写：`FALSE`、`TRUE` 可读写，查询结果与布尔比较均正确。
+- JDBC 断言：查询测试和种子数据测试已兼容 H2 返回 `Boolean` 以及旧驱动可能返回数值两种形式，不会因方言差异误判。
+- `preferred_boolean_jdbc_type=TINYINT`：源代码与配置中未发现该属性；标准测试命令不需要额外 `-D` 参数。
+
+## 独立测试与打包结果
+
+环境：
+
+```text
+JAVA_HOME=D:\java\jdk
+Maven=D:\maven\apache-maven-3.9.7\bin\mvn.cmd
+```
+
+### T2–T10 指定测试组
+
+在 `mydreamjob-server` 下执行，未附加任何布尔类型属性：
+
+```text
+mvn -Dtest=SkillCloudAuthorizationIntegrationTest,SkillCloudControllerTest,SkillCloudEndToEndIntegrationTest,SkillCloudQueryServiceTest,SkillCloudSeedDataIntegrationTest,SkillLearningPathServiceTest,SkillMatchServiceTest,SkillTaxonomyMigrationTest,SkillTaxonomyRepositoryTest test
+```
+
+结果：
+
+```text
+Tests run: 74, Failures: 0, Errors: 0, Skipped: 0
+BUILD SUCCESS
+Total time: 55.561 s
+```
+
+### 打包
+
+```text
+mvn -DskipTests package
+BUILD SUCCESS
+Total time: 2.439 s
+```
+
+### MySQL 8.0.43 冒烟
+
+实际执行结果：
+
+```text
+id  importance_is_proxy
+1   0
+2   0
+3   1
+
+DATA_TYPE  COLUMN_TYPE  COLUMN_DEFAULT  IS_NULLABLE
+tinyint    tinyint(1)   0               NO
+```
+
+说明：MySQL 将 `BOOLEAN` 规范化为 `tinyint(1)` 属正常行为；这与 V37 目标及 H2 的 `BOOLEAN` 元数据要求一致。
+
+## 完整 `mvn test` 状态
+
+独立执行完整命令：
+
+```text
+mvn test
+Tests run: 1396, Failures: 2, Errors: 9, Skipped: 0
+BUILD FAILURE
+```
+
+失败项仍为与本功能无关的既有问题：
+
+- `CareerProgressServiceTest.fullAggregation_returnsCorrectSummaries`：固定过期时间导致期望 1、实际 0。
+- `JobReviewDimensionControllerTest.listReviews_shouldReturnDimensionScores`：测试仍使用旧服务方法签名，返回 500。
+- `JobReviewDimensionServiceTest.listReviews_shouldReturnDimensionScoresWithoutN1`：测试仍 stub 旧 Repository 方法，结果为 null。
+- `LocalResumeStorageServiceTest`：Windows JUnit 临时目录清理的 8 个 `AccessDeniedException` 错误。
+
+Skill Cloud 相关测试在完整套件中通过；但按退出条件，完整 `mvn test` 仍未全绿，不能声称全量回归通过。
+
+## 范围与遮蔽检查
+
+- 本次修复的生产代码变更仅涉及 `OccupationSkill` 和新增 V37；其余变更为相应专项测试的布尔兼容与回归断言。
+- 未修改 `SecurityConfig`、接口、DTO、业务查询逻辑或其他 schema 映射。
+- `SkillTaxonomyRepositoryTest` 原有的 schema filter 仍只限制 H2 测试环境的旧表验证范围，本轮没有扩大或借助该 filter 掩盖 V37 相关 schema 问题；V37 专项迁移测试直接检查 `information_schema` 元数据和约束。
+- 工作区中 `.trae/*` 等文件属于本任务之外的既有未提交内容，不构成本次运行时修复差异。
+
+## 非阻断观察
+
+1. `V37__skill_cloud_boolean_type.sql` 当前索引版本与工作区版本存在一个仅涉及列注释的文本差异；两者不影响 DDL 语义，但提交前应统一内容，避免最终提交与独立测试的具体文本不一致。
+2. V37 文件工作区版本末尾缺少换行；非功能问题。
+3. MySQL 仅完成 8.0.43 二进制冒烟，未在实际 8.4 二进制上复跑；判断为语法兼容，但如需严格的 8.4 认证应补充运行环境验证。
+
+## 剩余阻断
+
+- 本次运行时启动修复：无阻断。
+- 项目最终关闭：完整 `mvn test` 仍有 2 failures + 9 errors；需要修复这些既有测试，或由项目按流程正式记录豁免后，才能推进全量回归结论和最终关闭。

changes/n03-skill-cloud/.superpowers/sdd/runtime-startup-failure.txt

@@ -0,0 +1,14 @@
+Runtime failure evidence
+=======================
+Task: manual application startup from IntelliJ
+Symptom: Hibernate SessionFactory build failed
+Column: occupation_skills.importance_is_proxy
+Found: bit (Types#BIT)
+Expected: tinyint (Types#TINYINT)
+Root cause: OccupationSkill.importanceIsProxy is explicitly forced to SqlTypes.TINYINT, unlike existing Boolean mappings.
+
+Attempt 2 evidence
+==================
+Removing @JdbcTypeCode(TINYINT) alone fixed the MySQL expectation but broke H2 schema validation:
+found tinyint, expected boolean.
+Conclusion: the column must be normalized to a cross-dialect BOOLEAN/BIT form, without modifying already-applied V35.

mydreamjob-server/src/main/java/com/mydreamjob/skill/domain/OccupationSkill.java

@@ -11,8 +11,6 @@ import lombok.Builder;
 import lombok.Getter;
 import lombok.NoArgsConstructor;
 import lombok.Setter;
-import org.hibernate.annotations.JdbcTypeCode;
-import org.hibernate.type.SqlTypes;
 
 import java.math.BigDecimal;
 import java.time.LocalDateTime;
@@ -47,8 +45,6 @@ public class OccupationSkill {
 
     @Column(name = "importance_element_id", length = 30)
     private String importanceElementId;
-
-    @JdbcTypeCode(SqlTypes.TINYINT)
     @Column(name = "importance_is_proxy", nullable = false)
     private Boolean importanceIsProxy;
 

mydreamjob-server/src/main/resources/db/migration/V37__skill_cloud_boolean_type.sql

@@ -0,0 +1,12 @@
+-- Flyway V37: 将技能代理标记规范化为跨方言 BOOLEAN。
+-- 不改写 V35/V36，确保已应用迁移的 Flyway checksum 保持有效。
+
+ALTER TABLE occupation_skills
+    DROP CONSTRAINT ck_occupation_skills_importance_proxy;
+
+ALTER TABLE occupation_skills
+    MODIFY COLUMN importance_is_proxy BOOLEAN NOT NULL DEFAULT FALSE;
+
+ALTER TABLE occupation_skills
+    ADD CONSTRAINT ck_occupation_skills_importance_proxy
+    CHECK (importance_is_proxy IN (FALSE, TRUE));

mydreamjob-server/src/test/java/com/mydreamjob/skill/SkillCloudQueryServiceTest.java

@@ -221,7 +221,7 @@ class SkillCloudQueryServiceTest {
         assertThat(react.heat()).isEqualByComparingTo((BigDecimal) row.get("importance"));
         assertThat(react.heatSourceCode()).isEqualTo(row.get("importance_source_code"));
         assertThat(react.heatElementId()).isEqualTo(row.get("importance_element_id"));
-        assertThat(react.heatProxy()).isEqualTo(((Number) row.get("importance_is_proxy")).intValue() == 1);
+        assertThat(react.heatProxy()).isEqualTo(toBoolean(row.get("importance_is_proxy")));
 
         SkillCloudResponse languages = service.query(1L, 1L, 101L);
         SkillCloudItem javascript = languages.items().stream()
@@ -256,6 +256,13 @@ class SkillCloudQueryServiceTest {
         assertBadRequest(() -> service.query(1L, 1L, 9999L), "category not found");
     }
 
+    private boolean toBoolean(Object value) {
+        if (value instanceof Boolean booleanValue) {
+            return booleanValue;
+        }
+        return ((Number) value).intValue() != 0;
+    }
+
     private void assertBadRequest(ThrowingCallable action, String detailFragment) {
         BusinessException exception = catchThrowableOfType(action, BusinessException.class);
         assertThat(exception).isNotNull();

mydreamjob-server/src/test/java/com/mydreamjob/skill/SkillCloudSeedDataIntegrationTest.java

@@ -202,7 +202,7 @@ class SkillCloudSeedDataIntegrationTest {
                         "OR importance_element_id IS NULL OR TRIM(importance_element_id) = '')"));
         assertEquals(0L, count(
                 "SELECT COUNT(*) FROM occupation_skills " +
-                        "WHERE importance_is_proxy IS NULL OR importance_is_proxy NOT IN (0, 1)"));
+                        "WHERE importance_is_proxy IS NULL OR importance_is_proxy NOT IN (FALSE, TRUE)"));
         assertEquals(0L, count(
                 "SELECT COUNT(*) FROM occupation_skills os " +
                         "JOIN skill_source_versions sv ON sv.id = os.source_version_id " +
@@ -226,7 +226,7 @@ class SkillCloudSeedDataIntegrationTest {
             String sourceCode = (String) row.get("importance_source_code");
             String elementId = (String) row.get("importance_element_id");
             BigDecimal importance = (BigDecimal) row.get("importance");
-            int proxy = ((Number) row.get("importance_is_proxy")).intValue();
+            int proxy = toInteger(row.get("importance_is_proxy"));
 
             assertTrue(proxy == 0 || proxy == 1,
                     "Invalid importance_is_proxy: relationId=" + relationId
@@ -581,7 +581,13 @@ class SkillCloudSeedDataIntegrationTest {
     }
 
     private Integer toInteger(Object value) {
-        return value == null ? null : ((Number) value).intValue();
+        if (value == null) {
+            return null;
+        }
+        if (value instanceof Boolean booleanValue) {
+            return booleanValue ? 1 : 0;
+        }
+        return ((Number) value).intValue();
     }
 
     private void assertSameMappingKeys(
@@ -979,7 +985,7 @@ class SkillCloudSeedDataIntegrationTest {
         assertEquals(new BigDecimal(expectedValue), ((BigDecimal) row.get("importance")).setScale(2));
         assertEquals(sourceCode, row.get("importance_source_code"));
         assertEquals(elementId, row.get("importance_element_id"));
-        assertEquals(1, ((Number) row.get("importance_is_proxy")).intValue());
+        assertEquals(1, toInteger(row.get("importance_is_proxy")));
     }
 
     private void assertNullImportance(String occupationCode, String skillCode) {
@@ -994,7 +1000,7 @@ class SkillCloudSeedDataIntegrationTest {
         assertNull(row.get("importance"));
         assertNull(row.get("importance_source_code"));
         assertNull(row.get("importance_element_id"));
-        assertEquals(0, ((Number) row.get("importance_is_proxy")).intValue());
+        assertEquals(0, toInteger(row.get("importance_is_proxy")));
     }
 
     private boolean hasSkillInIndustry(String industryCode, String skillCode) {

mydreamjob-server/src/test/java/com/mydreamjob/skill/SkillTaxonomyMigrationTest.java

@@ -20,6 +20,7 @@ import java.sql.SQLException;
 import java.util.ArrayList;
 import java.util.LinkedHashMap;
 import java.util.List;
+import java.util.Locale;
 import java.util.Map;
 import java.util.TreeMap;
 
@@ -95,6 +96,13 @@ class SkillTaxonomyMigrationTest {
 
         assertIndex("occupation_skills", "occupation_id", "category_id");
         assertIndex("occupation_skills", "occupation_id", "importance");
+        assertBooleanColumnMetadata("occupation_skills", "importance_is_proxy");
+        assertEquals(1L, jdbcTemplate.queryForObject(
+                "SELECT COUNT(*) FROM information_schema.table_constraints " +
+                        "WHERE UPPER(table_name) = 'OCCUPATION_SKILLS' " +
+                        "AND UPPER(constraint_name) = 'CK_OCCUPATION_SKILLS_IMPORTANCE_PROXY' " +
+                        "AND UPPER(constraint_type) = 'CHECK'",
+                Long.class));
     }
 
     @Test
@@ -148,14 +156,17 @@ class SkillTaxonomyMigrationTest {
         assertNull(joined.get("importance"));
         assertNull(joined.get("importance_source_code"));
         assertNull(joined.get("importance_element_id"));
-        assertEquals(0, ((Number) joined.get("importance_is_proxy")).intValue());
+        assertEquals(Boolean.FALSE, joined.get("importance_is_proxy"));
+        assertEquals(1L, jdbcTemplate.queryForObject(
+                "SELECT COUNT(*) FROM occupation_skills WHERE id = ? AND importance_is_proxy = FALSE",
+                Long.class, occupationSkillId));
 
         assertConstraintFailure("UPDATE occupation_skills SET importance = ? WHERE id = ?",
                 new BigDecimal("4.25"), occupationSkillId);
         jdbcTemplate.update("UPDATE occupation_skills SET importance = ?, " +
                         "importance_source_code = ?, importance_element_id = ?, importance_is_proxy = ? " +
                         "WHERE id = ?",
-                new BigDecimal("4.25"), "15-1252.00", "4.A.3.b.1", 1, occupationSkillId);
+                new BigDecimal("4.25"), "15-1252.00", "4.A.3.b.1", Boolean.TRUE, occupationSkillId);
         Map<String, Object> weighted = jdbcTemplate.queryForMap(
                 "SELECT importance, importance_source_code, importance_element_id, importance_is_proxy " +
                         "FROM occupation_skills WHERE id = ?",
@@ -163,7 +174,10 @@ class SkillTaxonomyMigrationTest {
         assertEquals(new BigDecimal("4.25"), weighted.get("importance"));
         assertEquals("15-1252.00", weighted.get("importance_source_code"));
         assertEquals("4.A.3.b.1", weighted.get("importance_element_id"));
-        assertEquals(1, ((Number) weighted.get("importance_is_proxy")).intValue());
+        assertEquals(Boolean.TRUE, weighted.get("importance_is_proxy"));
+        assertEquals(1L, jdbcTemplate.queryForObject(
+                "SELECT COUNT(*) FROM occupation_skills WHERE id = ? AND importance_is_proxy = TRUE",
+                Long.class, occupationSkillId));
         assertConstraintFailure(
                 "INSERT INTO skill_source_versions " +
                         "(source_name, source_version, license, attribution_url) VALUES (?, ?, ?, ?)",
@@ -202,7 +216,8 @@ class SkillTaxonomyMigrationTest {
 
         assertConstraintFailure(
                 "UPDATE occupation_skills SET importance_is_proxy = ? WHERE id = ?",
-                2, occupationSkillId);        assertTrue(jdbcTemplate.queryForObject(
+                (Object) null, occupationSkillId);
+        assertTrue(jdbcTemplate.queryForObject(
                 "SELECT COUNT(*) FROM skill_aliases WHERE skill_id = ? AND normalized_alias = ?",
                 Integer.class, skillId, "java se") == 1);
     }
@@ -234,6 +249,16 @@ class SkillTaxonomyMigrationTest {
         }
     }
 
+    private void assertBooleanColumnMetadata(String table, String column) {
+        Map<String, Object> metadata = jdbcTemplate.queryForMap(
+                "SELECT data_type, column_default, is_nullable FROM information_schema.columns " +
+                        "WHERE UPPER(table_name) = ? AND UPPER(column_name) = ?",
+                table.toUpperCase(Locale.ROOT), column.toUpperCase(Locale.ROOT));
+        assertEquals("BOOLEAN", String.valueOf(metadata.get("data_type")).toUpperCase(Locale.ROOT));
+        assertEquals("FALSE", String.valueOf(metadata.get("column_default")).toUpperCase(Locale.ROOT));
+        assertEquals("NO", String.valueOf(metadata.get("is_nullable")).toUpperCase(Locale.ROOT));
+    }
+
     private void assertTableAndColumns(String table, String... columns) throws SQLException {
         try (Connection connection = dataSource.getConnection()) {
             DatabaseMetaData metadata = connection.getMetaData();

mydreamjob-server/src/test/java/com/mydreamjob/skill/SkillTaxonomyRepositoryTest.java

@@ -1,5 +1,6 @@
 package com.mydreamjob.skill;
 
+import com.mydreamjob.skill.domain.OccupationSkill;
 import com.mydreamjob.skill.domain.Skill;
 import com.mydreamjob.skill.domain.SkillAlias;
 import com.mydreamjob.skill.dto.SkillCloudSkillProjection;
@@ -10,6 +11,7 @@ import com.mydreamjob.skill.repository.SkillIndustryRepository;
 import com.mydreamjob.skill.repository.SkillOccupationRepository;
 import com.mydreamjob.skill.repository.SkillRepository;
 import com.mydreamjob.skill.repository.SkillSourceVersionRepository;
+import jakarta.persistence.EntityManagerFactory;
 import org.junit.jupiter.api.Test;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.boot.test.context.SpringBootTest;
@@ -19,8 +21,11 @@ import org.springframework.jdbc.core.JdbcTemplate;
 import org.springframework.test.context.ActiveProfiles;
 import org.springframework.test.context.TestPropertySource;
 import org.springframework.transaction.annotation.Transactional;
+import org.hibernate.engine.spi.SessionFactoryImplementor;
 import org.hibernate.boot.model.relational.Namespace;
 import org.hibernate.boot.model.relational.Sequence;
+import org.hibernate.annotations.JdbcTypeCode;
+import org.hibernate.persister.entity.EntityPersister;
 import org.hibernate.mapping.Table;
 import org.hibernate.tool.schema.spi.SchemaFilter;
 import org.hibernate.tool.schema.spi.SchemaFilterProvider;
@@ -66,6 +71,9 @@ class SkillTaxonomyRepositoryTest {
     @Autowired
     private JdbcTemplate jdbcTemplate;
 
+    @Autowired
+    private EntityManagerFactory entityManagerFactory;
+
     @MockBean
     private RedisTemplate<String, Object> redisTemplate;
 
@@ -131,7 +139,7 @@ class SkillTaxonomyRepositoryTest {
                 ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
                 """,
                 1L, 1L, 201L, new BigDecimal("4.61"),
-                "15-1252.00", "4.A.3.b.1", 1, "ESSENTIAL", 2L);
+                "15-1252.00", "4.A.3.b.1", Boolean.TRUE, "ESSENTIAL", 2L);
 
         List<SkillCloudSkillProjection> occupationOneSkills =
                 occupationSkillRepository.findSkillProjectionsByOccupationId(1L);
@@ -211,6 +219,22 @@ class SkillTaxonomyRepositoryTest {
                 .containsExactly(3L, 4L);
     }
 
+    @Test
+    void importanceIsProxyUsesDefaultBooleanMapping() throws NoSuchFieldException {
+        SessionFactoryImplementor sessionFactory = entityManagerFactory.unwrap(SessionFactoryImplementor.class);
+        EntityPersister persister = sessionFactory.getMappingMetamodel().getEntityDescriptor(OccupationSkill.class);
+
+        org.hibernate.type.Type propertyType = persister.getPropertyType("importanceIsProxy");
+        assertThat(propertyType.getReturnedClass()).isEqualTo(Boolean.class);
+
+        JdbcTypeCode explicitJdbcType = OccupationSkill.class
+                .getDeclaredField("importanceIsProxy")
+                .getAnnotation(JdbcTypeCode.class);
+        assertThat(explicitJdbcType)
+                .as("importanceIsProxy must use the default Boolean mapping without a forced JDBC type")
+                .isNull();
+    }
+
     /**
      * The legacy H2 schema has TINYINT/Boolean mismatches outside the V35 taxonomy.
      * Scope validation to the seven T4 tables without changing historical migrations or entities.