Merge branch 'develop' of https://git.reelshort2.com:80/jianghaifeng/FruitServer into develop

fix: 消除 JWT/签名密钥源码硬编码，全部改为环境变量注入
- JwtProperties.adminSecret/appSecret 默认值从 dev 密钥改为空字符串 - MediaProperties.signatureSecret 默认值从 dev 密钥改为空字符串 - app-api/admin-api application.yml 三处密钥回退值均改为空 - docker-compose.yml CORS_ALLOWED_ORIGINS 追加 ymb-site 3007 端口白名单 - .gitignore 追加 *.secrets.env / SSL 证书 / nginx 部署目录忽略规则
2026-11-13 16:55:07 +08:00 · 2026-11-13 16:53:53 +08:00 · 2026-11-13 13:43:16 +08:00 · 2026-11-13 12:30:55 +08:00 · 2026-11-09 10:35:37 +08:00 · 2026-11-09 10:32:53 +08:00
144 changed files with 6227 additions and 172 deletions
@@ -0,0 +1,25 @@
+# Author: fruit.com.cn
+# FruitServer 后端 CI：编译 + 测试门禁
+name: backend-ci
+
+on:
+  push:
+    branches: [develop, main]
+  pull_request:
+    branches: [develop, main]
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-java@v4
+        with:
+          distribution: temurin
+          java-version: "21"
+          cache: maven
+      - name: 编译 + 单测
+        run: mvn -B -T 1C test -DfailIfNoTests=false
+      - name: 打包（跳过测试）
+        if: success()
+        run: mvn -B package -DskipTests -q
@@ -19,4 +19,19 @@ data/uploads/*

 # 部署用的真实环境变量（含密钥），只提交 .env.example
 .env
+*.secrets.env
 dump.rdb
+
+# 看门狗飞书告警 Webhook，只存在于部署机
+deploy/feishu-webhook.txt
+
+# SSL 证书与私钥（.crt/.cer/.pem/.key/.p12/.jks）—— 部署机本地文件，禁止入库
+*.crt
+*.cer
+*.pem
+*.key
+*.p12
+*.jks
+
+# 部署用 nginx 配置目录（挂载卷的本地配置，随环境而异）
+nginx/
@@ -15,6 +15,20 @@
 FROM maven:3.9-eclipse-temurin-21 AS build
 WORKDIR /build

+# Maven Central 在国内网络下拉依赖不稳定（构建时曾出现 maven-filtering:3.3.1 解析失败），
+# 构建阶段固定走阿里云 central 镜像；其它仓库仍直连。
+RUN mkdir -p /root/.m2 \
+    && printf '%s\n' \
+       '<settings xmlns="http://maven.apache.org/SETTINGS/1.0.0">' \
+       '  <mirrors>' \
+       '    <mirror>' \
+       '      <id>aliyun-central</id>' \
+       '      <mirrorOf>central</mirrorOf>' \
+       '      <url>https://maven.aliyun.com/repository/central</url>' \
+       '    </mirror>' \
+       '  </mirrors>' \
+       '</settings>' > /root/.m2/settings.xml
+
 # 先只拷各模块 pom 再拉依赖：依赖层可复用，改业务代码不会重新下载依赖
 COPY pom.xml .
 COPY fruitshorts-common/pom.xml fruitshorts-common/
@@ -30,7 +44,7 @@ COPY fruitshorts-module-creator/pom.xml fruitshorts-module-creator/
 COPY fruitshorts-admin-api/pom.xml fruitshorts-admin-api/
 COPY fruitshorts-app-api/pom.xml fruitshorts-app-api/
 COPY fruitshorts-transcode-worker/pom.xml fruitshorts-transcode-worker/
-RUN mvn -B -q -DskipTests dependency:go-offline || true
+RUN mvn -B -q -DskipTests dependency:go-offline

 COPY . .
 ARG MODULE=fruitshorts-app-api
@@ -191,7 +191,7 @@ java -jar fruitshorts-app-api/target/fruitshorts-app-api-1.0.0-SNAPSHOT.jar

 ## 第一阶段实现进度

-> 最后更新：2026-10-16（后端 `develop` 分支 `4418a84`）。**未完成清单见文末「尚未完成」。**
+> 最后更新：2026-10-24（拉取 `develop` 最新代码后）。**未完成清单见文末「尚未完成」。**

 | 模块 | 状态 | 说明 |
 | --- | --- | --- |
@@ -200,11 +200,11 @@ java -jar fruitshorts-app-api/target/fruitshorts-app-api-1.0.0-SNAPSHOT.jar
 | 03 内容发现与详情 | 已实现 | 首页/发现/分类/详情；内容分级、可播区域、版权窗口、标签字段 |
 | 04 播放器与播放控制 | 已实现 | 播放票据 + 签名地址 + 进度；多码率 HLS 由转码 worker 产出（见 10） |
 | 05 记录、收藏与下载 | 已实现 | 进度、观看流水、收藏、离线下载授权与任务 |
-| 06 评论、点赞与分享 | 已实现 | 评论（游标翻页/审核/删除）、点赞、举报、敏感词；**分享埋点待 C3** |
+| 06 评论、点赞与分享 | 已实现 | 评论（游标翻页/审核/删除）、点赞、举报、敏感词、分享 |
 | 07 创作者中心 | 已实现 | **在后台管理（Web 端 `ReelShortWeb`）**：工作台、内容编辑、分片上传与断点续传、提交审核与上下架、分集收费与试看、数据看板；不含提现/结算。**App 客户端不提供创作者中心**（口径 2026-10-16） |
 | 08 平台运营后台 | 已实现 | 用户管理、内容治理、订单与权益、创作者与内容审核、数据看板 + 四个后台页面 |
 | 09 分集收费与支付 | 部分 | **Google Play 票据校验闭环已实现**（校验→建单→发权益、幂等与防重放、恢复购买、退款拒付回收、对账）；**Apple IAP 只留端口未实现**（印尼 iOS 占比低，文档口径为"预留"） |
-| 10 质量、数据与上线 | 部分 | **转码 worker（C1）已实现**；**Redis 缓存与限流（C2）、埋点（C3）、压测未做** |
+| 10 质量、数据与上线 | 部分 | **转码 worker（C1）、Redis 缓存与限流（C2）、埋点（C3）均已实现**；**压测未做** |

 ### 已完成批次（按提交顺序）

@@ -426,18 +426,18 @@ public Result<Long> create(@Valid @RequestBody DramaCategorySaveReqVO req) { ...

 ## 尚未完成

-> 最后更新：2026-10-16。完成后请同步本表与 [docs/api-phase1.md](docs/api-phase1.md)。
+> 最后更新：2026-10-24。完成后请同步本表与 [docs/api-phase1.md](docs/api-phase1.md)。

 ### 一、后端研发（剩余）

+> 已完成的项（不再列出）：**C2 Redis 缓存与限流**（`framework/redis` 的 `RedisService` + `RateLimit` 切面）、**C3 埋点**（客户端埋点 SDK），均于 10-20 ~ 10-23 落地。
+
 | # | 项 | 内容 | 依据 |
 | --- | --- | --- | --- |
-| 1 | **C2 Redis 缓存与限流** | 首页/发现/分类等热点接口缓存（Cache-Aside）+ 验证码/注册/登录限流；生产 Redis 规格 `4C16G 主从 2~3 哨兵` | 任务清单 C2、`17-风险评估` R-10、`10-安全方案` §三 |
-| 2 | **C3 埋点** | 播放/支付/转化事件 + 数据字典对齐（含 06 的分享埋点） | 任务清单 C3、`api-phase1` §3 |
-| 3 | **Apple IAP 票据校验** | 目前只留端口与枚举，未做真实校验（印尼 iOS 占比低，文档口径为"预留"） | `api-phase1` §1.8 |
-| 4 | **压测** | 目标 `P95 < 50ms`（预热后）；容量口径文档里有两套（"1 万并发"与"2 万并发 + 3000 QPS"），需定稿 | `09-测试计划` §五、`13/14-容量` |
-| 5 | **对账数据源** | 结算金额/手续费/税只能从 Play Console 财务报告取（需报表权限）；当前 `storeAmountSum` 恒为 `null` + `notes` 说明 | B1-2 待确认 |
-| 6 | **退款口径完善** | 部分退款按比例回收、退款实时性（当前由每日对账 + 手动驱动，未接 RTDN 推送） | B1-2 待确认 |
+| 1 | **Apple IAP 票据校验** | 目前只留端口与枚举，未做真实校验（印尼 iOS 占比低，文档口径为"预留"） | `api-phase1` §1.8 |
+| 2 | **压测** | 目标 `P95 < 50ms`（预热后）；容量口径文档里有两套（"1 万并发"与"2 万并发 + 3000 QPS"），需定稿 | `09-测试计划` §五、`13/14-容量` |
+| 3 | **对账数据源** | 结算金额/手续费/税只能从 Play Console 财务报告取（需报表权限）；当前 `storeAmountSum` 恒为 `null` + `notes` 说明 | B1-2 待确认 |
+| 4 | **退款口径完善** | 部分退款按比例回收、退款实时性（当前由每日对账 + 手动驱动，未接 RTDN 推送） | B1-2 待确认 |

 ### 二、上线前必补（P0 / Go-No-Go：非研发，但阻塞上线）

@@ -0,0 +1,38 @@
+<?xml version="1.0" encoding="UTF-16"?>
+<Task version="1.3" xmlns="http://schemas.microsoft.com/windows/2004/02/mit/task">
+  <RegistrationInfo>
+    <Description>FruitShorts backend watchdog: health check every 2 minutes and restart unhealthy services.</Description>
+  </RegistrationInfo>
+  <Principals>
+    <Principal id="Author">
+      <UserId>S-1-5-18</UserId>
+      <RunLevel>HighestAvailable</RunLevel>
+    </Principal>
+  </Principals>
+  <Settings>
+    <MultipleInstancesPolicy>IgnoreNew</MultipleInstancesPolicy>
+    <DisallowStartIfOnBatteries>false</DisallowStartIfOnBatteries>
+    <StopIfGoingOnBatteries>false</StopIfGoingOnBatteries>
+    <StartWhenAvailable>true</StartWhenAvailable>
+    <ExecutionTimeLimit>PT10M</ExecutionTimeLimit>
+  </Settings>
+  <Triggers>
+    <!-- BootTrigger 上挂 <Repetition> 在 Windows 计划任务里不生效（导入后 Next Run Time 为 N/A，
+         实际只在开机跑一次）。改成 TimeTrigger + 无限重复，配合 StartWhenAvailable
+         保证开机后若错过也会立即补跑；这样才真正做到每 2 分钟巡检一次。 -->
+    <TimeTrigger>
+      <StartBoundary>2026-01-01T00:00:00</StartBoundary>
+      <Repetition>
+        <Interval>PT2M</Interval>
+        <Duration>P3650D</Duration>
+        <StopAtDurationEnd>false</StopAtDurationEnd>
+      </Repetition>
+    </TimeTrigger>
+  </Triggers>
+  <Actions Context="Author">
+    <Exec>
+      <Command>powershell.exe</Command>
+      <Arguments>-NoProfile -ExecutionPolicy Bypass -File "C:\Users\Administrator\Desktop\ReelShorts\FruitServer\deploy\watchdog.ps1" -ComposeDir "C:\Users\Administrator\Desktop\ReelShorts\FruitServer" -LogDir "C:\Users\Administrator\Desktop\ReelShorts\FruitServer\logs"</Arguments>
+    </Exec>
+  </Actions>
+</Task>
@@ -0,0 +1,232 @@
+# Author: fruit.com.cn
+#
+# 服务看门狗：每 2 分钟检查一次，挂了自动拉起，连续失败发飞书告警。
+# 注册为 Windows 计划任务后无人值守运行。
+
+param(
+    [string]$ComposeDir = "C:\FruitServer",
+    [string]$LogDir = "C:\FruitServer\logs",
+    [string]$FeishuWebhook = "",
+    [int]$MaxRestarts = 3,
+    [string]$FrontendTask = "FruitShorts-Web-3005"
+)
+
+$ErrorActionPreference = "Continue"
+$ComposeFile = Join-Path $ComposeDir "docker-compose.yml"
+$LogFile = Join-Path $LogDir "watchdog-$(Get-Date -Format 'yyyy-MM-dd').log"
+# 连续失败计数落盘文件：计划任务每 2 分钟起一个新进程，计数只放进程内永远累积不到
+# $MaxRestarts，告警会静默哑火。
+$StateFile = Join-Path $LogDir "watchdog-state.json"
+
+function Write-Log($msg) {
+    $line = "$(Get-Date -Format 'yyyy-MM-dd HH:mm:ss') $msg"
+    Add-Content -Path $LogFile -Value $line -ErrorAction SilentlyContinue
+}
+
+function Send-Alert($title, $msg) {
+    if (-not $FeishuWebhook) { return }
+    $json = @{
+        msg_type = "text"
+        content  = @{ text = "[$title] $msg" }
+    } | ConvertTo-Json -Depth 3
+    try {
+        # PS5 的 Invoke-RestMethod 对字符串 body 默认按 Latin-1 编码，中文会变成 ???，
+        # 必须手动转 UTF-8 字节数组发送
+        $bytes = [System.Text.Encoding]::UTF8.GetBytes($json)
+        Invoke-RestMethod -Uri $FeishuWebhook -Method Post -Body $bytes -ContentType "application/json; charset=utf-8" -TimeoutSec 10
+    } catch {
+        Write-Log "飞书告警发送失败: $_"
+    }
+}
+
+# 连续失败计数的读写：JSON 落盘，跨进程保留
+function Import-FailCounts {
+    $counts = @{}
+    if (-not (Test-Path $StateFile)) { return $counts }
+    try {
+        $saved = Get-Content -Path $StateFile -Raw | ConvertFrom-Json
+        foreach ($prop in $saved.PSObject.Properties) {
+            $counts[$prop.Name] = [int]$prop.Value
+        }
+    } catch {
+        Write-Log "看门狗计数文件解析失败，各服务按 0 重新计数: $_"
+    }
+    return $counts
+}
+
+function Export-FailCounts($counts) {
+    try {
+        $counts | ConvertTo-Json | Set-Content -Path $StateFile -Encoding UTF8
+    } catch {
+        Write-Log "看门狗计数文件写入失败: $_"
+    }
+}
+
+function Test-Docker {
+    docker info --format "{{.ServerVersion}}" 2>$null | Out-Null
+    return ($LASTEXITCODE -eq 0)
+}
+
+function Test-Http([string]$url) {
+    try {
+        $response = Invoke-WebRequest -Uri $url -TimeoutSec 10 -UseBasicParsing -ErrorAction Stop
+        return ($response.StatusCode -ge 200 -and $response.StatusCode -lt 400)
+    } catch {
+        return $false
+    }
+}
+
+function Test-Container([string]$container) {
+    $status = docker inspect -f "{{.State.Status}}" $container 2>$null
+    return ($status -eq "running")
+}
+
+function Invoke-Compose([string[]]$composeArgs) {
+    & docker compose -f $ComposeFile @composeArgs 2>&1 | Out-Null
+    return $LASTEXITCODE
+}
+
+# 确保日志目录存在
+New-Item -ItemType Directory -Force -Path $LogDir | Out-Null
+
+# 告警 Webhook：命令行参数 > 环境变量 > deploy 目录下的 feishu-webhook.txt。
+# 计划任务注册命令里不写密钥（密钥不该进版本库），由部署机本地放文件或配环境变量。
+if (-not $FeishuWebhook) { $FeishuWebhook = $env:FRUITSHORTS_FEISHU_WEBHOOK }
+if (-not $FeishuWebhook) {
+    $webhookFile = Join-Path $PSScriptRoot "feishu-webhook.txt"
+    if (Test-Path $webhookFile) {
+        $FeishuWebhook = (Get-Content -Path $webhookFile -Raw -ErrorAction SilentlyContinue)
+        if ($FeishuWebhook) { $FeishuWebhook = $FeishuWebhook.Trim() }
+    }
+}
+if (-not $FeishuWebhook) {
+    Write-Log "未配置飞书 Webhook（参数/环境变量/feishu-webhook.txt 均为空），告警只写本地日志"
+}
+
+# Docker Desktop 登录后偶尔尚未就绪，先等待并尝试拉起。
+# 注意：本脚本以 SYSTEM 身份运行，绝不能直接 Start-Process Docker Desktop.exe。
+# WSL 不支持本地系统账户运行（WSL_E_LOCAL_SYSTEM_NOT_SUPPORTED），
+# 以 SYSTEM 启动会把 docker-desktop 发行版搞成僵死状态（VHD 已挂载无法终止），
+# 结果是登录用户会话里的 Docker Desktop 也永远起不来。
+# 因此改为触发以登录用户身份运行的 FruitShorts-DockerDesktop 计划任务。
+if (-not (Test-Docker)) {
+    Write-Log "Docker 未就绪，尝试通过用户会话启动 Docker Desktop"
+    $desktopTask = "FruitShorts-DockerDesktop"
+    try {
+        # Docker Desktop.exe 是任务进程树的一部分，GUI 活着时任务一直是 Running，
+        # 直接 Start-ScheduledTask 会被 IgnoreNew 忽略，所以先结束旧实例再拉起。
+        $t = Get-ScheduledTask -TaskName $desktopTask -ErrorAction Stop
+        if ($t.State -eq "Running") {
+            Stop-ScheduledTask -TaskName $desktopTask -ErrorAction SilentlyContinue
+            Start-Sleep -Seconds 5
+        }
+        Start-ScheduledTask -TaskName $desktopTask -ErrorAction Stop
+    } catch {
+        Write-Log "触发 Docker Desktop 启动任务失败: $_"
+    }
+
+    for ($i = 0; $i -lt 18; $i++) {
+        Start-Sleep -Seconds 5
+        if (Test-Docker) { break }
+    }
+}
+
+if (-not (Test-Docker)) {
+    Write-Log "Docker 在 90 秒内未就绪，跳过本轮检查"
+    Send-Alert "服务异常" "Docker Desktop 无法启动，请人工检查桌面机。"
+    exit 1
+}
+
+# 健康检查定义：名称 → 检查方式
+$checks = @(
+    @{ Name = "app-api";    Type = "http";     Url = "http://127.0.0.1:8081/healthz"; Service = "app-api"; Container = "fruitshorts-app-api" },
+    @{ Name = "admin-api";  Type = "http";     Url = "http://127.0.0.1:8080/healthz"; Service = "admin-api"; Container = "fruitshorts-admin-api" },
+    @{ Name = "frontend";   Type = "frontend"; Url = "http://127.0.0.1:3005/dist-dev/" },
+    @{ Name = "Grafana";    Type = "http";     Url = "http://127.0.0.1:3000/api/health"; Service = "grafana"; Container = "fruitshorts-grafana" },
+    @{ Name = "PostgreSQL"; Type = "docker";   Service = "db"; Container = "fruitshorts-db" },
+    @{ Name = "Redis";      Type = "docker";   Service = "redis"; Container = "fruitshorts-redis" },
+    @{ Name = "Prometheus"; Type = "http";     Url = "http://127.0.0.1:9090/-/healthy"; Service = "prometheus"; Container = "fruitshorts-prometheus" }
+)
+
+# 跟踪每个服务的连续失败次数（跨进程从状态文件恢复）
+$failCounts = Import-FailCounts
+
+foreach ($check in $checks) {
+    $name = $check.Name
+    $healthy = $false
+
+    if ($check.Type -eq "http") {
+        $healthy = Test-Http $check.Url
+    } elseif ($check.Type -eq "frontend") {
+        $healthy = Test-Http $check.Url
+    } else {
+        $healthy = Test-Container $check.Container
+    }
+
+    if ($healthy) {
+        if ($failCounts[$name] -gt 0) {
+            Write-Log "$name 恢复正常（此前连续失败 $($failCounts[$name]) 次）"
+            Send-Alert "服务恢复" "$name 已恢复正常"
+        }
+        $failCounts[$name] = 0
+    } else {
+        if ($null -eq $failCounts[$name]) {
+            $failCounts[$name] = 0
+        }
+        $failCounts[$name] = $failCounts[$name] + 1
+        $count = $failCounts[$name]
+        Write-Log "$name 不健康（第 $count 次）"
+
+        if ($check.Type -eq "frontend") {
+            Write-Log "$name 重启计划任务 $FrontendTask"
+            Stop-ScheduledTask -TaskName $FrontendTask -ErrorAction SilentlyContinue
+            Start-Sleep -Seconds 2
+            Start-ScheduledTask -TaskName $FrontendTask -ErrorAction SilentlyContinue
+            Start-Sleep -Seconds 6
+            $healthy = Test-Http $check.Url
+        } elseif ($check.Type -eq "http") {
+            Write-Log "$name 重启 Compose 服务 $($check.Service)"
+            Invoke-Compose @("restart", $check.Service) | Out-Null
+            Start-Sleep -Seconds 12
+            $healthy = Test-Http $check.Url
+
+            if (-not $healthy) {
+                Write-Log "$name 重启后仍不健康，执行 compose up -d"
+                Invoke-Compose @("up", "-d", $check.Service) | Out-Null
+            }
+        } else {
+            Write-Log "$name 拉起容器 $($check.Container)"
+            docker start $check.Container 2>&1 | Out-Null
+            Start-Sleep -Seconds 5
+            $healthy = Test-Container $check.Container
+
+            if (-not $healthy) {
+                Write-Log "$name 启动失败，执行 compose up -d"
+                Invoke-Compose @("up", "-d", $check.Service) | Out-Null
+            }
+        }
+
+        # 连续失败达到上限 → 告警。计数会跨进程累积，所以只在首次达阈值和
+        # 之后每 30 轮（约 1 小时）提醒一次，避免每 2 分钟刷屏。
+        if (-not $healthy -and $count -ge $MaxRestarts -and
+                ($count -eq $MaxRestarts -or $count % 30 -eq 0)) {
+            Send-Alert "服务异常" "$name 已连续 $count 次不健康，已尝试重启。请人工介入检查。"
+            Write-Log "$name 连续 $count 次失败，已发告警"
+        } elseif ($healthy) {
+            Write-Log "$name 已自动恢复"
+        }
+    }
+}
+
+# 磁盘检查：超过 85% 告警
+$drive = (Get-PSDrive C -ErrorAction SilentlyContinue)
+if ($drive) {
+    $pct = [math]::Round(($drive.Used / ($drive.Used + $drive.Free)) * 100)
+    if ($pct -gt 85) {
+        Write-Log "磁盘使用率 ${pct}%（超过 85%）"
+        Send-Alert "磁盘告警" "C 盘使用率 ${pct}%，请清理日志或扩容"
+    }
+}
+
+# 本轮结果落盘，供下一轮（2 分钟后的新进程）继续累加
+Export-FailCounts $failCounts
@@ -71,11 +71,16 @@ services:
    env_file: .env
    environment:
      SERVER_PORT: "8081"
-      # 默认连编排里的 db；要连外部库就在 .env 里覆盖 DB_URL
-      DB_URL: ${DB_URL:-jdbc:postgresql://db:5432/${DB_NAME:-fruitshorts}}
+      # 默认连编排里的 db；要连外部库就在 .env 里覆盖 DB_URL。
+      # reWriteBatchedInserts=true：pgjdbc 把 JDBC 批内多条 INSERT 重写成多值
+      # INSERT，观看进度缓冲落库（watch:pg:dirty 消费任务）依赖它跑满吞吐。
+      DB_URL: ${DB_URL:-jdbc:postgresql://db:5432/${DB_NAME:-fruitshorts}?reWriteBatchedInserts=true}
      # 限流/缓存用 Redis；容器内 127.0.0.1 是容器自身，必须指向编排里的 redis
      REDIS_HOST: ${REDIS_HOST:-redis}
      REDIS_PORT: ${REDIS_PORT:-6379}
+      # CORS：公网入口 nginx 把 SSL 跑在 80 端口上（腾讯云安全组只放 80），
+      # 浏览器 fetch 带 Origin 时端口不匹配会被 Spring CORS 拒（必须精确字符串匹配）。
+      CORS_ALLOWED_ORIGINS: "https://api.frostgiant.vip:80,https://api.frostgiant.vip,http://api.frostgiant.vip,https://39.162.50.99:8081,http://localhost:3005,http://127.0.0.1:3005,http://39.162.50.99:3007,http://192.168.31.250:3007"
    ports:
      - "8081:8081"
    volumes:
@@ -106,7 +111,8 @@ services:
      SERVER_PORT: "8080"
      SPRING_SERVLET_MULTIPART_MAX_FILE_SIZE: "2GB"
      SPRING_SERVLET_MULTIPART_MAX_REQUEST_SIZE: "2GB"
-      CORS_ALLOWED_ORIGINS: "http://localhost:3005,http://127.0.0.1:3005,http://39.162.50.99:3005,http://192.168.31.250:3005"
+      # 浏览后台时 Origin 是实际访问地址，必须精确列全：本机、局域网、公网 IP、域名。
+      CORS_ALLOWED_ORIGINS: "http://localhost:3005,http://127.0.0.1:3005,http://39.162.50.99:3005,http://192.168.31.250:3005,https://api.frostgiant.vip,https://admin.frostgiant.vip"
      DB_URL: ${DB_URL:-jdbc:postgresql://db:5432/${DB_NAME:-fruitshorts}}
      # 管理端仅内网，页面上直接播放/下载裸媒资地址（不签播放签名），
      # 因此这里不启用 /files/episode/** 的签名校验；公开的 app-api 仍保持开启。
@@ -197,9 +203,40 @@ services:
      GF_SECURITY_ADMIN_USER: ${GRAFANA_ADMIN_USER:-admin}
      GF_SECURITY_ADMIN_PASSWORD: ${GRAFANA_ADMIN_PASSWORD:?Grafana 管理员密码必填，见 .env.example}
      GF_USERS_ALLOW_SIGN_UP: "false"
+      # 新用户默认界面语言：简体中文
+      GF_USERS_LANGUAGE: "zh-Hans"
      TZ: Asia/Shanghai
    depends_on:
      - prometheus
+      - loki
+
+  # ─────────── 日志（Loki + Promtail）───────────
+  # Loki：日志存储与查询引擎；Promtail：采集容器 stdout/stderr 推给 Loki。
+  # Grafana 里通过 Loki 数据源可直接搜索/过滤各容器的请求日志。
+  loki:
+    image: grafana/loki:latest
+    container_name: fruitshorts-loki
+    restart: unless-stopped
+    command: -config.file=/etc/loki/local-config.yaml
+    volumes:
+      - ./loki-config.yml:/etc/loki/local-config.yaml:ro
+      - loki-data:/loki
+    expose:
+      - "3100"
+    # 镜像为 distroless（无 shell/wget），无法在容器内做 HTTP 探活；
+    # 靠 restart: unless-stopped 自动拉起，Grafana 数据源状态可反映可用性。
+
+  promtail:
+    image: grafana/promtail:latest
+    container_name: fruitshorts-promtail
+    restart: unless-stopped
+    command: -config.file=/etc/promtail/config.yml
+    volumes:
+      - ./promtail-config.yml:/etc/promtail/config.yml:ro
+      # 读取容器日志需要 Docker socket
+      - /var/run/docker.sock:/var/run/docker.sock:ro
+    depends_on:
+      - loki

  # 黑盒探活：从外部探测接口可用性与耗时
  blackbox:
@@ -227,3 +264,4 @@ volumes:
  redis-data:
  prometheus-data:
  grafana-data:
+  loki-data:
@@ -170,8 +170,9 @@ app.register.max-per-device-per-day
 | GET | `/app/home/feed` | 首页：轮播 + 分区，卡片带 `preview` 可播预览集与 `language` 语种 |
 | GET | `/app/discover/feed` | 发现页分区 |
 | GET | `/app/feed?types=ANIME,LIVE&categoryId=7&cursor=&size=20` | 推荐流；支持内容类型与分类叠加过滤，游标翻页 |
-| GET | `/app/categories` | 已启用首页分类。`name` 为中文，`locales` 为 `{zh,en,id}` |
+| GET | `/app/categories` | 已启用首页分类。名称在 `locales`；另带 `code`、`layoutType`（`GRID` / `RANKING`）、`revision` |
 | GET | `/app/categories/{id}/dramas?pageIndex=&pageSize=` | 分类下已上线短剧，分页。`pageIndex` 默认 1，`pageSize` 默认 20、最大 50 |
+| GET | `/app/categories/{id}/ranking` | 推荐榜快照；只接受 `layoutType=RANKING` 的已启用分类，按后台位置返回连续排名 |
 | GET | `/app/drama-categories` | 已启用类型。`locales` 为 `{zh,en,id}` |
 | GET | `/app/tags` | 已启用标签。`locales` 为 `{zh,en,id}` |
 | POST | `/app/dramas/page` | 全部短剧分页。请求体 `pageIndex`（默认 1）、`pageSize`（默认 20、最大 50）、`categoryIds`、`classificationIds`、`tagIds`。id 用 JSON 数组，不放查询串。同一组多选为或，组与组之间为且 |
@@ -205,6 +206,10 @@ app.register.max-per-device-per-day
 > 卡片文案只放语言表：`titleLocales`、`synopsisLocales`、`types`、`tagLocales`。
 > `tagColor` 是标签背景色。中文取各表的 `zh`。
 >
+> `tagCode` 是标签语义码（如 `NEW_ARRIVAL`），来自 `content_tag.code`。
+> 客户端按码判断板块（推荐页「上新」横滑），`tagLocales` 只用于展示；
+> 码为空时客户端才退回按文案匹配。后台标签管理可配置该码。
+>
 > 卡片新增 `dramaType`：`ANIME` 表示漫剧，`LIVE` 表示真人剧。
 > 客户端字段仍返回主内容类型；后台多选值保存在 `drama.drama_types`，
 > App 类型筛选按逗号列整词匹配，因此 `ANIME,LIVE` 多标签剧可被任一类型命中。
@@ -218,6 +223,28 @@ app.register.max-per-device-per-day
 > 只返回 `status = 1` 的剧单，排序与后台剧单排序一致，卡片顺序与后台关联顺序一致。
 > 剧单列表越界页返回空 `list`，`total` 仍是全部剧单数。详情越界页同样返回空 `list`。

+#### 推荐榜（`GET /app/categories/{id}/ranking`）
+
+- 分类列表中的 `layoutType=RANKING` 表示客户端必须使用榜单布局，禁止按分类名称判断。
+- 榜单内容与顺序以 `drama_classification_drama.position asc` 为准；客户端不得按播放量重新排序。
+- 已下架、未发布或不存在的短剧会被过滤，剩余项目的 `rank` 从 1 连续补齐。
+- 最多返回 50 部；`revision` 在后台保存内容或顺序后递增，供缓存与曝光埋点使用。
+- 响应 `list` 项结构为 `{rank, drama}`，其中 `drama` 沿用 `AppDramaCardVO`。
+
+```json
+{
+  "id": "2112807182243336193",
+  "code": "RECOMMEND_RANKING",
+  "locales": {"zh": "推荐榜", "en": "Top Picks", "id": "Pilihan Teratas"},
+  "revision": "8",
+  "generatedAt": "2026-11-02T10:00:00",
+  "total": 1,
+  "list": [
+    {"rank": 1, "drama": {"id": "2112807182243336194", "titleLocales": {"zh": "短剧 A"}}}
+  ]
+}
+```
+
 #### 推荐类型流（`GET /app/feed`）

 - `types` 可选，逗号分隔，支持 `ANIME`、`LIVE` 或多选 `ANIME,LIVE`；不传或空值返回全部已上线内容。
@@ -462,6 +489,7 @@ app.register.max-per-device-per-day
        "id": "Pengantin Pengganti: Kesayangan Presiden Direktur"
      },
      "dramaCover": "/files/drama_cover/12.jpg",
+      "dramaCoverLandscape": "/files/drama_cover/12-wide.jpg",
      "episodeNumber": 6,
      "totalEpisodes": 68,
      "viewCount": "1800",
@@ -484,7 +512,8 @@ app.register.max-per-device-per-day
 | --- | --- | --- |
 | `dramaTitle` | string / null | 短剧中文标题，旧客户端回退用 |
 | `titleLocales` | object / null | 短剧标题语言表，key 为 `zh` / `en` / `id`。客户端按当前语言取，没有对应语言时回退 `zh` |
-| `dramaCover` | string / null | 短剧封面 |
+| `dramaCover` | string / null | 短剧竖版封面 |
+| `dramaCoverLandscape` | string / null | 短剧横版封面，供继续观看横幅等横向位使用；为空时客户端回退 `dramaCover` |
 | `episodeNumber` | int / null | 当前续看集号 `ep_no` |
 | `totalEpisodes` | int / null | 短剧总集数 |
 | `viewCount` | Long（JSON 字符串）/ null | 短剧热度，取 `drama.view_count`。`playCount` 是用户自己的播放次数 |
@@ -557,6 +586,53 @@ app.register.max-per-device-per-day
 解锁后播放入口与下载入口会同时放行 —— 权益判定由交易模块的 `EntitlementPort` 实现提供，
 播放域与下载域都不需要改代码。金币变动一律带幂等键并写 `coin_ledger`，钱包余额与流水同事务。

+### 1.8.1 奖励中心（已实现）
+
+奖励中心复用钱包和金币流水，首发时区固定为 `Asia/Jakarta`。任务配置、奖励金币、任务文案、动作、周期和上下线状态均由后台维护；客户端不能直接提交任务进度，观看进度由服务端在 `/app/watch/progress` 校验成功后累计。
+
+| 方法 | 路径 | 鉴权 | 说明 |
+| --- | --- | --- | --- |
+| GET | `/app/rewards/overview` | 匿名 | 返回任务配置、任务分组、签到规则和活动卡片；未登录时余额为 `0`、用户进度为 `0`、签到状态为未签到；登录后补充用户数据；`locale` 可选 `id/en/zh` |
+| GET | `/app/rewards/activities` | 匿名 | 返回当前生效活动卡片，活动一期只展示和跳转 |
+| GET | `/app/rewards/check-in` | 登录 | 返回今日是否签到、连续天数、7 天规则 |
+| POST | `/app/rewards/check-in` | 登录 | 按服务端日期和连续签到规则发放金币；同用户同日期幂等 |
+| POST | `/app/rewards/tasks/{taskId}/claim` | 登录 | 领取已完成任务；同任务同周期幂等 |
+
+总览响应核心字段：
+
+```json
+{
+  "serverDate": "2026-11-05",
+  "timezone": "Asia/Jakarta",
+  "coinBalance": "135",
+  "checkin": {
+    "taskId": "202611050001",
+    "checkedInToday": false,
+    "streak": 2,
+    "currentDay": 3,
+    "days": [{"dayIndex": 1, "rewardCoin": "35", "checked": true, "current": false}]
+  },
+  "sections": [{
+    "code": "DAILY",
+    "title": "Tugas harian",
+    "tasks": [{
+      "id": "202611050002",
+      "code": "watch_5_minutes",
+      "type": "WATCH_DURATION",
+      "progressValue": "120",
+      "targetValue": "300",
+      "rewardCoin": "20",
+      "status": "IN_PROGRESS"
+    }]
+  }],
+  "activities": []
+}
+```
+
+一期任务类型为 `DAILY_CHECK_IN`、`WATCH_DURATION`、`WATCH_EPISODES`、`COMPLETE_PROFILE`、`FIRST_PURCHASE`；`FIRST_LOGIN` 预留给登录事件接入。任务状态为 `IN_PROGRESS`、`COMPLETED`、`CLAIMED`。奖励发放使用 `coin_ledger.biz_type=REWARD`，任务领取幂等键为 `reward:{taskCode}:{userId}:{cycleKey}`，签到幂等键为 `reward:checkin:{userId}:{date}`。重复请求返回既有发放结果，不重复增加钱包余额。
+
+失败场景：任务未完成或已停用返回 `200003`；任务、签到规则不存在返回 `200002`；奖励金币为 0 或请求参数非法返回 `400`；钱包余额和发放单不一致时整笔事务回滚。
+
 **`POST /app/orders/verify`（B1-1：Google Play 票据校验闭环）**

 请求体：
@@ -633,6 +709,7 @@ B1-2 的退款/拒付复验依赖它。服务端凭据（`packageName` + service
 | `noticeEnabled` | `app.notice.enabled` | `true` | 公告入口开关 |
 | `coinUnlockEnabled` | `app.coin.unlock.enabled` | `true` | 金币解锁开关 |
 | `downloadEnabled` | `app.download.enabled` | `true` | 离线下载开关 |
+| `loginBackgroundUrl` | `app.login.background.url` | `""` | 登录页全屏海报背景；留空 App 用内置默认图。**建议尺寸 1170×2532**（iPhone 14 Pro Max 3× 整屏竖图），后台走 `/admin/media/upload/` 任意 bizType 上传后把返回的相对路径（`/files/login_bg/xxx.jpg`）写入即可 |

 **口径**：**只下发上述白名单键**（服务端硬编码白名单），后台配置里的其它键（可能含内部开关）
 **一律不下发**；库里缺键时用「契约默认值」兜底，**不返回 null 让客户端自己猜默认值**。
@@ -1203,6 +1280,24 @@ commentSummary,createdAt`。游客的 userId 为空、anonymous 为 true；评

 > `id` 以字符串下发：见 **§0「ID 字段一律以字符串下发」**（本节不再单独规定）。

+### 2.11.1 奖励中心管理（已实现）
+
+| 方法 | 路径 | 权限点 | 说明 |
+| --- | --- | --- | --- |
+| GET | `/admin/rewards/tasks/page` · `/tasks/{id}` | `reward:list` | 奖励任务分页与详情 |
+| POST | `/admin/rewards/tasks` | `reward:update` | 新建任务，默认下线 |
+| PUT | `/admin/rewards/tasks/{id}` · `/{id}/status` | `reward:update` | 编辑、上线 / 下线；编辑会递增版本 |
+| GET | `/admin/rewards/activities/page` · `/activities/{id}` | `reward:list` | 奖励活动分页与详情 |
+| POST | `/admin/rewards/activities` | `reward:update` | 新建活动，默认下线 |
+| PUT | `/admin/rewards/activities/{id}` · `/{id}/status` | `reward:update` | 编辑、上线 / 下线 |
+| GET · PUT | `/admin/rewards/check-in/rules` | `reward:checkin` | 查看 / 保存签到每日奖励规则，天数不能重复 |
+| GET | `/admin/rewards/grants/page` | `reward:grant` | 用户、任务、来源、状态筛选发放记录 |
+| POST | `/admin/rewards/grants/manual` | `reward:grant` | 人工补发；仍写 `REWARD` 钱包流水并要求幂等键 |
+
+后台任务保存字段包括 `code`、`sectionCode`、`type`、`verifyMode`、`targetValue`、`rewardCoin`、`cycleType`、`cycleLimit`、三语言文案、动作、排序和生效时间。任务配置不允许后台写任意脚本，扩展字段只能放在 `configJson`。
+
+后台活动保存字段包括 `code`、`coverUrl`、`actionType`、`actionUrl`、三语言标题、三语言摘要、三语言按钮文案、排序和生效时间。活动与任务共用 `reward:update` 权限，新建活动默认下线。
+
 **校验与错误码**：

 | 场景 | 结果 |
@@ -1262,6 +1357,7 @@ commentSummary,createdAt`。游客的 userId 为空、anonymous 为 true；评
 | GET | `/admin/drama-classifications/{id}/dramas/candidates` | `drama:list` | 尚未关联到该分类的短剧（分页，供多选） |
 | POST | `/admin/drama-classifications/{id}/dramas` | `drama:update` | 批量关联短剧，返回实际新增数量 |
 | DELETE | `/admin/drama-classifications/{id}/dramas/{dramaId}` | `drama:update` | 从分类移出短剧（幂等） |
+| PUT | `/admin/drama-classifications/{id}/ranking-items` | `drama:update` | 原子保存推荐榜完整顺序，最多 50 部；空数组表示清空 |

 **列表响应**

@@ -1273,6 +1369,9 @@ commentSummary,createdAt`。游客的 userId 为空、anonymous 为 true；评
    {
      "id": "2112807182243336193",
      "name": "本周必看",
+      "code": "CLASSIFICATION_2112807182243336193",
+      "layoutType": "GRID",
+      "revision": "1",
      "sort": 1,
      "status": 1,
      "dramaCount": 12,
@@ -1288,12 +1387,20 @@ commentSummary,createdAt`。游客的 userId 为空、anonymous 为 true；评
 **新建 / 编辑请求体**

 ```json
-{ "name": "本周必看", "sort": 1, "status": 1 }
+{
+  "name": "推荐榜",
+  "code": "RECOMMEND_RANKING",
+  "layoutType": "RANKING",
+  "sort": 1,
+  "status": 1
+}
 ```

 | 字段 | 必填 | 说明 |
 | --- | --- | --- |
 | `name` | 是 | 去首尾空格后保存，全局唯一；`@NotBlank` 提示「请填写分类名称」 |
+| `code` | 否 | 稳定语义码，只允许大写字母、数字、下划线；不传时生成 `CLASSIFICATION_{id}` |
+| `layoutType` | 否 | `GRID` 普通分类 / `RANKING` 推荐榜；默认 `GRID` |
 | `sort` | 否 | 新建不传时取 `现有条数 + 1`；编辑不传（null）时保持原值 |
 | `status` | 否 | `1` 启用 / `0` 停用；新建默认 `1`，编辑不传保持原值 |

@@ -1307,6 +1414,11 @@ POST /admin/drama-classifications/2112807182243336193/dramas
 返回 `data` 为实际新增条数（整数）。已关联的、以及不存在的 `dramaId` 会被静默跳过，不报错；
 全部跳过时返回 `0`。`dramaIds` 为空数组 → `400 请选择短剧`。

+推荐榜应使用 `PUT /{id}/ranking-items` 一次提交完整有序 `dramaIds`。接口会去重、校验短剧存在，
+按数组顺序写入 `position=1..N` 并递增分类 `revision`；`dramaIds` 必须显式传数组，空数组表示清空。
+普通分类调用该接口返回 `200003`；推荐榜调用旧的 `POST /{id}/dramas` 或
+`DELETE /{id}/dramas/{dramaId}` 同样返回 `200003`，防止绕过版本与排序更新。
+
 **短剧列表项（`GET /{id}/dramas` 与 `/dramas/candidates` 共用）**

 ```json
@@ -70,8 +70,8 @@ public class CreatorAdminController {
        return Result.ok(creatorService.audit(id, req, SecurityUtils.getUserId()));
    }

-    /** 手工录入创作者主体（C 端申请入驻还没实现，先用它打通链路）。 */
-    @Operation(summary = "手工录入创作者主体")
+    /** 手工录入创作者主体：录入即通过，可直接开号。 */
+    @Operation(summary = "手工录入创作者主体（录入即通过）")
    @PostMapping
    @PreAuthorize("@ss.hasPermission('creator:audit')")
    @OperationLog(module = "创作者管理", action = "新增创作者")
