增加与ai大模型对话

doc/灵活用工-mysql.sql

@@ -402,8 +402,8 @@ DROP TABLE IF EXISTS `fe_registration_batch`;
 CREATE TABLE `fe_registration_batch` (
   `id` bigint NOT NULL AUTO_INCREMENT COMMENT '表主键，自增。订单进入登记步骤时由后端创建。非空。',
   `batch_no` VARCHAR(32)     NOT NULL COMMENT '登记批次业务编号。示例：BATCH-001。非空；唯一索引 uk_fe_batch_no。',
-  `order_id` BIGINT          NOT NULL COMMENT '关联用工订单，外键 REFERENCES fe_employment_order(id)。非空；索引 idx_fe_batch_order。',
-  `enterprise_id` BIGINT          NOT NULL COMMENT '所属企业，外键 REFERENCES fe_enterprise(id)。冗余便于按企业查批次。非空。',
+  `order_id` BIGINT          NOT NULL COMMENT '关联用工订单 fe_employment_order.id（逻辑关联，无数据库外键）。非空；索引 idx_fe_batch_order。',
+  `enterprise_id` BIGINT          NOT NULL COMMENT '所属企业 fe_enterprise.id（逻辑关联，无数据库外键）。冗余便于按企业查批次。非空。',
   `expected_count` int         NOT NULL COMMENT '本批次预期登记人数，通常等于订单 worker_count。非空。',
   `registered_count` int         NOT NULL DEFAULT 0 COMMENT '已登记总数（含进行中），冗余统计。非空，默认 0。',
   `pending_count` int         NOT NULL DEFAULT 0 COMMENT '尚未开始登记人数。非空，默认 0。',
@@ -423,9 +423,8 @@ CREATE TABLE `fe_registration_batch` (
   UNIQUE KEY `uk_fe_batch_no` (`batch_no`),
   UNIQUE KEY `uk_fe_batch_token` (`qr_token`),
   KEY `idx_fe_batch_order` (`order_id`),
-  CONSTRAINT `fk_fe_registration_batch_order_id` FOREIGN KEY (`order_id`) REFERENCES `fe_employment_order` (`id`),
-  CONSTRAINT `fk_fe_registration_batch_enterprise_id` FOREIGN KEY (`enterprise_id`) REFERENCES `fe_enterprise` (`id`)
-) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='临时工扫码登记批次表，草稿确认方案后生成，含 H5/小程序登记链接、二维码图片与有效期。企业主在进度页查看登记统计；一对多关联 fe_worker_registration。';
+  KEY `idx_fe_batch_enterprise` (`enterprise_id`)
+) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='临时工扫码登记批次表，草稿确认方案后生成，含 H5/小程序登记链接、二维码图片与有效期。企业主在进度页查看登记统计；一对多关联 fe_worker_registration。关联列暂不建数据库外键。';
 
 DROP TABLE IF EXISTS `fe_order_workflow_log`;
 CREATE TABLE `fe_order_workflow_log` (
@@ -475,7 +474,7 @@ CREATE TABLE `fe_worker` (
 DROP TABLE IF EXISTS `fe_worker_registration`;
 CREATE TABLE `fe_worker_registration` (
   `id` bigint NOT NULL AUTO_INCREMENT COMMENT '表主键，自增。临时工打开登记页或提交时创建。非空。',
-  `batch_id` BIGINT          NOT NULL COMMENT '所属登记批次，外键 REFERENCES fe_registration_batch(id)。非空；索引 idx_fe_worker_reg_batch。',
+  `batch_id` BIGINT          NOT NULL COMMENT '所属登记批次 fe_registration_batch.id（逻辑关联，无数据库外键）。非空；索引 idx_fe_worker_reg_batch。',
   `order_id` BIGINT          NOT NULL COMMENT '关联订单，外键 REFERENCES fe_employment_order(id)。冗余便于按订单查登记列表。非空；索引 idx_fe_worker_reg_order。',
   `enterprise_id` BIGINT          NOT NULL COMMENT '所属企业，外键 REFERENCES fe_enterprise(id)。冗余。非空。',
   `worker_id` BIGINT COMMENT '关联临时工档案，外键 REFERENCES fe_worker(id)。提交成功且匹配/创建档案后绑定。可空（登记进行中）。',
@@ -498,12 +497,11 @@ CREATE TABLE `fe_worker_registration` (
   PRIMARY KEY (`id`),
   KEY `idx_fe_worker_reg_batch` (`batch_id`, `reg_status`),
   KEY `idx_fe_worker_reg_order` (`order_id`),
-  CONSTRAINT `fk_fe_worker_registration_batch_id` FOREIGN KEY (`batch_id`) REFERENCES `fe_registration_batch` (`id`),
   CONSTRAINT `fk_fe_worker_registration_order_id` FOREIGN KEY (`order_id`) REFERENCES `fe_employment_order` (`id`),
   CONSTRAINT `fk_fe_worker_registration_enterprise_id` FOREIGN KEY (`enterprise_id`) REFERENCES `fe_enterprise` (`id`),
   CONSTRAINT `fk_fe_worker_registration_worker_id` FOREIGN KEY (`worker_id`) REFERENCES `fe_worker` (`id`),
   CONSTRAINT `fk_fe_worker_registration_reviewed_by` FOREIGN KEY (`reviewed_by`) REFERENCES `fe_user` (`id`)
-) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='批次登记记录表，记录每个临时工在某一 fe_registration_batch 下的一次登记全过程。reg_status 驱动进度页统计、催办与审核；关联 fe_worker 档案，敏感证件信息加密存储。';
+) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='批次登记记录表，记录每个临时工在某一 fe_registration_batch 下的一次登记全过程。reg_status 驱动进度页统计、催办与审核；关联 fe_worker 档案，敏感证件信息加密存储。batch_id 暂无数据库外键。';
 
 DROP TABLE IF EXISTS `fe_worker_consent`;
 CREATE TABLE `fe_worker_consent` (
@@ -557,7 +555,7 @@ CREATE TABLE `fe_settlement_order` (
   `id` bigint NOT NULL AUTO_INCREMENT COMMENT '表主键，自增。结算引擎生成结算单时创建。非空。',
   `settlement_no` VARCHAR(32)     NOT NULL COMMENT '结算单业务编号。示例：STL20260707001。非空；唯一索引 uk_fe_settlement_no。',
   `order_id` BIGINT          NOT NULL COMMENT '关联用工订单，外键 REFERENCES fe_employment_order(id)。非空。',
-  `batch_id` BIGINT COMMENT '关联登记批次，外键 REFERENCES fe_registration_batch(id)。可空；多批次订单可只关联主批次。',
+  `batch_id` BIGINT COMMENT '关联登记批次 fe_registration_batch.id（逻辑关联，无数据库外键）。可空；多批次订单可只关联主批次。',
   `enterprise_id` BIGINT          NOT NULL COMMENT '所属企业，外键 REFERENCES fe_enterprise(id)。非空；索引 idx_fe_settlement_ent。',
   `worker_count` int         NOT NULL COMMENT '本次结算涵盖人数。非空。',
   `gross_amount` decimal(14,2)   NOT NULL DEFAULT 0 COMMENT '应发总额（元），税前劳务合计。非空，默认 0。',
@@ -578,11 +576,11 @@ CREATE TABLE `fe_settlement_order` (
   PRIMARY KEY (`id`),
   UNIQUE KEY `uk_fe_settlement_no` (`settlement_no`),
   KEY `idx_fe_settlement_ent` (`enterprise_id`, `settlement_status`),
+  KEY `idx_fe_settlement_batch` (`batch_id`),
   CONSTRAINT `fk_fe_settlement_order_order_id` FOREIGN KEY (`order_id`) REFERENCES `fe_employment_order` (`id`),
-  CONSTRAINT `fk_fe_settlement_order_batch_id` FOREIGN KEY (`batch_id`) REFERENCES `fe_registration_batch` (`id`),
   CONSTRAINT `fk_fe_settlement_order_enterprise_id` FOREIGN KEY (`enterprise_id`) REFERENCES `fe_enterprise` (`id`),
   CONSTRAINT `fk_fe_settlement_order_confirmed_by` FOREIGN KEY (`confirmed_by`) REFERENCES `fe_user` (`id`)
-) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='结算确认单主表，用工结束后按考勤或约定生成，展示应发/扣款/实发、服务费、开票额与企业总支出。企业确认后进入支付环节；一对多关联 fe_settlement_item、fe_settlement_fee、fe_payment_record。';
+) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='结算确认单主表，用工结束后按考勤或约定生成，展示应发/扣款/实发、服务费、开票额与企业总支出。企业确认后进入支付环节；一对多关联 fe_settlement_item、fe_settlement_fee、fe_payment_record。batch_id 暂无数据库外键。';
 
 DROP TABLE IF EXISTS `fe_settlement_item`;
 CREATE TABLE `fe_settlement_item` (
@@ -649,7 +647,7 @@ CREATE TABLE `fe_payment_record` (
 DROP TABLE IF EXISTS `fe_attendance_batch`;
 CREATE TABLE `fe_attendance_batch` (
   `id` bigint NOT NULL AUTO_INCREMENT COMMENT '表主键，自增。每日定时任务或企业主手动生成日报时创建。非空。',
-  `batch_id` BIGINT          NOT NULL COMMENT '关联登记批次，外键 REFERENCES fe_registration_batch(id)。非空；与 attendance_date 组成唯一索引 uk_fe_attendance_batch。',
+  `batch_id` BIGINT          NOT NULL COMMENT '关联登记批次 fe_registration_batch.id（逻辑关联，无数据库外键）。非空；与 attendance_date 组成唯一索引 uk_fe_attendance_batch。',
   `order_id` BIGINT          NOT NULL COMMENT '关联订单，外键 REFERENCES fe_employment_order(id)。冗余便于订单维度查考勤。非空。',
   `attendance_date` DATE            NOT NULL COMMENT '考勤统计日期，DATE 类型。示例：2026-08-15。非空。',
   `total_workers` int         NOT NULL DEFAULT 0 COMMENT '当日应考勤人数。非空，默认 0。',
@@ -666,10 +664,9 @@ CREATE TABLE `fe_attendance_batch` (
   `update_time` datetime     NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '考勤数据变更时更新。非空。',
   PRIMARY KEY (`id`),
   UNIQUE KEY `uk_fe_attendance_batch` (`batch_id`, `attendance_date`),
-  CONSTRAINT `fk_fe_attendance_batch_batch_id` FOREIGN KEY (`batch_id`) REFERENCES `fe_registration_batch` (`id`),
   CONSTRAINT `fk_fe_attendance_batch_order_id` FOREIGN KEY (`order_id`) REFERENCES `fe_employment_order` (`id`),
   CONSTRAINT `fk_fe_attendance_batch_confirmed_by` FOREIGN KEY (`confirmed_by`) REFERENCES `fe_user` (`id`)
-) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='考勤日报批次表（二期功能），按登记批次与日期汇总当日应考勤人数、出勤/加班/请假统计及预估费用。一期 MVP 可不实现业务逻辑，表结构先行预留；关联 fe_registration_batch、fe_employment_order。';
+) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='考勤日报批次表（二期功能），按登记批次与日期汇总当日应考勤人数、出勤/加班/请假统计及预估费用。一期 MVP 可不实现业务逻辑，表结构先行预留；batch_id 暂无数据库外键。';
 
 DROP TABLE IF EXISTS `fe_attendance_record`;
 CREATE TABLE `fe_attendance_record` (
@@ -814,21 +811,27 @@ CROSS JOIN (
 ) s
 WHERE wd.`workflow_code` = 'employment_compliance' AND wd.`version` = 1;
 
-INSERT INTO `fe_service_plan` (`plan_code`, `plan_name`, `plan_type`, `description`, `service_fee_rate`, `insurance_level`, `compliance_tags`, `sort_order`, `status`)
+INSERT INTO `fe_service_plan` (`plan_code`, `plan_name`, `plan_type`, `description`, `service_fee_rate`, `insurance_level`, `tax_mode`, `compliance_tags`, `sort_order`, `status`)
 VALUES
-  ('current', '当前处理方式', 'traditional', '企业现有处理方式估算', NULL, NULL, '[]', 0, 'active'),
-  ('plan_1', '合规优先 (A)', 'flexible', '测试方案一：合规优先', 0.0800, 'premium', '["业务真实","资金合规","个税申报"]', 1, 'test_only'),
-  ('plan_2', '传统用工 (B)', 'traditional', '测试方案二：传统用工', NULL, NULL, '[]', 2, 'test_only'),
-  ('plan_3', '成本优化 (C)', 'flexible', '测试方案三：成本优化', 0.0600, 'basic', '["业务真实","资金合规"]', 3, 'test_only');
-
-INSERT INTO `fe_service_plan_fee_rule` (`plan_id`, `fee_code`, `fee_name`, `calc_type`, `default_rate`, `sort_order`)
-SELECT p.`id`, f.`fee_code`, f.`fee_name`, f.`calc_type`, f.`default_rate`, f.`sort_order`
+  ('current', '当前处理方式', 'traditional', '企业现有处理方式估算', NULL, NULL, NULL, '[]', 0, 'active'),
+  ('SCHEME_A', '灵活用工模式（推荐）', 'flexible', '灵活用工：企业支付劳务费 + 平台服务费，劳动者到手无需预扣个税（示例）', 0.0200, 'standard', 'platform_withhold', '["合规","低税负"]', 1, 'active'),
+  ('SCHEME_B', '劳务报酬模式', 'traditional', '劳务报酬：企业支付劳务费，按劳务报酬预扣个税（示例：3000 元对应税 440 元）', NULL, NULL, 'labor_remuneration', '["传统"]', 2, 'active'),
+  ('plan_1', '合规优先 (A)', 'flexible', '测试方案一：合规优先', 0.0800, 'premium', NULL, '["业务真实","资金合规","个税申报"]', 11, 'test_only'),
+  ('plan_2', '传统用工 (B)', 'traditional', '测试方案二：传统用工', NULL, NULL, NULL, '[]', 12, 'test_only'),
+  ('plan_3', '成本优化 (C)', 'flexible', '测试方案三：成本优化', 0.0600, 'basic', NULL, '["业务真实","资金合规"]', 13, 'test_only');
+
+INSERT INTO `fe_service_plan_fee_rule` (`plan_id`, `fee_code`, `fee_name`, `calc_type`, `calc_expression`, `default_rate`, `sort_order`)
+SELECT p.`id`, f.`fee_code`, f.`fee_name`, f.`calc_type`, f.`calc_expression`, f.`default_rate`, f.`sort_order`
 FROM `fe_service_plan` p
 INNER JOIN (
-  SELECT 'plan_1' AS plan_code, 'labor_fee' AS fee_code, '劳务费' AS fee_name, 'formula' AS calc_type, NULL AS default_rate, 1 AS sort_order
-  UNION ALL SELECT 'plan_1', 'service_fee', '服务费', 'rate', 0.0800, 2
-  UNION ALL SELECT 'plan_1', 'insurance', '保险', 'fixed', NULL, 3
-  UNION ALL SELECT 'plan_1', 'tax_withhold', '税费代征', 'formula', NULL, 4
+  SELECT 'SCHEME_A' AS plan_code, 'labor_fee' AS fee_code, '劳务费' AS fee_name, 'formula' AS calc_type, 'gross' AS calc_expression, NULL AS default_rate, 1 AS sort_order
+  UNION ALL SELECT 'SCHEME_A', 'service_fee', '服务费', 'rate', 'gross * service_fee_rate', 0.0200, 2
+  UNION ALL SELECT 'SCHEME_B', 'labor_fee', '劳务费', 'formula', 'gross', NULL, 1
+  UNION ALL SELECT 'SCHEME_B', 'tax_withhold', '个税预扣', 'formula', 'gross*440/3000', NULL, 2
+  UNION ALL SELECT 'plan_1', 'labor_fee', '劳务费', 'formula', NULL, NULL, 1
+  UNION ALL SELECT 'plan_1', 'service_fee', '服务费', 'rate', NULL, 0.0800, 2
+  UNION ALL SELECT 'plan_1', 'insurance', '保险', 'fixed', NULL, NULL, 3
+  UNION ALL SELECT 'plan_1', 'tax_withhold', '税费代征', 'formula', NULL, NULL, 4
 ) f ON p.`plan_code` = f.`plan_code`;
 
 SET FOREIGN_KEY_CHECKS = 1;

doc/灵活用工.sql

@@ -415,8 +415,8 @@ CREATE INDEX idx_fe_order_ent ON fe_employment_order (enterprise_id, order_statu
 CREATE TABLE fe_registration_batch (
     id                  BIGSERIAL       PRIMARY KEY,
     batch_no            VARCHAR(32)     NOT NULL,                   -- BATCH-001
-    order_id            BIGINT          NOT NULL REFERENCES fe_employment_order(id),
-    enterprise_id       BIGINT          NOT NULL REFERENCES fe_enterprise(id),
+    order_id            BIGINT          NOT NULL,                   -- 逻辑关联 fe_employment_order.id（无 FK）
+    enterprise_id       BIGINT          NOT NULL,                   -- 逻辑关联 fe_enterprise.id（无 FK）
     expected_count      INTEGER         NOT NULL,
     registered_count    INTEGER         NOT NULL DEFAULT 0,
     pending_count       INTEGER         NOT NULL DEFAULT 0,
@@ -436,6 +436,7 @@ CREATE TABLE fe_registration_batch (
 CREATE UNIQUE INDEX uk_fe_batch_no ON fe_registration_batch (batch_no);
 CREATE UNIQUE INDEX uk_fe_batch_token ON fe_registration_batch (qr_token) WHERE qr_token IS NOT NULL;
 CREATE INDEX idx_fe_batch_order ON fe_registration_batch (order_id);
+CREATE INDEX idx_fe_batch_enterprise ON fe_registration_batch (enterprise_id);
 
 
 -- 订单流程状态变更日志（合规状态机留痕）
@@ -489,7 +490,7 @@ CREATE INDEX idx_fe_worker_mobile ON fe_worker (mobile_mask);
 -- 批次登记记录
 CREATE TABLE fe_worker_registration (
     id                  BIGSERIAL       PRIMARY KEY,
-    batch_id            BIGINT          NOT NULL REFERENCES fe_registration_batch(id),
+    batch_id            BIGINT          NOT NULL,                   -- 逻辑关联 fe_registration_batch.id（无 FK）
     order_id            BIGINT          NOT NULL REFERENCES fe_employment_order(id),
     enterprise_id       BIGINT          NOT NULL REFERENCES fe_enterprise(id),
     worker_id           BIGINT          REFERENCES fe_worker(id),
@@ -569,7 +570,7 @@ CREATE TABLE fe_settlement_order (
     id                  BIGSERIAL       PRIMARY KEY,
     settlement_no       VARCHAR(32)     NOT NULL,
     order_id            BIGINT          NOT NULL REFERENCES fe_employment_order(id),
-    batch_id            BIGINT          REFERENCES fe_registration_batch(id),
+    batch_id            BIGINT,                                     -- 逻辑关联 fe_registration_batch.id（无 FK）
     enterprise_id       BIGINT          NOT NULL REFERENCES fe_enterprise(id),
     worker_count        INTEGER         NOT NULL,
     gross_amount        NUMERIC(14,2)   NOT NULL DEFAULT 0,         -- 应发总额
@@ -654,7 +655,7 @@ CREATE INDEX idx_fe_payment_settlement ON fe_payment_record (settlement_id);
 
 CREATE TABLE fe_attendance_batch (
     id              BIGSERIAL       PRIMARY KEY,
-    batch_id        BIGINT          NOT NULL REFERENCES fe_registration_batch(id),
+    batch_id        BIGINT          NOT NULL,                       -- 逻辑关联 fe_registration_batch.id（无 FK）
     order_id        BIGINT          NOT NULL REFERENCES fe_employment_order(id),
     attendance_date DATE            NOT NULL,
     total_workers   INTEGER         NOT NULL DEFAULT 0,
@@ -1075,8 +1076,8 @@ COMMENT ON COLUMN fe_employment_order.del_flag IS '逻辑删除标记。枚举
 COMMENT ON TABLE fe_registration_batch IS '临时工扫码登记批次表，草稿确认方案后生成，含 H5/小程序登记链接、二维码图片与有效期。企业主在进度页查看登记统计；一对多关联 fe_worker_registration。';
 COMMENT ON COLUMN fe_registration_batch.id IS '表主键，自增。订单进入登记步骤时由后端创建。非空。';
 COMMENT ON COLUMN fe_registration_batch.batch_no IS '登记批次业务编号。示例：BATCH-001。非空；唯一索引 uk_fe_batch_no。';
-COMMENT ON COLUMN fe_registration_batch.order_id IS '关联用工订单，外键 REFERENCES fe_employment_order(id)。非空；索引 idx_fe_batch_order。';
-COMMENT ON COLUMN fe_registration_batch.enterprise_id IS '所属企业，外键 REFERENCES fe_enterprise(id)。冗余便于按企业查批次。非空。';
+COMMENT ON COLUMN fe_registration_batch.order_id IS '关联用工订单 fe_employment_order.id（逻辑关联，无数据库外键）。非空；索引 idx_fe_batch_order。';
+COMMENT ON COLUMN fe_registration_batch.enterprise_id IS '所属企业 fe_enterprise.id（逻辑关联，无数据库外键）。冗余便于按企业查批次。非空。';
 COMMENT ON COLUMN fe_registration_batch.expected_count IS '本批次预期登记人数，通常等于订单 worker_count。非空。';
 COMMENT ON COLUMN fe_registration_batch.registered_count IS '已登记总数（含进行中），冗余统计。非空，默认 0。';
 COMMENT ON COLUMN fe_registration_batch.pending_count IS '尚未开始登记人数。非空，默认 0。';
@@ -1127,7 +1128,7 @@ COMMENT ON COLUMN fe_worker.del_flag IS '逻辑删除标记。枚举：0=正常
 
 COMMENT ON TABLE fe_worker_registration IS '批次登记记录表，记录每个临时工在某一 fe_registration_batch 下的一次登记全过程。reg_status 驱动进度页统计、催办与审核；关联 fe_worker 档案，敏感证件信息加密存储。';
 COMMENT ON COLUMN fe_worker_registration.id IS '表主键，自增。临时工打开登记页或提交时创建。非空。';
-COMMENT ON COLUMN fe_worker_registration.batch_id IS '所属登记批次，外键 REFERENCES fe_registration_batch(id)。非空；索引 idx_fe_worker_reg_batch。';
+COMMENT ON COLUMN fe_worker_registration.batch_id IS '所属登记批次 fe_registration_batch.id（逻辑关联，无数据库外键）。非空；索引 idx_fe_worker_reg_batch。';
 COMMENT ON COLUMN fe_worker_registration.order_id IS '关联订单，外键 REFERENCES fe_employment_order(id)。冗余便于按订单查登记列表。非空；索引 idx_fe_worker_reg_order。';
 COMMENT ON COLUMN fe_worker_registration.enterprise_id IS '所属企业，外键 REFERENCES fe_enterprise(id)。冗余。非空。';
 COMMENT ON COLUMN fe_worker_registration.worker_id IS '关联临时工档案，外键 REFERENCES fe_worker(id)。提交成功且匹配/创建档案后绑定。可空（登记进行中）。';
@@ -1184,7 +1185,7 @@ COMMENT ON TABLE fe_settlement_order IS '结算确认单主表，用工结束后
 COMMENT ON COLUMN fe_settlement_order.id IS '表主键，自增。结算引擎生成结算单时创建。非空。';
 COMMENT ON COLUMN fe_settlement_order.settlement_no IS '结算单业务编号。示例：STL20260707001。非空；唯一索引 uk_fe_settlement_no。';
 COMMENT ON COLUMN fe_settlement_order.order_id IS '关联用工订单，外键 REFERENCES fe_employment_order(id)。非空。';
-COMMENT ON COLUMN fe_settlement_order.batch_id IS '关联登记批次，外键 REFERENCES fe_registration_batch(id)。可空；多批次订单可只关联主批次。';
+COMMENT ON COLUMN fe_settlement_order.batch_id IS '关联登记批次 fe_registration_batch.id（逻辑关联，无数据库外键）。可空；多批次订单可只关联主批次。';
 COMMENT ON COLUMN fe_settlement_order.enterprise_id IS '所属企业，外键 REFERENCES fe_enterprise(id)。非空；索引 idx_fe_settlement_ent。';
 COMMENT ON COLUMN fe_settlement_order.worker_count IS '本次结算涵盖人数。非空。';
 COMMENT ON COLUMN fe_settlement_order.gross_amount IS '应发总额（元），税前劳务合计。非空，默认 0。';
@@ -1247,7 +1248,7 @@ COMMENT ON COLUMN fe_payment_record.update_time IS '状态变更时更新。非
 
 COMMENT ON TABLE fe_attendance_batch IS '考勤日报批次表（二期功能），按登记批次与日期汇总当日应考勤人数、出勤/加班/请假统计及预估费用。一期 MVP 可不实现业务逻辑，表结构先行预留；关联 fe_registration_batch、fe_employment_order。';
 COMMENT ON COLUMN fe_attendance_batch.id IS '表主键，自增。每日定时任务或企业主手动生成日报时创建。非空。';
-COMMENT ON COLUMN fe_attendance_batch.batch_id IS '关联登记批次，外键 REFERENCES fe_registration_batch(id)。非空；与 attendance_date 组成唯一索引 uk_fe_attendance_batch。';
+COMMENT ON COLUMN fe_attendance_batch.batch_id IS '关联登记批次 fe_registration_batch.id（逻辑关联，无数据库外键）。非空；与 attendance_date 组成唯一索引 uk_fe_attendance_batch。';
 COMMENT ON COLUMN fe_attendance_batch.order_id IS '关联订单，外键 REFERENCES fe_employment_order(id)。冗余便于订单维度查考勤。非空。';
 COMMENT ON COLUMN fe_attendance_batch.attendance_date IS '考勤统计日期，DATE 类型。示例：2026-08-15。非空。';
 COMMENT ON COLUMN fe_attendance_batch.total_workers IS '当日应考勤人数。非空，默认 0。';
@@ -1373,22 +1374,28 @@ FROM fe_workflow_definition wd,
 ) AS s(step_code, step_name, step_order)
 WHERE wd.workflow_code = 'employment_compliance' AND wd.version = 1;
 
-INSERT INTO fe_service_plan (plan_code, plan_name, plan_type, description, service_fee_rate, insurance_level, compliance_tags, sort_order, status)
+INSERT INTO fe_service_plan (plan_code, plan_name, plan_type, description, service_fee_rate, insurance_level, tax_mode, compliance_tags, sort_order, status)
 VALUES
-    ('current', '当前处理方式',   'traditional', '企业现有处理方式估算', NULL,  NULL,      '[]', 0, 'active'),
-    ('plan_1',  '合规优先 (A)',   'flexible',    '测试方案一：合规优先', 0.08, 'premium', '["业务真实","资金合规","个税申报"]', 1, 'test_only'),
-    ('plan_2',  '传统用工 (B)',   'traditional', '测试方案二：传统用工', NULL,  NULL,      '[]', 2, 'test_only'),
-    ('plan_3',  '成本优化 (C)',   'flexible',    '测试方案三：成本优化', 0.06, 'basic',   '["业务真实","资金合规"]', 3, 'test_only');
-
-INSERT INTO fe_service_plan_fee_rule (plan_id, fee_code, fee_name, calc_type, default_rate, sort_order)
-SELECT p.id, f.fee_code, f.fee_name, f.calc_type, f.default_rate, f.sort_order
+    ('current',  '当前处理方式',         'traditional', '企业现有处理方式估算', NULL,  NULL,      NULL,                   '[]', 0, 'active'),
+    ('SCHEME_A', '灵活用工模式（推荐）', 'flexible',    '灵活用工：企业支付劳务费 + 平台服务费，劳动者到手无需预扣个税（示例）', 0.02, 'standard', 'platform_withhold', '["合规","低税负"]', 1, 'active'),
+    ('SCHEME_B', '劳务报酬模式',         'traditional', '劳务报酬：企业支付劳务费，按劳务报酬预扣个税（示例：3000 元对应税 440 元）', NULL, NULL, 'labor_remuneration', '["传统"]', 2, 'active'),
+    ('plan_1',   '合规优先 (A)',         'flexible',    '测试方案一：合规优先', 0.08, 'premium', NULL,                   '["业务真实","资金合规","个税申报"]', 11, 'test_only'),
+    ('plan_2',   '传统用工 (B)',         'traditional', '测试方案二：传统用工', NULL,  NULL,      NULL,                   '[]', 12, 'test_only'),
+    ('plan_3',   '成本优化 (C)',         'flexible',    '测试方案三：成本优化', 0.06, 'basic',   NULL,                   '["业务真实","资金合规"]', 13, 'test_only');
+
+INSERT INTO fe_service_plan_fee_rule (plan_id, fee_code, fee_name, calc_type, calc_expression, default_rate, sort_order)
+SELECT p.id, f.fee_code, f.fee_name, f.calc_type, f.calc_expression, f.default_rate, f.sort_order
 FROM fe_service_plan p
 JOIN (VALUES
-    ('plan_1', 'labor_fee',    '劳务费',   'formula', NULL,  1),
-    ('plan_1', 'service_fee',  '服务费',   'rate',    0.08,  2),
-    ('plan_1', 'insurance',    '保险',     'fixed',   NULL,  3),
-    ('plan_1', 'tax_withhold', '税费代征', 'formula', NULL,  4)
-) AS f(plan_code, fee_code, fee_name, calc_type, default_rate, sort_order)
+    ('SCHEME_A', 'labor_fee',     '劳务费',   'formula', 'gross',                  NULL,  1),
+    ('SCHEME_A', 'service_fee',   '服务费',   'rate',    'gross * service_fee_rate', 0.02, 2),
+    ('SCHEME_B', 'labor_fee',     '劳务费',   'formula', 'gross',                  NULL,  1),
+    ('SCHEME_B', 'tax_withhold',  '个税预扣', 'formula', 'gross*440/3000',         NULL,  2),
+    ('plan_1',   'labor_fee',     '劳务费',   'formula', NULL,                     NULL,  1),
+    ('plan_1',   'service_fee',   '服务费',   'rate',    NULL,                     0.08,  2),
+    ('plan_1',   'insurance',     '保险',     'fixed',   NULL,                     NULL,  3),
+    ('plan_1',   'tax_withhold',  '税费代征', 'formula', NULL,                     NULL,  4)
+) AS f(plan_code, fee_code, fee_name, calc_type, calc_expression, default_rate, sort_order)
 ON p.plan_code = f.plan_code;
 
 -- -----------------------------------------------------------------------------

huimv-employment/fe-api/src/main/java/com/huimv/employment/controller/mcp/McpDraftController.java

@@ -89,7 +89,7 @@ public class McpDraftController {
 
     @PostMapping("/submit")
     @Operation(summary = "确认并提交草稿",
-            description = "用户选定方案后转化为正式订单，需先调用 calculate。",
+            description = "用户选定方案后转化为正式订单，并创建登记批次、立刻生成小程序码（fe_registration_batch.qr_code_url）。需先调用 calculate。",
             parameters = {
                     @Parameter(name = "X-Fe-Ai-Key", in = ParameterIn.HEADER)
             })

huimv-employment/fe-api/src/main/java/com/huimv/employment/controller/mp/DraftController.java

@@ -46,7 +46,8 @@ public class DraftController {
 
     @GetMapping("/{id}")
     @Operation(summary = "查询用工草稿详情",
-            description = "返回草稿主表字段及 fe_draft_field 字段明细（含来源、可编辑性）。仅可查询本企业草稿。")
+            description = "返回草稿主表字段及 fe_draft_field 字段明细（含来源、可编辑性）；"
+                    + "确认方案后额外返回 qr_code_url（来自 fe_registration_batch）。仅可查询本企业草稿。")
     public R<DraftDetailResponse> getDetail(@PathVariable("id") Long draftId) {
         LoginUser loginUser = requireEnterprise();
         return R.ok(draftService.getDetail(loginUser.getUserId(), draftId));
@@ -74,7 +75,8 @@ public class DraftController {
     @PostMapping("/{id}/confirm")
     @Operation(summary = "确认此方案",
             description = "草稿 pending 且 missingFields 为空后调用。传入 selected_scheme_code（如 SCHEME_A）："
-                    + "1）生成正式订单；2）将草稿 status 更新为 confirmed（含 confirmed_at/confirmed_by）；"
+                    + "1）生成正式订单；2）草稿置为 confirmed；"
+                    + "3）创建 fe_registration_batch 并立刻生成小程序码写入 qr_code_url；"
                     + "若尚未测算会自动先测算。")
     public R<DraftConfirmResponse> confirm(@PathVariable("id") Long draftId,
                                            @Validated @RequestBody DraftConfirmRequest request) {

huimv-employment/fe-api/src/main/java/com/huimv/employment/controller/publicapi/RegistrationQrController.java

@@ -0,0 +1,41 @@
+package com.huimv.employment.controller.publicapi;
+
+import com.huimv.employment.service.registration.RegistrationBatchService;
+import io.swagger.v3.oas.annotations.Operation;
+import io.swagger.v3.oas.annotations.tags.Tag;
+import org.springframework.http.HttpHeaders;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.MediaType;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.PathVariable;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
+
+/**
+ * 登记小程序码图片公开访问（路径写入 {@code fe_registration_batch.qr_code_url}）。
+ */
+@RestController
+@RequestMapping("/api/v1/public/registration-qr")
+@Tag(name = "登记小程序码", description = "公开访问登记批次小程序码 PNG")
+public class RegistrationQrController {
+
+    private final RegistrationBatchService registrationBatchService;
+
+    public RegistrationQrController(RegistrationBatchService registrationBatchService) {
+        this.registrationBatchService = registrationBatchService;
+    }
+
+    @GetMapping("/{scene}.png")
+    @Operation(summary = "获取登记小程序码图片（scene=订单编号）")
+    public ResponseEntity<byte[]> getQrPng(@PathVariable("scene") String scene) {
+        byte[] png = registrationBatchService.readQrPng(scene);
+        if (png == null || png.length == 0) {
+            return ResponseEntity.status(HttpStatus.NOT_FOUND).build();
+        }
+        HttpHeaders headers = new HttpHeaders();
+        headers.setContentType(MediaType.IMAGE_PNG);
+        headers.setCacheControl("public, max-age=86400");
+        return new ResponseEntity<>(png, headers, HttpStatus.OK);
+    }
+}

huimv-employment/fe-api/src/main/resources/application.yml

@@ -39,6 +39,19 @@ fe:
       app-id: wx01c326e8fff67376
       app-secret: 54715e3f42f5421e5771c58cbf2dedb3
       mock-openid: mock_wx_openid_dev
+  registration:
+    qr:
+      # 对应 POST /wxa/getwxacodeunlimit
+      page: pages/worker/job-offer
+      # 页面未发布到微信后台前务必 false，否则易报 41030/85079
+      check-path: false
+      env-version: release
+      # 微信失败时写占位图，避免确认方案失败回滚；真正上线可改为 false
+      fallback-mock-on-error: true
+      width: 430
+      default-valid-days: 7
+      storage-path: ${FE_QR_STORAGE_PATH:./data/registration-qr}
+      public-url-prefix: ${FE_QR_PUBLIC_URL_PREFIX:}
   sms:
     mock-enabled: true
     mock-code: "123456"

huimv-employment/fe-dao/src/main/java/com/huimv/employment/dao/entity/FeRegistrationBatch.java

@@ -0,0 +1,211 @@
+package com.huimv.employment.dao.entity;
+
+import com.baomidou.mybatisplus.annotation.IdType;
+import com.baomidou.mybatisplus.annotation.TableId;
+import com.baomidou.mybatisplus.annotation.TableLogic;
+import com.baomidou.mybatisplus.annotation.TableName;
+
+import java.time.LocalDateTime;
+
+/**
+ * 临时工扫码登记批次 {@code fe_registration_batch} 实体。
+ */
+@TableName("fe_registration_batch")
+public class FeRegistrationBatch {
+
+    @TableId(type = IdType.AUTO)
+    private Long id;
+
+    private String batchNo;
+
+    private Long orderId;
+
+    private Long enterpriseId;
+
+    private Integer expectedCount;
+
+    private Integer registeredCount;
+
+    private Integer pendingCount;
+
+    private Integer inProgressCount;
+
+    private Integer completedCount;
+
+    private Integer abnormalCount;
+
+    /** 小程序登记页 path（可带 token 查询参数） */
+    private String registrationUrl;
+
+    /** 小程序码图片可访问 URL */
+    private String qrCodeUrl;
+
+    /** 扫码 scene / 校验 token，最长 32（微信 scene 限制） */
+    private String qrToken;
+
+    private LocalDateTime validFrom;
+
+    private LocalDateTime validUntil;
+
+    /** active / expired / closed */
+    private String status;
+
+    private LocalDateTime createTime;
+
+    private LocalDateTime updateTime;
+
+    @TableLogic
+    private Integer delFlag;
+
+    public Long getId() {
+        return id;
+    }
+
+    public void setId(Long id) {
+        this.id = id;
+    }
+
+    public String getBatchNo() {
+        return batchNo;
+    }
+
+    public void setBatchNo(String batchNo) {
+        this.batchNo = batchNo;
+    }
+
+    public Long getOrderId() {
+        return orderId;
+    }
+
+    public void setOrderId(Long orderId) {
+        this.orderId = orderId;
+    }
+
+    public Long getEnterpriseId() {
+        return enterpriseId;
+    }
+
+    public void setEnterpriseId(Long enterpriseId) {
+        this.enterpriseId = enterpriseId;
+    }
+
+    public Integer getExpectedCount() {
+        return expectedCount;
+    }
+
+    public void setExpectedCount(Integer expectedCount) {
+        this.expectedCount = expectedCount;
+    }
+
+    public Integer getRegisteredCount() {
+        return registeredCount;
+    }
+
+    public void setRegisteredCount(Integer registeredCount) {
+        this.registeredCount = registeredCount;
+    }
+
+    public Integer getPendingCount() {
+        return pendingCount;
+    }
+
+    public void setPendingCount(Integer pendingCount) {
+        this.pendingCount = pendingCount;
+    }
+
+    public Integer getInProgressCount() {
+        return inProgressCount;
+    }
+
+    public void setInProgressCount(Integer inProgressCount) {
+        this.inProgressCount = inProgressCount;
+    }
+
+    public Integer getCompletedCount() {
+        return completedCount;
+    }
+
+    public void setCompletedCount(Integer completedCount) {
+        this.completedCount = completedCount;
+    }
+
+    public Integer getAbnormalCount() {
+        return abnormalCount;
+    }
+
+    public void setAbnormalCount(Integer abnormalCount) {
+        this.abnormalCount = abnormalCount;
+    }
+
+    public String getRegistrationUrl() {
+        return registrationUrl;
+    }
+
+    public void setRegistrationUrl(String registrationUrl) {
+        this.registrationUrl = registrationUrl;
+    }
+
+    public String getQrCodeUrl() {
+        return qrCodeUrl;
+    }
+
+    public void setQrCodeUrl(String qrCodeUrl) {
+        this.qrCodeUrl = qrCodeUrl;
+    }
+
+    public String getQrToken() {
+        return qrToken;
+    }
+
+    public void setQrToken(String qrToken) {
+        this.qrToken = qrToken;
+    }
+
+    public LocalDateTime getValidFrom() {
+        return validFrom;
+    }
+
+    public void setValidFrom(LocalDateTime validFrom) {
+        this.validFrom = validFrom;
+    }
+
+    public LocalDateTime getValidUntil() {
+        return validUntil;
+    }
+
+    public void setValidUntil(LocalDateTime validUntil) {
+        this.validUntil = validUntil;
+    }
+
+    public String getStatus() {
+        return status;
+    }
+
+    public void setStatus(String status) {
+        this.status = status;
+    }
+
+    public LocalDateTime getCreateTime() {
+        return createTime;
+    }
+
+    public void setCreateTime(LocalDateTime createTime) {
+        this.createTime = createTime;
+    }
+
+    public LocalDateTime getUpdateTime() {
+        return updateTime;
+    }
+
+    public void setUpdateTime(LocalDateTime updateTime) {
+        this.updateTime = updateTime;
+    }
+
+    public Integer getDelFlag() {
+        return delFlag;
+    }
+
+    public void setDelFlag(Integer delFlag) {
+        this.delFlag = delFlag;
+    }
+}

huimv-employment/fe-dao/src/main/java/com/huimv/employment/dao/mapper/FeRegistrationBatchMapper.java

@@ -0,0 +1,9 @@
+package com.huimv.employment.dao.mapper;
+
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+import com.huimv.employment.dao.entity.FeRegistrationBatch;
+import org.apache.ibatis.annotations.Mapper;
+
+@Mapper
+public interface FeRegistrationBatchMapper extends BaseMapper<FeRegistrationBatch> {
+}

huimv-employment/fe-service/src/main/java/com/huimv/employment/service/config/RegistrationQrConfiguration.java

@@ -0,0 +1,9 @@
+package com.huimv.employment.service.config;
+
+import org.springframework.boot.context.properties.EnableConfigurationProperties;
+import org.springframework.context.annotation.Configuration;
+
+@Configuration
+@EnableConfigurationProperties(RegistrationQrProperties.class)
+public class RegistrationQrConfiguration {
+}

huimv-employment/fe-service/src/main/java/com/huimv/employment/service/config/RegistrationQrProperties.java

@@ -0,0 +1,109 @@
+package com.huimv.employment.service.config;
+
+import org.springframework.boot.context.properties.ConfigurationProperties;
+
+/**
+ * 登记小程序码配置，绑定 {@code fe.registration.qr.*}。
+ */
+@ConfigurationProperties(prefix = "fe.registration.qr")
+public class RegistrationQrProperties {
+
+    /**
+     * getwxacodeunlimit.page（不要以 / 开头，不要带 query）。
+     * 对应 POST /wxa/getwxacodeunlimit 的 page。
+     */
+    private String page = "pages/worker/job-offer";
+
+    /** release / trial / develop */
+    private String envVersion = "release";
+
+    /**
+     * 是否校验 page 存在；对应 check_path。
+     * 正式发布 pages/worker/job-offer 后可设 true；未发布时 true 会导致微信 41030/85079。
+     */
+    private boolean checkPath = false;
+
+    /**
+     * 微信生成失败时是否落 Mock PNG，避免确认方案整单回滚。
+     * 生产建议 false，联调可 true。
+     */
+    private boolean fallbackMockOnError = true;
+
+    private int width = 430;
+
+    /** 草稿未配置 qr_valid_days 时的默认有效天数 */
+    private int defaultValidDays = 7;
+
+    /** 小程序码 PNG 本地存储目录 */
+    private String storagePath = "./data/registration-qr";
+
+    /**
+     * 对外访问前缀，写入 {@code qr_code_url}。
+     * 为空则使用相对路径 {@code /api/v1/public/registration-qr/{token}.png}。
+     */
+    private String publicUrlPrefix = "";
+
+    public String getPage() {
+        return page;
+    }
+
+    public void setPage(String page) {
+        this.page = page;
+    }
+
+    public String getEnvVersion() {
+        return envVersion;
+    }
+
+    public void setEnvVersion(String envVersion) {
+        this.envVersion = envVersion;
+    }
+
+    public boolean isCheckPath() {
+        return checkPath;
+    }
+
+    public void setCheckPath(boolean checkPath) {
+        this.checkPath = checkPath;
+    }
+
+    public boolean isFallbackMockOnError() {
+        return fallbackMockOnError;
+    }
+
+    public void setFallbackMockOnError(boolean fallbackMockOnError) {
+        this.fallbackMockOnError = fallbackMockOnError;
+    }
+
+    public int getWidth() {
+        return width;
+    }
+
+    public void setWidth(int width) {
+        this.width = width;
+    }
+
+    public int getDefaultValidDays() {
+        return defaultValidDays;
+    }
+
+    public void setDefaultValidDays(int defaultValidDays) {
+        this.defaultValidDays = defaultValidDays;
+    }
+
+    public String getStoragePath() {
+        return storagePath;
+    }
+
+    public void setStoragePath(String storagePath) {
+        this.storagePath = storagePath;
+    }
+
+    public String getPublicUrlPrefix() {
+        return publicUrlPrefix;
+    }
+
+    public void setPublicUrlPrefix(String publicUrlPrefix) {
+        this.publicUrlPrefix = publicUrlPrefix;
+    }
+}

huimv-employment/fe-service/src/main/java/com/huimv/employment/service/draft/DraftService.java

@@ -11,10 +11,12 @@ import com.huimv.employment.dao.entity.FeDraftField;
 import com.huimv.employment.dao.entity.FeEmploymentDraft;
 import com.huimv.employment.dao.entity.FeEmploymentOrder;
 import com.huimv.employment.dao.entity.FeEnterprise;
+import com.huimv.employment.dao.entity.FeRegistrationBatch;
 import com.huimv.employment.dao.mapper.FeDraftCostSnapshotMapper;
 import com.huimv.employment.dao.mapper.FeDraftFieldMapper;
 import com.huimv.employment.dao.mapper.FeEmploymentDraftMapper;
 import com.huimv.employment.dao.mapper.FeEmploymentOrderMapper;
+import com.huimv.employment.dao.mapper.FeRegistrationBatchMapper;
 import com.huimv.employment.service.draft.dto.DraftConfirmRequest;
 import com.huimv.employment.service.draft.dto.DraftConfirmResponse;
 import com.huimv.employment.service.draft.dto.DraftDetailResponse;
@@ -22,6 +24,7 @@ import com.huimv.employment.service.draft.dto.DraftFieldResponse;
 import com.huimv.employment.service.draft.dto.DraftUpdateRequest;
 import com.huimv.employment.service.draft.dto.McpDraftCalculateResponse;
 import com.huimv.employment.service.enterprise.EnterpriseService;
+import com.huimv.employment.service.registration.RegistrationBatchService;
 import org.springframework.dao.DuplicateKeyException;
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;
@@ -76,23 +79,29 @@ public class DraftService {
     private final FeDraftFieldMapper feDraftFieldMapper;
     private final FeDraftCostSnapshotMapper feDraftCostSnapshotMapper;
     private final FeEmploymentOrderMapper feEmploymentOrderMapper;
+    private final FeRegistrationBatchMapper feRegistrationBatchMapper;
     private final EnterpriseService enterpriseService;
     private final DraftCostCalculationEngine draftCostCalculationEngine;
+    private final RegistrationBatchService registrationBatchService;
     private final ObjectMapper objectMapper;
 
     public DraftService(FeEmploymentDraftMapper feEmploymentDraftMapper,
                         FeDraftFieldMapper feDraftFieldMapper,
                         FeDraftCostSnapshotMapper feDraftCostSnapshotMapper,
                         FeEmploymentOrderMapper feEmploymentOrderMapper,
+                        FeRegistrationBatchMapper feRegistrationBatchMapper,
                         EnterpriseService enterpriseService,
                         DraftCostCalculationEngine draftCostCalculationEngine,
+                        RegistrationBatchService registrationBatchService,
                         ObjectMapper objectMapper) {
         this.feEmploymentDraftMapper = feEmploymentDraftMapper;
         this.feDraftFieldMapper = feDraftFieldMapper;
         this.feDraftCostSnapshotMapper = feDraftCostSnapshotMapper;
         this.feEmploymentOrderMapper = feEmploymentOrderMapper;
+        this.feRegistrationBatchMapper = feRegistrationBatchMapper;
         this.enterpriseService = enterpriseService;
         this.draftCostCalculationEngine = draftCostCalculationEngine;
+        this.registrationBatchService = registrationBatchService;
         this.objectMapper = objectMapper;
     }
 
@@ -184,12 +193,19 @@ public class DraftService {
             throw new BizException(ErrorCode.DRAFT_NOT_EDITABLE);
         }
 
+        // 3) 创建登记批次并立刻写入小程序码（fe_registration_batch.qr_code_url）
+        FeRegistrationBatch batch = registrationBatchService.createForOrder(order, draft, now);
+
         DraftConfirmResponse response = new DraftConfirmResponse();
         response.setStatus(CONFIRM_SUCCESS);
         response.setDraftStatus(STATUS_CONFIRMED);
         response.setOrderId(order.getOrderNo());
         response.setDraftId(draft.getId());
         response.setSelectedSchemeCode(schemeCode);
+        response.setBatchId(batch.getBatchNo());
+        response.setRegistrationUrl(batch.getRegistrationUrl());
+        response.setQrCodeUrl(batch.getQrCodeUrl());
+        response.setQrToken(batch.getQrToken());
         return response;
     }
 
@@ -511,12 +527,32 @@ public class DraftService {
         response.setEstimatedTotal(draft.getEstimatedTotal());
         response.setEstimatedPerCapita(draft.getEstimatedPerCapita());
         response.setSelectedPlanId(draft.getSelectedPlanId());
+        response.setQrCodeUrl(findQrCodeUrlByDraftId(draft.getId()));
         response.setFields(fields.stream().map(this::toFieldResponse).collect(Collectors.toList()));
         response.setCreateTime(draft.getCreateTime());
         response.setUpdateTime(draft.getUpdateTime());
         return response;
     }
 
+    /** 草稿确认后关联订单 → 登记批次上的小程序码；未确认则为 null。 */
+    private String findQrCodeUrlByDraftId(Long draftId) {
+        if (draftId == null) {
+            return null;
+        }
+        FeEmploymentOrder order = feEmploymentOrderMapper.selectOne(new LambdaQueryWrapper<FeEmploymentOrder>()
+                .eq(FeEmploymentOrder::getDraftId, draftId)
+                .orderByDesc(FeEmploymentOrder::getId)
+                .last("LIMIT 1"));
+        if (order == null) {
+            return null;
+        }
+        FeRegistrationBatch batch = feRegistrationBatchMapper.selectOne(new LambdaQueryWrapper<FeRegistrationBatch>()
+                .eq(FeRegistrationBatch::getOrderId, order.getId())
+                .orderByDesc(FeRegistrationBatch::getId)
+                .last("LIMIT 1"));
+        return batch != null ? batch.getQrCodeUrl() : null;
+    }
+
     private DraftFieldResponse toFieldResponse(FeDraftField entity) {
         DraftFieldResponse response = new DraftFieldResponse();
         response.setFieldKey(entity.getFieldKey());

huimv-employment/fe-service/src/main/java/com/huimv/employment/service/draft/McpDraftService.java

@@ -10,11 +10,13 @@ import com.huimv.employment.dao.entity.FeDraftField;
 import com.huimv.employment.dao.entity.FeEmploymentDraft;
 import com.huimv.employment.dao.entity.FeEmploymentOrder;
 import com.huimv.employment.dao.entity.FeEnterprise;
+import com.huimv.employment.dao.entity.FeRegistrationBatch;
 import com.huimv.employment.dao.mapper.FeDraftCostSnapshotMapper;
 import com.huimv.employment.dao.mapper.FeDraftFieldMapper;
 import com.huimv.employment.dao.mapper.FeEmploymentDraftMapper;
 import com.huimv.employment.dao.mapper.FeEmploymentOrderMapper;
 import com.huimv.employment.service.conversation.ConversationService;
+import com.huimv.employment.service.registration.RegistrationBatchService;
 import com.huimv.employment.service.draft.dto.McpDraftCalculateResponse;
 import com.huimv.employment.service.draft.dto.McpDraftGenerateRequest;
 import com.huimv.employment.service.draft.dto.McpDraftGenerateResponse;
@@ -81,6 +83,7 @@ public class McpDraftService {
     private final ConversationService conversationService;
     private final EnterpriseService enterpriseService;
     private final DraftCostCalculationEngine draftCostCalculationEngine;
+    private final RegistrationBatchService registrationBatchService;
     private final ObjectMapper objectMapper;
 
     public McpDraftService(FeEmploymentDraftMapper feEmploymentDraftMapper,
@@ -90,6 +93,7 @@ public class McpDraftService {
                            ConversationService conversationService,
                            EnterpriseService enterpriseService,
                            DraftCostCalculationEngine draftCostCalculationEngine,
+                           RegistrationBatchService registrationBatchService,
                            ObjectMapper objectMapper) {
         this.feEmploymentDraftMapper = feEmploymentDraftMapper;
         this.feDraftFieldMapper = feDraftFieldMapper;
@@ -98,6 +102,7 @@ public class McpDraftService {
         this.conversationService = conversationService;
         this.enterpriseService = enterpriseService;
         this.draftCostCalculationEngine = draftCostCalculationEngine;
+        this.registrationBatchService = registrationBatchService;
         this.objectMapper = objectMapper;
     }
 
@@ -202,9 +207,14 @@ public class McpDraftService {
         draftUpdate.setUpdateTime(now);
         feEmploymentDraftMapper.updateById(draftUpdate);
 
+        FeRegistrationBatch batch = registrationBatchService.createForOrder(order, draft, now);
+
         McpDraftSubmitResponse response = new McpDraftSubmitResponse();
         response.setStatus(SUBMIT_SUCCESS);
         response.setOrderId(order.getOrderNo());
+        response.setBatchId(batch.getBatchNo());
+        response.setRegistrationUrl(batch.getRegistrationUrl());
+        response.setQrCodeUrl(batch.getQrCodeUrl());
         return response;
     }
 

huimv-employment/fe-service/src/main/java/com/huimv/employment/service/draft/dto/DraftConfirmResponse.java

@@ -25,6 +25,22 @@ public class DraftConfirmResponse {
     @Schema(description = "确认的方案编码", example = "SCHEME_A")
     private String selectedSchemeCode;
 
+    @JsonProperty("batch_id")
+    @Schema(description = "登记批次业务编号", example = "bat_1")
+    private String batchId;
+
+    @JsonProperty("registration_url")
+    @Schema(description = "临时工登记页 path", example = "pages/worker/register?token=abc")
+    private String registrationUrl;
+
+    @JsonProperty("qr_code_url")
+    @Schema(description = "小程序码图片 URL（fe_registration_batch.qr_code_url）")
+    private String qrCodeUrl;
+
+    @JsonProperty("qr_token")
+    @Schema(description = "扫码登记 token（写入小程序码 scene）")
+    private String qrToken;
+
     public String getStatus() {
         return status;
     }
@@ -64,4 +80,36 @@ public class DraftConfirmResponse {
     public void setSelectedSchemeCode(String selectedSchemeCode) {
         this.selectedSchemeCode = selectedSchemeCode;
     }
+
+    public String getBatchId() {
+        return batchId;
+    }
+
+    public void setBatchId(String batchId) {
+        this.batchId = batchId;
+    }
+
+    public String getRegistrationUrl() {
+        return registrationUrl;
+    }
+
+    public void setRegistrationUrl(String registrationUrl) {
+        this.registrationUrl = registrationUrl;
+    }
+
+    public String getQrCodeUrl() {
+        return qrCodeUrl;
+    }
+
+    public void setQrCodeUrl(String qrCodeUrl) {
+        this.qrCodeUrl = qrCodeUrl;
+    }
+
+    public String getQrToken() {
+        return qrToken;
+    }
+
+    public void setQrToken(String qrToken) {
+        this.qrToken = qrToken;
+    }
 }

huimv-employment/fe-service/src/main/java/com/huimv/employment/service/draft/dto/DraftDetailResponse.java

@@ -1,5 +1,7 @@
 package com.huimv.employment.service.draft.dto;
 
+import com.fasterxml.jackson.annotation.JsonInclude;
+import com.fasterxml.jackson.annotation.JsonProperty;
 import io.swagger.v3.oas.annotations.media.Schema;
 
 import java.math.BigDecimal;
@@ -97,6 +99,11 @@ public class DraftDetailResponse {
     @Schema(description = "已选方案 ID")
     private Long selectedPlanId;
 
+    @JsonProperty("qr_code_url")
+    @JsonInclude(JsonInclude.Include.ALWAYS)
+    @Schema(description = "登记小程序码图片 URL（确认方案后由 fe_registration_batch 带回；未确认时为 null）")
+    private String qrCodeUrl;
+
     @Schema(description = "字段级明细（来源、可编辑性）")
     private List<DraftFieldResponse> fields;
 
@@ -330,6 +337,14 @@ public class DraftDetailResponse {
         this.selectedPlanId = selectedPlanId;
     }
 
+    public String getQrCodeUrl() {
+        return qrCodeUrl;
+    }
+
+    public void setQrCodeUrl(String qrCodeUrl) {
+        this.qrCodeUrl = qrCodeUrl;
+    }
+
     public List<DraftFieldResponse> getFields() {
         return fields;
     }

huimv-employment/fe-service/src/main/java/com/huimv/employment/service/draft/dto/McpDraftSubmitResponse.java

@@ -13,6 +13,18 @@ public class McpDraftSubmitResponse {
     @Schema(description = "生成的正式订单 ID", example = "ord_98765")
     private String orderId;
 
+    @JsonProperty("batch_id")
+    @Schema(description = "登记批次业务编号", example = "bat_1")
+    private String batchId;
+
+    @JsonProperty("registration_url")
+    @Schema(description = "临时工登记页 path")
+    private String registrationUrl;
+
+    @JsonProperty("qr_code_url")
+    @Schema(description = "小程序码图片 URL")
+    private String qrCodeUrl;
+
     public String getStatus() {
         return status;
     }
@@ -28,4 +40,28 @@ public class McpDraftSubmitResponse {
     public void setOrderId(String orderId) {
         this.orderId = orderId;
     }
+
+    public String getBatchId() {
+        return batchId;
+    }
+
+    public void setBatchId(String batchId) {
+        this.batchId = batchId;
+    }
+
+    public String getRegistrationUrl() {
+        return registrationUrl;
+    }
+
+    public void setRegistrationUrl(String registrationUrl) {
+        this.registrationUrl = registrationUrl;
+    }
+
+    public String getQrCodeUrl() {
+        return qrCodeUrl;
+    }
+
+    public void setQrCodeUrl(String qrCodeUrl) {
+        this.qrCodeUrl = qrCodeUrl;
+    }
 }

huimv-employment/fe-service/src/main/java/com/huimv/employment/service/registration/RegistrationBatchService.java

@@ -0,0 +1,199 @@
+package com.huimv.employment.service.registration;
+
+import com.huimv.employment.common.exception.BizException;
+import com.huimv.employment.common.exception.ErrorCode;
+import com.huimv.employment.dao.entity.FeEmploymentDraft;
+import com.huimv.employment.dao.entity.FeEmploymentOrder;
+import com.huimv.employment.dao.entity.FeRegistrationBatch;
+import com.huimv.employment.dao.mapper.FeEmploymentOrderMapper;
+import com.huimv.employment.dao.mapper.FeRegistrationBatchMapper;
+import com.huimv.employment.service.config.RegistrationQrProperties;
+import com.huimv.employment.service.wechat.WeChatMiniAppService;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.dao.DuplicateKeyException;
+import org.springframework.stereotype.Service;
+import org.springframework.util.StringUtils;
+
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.time.LocalDateTime;
+import java.util.regex.Pattern;
+
+/**
+ * 方案确认后创建登记批次，并立刻生成小程序码写入 {@code fe_registration_batch.qr_code_url}。
+ * <p>小程序码 scene = 订单编号，page = pages/worker/job-offer（见微信 getwxacodeunlimit）。</p>
+ */
+@Service
+public class RegistrationBatchService {
+
+    private static final Logger log = LoggerFactory.getLogger(RegistrationBatchService.class);
+
+    private static final String STATUS_ACTIVE = "active";
+    private static final String STEP_REGISTRATION = "registration";
+    private static final String PUBLIC_PATH_TEMPLATE = "/api/v1/public/registration-qr/%s.png";
+    /** 订单编号 / 文件名安全字符 */
+    private static final Pattern SAFE_SCENE = Pattern.compile("^[A-Za-z0-9_-]{1,32}$");
+
+    private final FeRegistrationBatchMapper feRegistrationBatchMapper;
+    private final FeEmploymentOrderMapper feEmploymentOrderMapper;
+    private final WeChatMiniAppService weChatMiniAppService;
+    private final RegistrationQrProperties qrProperties;
+
+    public RegistrationBatchService(FeRegistrationBatchMapper feRegistrationBatchMapper,
+                                    FeEmploymentOrderMapper feEmploymentOrderMapper,
+                                    WeChatMiniAppService weChatMiniAppService,
+                                    RegistrationQrProperties qrProperties) {
+        this.feRegistrationBatchMapper = feRegistrationBatchMapper;
+        this.feEmploymentOrderMapper = feEmploymentOrderMapper;
+        this.weChatMiniAppService = weChatMiniAppService;
+        this.qrProperties = qrProperties;
+    }
+
+    /**
+     * 一单一主批次：落批次 + 生成小程序码 + 推进订单步骤到 registration。
+     */
+    public FeRegistrationBatch createForOrder(FeEmploymentOrder order, FeEmploymentDraft draft, LocalDateTime now) {
+        if (order == null || order.getId() == null) {
+            throw new BizException(ErrorCode.BAD_REQUEST, "订单不存在，无法创建登记批次");
+        }
+        if (!StringUtils.hasText(order.getOrderNo()) || !SAFE_SCENE.matcher(order.getOrderNo().trim()).matches()) {
+            throw new BizException(ErrorCode.BAD_REQUEST, "订单编号无效，无法作为小程序码 scene");
+        }
+        // getwxacodeunlimit.scene = 订单编号（≤32）
+        String scene = order.getOrderNo().trim();
+        int validDays = resolveValidDays(draft);
+        String page = normalizePage(qrProperties.getPage());
+        String registrationUrl = page + "?scene=" + scene;
+
+        FeRegistrationBatch batch = new FeRegistrationBatch();
+        batch.setBatchNo("tmp_" + scene);
+        batch.setOrderId(order.getId());
+        batch.setEnterpriseId(order.getEnterpriseId());
+        int expected = order.getWorkerCount() != null && order.getWorkerCount() > 0
+                ? order.getWorkerCount() : 0;
+        batch.setExpectedCount(expected);
+        batch.setRegisteredCount(0);
+        batch.setPendingCount(expected);
+        batch.setInProgressCount(0);
+        batch.setCompletedCount(0);
+        batch.setAbnormalCount(0);
+        batch.setRegistrationUrl(registrationUrl);
+        batch.setQrToken(scene);
+        batch.setValidFrom(now);
+        batch.setValidUntil(now.plusDays(validDays));
+        batch.setStatus(STATUS_ACTIVE);
+        batch.setCreateTime(now);
+        batch.setUpdateTime(now);
+        batch.setDelFlag(0);
+
+        try {
+            feRegistrationBatchMapper.insert(batch);
+        } catch (DuplicateKeyException ex) {
+            throw new BizException(ErrorCode.BAD_REQUEST, "登记批次编号冲突，请重试");
+        }
+        batch.setBatchNo(String.format("bat_%d", batch.getId()));
+        feRegistrationBatchMapper.updateById(batch);
+
+        attachQrCode(batch, scene, now);
+        advanceOrderToRegistration(order.getId(), now);
+        return feRegistrationBatchMapper.selectById(batch.getId());
+    }
+
+    /** 按订单编号（scene）读取本地小程序码 PNG；不存在返回 null。 */
+    public byte[] readQrPng(String scene) {
+        if (!StringUtils.hasText(scene) || !SAFE_SCENE.matcher(scene.trim()).matches()) {
+            return null;
+        }
+        Path file = resolveQrFile(scene.trim());
+        if (!Files.isRegularFile(file)) {
+            return null;
+        }
+        try {
+            return Files.readAllBytes(file);
+        } catch (IOException ex) {
+            log.warn("读取小程序码失败 scene={}", scene, ex);
+            return null;
+        }
+    }
+
+    private void attachQrCode(FeRegistrationBatch batch, String scene, LocalDateTime now) {
+        try {
+            byte[] png;
+            try {
+                png = weChatMiniAppService.createRegistrationWxaCode(scene);
+            } catch (BizException ex) {
+                if (!qrProperties.isFallbackMockOnError()) {
+                    throw ex;
+                }
+                log.error("订单 orderId={} 微信小程序码失败，降级 Mock PNG: {}",
+                        batch.getOrderId(), ex.getMessage());
+                png = weChatMiniAppService.createRegistrationWxaCodeForFallback(scene);
+            }
+            Path file = resolveQrFile(scene);
+            Files.createDirectories(file.getParent());
+            Files.write(file, png);
+
+            String qrCodeUrl = buildPublicQrUrl(scene);
+            FeRegistrationBatch update = new FeRegistrationBatch();
+            update.setId(batch.getId());
+            update.setQrCodeUrl(qrCodeUrl);
+            update.setUpdateTime(now);
+            feRegistrationBatchMapper.updateById(update);
+            batch.setQrCodeUrl(qrCodeUrl);
+        } catch (BizException ex) {
+            log.error("订单 orderId={} 生成登记小程序码失败: {}", batch.getOrderId(), ex.getMessage());
+            throw ex;
+        } catch (Exception ex) {
+            log.error("订单 orderId={} 写入登记小程序码失败", batch.getOrderId(), ex);
+            throw new BizException(ErrorCode.INTERNAL_ERROR, "写入登记小程序码失败");
+        }
+    }
+
+    private void advanceOrderToRegistration(Long orderId, LocalDateTime now) {
+        FeEmploymentOrder update = new FeEmploymentOrder();
+        update.setId(orderId);
+        update.setCurrentStepCode(STEP_REGISTRATION);
+        update.setUpdateTime(now);
+        feEmploymentOrderMapper.updateById(update);
+    }
+
+    private int resolveValidDays(FeEmploymentDraft draft) {
+        if (draft != null && draft.getQrValidDays() != null && draft.getQrValidDays() > 0) {
+            return draft.getQrValidDays();
+        }
+        return Math.max(1, qrProperties.getDefaultValidDays());
+    }
+
+    private static String normalizePage(String page) {
+        if (!StringUtils.hasText(page)) {
+            return "pages/worker/job-offer";
+        }
+        String p = page.trim();
+        if (p.startsWith("/")) {
+            p = p.substring(1);
+        }
+        int q = p.indexOf('?');
+        if (q >= 0) {
+            p = p.substring(0, q);
+        }
+        return p;
+    }
+
+    private Path resolveQrFile(String scene) {
+        return Paths.get(qrProperties.getStoragePath()).toAbsolutePath().normalize()
+                .resolve(scene + ".png");
+    }
+
+    private String buildPublicQrUrl(String scene) {
+        String relative = String.format(PUBLIC_PATH_TEMPLATE, scene);
+        String prefix = qrProperties.getPublicUrlPrefix();
+        if (!StringUtils.hasText(prefix)) {
+            return relative;
+        }
+        String base = prefix.endsWith("/") ? prefix.substring(0, prefix.length() - 1) : prefix.trim();
+        return base + relative;
+    }
+}

huimv-employment/fe-service/src/main/java/com/huimv/employment/service/wechat/WeChatMiniAppService.java

@@ -2,26 +2,49 @@ package com.huimv.employment.service.wechat;
 
 import cn.binarywang.wx.miniapp.api.WxMaService;
 import cn.binarywang.wx.miniapp.bean.WxMaJscode2SessionResult;
+import cn.binarywang.wx.miniapp.bean.WxaCodeUnlimit;
+import cn.binarywang.wx.miniapp.executor.QrcodeBytesRequestExecutor;
 import com.huimv.employment.common.exception.BizException;
 import com.huimv.employment.common.exception.ErrorCode;
+import com.huimv.employment.service.config.RegistrationQrProperties;
 import com.huimv.employment.service.config.WeChatMiniAppProperties;
 import me.chanjar.weixin.common.error.WxErrorException;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 import org.springframework.beans.factory.ObjectProvider;
 import org.springframework.stereotype.Service;
 import org.springframework.util.StringUtils;
 
+import java.awt.Color;
+import java.awt.Font;
+import java.awt.Graphics2D;
+import java.awt.image.BufferedImage;
+import java.io.ByteArrayOutputStream;
+import java.util.regex.Pattern;
+import javax.imageio.ImageIO;
+
+import static cn.binarywang.wx.miniapp.constant.WxMaApiUrlConstants.Qrcode.GET_WXACODE_UNLIMIT_URL;
+
 /**
- * 微信小程序 code2session。
+ * 微信小程序：登录会话与登记小程序码。
  */
 @Service
 public class WeChatMiniAppService {
 
+    private static final Logger log = LoggerFactory.getLogger(WeChatMiniAppService.class);
+
+    /** 微信 scene 允许字符（不含中文空格等） */
+    private static final Pattern SCENE_PATTERN = Pattern.compile("^[0-9A-Za-z!#$&'()*+,/:;=?@\\-._~]{1,32}$");
+
     private final WeChatMiniAppProperties properties;
+    private final RegistrationQrProperties registrationQrProperties;
     private final ObjectProvider<WxMaService> wxMaServiceProvider;
 
     public WeChatMiniAppService(WeChatMiniAppProperties properties,
+                                RegistrationQrProperties registrationQrProperties,
                                 ObjectProvider<WxMaService> wxMaServiceProvider) {
         this.properties = properties;
+        this.registrationQrProperties = registrationQrProperties;
         this.wxMaServiceProvider = wxMaServiceProvider;
     }
 
@@ -44,6 +67,130 @@ public class WeChatMiniAppService {
         }
     }
 
+    /**
+     * 生成不限制的小程序码。
+     * <p>
+     * access_token 由 WxMaService 按
+     * {@code GET /cgi-bin/token?grant_type=client_credential&appid&secret} 自动获取；
+     * 码体对应 {@code POST /wxa/getwxacodeunlimit}，scene 传订单编号（最长 32）。
+     * </p>
+     */
+    public byte[] createRegistrationWxaCode(String scene) {
+        if (!StringUtils.hasText(scene)) {
+            throw new BizException(ErrorCode.BAD_REQUEST, "小程序码 scene（订单编号）不能为空");
+        }
+        String normalizedScene = scene.trim();
+        if (!SCENE_PATTERN.matcher(normalizedScene).matches()) {
+            throw new BizException(ErrorCode.BAD_REQUEST,
+                    "小程序码 scene 非法（仅支持 1-32 位数字/字母及 !#$&'()*+,/:;=?@-._~）：" + scene);
+        }
+        if (properties.isMockEnabled()) {
+            return createMockQrPng(normalizedScene, registrationQrProperties.getWidth());
+        }
+        WxMaService wxMaService = wxMaServiceProvider.getIfAvailable();
+        if (wxMaService == null) {
+            throw new BizException(ErrorCode.INTERNAL_ERROR, "微信小程序未配置");
+        }
+        String page = registrationQrProperties.getPage();
+        if (page != null && page.startsWith("/")) {
+            page = page.substring(1);
+        }
+        boolean checkPath = registrationQrProperties.isCheckPath();
+        try {
+            return invokeGetWxaCodeUnlimit(wxMaService, normalizedScene, page, checkPath);
+        } catch (WxErrorException ex) {
+            // 页面未发布到对应 env 时常见 41030 / 85079；自动降级为 check_path=false 再试一次
+            if (checkPath && isPagePathError(ex)) {
+                log.warn("check_path=true 生成失败，降级 check_path=false 重试 scene={}, page={}, err={}",
+                        normalizedScene, page, formatWxError(ex));
+                try {
+                    return invokeGetWxaCodeUnlimit(wxMaService, normalizedScene, page, false);
+                } catch (WxErrorException retryEx) {
+                    throw toQrBizException(normalizedScene, page, retryEx);
+                }
+            }
+            throw toQrBizException(normalizedScene, page, ex);
+        }
+    }
+
+    /**
+     * 组装与微信文档一致的请求体，禁止把 line_color 置 null（否则报「请求的参数不正确」）。
+     */
+    private byte[] invokeGetWxaCodeUnlimit(WxMaService wxMaService,
+                                           String scene,
+                                           String page,
+                                           boolean checkPath) throws WxErrorException {
+        WxaCodeUnlimit req = new WxaCodeUnlimit();
+        req.setScene(scene);
+        req.setPage(page);
+        req.setCheckPath(checkPath);
+        String env = registrationQrProperties.getEnvVersion();
+        req.setEnvVersion(StringUtils.hasText(env) ? env.trim() : "release");
+        int width = registrationQrProperties.getWidth();
+        req.setWidth(width > 0 ? width : 430);
+        // 保持 bean 默认 auto_color=true / line_color={"r":"0","g":"0","b":"0"}，勿 setLineColor(null)
+        log.info("调用 getwxacodeunlimit body={}", req.toJson());
+        return wxMaService.execute(
+                QrcodeBytesRequestExecutor.create(wxMaService.getRequestHttp()),
+                GET_WXACODE_UNLIMIT_URL,
+                req);
+    }
+
+    private static boolean isPagePathError(WxErrorException ex) {
+        if (ex.getError() == null) {
+            return false;
+        }
+        int code = ex.getError().getErrorCode();
+        // 41030 invalid page；85079 page not found / not published for env
+        return code == 41030 || code == 85079 || code == 40165 || code == 40212;
+    }
+
+    private BizException toQrBizException(String scene, String page, WxErrorException ex) {
+        String detail = formatWxError(ex);
+        log.warn("生成登记小程序码失败 scene={}, page={}, env={}, err={}",
+                scene, page, registrationQrProperties.getEnvVersion(), detail);
+        return new BizException(ErrorCode.INTERNAL_ERROR,
+                "生成登记小程序码失败：" + detail
+                        + "（请确认 access_token 有效，且 pages/worker/job-offer 已上传到 "
+                        + registrationQrProperties.getEnvVersion()
+                        + "；未发布时可将 fe.registration.qr.check-path 设为 false）");
+    }
+
+    private static String formatWxError(WxErrorException ex) {
+        if (ex.getError() == null) {
+            return ex.getMessage();
+        }
+        return "errcode=" + ex.getError().getErrorCode() + ", " + ex.getError().getErrorMsg();
+    }
+
+    /** 微信失败时的降级 PNG（不依赖 mock-enabled / 网络）。 */
+    public byte[] createRegistrationWxaCodeForFallback(String scene) {
+        return createMockQrPng(scene, registrationQrProperties.getWidth());
+    }
+
+    private static byte[] createMockQrPng(String scene, int width) {
+        int size = width > 0 ? width : 430;
+        BufferedImage image = new BufferedImage(size, size, BufferedImage.TYPE_INT_RGB);
+        Graphics2D g = image.createGraphics();
+        try {
+            g.setColor(Color.WHITE);
+            g.fillRect(0, 0, size, size);
+            g.setColor(Color.BLACK);
+            g.drawRect(8, 8, size - 16, size - 16);
+            g.setFont(new Font("SansSerif", Font.BOLD, 18));
+            g.drawString("MOCK WXA CODE", 24, size / 2 - 10);
+            g.setFont(new Font("SansSerif", Font.PLAIN, 14));
+            g.drawString(scene, 24, size / 2 + 20);
+            ByteArrayOutputStream out = new ByteArrayOutputStream();
+            ImageIO.write(image, "png", out);
+            return out.toByteArray();
+        } catch (Exception ex) {
+            throw new BizException(ErrorCode.INTERNAL_ERROR, "生成 Mock 小程序码失败");
+        } finally {
+            g.dispose();
+        }
+    }
+
     public static class WxSession {
         private final String openid;
         private final String unionid;