@@ -79,8 +79,8 @@ public class CreatorAdminController {
        return Result.ok(creatorService.create(req));
    }

-    /** 开通创作者账号：仅审核通过可开；已开通则幂等返回，不重复建号。 */
-    @Operation(summary = "开通创作者账号（仅审核通过可开通，幂等）")
+    /** 开通创作者账号：不再校验入驻审核，仅冻结状态拒绝；已开通则幂等返回。 */
+    @Operation(summary = "开通创作者账号（仅冻结状态拒绝，幂等）")
    @PostMapping("/{id}/account")
    @PreAuthorize("@ss.hasPermission('creator:account')")
    @OperationLog(module = "创作者管理", action = "开通创作者账号")
@@ -12,6 +12,8 @@ import com.fruitshorts.creator.service.CreatorContentService;
 import com.fruitshorts.creator.vo.CreatorAttachReqVO;
 import com.fruitshorts.creator.vo.CreatorDramaEditReqVO;
 import com.fruitshorts.creator.vo.CreatorEpisodeReqVO;
+import com.fruitshorts.creator.vo.CreatorPublishReqVO;
+import com.fruitshorts.creator.vo.CreatorPublishRespVO;
 import com.fruitshorts.creator.vo.CreatorSubmitReqVO;
 import com.fruitshorts.framework.log.OperationLog;
 import io.swagger.v3.oas.annotations.Operation;
@@ -53,6 +55,15 @@ public class CreatorContentController {
        return Result.ok(creatorContentService.createDrama(req));
    }

+    /** 一键发布：建作品 + 建分集 + 绑定视频（可选同时提交审核），一个事务完成。 */
+    @Operation(summary = "一键发布（建作品 / 分集 / 绑定视频 / 可选提交审核）")
+    @PostMapping("/publish")
+    @PreAuthorize("@ss.hasPermission('creator-center:drama:edit')")
+    @OperationLog(module = "创作者中心", action = "一键发布作品")
+    public Result<CreatorPublishRespVO> publish(@Valid @RequestBody CreatorPublishReqVO req) {
+        return Result.ok(creatorContentService.publish(req));
+    }
+
    /** 编辑作品信息（仅草稿 / 已下线可改）。 */
    @Operation(summary = "编辑作品信息（仅草稿 / 已下线可改）")
    @PutMapping("/dramas/{id}")
@@ -101,6 +112,15 @@ public class CreatorContentController {
        return Result.ok();
    }

+    @Operation(summary = "删除作品")
+    @DeleteMapping("/dramas/{id}")
+    @PreAuthorize("@ss.hasPermission('creator-center:drama:edit')")
+    @OperationLog(module = "创作者中心", action = "删除作品")
+    public Result<Void> deleteDrama(@PathVariable Long id) {
+        creatorContentService.deleteDrama(id);
+        return Result.ok();
+    }
+
    /** 批量排序：body 里按新顺序给出分集 id。 */
    @Operation(summary = "分集批量排序")
    @PutMapping("/dramas/{id}/episodes/sort")
@@ -31,14 +31,14 @@ public class DictController {

    @Operation(summary = "短剧分类字典")
    @GetMapping("/drama-category")
-    @PreAuthorize("@ss.hasPermission('drama:list')")
+    @PreAuthorize("@ss.hasAnyPermission('drama:list','creator-center:view')")
    public Result<List<DramaCategoryRespVO>> dramaCategories() {
        return Result.ok(dramaCategoryService.list());
    }

    @Operation(summary = "内容状态字典")
    @GetMapping("/content-status")
-    @PreAuthorize("@ss.hasPermission('drama:list')")
+    @PreAuthorize("@ss.hasAnyPermission('drama:list','creator-center:view')")
    public Result<List<Map<String, String>>> contentStatus() {
        return Result.ok(Arrays.stream(ContentStatus.values())
                .map(status -> Map.of("code", status.getCode(), "text", status.getText()))
@@ -9,6 +9,7 @@ import com.fruitshorts.content.vo.DramaBriefVO;
 import com.fruitshorts.content.vo.DramaClassificationRespVO;
 import com.fruitshorts.content.vo.DramaClassificationSaveReqVO;
 import com.fruitshorts.content.vo.DramaIdsReqVO;
+import com.fruitshorts.content.vo.DramaRankingItemsReqVO;
 import com.fruitshorts.framework.log.OperationLog;
 import io.swagger.v3.oas.annotations.Operation;
 import io.swagger.v3.oas.annotations.tags.Tag;
@@ -104,6 +105,16 @@ public class DramaClassificationController {
        return Result.ok(classificationService.bindDramas(id, req.getDramaIds()));
    }

+    @Operation(summary = "保存推荐榜完整内容与顺序")
+    @PutMapping("/{id}/ranking-items")
+    @PreAuthorize("@ss.hasPermission('drama:update')")
+    @OperationLog(module = "内容管理", action = "保存推荐榜顺序")
+    public Result<Void> saveRankingItems(@PathVariable Long id,
+                                         @Valid @RequestBody DramaRankingItemsReqVO req) {
+        classificationService.saveRankingItems(id, req.getDramaIds());
+        return Result.ok();
+    }
+
    @Operation(summary = "移除分类下的短剧")
    @DeleteMapping("/{id}/dramas/{dramaId}")
    @PreAuthorize("@ss.hasPermission('drama:update')")
@@ -113,6 +113,15 @@ public class DramaController {
        return Result.ok();
    }

+    @Operation(summary = "审核通过并上线")
+    @PostMapping("/{id}/approve-publish")
+    @PreAuthorize("@ss.hasPermission('drama:review')")
+    @OperationLog(module = "内容管理", action = "审核通过并上线")
+    public Result<Void> approvePublish(@PathVariable Long id, @RequestBody(required = false) DramaStatusReqVO req) {
+        changeStatus(id, "APPROVE_PUBLISH", req);
+        return Result.ok();
+    }
+
    @Operation(summary = "上线")
    @PostMapping("/{id}/publish")
    @PreAuthorize("@ss.hasPermission('drama:review')")
@@ -0,0 +1,171 @@
+// Author: fruit.com.cn
+
+package com.fruitshorts.admin.controller;
+
+import com.fruitshorts.commerce.reward.service.RewardCheckinService;
+import com.fruitshorts.commerce.reward.service.RewardActivityAdminService;
+import com.fruitshorts.commerce.reward.service.RewardGrantService;
+import com.fruitshorts.commerce.reward.service.RewardTaskService;
+import com.fruitshorts.commerce.reward.vo.RewardActivityQueryReqVO;
+import com.fruitshorts.commerce.reward.vo.RewardActivityRespVO;
+import com.fruitshorts.commerce.reward.vo.RewardActivitySaveReqVO;
+import com.fruitshorts.commerce.reward.vo.RewardCheckinRuleSaveReqVO;
+import com.fruitshorts.commerce.reward.vo.RewardGrantQueryReqVO;
+import com.fruitshorts.commerce.reward.vo.RewardGrantRespVO;
+import com.fruitshorts.commerce.reward.vo.RewardManualGrantReqVO;
+import com.fruitshorts.commerce.reward.vo.RewardRuleDayVO;
+import com.fruitshorts.commerce.reward.vo.RewardTaskQueryReqVO;
+import com.fruitshorts.commerce.reward.vo.RewardTaskRespVO;
+import com.fruitshorts.commerce.reward.vo.RewardTaskSaveReqVO;
+import com.fruitshorts.common.exception.ErrorCode;
+import com.fruitshorts.common.exception.ServiceException;
+import com.fruitshorts.common.pojo.PageResult;
+import com.fruitshorts.common.pojo.Result;
+import com.fruitshorts.framework.log.OperationLog;
+import com.fruitshorts.framework.security.SecurityUtils;
+import com.fruitshorts.user.dal.mapper.AppUserMapper;
+import io.swagger.v3.oas.annotations.Operation;
+import io.swagger.v3.oas.annotations.tags.Tag;
+import jakarta.validation.Valid;
+import lombok.RequiredArgsConstructor;
+import org.springframework.security.access.prepost.PreAuthorize;
+import org.springframework.validation.annotation.Validated;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.PathVariable;
+import org.springframework.web.bind.annotation.PostMapping;
+import org.springframework.web.bind.annotation.PutMapping;
+import org.springframework.web.bind.annotation.RequestBody;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RequestParam;
+import org.springframework.web.bind.annotation.RestController;
+
+import java.util.List;
+
+/** 后台奖励任务、签到规则和发放记录管理。 */
+@Tag(name = "后台-奖励中心")
+@RestController
+@RequestMapping("/admin/rewards")
+@RequiredArgsConstructor
+public class RewardAdminController {
+
+    private final RewardTaskService taskService;
+    private final RewardActivityAdminService activityService;
+    private final RewardCheckinService checkinService;
+    private final RewardGrantService grantService;
+    private final AppUserMapper appUserMapper;
+
+    @Operation(summary = "奖励任务分页")
+    @GetMapping("/tasks/page")
+    @PreAuthorize("@ss.hasPermission('reward:list')")
+    public Result<PageResult<RewardTaskRespVO>> page(@Validated RewardTaskQueryReqVO req) {
+        return Result.ok(taskService.page(req));
+    }
+
+    @Operation(summary = "奖励任务详情")
+    @GetMapping("/tasks/{id}")
+    @PreAuthorize("@ss.hasPermission('reward:list')")
+    public Result<RewardTaskRespVO> detail(@PathVariable Long id) {
+        return Result.ok(taskService.detail(id));
+    }
+
+    @Operation(summary = "新建奖励任务")
+    @PostMapping("/tasks")
+    @PreAuthorize("@ss.hasPermission('reward:update')")
+    @OperationLog(module = "奖励中心", action = "新建奖励任务")
+    public Result<Long> create(@Valid @RequestBody RewardTaskSaveReqVO req) {
+        return Result.ok(taskService.create(req));
+    }
+
+    @Operation(summary = "编辑奖励任务")
+    @PutMapping("/tasks/{id}")
+    @PreAuthorize("@ss.hasPermission('reward:update')")
+    @OperationLog(module = "奖励中心", action = "编辑奖励任务")
+    public Result<Void> update(@PathVariable Long id, @Valid @RequestBody RewardTaskSaveReqVO req) {
+        taskService.update(id, req);
+        return Result.ok();
+    }
+
+    @Operation(summary = "奖励任务上下线")
+    @PutMapping("/tasks/{id}/status")
+    @PreAuthorize("@ss.hasPermission('reward:update')")
+    @OperationLog(module = "奖励中心", action = "奖励任务上下线")
+    public Result<Void> updateStatus(@PathVariable Long id, @RequestParam Integer status) {
+        taskService.updateStatus(id, status);
+        return Result.ok();
+    }
+
+    @Operation(summary = "奖励活动分页")
+    @GetMapping("/activities/page")
+    @PreAuthorize("@ss.hasPermission('reward:list')")
+    public Result<PageResult<RewardActivityRespVO>> activityPage(@Validated RewardActivityQueryReqVO req) {
+        return Result.ok(activityService.page(req));
+    }
+
+    @Operation(summary = "奖励活动详情")
+    @GetMapping("/activities/{id}")
+    @PreAuthorize("@ss.hasPermission('reward:list')")
+    public Result<RewardActivityRespVO> activityDetail(@PathVariable Long id) {
+        return Result.ok(activityService.detail(id));
+    }
+
+    @Operation(summary = "新建奖励活动")
+    @PostMapping("/activities")
+    @PreAuthorize("@ss.hasPermission('reward:update')")
+    @OperationLog(module = "奖励中心", action = "新建奖励活动")
+    public Result<Long> createActivity(@Valid @RequestBody RewardActivitySaveReqVO req) {
+        return Result.ok(activityService.create(req));
+    }
+
+    @Operation(summary = "编辑奖励活动")
+    @PutMapping("/activities/{id}")
+    @PreAuthorize("@ss.hasPermission('reward:update')")
+    @OperationLog(module = "奖励中心", action = "编辑奖励活动")
+    public Result<Void> updateActivity(@PathVariable Long id, @Valid @RequestBody RewardActivitySaveReqVO req) {
+        activityService.update(id, req);
+        return Result.ok();
+    }
+
+    @Operation(summary = "奖励活动上下线")
+    @PutMapping("/activities/{id}/status")
+    @PreAuthorize("@ss.hasPermission('reward:update')")
+    @OperationLog(module = "奖励中心", action = "奖励活动上下线")
+    public Result<Void> updateActivityStatus(@PathVariable Long id, @RequestParam Integer status) {
+        activityService.updateStatus(id, status);
+        return Result.ok();
+    }
+
+    @Operation(summary = "签到规则")
+    @GetMapping("/check-in/rules")
+    @PreAuthorize("@ss.hasPermission('reward:checkin')")
+    public Result<List<RewardRuleDayVO>> rules() {
+        return Result.ok(checkinService.rulesForAdmin());
+    }
+
+    @Operation(summary = "保存签到规则")
+    @PutMapping("/check-in/rules")
+    @PreAuthorize("@ss.hasPermission('reward:checkin')")
+    @OperationLog(module = "奖励中心", action = "保存签到规则")
+    public Result<Void> saveRules(@Valid @RequestBody RewardCheckinRuleSaveReqVO req) {
+        checkinService.saveRules(req);
+        return Result.ok();
+    }
+
+    @Operation(summary = "奖励发放记录分页")
+    @GetMapping("/grants/page")
+    @PreAuthorize("@ss.hasPermission('reward:grant')")
+    public Result<PageResult<RewardGrantRespVO>> grants(@Validated RewardGrantQueryReqVO req) {
+        return Result.ok(grantService.page(req));
+    }
+
+    @Operation(summary = "人工补发奖励")
+    @PostMapping("/grants/manual")
+    @PreAuthorize("@ss.hasPermission('reward:grant')")
+    @OperationLog(module = "奖励中心", action = "人工补发奖励")
+    public Result<RewardGrantRespVO> manualGrant(@Valid @RequestBody RewardManualGrantReqVO req) {
+        if (appUserMapper.selectById(req.getUserId()) == null) {
+            throw new ServiceException(ErrorCode.DATA_NOT_FOUND, "用户不存在，无法补发奖励");
+        }
+        return Result.ok(grantService.manualGrant(req.getUserId(), req.getTaskId(), req.getAmount(),
+                req.getIdempotentKey(), SecurityUtils.getUserId()));
+    }
+}
@@ -14,6 +14,12 @@ spring:
    url: ${DB_URL:jdbc:postgresql://127.0.0.1:5432/fruitshorts}
    username: ${DB_USER:fruitshorts}
    password: ${DB_PASSWORD:fruitshorts}
+  data:
+    redis:
+      # 与 app-api 共用同一个 Redis 实例；容器内必须显式指定 host，
+      # 否则 Spring Boot 默认连 127.0.0.1（容器内即自身）导致健康检查报 DOWN。
+      host: ${REDIS_HOST:127.0.0.1}
+      port: ${REDIS_PORT:6379}
  jackson:
    date-format: yyyy-MM-dd HH:mm:ss
    time-zone: Asia/Shanghai
@@ -51,14 +57,14 @@ fruitshorts:
    public-prefix: /files
    chunk-size: 5242880
    max-file-size: 2147483648
-    signature-secret: ${MEDIA_SIGNATURE_SECRET:fruitshorts-media-dev-secret-change-me-in-production-32b}
+    signature-secret: ${MEDIA_SIGNATURE_SECRET:}
    signature-required: ${MEDIA_SIGNATURE_REQUIRED:false}
    signature-ttl-minutes: 15
  jwt:
-    # 双密钥都要外置：只配 admin 而漏配 app，生产会静默用 dev 默认值（prod fail-fast 会拦住）
-    admin-secret: ${JWT_ADMIN_SECRET:fruitshorts-admin-dev-secret-change-me-in-production-32b}
+    # ⚠️ 所有环境必须注入 JWT_ADMIN_SECRET / JWT_APP_SECRET，不设任何代码级默认值
+    admin-secret: ${JWT_ADMIN_SECRET:}
    admin-ttl-hours: 12
-    app-secret: ${JWT_APP_SECRET:fruitshorts-app-dev-secret-change-me-in-production-32bytes}
+    app-secret: ${JWT_APP_SECRET:}
    app-access-ttl-minutes: 120
    app-refresh-ttl-days: 30
  cors:
@@ -32,6 +32,11 @@ class AdminPermissionAnnotationTest {
        assertThat(permissionsOf(NoticeAdminController.class))
                .containsExactlyInAnyOrder("notice:list", "notice:list",
                        "notice:update", "notice:update", "notice:update", "notice:update");
+        assertThat(permissionsOf(RewardAdminController.class))
+                .containsExactlyInAnyOrder("reward:list", "reward:list", "reward:update",
+                        "reward:update", "reward:update", "reward:checkin", "reward:checkin",
+                        "reward:grant", "reward:grant", "reward:list", "reward:list",
+                        "reward:update", "reward:update", "reward:update");
    }

    /** 收集控制器里所有映射方法的 @PreAuthorize 权限点（缺失则记为 MISSING，便于断言直接看到）。 */
@@ -3,11 +3,13 @@
 package com.fruitshorts.app.controller;

 import com.fruitshorts.app.service.AppCatalogService;
+import com.fruitshorts.app.service.AppRankingService;
 import com.fruitshorts.app.vo.AppCategoryVO;
 import com.fruitshorts.app.vo.AppDramaPageReqVO;
 import com.fruitshorts.app.vo.AppFeedVO;
 import com.fruitshorts.app.vo.AppDramaCardVO;
 import com.fruitshorts.app.vo.AppPlaylistDetailVO;
+import com.fruitshorts.app.vo.AppRankingVO;
 import com.fruitshorts.common.pojo.CursorResult;
 import com.fruitshorts.common.pojo.PageResult;
 import com.fruitshorts.common.pojo.Result;
@@ -37,6 +39,7 @@ public class AppCatalogController {
    private static final int DRAMA_PAGE_SIZE = 20;

    private final AppCatalogService appCatalogService;
+    private final AppRankingService appRankingService;

    @Operation(summary = "首页聚合：轮播 + 分区，一次请求渲染整页")
    @GetMapping("/home/feed")
@@ -75,6 +78,12 @@ public class AppCatalogController {
        return Result.ok(appCatalogService.categoryDramas(id, pageIndex, pageSize));
    }

+    @Operation(summary = "推荐榜：按后台配置顺序返回榜单快照")
+    @GetMapping("/categories/{id}/ranking")
+    public Result<AppRankingVO> categoryRanking(@PathVariable Long id) {
+        return Result.ok(appRankingService.ranking(id));
+    }
+
    @Operation(summary = "已启用类型")
    @GetMapping("/drama-categories")
    public Result<List<AppCategoryVO>> dramaCategories() {
@@ -7,12 +7,14 @@ import com.fruitshorts.commerce.service.OrderService;
 import com.fruitshorts.commerce.service.ProductService;
 import com.fruitshorts.commerce.service.UnlockService;
 import com.fruitshorts.commerce.service.WalletService;
+import com.fruitshorts.commerce.reward.service.RewardTaskService;
 import com.fruitshorts.commerce.vo.ProductRespVO;
 import com.fruitshorts.common.pojo.Result;
 import com.fruitshorts.framework.security.SecurityUtils;
 import io.swagger.v3.oas.annotations.Operation;
 import io.swagger.v3.oas.annotations.tags.Tag;
 import lombok.RequiredArgsConstructor;
+import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.web.bind.annotation.GetMapping;
 import org.springframework.web.bind.annotation.PathVariable;
 import org.springframework.web.bind.annotation.PostMapping;
@@ -41,6 +43,8 @@ public class AppCommerceController {
    private final UnlockService unlockService;
    private final OrderService orderService;
    private final ProductService productService;
+    @Autowired(required = false)
+    private RewardTaskService rewardTaskService;

    /** 我的钱包：余额 + 最近流水，客户端一处渲染。 */
    @Operation(summary = "我的钱包（余额 + 最近流水）")
@@ -92,9 +96,14 @@ public class AppCommerceController {
    @Operation(summary = "提交商店票据（校验后建单并发权益，重复提交幂等）")
    @PostMapping("/orders/verify")
    public Result<Orders> verify(@RequestBody Map<String, String> body) {
-        return Result.ok(orderService.verifyAndDeliver(SecurityUtils.getAppUserId(),
+        Orders order = orderService.verifyAndDeliver(SecurityUtils.getAppUserId(),
                body.getOrDefault("platform", ""),
                body.getOrDefault("productId", ""),
-                body.getOrDefault("receipt", "")));
+                body.getOrDefault("receipt", ""));
+        if (rewardTaskService != null && OrderService.STATUS_DELIVERED.equals(order.getStatus())) {
+            rewardTaskService.recordEvent(order.getUserId(), RewardTaskService.TYPE_FIRST_PURCHASE,
+                    order.getOrderNo(), 1L);
+        }
+        return Result.ok(order);
    }
 }
@@ -9,16 +9,19 @@ import com.fruitshorts.user.service.AppUserService;
 import com.fruitshorts.user.vo.AppUserRespVO;
 import com.fruitshorts.user.vo.DeactivateReqVO;
 import com.fruitshorts.user.vo.ProfileUpdateReqVO;
+import com.fruitshorts.commerce.reward.service.RewardTaskService;
 import io.swagger.v3.oas.annotations.Operation;
 import io.swagger.v3.oas.annotations.tags.Tag;
 import jakarta.validation.Valid;
 import lombok.RequiredArgsConstructor;
+import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.web.bind.annotation.GetMapping;
 import org.springframework.web.bind.annotation.PostMapping;
 import org.springframework.web.bind.annotation.PutMapping;
 import org.springframework.web.bind.annotation.RequestBody;
 import org.springframework.web.bind.annotation.RequestMapping;
 import org.springframework.web.bind.annotation.RestController;
+import org.springframework.util.StringUtils;

 import java.time.LocalDateTime;
 import java.util.List;
@@ -32,6 +35,8 @@ import java.util.Map;
 public class AppMeController {

    private final AppUserService userService;
+    @Autowired(required = false)
+    private RewardTaskService rewardTaskService;

    @Operation(summary = "我的资料")
    @GetMapping
@@ -42,7 +47,14 @@ public class AppMeController {
    @Operation(summary = "修改资料（昵称 / 头像 / 语言等）")
    @PutMapping
    public Result<AppUserRespVO> update(@Valid @RequestBody ProfileUpdateReqVO req) {
-        return Result.ok(userService.updateProfile(SecurityUtils.getAppUserId(), req));
+        Long userId = SecurityUtils.getAppUserId();
+        AppUserRespVO profile = userService.updateProfile(userId, req);
+        if (rewardTaskService != null && StringUtils.hasText(profile.getNickname())
+                && StringUtils.hasText(profile.getAvatarUrl())) {
+            rewardTaskService.recordEvent(userId, RewardTaskService.TYPE_COMPLETE_PROFILE,
+                    userId.toString(), 1L);
+        }
+        return Result.ok(profile);
    }

    @Operation(summary = "我的登录设备列表")
@@ -0,0 +1,78 @@
+// Author: fruit.com.cn
+
+package com.fruitshorts.app.controller;
+
+import com.fruitshorts.commerce.reward.service.RewardCheckinService;
+import com.fruitshorts.commerce.reward.service.RewardGrantService;
+import com.fruitshorts.commerce.reward.service.RewardTaskService;
+import com.fruitshorts.commerce.reward.vo.RewardActivityVO;
+import com.fruitshorts.commerce.reward.vo.RewardCheckinRespVO;
+import com.fruitshorts.commerce.reward.vo.RewardCheckinVO;
+import com.fruitshorts.commerce.reward.vo.RewardClaimRespVO;
+import com.fruitshorts.commerce.reward.vo.RewardOverviewVO;
+import com.fruitshorts.common.pojo.Result;
+import com.fruitshorts.commerce.service.WalletService;
+import com.fruitshorts.framework.security.SecurityUtils;
+import io.swagger.v3.oas.annotations.Operation;
+import io.swagger.v3.oas.annotations.Parameter;
+import io.swagger.v3.oas.annotations.tags.Tag;
+import lombok.RequiredArgsConstructor;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.PathVariable;
+import org.springframework.web.bind.annotation.PostMapping;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RequestParam;
+import org.springframework.web.bind.annotation.RestController;
+
+import java.util.List;
+
+/** 客户端奖励中心：总览、签到、任务领取与活动。 */
+@Tag(name = "客户端-奖励中心")
+@RestController
+@RequestMapping("/app/rewards")
+@RequiredArgsConstructor
+public class AppRewardController {
+
+    private final RewardTaskService taskService;
+    private final RewardCheckinService checkinService;
+    private final RewardGrantService grantService;
+    private final WalletService walletService;
+
+    @Operation(summary = "奖励中心总览")
+    @GetMapping("/overview")
+    public Result<RewardOverviewVO> overview(@RequestParam(required = false) String locale) {
+        Long userId = SecurityUtils.getAppUserIdOrNull();
+        long coinBalance = userId == null ? 0L : walletService.getOrCreate(userId).getCoinBalance();
+        RewardOverviewVO overview = taskService.overview(
+                userId, locale, coinBalance);
+        overview.setCheckin(checkinService.status(userId));
+        return Result.ok(overview);
+    }
+
+    @Operation(summary = "奖励活动列表")
+    @GetMapping("/activities")
+    public Result<List<RewardActivityVO>> activities(@RequestParam(required = false) String locale) {
+        return Result.ok(taskService.activities(locale));
+    }
+
+    @Operation(summary = "签到状态")
+    @GetMapping("/check-in")
+    public Result<RewardCheckinVO> checkInStatus() {
+        return Result.ok(checkinService.status(SecurityUtils.getAppUserId()));
+    }
+
+    @Operation(summary = "执行签到")
+    @PostMapping("/check-in")
+    public Result<RewardCheckinRespVO> checkIn() {
+        return Result.ok(checkinService.checkIn(SecurityUtils.getAppUserId()));
+    }
+
+    @Operation(summary = "领取已完成任务奖励")
+    @PostMapping("/tasks/{taskId}/claim")
+    public Result<RewardClaimRespVO> claim(
+            @Parameter(description = "奖励任务 ID") @PathVariable Long taskId) {
+        Long userId = SecurityUtils.getAppUserId();
+        var task = taskService.getExisting(taskId);
+        return Result.ok(grantService.claim(userId, task, taskService.currentProgress(userId, task)));
+    }
+}
@@ -9,6 +9,7 @@ import com.fruitshorts.app.service.AnonymousInteractionRateLimiter;
 import com.fruitshorts.framework.interaction.InteractionIdentityResolver;
 import com.fruitshorts.framework.security.SecurityUtils;
 import com.fruitshorts.playback.service.WatchProgressService;
+import com.fruitshorts.commerce.reward.service.RewardTaskService;
 import com.fruitshorts.playback.vo.ProgressRespVO;
 import com.fruitshorts.playback.vo.ProgressSaveReqVO;
 import io.swagger.v3.oas.annotations.Operation;
@@ -16,6 +17,7 @@ import io.swagger.v3.oas.annotations.tags.Tag;
 import jakarta.validation.Valid;
 import jakarta.servlet.http.HttpServletRequest;
 import lombok.RequiredArgsConstructor;
+import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.web.bind.annotation.DeleteMapping;
 import org.springframework.web.bind.annotation.GetMapping;
 import org.springframework.web.bind.annotation.PathVariable;
@@ -33,6 +35,8 @@ import org.springframework.web.bind.annotation.RestController;
 public class AppWatchController {

    private final WatchProgressService progressService;
+    @Autowired(required = false)
+    private RewardTaskService rewardTaskService;
    private final InteractionIdentityResolver identityResolver;
    private final AnonymousInteractionRateLimiter anonymousRateLimiter;

@@ -46,7 +50,12 @@ public class AppWatchController {
                request.getHeader("X-Device-Id"),
                req.getDeviceId());
        anonymousRateLimiter.check(identity, "watch");
-        return Result.ok(progressService.save(identity, req));
+        ProgressRespVO saved = progressService.save(identity, req);
+        if (rewardTaskService != null && identity.authenticated()) {
+            rewardTaskService.recordWatch(identity.userId(), saved.getEpisodeId(),
+                    saved.getPositionMs(), Boolean.TRUE.equals(saved.getFinished()));
+        }
+        return Result.ok(saved);
    }

    /** 某部剧的续看位置，进详情页时用它决定"续看第 N 集"。 */
@@ -34,7 +34,6 @@ import org.springframework.stereotype.Service;

 import java.util.ArrayList;
 import java.util.HashMap;
-import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Map;
 import java.util.Arrays;
@@ -93,6 +92,11 @@ public class AppCatalogService {
                            c.getNameLocales(), c.getName(), c.getNameEn(), c.getNameId());
                    AppCategoryVO vo = new AppCategoryVO(c.getId(), ContentLocaleTexts.value(locales, ContentLocaleTexts.ZH));
                    vo.setLocales(locales);
+                    vo.setCode(c.getCode());
+                    vo.setLayoutType(c.getLayoutType() == null
+                            ? DramaClassificationService.LAYOUT_GRID
+                            : c.getLayoutType());
+                    vo.setRevision(c.getRevision() == null ? 1L : c.getRevision());
                    return vo;
                })
                .toList();
@@ -206,6 +210,7 @@ public class AppCatalogService {
        detail.setTitleLocales(titles);
        detail.setSynopsisLocales(synopses);
        detail.setCover(drama.getCoverUrl());
+        detail.setCoverLandscape(drama.getHorizontalCoverUrl());
        detail.setTypes(types);
        fillDetailTag(detail, drama);
        detail.setTotalEpisodes(drama.getTotalEpisodes());
@@ -348,7 +353,8 @@ public class AppCatalogService {
                drama.getSynopsisLocales(), drama.getSynopsis(), null, null);
        card.setTitleLocales(titles);
        card.setCover(drama.getCoverUrl());
-        card.setSynopsisLocales(shortLocales(synopses));
+        card.setCoverLandscape(drama.getHorizontalCoverUrl());
+        card.setSynopsisLocales(synopses);
        card.setTypes(types);
        fillTag(card, drama, tags);
        card.setTotalEpisodes(drama.getTotalEpisodes());
@@ -411,6 +417,7 @@ public class AppCatalogService {
        ContentTag tag = tagOf(drama, tags);
        Map<String, String> locales = tagLocales(tag);
        card.setTagLocales(locales);
+        card.setTagCode(tagCode(tag));
        card.setTagColor(tag == null ? "" : tag.getBgColor());
    }

@@ -418,9 +425,18 @@ public class AppCatalogService {
        ContentTag tag = tagOf(drama, loadTags(List.of(drama)));
        Map<String, String> locales = tagLocales(tag);
        detail.setTagLocales(locales);
+        detail.setTagCode(tagCode(tag));
        detail.setTagColor(tag == null ? "" : tag.getBgColor());
    }

+    /** 语义码直接下发，客户端据此判断板块；未配置时给空串，由客户端按文案兜底。 */
+    private String tagCode(ContentTag tag) {
+        if (tag == null || tag.getCode() == null) {
+            return "";
+        }
+        return tag.getCode().trim();
+    }
+
    private ContentTag tagOf(Drama drama, Map<Long, ContentTag> tags) {
        if (drama.getTagId() == null || drama.getTagId() <= 0L) {
            return null;
@@ -439,20 +455,4 @@ public class AppCatalogService {
        return dramaCategoryService.localeMap();
    }

-    /** 卡片只带一句简介，避免列表响应体过大 */
-    private Map<String, String> shortLocales(Map<String, String> locales) {
-        Map<String, String> result = new LinkedHashMap<>();
-        if (locales == null) {
-            return result;
-        }
-        locales.forEach((code, text) -> result.put(code, shortSynopsis(text)));
-        return result;
-    }
-
-    private String shortSynopsis(String synopsis) {
-        if (synopsis == null) {
-            return "";
-        }
-        return synopsis.length() <= 60 ? synopsis : synopsis.substring(0, 60);
-    }
 }
@@ -35,6 +35,7 @@ public class AppConfigService {
        KEYS.put("noticeEnabled", new KeySpec("app.notice.enabled", "true"));
        KEYS.put("coinUnlockEnabled", new KeySpec("app.coin.unlock.enabled", "true"));
        KEYS.put("downloadEnabled", new KeySpec("app.download.enabled", "true"));
+        KEYS.put("loginBackgroundUrl", new KeySpec("app.login.background.url", ""));
    }

    private final SysConfigMapper sysConfigMapper;
@@ -0,0 +1,79 @@
+// Author: fruit.com.cn
+
+package com.fruitshorts.app.service;
+
+import com.fruitshorts.app.vo.AppDramaCardVO;
+import com.fruitshorts.app.vo.AppRankingEntryVO;
+import com.fruitshorts.app.vo.AppRankingVO;
+import com.fruitshorts.common.exception.ErrorCode;
+import com.fruitshorts.common.exception.ServiceException;
+import com.fruitshorts.content.dal.entity.Drama;
+import com.fruitshorts.content.service.ContentLocaleTexts;
+import com.fruitshorts.content.service.DramaClassificationService;
+import com.fruitshorts.content.service.DramaService;
+import lombok.RequiredArgsConstructor;
+import org.springframework.stereotype.Service;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+/** C 端推荐榜快照组装。 */
+@Service
+@RequiredArgsConstructor
+public class AppRankingService {
+
+    private static final int MAX_RANKING_ITEMS = 50;
+
+    private final DramaClassificationService classificationService;
+    private final DramaService dramaService;
+    private final AppCatalogService catalogService;
+
+    /** 过滤未上线短剧后保持后台位置，排名连续补齐。 */
+    public AppRankingVO ranking(Long classificationId) {
+        var classification = classificationService.getEnabledById(classificationId);
+        if (!DramaClassificationService.LAYOUT_RANKING.equals(classification.getLayoutType())) {
+            throw new ServiceException(ErrorCode.OPERATION_NOT_ALLOWED, "该分类不是推荐榜");
+        }
+        List<Long> ids = classificationService.listDramaIdsByClassification(classificationId);
+        List<Drama> ordered = orderedPublished(ids).stream().limit(MAX_RANKING_ITEMS).toList();
+        List<AppDramaCardVO> cards = catalogService.toCards(ordered);
+        List<AppRankingEntryVO> entries = entries(cards);
+        Map<String, String> locales = ContentLocaleTexts.read(
+                classification.getNameLocales(), classification.getName(),
+                classification.getNameEn(), classification.getNameId());
+        AppRankingVO ranking = new AppRankingVO();
+        ranking.setId(classification.getId());
+        ranking.setCode(classification.getCode());
+        ranking.setLocales(locales);
+        ranking.setRevision(classification.getRevision() == null ? 1L : classification.getRevision());
+        ranking.setGeneratedAt(classification.getUpdatedAt());
+        ranking.setTotal(entries.size());
+        ranking.setList(entries);
+        return ranking;
+    }
+
+    private List<AppRankingEntryVO> entries(List<AppDramaCardVO> cards) {
+        List<AppRankingEntryVO> entries = new ArrayList<>();
+        for (int index = 0; index < cards.size(); index++) {
+            entries.add(new AppRankingEntryVO(index + 1, cards.get(index)));
+        }
+        return entries;
+    }
+
+    private List<Drama> orderedPublished(List<Long> ids) {
+        if (ids.isEmpty()) {
+            return List.of();
+        }
+        Map<Long, Integer> positions = new HashMap<>();
+        for (int index = 0; index < ids.size(); index++) {
+            positions.put(ids.get(index), index);
+        }
+        return dramaService.listPublishedByIds(ids).stream()
+                .sorted((left, right) -> Integer.compare(
+                        positions.getOrDefault(left.getId(), Integer.MAX_VALUE),
+                        positions.getOrDefault(right.getId(), Integer.MAX_VALUE)))
+                .toList();
+    }
+}
@@ -35,7 +35,9 @@ public class AppSearchService {
        Page<Drama> page = new Page<>(safeIndex, safeSize);
        Page<Drama> result = dramaMapper.selectPage(page, Wrappers.<Drama>lambdaQuery()
                .eq(Drama::getStatus, ContentStatus.PUBLISHED.getCode())
-                .and(w -> w.like(Drama::getTitle, keyword.trim())
+                .and(w -> w.like(Drama::getTitleLocales, keyword.trim())
+                        .or().like(Drama::getSynopsisLocales, keyword.trim())
+                        .or().like(Drama::getTitle, keyword.trim())
                        .or().like(Drama::getSynopsis, keyword.trim()))
                .orderByDesc(Drama::getSort)
                .orderByDesc(Drama::getId));
@@ -11,10 +11,15 @@ import java.util.Map;
 public class AppCategoryVO {

    private Long id;
+    private String code;
+    private String layoutType;
+    private Long revision;
    private Map<String, String> locales;

    public AppCategoryVO(Long id, String name) {
        this.id = id;
+        this.layoutType = "GRID";
+        this.revision = 1L;
        this.locales = name == null || name.isBlank() ? Map.of() : Map.of("zh", name);
    }
 }
@@ -15,11 +15,15 @@ public class AppDramaCardVO {
    private Long id;
    private Map<String, String> titleLocales;
    private String cover;
+    /** 横版封面（16:9），横幅等横向位优先用它；空串表示未上传，客户端回退竖版。 */
+    private String coverLandscape;
    private Map<String, String> synopsisLocales;
    /** 短剧选中的全部类型，每项是一份语言表。 */
    private List<Map<String, String>> types;
    /** 标签语言表，key 为 zh / en / id。 */
    private Map<String, String> tagLocales;
+    /** 标签语义码，如 NEW_ARRIVAL；客户端按码判断板块，文案仅用于展示。 */
+    private String tagCode;
    /** 标签角标背景色，#RRGGBB。 */
    private String tagColor;
    private Integer totalEpisodes;
@@ -14,8 +14,12 @@ public class AppDramaDetailVO {
    private Map<String, String> titleLocales;
    private Map<String, String> synopsisLocales;
    private String cover;
+    /** 横版封面（16:9）；空串表示未上传。 */
+    private String coverLandscape;
    private List<Map<String, String>> types;
    private Map<String, String> tagLocales;
+    /** 标签语义码，如 NEW_ARRIVAL；空表示未配置。 */
+    private String tagCode;
    private String tagColor;
    private Integer totalEpisodes;
    private Integer freeEpisodes;
@@ -0,0 +1,15 @@
+// Author: fruit.com.cn
+
+package com.fruitshorts.app.vo;
+
+import lombok.AllArgsConstructor;
+import lombok.Data;
+
+/** 推荐榜单项，排名由服务端确定。 */
+@Data
+@AllArgsConstructor
+public class AppRankingEntryVO {
+
+    private Integer rank;
+    private AppDramaCardVO drama;
+}
@@ -0,0 +1,22 @@
+// Author: fruit.com.cn
+
+package com.fruitshorts.app.vo;
+
+import lombok.Data;
+
+import java.time.LocalDateTime;
+import java.util.List;
+import java.util.Map;
+
+/** 推荐榜快照。 */
+@Data
+public class AppRankingVO {
+
+    private Long id;
+    private String code;
+    private Map<String, String> locales;
+    private Long revision;
+    private LocalDateTime generatedAt;
+    private Integer total;
+    private List<AppRankingEntryVO> list;
+}
@@ -23,6 +23,13 @@ fruitshorts:
  cors:
    # 生产只允许显式配置的来源；没配就等于空，浏览器侧会被拦住（比"*"安全）
    allowed-origins: ${CORS_ALLOWED_ORIGINS:}
+  watch-progress:
+    # 观看进度写缓冲：POST 先写 Redis 立即返回，后台任务批量合并进 watch_progress。
+    # 消化能力 = batch-size / interval ≈ 5000 条/秒，覆盖 30 万 DAU 峰值 ~3700 条/秒上报。
+    # 关掉（false）即回退同步写库，接口契约不变。
+    buffer: true
+    flush-interval-ms: 2000
+    flush-batch-size: 10000

 springdoc:
  # 生产只留机器可读契约，关掉 UI（doc.html 不对外开放）
@@ -11,13 +11,22 @@ spring:
  datasource:
    driver-class-name: org.postgresql.Driver
    # 地址必须外置：不同环境（本机 / 测试 / 生产）连的库不一样，
-    # 生产请用 DB_URL 注入（prod profile 会校验它非空）
-    url: ${DB_URL:jdbc:postgresql://127.0.0.1:5432/fruitshorts}
+    # 生产请用 DB_URL 注入（prod profile 会校验它非空）。
+    # reWriteBatchedInserts：pgjdbc 把批内多条 INSERT 重写成多值 INSERT，
+    # 观看进度缓冲落库依赖它才能跑满批量吞吐。
+    url: ${DB_URL:jdbc:postgresql://127.0.0.1:5432/fruitshorts?reWriteBatchedInserts=true}
    username: ${DB_USER:fruitshorts}
    password: ${DB_PASSWORD:fruitshorts}
  jackson:
    date-format: yyyy-MM-dd HH:mm:ss
    time-zone: Asia/Shanghai
+  task:
+    scheduling:
+      # 默认调度池只有 1 条线程：观看进度落库（每 2s）会和其他定时任务互相排队，
+      # 落库一旦拖慢就会连带推迟对时延敏感的任务，必须给池子多几条线程。
+      pool:
+        size: 4
+      thread-name-prefix: fruitshorts-sched-
  data:
    redis:
      host: ${REDIS_HOST:127.0.0.1}
@@ -56,6 +65,11 @@ fruitshorts:
    # 仅作 sys_config 缺失/非法时的兜底；运行时优先读取后台「系统配置」
    register-max-per-ip-per-day: ${REGISTER_MAX_PER_IP_PER_DAY:5}
    register-max-per-device-per-day: ${REGISTER_MAX_PER_DEVICE_PER_DAY:3}
+    google:
+      # Google 登录允许的客户端 id（逗号分隔）。idToken 的 aud 随平台不同：
+      # iOS 为 iOS 客户端 id，Android 为 serverClientId 对应的 Web 客户端 id。
+      # 客户端 id 属公开信息，不是密钥；生产可用 GOOGLE_CLIENT_IDS 覆盖。
+      client-ids: ${GOOGLE_CLIENT_IDS:11115008580-51gv4sj2c78rud6n127g3shu4d2n96un.apps.googleusercontent.com,11115008580-dbqe47fhp5560nhrocrppiq7hcnlvl1s.apps.googleusercontent.com,11115008580-1v5pt5mfgbbuba74ebia6hngj618ne3a.apps.googleusercontent.com}
  interaction:
    # MACHINE_FIRST：机审通过即发布，命中 REVIEW 级敏感词才转人工
    # PRE_REVIEW   ：全部先审后发（生产建议）
@@ -85,15 +99,15 @@ fruitshorts:
    chunk-size: 5242880
    max-file-size: 2147483648
    # 播放地址签名：生产必开（docs/12-上线检查清单），prod profile 里强制为 true
-    signature-secret: ${MEDIA_SIGNATURE_SECRET:fruitshorts-media-dev-secret-change-me-in-production-32b}
+    signature-secret: ${MEDIA_SIGNATURE_SECRET:}
    signature-required: ${MEDIA_SIGNATURE_REQUIRED:false}
    signature-ttl-minutes: 15
  jwt:
    # 双密钥：管理端与客户端物理隔离，token 不能互换（AGENTS.md 强制约束 2）
-    # 注意 app-secret 以前没写在这里，一直用代码里的 dev 默认值 —— 生产必须注入 JWT_APP_SECRET
-    admin-secret: ${JWT_ADMIN_SECRET:fruitshorts-admin-dev-secret-change-me-in-production-32b}
+    # ⚠️ 所有环境必须注入 JWT_ADMIN_SECRET / JWT_APP_SECRET，不设任何代码级默认值
+    admin-secret: ${JWT_ADMIN_SECRET:}
    admin-ttl-hours: 12
-    app-secret: ${JWT_APP_SECRET:fruitshorts-app-dev-secret-change-me-in-production-32bytes}
+    app-secret: ${JWT_APP_SECRET:}
    app-access-ttl-minutes: 120
    app-refresh-ttl-days: 30
  cors:
@@ -3,6 +3,7 @@ package com.fruitshorts.app.controller;

 import com.fruitshorts.app.service.AppCatalogService;
 import com.fruitshorts.app.service.AppEpisodeStatsService;
+import com.fruitshorts.app.service.AppRankingService;
 import com.fruitshorts.app.support.ControllerContractSupport;
 import com.fruitshorts.app.vo.AppBannerVO;
 import com.fruitshorts.app.vo.AppCategoryVO;
@@ -10,6 +11,8 @@ import com.fruitshorts.app.vo.AppDramaCardVO;
 import com.fruitshorts.app.vo.AppDramaDetailVO;
 import com.fruitshorts.app.vo.AppFeedVO;
 import com.fruitshorts.app.vo.AppSectionVO;
+import com.fruitshorts.app.vo.AppRankingEntryVO;
+import com.fruitshorts.app.vo.AppRankingVO;
 import com.fruitshorts.common.pojo.CursorResult;
 import com.fruitshorts.content.service.EpisodeService;
 import com.fruitshorts.common.exception.ErrorCode;
@@ -41,13 +44,16 @@ import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.
 class AppCatalogControllerContractTest {

    private AppCatalogService catalogService;
+    private AppRankingService rankingService;
    private MockMvc catalogMvc;
    private MockMvc dramaMvc;

    @BeforeEach
    void setUp() {
        catalogService = mock(AppCatalogService.class);
-        catalogMvc = ControllerContractSupport.mockMvcOf(new AppCatalogController(catalogService));
+        rankingService = mock(AppRankingService.class);
+        catalogMvc = ControllerContractSupport.mockMvcOf(
+                new AppCatalogController(catalogService, rankingService));
        dramaMvc = ControllerContractSupport.mockMvcOf(
                new AppDramaController(catalogService, mock(PlaybackService.class),
                        mock(EpisodeService.class), mock(CommentService.class),
@@ -122,15 +128,44 @@ class AppCatalogControllerContractTest {
    @Test
    void should_return_category_list_when_categories_are_requested() throws Exception {
        AppCategoryVO category = new AppCategoryVO(3L, "都市");
+        category.setCode("RECOMMEND_RANKING");
+        category.setLayoutType("RANKING");
+        category.setRevision(7L);
        given(catalogService.categories()).willReturn(List.of(category));

        catalogMvc.perform(get("/app/categories"))
                .andExpect(status().isOk())
                .andExpect(jsonPath("$.code").value(0))
                .andExpect(jsonPath("$.data[0].id").value(3))
+                .andExpect(jsonPath("$.data[0].code").value("RECOMMEND_RANKING"))
+                .andExpect(jsonPath("$.data[0].layoutType").value("RANKING"))
+                .andExpect(jsonPath("$.data[0].revision").value("7"))
                .andExpect(jsonPath("$.data[0].locales.zh").value("都市"));
    }

+    @Test
+    void should_return_server_rank_when_ranking_is_requested() throws Exception {
+        AppDramaCardVO card = new AppDramaCardVO();
+        card.setId(12L);
+        card.setTitleLocales(Map.of("zh", "榜首短剧"));
+        AppRankingVO ranking = new AppRankingVO();
+        ranking.setId(3L);
+        ranking.setCode("RECOMMEND_RANKING");
+        ranking.setRevision(8L);
+        ranking.setTotal(1);
+        ranking.setList(List.of(new AppRankingEntryVO(1, card)));
+        given(rankingService.ranking(3L)).willReturn(ranking);
+
+        catalogMvc.perform(get("/app/categories/3/ranking"))
+                .andExpect(status().isOk())
+                .andExpect(jsonPath("$.code").value(0))
+                .andExpect(jsonPath("$.data.revision").value("8"))
+                .andExpect(jsonPath("$.data.list[0].rank").value(1))
+                .andExpect(jsonPath("$.data.list[0].drama.id").value("12"));
+
+        verify(rankingService).ranking(3L);
+    }
+
    @Test
    void should_bind_path_variable_when_drama_detail_is_requested() throws Exception {
        AppDramaDetailVO detail = new AppDramaDetailVO();
@@ -328,7 +328,9 @@ class AppCommentCountAnonymousSecurityTest {

        @Bean
        AppCatalogController appCatalogController(AppCatalogService appCatalogService) {
-            return new AppCatalogController(appCatalogService);
+            return new AppCatalogController(
+                    appCatalogService,
+                    mock(com.fruitshorts.app.service.AppRankingService.class));
        }

        @Bean
@@ -90,6 +90,7 @@ class AppCreatorAndConfigContractTest {
        whitelist.put("noticeEnabled", true);
        whitelist.put("coinUnlockEnabled", true);
        whitelist.put("downloadEnabled", true);
+        whitelist.put("loginBackgroundUrl", "");
        given(appConfigService.appConfig()).willReturn(whitelist);

        String body = configMvc.perform(get("/app/config"))
@@ -97,6 +98,7 @@ class AppCreatorAndConfigContractTest {
                .andExpect(jsonPath("$.code").value(0))
                .andExpect(jsonPath("$.data.agreementVersion").value("2026-10-01"))
                .andExpect(jsonPath("$.data.forceUpdate").value(false))
+                .andExpect(jsonPath("$.data.loginBackgroundUrl").value(""))
                .andReturn().getResponse().getContentAsString(java.nio.charset.StandardCharsets.UTF_8);

        // 没登录也能拿到（匿名）
@@ -0,0 +1,165 @@
+// Author: fruit.com.cn
+
+package com.fruitshorts.app.controller;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.fruitshorts.commerce.reward.service.RewardCheckinService;
+import com.fruitshorts.commerce.reward.service.RewardGrantService;
+import com.fruitshorts.commerce.reward.service.RewardTaskService;
+import com.fruitshorts.commerce.reward.vo.RewardCheckinVO;
+import com.fruitshorts.commerce.reward.vo.RewardOverviewVO;
+import com.fruitshorts.commerce.reward.vo.RewardActivityVO;
+import com.fruitshorts.commerce.service.WalletService;
+import com.fruitshorts.common.exception.ErrorCode;
+import com.fruitshorts.framework.log.AccessDeniedRecorder;
+import com.fruitshorts.framework.security.JwtAuthenticationFilter;
+import com.fruitshorts.framework.security.JwtTokenProvider;
+import com.fruitshorts.framework.security.RestAuthEntryPoint;
+import com.fruitshorts.framework.security.SecurityConfig;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.springframework.beans.factory.ObjectProvider;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.context.annotation.Import;
+import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
+import org.springframework.security.web.FilterChainProxy;
+import org.springframework.test.context.ContextConfiguration;
+import org.springframework.test.context.junit.jupiter.SpringExtension;
+import org.springframework.test.context.web.WebAppConfiguration;
+import org.springframework.test.web.servlet.MockMvc;
+import org.springframework.test.web.servlet.setup.MockMvcBuilders;
+import org.springframework.web.context.WebApplicationContext;
+import org.springframework.web.servlet.config.annotation.EnableWebMvc;
+
+import java.util.List;
+
+import static org.mockito.ArgumentMatchers.isNull;
+import static org.mockito.BDDMockito.given;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.verify;
+import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.get;
+import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.post;
+import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.jsonPath;
+import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;
+
+/** 奖励中心匿名浏览与写操作鉴权的安全链契约。 */
+@ExtendWith(SpringExtension.class)
+@WebAppConfiguration
+@ContextConfiguration(classes = AppRewardAnonymousSecurityTest.TestConfig.class)
+class AppRewardAnonymousSecurityTest {
+
+    @Autowired
+    private MockMvc mockMvc;
+    @Autowired
+    private RewardTaskService taskService;
+    @Autowired
+    private RewardCheckinService checkinService;
+    @Autowired
+    private WalletService walletService;
+
+    @Test
+    void should_allow_anonymous_reward_overview_without_creating_wallet() throws Exception {
+        RewardOverviewVO overview = new RewardOverviewVO();
+        overview.setCoinBalance(0L);
+        overview.setSections(List.of());
+        overview.setActivities(List.of());
+        given(taskService.overview(isNull(), org.mockito.ArgumentMatchers.eq("en"),
+                org.mockito.ArgumentMatchers.eq(0L))).willReturn(overview);
+        given(checkinService.status(isNull())).willReturn(new RewardCheckinVO());
+
+        mockMvc.perform(get("/app/rewards/overview").param("locale", "en"))
+                .andExpect(status().isOk())
+                .andExpect(jsonPath("$.code").value(0))
+                .andExpect(jsonPath("$.data.coinBalance").value(0));
+
+        verify(walletService, never()).getOrCreate(org.mockito.ArgumentMatchers.any());
+    }
+
+    @Test
+    void should_allow_anonymous_reward_activities() throws Exception {
+        given(taskService.activities("id")).willReturn(List.of(new RewardActivityVO()));
+
+        mockMvc.perform(get("/app/rewards/activities").param("locale", "id"))
+                .andExpect(status().isOk())
+                .andExpect(jsonPath("$.code").value(0))
+                .andExpect(jsonPath("$.data").isArray())
+                .andExpect(jsonPath("$.data", org.hamcrest.Matchers.hasSize(1)));
+    }
+
+    @Test
+    void should_keep_personal_reward_operations_login_required() throws Exception {
+        mockMvc.perform(get("/app/rewards/check-in"))
+                .andExpect(status().isOk())
+                .andExpect(jsonPath("$.code").value(ErrorCode.UNAUTHORIZED.getCode()));
+        mockMvc.perform(post("/app/rewards/check-in"))
+                .andExpect(status().isOk())
+                .andExpect(jsonPath("$.code").value(ErrorCode.UNAUTHORIZED.getCode()));
+        mockMvc.perform(post("/app/rewards/tasks/9/claim"))
+                .andExpect(status().isOk())
+                .andExpect(jsonPath("$.code").value(ErrorCode.UNAUTHORIZED.getCode()));
+    }
+
+    @Configuration
+    @EnableWebMvc
+    @EnableWebSecurity
+    @Import(SecurityConfig.class)
+    static class TestConfig {
+
+        @Bean
+        RewardTaskService rewardTaskService() {
+            return mock(RewardTaskService.class);
+        }
+
+        @Bean
+        RewardCheckinService rewardCheckinService() {
+            return mock(RewardCheckinService.class);
+        }
+
+        @Bean
+        RewardGrantService rewardGrantService() {
+            return mock(RewardGrantService.class);
+        }
+
+        @Bean
+        WalletService walletService() {
+            return mock(WalletService.class);
+        }
+
+        @Bean
+        AppRewardController appRewardController(
+                RewardTaskService taskService,
+                RewardCheckinService checkinService,
+                RewardGrantService grantService,
+                WalletService walletService) {
+            return new AppRewardController(taskService, checkinService, grantService, walletService);
+        }
+
+        @Bean
+        JwtAuthenticationFilter jwtAuthenticationFilter() {
+            return new JwtAuthenticationFilter(mock(JwtTokenProvider.class), mock(ObjectProvider.class));
+        }
+
+        @Bean
+        RestAuthEntryPoint restAuthEntryPoint(ObjectMapper objectMapper) {
+            return new RestAuthEntryPoint(objectMapper,
+                    new AccessDeniedRecorder(mock(ObjectProvider.class), mock(ObjectProvider.class)));
+        }
+
+        @Bean
+        ObjectMapper objectMapper() {
+            return new ObjectMapper();
+        }
+
+        @Bean
+        MockMvc mockMvc(WebApplicationContext context) {
+            FilterChainProxy securityFilter = context.getBean(
+                    "springSecurityFilterChain", FilterChainProxy.class);
+            return MockMvcBuilders.webAppContextSetup(context)
+                    .addFilters(securityFilter)
+                    .build();
+        }
+    }
+}
@@ -130,6 +130,25 @@ class AppCatalogServiceTest {
        verify(commentService, never()).countByDrama(any());
    }

+    @Test
+    void should_keep_full_synopsis_on_card_when_text_exceeds_card_length() {
+        String longSynopsis = "一纸婚约，开启了甜蜜又心动的同居生活。"
+                + "真相只有一个，而她亲手揭开迷雾。一场意外替嫁，让她成为冷面总裁的契约新娘。";
+        Drama drama = new Drama();
+        drama.setId(1L);
+        drama.setTitle("第一部");
+        drama.setSynopsis(longSynopsis);
+        given(episodeService.firstPlayableByDramas(List.of(1L))).willReturn(Map.of());
+        given(dramaCategoryService.listBasic()).willReturn(List.of());
+        given(commentService.countByEpisodes(List.of())).willReturn(Map.of());
+
+        List<AppDramaCardVO> cards = catalogService.toCards(List.of(drama));
+
+        assertThat(cards).hasSize(1);
+        assertThat(cards.get(0).getSynopsisLocales())
+                .containsEntry("zh", longSynopsis);
+    }
+
    @Test
    void should_filter_feed_by_drama_type_and_expose_it_on_card() {
        Drama anime = drama(1L, "ANIME");
@@ -0,0 +1,75 @@
+// Author: fruit.com.cn
+
+package com.fruitshorts.app.service;
+
+import com.fruitshorts.app.vo.AppDramaCardVO;
+import com.fruitshorts.app.vo.AppRankingVO;
+import com.fruitshorts.content.dal.entity.Drama;
+import com.fruitshorts.content.dal.entity.DramaClassification;
+import com.fruitshorts.content.service.DramaClassificationService;
+import com.fruitshorts.content.service.DramaService;
+import org.junit.jupiter.api.Test;
+
+import java.util.List;
+import java.util.Map;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.mockito.BDDMockito.given;
+import static org.mockito.Mockito.mock;
+
+/** 推荐榜快照顺序与排名测试。 */
+class AppRankingServiceTest {
+
+    @Test
+    void should_preserve_server_order_and_compact_rank_when_offline_items_are_filtered() {
+        DramaClassificationService classificationService = mock(DramaClassificationService.class);
+        DramaService dramaService = mock(DramaService.class);
+        AppCatalogService catalogService = mock(AppCatalogService.class);
+        AppRankingService service = new AppRankingService(
+                classificationService, dramaService, catalogService);
+        DramaClassification classification = rankingClassification();
+        Drama second = drama(22L);
+        Drama first = drama(11L);
+        given(classificationService.getEnabledById(3L)).willReturn(classification);
+        given(classificationService.listDramaIdsByClassification(3L))
+                .willReturn(List.of(11L, 99L, 22L));
+        given(dramaService.listPublishedByIds(List.of(11L, 99L, 22L)))
+                .willReturn(List.of(second, first));
+        AppDramaCardVO firstCard = card(11L);
+        AppDramaCardVO secondCard = card(22L);
+        given(catalogService.toCards(List.of(first, second)))
+                .willReturn(List.of(firstCard, secondCard));
+
+        AppRankingVO result = service.ranking(3L);
+
+        assertThat(result.getRevision()).isEqualTo(7L);
+        assertThat(result.getList()).extracting(item -> item.getDrama().getId())
+                .containsExactly(11L, 22L);
+        assertThat(result.getList()).extracting(item -> item.getRank())
+                .containsExactly(1, 2);
+    }
+
+    private DramaClassification rankingClassification() {
+        DramaClassification classification = new DramaClassification();
+        classification.setId(3L);
+        classification.setCode("RECOMMEND_RANKING");
+        classification.setName("推荐榜");
+        classification.setNameLocales("{\"zh\":\"推荐榜\"}");
+        classification.setLayoutType(DramaClassificationService.LAYOUT_RANKING);
+        classification.setRevision(7L);
+        return classification;
+    }
+
+    private Drama drama(Long id) {
+        Drama drama = new Drama();
+        drama.setId(id);
+        return drama;
+    }
+
+    private AppDramaCardVO card(Long id) {
+        AppDramaCardVO card = new AppDramaCardVO();
+        card.setId(id);
+        card.setTitleLocales(Map.of("zh", "短剧" + id));
+        return card;
+    }
+}
@@ -20,18 +20,28 @@ import com.fruitshorts.playback.vo.ProgressRespVO;
 import com.fruitshorts.playback.vo.ProgressSaveReqVO;
 import org.apache.ibatis.builder.MapperBuilderAssistant;
 import org.apache.ibatis.annotations.Select;
+import org.apache.ibatis.session.ExecutorType;
+import org.apache.ibatis.session.SqlSession;
+import org.apache.ibatis.session.SqlSessionFactory;
 import org.junit.jupiter.api.BeforeAll;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
 import org.mockito.ArgumentCaptor;
+import org.mockito.InOrder;
+import org.springframework.beans.factory.ObjectProvider;
+import org.springframework.transaction.PlatformTransactionManager;
+import org.springframework.transaction.support.TransactionTemplate;

 import java.time.LocalDateTime;
 import java.lang.reflect.Method;
 import java.util.List;
+import java.util.Map;

 import static org.assertj.core.api.Assertions.assertThat;
 import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.eq;
 import static org.mockito.BDDMockito.given;
+import static org.mockito.Mockito.inOrder;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.never;
 import static org.mockito.Mockito.times;
@@ -58,11 +68,18 @@ class WatchProgressServiceTest {
        historyMapper = mock(WatchHistoryMapper.class);
        dramaService = mock(DramaService.class);
        episodeService = mock(EpisodeService.class);
+        // 测试统一走缓冲关闭（同步写库）路径：getIfAvailable 返回 null
+        @SuppressWarnings("unchecked")
+        ObjectProvider<WatchProgressBuffer> bufferProvider = mock(ObjectProvider.class);
+        given(bufferProvider.getIfAvailable()).willReturn(null);
        progressService = new WatchProgressService(
                progressMapper,
                historyMapper,
                dramaService,
-                episodeService);
+                episodeService,
+                bufferProvider,
+                mock(SqlSessionFactory.class),
+                new TransactionTemplate(mock(PlatformTransactionManager.class)));
    }

    @Test
@@ -319,6 +336,123 @@ class WatchProgressServiceTest {
        verify(progressMapper).deleteById(1L);
    }

+    @Test
+    void should_delete_buffer_state_when_removing_or_clearing_history() {
+        WatchProgressBuffer buffer = mock(WatchProgressBuffer.class);
+        WatchProgressService service = serviceWithBuffer(buffer);
+
+        service.remove(new InteractionIdentity(9L, ""), 5L);
+        service.clear(new InteractionIdentity(9L, ""));
+
+        verify(buffer).remove(any(InteractionIdentity.class), eq(5L));
+        verify(buffer).clear(any(InteractionIdentity.class));
+        verify(progressMapper, times(2)).delete(any());
+    }
+
+    @Test
+    void should_not_bring_back_deleted_drama_from_buffer_in_recent_page() {
+        WatchProgressBuffer buffer = mock(WatchProgressBuffer.class);
+        WatchProgressService service = serviceWithBuffer(buffer);
+        Page<WatchProgress> emptyPage = new Page<>(1, 20, 0);
+        emptyPage.setRecords(List.of());
+        given(progressMapper.selectPage(any(Page.class), any())).willReturn(emptyPage);
+        given(buffer.getAll(any(InteractionIdentity.class))).willReturn(Map.of(
+                5L, new WatchProgressBuffer.BufferedProgress(
+                        5L, 88L, 1_000L, 2_000L, false, "feed", "", 1_700_000_000_000L)));
+        // 库里该剧只剩逻辑删除行：缓冲状态不得再把它读回列表
+        WatchProgress hidden = progress(5L, 88L);
+        hidden.setDeleted(1);
+        given(progressMapper.selectAnyForIdentityIn(9L, "", List.of(5L)))
+                .willReturn(List.of(hidden));
+
+        PageResult<ProgressRespVO> result =
+                service.recentPage(new InteractionIdentity(9L, ""), 1, 20);
+
+        assertThat(result.getList()).isEmpty();
+        assertThat(result.getTotal()).isZero();
+    }
+
+    @Test
+    void should_drop_buffered_refs_whose_state_is_gone_instead_of_requeue() {
+        WatchProgressBuffer buffer = mock(WatchProgressBuffer.class);
+        WatchProgressService service = serviceWithBuffer(buffer);
+        given(buffer.drain(10)).willReturn(
+                List.of(new WatchProgressBuffer.IdentityRef("u:9", 9L, "", 5L)));
+        given(buffer.getAllBatch(List.of("u:9"))).willReturn(Map.of());
+
+        int flushed = service.flushBuffered(10);
+
+        // 状态已消失（用户删除/清空历史或 TTL 过期）：必须丢弃，退回队列会变成永不消失的僵尸条目
+        assertThat(flushed).isZero();
+        verify(buffer, never()).requeue(any());
+        verify(progressMapper, never()).selectBatchForPairs(any());
+    }
+
+    @Test
+    void should_flush_device_buffer_before_merging_and_clear_it_after() {
+        WatchProgressBuffer buffer = mock(WatchProgressBuffer.class);
+        given(buffer.getAll(any(InteractionIdentity.class))).willReturn(Map.of());
+        WatchProgressService service = serviceWithBuffer(buffer);
+        given(progressMapper.selectList(any())).willReturn(List.of());
+        given(historyMapper.selectList(any())).willReturn(List.of());
+
+        service.mergeDeviceIntoUser(9L, "device-a");
+
+        // 合并前先把缓冲落库，合并完再清掉设备侧缓冲
+        InOrder order = inOrder(buffer);
+        order.verify(buffer).getAll(any(InteractionIdentity.class));
+        order.verify(buffer).clear(any(InteractionIdentity.class));
+    }
+
+    @Test
+    void should_drop_late_buffered_ref_when_row_is_already_deleted() {
+        WatchProgressBuffer buffer = mock(WatchProgressBuffer.class);
+        SqlSessionFactory sessionFactory = mock(SqlSessionFactory.class);
+        SqlSession session = mock(SqlSession.class);
+        WatchProgressMapper batchProgress = mock(WatchProgressMapper.class);
+        WatchHistoryMapper batchHistory = mock(WatchHistoryMapper.class);
+        given(sessionFactory.openSession(ExecutorType.BATCH, false)).willReturn(session);
+        given(session.getMapper(WatchProgressMapper.class)).willReturn(batchProgress);
+        given(session.getMapper(WatchHistoryMapper.class)).willReturn(batchHistory);
+        WatchProgressService service = serviceWithBuffer(buffer, sessionFactory);
+
+        given(buffer.drain(10)).willReturn(
+                List.of(new WatchProgressBuffer.IdentityRef("u:9", 9L, "", 5L)));
+        given(buffer.getAllBatch(List.of("u:9"))).willReturn(Map.of("u:9", Map.of(
+                5L, new WatchProgressBuffer.BufferedProgress(
+                        5L, 88L, 1_000L, 2_000L, false, "feed", "", 1_700_000_000_000L))));
+        // 库里是逻辑删除行，且删除时刻晚于该条缓冲的上报时刻
+        WatchProgress hidden = progress(5L, 88L);
+        hidden.setUserId(9L);
+        hidden.setDeleted(1);
+        hidden.setUpdatedAt(LocalDateTime.of(2026, 10, 28, 12, 0));
+        given(progressMapper.selectBatchForPairs(any())).willReturn(List.of(hidden));
+
+        service.flushBuffered(10);
+
+        verify(batchProgress, never()).updateRowAny(any());
+        verify(batchHistory, never()).insert(any(WatchHistory.class));
+    }
+
+    private WatchProgressService serviceWithBuffer(WatchProgressBuffer buffer) {
+        return serviceWithBuffer(buffer, mock(SqlSessionFactory.class));
+    }
+
+    private WatchProgressService serviceWithBuffer(
+            WatchProgressBuffer buffer, SqlSessionFactory sessionFactory) {
+        @SuppressWarnings("unchecked")
+        ObjectProvider<WatchProgressBuffer> provider = mock(ObjectProvider.class);
+        given(provider.getIfAvailable()).willReturn(buffer);
+        return new WatchProgressService(
+                progressMapper,
+                historyMapper,
+                dramaService,
+                episodeService,
+                provider,
+                sessionFactory,
+                new TransactionTemplate(mock(PlatformTransactionManager.class)));
+    }
+
    private Drama drama(Long id, String title, int totalEpisodes) {
        Drama drama = new Drama();
        drama.setId(id);
@@ -11,17 +11,17 @@ import org.springframework.stereotype.Component;
@ConfigurationProperties(prefix = "fruitshorts.jwt")
 public class JwtProperties {

-    /** 管理端签名密钥，长度必须 >= 32 字节。生产环境通过环境变量注入。 */
-    private String adminSecret = "fruitshorts-admin-dev-secret-change-me-in-production-32b";
+    /** 管理端签名密钥，长度必须 >= 32 字节。**所有环境必须通过环境变量注入，不设任何默认值。** */
+    private String adminSecret = "";

    /** 管理端 token 有效期（小时）。 */
    private int adminTtlHours = 12;

    /**
     * 客户端签名密钥。与管理端物理隔离：管理端 token 拿到客户端接口上无法通过验签，
-     * 反之亦然。生产环境必须通过环境变量注入，不要沿用默认值。
+     * 反之亦然。**所有环境必须通过环境变量注入，不设任何默认值。**
     */
-    private String appSecret = "fruitshorts-app-dev-secret-change-me-in-production-32bytes";
+    private String appSecret = "";

    /** 客户端 access token 有效期（分钟）。 */
    private int appAccessTtlMinutes = 120;
@@ -50,6 +50,9 @@ public class SecurityConfig {
            /* 启动配置与公告：客户端登录前就要拿（POST /app/creator/apply 等仍要登录） */
            "/app/config",
            "/app/notices",
+            /* 奖励中心只读配置：登录前可浏览任务与活动，签到/领取仍需登录。 */
+            "/app/rewards/overview",
+            "/app/rewards/activities",
            /* 服务条款与隐私协议：登录前就要能打开，按语言返回 HTML */
            "/privacy/**",
            "/terms/**",
@@ -108,7 +111,7 @@ public class SecurityConfig {
    @Bean
    public CorsConfigurationSource corsConfigurationSource() {
        CorsConfiguration configuration = new CorsConfiguration();
-        configuration.setAllowedOrigins(Arrays.stream(allowedOrigins.split(",")).map(String::trim).toList());
+        configuration.setAllowedOriginPatterns(Arrays.stream(allowedOrigins.split(",")).map(String::trim).toList());
        configuration.setAllowedMethods(List.of("GET", "POST", "PUT", "DELETE", "OPTIONS", "PATCH"));
        configuration.setAllowedHeaders(List.of("*"));
        configuration.setAllowCredentials(true);
@@ -58,4 +58,10 @@ public final class SecurityUtils {
        }
        return loginUser.userId();
    }
+
+    /** 客户端匿名只读接口取当前用户，未登录或非客户端用户返回 null。 */
+    public static Long getAppUserIdOrNull() {
+        LoginUser loginUser = getLoginUserOrNull();
+        return isAppUser(loginUser) ? loginUser.userId() : null;
+    }
 }
@@ -0,0 +1,39 @@
+// Author: fruit.com.cn
+
+package com.fruitshorts.commerce.reward.dal.entity;
+
+import com.baomidou.mybatisplus.annotation.IdType;
+import com.baomidou.mybatisplus.annotation.TableId;
+import com.baomidou.mybatisplus.annotation.TableName;
+import lombok.Data;
+
+import java.time.LocalDateTime;
+
+/** 奖励中心活动展示卡片。 */
+@Data
+@TableName("reward_activity")
+public class RewardActivity {
+
+    @TableId(type = IdType.ASSIGN_ID)
+    private Long id;
+    private String code;
+    private String coverUrl;
+    private String actionType;
+    private String actionUrl;
+    private String titleId;
+    private String titleEn;
+    private String titleZh;
+    private String summaryId;
+    private String summaryEn;
+    private String summaryZh;
+    private String ctaId;
+    private String ctaEn;
+    private String ctaZh;
+    private Integer sort;
+    private Integer status;
+    private LocalDateTime startAt;
+    private LocalDateTime endAt;
+    private LocalDateTime createdAt;
+    private LocalDateTime updatedAt;
+    private Integer deleted;
+}
@@ -0,0 +1,28 @@
+// Author: fruit.com.cn
+
+package com.fruitshorts.commerce.reward.dal.entity;
+
+import com.baomidou.mybatisplus.annotation.IdType;
+import com.baomidou.mybatisplus.annotation.TableId;
+import com.baomidou.mybatisplus.annotation.TableName;
+import lombok.Data;
+
+import java.time.LocalDate;
+import java.time.LocalDateTime;
+
+/** 用户签到事实，日期唯一用于幂等防刷。 */
+@Data
+@TableName("reward_checkin_record")
+public class RewardCheckinRecord {
+
+    @TableId(type = IdType.ASSIGN_ID)
+    private Long id;
+    private Long userId;
+    private Long taskId;
+    private LocalDate checkinDate;
+    private Integer dayIndex;
+    private Integer streak;
+    private Long rewardCoin;
+    private Long grantId;
+    private LocalDateTime createdAt;
+}
@@ -0,0 +1,24 @@
+// Author: fruit.com.cn
+
+package com.fruitshorts.commerce.reward.dal.entity;
+
+import com.baomidou.mybatisplus.annotation.IdType;
+import com.baomidou.mybatisplus.annotation.TableId;
+import com.baomidou.mybatisplus.annotation.TableName;
+import lombok.Data;
+
+import java.time.LocalDateTime;
+
+/** 签到周期中某一天的金币奖励。 */
+@Data
+@TableName("reward_checkin_rule_day")
+public class RewardCheckinRuleDay {
+
+    @TableId(type = IdType.ASSIGN_ID)
+    private Long id;
+    private Long taskId;
+    private Integer dayIndex;
+    private Long rewardCoin;
+    private LocalDateTime createdAt;
+    private LocalDateTime updatedAt;
+}
@@ -0,0 +1,25 @@
+// Author: fruit.com.cn
+
+package com.fruitshorts.commerce.reward.dal.entity;
+
+import com.baomidou.mybatisplus.annotation.IdType;
+import com.baomidou.mybatisplus.annotation.TableId;
+import com.baomidou.mybatisplus.annotation.TableName;
+import lombok.Data;
+
+import java.time.LocalDateTime;
+
+/** 服务端已验证奖励事件，用幂等键防止重复上报累计。 */
+@Data
+@TableName("reward_event_log")
+public class RewardEventLog {
+
+    @TableId(type = IdType.ASSIGN_ID)
+    private Long id;
+    private Long userId;
+    private String eventType;
+    private String sourceId;
+    private Long eventValue;
+    private String idempotentKey;
+    private LocalDateTime occurredAt;
+}
@@ -0,0 +1,33 @@
+// Author: fruit.com.cn
+
+package com.fruitshorts.commerce.reward.dal.entity;
+
+import com.baomidou.mybatisplus.annotation.IdType;
+import com.baomidou.mybatisplus.annotation.TableId;
+import com.baomidou.mybatisplus.annotation.TableName;
+import lombok.Data;
+
+import java.time.LocalDateTime;
+
+/** 奖励发放单，关联钱包流水并保留操作审计信息。 */
+@Data
+@TableName("reward_grant")
+public class RewardGrant {
+
+    @TableId(type = IdType.ASSIGN_ID)
+    private Long id;
+    private Long userId;
+    private Long taskId;
+    private String cycleKey;
+    private Integer claimSeq;
+    private Long amount;
+    private String status;
+    private String idempotentKey;
+    private Long coinLedgerId;
+    private String source;
+    private Long operatorId;
+    private String failureReason;
+    private LocalDateTime grantedAt;
+    private LocalDateTime createdAt;
+    private LocalDateTime updatedAt;
+}
@@ -0,0 +1,51 @@
+// Author: fruit.com.cn
+
+package com.fruitshorts.commerce.reward.dal.entity;
+
+import com.baomidou.mybatisplus.annotation.IdType;
+import com.baomidou.mybatisplus.annotation.TableId;
+import com.baomidou.mybatisplus.annotation.TableName;
+import lombok.Data;
+
+import java.time.LocalDateTime;
+
+/** 奖励任务配置，后台维护后由客户端奖励页读取。 */
+@Data
+@TableName("reward_task")
+public class RewardTask {
+
+    @TableId(type = IdType.ASSIGN_ID)
+    private Long id;
+    private String code;
+    private String sectionCode;
+    private String type;
+    private String verifyMode;
+    private Long targetValue;
+    private Long rewardCoin;
+    private String cycleType;
+    private Integer cycleLimit;
+    private String actionType;
+    private String actionUrl;
+    private String iconUrl;
+    private String titleId;
+    private String titleEn;
+    private String titleZh;
+    private String subtitleId;
+    private String subtitleEn;
+    private String subtitleZh;
+    private String ctaId;
+    private String ctaEn;
+    private String ctaZh;
+    private String sectionTitleId;
+    private String sectionTitleEn;
+    private String sectionTitleZh;
+    private String configJson;
+    private Integer sort;
+    private Integer status;
+    private LocalDateTime startAt;
+    private LocalDateTime endAt;
+    private Integer version;
+    private LocalDateTime createdAt;
+    private LocalDateTime updatedAt;
+    private Integer deleted;
+}
@@ -0,0 +1,31 @@
+// Author: fruit.com.cn
+
+package com.fruitshorts.commerce.reward.dal.entity;
+
+import com.baomidou.mybatisplus.annotation.IdType;
+import com.baomidou.mybatisplus.annotation.TableId;
+import com.baomidou.mybatisplus.annotation.TableName;
+import lombok.Data;
+
+import java.time.LocalDateTime;
+
+/** 用户任务在一个周期内的服务端进度。 */
+@Data
+@TableName("reward_task_progress")
+public class RewardTaskProgress {
+
+    @TableId(type = IdType.ASSIGN_ID)
+    private Long id;
+    private Long userId;
+    private Long taskId;
+    private String cycleKey;
+    private Long progressValue;
+    private Long targetValue;
+    private String status;
+    private Integer claimSeq;
+    private LocalDateTime completedAt;
+    private LocalDateTime claimedAt;
+    private LocalDateTime lastEventAt;
+    private LocalDateTime createdAt;
+    private LocalDateTime updatedAt;
+}
@@ -0,0 +1,10 @@
+// Author: fruit.com.cn
+
+package com.fruitshorts.commerce.reward.dal.mapper;
+
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+import com.fruitshorts.commerce.reward.dal.entity.RewardActivity;
+
+/** 奖励活动访问。 */
+public interface RewardActivityMapper extends BaseMapper<RewardActivity> {
+}
@@ -0,0 +1,10 @@
+// Author: fruit.com.cn
+
+package com.fruitshorts.commerce.reward.dal.mapper;
+
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+import com.fruitshorts.commerce.reward.dal.entity.RewardCheckinRecord;
+
+/** 用户签到事实访问。 */
+public interface RewardCheckinRecordMapper extends BaseMapper<RewardCheckinRecord> {
+}
@@ -0,0 +1,10 @@
+// Author: fruit.com.cn
+
+package com.fruitshorts.commerce.reward.dal.mapper;
+
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+import com.fruitshorts.commerce.reward.dal.entity.RewardCheckinRuleDay;
+
+/** 签到规则访问。 */
+public interface RewardCheckinRuleDayMapper extends BaseMapper<RewardCheckinRuleDay> {
+}
@@ -0,0 +1,10 @@
+// Author: fruit.com.cn
+
+package com.fruitshorts.commerce.reward.dal.mapper;
+
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+import com.fruitshorts.commerce.reward.dal.entity.RewardEventLog;
+
+/** 服务端奖励事件访问。 */
+public interface RewardEventLogMapper extends BaseMapper<RewardEventLog> {
+}
@@ -0,0 +1,10 @@
+// Author: fruit.com.cn
+
+package com.fruitshorts.commerce.reward.dal.mapper;
+
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+import com.fruitshorts.commerce.reward.dal.entity.RewardGrant;
+
+/** 奖励发放单访问。 */
+public interface RewardGrantMapper extends BaseMapper<RewardGrant> {
+}
@@ -0,0 +1,10 @@
+// Author: fruit.com.cn
+
+package com.fruitshorts.commerce.reward.dal.mapper;
+
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+import com.fruitshorts.commerce.reward.dal.entity.RewardTask;
+
+/** 奖励任务表访问。 */
+public interface RewardTaskMapper extends BaseMapper<RewardTask> {
+}
@@ -0,0 +1,10 @@
+// Author: fruit.com.cn
+
+package com.fruitshorts.commerce.reward.dal.mapper;
+
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+import com.fruitshorts.commerce.reward.dal.entity.RewardTaskProgress;
+
+/** 用户奖励进度表访问。 */
+public interface RewardTaskProgressMapper extends BaseMapper<RewardTaskProgress> {
+}
@@ -0,0 +1,136 @@
+// Author: fruit.com.cn
+
+package com.fruitshorts.commerce.reward.service;
+
+import com.baomidou.mybatisplus.core.metadata.IPage;
+import com.baomidou.mybatisplus.core.toolkit.Wrappers;
+import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
+import com.fruitshorts.commerce.reward.dal.entity.RewardActivity;
+import com.fruitshorts.commerce.reward.dal.mapper.RewardActivityMapper;
+import com.fruitshorts.commerce.reward.vo.RewardActivityQueryReqVO;
+import com.fruitshorts.commerce.reward.vo.RewardActivityRespVO;
+import com.fruitshorts.commerce.reward.vo.RewardActivitySaveReqVO;
+import com.fruitshorts.common.exception.ErrorCode;
+import com.fruitshorts.common.exception.ServiceException;
+import com.fruitshorts.common.pojo.PageResult;
+import lombok.RequiredArgsConstructor;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+import org.springframework.util.StringUtils;
+
+/** 奖励中心活动的后台配置服务。 */
+@Service
+@RequiredArgsConstructor
+public class RewardActivityAdminService {
+
+    private final RewardActivityMapper activityMapper;
+
+    /** 分页查询活动配置。 */
+    public PageResult<RewardActivityRespVO> page(RewardActivityQueryReqVO req) {
+        Page<RewardActivity> page = new Page<>(req.getSafePageIndex(), req.getSafePageSize());
+        IPage<RewardActivity> result = activityMapper.selectPage(page, Wrappers.<RewardActivity>lambdaQuery()
+                .eq(RewardActivity::getDeleted, 0)
+                .eq(req.getStatus() != null, RewardActivity::getStatus, req.getStatus())
+                .and(StringUtils.hasText(req.getKeyword()), w -> w
+                        .like(RewardActivity::getCode, req.getKeyword())
+                        .or().like(RewardActivity::getTitleId, req.getKeyword())
+                        .or().like(RewardActivity::getTitleEn, req.getKeyword())
+                        .or().like(RewardActivity::getTitleZh, req.getKeyword()))
+                .orderByAsc(RewardActivity::getSort)
+                .orderByDesc(RewardActivity::getId));
+        return new PageResult<>(result.getTotal(), result.getRecords().stream()
+                .map(RewardActivityRespVO::of).toList());
+    }
+
+    /** 查询活动详情。 */
+    public RewardActivityRespVO detail(Long id) {
+        return RewardActivityRespVO.of(getExisting(id));
+    }
+
+    /** 新建活动，默认下线，避免半配置内容立即展示。 */
+    @Transactional(rollbackFor = Exception.class)
+    public Long create(RewardActivitySaveReqVO req) {
+        validate(req);
+        String code = req.getCode().trim();
+        requireCodeFree(code, null);
+        RewardActivity activity = new RewardActivity();
+        activity.setCode(code);
+        apply(activity, req);
+        activity.setStatus(0);
+        activityMapper.insert(activity);
+        return activity.getId();
+    }
+
+    /** 编辑活动，保留现有上下线状态。 */
+    @Transactional(rollbackFor = Exception.class)
+    public void update(Long id, RewardActivitySaveReqVO req) {
+        validate(req);
+        RewardActivity activity = getExisting(id);
+        String code = req.getCode().trim();
+        requireCodeFree(code, id);
+        activity.setCode(code);
+        apply(activity, req);
+        activityMapper.updateById(activity);
+    }
+
+    /** 上线或下线活动。 */
+    @Transactional(rollbackFor = Exception.class)
+    public void updateStatus(Long id, Integer status) {
+        if (status == null || (status != 0 && status != 1)) {
+            throw new ServiceException(ErrorCode.BAD_REQUEST, "状态只能是 0 或 1");
+        }
+        RewardActivity activity = getExisting(id);
+        activity.setStatus(status);
+        activityMapper.updateById(activity);
+    }
+
+    private void validate(RewardActivitySaveReqVO req) {
+        if (req == null || !StringUtils.hasText(req.getCode()) || !StringUtils.hasText(req.getTitleId())) {
+            throw new ServiceException(ErrorCode.BAD_REQUEST, "请填写活动编码和印尼语标题");
+        }
+    }
+
+    private void apply(RewardActivity activity, RewardActivitySaveReqVO req) {
+        activity.setCoverUrl(valueOrEmpty(req.getCoverUrl()));
+        activity.setActionType(valueOrDefault(req.getActionType(), "NONE"));
+        activity.setActionUrl(valueOrEmpty(req.getActionUrl()));
+        activity.setTitleId(req.getTitleId().trim());
+        activity.setTitleEn(valueOrEmpty(req.getTitleEn()));
+        activity.setTitleZh(valueOrEmpty(req.getTitleZh()));
+        activity.setSummaryId(valueOrEmpty(req.getSummaryId()));
+        activity.setSummaryEn(valueOrEmpty(req.getSummaryEn()));
+        activity.setSummaryZh(valueOrEmpty(req.getSummaryZh()));
+        activity.setCtaId(valueOrEmpty(req.getCtaId()));
+        activity.setCtaEn(valueOrEmpty(req.getCtaEn()));
+        activity.setCtaZh(valueOrEmpty(req.getCtaZh()));
+        activity.setSort(req.getSort() == null ? 0 : req.getSort());
+        activity.setStartAt(req.getStartAt());
+        activity.setEndAt(req.getEndAt());
+    }
+
+    private RewardActivity getExisting(Long id) {
+        RewardActivity activity = id == null ? null : activityMapper.selectById(id);
+        if (activity == null || Integer.valueOf(1).equals(activity.getDeleted())) {
+            throw new ServiceException(ErrorCode.DATA_NOT_FOUND, "奖励活动不存在");
+        }
+        return activity;
+    }
+
+    private void requireCodeFree(String code, Long excludeId) {
+        Long count = activityMapper.selectCount(Wrappers.<RewardActivity>lambdaQuery()
+                .eq(RewardActivity::getCode, code)
+                .eq(RewardActivity::getDeleted, 0)
+                .ne(excludeId != null, RewardActivity::getId, excludeId));
+        if (count != null && count > 0) {
+            throw new ServiceException(ErrorCode.DATA_EXISTS, "活动编码已存在：" + code);
+        }
+    }
+
+    private String valueOrEmpty(String value) {
+        return value == null ? "" : value.trim();
+    }
+
+    private String valueOrDefault(String value, String fallback) {
+        return StringUtils.hasText(value) ? value.trim() : fallback;
+    }
+}
@@ -0,0 +1,170 @@
+// Author: fruit.com.cn
+
+package com.fruitshorts.commerce.reward.service;
+
+import com.baomidou.mybatisplus.core.toolkit.Wrappers;
+import com.fruitshorts.commerce.reward.dal.entity.RewardCheckinRecord;
+import com.fruitshorts.commerce.reward.dal.entity.RewardCheckinRuleDay;
+import com.fruitshorts.commerce.reward.dal.entity.RewardTask;
+import com.fruitshorts.commerce.reward.dal.mapper.RewardCheckinRecordMapper;
+import com.fruitshorts.commerce.reward.dal.mapper.RewardCheckinRuleDayMapper;
+import com.fruitshorts.commerce.reward.dal.mapper.RewardTaskMapper;
+import com.fruitshorts.commerce.reward.vo.RewardCheckinRespVO;
+import com.fruitshorts.commerce.reward.vo.RewardCheckinRuleDayReqVO;
+import com.fruitshorts.commerce.reward.vo.RewardCheckinRuleSaveReqVO;
+import com.fruitshorts.commerce.reward.vo.RewardCheckinVO;
+import com.fruitshorts.commerce.reward.vo.RewardRuleDayVO;
+import com.fruitshorts.common.exception.ErrorCode;
+import com.fruitshorts.common.exception.ServiceException;
+import lombok.RequiredArgsConstructor;
+import org.springframework.dao.DuplicateKeyException;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.time.LocalDate;
+import java.util.List;
+
+/** 每日签到规则与签到发放。 */
+@Service
+@RequiredArgsConstructor
+public class RewardCheckinService {
+
+    private static final String CHECKIN_CODE = "daily_check_in";
+    private static final String CHECKIN_TYPE = RewardTaskService.TYPE_DAILY_CHECK_IN;
+
+    private final RewardTaskMapper taskMapper;
+    private final RewardCheckinRuleDayMapper ruleMapper;
+    private final RewardCheckinRecordMapper recordMapper;
+    private final RewardGrantService grantService;
+
+    /** 客户端签到状态。 */
+    public RewardCheckinVO status(Long userId) {
+        RewardTask task = task();
+        List<RewardCheckinRuleDay> rules = rules(task.getId());
+        if (userId == null) {
+            return anonymousStatus(task, rules);
+        }
+        RewardCheckinRecord latest = latest(userId, task.getId());
+        LocalDate today = LocalDate.now(RewardTaskService.REWARD_ZONE);
+        boolean checked = recordMapper.selectCount(Wrappers.<RewardCheckinRecord>lambdaQuery()
+                .eq(RewardCheckinRecord::getUserId, userId).eq(RewardCheckinRecord::getTaskId, task.getId())
+                .eq(RewardCheckinRecord::getCheckinDate, today)) > 0;
+        int currentDay = latest == null ? 1 : Math.min(latest.getDayIndex() + 1, rules.size());
+        RewardCheckinVO vo = new RewardCheckinVO();
+        vo.setTaskId(task.getId());
+        vo.setCheckedInToday(checked);
+        vo.setStreak(latest == null ? 0 : latest.getStreak());
+        vo.setCurrentDay(currentDay);
+        vo.setDays(rules.stream().map(rule -> new RewardRuleDayVO(rule.getDayIndex(), rule.getRewardCoin(),
+                checked && latest != null && rule.getDayIndex() <= latest.getDayIndex(),
+                rule.getDayIndex() == currentDay)).toList());
+        return vo;
+    }
+
+    private RewardCheckinVO anonymousStatus(RewardTask task, List<RewardCheckinRuleDay> rules) {
+        RewardCheckinVO vo = new RewardCheckinVO();
+        vo.setTaskId(task.getId());
+        vo.setCheckedInToday(false);
+        vo.setStreak(0);
+        vo.setCurrentDay(1);
+        vo.setDays(rules.stream().map(rule -> new RewardRuleDayVO(
+                rule.getDayIndex(), rule.getRewardCoin(), false, rule.getDayIndex() == 1)).toList());
+        return vo;
+    }
+
+    /** 后台查看当前签到规则。 */
+    public List<RewardRuleDayVO> rulesForAdmin() {
+        RewardTask task = task();
+        return rules(task.getId()).stream()
+                .map(rule -> new RewardRuleDayVO(rule.getDayIndex(), rule.getRewardCoin(), false, false))
+                .toList();
+    }
+
+    /** 客户端执行签到，按印尼时区计算连续天数。 */
+    @Transactional(rollbackFor = Exception.class)
+    public RewardCheckinRespVO checkIn(Long userId) {
+        RewardTask task = task();
+        LocalDate today = LocalDate.now(RewardTaskService.REWARD_ZONE);
+        RewardCheckinRecord existed = recordMapper.selectOne(Wrappers.<RewardCheckinRecord>lambdaQuery()
+                .eq(RewardCheckinRecord::getUserId, userId).eq(RewardCheckinRecord::getTaskId, task.getId())
+                .eq(RewardCheckinRecord::getCheckinDate, today).last("limit 1"));
+        if (existed != null) return toResp(existed, true, userId);
+        List<RewardCheckinRuleDay> rules = rules(task.getId());
+        RewardCheckinRecord latest = latest(userId, task.getId());
+        int streak = latest != null && latest.getCheckinDate().plusDays(1).equals(today)
+                ? latest.getStreak() + 1 : 1;
+        int dayIndex = ((streak - 1) % rules.size()) + 1;
+        RewardCheckinRuleDay rule = rules.stream().filter(item -> item.getDayIndex() == dayIndex).findFirst()
+                .orElseThrow(() -> new ServiceException(ErrorCode.OPERATION_NOT_ALLOWED, "签到规则未配置"));
+        String key = "reward:checkin:" + userId + ":" + today;
+        var grant = grantService.grant(userId, task.getId(), today.toString(), rule.getRewardCoin(),
+                RewardGrantService.SOURCE_APP, 0L, key);
+        RewardCheckinRecord record = new RewardCheckinRecord();
+        record.setUserId(userId);
+        record.setTaskId(task.getId());
+        record.setCheckinDate(today);
+        record.setDayIndex(dayIndex);
+        record.setStreak(streak);
+        record.setRewardCoin(rule.getRewardCoin());
+        record.setGrantId(grant.getId());
+        try {
+            recordMapper.insert(record);
+        } catch (DuplicateKeyException ex) {
+            RewardCheckinRecord raced = recordMapper.selectOne(Wrappers.<RewardCheckinRecord>lambdaQuery()
+                    .eq(RewardCheckinRecord::getUserId, userId).eq(RewardCheckinRecord::getTaskId, task.getId())
+                    .eq(RewardCheckinRecord::getCheckinDate, today).last("limit 1"));
+            if (raced != null) return toResp(raced, true, userId);
+            throw ex;
+        }
+        return toResp(record, false, userId);
+    }
+
+    /** 后台覆盖签到规则，按天数唯一校验。 */
+    @Transactional(rollbackFor = Exception.class)
+    public void saveRules(RewardCheckinRuleSaveReqVO req) {
+        RewardTask task = task();
+        long distinct = req.getDays().stream().map(RewardCheckinRuleDayReqVO::getDayIndex).distinct().count();
+        if (distinct != req.getDays().size()) throw new ServiceException(ErrorCode.BAD_REQUEST, "签到天数不能重复");
+        ruleMapper.delete(Wrappers.<RewardCheckinRuleDay>lambdaQuery().eq(RewardCheckinRuleDay::getTaskId, task.getId()));
+        for (RewardCheckinRuleDayReqVO item : req.getDays()) {
+            RewardCheckinRuleDay row = new RewardCheckinRuleDay();
+            row.setTaskId(task.getId());
+            row.setDayIndex(item.getDayIndex());
+            row.setRewardCoin(item.getRewardCoin());
+            ruleMapper.insert(row);
+        }
+    }
+
+    private RewardTask task() {
+        RewardTask task = taskMapper.selectOne(Wrappers.<RewardTask>lambdaQuery()
+                .eq(RewardTask::getCode, CHECKIN_CODE).eq(RewardTask::getType, CHECKIN_TYPE)
+                .eq(RewardTask::getStatus, 1).eq(RewardTask::getDeleted, 0).last("limit 1"));
+        if (task == null) throw new ServiceException(ErrorCode.DATA_NOT_FOUND, "签到任务未配置");
+        return task;
+    }
+
+    private List<RewardCheckinRuleDay> rules(Long taskId) {
+        List<RewardCheckinRuleDay> rows = ruleMapper.selectList(Wrappers.<RewardCheckinRuleDay>lambdaQuery()
+                .eq(RewardCheckinRuleDay::getTaskId, taskId).orderByAsc(RewardCheckinRuleDay::getDayIndex));
+        if (rows.isEmpty()) throw new ServiceException(ErrorCode.DATA_NOT_FOUND, "签到规则未配置");
+        return rows;
+    }
+
+    private RewardCheckinRecord latest(Long userId, Long taskId) {
+        return recordMapper.selectOne(Wrappers.<RewardCheckinRecord>lambdaQuery()
+                .eq(RewardCheckinRecord::getUserId, userId).eq(RewardCheckinRecord::getTaskId, taskId)
+                .orderByDesc(RewardCheckinRecord::getCheckinDate).last("limit 1"));
+    }
+
+    private RewardCheckinRespVO toResp(RewardCheckinRecord record, boolean existed, Long userId) {
+        RewardCheckinRespVO vo = new RewardCheckinRespVO();
+        vo.setTaskId(record.getTaskId());
+        vo.setGrantId(record.getGrantId());
+        vo.setDayIndex(record.getDayIndex());
+        vo.setStreak(record.getStreak());
+        vo.setRewardCoin(record.getRewardCoin());
+        vo.setCoinBalance(grantService.balance(userId));
+        vo.setAlreadyCheckedIn(existed);
+        return vo;
+    }
+}
@@ -0,0 +1,140 @@
+// Author: fruit.com.cn
+
+package com.fruitshorts.commerce.reward.service;
+
+import com.baomidou.mybatisplus.core.metadata.IPage;
+import com.baomidou.mybatisplus.core.toolkit.Wrappers;
+import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
+import com.fruitshorts.commerce.dal.entity.CoinLedger;
+import com.fruitshorts.commerce.reward.dal.entity.RewardGrant;
+import com.fruitshorts.commerce.reward.dal.entity.RewardTask;
+import com.fruitshorts.commerce.reward.dal.entity.RewardTaskProgress;
+import com.fruitshorts.commerce.reward.dal.mapper.RewardGrantMapper;
+import com.fruitshorts.commerce.reward.dal.mapper.RewardTaskProgressMapper;
+import com.fruitshorts.commerce.reward.vo.RewardClaimRespVO;
+import com.fruitshorts.commerce.reward.vo.RewardGrantQueryReqVO;
+import com.fruitshorts.commerce.reward.vo.RewardGrantRespVO;
+import com.fruitshorts.common.exception.ErrorCode;
+import com.fruitshorts.common.exception.ServiceException;
+import com.fruitshorts.common.pojo.PageResult;
+import lombok.RequiredArgsConstructor;
+import org.springframework.dao.DuplicateKeyException;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+import org.springframework.util.StringUtils;
+
+import java.time.LocalDateTime;
+
+/** 奖励发放、任务领取和人工补发，统一复用钱包流水。 */
+@Service
+@RequiredArgsConstructor
+public class RewardGrantService {
+
+    public static final String STATUS_PENDING = "PENDING";
+    public static final String STATUS_GRANTED = "GRANTED";
+    public static final String SOURCE_APP = "APP";
+    public static final String SOURCE_ADMIN = "ADMIN";
+
+    private final RewardGrantMapper grantMapper;
+    private final RewardTaskProgressMapper progressMapper;
+    private final WalletServiceFacade wallet;
+
+    /** 领取已完成任务。 */
+    @Transactional(rollbackFor = Exception.class)
+    public RewardClaimRespVO claim(Long userId, RewardTask task, RewardTaskProgress progress) {
+        if (progress == null || (!RewardTaskService.STATUS_COMPLETED.equals(progress.getStatus())
+                && !RewardTaskService.STATUS_CLAIMED.equals(progress.getStatus()))) {
+            throw new ServiceException(ErrorCode.OPERATION_NOT_ALLOWED, "任务尚未完成");
+        }
+        String key = "reward:" + task.getCode() + ":" + userId + ":" + progress.getCycleKey();
+        boolean existed = grantMapper.selectCount(Wrappers.<RewardGrant>lambdaQuery()
+                .eq(RewardGrant::getIdempotentKey, key)) > 0;
+        RewardGrant grant = grant(userId, task.getId(), progress.getCycleKey(), task.getRewardCoin(),
+                SOURCE_APP, 0L, key);
+        RewardClaimRespVO result = new RewardClaimRespVO();
+        result.setTaskId(task.getId());
+        result.setGrantId(grant.getId());
+        result.setRewardCoin(grant.getAmount());
+        result.setCoinBalance(wallet.balance(userId));
+        result.setAlreadyGranted(existed);
+        progress.setStatus(RewardTaskService.STATUS_CLAIMED);
+        progress.setClaimedAt(LocalDateTime.now());
+        progressMapper.updateById(progress);
+        return result;
+    }
+
+    /** 统一发放事务；先登记发放单，再写钱包流水，最后回填流水 id。 */
+    @Transactional(rollbackFor = Exception.class)
+    public RewardGrant grant(Long userId, Long taskId, String cycleKey, Long amount,
+                             String source, Long operatorId, String idempotentKey) {
+        if (amount == null || amount <= 0) {
+            throw new ServiceException(ErrorCode.BAD_REQUEST, "奖励金币必须大于 0");
+        }
+        RewardGrant existed = grantMapper.selectOne(Wrappers.<RewardGrant>lambdaQuery()
+                .eq(RewardGrant::getIdempotentKey, idempotentKey).last("limit 1"));
+        if (existed != null && STATUS_GRANTED.equals(existed.getStatus())) return existed;
+        RewardGrant row = existed == null ? newGrant(userId, taskId, cycleKey, amount, source, operatorId, idempotentKey) : existed;
+        if (existed == null) {
+            try {
+                grantMapper.insert(row);
+            } catch (DuplicateKeyException ex) {
+                RewardGrant raced = grantMapper.selectOne(Wrappers.<RewardGrant>lambdaQuery()
+                        .eq(RewardGrant::getIdempotentKey, idempotentKey).last("limit 1"));
+                if (raced != null) return raced;
+                throw ex;
+            }
+        }
+        CoinLedger ledger = wallet.change(userId, amount, idempotentKey, source, operatorId);
+        row.setStatus(STATUS_GRANTED);
+        row.setCoinLedgerId(ledger.getId());
+        row.setGrantedAt(LocalDateTime.now());
+        row.setFailureReason("");
+        grantMapper.updateById(row);
+        return row;
+    }
+
+    /** 后台分页查看发放记录。 */
+    public PageResult<RewardGrantRespVO> page(RewardGrantQueryReqVO req) {
+        Page<RewardGrant> page = new Page<>(req.getSafePageIndex(), req.getSafePageSize());
+        IPage<RewardGrant> result = grantMapper.selectPage(page, Wrappers.<RewardGrant>lambdaQuery()
+                .eq(req.getUserId() != null, RewardGrant::getUserId, req.getUserId())
+                .eq(req.getTaskId() != null, RewardGrant::getTaskId, req.getTaskId())
+                .eq(StringUtils.hasText(req.getStatus()), RewardGrant::getStatus, req.getStatus())
+                .eq(StringUtils.hasText(req.getSource()), RewardGrant::getSource, req.getSource())
+                .orderByDesc(RewardGrant::getCreatedAt));
+        return new PageResult<>(result.getTotal(), result.getRecords().stream()
+                .map(RewardGrantRespVO::of).toList());
+    }
+
+    /** 返回奖励发放后的钱包余额。 */
+    public Long balance(Long userId) {
+        return wallet.balance(userId);
+    }
+
+    /** 后台人工补发奖励，幂等键为空时生成一次性操作键。 */
+    @Transactional(rollbackFor = Exception.class)
+    public RewardGrantRespVO manualGrant(Long userId, Long taskId, Long amount,
+                                         String idempotentKey, Long operatorId) {
+        String key = StringUtils.hasText(idempotentKey) ? idempotentKey.trim()
+                : "reward-admin:" + operatorId + ":" + userId + ":" + System.currentTimeMillis();
+        RewardGrant grant = grant(userId, taskId, "MANUAL", amount, SOURCE_ADMIN, operatorId, key);
+        return RewardGrantRespVO.of(grant);
+    }
+
+    private RewardGrant newGrant(Long userId, Long taskId, String cycleKey, Long amount,
+                                 String source, Long operatorId, String key) {
+        RewardGrant row = new RewardGrant();
+        row.setUserId(userId);
+        row.setTaskId(taskId == null ? 0L : taskId);
+        row.setCycleKey(cycleKey == null ? "MANUAL" : cycleKey);
+        row.setClaimSeq(1);
+        row.setAmount(amount);
+        row.setStatus(STATUS_PENDING);
+        row.setIdempotentKey(key);
+        row.setCoinLedgerId(0L);
+        row.setSource(source);
+        row.setOperatorId(operatorId == null ? 0L : operatorId);
+        row.setFailureReason("");
+        return row;
+    }
+}
@@ -0,0 +1,77 @@
+// Author: fruit.com.cn
+
+package com.fruitshorts.commerce.reward.service;
+
+import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
+import com.baomidou.mybatisplus.core.toolkit.Wrappers;
+import com.fruitshorts.commerce.reward.dal.entity.RewardTask;
+import com.fruitshorts.commerce.reward.vo.RewardTaskQueryReqVO;
+import com.fruitshorts.commerce.reward.vo.RewardTaskSaveReqVO;
+import com.fruitshorts.common.exception.ErrorCode;
+import com.fruitshorts.common.exception.ServiceException;
+import org.springframework.util.StringUtils;
+
+import java.util.Locale;
+
+/** 奖励任务后台配置的字段校验、查询与复制规则。 */
+final class RewardTaskConfiguration {
+
+    private RewardTaskConfiguration() {
+    }
+
+    static LambdaQueryWrapper<RewardTask> taskQuery(RewardTaskQueryReqVO req) {
+        return Wrappers.<RewardTask>lambdaQuery().eq(RewardTask::getDeleted, 0)
+                .eq(StringUtils.hasText(req.getType()), RewardTask::getType, req.getType())
+                .eq(StringUtils.hasText(req.getSectionCode()), RewardTask::getSectionCode, req.getSectionCode())
+                .eq(req.getStatus() != null, RewardTask::getStatus, req.getStatus())
+                .and(StringUtils.hasText(req.getKeyword()), wrapper -> wrapper
+                        .like(RewardTask::getCode, req.getKeyword())
+                        .or().like(RewardTask::getTitleId, req.getKeyword())
+                        .or().like(RewardTask::getTitleEn, req.getKeyword()))
+                .orderByAsc(RewardTask::getSort).orderByDesc(RewardTask::getId);
+    }
+
+    static void validate(RewardTaskSaveReqVO req) {
+        if (req.getStartAt() != null && req.getEndAt() != null
+                && req.getStartAt().isAfter(req.getEndAt())) {
+            throw new ServiceException(ErrorCode.BAD_REQUEST, "任务开始时间不能晚于结束时间");
+        }
+        if (RewardTaskService.CYCLE_ONCE.equals(req.getCycleType())
+                && req.getCycleLimit() != null && req.getCycleLimit() > 1) {
+            throw new ServiceException(ErrorCode.BAD_REQUEST, "一次性任务的周期上限只能为 1");
+        }
+    }
+
+    static void apply(RewardTask task, RewardTaskSaveReqVO req) {
+        task.setSectionCode(req.getSectionCode().trim());
+        task.setType(req.getType().trim().toUpperCase(Locale.ROOT));
+        task.setVerifyMode(StringUtils.hasText(req.getVerifyMode()) ? req.getVerifyMode() : "SERVER");
+        task.setTargetValue(req.getTargetValue());
+        task.setRewardCoin(req.getRewardCoin());
+        task.setCycleType(req.getCycleType().trim().toUpperCase(Locale.ROOT));
+        task.setCycleLimit(req.getCycleLimit() == null ? 1 : req.getCycleLimit());
+        task.setActionType(StringUtils.hasText(req.getActionType()) ? req.getActionType() : "NONE");
+        task.setActionUrl(blank(req.getActionUrl()));
+        task.setIconUrl(blank(req.getIconUrl()));
+        task.setTitleId(req.getTitleId().trim());
+        task.setTitleEn(blank(req.getTitleEn()));
+        task.setTitleZh(blank(req.getTitleZh()));
+        task.setSubtitleId(blank(req.getSubtitleId()));
+        task.setSubtitleEn(blank(req.getSubtitleEn()));
+        task.setSubtitleZh(blank(req.getSubtitleZh()));
+        task.setCtaId(blank(req.getCtaId()));
+        task.setCtaEn(blank(req.getCtaEn()));
+        task.setCtaZh(blank(req.getCtaZh()));
+        task.setSectionTitleId(req.getSectionTitleId().trim());
+        task.setSectionTitleEn(blank(req.getSectionTitleEn()));
+        task.setSectionTitleZh(blank(req.getSectionTitleZh()));
+        task.setConfigJson(blank(req.getConfigJson()));
+        task.setSort(req.getSort() == null ? 0 : req.getSort());
+        task.setStartAt(req.getStartAt());
+        task.setEndAt(req.getEndAt());
+    }
+
+    private static String blank(String value) {
+        return value == null ? "" : value.trim();
+    }
+}
@@ -0,0 +1,306 @@
+// Author: fruit.com.cn
+
+package com.fruitshorts.commerce.reward.service;
+
+import com.baomidou.mybatisplus.core.metadata.IPage;
+import com.baomidou.mybatisplus.core.toolkit.Wrappers;
+import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
+import com.fruitshorts.commerce.reward.dal.entity.RewardActivity;
+import com.fruitshorts.commerce.reward.dal.entity.RewardEventLog;
+import com.fruitshorts.commerce.reward.dal.entity.RewardTask;
+import com.fruitshorts.commerce.reward.dal.entity.RewardTaskProgress;
+import com.fruitshorts.commerce.reward.dal.mapper.RewardActivityMapper;
+import com.fruitshorts.commerce.reward.dal.mapper.RewardEventLogMapper;
+import com.fruitshorts.commerce.reward.dal.mapper.RewardTaskMapper;
+import com.fruitshorts.commerce.reward.dal.mapper.RewardTaskProgressMapper;
+import com.fruitshorts.commerce.reward.vo.RewardActivityVO;
+import com.fruitshorts.commerce.reward.vo.RewardOverviewVO;
+import com.fruitshorts.commerce.reward.vo.RewardSectionVO;
+import com.fruitshorts.commerce.reward.vo.RewardTaskItemVO;
+import com.fruitshorts.commerce.reward.vo.RewardTaskQueryReqVO;
+import com.fruitshorts.commerce.reward.vo.RewardTaskRespVO;
+import com.fruitshorts.commerce.reward.vo.RewardTaskSaveReqVO;
+import com.fruitshorts.common.exception.ErrorCode;
+import com.fruitshorts.common.exception.ServiceException;
+import com.fruitshorts.common.pojo.PageResult;
+import lombok.RequiredArgsConstructor;
+import org.springframework.dao.DuplicateKeyException;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+import org.springframework.util.StringUtils;
+
+import java.time.LocalDate;
+import java.time.LocalDateTime;
+import java.time.ZoneId;
+import java.time.temporal.WeekFields;
+import java.util.ArrayList;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+
+/** 奖励任务配置、用户进度与客户端总览。 */
+@Service
+@RequiredArgsConstructor
+public class RewardTaskService {
+
+    public static final String TYPE_DAILY_CHECK_IN = "DAILY_CHECK_IN";
+    public static final String TYPE_WATCH_DURATION = "WATCH_DURATION";
+    public static final String TYPE_WATCH_EPISODES = "WATCH_EPISODES";
+    public static final String TYPE_FIRST_LOGIN = "FIRST_LOGIN";
+    public static final String TYPE_COMPLETE_PROFILE = "COMPLETE_PROFILE";
+    public static final String TYPE_FIRST_PURCHASE = "FIRST_PURCHASE";
+    public static final String STATUS_PROGRESS = "IN_PROGRESS";
+    public static final String STATUS_COMPLETED = "COMPLETED";
+    public static final String STATUS_CLAIMED = "CLAIMED";
+    public static final String CYCLE_ONCE = "ONCE";
+    public static final String CYCLE_DAILY = "DAILY";
+    public static final String CYCLE_WEEKLY = "WEEKLY";
+    public static final ZoneId REWARD_ZONE = ZoneId.of("Asia/Jakarta");
+
+    private final RewardTaskMapper taskMapper;
+    private final RewardTaskProgressMapper progressMapper;
+    private final RewardEventLogMapper eventLogMapper;
+    private final RewardActivityMapper activityMapper;
+
+    /** 后台分页查询任务配置。 */
+    public PageResult<RewardTaskRespVO> page(RewardTaskQueryReqVO req) {
+        Page<RewardTask> page = new Page<>(req.getSafePageIndex(), req.getSafePageSize());
+        IPage<RewardTask> result = taskMapper.selectPage(page, RewardTaskConfiguration.taskQuery(req));
+        return new PageResult<>(result.getTotal(), result.getRecords().stream()
+                .map(RewardTaskRespVO::of).toList());
+    }
+
+    /** 查询任务详情。 */
+    public RewardTaskRespVO detail(Long id) {
+        return RewardTaskRespVO.of(getExisting(id));
+    }
+
+    /** 新建奖励任务，默认下线，避免半配置立即暴露给客户端。 */
+    @Transactional(rollbackFor = Exception.class)
+    public Long create(RewardTaskSaveReqVO req) {
+        RewardTaskConfiguration.validate(req);
+        requireCodeFree(req.getCode().trim(), null);
+        RewardTask task = new RewardTask();
+        task.setCode(req.getCode().trim());
+        RewardTaskConfiguration.apply(task, req);
+        task.setStatus(0);
+        task.setVersion(1);
+        taskMapper.insert(task);
+        return task.getId();
+    }
+
+    /** 编辑奖励任务。已产生进度的任务保留原 id，版本递增。 */
+    @Transactional(rollbackFor = Exception.class)
+    public void update(Long id, RewardTaskSaveReqVO req) {
+        RewardTaskConfiguration.validate(req);
+        RewardTask task = getExisting(id);
+        requireCodeFree(req.getCode().trim(), id);
+        task.setCode(req.getCode().trim());
+        RewardTaskConfiguration.apply(task, req);
+        task.setVersion((task.getVersion() == null ? 0 : task.getVersion()) + 1);
+        taskMapper.updateById(task);
+    }
+
+    /** 上线或下线任务。 */
+    @Transactional(rollbackFor = Exception.class)
+    public void updateStatus(Long id, Integer status) {
+        if (status == null || (status != 0 && status != 1)) {
+            throw new ServiceException(ErrorCode.BAD_REQUEST, "状态只能是 0 或 1");
+        }
+        RewardTask task = getExisting(id);
+        task.setStatus(status);
+        taskMapper.updateById(task);
+    }
+
+    /** 客户端奖励总览。 */
+    public RewardOverviewVO overview(Long userId, String locale, Long coinBalance) {
+        String language = RewardViewAssembler.normalizeLocale(locale);
+        List<RewardTask> tasks = activeTasks();
+        Map<String, List<RewardTaskItemVO>> grouped = new LinkedHashMap<>();
+        for (RewardTask task : tasks) {
+            RewardTaskProgress progress = currentProgress(userId, task);
+            grouped.computeIfAbsent(task.getSectionCode(), key -> new ArrayList<>())
+                    .add(RewardViewAssembler.toItem(task, progress, language));
+        }
+        RewardOverviewVO overview = new RewardOverviewVO();
+        overview.setServerDate(LocalDate.now(REWARD_ZONE).toString());
+        overview.setTimezone(REWARD_ZONE.getId());
+        overview.setCoinBalance(coinBalance);
+        overview.setSections(grouped.entrySet().stream()
+                .map(entry -> new RewardSectionVO(entry.getKey(),
+                        RewardViewAssembler.sectionTitle(tasks, entry.getKey(), language),
+                        entry.getValue())).toList());
+        overview.setActivities(activities(language));
+        return overview;
+    }
+
+    /** 服务端记录已验证事件并推进任务。 */
+    @Transactional(rollbackFor = Exception.class)
+    public void recordEvent(Long userId, String eventType, String sourceId, long eventValue) {
+        if (userId == null || !StringUtils.hasText(eventType) || !StringUtils.hasText(sourceId)) {
+            return;
+        }
+        for (RewardTask task : activeTasks()) {
+            if (!eventType.equals(task.getType())) {
+                continue;
+            }
+            String eventKey = eventKey(task, userId, sourceId);
+            if (!insertEvent(userId, eventType, sourceId, eventValue, eventKey)) {
+                continue;
+            }
+            addProgress(userId, task, Math.max(eventValue, 0L));
+        }
+    }
+
+    /** 记录服务端校验后的观看进度，时长按单集最大值增量累计，完播集数按分集去重。 */
+    @Transactional(rollbackFor = Exception.class)
+    public void recordWatch(Long userId, Long episodeId, Long positionMs, boolean finished) {
+        if (userId == null || episodeId == null) return;
+        for (RewardTask task : activeTasks()) {
+            if (TYPE_WATCH_DURATION.equals(task.getType())) {
+                recordWatchDuration(userId, episodeId, positionMs, task);
+            } else if (TYPE_WATCH_EPISODES.equals(task.getType()) && finished) {
+                recordWatchEpisode(userId, episodeId, task);
+            }
+        }
+    }
+
+    /** 取现有任务实体。 */
+    public RewardTask getExisting(Long id) {
+        RewardTask task = id == null ? null : taskMapper.selectById(id);
+        if (task == null || Integer.valueOf(1).equals(task.getDeleted())) {
+            throw new ServiceException(ErrorCode.DATA_NOT_FOUND, "奖励任务不存在");
+        }
+        return task;
+    }
+
+    /** 取当前周期进度。 */
+    public RewardTaskProgress currentProgress(Long userId, RewardTask task) {
+        return findProgress(userId, task.getId(), cycleKey(task));
+    }
+
+    /** 周期键规则集中管理，保证进度和幂等键一致。 */
+    public String cycleKey(RewardTask task) {
+        LocalDate today = LocalDate.now(REWARD_ZONE);
+        return switch (task.getCycleType()) {
+            case CYCLE_DAILY -> today.toString();
+            case CYCLE_WEEKLY -> today.getYear() + "-W" + today.get(WeekFields.ISO.weekOfWeekBasedYear());
+            default -> CYCLE_ONCE;
+        };
+    }
+
+    private List<RewardTask> activeTasks() {
+        LocalDateTime now = LocalDateTime.now(REWARD_ZONE);
+        return taskMapper.selectList(Wrappers.<RewardTask>lambdaQuery()
+                .eq(RewardTask::getStatus, 1).eq(RewardTask::getDeleted, 0)
+                .and(w -> w.isNull(RewardTask::getStartAt).or().le(RewardTask::getStartAt, now))
+                .and(w -> w.isNull(RewardTask::getEndAt).or().ge(RewardTask::getEndAt, now))
+                .orderByAsc(RewardTask::getSort).orderByAsc(RewardTask::getId));
+    }
+
+    /** 返回当前生效活动卡片。 */
+    public List<RewardActivityVO> activities(String locale) {
+        String language = RewardViewAssembler.normalizeLocale(locale);
+        LocalDateTime now = LocalDateTime.now(REWARD_ZONE);
+        return activityMapper.selectList(Wrappers.<RewardActivity>lambdaQuery()
+                .eq(RewardActivity::getStatus, 1).eq(RewardActivity::getDeleted, 0)
+                .and(w -> w.isNull(RewardActivity::getStartAt).or().le(RewardActivity::getStartAt, now))
+                .and(w -> w.isNull(RewardActivity::getEndAt).or().ge(RewardActivity::getEndAt, now))
+                .orderByAsc(RewardActivity::getSort)).stream()
+                .map(row -> RewardViewAssembler.toActivity(row, language)).toList();
+    }
+
+    private RewardTaskProgress findProgress(Long userId, Long taskId, String cycleKey) {
+        if (userId == null) {
+            return null;
+        }
+        return progressMapper.selectOne(Wrappers.<RewardTaskProgress>lambdaQuery()
+                .eq(RewardTaskProgress::getUserId, userId).eq(RewardTaskProgress::getTaskId, taskId)
+                .eq(RewardTaskProgress::getCycleKey, cycleKey).last("limit 1"));
+    }
+
+    private RewardTaskProgress newProgress(Long userId, RewardTask task, String cycleKey) {
+        RewardTaskProgress progress = new RewardTaskProgress();
+        progress.setUserId(userId);
+        progress.setTaskId(task.getId());
+        progress.setCycleKey(cycleKey);
+        progress.setProgressValue(0L);
+        progress.setTargetValue(task.getTargetValue());
+        progress.setStatus(STATUS_PROGRESS);
+        progress.setClaimSeq(0);
+        return progress;
+    }
+
+    private boolean insertEvent(Long userId, String eventType, String sourceId, long value, String key) {
+        RewardEventLog event = new RewardEventLog();
+        event.setUserId(userId);
+        event.setEventType(eventType);
+        event.setSourceId(sourceId);
+        event.setEventValue(value);
+        event.setIdempotentKey(key);
+        try {
+            eventLogMapper.insert(event);
+            return true;
+        } catch (DuplicateKeyException ex) {
+            return false;
+        }
+    }
+
+    private void recordWatchDuration(Long userId, Long episodeId, Long positionMs, RewardTask task) {
+        long seconds = Math.max(positionMs == null ? 0L : positionMs / 1000L, 0L);
+        String key = eventKey(task, userId, episodeId.toString());
+        RewardEventLog event = eventLogMapper.selectOne(Wrappers.<RewardEventLog>lambdaQuery()
+                .eq(RewardEventLog::getIdempotentKey, key).last("limit 1"));
+        long previous = event == null || event.getEventValue() == null ? 0L : event.getEventValue();
+        if (seconds <= previous) return;
+        if (event == null) {
+            event = new RewardEventLog();
+            event.setUserId(userId);
+            event.setEventType(TYPE_WATCH_DURATION);
+            event.setSourceId(episodeId.toString());
+            event.setEventValue(seconds);
+            event.setIdempotentKey(key);
+            eventLogMapper.insert(event);
+        } else {
+            event.setEventValue(seconds);
+            eventLogMapper.updateById(event);
+        }
+        addProgress(userId, task, seconds - previous);
+    }
+
+    private void recordWatchEpisode(Long userId, Long episodeId, RewardTask task) {
+        String key = eventKey(task, userId, episodeId.toString());
+        if (insertEvent(userId, TYPE_WATCH_EPISODES, episodeId.toString(), 1L, key)) {
+            addProgress(userId, task, 1L);
+        }
+    }
+
+    private void addProgress(Long userId, RewardTask task, long delta) {
+        if (delta <= 0) return;
+        String cycleKey = cycleKey(task);
+        RewardTaskProgress progress = findProgress(userId, task.getId(), cycleKey);
+        if (progress == null) {
+            progress = newProgress(userId, task, cycleKey);
+            progressMapper.insert(progress);
+        }
+        long next = progress.getProgressValue() + delta;
+        progress.setProgressValue(Math.min(next, task.getTargetValue()));
+        progress.setLastEventAt(LocalDateTime.now());
+        if (progress.getProgressValue() >= task.getTargetValue()) {
+            progress.setStatus(STATUS_COMPLETED);
+            progress.setCompletedAt(LocalDateTime.now());
+        }
+        progressMapper.updateById(progress);
+    }
+
+    private String eventKey(RewardTask task, Long userId, String sourceId) {
+        return "reward-event:" + task.getCode() + ":" + userId + ":" + cycleKey(task) + ":" + sourceId;
+    }
+
+    private void requireCodeFree(String code, Long excludeId) {
+        Long count = taskMapper.selectCount(Wrappers.<RewardTask>lambdaQuery().eq(RewardTask::getCode, code)
+                .eq(RewardTask::getDeleted, 0).ne(excludeId != null, RewardTask::getId, excludeId));
+        if (count != null && count > 0) throw new ServiceException(ErrorCode.DATA_EXISTS, "任务编码已存在：" + code);
+    }
+
+}
@@ -0,0 +1,79 @@
+// Author: fruit.com.cn
+
+package com.fruitshorts.commerce.reward.service;
+
+import com.fruitshorts.commerce.reward.dal.entity.RewardActivity;
+import com.fruitshorts.commerce.reward.dal.entity.RewardTask;
+import com.fruitshorts.commerce.reward.dal.entity.RewardTaskProgress;
+import com.fruitshorts.commerce.reward.vo.RewardActivityVO;
+import com.fruitshorts.commerce.reward.vo.RewardTaskItemVO;
+import org.springframework.util.StringUtils;
+
+import java.util.List;
+import java.util.Locale;
+
+/** 奖励中心多语言展示模型组装器。 */
+final class RewardViewAssembler {
+
+    private RewardViewAssembler() {
+    }
+
+    static RewardTaskItemVO toItem(RewardTask task, RewardTaskProgress progress, String locale) {
+        RewardTaskItemVO item = new RewardTaskItemVO();
+        item.setId(task.getId());
+        item.setCode(task.getCode());
+        item.setType(task.getType());
+        item.setTitle(text(task.getTitleId(), task.getTitleEn(), task.getTitleZh(), locale));
+        item.setSubtitle(text(task.getSubtitleId(), task.getSubtitleEn(), task.getSubtitleZh(), locale));
+        item.setCtaText(text(task.getCtaId(), task.getCtaEn(), task.getCtaZh(), locale));
+        item.setIconUrl(task.getIconUrl());
+        item.setActionType(task.getActionType());
+        item.setActionUrl(task.getActionUrl());
+        item.setTargetValue(task.getTargetValue());
+        item.setRewardCoin(task.getRewardCoin());
+        item.setProgressValue(progress == null ? 0L : progress.getProgressValue());
+        item.setStatus(progress == null ? RewardTaskService.STATUS_PROGRESS : progress.getStatus());
+        return item;
+    }
+
+    static RewardActivityVO toActivity(RewardActivity row, String locale) {
+        RewardActivityVO vo = new RewardActivityVO();
+        vo.setId(row.getId());
+        vo.setCode(row.getCode());
+        vo.setCoverUrl(row.getCoverUrl());
+        vo.setTitle(text(row.getTitleId(), row.getTitleEn(), row.getTitleZh(), locale));
+        vo.setSummary(text(row.getSummaryId(), row.getSummaryEn(), row.getSummaryZh(), locale));
+        vo.setCtaText(text(row.getCtaId(), row.getCtaEn(), row.getCtaZh(), locale));
+        vo.setActionType(row.getActionType());
+        vo.setActionUrl(row.getActionUrl());
+        return vo;
+    }
+
+    static String sectionTitle(List<RewardTask> tasks, String code, String locale) {
+        return tasks.stream().filter(task -> code.equals(task.getSectionCode())).findFirst()
+                .map(task -> text(task.getSectionTitleId(), task.getSectionTitleEn(),
+                        task.getSectionTitleZh(), locale))
+                .orElse(code);
+    }
+
+    static String normalizeLocale(String locale) {
+        if (!StringUtils.hasText(locale)) {
+            return "id";
+        }
+        String normalized = locale.trim().toLowerCase(Locale.ROOT);
+        if (normalized.startsWith("zh")) {
+            return "zh";
+        }
+        return normalized.startsWith("en") ? "en" : "id";
+    }
+
+    private static String text(String id, String en, String zh, String locale) {
+        if ("zh".equals(locale) && StringUtils.hasText(zh)) {
+            return zh;
+        }
+        if ("en".equals(locale) && StringUtils.hasText(en)) {
+            return en;
+        }
+        return StringUtils.hasText(id) ? id : (StringUtils.hasText(en) ? en : zh);
+    }
+}
@@ -0,0 +1,30 @@
+// Author: fruit.com.cn
+
+package com.fruitshorts.commerce.reward.service;
+
+import com.fruitshorts.commerce.dal.entity.CoinLedger;
+import com.fruitshorts.commerce.dal.entity.Wallet;
+import com.fruitshorts.commerce.service.WalletService;
+import lombok.RequiredArgsConstructor;
+import org.springframework.stereotype.Component;
+
+/** 奖励域对钱包能力的最小适配，避免奖励服务泄露钱包实现细节。 */
+@Component
+@RequiredArgsConstructor
+public class WalletServiceFacade {
+
+    private final WalletService walletService;
+
+    /** 以 REWARD 类型写入金币流水。 */
+    public CoinLedger change(Long userId, long amount, String idempotentKey,
+                             String source, Long operatorId) {
+        return walletService.change(userId, amount, WalletService.BIZ_REWARD,
+                idempotentKey, idempotentKey, "奖励发放：" + source, false, operatorId);
+    }
+
+    /** 查询当前钱包余额。 */
+    public Long balance(Long userId) {
+        Wallet wallet = walletService.getOrCreate(userId);
+        return wallet.getCoinBalance();
+    }
+}
@@ -0,0 +1,16 @@
+// Author: fruit.com.cn
+
+package com.fruitshorts.commerce.reward.vo;
+
+import com.fruitshorts.common.pojo.PageParam;
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+
+/** 后台奖励活动分页条件。 */
+@Data
+@EqualsAndHashCode(callSuper = true)
+public class RewardActivityQueryReqVO extends PageParam {
+
+    private String keyword;
+    private Integer status;
+}
@@ -0,0 +1,62 @@
+// Author: fruit.com.cn
+
+package com.fruitshorts.commerce.reward.vo;
+
+import com.fruitshorts.commerce.reward.dal.entity.RewardActivity;
+import lombok.Data;
+
+import java.time.LocalDateTime;
+
+/** 后台奖励活动响应。 */
+@Data
+public class RewardActivityRespVO {
+
+    private Long id;
+    private String code;
+    private String coverUrl;
+    private String actionType;
+    private String actionUrl;
+    private String titleId;
+    private String titleEn;
+    private String titleZh;
+    private String summaryId;
+    private String summaryEn;
+    private String summaryZh;
+    private String ctaId;
+    private String ctaEn;
+    private String ctaZh;
+    private Integer sort;
+    private Integer status;
+    private String statusText;
+    private LocalDateTime startAt;
+    private LocalDateTime endAt;
+    private LocalDateTime createdAt;
+    private LocalDateTime updatedAt;
+
+    /** 将活动实体转换为后台展示模型。 */
+    public static RewardActivityRespVO of(RewardActivity activity) {
+        RewardActivityRespVO vo = new RewardActivityRespVO();
+        vo.id = activity.getId();
+        vo.code = activity.getCode();
+        vo.coverUrl = activity.getCoverUrl();
+        vo.actionType = activity.getActionType();
+        vo.actionUrl = activity.getActionUrl();
+        vo.titleId = activity.getTitleId();
+        vo.titleEn = activity.getTitleEn();
+        vo.titleZh = activity.getTitleZh();
+        vo.summaryId = activity.getSummaryId();
+        vo.summaryEn = activity.getSummaryEn();
+        vo.summaryZh = activity.getSummaryZh();
+        vo.ctaId = activity.getCtaId();
+        vo.ctaEn = activity.getCtaEn();
+        vo.ctaZh = activity.getCtaZh();
+        vo.sort = activity.getSort();
+        vo.status = activity.getStatus();
+        vo.statusText = activity.getStatus() != null && activity.getStatus() == 1 ? "已上线" : "已下线";
+        vo.startAt = activity.getStartAt();
+        vo.endAt = activity.getEndAt();
+        vo.createdAt = activity.getCreatedAt();
+        vo.updatedAt = activity.getUpdatedAt();
+        return vo;
+    }
+}
@@ -0,0 +1,36 @@
+// Author: fruit.com.cn
+
+package com.fruitshorts.commerce.reward.vo;
+
+import jakarta.validation.constraints.NotBlank;
+import jakarta.validation.constraints.Size;
+import lombok.Data;
+
+import java.time.LocalDateTime;
+
+/** 后台奖励活动新增和编辑参数。 */
+@Data
+public class RewardActivitySaveReqVO {
+
+    @NotBlank(message = "请填写活动编码")
+    @Size(max = 64, message = "活动编码过长")
+    private String code;
+    @Size(max = 512, message = "封面地址过长")
+    private String coverUrl;
+    private String actionType;
+    @Size(max = 512, message = "跳转地址过长")
+    private String actionUrl;
+    @NotBlank(message = "请填写印尼语标题")
+    private String titleId;
+    private String titleEn;
+    private String titleZh;
+    private String summaryId;
+    private String summaryEn;
+    private String summaryZh;
+    private String ctaId;
+    private String ctaEn;
+    private String ctaZh;
+    private Integer sort;
+    private LocalDateTime startAt;
+    private LocalDateTime endAt;
+}
@@ -0,0 +1,19 @@
+// Author: fruit.com.cn
+
+package com.fruitshorts.commerce.reward.vo;
+
+import lombok.Data;
+
+/** 客户端奖励活动卡片。 */
+@Data
+public class RewardActivityVO {
+
+    private Long id;
+    private String code;
+    private String coverUrl;
+    private String title;
+    private String summary;
+    private String ctaText;
+    private String actionType;
+    private String actionUrl;
+}
@@ -0,0 +1,18 @@
+// Author: fruit.com.cn
+
+package com.fruitshorts.commerce.reward.vo;
+
+import lombok.Data;
+
+/** 客户端签到结果。 */
+@Data
+public class RewardCheckinRespVO {
+
+    private Long taskId;
+    private Long grantId;
+    private Integer dayIndex;
+    private Integer streak;
+    private Long rewardCoin;
+    private Long coinBalance;
+    private Boolean alreadyCheckedIn;
+}
@@ -0,0 +1,19 @@
+// Author: fruit.com.cn
+
+package com.fruitshorts.commerce.reward.vo;
+
+import jakarta.validation.constraints.Min;
+import jakarta.validation.constraints.NotNull;
+import lombok.Data;
+
+/** 后台签到单日奖励参数。 */
+@Data
+public class RewardCheckinRuleDayReqVO {
+
+    @NotNull(message = "请填写签到天数")
+    @Min(value = 1, message = "签到天数必须大于 0")
+    private Integer dayIndex;
+    @NotNull(message = "请填写签到奖励")
+    @Min(value = 0, message = "签到奖励不能小于 0")
+    private Long rewardCoin;
+}
@@ -0,0 +1,18 @@
+// Author: fruit.com.cn
+
+package com.fruitshorts.commerce.reward.vo;
+
+import jakarta.validation.Valid;
+import jakarta.validation.constraints.NotEmpty;
+import lombok.Data;
+
+import java.util.List;
+
+/** 后台保存签到周期奖励。 */
+@Data
+public class RewardCheckinRuleSaveReqVO {
+
+    @Valid
+    @NotEmpty(message = "签到规则不能为空")
+    private List<RewardCheckinRuleDayReqVO> days;
+}
@@ -0,0 +1,18 @@
+// Author: fruit.com.cn
+
+package com.fruitshorts.commerce.reward.vo;
+
+import lombok.Data;
+
+import java.util.List;
+
+/** 客户端签到卡片状态。 */
+@Data
+public class RewardCheckinVO {
+
+    private Long taskId;
+    private Boolean checkedInToday;
+    private Integer streak;
+    private Integer currentDay;
+    private List<RewardRuleDayVO> days;
+}
@@ -0,0 +1,16 @@
+// Author: fruit.com.cn
+
+package com.fruitshorts.commerce.reward.vo;
+
+import lombok.Data;
+
+/** 客户端领取任务奖励结果。 */
+@Data
+public class RewardClaimRespVO {
+
+    private Long taskId;
+    private Long grantId;
+    private Long rewardCoin;
+    private Long coinBalance;
+    private Boolean alreadyGranted;
+}
@@ -0,0 +1,18 @@
+// Author: fruit.com.cn
+
+package com.fruitshorts.commerce.reward.vo;
+
+import com.fruitshorts.common.pojo.PageParam;
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+
+/** 后台奖励发放记录分页条件。 */
+@Data
+@EqualsAndHashCode(callSuper = true)
+public class RewardGrantQueryReqVO extends PageParam {
+
+    private Long userId;
+    private Long taskId;
+    private String status;
+    private String source;
+}
@@ -0,0 +1,48 @@
+// Author: fruit.com.cn
+
+package com.fruitshorts.commerce.reward.vo;
+
+import com.fruitshorts.commerce.reward.dal.entity.RewardGrant;
+import lombok.Data;
+
+import java.time.LocalDateTime;
+
+/** 奖励发放记录响应。 */
+@Data
+public class RewardGrantRespVO {
+
+    private Long id;
+    private Long userId;
+    private Long taskId;
+    private String cycleKey;
+    private Integer claimSeq;
+    private Long amount;
+    private String status;
+    private String idempotentKey;
+    private Long coinLedgerId;
+    private String source;
+    private Long operatorId;
+    private String failureReason;
+    private LocalDateTime grantedAt;
+    private LocalDateTime createdAt;
+
+    /** 将发放实体转换为后台响应。 */
+    public static RewardGrantRespVO of(RewardGrant grant) {
+        RewardGrantRespVO vo = new RewardGrantRespVO();
+        vo.id = grant.getId();
+        vo.userId = grant.getUserId();
+        vo.taskId = grant.getTaskId();
+        vo.cycleKey = grant.getCycleKey();
+        vo.claimSeq = grant.getClaimSeq();
+        vo.amount = grant.getAmount();
+        vo.status = grant.getStatus();
+        vo.idempotentKey = grant.getIdempotentKey();
+        vo.coinLedgerId = grant.getCoinLedgerId();
+        vo.source = grant.getSource();
+        vo.operatorId = grant.getOperatorId();
+        vo.failureReason = grant.getFailureReason();
+        vo.grantedAt = grant.getGrantedAt();
+        vo.createdAt = grant.getCreatedAt();
+        return vo;
+    }
+}
@@ -0,0 +1,24 @@
+// Author: fruit.com.cn
+
+package com.fruitshorts.commerce.reward.vo;
+
+import jakarta.validation.constraints.Min;
+import jakarta.validation.constraints.NotNull;
+import jakarta.validation.constraints.Size;
+import lombok.Data;
+
+/** 后台人工补发奖励参数。 */
+@Data
+public class RewardManualGrantReqVO {
+
+    @NotNull(message = "请填写用户 ID")
+    private Long userId;
+    private Long taskId;
+    @NotNull(message = "请填写补发金币")
+    @Min(value = 1, message = "补发金币必须大于 0")
+    private Long amount;
+    @Size(max = 64, message = "幂等键过长")
+    private String idempotentKey;
+    @Size(max = 255, message = "补发原因过长")
+    private String reason;
+}
@@ -0,0 +1,19 @@
+// Author: fruit.com.cn
+
+package com.fruitshorts.commerce.reward.vo;
+
+import lombok.Data;
+
+import java.util.List;
+
+/** 客户端奖励中心总览。 */
+@Data
+public class RewardOverviewVO {
+
+    private String serverDate;
+    private String timezone;
+    private Long coinBalance;
+    private RewardCheckinVO checkin;
+    private List<RewardSectionVO> sections;
+    private List<RewardActivityVO> activities;
+}
@@ -0,0 +1,19 @@
+// Author: fruit.com.cn
+
+package com.fruitshorts.commerce.reward.vo;
+
+import lombok.AllArgsConstructor;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+/** 签到周期某一天的配置与展示状态。 */
+@Data
+@NoArgsConstructor
+@AllArgsConstructor
+public class RewardRuleDayVO {
+
+    private Integer dayIndex;
+    private Long rewardCoin;
+    private Boolean checked;
+    private Boolean current;
+}
@@ -0,0 +1,20 @@
+// Author: fruit.com.cn
+
+package com.fruitshorts.commerce.reward.vo;
+
+import lombok.AllArgsConstructor;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+import java.util.List;
+
+/** 客户端奖励任务分组。 */
+@Data
+@NoArgsConstructor
+@AllArgsConstructor
+public class RewardSectionVO {
+
+    private String code;
+    private String title;
+    private List<RewardTaskItemVO> tasks;
+}
@@ -0,0 +1,24 @@
+// Author: fruit.com.cn
+
+package com.fruitshorts.commerce.reward.vo;
+
+import lombok.Data;
+
+/** 客户端奖励任务卡片。 */
+@Data
+public class RewardTaskItemVO {
+
+    private Long id;
+    private String code;
+    private String type;
+    private String title;
+    private String subtitle;
+    private String ctaText;
+    private String iconUrl;
+    private String actionType;
+    private String actionUrl;
+    private Long progressValue;
+    private Long targetValue;
+    private Long rewardCoin;
+    private String status;
+}
@@ -0,0 +1,18 @@
+// Author: fruit.com.cn
+
+package com.fruitshorts.commerce.reward.vo;
+
+import com.fruitshorts.common.pojo.PageParam;
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+
+/** 后台奖励任务分页条件。 */
+@Data
+@EqualsAndHashCode(callSuper = true)
+public class RewardTaskQueryReqVO extends PageParam {
+
+    private String keyword;
+    private String type;
+    private String sectionCode;
+    private Integer status;
+}
@@ -0,0 +1,90 @@
+// Author: fruit.com.cn
+
+package com.fruitshorts.commerce.reward.vo;
+
+import com.fruitshorts.commerce.reward.dal.entity.RewardTask;
+import lombok.Data;
+
+import java.time.LocalDateTime;
+
+/** 后台奖励任务响应。 */
+@Data
+public class RewardTaskRespVO {
+
+    private Long id;
+    private String code;
+    private String sectionCode;
+    private String type;
+    private String verifyMode;
+    private Long targetValue;
+    private Long rewardCoin;
+    private String cycleType;
+    private Integer cycleLimit;
+    private String actionType;
+    private String actionUrl;
+    private String iconUrl;
+    private String titleId;
+    private String titleEn;
+    private String titleZh;
+    private String subtitleId;
+    private String subtitleEn;
+    private String subtitleZh;
+    private String ctaId;
+    private String ctaEn;
+    private String ctaZh;
+    private String sectionTitleId;
+    private String sectionTitleEn;
+    private String sectionTitleZh;
+    private String configJson;
+    private Integer sort;
+    private Integer status;
+    private String statusText;
+    private LocalDateTime startAt;
+    private LocalDateTime endAt;
+    private Integer version;
+    private LocalDateTime createdAt;
+    private LocalDateTime updatedAt;
+
+    /** 将任务实体转换为后台展示模型。 */
+    public static RewardTaskRespVO of(RewardTask task) {
+        RewardTaskRespVO vo = new RewardTaskRespVO();
+        vo.id = task.getId();
+        vo.code = task.getCode();
+        vo.sectionCode = task.getSectionCode();
+        vo.type = task.getType();
+        vo.verifyMode = task.getVerifyMode();
+        vo.targetValue = task.getTargetValue();
+        vo.rewardCoin = task.getRewardCoin();
+        vo.cycleType = task.getCycleType();
+        vo.cycleLimit = task.getCycleLimit();
+        vo.actionType = task.getActionType();
+        vo.actionUrl = task.getActionUrl();
+        vo.iconUrl = task.getIconUrl();
+        vo.copyTexts(task);
+        vo.configJson = task.getConfigJson();
+        vo.sort = task.getSort();
+        vo.status = task.getStatus();
+        vo.statusText = task.getStatus() != null && task.getStatus() == 1 ? "已上线" : "已下线";
+        vo.startAt = task.getStartAt();
+        vo.endAt = task.getEndAt();
+        vo.version = task.getVersion();
+        vo.createdAt = task.getCreatedAt();
+        vo.updatedAt = task.getUpdatedAt();
+        return vo;
+    }
+
+    private void copyTexts(RewardTask task) {
+        titleId = task.getTitleId();
+        titleEn = task.getTitleEn();
+        titleZh = task.getTitleZh();
+        subtitleId = task.getSubtitleId();
+        subtitleEn = task.getSubtitleEn();
+        subtitleZh = task.getSubtitleZh();
+        ctaId = task.getCtaId();
+        ctaEn = task.getCtaEn();
+        ctaZh = task.getCtaZh();
+        sectionTitleId = task.getSectionTitleId();
+        sectionTitleEn = task.getSectionTitleEn();
+        sectionTitleZh = task.getSectionTitleZh();
+    }
+}
@@ -0,0 +1,56 @@
+// Author: fruit.com.cn
+
+package com.fruitshorts.commerce.reward.vo;
+
+import jakarta.validation.constraints.Min;
+import jakarta.validation.constraints.NotBlank;
+import jakarta.validation.constraints.NotNull;
+import jakarta.validation.constraints.Size;
+import lombok.Data;
+
+import java.time.LocalDateTime;
+
+/** 后台奖励任务新增和编辑参数。 */
+@Data
+public class RewardTaskSaveReqVO {
+
+    @NotBlank(message = "请填写任务编码")
+    @Size(max = 64, message = "任务编码过长")
+    private String code;
+    @NotBlank(message = "请选择任务分组")
+    private String sectionCode;
+    @NotBlank(message = "请选择任务类型")
+    private String type;
+    private String verifyMode;
+    @NotNull(message = "请填写目标值")
+    @Min(value = 1, message = "目标值必须大于 0")
+    private Long targetValue;
+    @NotNull(message = "请填写奖励金币")
+    @Min(value = 0, message = "奖励金币不能小于 0")
+    private Long rewardCoin;
+    @NotBlank(message = "请选择任务周期")
+    private String cycleType;
+    @Min(value = 1, message = "周期领取上限必须大于 0")
+    private Integer cycleLimit;
+    private String actionType;
+    private String actionUrl;
+    private String iconUrl;
+    @NotBlank(message = "请填写印尼语标题")
+    private String titleId;
+    private String titleEn;
+    private String titleZh;
+    private String subtitleId;
+    private String subtitleEn;
+    private String subtitleZh;
+    private String ctaId;
+    private String ctaEn;
+    private String ctaZh;
+    @NotBlank(message = "请填写印尼语分组标题")
+    private String sectionTitleId;
+    private String sectionTitleEn;
+    private String sectionTitleZh;
+    private String configJson;
+    private Integer sort;
+    private LocalDateTime startAt;
+    private LocalDateTime endAt;
+}
@@ -33,6 +33,7 @@ public class WalletService {
    public static final String BIZ_UNLOCK = "UNLOCK";
    public static final String BIZ_REFUND = "REFUND";
    public static final String BIZ_ADMIN = "ADMIN";
+    public static final String BIZ_REWARD = "REWARD";

    private final WalletMapper walletMapper;
    private final CoinLedgerMapper ledgerMapper;
@@ -0,0 +1,102 @@
+// Author: fruit.com.cn
+
+package com.fruitshorts.commerce.reward.service;
+
+import com.baomidou.mybatisplus.core.MybatisConfiguration;
+import com.baomidou.mybatisplus.core.metadata.TableInfoHelper;
+import com.fruitshorts.commerce.reward.dal.entity.RewardActivity;
+import com.fruitshorts.commerce.reward.dal.mapper.RewardActivityMapper;
+import com.fruitshorts.commerce.reward.vo.RewardActivitySaveReqVO;
+import com.fruitshorts.common.exception.ErrorCode;
+import com.fruitshorts.common.exception.ServiceException;
+import org.apache.ibatis.builder.MapperBuilderAssistant;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+import java.util.concurrent.atomic.AtomicReference;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.BDDMockito.given;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.verify;
+
+/** 奖励活动后台配置服务测试。 */
+class RewardActivityAdminServiceTest {
+
+    private RewardActivityMapper activityMapper;
+    private RewardActivityAdminService service;
+
+    @BeforeAll
+    static void initTableInfo() {
+        TableInfoHelper.initTableInfo(
+                new MapperBuilderAssistant(new MybatisConfiguration(), ""), RewardActivity.class);
+    }
+
+    @BeforeEach
+    void setUp() {
+        activityMapper = mock(RewardActivityMapper.class);
+        service = new RewardActivityAdminService(activityMapper);
+    }
+
+    @Test
+    void should_create_activity_offline_when_status_is_missing() {
+        given(activityMapper.selectCount(any())).willReturn(0L);
+        AtomicReference<RewardActivity> saved = captureInsert();
+
+        service.create(activity("spring_event"));
+
+        assertThat(saved.get().getCode()).isEqualTo("spring_event");
+        assertThat(saved.get().getStatus()).isZero();
+    }
+
+    @Test
+    void should_reject_when_activity_code_already_exists() {
+        given(activityMapper.selectCount(any())).willReturn(1L);
+
+        assertThatThrownBy(() -> service.create(activity("spring_event")))
+                .isInstanceOf(ServiceException.class)
+                .satisfies(ex -> assertThat(((ServiceException) ex).getCode())
+                        .isEqualTo(ErrorCode.DATA_EXISTS.getCode()))
+                .hasMessageContaining("活动编码已存在");
+        verify(activityMapper, never()).insert(any(RewardActivity.class));
+    }
+
+    @Test
+    void should_update_status_when_status_is_valid() {
+        RewardActivity existing = new RewardActivity();
+        existing.setId(9L);
+        existing.setDeleted(0);
+        given(activityMapper.selectById(9L)).willReturn(existing);
+
+        service.updateStatus(9L, 1);
+
+        assertThat(existing.getStatus()).isOne();
+        verify(activityMapper).updateById(existing);
+    }
+
+    private AtomicReference<RewardActivity> captureInsert() {
+        AtomicReference<RewardActivity> saved = new AtomicReference<>();
+        given(activityMapper.insert(any(RewardActivity.class))).willAnswer(invocation -> {
+            RewardActivity activity = invocation.getArgument(0);
+            activity.setId(9L);
+            saved.set(activity);
+            return 1;
+        });
+        return saved;
+    }
+
+    private RewardActivitySaveReqVO activity(String code) {
+        RewardActivitySaveReqVO req = new RewardActivitySaveReqVO();
+        req.setCode(code);
+        req.setTitleId("Acara musim semi");
+        req.setTitleEn("Spring event");
+        req.setTitleZh("春季活动");
+        req.setSummaryId("Dapatkan koin tambahan");
+        req.setActionType("OPEN_HOME");
+        return req;
+    }
+}
@@ -0,0 +1,131 @@
+// Author: fruit.com.cn
+
+package com.fruitshorts.commerce.reward.service;
+
+import com.baomidou.mybatisplus.core.MybatisConfiguration;
+import com.baomidou.mybatisplus.core.metadata.TableInfoHelper;
+import com.fruitshorts.commerce.reward.dal.entity.RewardCheckinRecord;
+import com.fruitshorts.commerce.reward.dal.entity.RewardCheckinRuleDay;
+import com.fruitshorts.commerce.reward.dal.entity.RewardGrant;
+import com.fruitshorts.commerce.reward.dal.entity.RewardTask;
+import com.fruitshorts.commerce.reward.dal.mapper.RewardCheckinRecordMapper;
+import com.fruitshorts.commerce.reward.dal.mapper.RewardCheckinRuleDayMapper;
+import com.fruitshorts.commerce.reward.dal.mapper.RewardTaskMapper;
+import org.apache.ibatis.builder.MapperBuilderAssistant;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+import java.time.LocalDate;
+import java.util.List;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.BDDMockito.given;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.verify;
+
+/** 每日签到幂等测试。 */
+class RewardCheckinServiceTest {
+
+    private RewardTaskMapper taskMapper;
+    private RewardCheckinRuleDayMapper ruleMapper;
+    private RewardCheckinRecordMapper recordMapper;
+    private RewardGrantService grantService;
+    private RewardCheckinService service;
+
+    @BeforeAll
+    static void initTableInfo() {
+        MapperBuilderAssistant assistant = new MapperBuilderAssistant(new MybatisConfiguration(), "");
+        TableInfoHelper.initTableInfo(assistant, RewardTask.class);
+        TableInfoHelper.initTableInfo(assistant, RewardCheckinRecord.class);
+        TableInfoHelper.initTableInfo(assistant, RewardCheckinRuleDay.class);
+    }
+
+    @BeforeEach
+    void setUp() {
+        taskMapper = mock(RewardTaskMapper.class);
+        ruleMapper = mock(RewardCheckinRuleDayMapper.class);
+        recordMapper = mock(RewardCheckinRecordMapper.class);
+        grantService = mock(RewardGrantService.class);
+        service = new RewardCheckinService(taskMapper, ruleMapper, recordMapper, grantService);
+        given(taskMapper.selectOne(any())).willReturn(task());
+        given(grantService.balance(7L)).willReturn(135L);
+    }
+
+    @Test
+    void should_return_existing_result_when_user_checks_in_twice() {
+        RewardCheckinRecord existing = record();
+        given(recordMapper.selectOne(any())).willReturn(existing);
+
+        var result = service.checkIn(7L);
+
+        assertThat(result.getAlreadyCheckedIn()).isTrue();
+        assertThat(result.getCoinBalance()).isEqualTo(135L);
+        verify(grantService, never()).grant(any(), any(), any(), any(), any(), any(), any());
+    }
+
+    @Test
+    void should_grant_configured_coins_when_first_check_in_today() {
+        given(recordMapper.selectOne(any())).willReturn(null);
+        RewardCheckinRuleDay day = new RewardCheckinRuleDay();
+        day.setDayIndex(1);
+        day.setRewardCoin(35L);
+        given(ruleMapper.selectList(any())).willReturn(List.of(day));
+        RewardGrant grant = new RewardGrant();
+        grant.setId(91L);
+        given(grantService.grant(any(), any(), any(), any(), any(), any(), any())).willReturn(grant);
+
+        var result = service.checkIn(7L);
+
+        assertThat(result.getAlreadyCheckedIn()).isFalse();
+        assertThat(result.getRewardCoin()).isEqualTo(35L);
+        verify(recordMapper).insert(any(RewardCheckinRecord.class));
+    }
+
+    @Test
+    void should_return_rule_defaults_without_reading_user_records_when_anonymous() {
+        RewardCheckinRuleDay first = new RewardCheckinRuleDay();
+        first.setDayIndex(1);
+        first.setRewardCoin(35L);
+        RewardCheckinRuleDay second = new RewardCheckinRuleDay();
+        second.setDayIndex(2);
+        second.setRewardCoin(50L);
+        given(ruleMapper.selectList(any())).willReturn(List.of(first, second));
+
+        var result = service.status(null);
+
+        assertThat(result.getCheckedInToday()).isFalse();
+        assertThat(result.getStreak()).isZero();
+        assertThat(result.getCurrentDay()).isEqualTo(1);
+        assertThat(result.getDays()).hasSize(2);
+        assertThat(result.getDays().get(0).getCurrent()).isTrue();
+        assertThat(result.getDays().get(1).getChecked()).isFalse();
+        verify(recordMapper, never()).selectOne(any());
+        verify(recordMapper, never()).selectCount(any());
+    }
+
+    private RewardTask task() {
+        RewardTask task = new RewardTask();
+        task.setId(3L);
+        task.setCode("daily_check_in");
+        task.setType(RewardTaskService.TYPE_DAILY_CHECK_IN);
+        task.setStatus(1);
+        task.setDeleted(0);
+        return task;
+    }
+
+    private RewardCheckinRecord record() {
+        RewardCheckinRecord record = new RewardCheckinRecord();
+        record.setId(6L);
+        record.setUserId(7L);
+        record.setTaskId(3L);
+        record.setCheckinDate(LocalDate.now(RewardTaskService.REWARD_ZONE));
+        record.setDayIndex(1);
+        record.setStreak(1);
+        record.setRewardCoin(35L);
+        record.setGrantId(9L);
+        return record;
+    }
+}
@@ -0,0 +1,93 @@
+// Author: fruit.com.cn
+
+package com.fruitshorts.commerce.reward.service;
+
+import com.baomidou.mybatisplus.core.MybatisConfiguration;
+import com.baomidou.mybatisplus.core.metadata.TableInfoHelper;
+import com.fruitshorts.commerce.dal.entity.CoinLedger;
+import com.fruitshorts.commerce.reward.dal.entity.RewardGrant;
+import com.fruitshorts.commerce.reward.dal.entity.RewardTask;
+import com.fruitshorts.commerce.reward.dal.entity.RewardTaskProgress;
+import com.fruitshorts.commerce.reward.dal.mapper.RewardGrantMapper;
+import com.fruitshorts.commerce.reward.dal.mapper.RewardTaskProgressMapper;
+import org.apache.ibatis.builder.MapperBuilderAssistant;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+import java.util.concurrent.atomic.AtomicReference;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.BDDMockito.given;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+
+/** 奖励领取幂等与钱包入账测试。 */
+class RewardGrantServiceTest {
+
+    private RewardGrantMapper grantMapper;
+    private RewardTaskProgressMapper progressMapper;
+    private WalletServiceFacade wallet;
+    private RewardGrantService service;
+
+    @BeforeAll
+    static void initTableInfo() {
+        MapperBuilderAssistant assistant = new MapperBuilderAssistant(new MybatisConfiguration(), "");
+        TableInfoHelper.initTableInfo(assistant, RewardGrant.class);
+        TableInfoHelper.initTableInfo(assistant, RewardTaskProgress.class);
+    }
+
+    @BeforeEach
+    void setUp() {
+        grantMapper = mock(RewardGrantMapper.class);
+        progressMapper = mock(RewardTaskProgressMapper.class);
+        wallet = mock(WalletServiceFacade.class);
+        service = new RewardGrantService(grantMapper, progressMapper, wallet);
+    }
+
+    @Test
+    void should_grant_once_when_claim_is_repeated() {
+        AtomicReference<RewardGrant> stored = new AtomicReference<>();
+        given(grantMapper.selectCount(any())).willAnswer(invocation -> stored.get() == null ? 0L : 1L);
+        given(grantMapper.selectOne(any())).willAnswer(invocation -> stored.get());
+        given(grantMapper.insert(any(RewardGrant.class))).willAnswer(invocation -> {
+            RewardGrant row = invocation.getArgument(0);
+            row.setId(88L);
+            stored.set(row);
+            return 1;
+        });
+        CoinLedger ledger = new CoinLedger();
+        ledger.setId(99L);
+        given(wallet.change(any(), any(Long.class), any(), any(), any())).willReturn(ledger);
+        given(wallet.balance(7L)).willReturn(150L);
+        RewardTask task = task();
+        RewardTaskProgress progress = progress();
+
+        var first = service.claim(7L, task, progress);
+        var second = service.claim(7L, task, progress);
+
+        assertThat(first.getAlreadyGranted()).isFalse();
+        assertThat(second.getAlreadyGranted()).isTrue();
+        assertThat(progress.getStatus()).isEqualTo(RewardTaskService.STATUS_CLAIMED);
+        verify(wallet, times(1)).change(any(), any(Long.class), any(), any(), any());
+        verify(progressMapper, times(2)).updateById(progress);
+    }
+
+    private RewardTask task() {
+        RewardTask task = new RewardTask();
+        task.setId(3L);
+        task.setCode("watch_5_minutes");
+        task.setRewardCoin(20L);
+        return task;
+    }
+
+    private RewardTaskProgress progress() {
+        RewardTaskProgress progress = new RewardTaskProgress();
+        progress.setId(5L);
+        progress.setCycleKey("2026-11-05");
+        progress.setStatus(RewardTaskService.STATUS_COMPLETED);
+        return progress;
+    }
+}
@@ -0,0 +1,99 @@
+// Author: fruit.com.cn
+
+package com.fruitshorts.commerce.reward.service;
+
+import com.baomidou.mybatisplus.core.MybatisConfiguration;
+import com.baomidou.mybatisplus.core.metadata.TableInfoHelper;
+import com.fruitshorts.commerce.reward.dal.entity.RewardActivity;
+import com.fruitshorts.commerce.reward.dal.entity.RewardEventLog;
+import com.fruitshorts.commerce.reward.dal.entity.RewardTask;
+import com.fruitshorts.commerce.reward.dal.entity.RewardTaskProgress;
+import com.fruitshorts.commerce.reward.dal.mapper.RewardActivityMapper;
+import com.fruitshorts.commerce.reward.dal.mapper.RewardEventLogMapper;
+import com.fruitshorts.commerce.reward.dal.mapper.RewardTaskMapper;
+import com.fruitshorts.commerce.reward.dal.mapper.RewardTaskProgressMapper;
+import org.apache.ibatis.builder.MapperBuilderAssistant;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+import java.util.List;
+import java.util.concurrent.atomic.AtomicReference;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.BDDMockito.given;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verify;
+
+/** 服务端观看事件进度测试。 */
+class RewardTaskServiceTest {
+
+    private RewardTaskMapper taskMapper;
+    private RewardTaskProgressMapper progressMapper;
+    private RewardEventLogMapper eventMapper;
+    private RewardTaskService service;
+    private AtomicReference<RewardEventLog> event;
+    private AtomicReference<RewardTaskProgress> progress;
+
+    @BeforeAll
+    static void initTableInfo() {
+        MapperBuilderAssistant assistant = new MapperBuilderAssistant(new MybatisConfiguration(), "");
+        TableInfoHelper.initTableInfo(assistant, RewardTask.class);
+        TableInfoHelper.initTableInfo(assistant, RewardTaskProgress.class);
+        TableInfoHelper.initTableInfo(assistant, RewardEventLog.class);
+        TableInfoHelper.initTableInfo(assistant, RewardActivity.class);
+    }
+
+    @BeforeEach
+    void setUp() {
+        taskMapper = mock(RewardTaskMapper.class);
+        progressMapper = mock(RewardTaskProgressMapper.class);
+        eventMapper = mock(RewardEventLogMapper.class);
+        event = new AtomicReference<>();
+        progress = new AtomicReference<>();
+        service = new RewardTaskService(taskMapper, progressMapper, eventMapper,
+                mock(RewardActivityMapper.class));
+        given(taskMapper.selectList(any())).willReturn(List.of(watchTask()));
+        given(eventMapper.selectOne(any())).willAnswer(invocation -> event.get());
+        given(progressMapper.selectOne(any())).willAnswer(invocation -> progress.get());
+        captureInserts();
+    }
+
+    @Test
+    void should_add_only_new_maximum_seconds_when_watch_progress_repeats() {
+        service.recordWatch(7L, 18L, 10_000L, false);
+        service.recordWatch(7L, 18L, 25_000L, false);
+
+        assertThat(event.get().getEventValue()).isEqualTo(25L);
+        assertThat(progress.get().getProgressValue()).isEqualTo(25L);
+        verify(eventMapper).updateById(event.get());
+    }
+
+    private void captureInserts() {
+        given(eventMapper.insert(any(RewardEventLog.class))).willAnswer(invocation -> {
+            RewardEventLog row = invocation.getArgument(0);
+            row.setId(1L);
+            event.set(row);
+            return 1;
+        });
+        given(progressMapper.insert(any(RewardTaskProgress.class))).willAnswer(invocation -> {
+            RewardTaskProgress row = invocation.getArgument(0);
+            row.setId(2L);
+            progress.set(row);
+            return 1;
+        });
+    }
+
+    private RewardTask watchTask() {
+        RewardTask task = new RewardTask();
+        task.setId(3L);
+        task.setCode("watch_5_minutes");
+        task.setType(RewardTaskService.TYPE_WATCH_DURATION);
+        task.setCycleType(RewardTaskService.CYCLE_DAILY);
+        task.setTargetValue(300L);
+        task.setStatus(1);
+        task.setDeleted(0);
+        return task;
+    }
+}
@@ -24,6 +24,8 @@ public class ContentTag {
    private String nameLocales;
    /** 角标背景色，#RRGGBB。 */
    private String bgColor;
+    /** 语义码，如 NEW_ARRIVAL；客户端按码判断板块，不解析文案。空表示未配置。 */
+    private String code;
    private Integer sort;
    private Integer status;
    private LocalDateTime createdAt;
@@ -18,10 +18,16 @@ public class DramaClassification {
    private Long id;
    /** 中文名称。 */
    private String name;
+    /** 稳定语义码，不随展示名称变化。 */
+    private String code;
    private String nameEn;
    private String nameId;
    /** 已选语言的名称。 */
    private String nameLocales;
+    /** 客户端布局：GRID / RANKING。 */
+    private String layoutType;
+    /** 内容或顺序版本。 */
+    private Long revision;
    private Integer sort;
    private Integer status;
    private LocalDateTime createdAt;
@@ -18,5 +18,7 @@ public class DramaClassificationDrama {
    private Long id;
    private Long classificationId;
    private Long dramaId;
+    /** 分类内展示位置，从 1 开始。 */
+    private Integer position;
    private LocalDateTime createdAt;
 }
@@ -49,9 +49,12 @@ public class ContentTagService {
    public Long create(ContentTagSaveReqVO req) {
        Map<String, String> locales = namesOf(req);
        ensureNameAvailable(locales.get(ContentLocaleTexts.ZH), null);
+        String code = normalizeCode(req.getCode());
+        ensureCodeAvailable(code, null);
        ContentTag entity = new ContentTag();
        writeNames(entity, locales);
        entity.setBgColor(normalizeColor(req.getBgColor()));
+        entity.setCode(code);
        Long count = tagMapper.selectCount(null);
        entity.setSort(req.getSort() == null
                ? (count == null ? 0 : count.intValue()) + 1
@@ -69,6 +72,11 @@ public class ContentTagService {
        if (req.getBgColor() != null) {
            entity.setBgColor(normalizeColor(req.getBgColor()));
        }
+        if (req.getCode() != null) {
+            String code = normalizeCode(req.getCode());
+            ensureCodeAvailable(code, id);
+            entity.setCode(code);
+        }
        if (req.getSort() != null) {
            entity.setSort(req.getSort());
        }
@@ -115,6 +123,23 @@ public class ContentTagService {
        return color.trim().toUpperCase();
    }

+    /** 语义码统一大写；空字符串表示不配置。 */
+    private String normalizeCode(String code) {
+        return code == null ? "" : code.trim().toUpperCase();
+    }
+
+    private void ensureCodeAvailable(String code, Long excludeId) {
+        if (code.isEmpty()) {
+            return;
+        }
+        Long count = tagMapper.selectCount(Wrappers.<ContentTag>lambdaQuery()
+                .eq(ContentTag::getCode, code)
+                .ne(excludeId != null, ContentTag::getId, excludeId));
+        if (count != null && count > 0) {
+            throw new ServiceException(ErrorCode.DATA_EXISTS, "语义码已存在");
+        }
+    }
+
    private ContentTag getExisting(Long id) {
        ContentTag entity = id == null ? null : tagMapper.selectById(id);
        if (entity == null) {
@@ -142,6 +167,7 @@ public class ContentTagService {
        vo.setNameId(ContentLocaleTexts.value(locales, ContentLocaleTexts.ID));
        vo.setLocales(locales);
        vo.setBgColor(tag.getBgColor() == null || tag.getBgColor().isBlank() ? "#E5484D" : tag.getBgColor());
+        vo.setCode(tag.getCode() == null ? "" : tag.getCode());
        vo.setSort(tag.getSort());
        vo.setStatus(tag.getStatus());
        return vo;
@@ -27,7 +27,6 @@ import org.springframework.util.StringUtils;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
-import java.util.stream.Collectors;

 /**
 * 运营分类服务。分类是独立于「短剧类型（drama_category）」的一套概念，
@@ -37,9 +36,15 @@ import java.util.stream.Collectors;
@RequiredArgsConstructor
 public class DramaClassificationService {

+    public static final String LAYOUT_GRID = "GRID";
+    public static final String LAYOUT_RANKING = "RANKING";
+    private static final long INITIAL_REVISION = 1L;
+    private static final String DEFAULT_CODE_PREFIX = "CLASSIFICATION_";
+
    private final DramaClassificationMapper classificationMapper;
    private final DramaClassificationDramaMapper classificationDramaMapper;
    private final DramaMapper dramaMapper;
+    private final DramaRankingService rankingService;

    public List<DramaClassificationRespVO> list() {
        Map<Long, Integer> counts = countDramas();
@@ -49,12 +54,15 @@ public class DramaClassificationService {
                .stream().map(item -> {
                    DramaClassificationRespVO vo = new DramaClassificationRespVO();
                    vo.setId(item.getId());
+                    vo.setCode(codeOf(item));
                    Map<String, String> locales = ContentLocaleTexts.read(
                            item.getNameLocales(), item.getName(), item.getNameEn(), item.getNameId());
                    vo.setName(locales.get(ContentLocaleTexts.ZH));
                    vo.setNameEn(ContentLocaleTexts.value(locales, ContentLocaleTexts.EN));
                    vo.setNameId(ContentLocaleTexts.value(locales, ContentLocaleTexts.ID));
                    vo.setLocales(locales);
+                    vo.setLayoutType(layoutOf(item));
+                    vo.setRevision(revisionOf(item));
                    vo.setSort(item.getSort());
                    vo.setStatus(item.getStatus());
                    vo.setUpdatedAt(item.getUpdatedAt());
@@ -68,12 +76,18 @@ public class DramaClassificationService {
        ensureNameAvailable(locales.get(ContentLocaleTexts.ZH), null);
        DramaClassification entity = new DramaClassification();
        writeNames(entity, locales);
+        writeClassificationSettings(entity, req);
        Long count = classificationMapper.selectCount(null);
        entity.setSort(req.getSort() == null
                ? (count == null ? 0 : count.intValue()) + 1
                : req.getSort());
        entity.setStatus(req.getStatus() == null ? 1 : req.getStatus());
+        entity.setRevision(INITIAL_REVISION);
        classificationMapper.insert(entity);
+        if (!StringUtils.hasText(entity.getCode())) {
+            entity.setCode(DEFAULT_CODE_PREFIX + entity.getId());
+            classificationMapper.updateById(entity);
+        }
        return entity.getId();
    }

@@ -82,6 +96,7 @@ public class DramaClassificationService {
        Map<String, String> locales = namesOf(req);
        ensureNameAvailable(locales.get(ContentLocaleTexts.ZH), id);
        writeNames(entity, locales);
+        writeClassificationSettings(entity, req);
        if (req.getSort() != null) {
            entity.setSort(req.getSort());
        }
@@ -114,7 +129,7 @@ public class DramaClassificationService {
    /** 批量关联短剧；已关联的自动跳过。 */
    @Transactional(rollbackFor = Exception.class)
    public int bindDramas(Long id, List<Long> dramaIds) {
-        getExisting(id);
+        ensureGridMutation(getExisting(id));
        if (dramaIds == null || dramaIds.isEmpty()) {
            return 0;
        }
@@ -133,6 +148,7 @@ public class DramaClassificationService {
            DramaClassificationDrama relation = new DramaClassificationDrama();
            relation.setClassificationId(id);
            relation.setDramaId(dramaId);
+            relation.setPosition(rankingService.nextPosition(id));
            classificationDramaMapper.insert(relation);
            added++;
        }
@@ -141,15 +157,24 @@ public class DramaClassificationService {

    /** 移出分类；短剧本身不受影响。 */
    public void unbindDrama(Long id, Long dramaId) {
-        getExisting(id);
+        ensureGridMutation(getExisting(id));
        classificationDramaMapper.delete(Wrappers.<DramaClassificationDrama>lambdaQuery()
                .eq(DramaClassificationDrama::getClassificationId, id)
                .eq(DramaClassificationDrama::getDramaId, dramaId));
    }

+    /** 原子替换推荐榜内容与顺序，成功后递增版本。 */
+    @Transactional(rollbackFor = Exception.class)
+    public void saveRankingItems(Long id, List<Long> dramaIds) {
+        rankingService.saveItems(id, dramaIds);
+    }
+
    private PageResult<DramaBriefVO> pageDramas(Long id, String keyword,
                                                int pageIndex, int pageSize, boolean bound) {
-        getExisting(id);
+        DramaClassification classification = getExisting(id);
+        if (bound && LAYOUT_RANKING.equals(layoutOf(classification))) {
+            return rankingService.page(id, keyword, pageIndex, pageSize);
+        }
        Page<Drama> page = new Page<>(Math.max(1, pageIndex), Math.max(1, Math.min(pageSize, 100)));
        LambdaQueryWrapper<Drama> wrapper = Wrappers.<Drama>lambdaQuery()
                .like(StringUtils.hasText(keyword), Drama::getTitle, keyword)
@@ -228,8 +253,12 @@ public class DramaClassificationService {
        return entity;
    }

-    /** C 端：分类下关联的全部 dramaId（按关联创建时间 desc）。 */
+    /** C 端：普通分类保留历史倒序，推荐榜严格按 position 升序。 */
    public List<Long> listDramaIdsByClassification(Long classificationId) {
+        DramaClassification classification = getExisting(classificationId);
+        if (LAYOUT_RANKING.equals(layoutOf(classification))) {
+            return rankingService.orderedDramaIds(classificationId);
+        }
        return classificationDramaMapper.selectList(
                        Wrappers.<DramaClassificationDrama>lambdaQuery()
                                .eq(DramaClassificationDrama::getClassificationId, classificationId)
@@ -237,10 +266,14 @@ public class DramaClassificationService {
                                .orderByDesc(DramaClassificationDrama::getId))
                .stream()
                .map(DramaClassificationDrama::getDramaId)
-                .collect(Collectors.toList());
+                .toList();
    }

    private DramaBriefVO toBrief(Drama drama) {
+        return toBrief(drama, null);
+    }
+
+    private DramaBriefVO toBrief(Drama drama, Integer position) {
        DramaBriefVO vo = new DramaBriefVO();
        vo.setId(drama.getId());
        vo.setTitle(drama.getTitle());
@@ -248,7 +281,54 @@ public class DramaClassificationService {
        vo.setStatus(drama.getStatus());
        vo.setTotalEpisodes(drama.getTotalEpisodes());
        vo.setSort(drama.getSort());
+        vo.setPosition(position);
        vo.setUpdatedAt(drama.getUpdatedAt());
        return vo;
    }
+
+    private void writeClassificationSettings(DramaClassification entity,
+                                             DramaClassificationSaveReqVO req) {
+        if (StringUtils.hasText(req.getCode())) {
+            String code = req.getCode().trim();
+            ensureCodeAvailable(code, entity.getId());
+            entity.setCode(code);
+        }
+        if (StringUtils.hasText(req.getLayoutType())) {
+            entity.setLayoutType(req.getLayoutType());
+        } else if (!StringUtils.hasText(entity.getLayoutType())) {
+            entity.setLayoutType(LAYOUT_GRID);
+        }
+    }
+
+    private void ensureCodeAvailable(String code, Long excludeId) {
+        Long count = classificationMapper.selectCount(Wrappers.<DramaClassification>lambdaQuery()
+                .eq(DramaClassification::getCode, code)
+                .ne(excludeId != null, DramaClassification::getId, excludeId));
+        if (count != null && count > 0) {
+            throw new ServiceException(ErrorCode.DATA_EXISTS, "分类编码已存在");
+        }
+    }
+
+    private String codeOf(DramaClassification classification) {
+        return StringUtils.hasText(classification.getCode())
+                ? classification.getCode()
+                : DEFAULT_CODE_PREFIX + classification.getId();
+    }
+
+    private String layoutOf(DramaClassification classification) {
+        return StringUtils.hasText(classification.getLayoutType())
+                ? classification.getLayoutType()
+                : LAYOUT_GRID;
+    }
+
+    private long revisionOf(DramaClassification classification) {
+        return classification.getRevision() == null ? INITIAL_REVISION : classification.getRevision();
+    }
+
+    private void ensureGridMutation(DramaClassification classification) {
+        if (LAYOUT_RANKING.equals(layoutOf(classification))) {
+            throw new ServiceException(ErrorCode.OPERATION_NOT_ALLOWED,
+                    "推荐榜请使用完整排序接口维护内容");
+        }
+    }
 }
@@ -0,0 +1,161 @@
+// Author: fruit.com.cn
+
+package com.fruitshorts.content.service;
+
+import com.baomidou.mybatisplus.core.toolkit.Wrappers;
+import com.fruitshorts.common.exception.ErrorCode;
+import com.fruitshorts.common.exception.ServiceException;
+import com.fruitshorts.common.pojo.PageResult;
+import com.fruitshorts.content.dal.entity.Drama;
+import com.fruitshorts.content.dal.entity.DramaClassification;
+import com.fruitshorts.content.dal.entity.DramaClassificationDrama;
+import com.fruitshorts.content.dal.mapper.DramaClassificationDramaMapper;
+import com.fruitshorts.content.dal.mapper.DramaClassificationMapper;
+import com.fruitshorts.content.dal.mapper.DramaMapper;
+import com.fruitshorts.content.vo.DramaBriefVO;
+import lombok.RequiredArgsConstructor;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+import org.springframework.util.StringUtils;
+
+import java.util.LinkedHashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.function.Function;
+import java.util.stream.Collectors;
+
+/** 推荐榜内容、顺序和版本服务。 */
+@Service
+@RequiredArgsConstructor
+public class DramaRankingService {
+
+    private static final int MAX_RANKING_ITEMS = 50;
+    private static final long INITIAL_REVISION = 1L;
+
+    private final DramaClassificationMapper classificationMapper;
+    private final DramaClassificationDramaMapper relationMapper;
+    private final DramaMapper dramaMapper;
+
+    /** 原子替换推荐榜内容与顺序，成功后递增版本。 */
+    @Transactional(rollbackFor = Exception.class)
+    public void saveItems(Long classificationId, List<Long> dramaIds) {
+        DramaClassification classification = getRanking(classificationId);
+        List<Long> orderedIds = orderedIds(dramaIds);
+        ensureDramasExist(orderedIds);
+        relationMapper.delete(Wrappers.<DramaClassificationDrama>lambdaQuery()
+                .eq(DramaClassificationDrama::getClassificationId, classificationId));
+        for (int index = 0; index < orderedIds.size(); index++) {
+            relationMapper.insert(relation(classificationId, orderedIds.get(index), index + 1));
+        }
+        long revision = classification.getRevision() == null
+                ? INITIAL_REVISION
+                : classification.getRevision();
+        classification.setRevision(revision + 1);
+        classificationMapper.updateById(classification);
+    }
+
+    /** 推荐榜后台分页，严格按持久化位置返回。 */
+    public PageResult<DramaBriefVO> page(Long classificationId, String keyword,
+                                         int pageIndex, int pageSize) {
+        List<DramaClassificationDrama> relations = orderedRelations(classificationId);
+        if (relations.isEmpty()) {
+            return PageResult.empty();
+        }
+        List<Long> ids = relations.stream().map(DramaClassificationDrama::getDramaId).toList();
+        Map<Long, Drama> dramas = dramaMapper.selectBatchIds(ids).stream()
+                .collect(Collectors.toMap(Drama::getId, Function.identity()));
+        List<DramaBriefVO> all = relations.stream()
+                .filter(item -> dramas.containsKey(item.getDramaId()))
+                .map(item -> toBrief(dramas.get(item.getDramaId()), item.getPosition()))
+                .filter(item -> !StringUtils.hasText(keyword) || item.getTitle().contains(keyword))
+                .toList();
+        return pageOf(all, pageIndex, pageSize);
+    }
+
+    /** 分类内全部短剧 id，严格按 position 升序。 */
+    public List<Long> orderedDramaIds(Long classificationId) {
+        return orderedRelations(classificationId).stream()
+                .map(DramaClassificationDrama::getDramaId)
+                .toList();
+    }
+
+    /** 新增关联时使用的末尾位置。 */
+    public int nextPosition(Long classificationId) {
+        return orderedRelations(classificationId).stream()
+                .map(DramaClassificationDrama::getPosition)
+                .filter(Objects::nonNull)
+                .max(Integer::compareTo)
+                .orElse(0) + 1;
+    }
+
+    private DramaClassification getRanking(Long id) {
+        DramaClassification classification = id == null ? null : classificationMapper.selectById(id);
+        if (classification == null) {
+            throw new ServiceException(ErrorCode.DATA_NOT_FOUND, "分类不存在");
+        }
+        if (!DramaClassificationService.LAYOUT_RANKING.equals(classification.getLayoutType())) {
+            throw new ServiceException(ErrorCode.OPERATION_NOT_ALLOWED, "只有推荐榜分类可以保存榜单顺序");
+        }
+        return classification;
+    }
+
+    private List<Long> orderedIds(List<Long> dramaIds) {
+        LinkedHashSet<Long> unique = new LinkedHashSet<>();
+        if (dramaIds != null) {
+            dramaIds.stream().filter(Objects::nonNull).forEach(unique::add);
+        }
+        if (unique.size() > MAX_RANKING_ITEMS) {
+            throw new ServiceException(ErrorCode.BAD_REQUEST, "推荐榜最多 50 部短剧");
+        }
+        return List.copyOf(unique);
+    }
+
+    private void ensureDramasExist(List<Long> dramaIds) {
+        if (dramaIds.isEmpty()) {
+            return;
+        }
+        if (dramaMapper.selectBatchIds(dramaIds).size() != dramaIds.size()) {
+            throw new ServiceException(ErrorCode.DATA_NOT_FOUND, "榜单中包含不存在的短剧");
+        }
+    }
+
+    private List<DramaClassificationDrama> orderedRelations(Long classificationId) {
+        return relationMapper.selectList(Wrappers.<DramaClassificationDrama>lambdaQuery()
+                .eq(DramaClassificationDrama::getClassificationId, classificationId)
+                .orderByAsc(DramaClassificationDrama::getPosition)
+                .orderByDesc(DramaClassificationDrama::getId));
+    }
+
+    private DramaClassificationDrama relation(Long classificationId, Long dramaId, int position) {
+        DramaClassificationDrama relation = new DramaClassificationDrama();
+        relation.setClassificationId(classificationId);
+        relation.setDramaId(dramaId);
+        relation.setPosition(position);
+        return relation;
+    }
+
+    private DramaBriefVO toBrief(Drama drama, Integer position) {
+        DramaBriefVO vo = new DramaBriefVO();
+        vo.setId(drama.getId());
+        vo.setTitle(drama.getTitle());
+        vo.setCover(drama.getCoverUrl());
+        vo.setStatus(drama.getStatus());
+        vo.setTotalEpisodes(drama.getTotalEpisodes());
+        vo.setSort(drama.getSort());
+        vo.setPosition(position);
+        vo.setUpdatedAt(drama.getUpdatedAt());
+        return vo;
+    }
+
+    private PageResult<DramaBriefVO> pageOf(List<DramaBriefVO> items, int pageIndex, int pageSize) {
+        int safeIndex = Math.max(1, pageIndex);
+        int safeSize = Math.max(1, Math.min(pageSize, 100));
+        int fromIndex = (safeIndex - 1) * safeSize;
+        if (fromIndex >= items.size()) {
+            return new PageResult<>(items.size(), List.of());
+        }
+        int toIndex = Math.min(fromIndex + safeSize, items.size());
+        return new PageResult<>(items.size(), items.subList(fromIndex, toIndex));
+    }
+}
@@ -61,6 +61,13 @@ public class DramaService {
                .like(StringUtils.hasText(req.getKeyword()), Drama::getTitle, req.getKeyword())
                .eq(StringUtils.hasText(req.getStatus()), Drama::getStatus, req.getStatus())
                .eq(req.getIsHot() != null, Drama::getIsHot, Boolean.TRUE.equals(req.getIsHot()) ? 1 : 0);
+        // admin 短剧管理默认隐藏创作者发的、尚在审核中/被驳回的剧——审核通过后才自动进入；
+        // admin 自己建的（creator_id IS NULL）不受影响；手动选了状态时也放行。
+        if (!StringUtils.hasText(req.getStatus())) {
+            wrapper.and(w -> w.isNull(Drama::getCreatorId)
+                    .or()
+                    .notIn(Drama::getStatus, List.of("reviewing", "rejected")));
+        }
        if (!dramaTypes.isEmpty()) {
            DramaMultiTagSupport.applyDramaTypeTokens(wrapper, dramaTypes);
        }
@@ -162,6 +169,12 @@ public class DramaService {
                requireState(current, "APPROVE", Set.of(ContentStatus.REVIEWING.getCode()));
                yield ContentStatus.APPROVED.getCode();
            }
+            case "APPROVE_PUBLISH" -> {
+                // 一步审核通过并上线，减少后台操作步骤
+                requireState(current, "APPROVE_PUBLISH", Set.of(ContentStatus.DRAFT.getCode(),
+                        ContentStatus.REVIEWING.getCode(), ContentStatus.OFFLINE.getCode()));
+                yield ContentStatus.PUBLISHED.getCode();
+            }
            case "REJECT" -> {
                requireState(current, "REJECT", Set.of(ContentStatus.REVIEWING.getCode()));
                yield ContentStatus.DRAFT.getCode();
@@ -464,10 +477,13 @@ public class DramaService {
        if (isNew || req.getCover() != null) {
            drama.setCoverUrl(req.getCover() == null ? "" : req.getCover());
        }
+        if (isNew || req.getHorizontalCover() != null) {
+            drama.setHorizontalCoverUrl(
+                    req.getHorizontalCover() == null ? "" : req.getHorizontalCover());
+        }
        if (isNew || req.getTrailerUrl() != null) {
            drama.setTrailerUrl(req.getTrailerUrl() == null ? "" : req.getTrailerUrl());
        }
-        drama.setHorizontalCoverUrl(drama.getHorizontalCoverUrl() == null ? "" : drama.getHorizontalCoverUrl());
        if (isNew || req.getLanguage() != null) {
            drama.setLanguage(req.getLanguage() == null ? "zh-CN" : req.getLanguage());
        }
@@ -530,6 +546,7 @@ public class DramaService {
            vo.setSynopsisLocales(synopses);
            vo.setSubtitle(drama.getSubtitle());
            vo.setCover(drama.getCoverUrl());
+            vo.setHorizontalCover(drama.getHorizontalCoverUrl());
            vo.setTrailerUrl(drama.getTrailerUrl());
            vo.setLanguage(drama.getLanguage());
            vo.setDramaType(dramaTypes.get(0));
@@ -14,6 +14,8 @@ public class ContentTagRespVO {
    private String nameId;
    private java.util.Map<String, String> locales;
    private String bgColor;
+    /** 语义码，如 NEW_ARRIVAL；空表示未配置。 */
+    private String code;
    private Integer sort;
    private Integer status;
 }
@@ -21,6 +21,10 @@ public class ContentTagSaveReqVO {
    @Pattern(regexp = "^$|^#[0-9A-Fa-f]{6}$", message = "背景色格式应为 #RRGGBB")
    private String bgColor;

+    /** 语义码，如 NEW_ARRIVAL；客户端按码判断板块，留空表示按文案兜底。 */
+    @Pattern(regexp = "^$|^[A-Z][A-Z0-9_]{0,31}$", message = "语义码需为大写字母、数字或下划线")
+    private String code;
+
    private Integer sort;
    private Integer status;
 }
@@ -16,5 +16,7 @@ public class DramaBriefVO {
    private String status;
    private Integer totalEpisodes;
    private Integer sort;
+    /** 分类内展示位置。 */
+    private Integer position;
    private LocalDateTime updatedAt;
 }
@@ -12,9 +12,12 @@ public class DramaClassificationRespVO {

    private Long id;
    private String name;
+    private String code;
    private String nameEn;
    private String nameId;
    private java.util.Map<String, String> locales;
+    private String layoutType;
+    private Long revision;
    private Integer sort;
    private Integer status;
    private Integer dramaCount;
@@ -3,6 +3,7 @@
 package com.fruitshorts.content.vo;

 import jakarta.validation.constraints.Size;
+import jakarta.validation.constraints.Pattern;
 import lombok.Data;

 /** 分类新增/编辑请求体。 */
@@ -17,6 +18,13 @@ public class DramaClassificationSaveReqVO {
    /** 勾选的语言名称，key 为 zh / en / id。 */
    private java.util.Map<String, String> locales;

+    @Size(max = 64, message = "分类编码最多 64 个字符")
+    @Pattern(regexp = "^[A-Z0-9_]*$", message = "分类编码只能包含大写字母、数字和下划线")
+    private String code;
+
+    @Pattern(regexp = "^(GRID|RANKING)$", message = "展示类型只支持 GRID 或 RANKING")
+    private String layoutType;
+
    private Integer sort;
    private Integer status;
 }
@@ -0,0 +1,18 @@
+// Author: fruit.com.cn
+
+package com.fruitshorts.content.vo;
+
+import jakarta.validation.constraints.NotNull;
+import jakarta.validation.constraints.Size;
+import lombok.Data;
+
+import java.util.List;
+
+/** 推荐榜完整有序短剧列表。 */
+@Data
+public class DramaRankingItemsReqVO {
+
+    @NotNull(message = "请提交推荐榜短剧列表")
+    @Size(max = 50, message = "推荐榜最多 50 部短剧")
+    private List<Long> dramaIds;
+}
Author	SHA1	Message	Date
jianghaifeng	2904e59e71	Merge branch 'develop' of https://git.reelshort2.com:80/jianghaifeng/FruitServer into develop backend-ci / test (push) Failing after 4m42s Details	2026-11-13 16:55:07 +08:00
Zhou Weidong	a5c9357a24	fix: 消除 JWT/签名密钥源码硬编码，全部改为环境变量注入 backend-ci / test (push) Failing after 4m39s Details - JwtProperties.adminSecret/appSecret 默认值从 dev 密钥改为空字符串 - MediaProperties.signatureSecret 默认值从 dev 密钥改为空字符串 - app-api/admin-api application.yml 三处密钥回退值均改为空 - docker-compose.yml CORS_ALLOWED_ORIGINS 追加 ymb-site 3007 端口白名单 - .gitignore 追加 *.secrets.env / SSL 证书 / nginx 部署目录忽略规则	2026-11-13 16:53:53 +08:00
Zhou Weidong	12c28963f5	feat(commerce): 完成奖励活动管理接口	2026-11-13 13:43:16 +08:00
jianghaifeng	32cac38a0e	feat(auth): Google 登录支持多客户端 audience 校验 - GoogleAuthProperties 的 clientId 改为 clientIds 列表 - GoogleIdTokenVerifier 命中任一 clientId 即通过，兼容 iOS 与 Android 不同的 aud - app-api 注入三个客户端 id，生产可用 GOOGLE_CLIENT_IDS 覆盖	2026-11-13 12:30:55 +08:00
Zhou Weidong	a706621786	fix(commerce): 奖励任务菜单改用46避免覆盖转码设置 backend-ci / test (push) Failing after 5m11s Details	2026-11-09 10:35:37 +08:00
Zhou Weidong	64eadf1446	feat(commerce): 新增打赏任务中心与签到发奖 backend-ci / test (push) Failing after 4m53s Details	2026-11-09 10:32:53 +08:00
Zhou Weidong	2fee329002	feat(creator): 内容审核返回创作者与分集信息	2026-11-09 10:32:53 +08:00
Zhou Weidong	9b2833dfd3	feat(creator): 后台录入创作者即通过并可直接开号	2026-11-09 10:32:53 +08:00
Zhou Weidong	af0bf7f90e	feat(creator): 新增一键发布与删除作品接口	2026-11-09 10:32:46 +08:00
Zhou Weidong	a36276051d	fix(system): 修复转码设置菜单误下发导致前端白屏	2026-11-09 10:32:46 +08:00
jianghaifeng	3df66c2f4c	refactor(media): 抽出 MediaStorage 接口为对象存储切换铺路 backend-ci / test (push) Failing after 5m7s Details 本地磁盘实现 MediaStorageService 改为实现接口，五处注入点改为依赖接口；行为不变。后期新增 S3 实现以配置切换即可。	2026-11-05 11:31:31 +08:00
jianghaifeng	32ada4c2bf	feat(content): 短剧支持审核通过并上线一步流转 backend-ci / test (push) Failing after 5m8s Details 新增 APPROVE_PUBLISH 动作与 approve-publish 接口，草稿/审核中/已下线可直接流转为已上线，事务内同步上线草稿分集并记录一条审核记录，后台审核操作由三步减为一步。	2026-11-05 10:55:52 +08:00
Zhou Weidong	eba7d400e1	fix(deploy): 看门狗飞书告警中文乱码改 UTF-8 发送 backend-ci / test (push) Failing after 4m39s Details PS5 Invoke-RestMethod 对字符串 body 默认按 Latin-1 编码导致中文变 ???，改为手动转 UTF-8 字节数组并声明 charset=utf-8。	2026-11-02 14:52:41 +08:00
Zhou Weidong	3faeba0589	fix(deploy): 补充 CORS 允许来源避免跨域被拒 app-api 增加 frostgiant 域名(含 nginx 非标准 80 端口)与公网 IP 来源； admin-api 增加公网/局域网 IP 与 admin.frostgiant.vip。 Spring setAllowedOrigins 为精确字符串匹配，来源必须逐条列全。	2026-11-02 14:52:41 +08:00
Zhou Weidong	8a5a381b44	feat(catalog): 新增分类推荐榜快照接口 backend-ci / test (push) Failing after 4m45s Details	2026-11-02 14:45:43 +08:00
jianghaifeng	afd8d00752	feat(catalog): 卡片下发完整简介不再截断 backend-ci / test (push) Canceled after 0s Details	2026-10-30 22:53:22 +08:00
jianghaifeng	958de5ef22	feat(config): /app/config 下发登录页背景地址 backend-ci / test (push) Canceled after 0s Details	2026-10-30 17:14:46 +08:00
jianghaifeng	f2103f6604	feat(cover): 短剧新增横版封面字段并在进度接口下发 backend-ci / test (push) Canceled after 0s Details - Drama/DramaSaveReqVO/DramaRespVO 新增 horizontalCover，打通后台上传链路 - AppDramaCardVO/AppDramaDetailVO 新增 coverLandscape - ProgressRespVO 新增 dramaCoverLandscape，继续观看横幅可直接取横版图	2026-10-29 17:32:49 +08:00
jianghaifeng	0d4d510aee	feat(content): 标签增加语义码并随卡片下发 backend-ci / test (push) Canceled after 0s Details 标签名称会随语言和运营文案变化，客户端按名称判断板块（如推荐页「上新」横滑）一改名就失效。content_tag 新增 code 列并在后台维护，卡片与详情以 tagCode 下发，已有「上新 / 热剧 / 新剧 / 热播」一并回填。	2026-10-29 15:45:34 +08:00
Zhou Weidong	4d796089a0	ops(grafana): 告警规则入库（服务下线/响应慢/磁盘满） backend-ci / test (push) Failing after 4m38s Details	2026-10-29 10:53:07 +08:00
Zhou Weidong	f71498339c	ci: 新增 Gitea Actions 流水线（测试/分析/构建门禁） backend-ci / test (push) Failing after 7m31s Details	2026-10-29 10:47:44 +08:00
Zhou Weidong	e4fe82283c	docs: 更新第一阶段进度表与尚未完成清单（C2/C3 标记已实现）	2026-10-29 10:47:44 +08:00
Zhou Weidong	26102332ac	fix(deploy): 看门狗改由用户会话任务启动 Docker Desktop 以 SYSTEM 身份直接 Start-Process Docker Desktop.exe 会命中 WSL_E_LOCAL_SYSTEM_NOT_SUPPORTED，把 docker-desktop 发行版搞成僵死状态（VHD 已挂载无法终止），导致登录用户自己也起不来。改为触发以登录用户身份运行的 FruitShorts-DockerDesktop 计划任务（先停再起，规避 IgnoreNew）。	2026-10-29 10:11:02 +08:00
Zhou Weidong	aa5954ef6a	chore(merge): 合并 main 的印尼语敏感词库种子到 develop	2026-10-29 09:21:19 +08:00
Zhou Weidong	963bf5c0da	test(playback): 补充合并预写缓冲与迟到条目丢弃用例	2026-10-28 19:02:33 +08:00
Zhou Weidong	a71d2701d1	fix(playback): 登录合并前预写设备缓冲，迟到条目不得复活已删记录 - 新增 flushIdentity：把某身份缓冲里未落库的进度立即写进权威表； mergeDeviceIntoUser 先调用它再扫库，否则登录前 2 秒内的上报会被漏掉，稍后落库还会生成一条登录用户看不到的匿名孤儿行；合并完清掉设备侧缓冲。 - planOne 增加判定：逻辑删除会刷新 updated_at，上报时间不晚于它的条目直接丢弃，防止删除瞬间已 drain 的在途引用把 deleted 写回 0。 - 去掉 save(Long userId, ...) 上多余的 @Transactional（缓冲路径白开事务）。	2026-10-28 19:02:32 +08:00
Zhou Weidong	025fbe73f0	perf(playback): 上报改用 Lua 单次往返写入缓冲原先 HSET、EXPIRE、LPUSH、LTRIM 分四次往返，进程若死在写状态与入队之间，该剧进度只留在 HASH 里永远不落库、12 小时后被 TTL 清掉。合并成一个脚本后热路径只需 1 次往返，脚本顺带返回 HLEN 是否超 30 决定要不要补裁剪。	2026-10-28 19:02:32 +08:00
Zhou Weidong	0d161f318f	chore(merge): 合并 origin/develop 的看门狗周期巡检与 admin-api Redis 配置 watchdog.ps1 冲突取本地实现：计数落盘用 Import/Export 函数，另含 Webhook 三级兜底与告警节流，为远程内联版本的超集。	2026-10-28 18:53:11 +08:00
Zhou Weidong	2eac1fe31d	test(playback): 补充缓冲删除双写、已删剧不读回与失效条目丢弃用例	2026-10-28 18:51:52 +08:00
Zhou Weidong	09b0f89e8d	fix(deploy): 看门狗失败计数落盘并补齐告警 Webhook 兜底计划任务每 2 分钟起新进程，进程内计数永远到不了阈值，告警静默哑火；计数改 JSON 落盘跨进程累加，达阈值后只在首达与每 30 轮提醒。Webhook 支持参数、环境变量、deploy/feishu-webhook.txt 三级兜底，密钥文件不入库。	2026-10-28 18:51:52 +08:00
Zhou Weidong	8fb1f52777	fix(config): 调度线程池扩到 4 条，避免落库与其它定时任务互相排队	2026-10-28 18:51:52 +08:00
Zhou Weidong	44b7abcd0f	fix(playback): 删除观看历史时同步清理进度缓冲缓冲已是读接口的权威来源，只删库行会被读覆盖层读回、并被下一次落库把行复活。缓冲补 remove/clear（HDEL/DEL），删除路径先清缓冲再删库行，读覆盖层按库行 deleted 过滤；落库时缓冲状态已失效的条目直接丢弃，不再整批退回队列。	2026-10-28 18:51:52 +08:00
Zhou Weidong	181b338780	fix(ops): 修复管理端 Redis 未配置与看门狗未真正周期巡检 - admin-api 的 application.yml 缺少 spring.data.redis 配置，容器内默认连 127.0.0.1 导致 /actuator/health 返回 DOWN（redis 组件不可用）；补齐后与 app-api 共用 REDIS_HOST/REDIS_PORT，健康检查恢复 UP - 计划任务原先用 BootTrigger 挂 Repetition，Windows 不生效（Next Run Time 为 N/A，9 小时只跑过一次），看门狗形同虚设；改为 TimeTrigger + PT2M 无限重复 + StartWhenAvailable，实测每 2 分钟稳定巡检 - watchdog.ps1 的连续失败计数改为落盘 watchdog-state.json，避免每轮进程重启后清零导致「连续 3 次失败告警」永不触发	2026-10-28 18:23:48 +08:00
Zhou Weidong	657190d5a8	chore(deploy): 加入服务看门狗脚本与 Windows 计划任务注册文件 - watchdog.ps1：每 2 分钟健康检查，Docker/DB/Redis/API/Grafana 任一不健康自动重启，连续 3 次失败发飞书告警，C 盘超 85% 也告警 - backend-watchdog-task.xml：开机触发、2 分钟循环的计划任务配置	2026-10-28 15:00:58 +08:00
Zhou Weidong	3e2d6a06d9	perf(playback): 观看进度上报异步化（Redis write-behind 批量落库） - POST /app/watch/progress 只写 Redis 缓冲立即返回（p95 75ms→2ms）， WatchProgressFlusher 每 2s 把 watch:pg:dirty 队列按身份合并批量 UPSERT， Redis 异常自动回退同步写库，接口契约不变 - 读接口用缓冲覆盖 DB 行保证读己之写；Caffeine 缓存剧集校验免去上报路径两条 DB 查询 - 落库按「新增进度/新增流水/更新行」分组攒批（MyBatis BATCH 只合并连续同形状语句），配合 reWriteBatchedInserts 多值 INSERT，12.4 万积压 45 秒消化完， 1650 QPS 持续压测队列稳态归零	2026-10-28 14:59:09 +08:00
Zhou Weidong	fc9e429187	feat(monitoring): 接入 Loki + Promtail 日志采集，Grafana 可直接搜索容器日志	2026-10-28 10:38:41 +08:00
Zhou Weidong	5d139783c9	fix(media): 缩略图唯一索引改为部分索引，避免软删行占用 episode_id 导致登记冲突	2026-10-27 21:07:10 +08:00
Zhou Weidong	ddd2406f32	fix(build): Docker 构建阶段固定阿里云 Maven 中央镜像容器内从 Maven Central 拉依赖时 maven-filtering:3.3.1 解析失败，且 dependency:go-offline 被 \|\| true 静默吞掉，导致发布时才暴露。构建阶段写入 settings.xml 走阿里云 central 镜像，并让 go-offline 失败即中断。	2026-10-27 20:14:19 +08:00
Zhou Weidong	6abb09e5c2	chore(merge): 将 release/v1.0.0 同步到 main	2026-10-23 13:07:42 +08:00
Zhou Weidong	8b37e23951	feat: 印尼语敏感词库种子数据（id-ID 增量补全 78 词）	2026-10-19 18:43:01 +08:00