update golang to 1.27.3

用户反馈「专题里的圆无论怎么缩放大小都一样，20km 却覆盖了整个南宁」。实测
三处画圆（编辑器 L.circle、改半径把手、前台迷雾裁剪圆）**全都是地理锚定的**：
编辑器圆直径 z9/z11/z13 = 178/710/2842px（期望 177/711/2847）、同一缩放下改半径
3/10/25/50km → 42/142/356/710px（期望 43/142/355/711）、把手距圆心 20.038km
（该圆半径 20km）、前台裁剪圆换算始终 ≈20km。也就是**复现不出「大小不变」**。

真正的问题是缺**参照物**：编辑器地图以前没有比例尺（前台专题页一直有），
圈圆时只能靠地名猜。用他自己的数据验证「20km 覆盖南宁」是对的——圆心 20km 内
落了他 477 个地点中的 45 个，最远到西乡塘的广西民族大学相思湖校区（14.5km）
与良庆的五象万象汇（10.2km），正是南宁建成区的跨度。

所以这一版补的是参照物，不改任何几何逻辑：
- 编辑器地图加 L.control.scale（跟前台一致，公制）。
- 半径旁边标出跨度：`spanLabel()` 把半径换成「约 40 公里宽」（<1 公里改用米，
  免得出「约 0.1 公里宽」这种别扭说法）；圆列表每行也标，新圆半径旁边实时跟着变。
- 守卫 TestTopicAreaEditorGivesSizeReference 钉住这两样（变异验证过：去掉比例尺立刻红）。
  它顺手抓到我自己的疏漏——模板的 init 调用漏传了 spanId，靠脚本默认值兜着，已补上显式传参。

验证：topic-areas.test.js 55 条（新增 11 条 spanLabel 边界）；无头实测比例尺在
（z10 显示 10 km）、新圆半径 3→「约 6 公里宽」/25→「约 50 公里宽」实时更新、
圆列表 20→「约 40 公里宽」，全程无 JS 报错。

.gitignore

@@ -1,6 +1,8 @@
 # 构建产物
 /rond
 /rond.exe
+# go build ./... 会按模块名输出到仓库根：漏了这个就会一直当未跟踪文件冒出来
+/rond-with-you.exe
 *.exe~
 /bin
 
@@ -19,7 +21,17 @@
 # 原始备份
 /data/
 .workbuddy/
-.tmp-test/
+# 但「项目记忆」要跟着仓库走：那批判据与教训是给后续会话看的，不该只留在本机。
+# 其余 .workbuddy 内容（计划、本地设置、临时产物）继续忽略。
+# 注意：只放行 memory 下的 .md——**别写成 `!.workbuddy/memory/**`**，
+# 那会把误落盘的 png/exe 一起放行（本项目真发生过 .test.exe 混进暂存）。
+!.workbuddy/
+.workbuddy/*
+!.workbuddy/memory/
+.workbuddy/memory/*
+!.workbuddy/memory/*.md
 
 # 开发期的临时探针/抓取产物（不属于运行时）
 /tmpfog/
+__pycache__/
+*.pyc

.workbuddy/memory/2026-09-14.md

@@ -0,0 +1,238 @@
+# 2026-09-14
+
+## rond-with-you：把 rond 备份变成足迹站点（从零建成可运行版本）
+
+### 背景
+用户提供 `data/20260914_151649.rondbackup`（3.4MB），要求做一个后台可上传该文件、
+前台展示足迹地图 / 类型 / 日期筛选的站点。技术栈由用户指定为 PostgreSQL（本地测试环境
+`postgres / 127.0.0.1:5432`），后端语言 Python 或 Go 自选。
+
+### 备份结构（已实测确认）
+`.rondbackup` 是 zip，内含 Core Data 库 `LifeEasy.sqlite` + `-wal` + `-shm`。
+**关键点：数据几乎全在 WAL 里**（主库 348KB / WAL 3MB），必须三个文件一起解出再打开，
+否则只能读到极少量记录。Core Data 时间戳基准为 2001-01-01 UTC。
+
+主要表与本次数据量：`ZVISIT` 824、`ZLOCATION` 323、`ZRAWVISIT` 2246、`ZMOVEMENT` 791、
+`ZACTIVITY` 30、`ZHOURLYWEATHER` 557、`ZTAG` 8、`ZTRANSPORT` 5、`ACHANGE` 4810（未导入）。
+标签关联表命名规则为 `Z_<实体号>TAGS_`，如 `Z_11VISITS_` = Visit↔Tag（11=Tag，18=Visit）。
+
+导入结果：823 条到访（跳过 1 条到达时间缺失的空记录）、323 地点、8 标签关联、791 位移、
+557 天气；跨度 2025-02-10 ~ 2026-09-13，估算里程 16861.9km，城市 9 座 / 省份 2 个。
+
+### 技术选型
+- Go 1.25 + 标准库 net/http + html/template（未引入 Web 框架）
+- PostgreSQL + `pgx/v5`；备份解析用纯 Go 的 `modernc.org/sqlite`（无 cgo）
+- 前端手写 CSS，Leaflet + markercluster 本地内置（无 CDN 依赖）
+- 口令 PBKDF2-SHA256（标准库 `crypto/pbkdf2`）；会话为 HMAC 签名 Cookie，
+  签名混入口令摘要前缀，改密即让旧会话失效
+
+### 踩过的坑（都已修复）
+1. `//go:embed static` 的资源路径相对包目录，原放在仓库根的 `web/` 下会编译失败，
+   已移动到 `internal/web/{templates,static}`。
+2. 地点查询用 `WHERE ... EXISTS (SELECT ... visits v` + `inner.SQL()[7:]` 拼接，
+   切片把 `WHERE` 关键字一起去掉了，导致 `SQLSTATE 42601`。改为 `inner.expr()` 并给
+   子查询占位符加偏移（`where.off`），避免与外层 `$1` 冲突。
+3. 模板函数 `dur` 形参写死 int64，而 `VisitRow.DurationMin` 是 int，渲染时报
+   "wrong type for value"，改成接受 `any`。
+4. 页面模板若共用 `templates/*.html` 一次性 ParseFS，各页 `{{define "content"}}`
+   会互相覆盖；改为每个页面与 layout 单独组成模板集。
+5. 月度图表只查有数据的月份，会把空档压缩掉；改为补齐成连续月份序列并标注年份。
+6. 移动端导航会折行撑坏布局，窄屏改为隐藏站点名、导航横向滚动、按钮文案缩短。
+   地图缩放/图层控件在窄屏改挂右下角，避免与全宽筛选面板重叠。
+
+### 环境备忘
+- `GOPROXY=https://goproxy.cn` 可用；`proxy.golang.org` 不通
+- jsdelivr 可下载前端库；高德瓦片 `webrd0X/webst0X.is.autonavi.com` 可直连
+- playwright-cli 通过 `npx --yes @playwright/cli@latest` 调用；**浏览器进程会在两次
+  bash 调用之间被回收**，open / goto / screenshot 必须放在同一次调用里
+
+---
+
+## 第二轮：地图偏移 + 重复导入 + 隐私默认 + 底图配置（P0/P1 收尾与回归）
+
+### 坐标结论（已实测，写进 README 了）
+rond 入库的 `ZLOCATION` / `ZRAWVISIT.ZLATITUDE` **本来就是 GCJ-02**，不是 WGS-84。
+证据两条：① 2246 个采样点「解析坐标 − 原始 GPS」中位差 lat −0.002823 / lon +0.004187，
+与 GCJ-02 理论偏移（−0.002825 / +0.004187）残差 0 米；② 与世界迷雾覆蓋比对，
+逆 GCJ→WGS 后命中率 92.3%，直接用原始值只有 32.8%。
+→ 高德 / 天地图这类 GCJ-02 底图**直接画，不要再纠偏**；只有 WGS-84 底图才做 GCJ→WGS 逆变换。
+旧代码对每个点都套了一次 `gcj()`，所以叠了约 1.1km 的双重偏移。
+
+### 底图配置
+`conf/app.ini`：`map_provider` = amap（默认免密钥）/ tianditu（需 `map_key`）/ custom
+（需 `map_tile_url` + `map_crs`）。填了 `map_key` 后瓦片走服务端代理 `/tiles/{layer}/{z}/{x}/{y}`，
+密钥不出现在页面源码；无密钥则浏览器直连。前端读 `/api/map-config` 拿 `crs` 决定要不要逆变换，
+切换底图时重新投影已有标记。
+
+### 本次修掉的三个 bug（都是实测复现过的）
+1. **瓦片代理子域写死 0** → 高德子域只有 01~04，`webrd00` / `wprd00` 根本不解析。
+   改为按 `(x+y)%count` 轮转，高德 1..4、天地图 0..7。代理模式实测 4 张瓦片全部 200。
+2. **`Stats.Skipped` 从未赋值**（`ingest.go` 构造 Stats 时漏了字段）→ 「已跳过 N 条」
+   与「内容完全重合」两个提示全是死代码。补上后实测提示正常。
+3. **`movements` INSERT 不写 `user_id`** → 位移永远无法去重（重导入 791 条变 1582 条），
+   且下次启动时迁移的回填 UPDATE 会撞上 `idx_movements_dedupe`，**整个站点起不来**
+   （`SQLSTATE 23505`，实测复现）。已补 user_id + `ON CONFLICT DO NOTHING`，
+   并把迁移里三个回填 UPDATE 各自包进 `EXCEPTION WHEN unique_violation`，保证迁移再也不会拖垮启动。
+
+### 数据集模型：已定「快照式」并落地（用户在两个方向里选了快照式）
+「自然键跨数据集全局去重」与「一次上传 = 一份完整数据集」互相矛盾：全局去重下，更新备份里的
+新记录只会落进未激活的数据集，页面上完全看不到（已实测：删 1 条后重导，新记录进了
+`is_active=f` 的数据集 #2，页面仍显示 822 条）。
+
+最终实现（快照式 B+）：
+- 一份备份 = 一份完整快照，行级唯一性只靠各表自带的 `UNIQUE (dataset_id, src_pk)`
+- `schema.sql`：`DROP INDEX idx_visits/movements/weather_dedupe`（迁移里清理旧索引），
+  `datasets` 加 `content_hash` 并建 `(user_id, content_hash)` 索引
+- `ingest.Import`：先按 `contentHash(b)`（到访自然键排序后 sha256）查重，命中就复用旧数据集
+  并返回 `Stats.Identical=true`；否则建新快照，最后 `UPDATE datasets SET is_active=(id=$1) WHERE user_id=$2`
+  让最新快照接管展示
+- `handlers_admin.go`：同 SHA 重复上传改为「已导入过，未重复导入」并顺手删掉刚落盘的文件
+  （顺带修了删除数据集不删上传文件的 P2）；提示语明确写「已切换为当前展示」
+- 回归全绿（一次性库实测）：首导 823 / 同文件复用 / 内容同字节不同的复用 / 含 1 条新到访的
+  备份 → 新快照 #2 824 条接管展示，页面上新记录可见
+- 已知小尾巴：存量数据集的 `content_hash` 是 NULL，无法识别与它的内容重复，只影响第一次
+  重传；后续上传正常
+- 交叉编译产物 `dist/rond-linux-amd64` 已同步重编
+
+### 回归验证配方（可复用，别动真实库）
+1. 建一次性库：`CREATE DATABASE rond_dedup_test`
+2. 写 `conf/app.test.ini` 指向它、`listen = :8090`、独立 upload/data 目录
+3. 首次启动自动建表并生成 `admin / rond-admin`
+4. `curl -X POST -d "username=admin&password=rond-admin" .../admin/login` 拿 cookie
+5. `curl -b <jar> -F "[email protected]" .../admin/upload`，提示语在 303 的
+   `Location` 头里（URL 编码，`urllib.parse.unquote` 解一下）
+6. 造「内容相同但摘要不同」的备份：用 python `zipfile` 按原条目重打包即可换 SHA
+7. 收尾：kill rond.exe → `DROP DATABASE` → 删 `conf/app.test.ini` 与测试目录
+
+### 其他备忘
+- `go build ... | head -20 && echo OK` 会**掩盖编译失败**（管道退出码来自 head），别这么判成功
+- Windows 上用 python 写 `/tmp/x` 会落到 `C:\tmp`（和 Git Bash 的 /tmp 不是一处），
+  尽量写项目内路径
+- 后台删除数据集只删 DB 行，`storage/uploads/` 里的原始文件会留在磁盘上（P2，待清理逻辑）
+
+### 世界迷雾叠加（已全部落地并验证）
+- `internal/fog`（fog.go 解码/编码、store.go 内存索引+Import(merge)、render.go 瓦片渲染）
+- 端到端：Go 解码与 Python 原型一致（52 tile / 8701 块 / 575753 格），编码回环无损（299112B）
+- 路由：`POST /admin/fog`（mode=overlay|cover）、`GET /admin/fog/export`、`GET /tiles/fog/{z}/{x}/{y}?crs=`
+- 前端：mapConfig 下发 fog 统计，rond-map.js 图层控件加「世界迷雾」，切底图自动换 crs 重拉
+- 渲染两坑：① 低缩放级按全球块范围双循环 = z0 卡死 43 亿次 → 改为遍历块表+粗裁剪
+  ② `image.RGBA` 是预乘 alpha，直写颜色被 png 编码器除回 alpha 变绿 → 用 `image.NRGBA`
+- 对齐验证：足迹点 WGS 格位图已点亮；gcj02 渲染像素与足迹点像素偏差 0.0px（数学）；
+  z15 近景合成图迷雾沿道路分布、红点落在迷雾格上（视觉）
+- 测试：overlay 删块恢复 ✓、cover 清空重导 ✓、导出→再导入格数不变 ✓
+- 测试配置留在 `conf/app-test.ini`（已 gitignore）；主站 8080 还是旧二进制，重启后才有迷雾功能
+- 19:07 主站已用新二进制重启（后台任务），真实库迁移出 fog_blocks ✓，fog 瓦片/配置接口正常；
+  真实库尚未导入迷雾，等用户在后台传 .fwss
+- 整体检查：build/vet 零问题；仓库历史文件是 CRLF 行尾（gofmt 全文件 diff），只有 internal/fog
+  做了 gofmt；fog.go 里多余的 filepath_Base 已换成 filepath.Base
+
+### P1+P2 六个功能（19:18-19:38 全部落地并冒烟通过）
+- 迷雾覆盖统计：fog.CellOf/AreaKm2/Index.CellLit + web/fogCoverage，stats 页新区块；
+  坑：SQL 少写一列但 Scan 五个目标 → 静默返回 nil（区块不显示），已修
+- 行程轨迹：/api/track（movements+places 起终点，5000 段上限），map.html 行程轨迹开关，
+  rond-map.js setTrack，随底图坐标系重投影
+- 到访热力：vendor leaflet-heat.js（unpkg 0.2.0），map.html 热力开关 + setHeat，权重=到访次数
+- 年度报告：/report?y=，Nav 新增「报告」，report.html（KPI+城市榜+南北两端+交通）
+- 数据导出：/admin/export/places.{geojson,gpx}，全量地点含家/工作（站长本人数据），
+  GCJ-02 原样导出并在 properties 注明 crs
+- PWA：manifest.webmanifest + PIL 生成的爪印图标 192/512 + layout head meta
+- 验证：测试库（rond_exp_test，已删）验导出 323 features/323 wpt、迷雾覆盖 47.8km²、
+  河池 43/93 等；主站 6 条路由全 200
+- 所有 Go 文件已 gofmt（含 LF 行尾归一，为将来 git init 首提交做准备）
+
+### 三个增强功能（20:00-20:45 全部落地并验证，主站 8080 已用最终二进制重启）
+- **OSM 免密钥兜底**：高德瓦片 tileerror≥8 次前端自动切 OSM + toast； clarification：Leaflet 是渲染库
+  不是瓦片源，高德本来就是免 key 直连默认底图
+- **公开页面开关**：settings 保存 `pages`（map/places/timeline/stats/report），guardPage 中间件
+  对匿名访客 404，管理员放行，导航同步隐藏；实测 anon /stats=404、admin /stats=200
+- **TOTP 两步验证**（internal/auth/totp.go + handlers_admin.go）：RFC 6238 HMAC-SHA1 30s ±1 窗口；
+  两步登录中间令牌 `2fa|uid|exp|mac`（绑定口令摘要，改密失效，5 分钟）；关闭 2FA 也要求新鲜验证码。
+  全流程实测通过：绑定→确认→登出→密码登录→动态码→/admin 200；负例（错码/篡改令牌）均被拒；
+  关闭后登录免第二步 ✓
+- **两个坑**：① TOTP 计数器曾用 `t.Unix()/int64(30*time.Second)`（除以 300 亿），改 `unixSec/30`；
+  ② login2FA 曾用 `SplitN(pending,"|",2)[0]` 取 uid（取到的是 "2fa" 前缀），改 `parts[1]`
+- **测试方法坑（重要）**：html/template 会把属性值里的 `+` 转义成 `&#43;`（防 UTF-7），curl 从 HTML
+  抠隐藏字段直接回传会验签失败——浏览器会解码实体，这不是产品 bug。测试脚本要先 `sed 's/&#43;/+/g'`
+- 验证用测试账号：首次启动自动生成 admin/rond-admin（README 有写）
+- 清理：rond_2fa_test 库已 DROP、conf/app-2fa.ini 与 .tmp-test/2fa 已删；conf/app-test.ini 保留
+  （gitignored，回归配方用）
+- venv 的 python.exe 在 `envs/<name>/Scripts/python.exe`（不在根目录），用户记忆里写的 sss 环境可用
+
+
+### 口令重置（21:05）
+- 主站真实库（rond_with_you）的 admin 口令早已改过，默认 rond-admin 只对空表新库生效
+  （EnsureDefaultUser 见 users 非空即跳过）；用户忘了旧口令，用项目内 auth.HashPassword 写了一次性
+  重置程序（.tmp-test/resetpw，用后已删）把口令恢复为 rond-admin，curl 实测登录 303→/admin 200 ✓
+- 改口令会同时让旧会话失效（session MAC 混入口令摘要前缀）——实测无异常
+- 遗留建议（P2，未实施，等批准）：默认账号首次登录时页面没有任何「请修改默认口令」的提示，
+  README 有写但站点不强制；可考虑 EnsureDefaultUser 建的账号加个首登 flash 提示
+
+### 默认口令警示 + 迷雾后台管理增强（22:30-22:45，主站已重启生效）
+- adminHome 检测 admin 口令仍为 rond-admin 时，后台首页顶部渲染警示条（含改密/2FA 链接）；
+  实现：AdminData.DefaultPW = auth.VerifyPassword(p.User.Hash, "rond-admin")，仅后台首页每次渲染时验证一次
+- 迷雾卡片增强：空态引导（尚未导入提示）、块/格/估算面积/最近更新时间（fog_blocks.max(updated_at)，
+  sql.NullTime + 模板函数 dtt 接受 *time.Time）、「清空迷雾」按钮（POST /admin/fog/clear，confirm 后
+  DELETE FROM fog_blocks + fogResetIndex() 换掉内存单例索引）
+- 模板函数注意：text/template 调函数时指针参数不会自动解引用，可空时间字段要么加 *T 版本函数，
+  要么模板里 if 判空后用 deref
+- 安全全链路实测：导出(299112B)→清空→空态→cover 重导→8701 块/575753 格/47.8km² 完整还原，瓦片 200
+- 用户真实库迷雾是用户 22:26 自己在后台导入的（说明迷雾 UI 其实可用，只是缺状态展示让人困惑）
+
+### 迷雾可视化 A+C + 传输层性能优化（23:50-00:25，主站已重启生效）
+- 迷雾配色改高对比：填充 #307ae0 a=132、边界 #103484 a=232；render.go 改为两遍渲染
+  （先填 mask，再按四邻域判定填充/描边），瓦片外邻格按「已探索」处理以免接缝处出现网格伪影。
+  实测贵阳 z12 瓦片：填充 5572px / 轮廓 663px ✓
+- 前端加「迷雾浓度」滑杆（L.Control + localStorage rond.fogOpacity，默认沿用图层 opacity 0.9）
+- 性能：新增 internal/web/gzip.go（gzip 池 + 首字节判 content-type，PNG 透传）；
+  assets.go 计算静态文件哈希作 assetVersion，cacheStatic 对 ?v=匹配者给 immutable 一年；
+  /map 不再内联 points（58.6KB→12.5KB，gzip 3.1KB）改走 /api/points；leaflet-heat 改为
+  首次勾选热力图时动态加载（ensureHeat）
+- 实测：/stats 38.3→5.4KB、/api/track 38.9→6.7KB、/report 6.3→2.0KB
+- 坑：模板函数传 *time.Time 不会自动解引用（另见上条）；server.go 里 gzip 是包级函数不是 Server 方法
+
+### 访客可见区域白名单 + 地点别名/备注（01:00-01:30，主站已重启生效）
+- 区域白名单：setting.Settings.Regions（省/市/区任意层级）；stats.Filter.Regions 在 visitsWhere 里
+  生成三段 IN 条件（province/city/district 各一份占位符）；filterOf 里仅 `!p.IsAdmin()` 时注入，
+  因此地图/地点库/时间线/统计/报告全站生效、管理员全量。
+  实测：设「贵阳市」→ 匿名 73 点全为贵阳，管理员 283 点 ✓（测完已清空）
+- 地点备注：新表 place_notes(user_id, src_pk, alias, note)，按 src_pk 而非 places.id 存，
+  重传备份不丢；internal/notes 包（All/Save，空则删记录）。Place 加 SrcPK/Alias/Note 三个字段，
+  placeCols 末尾追加 p.src_pk（scanPlace 同步）
+- 显示约定：别名对外替代原名（applyNotes 里直接改 Name，各页面/地图气泡自动生效），
+  备注仅管理员可见（applyNotes 传 admin 标志）
+- 坑：applyNotes 传切片，单地点场景必须 `ps := []stats.Place{place}; ...; place = ps[0]`，
+  直接传字面量切片改不到原值
+- 后台设置页新增「访客可见区域」textarea（一行一个），保存时按行 trim 去空
+
+### 备注可见性开关 + 后台备注管理页（01:25-01:35，主站已重启生效）
+- setting.Settings.NotesPublic（notes_public，默认 false）；applyNotes 参数由 admin 改为 showNote
+  = p.IsAdmin() || p.Settings.NotesPublic，别名始终对外、备注按开关
+- 新增 GET /admin/notes（notesPage + templates/admin/notes.html）：LEFT JOIN places 取地点名/城市/到访数，
+  支持 ?q= 搜索（别名/备注/地点名 ILIKE），每行就地保存/删除（删除=提交空值，Save 会自动删记录），
+  按 Referer 判断保存后回管理页还是后台首页
+- 后台首页导航与地点详情页都已挂入口
+- **事故与修复**：用 curl 单字段 POST /admin/settings 测区域白名单时，未提交 pages 字段导致
+  「公开页面」被清空（/map 等全部 404）。教训：settingsSubmit 是整体覆盖，任何脚本化测试都必须
+  把 pages/modules 等字段一并回传；已用全字段 POST 恢复
+- Git Bash 里 `curl -o /dev/null` 偶发 exit 23（写入失败），改成 -o 文件更稳
+
+### 四个增强功能 F1–F4（20:5x 收尾，主站已重启实测）
+- F1 出行方式配色：apiTrack 返回 `modes` 图例（空方式归「步行/其他」灰色 #8e8e93），
+  rond-map.js 渲染图例；实测 `modes:[步行/其他 370, 电🐔 317, 地铁 22, 高铁 21, 公交 17, 火车 9]`
+- F2 城市级聚合 + 首次到达里程碑：
+  - 地图 `/api/cities` 按城市聚合到访/时长/首次(last)日期，圈大小随到访量；已剔除家/工作
+  - 报告页「🏅 首次到达的城市」里程碑：firstArrivalCities 查「有史以来首次到访落在本年」的城市
+    （HAVING min(arrival) in [from,to)），按日期升序；区域白名单对访客同样生效
+  - **实测发现并修复的 bug**：apiCityAgg 原 SQL 写 `AND NOT p.is_home AND NOT p.is_work`，
+    但 is_home/is_work 是 visits 列、places 表没有 → `SQLSTATE 42703` 直接 500。
+    改为 `NOT EXISTS (SELECT 1 FROM visits vh WHERE vh.place_id=p.id AND (vh.is_home OR vh.is_work))`
+  - 报告页已验证 2025 年出现里程碑、/api/cities 返回 9 城带 first/last 日期
+- F3 年度报告长图/PDF 分享：ReportData 加 Cities []CityMilestone；报告页加「复制链接」(`navigator.share`
+  优先、否则 clipboard) + 「保存为 PDF」(`window.print()`)，app.css 加 `@media print` 隐藏导航/页脚/按钮、
+  卡片 break-inside:avoid。注：长图用浏览器打印生成 PDF（未接 html2canvas），README 已注明该取舍
+- F4 从 GPX 补充轨迹：internal/gpx 解析 trk/trkseg/rte（WGS-84）；adminGpxUpload 存 gpx_tracks，
+  apiGpx 按 crs=gcj02 把 WGS-84 转 GCJ-02 对齐高德底图；地图橙色叠加
+  - **修复**：gpx.Parse 原来 `if len(out)>0 return` 在已有 trk 时直接返回、丢掉 rte；改为 trk 与 rte 都追加
+  - 实测：登录 admin/rond-admin → 上传含 trk+rte 的测试 gpx → /api/gpx 返回两条轨迹（测试数据已删除）
+- 验证手段：`go build` + `go vet` 全过；主站后台起、curl 实测各 API 与报告页；测试轨迹上传后清理
+- README 已把 F1–F4 从「后续可以做的」挪到已实现章节，并补 GPX/城市聚合/报告分享说明

.workbuddy/memory/2026-09-15.md

@@ -0,0 +1,613 @@
+# 2026-09-15
+
+## rond-with-you：修复静态资源被截断（ERR_CONTENT_LENGTH_MISMATCH）
+
+### 现象
+浏览器控制台大量报错，页面样式/脚本失效：
+```
+GET /static/vendor/leaflet/leaflet.css?v=... net::ERR_CONTENT_LENGTH_MISMATCH 206 (Partial Content)
+GET /static/css/app.css?v=...              net::ERR_CONTENT_LENGTH_MISMATCH 206
+GET /static/js/rond-map.js?v=...           net::ERR_CONTENT_LENGTH_MISMATCH 206
+Manifest: Line 1, column 1, Syntax error.
+Uncaught TypeError: Cannot read properties of undefined (reading 'preview')   ← home.html 里 window.rondMap.preview(...)
+```
+
+### 根因（两层，缺一不可）
+gzip 中间件（internal/web/gzip.go）与 `http.FileServer` 冲突：
+1. **206 层**：浏览器对 `immutable` 缓存的静态资源会发 `Range` 请求 → `http.FileServer` 返回 206 并自带
+   `Content-Length`；gzip 无法在首部提交后再改长度 → 长度不符，文件被截断。
+2. **200 层（更隐蔽）**：`http.FileServer`(`serveContent`) 对**任何**请求都是 **先设 `Content-Length`、
+   再显式调用 `WriteHeader(200/206)`、最后才写 body**。原 `gzipWriter` 没有覆盖 `WriteHeader`，
+   所以 `WriteHeader(200)` 已经把 `Content-Length: <未压缩长度>` 提交出去；等到 `Write` 里才
+   `Set("Content-Encoding","gzip")` + `Del("Content-Length")` 全都太晚 → 响应既没有 Content-Encoding、
+   又声明了未压缩长度，body 却是 gzip → 浏览器按声明长度读不到那么多字节 → 截断。
+   （动态页面 `s.render`/`s.json` 不显式 WriteHeader、也不设 Content-Length，所以一直是好的——
+   这解释了「页面 HTML 正常、静态 CSS/JS 全坏」。之前重编译后 `?v=` 哈希变化强制重新拉取才暴露。）
+
+### 修复（internal/web/gzip.go）
+- **给 `gzipWriter` 增加 `WriteHeader` 覆盖**：在首部提交*之前*决定压不压。
+  只有 `200` 且 `compressible(Content-Type)` 才设 `Content-Encoding: gzip` + `Del Content-Length`；
+  `206/304/404/500` 等一律原样透传（自带长度语义，不能压）。
+- `Write` 路径保留「无显式 WriteHeader 时按首字节推断 Content-Type」的逻辑；`gz` 改懒初始化。
+- `gzipHandler` 额外加一道 `Range != ""` 直接透传的守卫（双保险）。
+
+### 验证（curl 实测，全部通过）
+- 普通静态请求：`200 + Content-Encoding: gzip`、**无 Content-Length**、body 解压后 = 完整 21587B ✓
+- Range 请求：`206`、`Content-Length: 100` = 实际 100B、无 Content-Encoding ✓
+- `curl --compressed` 全量拉 app.css = 14643B（完整）✓；manifest 解压后是合法 JSON ✓
+- PNG 图标：`200 + image/png + Content-Length: 1492`、无 Content-Encoding（透传未被压）✓
+- 首页 `--compressed` = 99259B 完整 HTML；`/ /map /report /stats /places /timeline /api/cities /api/track` 全 200 ✓
+
+### 教训
+Go 里做 gzip 中间件，**必须覆盖 `WriteHeader`**，否则任何「先 WriteHeader 再写 body」或
+「显式设置 Content-Length」的 handler（典型如 `http.FileServer`/`http.ServeContent`）都会踩坑。
+压缩决策要在首部提交前完成，不能拖到第一次 `Write`。
+
+---
+
+## 推荐 / 踩雷 投票 + 备注批量管理（A/B/C 三批次，均实测）
+
+### 需求 & 决策（用户拍板）
+- 备注与「踩雷 / 推荐」分开：踩雷/推荐改成按钮式，统计里单独计。
+- 投票主体：**站长官方结论 + 访客投票计数并存**；展示：**详情 + 地点库 + 地图**；
+  备注管理：**改为「全部地点可编辑」**（含新增 / 批量）。
+
+### 数据模型（internal/db/schema.sql）
+- `place_votes(user_id, src_pk, verdict, updated_at)`：站长结论，verdict 1 推荐 / -1 踩雷，单值。
+- `place_visitor_votes(src_pk, voter_key, vote, updated_at)` PK(src_pk, voter_key)：访客一人一票。
+- 都按 src_pk 存（与 place_notes 一致），换快照不丢。
+
+### 批次 A：投票后端 + 详情页卡片
+- 新包 `internal/votes`：Verdicts/Verdict/SaveVerdict、Tallies/Tally、Voter、Cast
+  （Cast 逻辑：没投过→插入；投同一票→**撤销**；投另一票→改票）。
+- `internal/web/handlers_vote.go`：`voterKeyFromRequest` / `ensureVoterKey`（cookie `rond_voter`
+  + IP 一起 sha256 取前 16 字节作 voter_key，清 cookie 也认同一来源，轻度防刷）；clientIP 取 XFF。
+  `apiVotes`(GET /api/votes)、`apiVote`(POST /api/vote)、`adminPlaceVote`(POST /admin/place/vote)。
+- setting 加 `MarksPublic`（marks_public，默认 true）+ 设置页勾选项。
+- 详情页 place.html：备注卡片下独立「推荐 / 踩雷」卡片；站长区是**表单**（提交即刷新，无需 JS），
+  访客区是 AJAX 投票（就地刷新票数）；备注框删掉「踩雷还是推荐」占位文案。
+- 实测：匿名看不到站长控件、管理员可标结论、访客投票 up→撤销→down 正确。
+
+### 批次 B：地点库 / 地图 / 统计
+- `stats.Filter` 加 `Verdict`，`stats.Places` 用 `EXISTS(place_votes ...)` 支持按结论筛选
+  （占位符接在内层条件之后，args 复用）。
+- `stats.Place` 加 Verdict/Up/Down；`web.attachVotes` 查询后填充（按 src_pk）。
+- Page 加 Verdict 字段 + filterPairs + `VerdictLink`；places.html 加标记筛选 chips + 行内徽章。
+- MapPoint 加 `sp/vd/u/dn`（omitempty）；rond-map.js popup 显示结论与票数。
+- stats.html 加「推荐 & 踩雷」区块（VoteRec/VoteAvoid/VoteUp/VoteDown + 两个榜单）。
+- 实测：列表徽章、?verdict=±1 筛选、统计区块、api/points 字段全部正确。
+
+### 批次 C：备注管理页重写
+- 数据源从 place_notes 改为「places LEFT JOIN place_notes LEFT JOIN place_votes」，
+  筛选 q/status(all|has|none)/city/sort(visit|note|talk|name) + 分页(50/页)；
+  底部单列「孤儿备注」（src_pk 已不在当前数据集）。
+- NotesData 加 Orphans/CityOptions/Status/City/Sort/BackURL + `PageLink` 方法（保留筛选）。
+- 端点：`POST /admin/notes/bulk`（action=delete|clear|verdict）；notes 存储加 `SetNote`(保留别名) / `Delete`。
+- notes.html 重写：**关键点**——批量复选框用 `form="bulk-form"` 关联到独立的批量表单，
+  避免「批量表单」与「每行编辑表单」嵌套（HTML 不允许嵌套 form）；行内保存/打标用同一表单 +
+  `formaction` 分流到 /admin/place/note 或 /admin/place/vote。
+- adminPlaceNote 优先用表单 `next`（带完整筛选）回跳，其次 Referer。
+- 实测：323 地点全列出、status=has/none 筛选、行内保存、批量设置结论/清空备注(保留别名)/删除 全部正确。
+
+### 踩坑
+- 嵌套 `<form>` 不合法：用 HTML5 `form="id"` 属性把行内复选框关联到外部批量表单，可绕开。
+- `omitempty` 会让 0 值字段（vd/u/dn）从 JSON 消失，grep 校验时要注意，别误判为没数据。
+- 内网 Git Bash `curl -o /dev/null` 在多命令 `&&` 链里偶发 exit 23 中断后续命令，改用 `-o 文件`。
+
+---
+
+## 投票前移到地图气泡 + 备注只读展示 + 备注保存回跳（实测通过）
+
+### 需求（用户原话要点）
+1. 点赞/点踩直接放到地图上点开的那个气泡里，属快速交互，不必再进详情页。
+2. 地图气泡：**登录时显示「我的结论」**（站长的 👍/👎），**未登录显示「大家怎么说」**（票数）。
+3. 顺带解决：在详情页输入备注但未提交时去点点赞点踩，会把备注框内容冲掉。
+4. 备注内容要能在气泡里直接看到（只读，不用编辑）。
+5. 提交备注后跳到 `/admin?ok=备注已保存`，与来源页无关，要跳回原处。
+
+### 实现
+- **后端**
+  - `MapPoint` 加 `Note string json:"note,omitempty"`，`toPoint` 带上 `p.Note`（备注是否可见仍由
+    `applyNotes(..., IsAdmin || Settings.NotesPublic)` 把关，访客在 `notes_public=false` 时拿不到）。
+  - `votes.VoterAll(ctx, voterKey) map[int]int`：一次取回该访客投过的全部票，供地图标「我投的」。
+  - `votePayload` 加 `Admin` / `Public` 两个布尔；`apiVotes` 填充（`userFrom(ctx)!=nil` 为 admin）。
+    前端据此决定气泡里渲染「我的结论」还是「大家怎么说」，不用在页面里另塞全局变量。
+  - 新增 `POST /api/verdict`（`requireAdmin` → `apiVerdict`）：气泡里 AJAX 设站长结论，不刷新页面。
+    *注意*：handler 用 `r.PostFormValue`，参数必须走 **POST body**（`ParseForm` 不把 query 并进 PostForm）。
+- **前端 `rond-map.js`**
+  - 新增模块级 `voteData/voteMeta/voteLoad` + `loadVotes()`：进地图取一次 `/api/votes`，
+    气泡渲染时同步查表，不为每个点单独发请求；到货后 `repaintVotes()` 刷新已打开的气泡。
+  - `popup(p, vote)` 改为**构造 DOM 节点**；`bindPopup(function(){ return popup(p, vote); })` 用函数式内容
+    （已验证 vendored leaflet 支持 `_content?this._content(this._source||this...)`），这样每次打开都重算
+    「我投的」，避免字符串闭包里的陈旧票数。
+  - 气泡结构：`.mp > .mp-n / .mp-m / .mp-note(white-space:pre-line 只读直出) / .mp-foot` +
+    `.mp-vote`（`.mp-vl` 标签 + `.mp-vb` 按钮）。管理员点已选中按钮 = 取消（`verdict=0`）。
+  - `markers(points, crs, useCluster, vote)` 多一个 `vote` 参数，`state4` 存 `this.vote` 并透传给
+    `apply()`，`setPoints` 也传 true —— **切底图坐标系重画标记时必须带上**，否则表决区会消失。
+- **详情页 `place.html`**
+  - 备注表单加 `<input type="hidden" name="next" value="/places/{{.Place.ID}}">` → 保存后跳回本页
+    （`/places/49?ok=备注已保存`），并在卡片里渲染 `.Flash`（`placePage` 只在 IsAdmin 时读 `?ok=`）。
+  - 站长结论从「表单提交」改为 AJAX（`POST /api/verdict`）：原来提交会整页刷新，把没保存的备注冲掉，
+    这正是需求 3 的根因。
+  - 删掉不再使用的 `.vote-form` CSS。
+- 顺手修：`full()` 原本没有 `return`，`map.html` 里 `window.__map = window.rondMap.full(...)` 一直是
+  `undefined`（虽无人读）。现在 `full()` 返回 Leaflet map。
+
+### 验证（本机 Chrome + CDP 真实点击，非静态推断）
+- 管理员：气泡显示备注「测试」+「我的结论」+ `👍 推荐[选中]`；点 👎 → 气泡立即变 `👎 踩雷[选中]`，
+  `/api/votes` 变 `{"49":-1}`；点 👍 回到 `1`。无 JS 报错。
+- 访客（清 cookie）：`admin:false`，气泡显示「大家怎么说」`👍0 👎1`；点 👍 → `👍1[选中]`，再点 → 撤回 `👍0`。
+  备注 `noteText=None` —— `notes_public=false`，访客确实拿不到，符合预期。
+- curl 侧：备注保存 303 → `Location: /places/49?ok=备注已保存`；匿名 `POST /api/verdict` 被 requireAdmin 拦（303）。
+
+### 环境经验（踩坑）
+- **`agent-browser` 在本机卡死**（`open` 挂了 7+ 分钟无输出，估计要 `agent-browser install` 下 Chromium）。
+  更省事的路子：本机 Chrome 已装，直接起
+  `chrome.exe --headless=new --remote-debugging-port=9333 --remote-allow-origins=* --user-data-dir=<tmp>`
+  再用 Python `websocket-client` 走 CDP（`Runtime.evaluate` / `Network.setCookie` / `Page.navigate`）。
+  必须加 `--remote-allow-origins=*`，否则 WS 握手 403。
+- 测试脚本要**轮询等待**而不是固定 sleep：`setView(17)` 让聚合散开后 `openPopup()` 才有效，
+  并且要重试直到 `.leaflet-popup .mp` 真的出现在 DOM 里（否则偶发抓不到气泡）。
+
+### rond 备份备注 → 地点备注（回填，实测通过）
+- 取证：rond 的备注在 `ZVISIT.ZREMARK_` → `visits.remark`，**per-visit**。当前活动数据集 14 条、
+  覆盖 12 个地点（`src_pk=286`「上班」3 条：拿快递 / 充电 / 充电）；`place_notes` 本来只有 1 行。
+- 用户拍板：① 多条**全部保留，每条一行带日期**（去重）；② 覆盖但**旧内容追加在后面**；
+  ③ **导入时自动 + 备注页手动按钮**。
+- 落地方案：**单独一列 `place_notes.rond_note`** 存回填结果。
+  这是唯一能同时满足「幂等 + 不销毁手写内容 + rond 在前」的做法：回填只重写这一列，
+  手写 `note` 一个字都不动，展示时 `joinNote(rond, hand)` 按「rond + 空行 + 手写」拼接。
+  （若直接往 `note` 里追加，每次重跑都会把上一次的结果再追加一遍，无限膨胀。）
+- `notes.BackfillRond(ctx, userID, datasetID)`：
+  - 汇总 SQL 两层去重——`DISTINCT (src_pk, line)`，`line = to_char(arrival,'YYYY-MM-DD') || ' ' || btrim(remark)`，
+    再 `string_agg(line, E'\n' ORDER BY day, line)`。同一天写的同一句只留一条。
+  - 顺带把「备注已从 rond 删掉」的地点清空（幂等），且**限定在本数据集的地点内**：
+    `dataset_id` 不合法时子查询为空 → 一行都不动，不会误清别的数据集。
+  - 不写 `updated_at`（那是手写备注的编辑时间）。日期用**完整 YYYY-MM-DD**：数据跨 2025/2026，MM-DD 会歧义。
+- `notes.Save`：两者都空时不再无条件删行——先 `DELETE ... AND rond_note=''`，再
+  `UPDATE SET alias='',note=''`。这样批量「清空备注」不会把 rond 那一块一起清掉。
+- `web.applyNotes` 用 `joinNote` 拼装展示值（详情页/地点库/地图气泡/接口都走这里）。
+- `notesPage`：搜索加 `n.rond_note ILIKE`；`status=has|none` 与 `HasNote` 都把 `rond_note` 算进去。
+  行内多一块 `来自 rond：...`（`.note-block`，`white-space: pre-line`）。
+- 触发点：`adminUpload` 导入成功后回填（并在 flash 里报「已从 rond 备注回填 N 个地点」）、
+  `adminActivate` 切换数据集时重算、`POST /admin/notes/rond` 手动按钮。
+- `PlaceData` 拆成 `MyNote`（编辑框里的手写内容）+ `RondNote`（只读展示），
+  详情页站长卡片把 rond 那一块单独列在表单上方——**否则编辑框里会看到拼好的全文，一保存就把 rond 行也写进手写备注**。
+- 实测：手动回填 → 12 个地点；`286` = `2026-08-22 拿快递\n2026-08-23 充电`（重复的「充电」已去重）；
+  重跑幂等；手写备注 `和室友一起去的` 保留且排在后（`2025-07-19 拍日月塔\n\n和室友一起去的`）；
+  浏览器实测：气泡 `white-space: pre-line`、2/3 行正确渲染，详情页编辑框只含手写内容、`next` 回跳本页。
+- 遗留：`place_notes` 里 `src_pk=49`（来宾北站）还有一条 `note=测试`，疑似早期测试残留，未擅自删除。
+
+
+
+### 地图气泡尺寸 + 投票按钮重复（本轮修复，实测通过）
+- **气泡太窄 → 推荐/踩雷换行**：真因是 Leaflet `.leaflet-popup` 默认 `maxWidth≈300`，
+  把 `.mp` 挤到 169px。修法：`bindPopup(..., {maxWidth: 360, minWidth: 240})`；
+  并在 CSS 上 `.mp-vl/.mp-vb { white-space: nowrap; flex: 0 0 auto; }` + `.mp-vote { flex-wrap: nowrap; }`。
+  实测桌面 1440 / 移动 390：气泡宽 241px，按钮 top 坐标唯一（不换行）。
+- **详情页站长同时看到「我的结论」+「大家怎么说」**：模板原来把两块都渲染在
+  `{{if or .IsAdmin .Settings.MarksPublic}}` 里。改为：`{{if .IsAdmin}}` 只出「我的结论」+ 只读
+  `访客票数 👍/👎`；`{{else}}` 只出「大家怎么说」。实测站长 `vote-row` 数=1。
+- **同类隐藏 bug（备注页）**：行内 👍/👎 原是 `formaction=/admin/place/vote` 提交，
+  会整页刷新 → 丢掉同一行备注框里未保存的编辑（与详情页同一病根）。改为 AJAX `POST /api/verdict`
+  （`data-verdict-btn` + `data-src`/`data-v`，toast 由 `[data-verdict-status]` 局部更新，不刷新页面）。
+- **`/api/verdict` 取参数**：必须 `r.PostFormValue(...)`（POST body），前端要放 body 不能放 query。
+- **`rond-map.js` `preview(opts)`**：只有 `opts.vote === true` 才 `loadVotes()` + 传 `vote`。
+  否则详情页/picker 里的小地图气泡也会长出投票按钮。`full()` 仍 `vote:true`。
+- 验证方式：headless Chrome + CDP 真点击（见上文环境经验）。全部无 JS 报错。
+
+### 详情页「访客票数」只读行样式统一（本轮，实测通过）
+- 反馈：站长详情页里 `访客票数 👍0 👎0（只读）` 是 12.5px 纯文本 + `margin-top:6px`，
+  比上面「我的结论」那一行（按钮 13.5px、padding 6/14、行高 27.5px）小一圈，看着不整齐。
+- 改法：不再单独搞 `.vote-tally`，直接复用 `.vote-row` 结构——
+  `访客票数` 用 `.vote-label`，两个数字用 `.vote-btn.ro`（`<span>`，只读变体），末尾 `.vote-tip` 放「只读」。
+  CSS 只保留 `.vote-btn.ro { cursor:default; color:var(--text-2); border-style:dashed; background:transparent }`
+  + 覆盖它的 `:hover`（不然会继承 `.vote-btn:hover` 的强调色，像可点）。
+- 实测（CDP 量出来的，不是肉眼看）：两行 `rowH=27.5`、`labelFont=12.5px`、`labelLH=20px`、
+  `margin-top=8px`、按钮字号 13.5px 全部一致；1440 与 390 两种视口都对得上，无 JS 报错。
+- 用虚线边框 + `cursor:default` 区分「不可点」，比整块 `opacity:.55` 干净。
+
+### 无密码状态下登录站长视图（本次新摸出来的路子，很好用）
+- 之前那套 `storage/2fa-cookies.txt` 里的 cookie 是 `uid=1`，但库里根本没有 id=1 的用户
+  （管理员是 `id=2 / admin`），所以带着它访问只会掉进访客分支。
+- 自己签一个会话 cookie 即可，不用知道口令：
+  `token = "<uid>|<exp>|" + base64_raw(hmac_sha256(secret_key, "<uid>|<exp>|" + password_hash[:16]))`
+  - `secret_key` 在 `conf/app.ini`；`password_hash` 用 psql 从 `users` 表取。
+  - 逻辑见 `internal/auth/auth.go` 的 `SignToken`/`mac`（base64 是 **RawStdEncoding，无 `=` 填充**）。
+- CDP 两处坑（补上次的记录）：
+  1. `/json/version` 给的是 **browser** 级 WS，调 `Page.enable` 会报 `-32601 wasn't found`；
+     要用 `/json` 列表里 `type=="page"` 那个 `webSocketDebuggerUrl`。
+  2. `--window-size=390,844` 在 `--headless=new` 下**不会**给出 390 的真实视口
+     （量出来卡片宽 457）。要 `Emulation.setDeviceMetricsOverride(width,height,deviceScaleFactor,mobile=width<=500)`。
+  3. `captureScreenshot(clip=...)` 的 clip 是**文档坐标**，不是视口坐标——滚动过就要
+     `rect.y + scrollY`，否则截到别处空白；且截图前要 `scrollIntoView({block:'center'})`
+     再等 ~0.5s，不等会得到半张空白 / 文字重叠的鬼影图。
+- 上述这套（含上面的自签 cookie）已沉淀成 skill `rond-web-verify`，
+  脚本 `~/.workbuddy/skills/rond-web-verify/scripts/site_cdp.py`，下次直接调，不用再摸一遍。
+
+### 移动端 .kpis 统计格子高矮不一（本轮，实测通过）
+- 反馈：`/places/196` 详情页移动端 2×2 统计格，第一行明显比第二行高。
+- 根因（实测复现，不是推断）：`.kpi .v` 固定 `font-size: 23px`，「112天19小时」在窄屏放不下
+  就折成两行，**把那一整行撑高**——量出来 row1=124.6 / row2=87.8，差 36.8px 正好一个 line-height。
+  临界宽度在 340~350px 之间（330 时两行都折，看起来反而"齐"；350 时只有停留那格折 → 就是你截图的样子）。
+  `2025-05-30` 这种数字窄，先撑不住的是中文字多的 `dur` 值（`fmtDur` 输出最长约「1234天23小时」9 字符）。
+- 改法（`internal/web/static/css/app.css` 的 `.kpis` / `.kpi .v` 两处）：
+  1. `.kpis { grid-auto-rows: 1fr }` —— 所有格子强行等高，这是兜底保证。
+  2. `.kpi .v { font-size: clamp(17px, 5.6vw, 23px) }` —— 字号随视口收，让长值在窄屏也能一行放下；
+     ≥411px 视口时 `5.6vw ≥ 23px`，clamp 封顶 → 桌面字号与原来完全一致，零回归。
+  没用 `white-space: nowrap`：万一将来出现更长的值，nowrap 会横向溢出卡片，比折行更难看；
+  靠字号收缩 + 行等高兜底更稳。
+- 实测：320/334/360/390/900 五种视口下 4 格宽高**完全一致**，
+  塞入最坏值「1234天23小时」仍是单行；`/`（8 格）、`/stats`（7 格）同样全等高、无折行、无 JS 报错；
+  1440 桌面 4 列、字号 23px 未变。
+- 一句话要记住：**「每个 .kpi 是 grid item」不等于「每行等高」**——`grid-auto-rows` 默认 `auto`，
+  某一格内容变高，它那一行就变高，另一行不受影响，视觉上就是"高矮不一"。
+
+### 访客可见区域：白名单 + 黑名单双模式（本轮，实测通过）
+- 背景：原本 `settings.regions` 是**白名单**（填了的区域才放行）。用户要黑名单，最终选「加模式开关，两种都留」。
+- 落地点：
+  - `internal/setting/setting.go`：新增 `RegionsMode`（`whitelist`/`blacklist`）+ `RegionBlacklist()`。
+    `Default()` 用黑名单；**`Load()` 在缺 `regions_mode` 键时一律回退白名单** —— 历史配置里填过的白名单
+    若被新默认值顺过来，会静默反转成黑名单（本该放行的区域全藏起来），这是唯一有破坏性的点。
+  - `internal/stats/stats.go`：`Filter.RegionsExclude` 决定 `EXISTS(...)` 前面加不加 `NOT`。
+  - `internal/web/handlers_public.go`：`regionSQL(regions, exclude, args)` 统一给报告页和城市聚合用；
+    `filterOf` 传 `RegionsExclude`；新增 `regionHidden()` 给详情页兜底。
+  - 后台：`settings.html` 加白名单/黑名单单选；`handlers_admin.go` 只认这两个值。
+- **补掉两个真窟窿**（改黑名单后更要紧，黑名单的意义就是藏住的绝不漏）：
+  1. `placePage` 原来按 ID 直取地点、**完全没走 `filterOf`** → 访客拿到链接就能看隐藏区域的地点。现在返回 404。
+  2. `apiCityAgg` 直接查 `places` 分组、**没挂区域条件** → 隐藏区域的城市名/坐标照样出现在地图上。现在挂上了。
+- 🩸 **踩到的 SQL 坑（三值逻辑）**：黑名单条件下访客的城市列表空了。
+  `NOT (province='x' OR city='x' OR district='x')` —— `district` 常为 NULL，`NULL='x'` 是 NULL，
+  整个 OR 变 NULL，`NOT NULL` 还是 NULL，行被静默丢掉。修法：`COALESCE(p.district,'') = $n`。
+  注意 `stats.go` 那份**不需要**改：条件包在 `EXISTS` 里，NULL 只是让子查询查不到行，`NOT EXISTS` 照样正确。
+  两处形式不同是对的，已在两处各留一行注释说明原因。
+- 实测（真跑服务 + 真读库）：
+  - 白名单 `[贵阳市]`：访客 points=73、`/api/cities` 只有贵阳市、`/places/1`(贵阳)=200、`/places/196`(河池)=**404**；站长 283/9 城/两个都 200。
+  - 黑名单 `[贵阳市]`：访客 points=210（=283-73）、cities=8（除贵阳）、`/places/1`=**404**、`/places/196`=200；站长全量。
+  - 后台表单端到端 POST 存黑名单 → 库里 `regions_mode='blacklist'` ✓。
+  - 还原成原始配置（`regions: null`、无 `regions_mode`）后行为回到基线：访客 283/9 城/两个都 200。
+- ⚠️ 测试期间临时改过 `settings`（改完已还原，并用 JSON 全字段 diff 确认与原值**完全一致**）。
+  还原时注意：原始配置里 **`marks_public` 这个键本来就不存在**（靠 `Load()` 的缺键默认值兜成 true），
+  重建表单提交会把缺失键写成 `false` 而改变行为 —— 用 `value - 'regions_mode' - 'marks_public'` 精确还原。
+- 遗留：用户明确说上一轮那两个问题（`src_pk=49` 的 `测试` 备注、回填日期格式）**都不要动**，已停止追问。
+
+---
+
+## 黑名单城市彻底隐藏 + 后台说明文案移动端换行优化（本轮，实测通过）
+
+### 需求 E-1：黑名单城市要从「城市列表」本身消失
+- 上一轮黑名单已过滤地点/地图/统计，但**城市筛选下拉框**仍显示被拉黑城市，点进去才空结果。
+- 根因：`internal/stats/stats.go` 的 `Cities()` 直接查 `places` 表，完全没走 `filterOf` / 区域条件。
+- 修法：
+  - `Cities(ctx, datasetID, regions, exclude)` 增加区域参数；省/市/区三级用 `COALESCE` 匹配（直接查 `places` 时 `district` NULL 会触发三值逻辑bug，必须 COALESCE）。
+  - `pageBase`（`internal/web/handlers_public.go`）对非站长传 `p.Settings.Regions + RegionBlacklist()`；站长传空列表，始终全量。
+  - 管理员备注页 `handlers_admin.go` 调用也传空列表，保证后台筛选城市选项不受区域限制。
+- 实测（当前配置 `regions:[河池市], regions_mode:blacklist`）：
+  - 访客 `/places` 城市下拉只剩 8 城，**河池市消失**。
+  - 管理员 `/places` 城市下拉仍为 9 城，**河池市在首位**。
+  - 时间线 / 地图的城市下拉共享同一 `CityList`，同步生效。
+
+### 需求 E-2：后台「访客可见区域」说明文案移动端换行不美观
+- 原模板用行内 `<b style="font-weight:500">只</b>` / `<b>隐藏</b>`，导致移动端 `隐藏` 被单独 orphans 到一行，像被「分开展示」。
+- 修法：
+  - `internal/web/templates/admin/settings.html` 去掉行内 `<b>`，改为自然文案：
+    - 白名单：访客只能看到这些区域的记录
+    - 黑名单：这些区域的记录对访客隐藏，其余照常开放
+  - 关键短语加 `<span class="nobr">` 保持同框：「只能看到这些区域」「对访客隐藏」。
+  - `internal/web/static/css/app.css`：`.check` 加 `word-break: keep-all; overflow-wrap: break-word;`，让中文词组优先不被拆开；新增 `.nobr { white-space: nowrap; }`。
+- 实测：390px CDP 截图，区域说明两行都按「词组」自然换行，不再出现单字/强调词孤立。
+
+### 服务状态
+- 重新编译并启动于后台任务 `Zy7wUd`，`home=200`，端口 8080 正常。
+
+## 新功能：编辑导入的 rond 数据 → 导出回 .rondbackup（完整编辑器 + PG 重建导出）
+
+用户诉求：有些记录点当时没带手机，想手动补录（新增点、时间）后导出为与原始格式一致的 `.rondbackup`。
+
+### 关键事实（先纠正一个旧假设）
+- **rond 的 `ZLOCATION` 坐标就是 GCJ-02**（`README.md:84-88`，实测 2246 采样点与 GCJ-02 理论偏移残差 0m）；站点 `places.lat/lon` 存的就是它。→ **导出回 rondbackup 无需任何坐标变换**（之前以为 rond 是 WGS-84 是错的）。
+- Core Data 主键表真名是 **`Z_PRIMARYKEY`**（带下划线），不是 `ZPRIMARYKEY`。列 `Z_ENT/Z_NAME/Z_MAX`。实体号：Location=6, Tag=11, Visit=18, Activity=1, ActivityGroup=2, HourlyWeather=3 …
+- 访问↔标签多对多表名形如 `Z_11VISITS_`，列 `Z_18VISITS_`（visit FK）/ `Z_11TAGS_5`（tag FK）。实体号可从 `Z_PRIMARYKEY` 反查。
+- Core Data 时间戳 = 自 2001-01-01 UTC 起的 float64 秒；往返存在 **亚微秒级浮点舍入**（实测最大 1.024µs），可忽略。
+
+### 实现（方案：PG 重建 + 导入期抓取 Core Data 元信息）
+- `internal/db/schema.sql`：`datasets` 新增列 `coredata_meta JSONB`。
+- `internal/rond/parse.go`：`Parse` 末尾调 `captureMeta` 抓 `Z_PRIMARYKEY`（实体名→Z_ENT/Z_MAX）、全部 `Z*` 表 DDL、以及用 `PRAGMA table_info` 定位的访问↔标签关联表（名+两列），存进 `Backup.Meta`。新增 `MetaFromArchive(path)` 只抓结构。
+- `internal/ingest/ingest.go`：`Import` 把 meta 写进 `datasets.coredata_meta`（新建快照路径 + 内容相同的复用路径都写）。
+- `internal/web/handlers_admin.go`：`adminUpload` 的 **sha256 去重短路** 分支里，若该数据集缺 meta 就 `MetaFromArchive` 补抓——这是旧数据集唯一的补抓途径（重传同一文件）。
+- `internal/rond/export.go`（新）：`ExportRondbackup(ctx, db, datasetID, meta, dst)` 从 PG 按实体重建 `LifeEasy.sqlite`（用抓取的 DDL 建表，INSERT 部分列，Z_PK=src_pk，appleSeconds 写时间，回写 `Z_PRIMARYKEY.Z_MAX`），zip 成含 `.sqlite/-wal/-shm` 的 `.rondbackup`。写入需注意 **PG 布尔列要扫进 `bool` 而非 `int`**（`is_home/is_work/is_bookmarked/is_user_added/is_daylight`）。
+- `internal/rond/export_roundtrip_test.go`（新）：用 rond 自己的 `Open+Parse` 反向解析导出包与原始包逐项比对（env `ROND_SRC`/`ROND_EXPORT`）。**回归测试保留**。
+- 编辑界面：`internal/web/handlers_edit.go` + `templates/admin/edit.html` + 路由 `GET /admin/edit` 及 `POST /admin/edit/{place,place/update,place/delete,visit,visit/update,visit/delete,movement,weather}`；`server.go` 注册 `admin/edit` 模板；后台首页加「数据编辑」入口与「导出 rondbackup」按钮。新增行 `src_pk=MAX+1`、`is_user_added=TRUE`；改删后重算地点/数据集聚合。
+- 地图选点用站点自带 `/tiles/amap-street/{z}/{x}/{y}`（GCJ-02，点选即所得）。新增 CSS `.inline-edit`。
+
+### 验证结论
+- 往返测试：823 到访 / 323 地点 / 8 标签 / 30 活动 / 791 位移 / 557 天气**完全一致**，坐标偏差 0，时间偏差 ≤1µs。`rawvisits` 2246→0（原始 GPS 采样点不导出，属预期）。
+- 补录实测：新增地点 src_pk=324 + 到访 src_pk=825 → 导出包中 `ZLOCATION(324)`、`ZVISIT(825)`（含时间/`ZUSERADDED=1`/标签关联 `(1,825)`）、`Z_PRIMARYKEY` Z_MAX 正确 bump；改/删/清理均正常，计数回到 323/823。
+- 服务：重新编译，运行于后台任务 `N52YdB`，端口 8080。
+- 旧数据集需**重传一次原始 .rondbackup** 补抓 `coredata_meta`（内容相同也会补抓）；未补抓时导出接口会明确提示。
+
+### 注意
+- `storage/` 已 gitignore；导出样本 `storage/export_clean.rondbackup` 保留备查。
+
+## 修复：/admin/edit 「新增地点」下方地图空白（用户反馈）
+
+**两个叠加的根因**（缺一不可，只修一个仍空白）：
+1. **脚本时序**：`layout.html` 的 `{{template "content" .}}`（L140）在 Leaflet `<script>`（L148）**之前**渲染。编辑页内联脚本执行时 `window.L` 仍是 `undefined`，`if (!el || !window.L) return;` 直接退出 → 地图容器连 `leaflet-container` 类都没有。实测证据：`tiles:0`、容器无 leaflet 类、截图仅剩一个空边框 div。
+2. **瓦片 URL 写错**：内联脚本硬写了 `/tiles/amap-street/{z}/{x}/{y}`。但 `handleTile` 只转发 `s.tiles.upstream` 里的图层，而 `map_provider=amap` 且 `map_key` 为空时 `upstream` 是**空的**，免密钥底图走浏览器直连的 `amapStyleStreet`（带 `{s}` 占位符）→ 该路由 404。
+
+**改法**：
+- `internal/web/tiles.go`：`mapConfig` 响应新增 `subs`（由 `tiles.subStart/subCount` 生成，amap 为 `["1","2","3","4"]`），供前端交给 Leaflet 展开 `{s}`。
+- `templates/admin/edit.html`：内联脚本改为 `whenReady`（`document.readyState==='complete'` 或等 `load` 事件）后再 `fetch('/api/map-config')`，取 `base[0]` + 顶层 `subs` 建 `L.tileLayer`，并保留「直接高德直连 URL」兜底。不再写站内 `/tiles/...` 路由。
+
+**验证**（无头 Chrome + CDP，站长会话 uid=2）：容器含 `leaflet-container`、7 个 pane、**10 个瓦片全部 loaded**，src 为 `https://webrd02.is.autonavi.com/...`（`{s}` 已展开），JS 报错为空，截图可见中国全域底图。
+
+### 可复用教训
+- 本项目模板用 `//go:embed`，**改 .html 必须重新编译二进制**，否则无头浏览器验证的还是旧页面。
+- 编辑页地图类断言必须先等 `load`（Leaflet 在 content 之后加载），否则拿到「容器存在但没初始化」的假象。
+
+## 地理编码（按名称搜坐标）可行性实测
+
+- 用户想法：「能否直接搜索名称来添加 GPS 坐标」。
+- 实测本机网络：**Nominatim（OSM 免密钥）超时不可达**（`http=000`，12s）；**高德 `restapi.amap.com/v3/geocode/geo` 可达**（无效 key 返回 200）、**天地图 `api.tianditu.gov.cn/geocoder` 可达**（无效 tk 返回 400）。
+- 结论：免密钥路线在当前网络下**不可行**，做地理编码必须申请 key。当前 `conf/app.ini` 为 `map_provider=amap` + `map_key=` 空（**无任何 key**）。
+- 待用户拍板方案：A 申请高德「Web 服务」类型 Key（返回 GCJ-02，零坐标转换，质量最好，仅用于地理编码，底图维持免密钥高德）；B 申请天地图 tk 并把底图也换成天地图（一个 key 管瓦片+地理编码，但底图观感变化，且返回 WGS-84 近似需转 GCJ-02）。key 一律只在服务端代理（新增 `/api/geocode`），不进前端源码。
+
+## 新增：「新增地点」按名称搜坐标 + 可选同时建到访（用户拍板方案 A）
+
+用户两点诉求：①「新增地点」没法填到访时间；②想按名称直接搜出 GPS 坐标。
+
+### 结论修正（用户提问）：「安全密钥(jscode)」与我们无关
+- 用户担心「没有安全密钥不能用」——那是**高德 Web端(JS API)** 的要求。我们走的是 **Web服务** 类型的 REST 接口
+  （`restapi.amap.com/v3/place/text`、`/v3/geocode/geo`），**只需 key，不需要安全密钥**。
+- 且底图仍走免密钥瓦片 CDN（`webrd0x.is.autonavi.com`），根本没碰 JS SDK。→ 配置里只填一个 `geocode_key` 即可。
+  申请时在高德开放平台选「**Web服务**」类型，别选「Web端(JS API)」。
+
+### 实现
+- `internal/config/config.go`：新增 `GeocodeKey`（配置项 `geocode_key`，可选，留空则功能关闭）。
+- `internal/web/geocode.go`（新）：`GET /api/geocode?q=`，**仅管理员**（`requireAdmin`，防配额被外部消耗）；
+  先打 `place/text`（POI 关键字，适合地名），无结果再兜底 `geocode/geo`（结构化地址）；
+  高德返回 **GCJ-02，与库内同系，零坐标转换**；密钥只在服务端拼接，不进前端源码。
+  高德字段 `province/city/district/address` 可能返回**空数组**而非字符串（直辖市常见），用 `amapStr(json.RawMessage)` 兼容。
+- `templates/admin/edit.html`：「新增地点」卡片顶部加搜索框 + 候选列表（点选填入 name/lat/lon/省市区并平移地图）；
+  仅 `{{if .GeocodeReady}}`（= `geocode_key` 非空）时渲染，未配置则显示一行配置提示，避免「看着能用却报错」。
+  地图选点与搜索共用 `fillCoord()` / `mapGoto()`，**地图未就绪时坐标照样能填**。
+- 「可选：同时创建一条到访记录」：用 `<details class="opt-visit">` 折叠，含到达/离开时间、活动、备注。
+  **只有填了 `arrival` 才建到访**，否则行为与以前完全一致。
+- `handlers_edit.go`：抽出 `insertVisit(...)`（`editVisitCreate` 与「地点+到访一次提交」共用，保证落库一致）；
+  `editPlaceCreate` 改为 `INSERT ... RETURNING id` 以拿到新地点 id，再按需建到访。
+- `view.go`：`EditData.GeocodeReady`。`static/css/app.css`：`.geo-list/.geo-item/.opt-visit`。
+- `conf/app.ini`：新增 `geocode_key =` 及说明注释。
+
+### 验证（无头 Chrome + CDP + psql）
+- 地图：容器含 `leaflet-container`、7 pane、**10 瓦片全 loaded**，无 JS 报错；截图确认新 UI 正常。
+- 未配 key：搜索框不渲染，显示配置提示；`/api/geocode` 返回 `{"error":"服务端未配置 geocode_key…"}`；访客访问返回 **303**（被 requireAdmin 拦）。
+- **临时填假 key 实测上游**：返回 `{"error":"高德返回：INVALID_USER_KEY"}` → 证明服务端确实打到了高德、参数构造正确、错误能优雅透出（随后已还原 `geocode_key` 为空）。
+- 补录流程：只填位置 → `places(324)`，`visit_count=0`、无到访（行为未变）；位置+时间 → `places(325)` + `visits(825, place_id=649, arrival 2026-08-01 10:00, departure 12:30, duration_min=150, is_user_added=true)`。
+- 用 `place/delete` 清理测试数据后计数回到 **323 / 823**，无残留；`go test ./...` 全绿。
+
+## 地理编码上线实测（用户已填 geocode_key，验证通过）
+
+- 用户在高德开放平台申请的 **Web服务** 类型 key 已填入 `conf/app.ini` 的 `geocode_key`（32 位 hex）。
+  **注意：配置只在启动时读取，填完必须重启服务才生效。**
+- `GET /api/geocode?q=杭州西湖` 返回真实候选：「杭州西湖风景名胜区」(30.222692,120.121358)、「西湖」(30.246255,120.144302) 等，
+  坐标经核算是 **GCJ-02**（西湖 WGS-84 约 30.2438/120.1503，加 GCJ 偏移后正合 30.2463/120.1443）。
+- **端到端 UI 实测**（无头 Chrome + CDP 自建轮询脚本）：输入「上海外滩」→ 点搜索 → 8 个候选 → 点第 1 个 →
+  表单被填为 `name=外滩 / lat=31.233516 / lon=121.492127 / 上海市 / 上海市 / 黄浦区`，地图落 1 个 marker 并平移到外滩，
+  提示语「已填入：外滩」，**无 JS 报错**。截图里 marker 正好压在高德底图的「外滩」标注上 → 直观证明坐标与底图同系。
+- 探测脚本只填表单未提交，数据计数仍为 **places=323 / visits=823**，无脏数据。
+- `/.gitignore` 已含 `/conf/app.ini`，密钥不会被提交进仓库。
+- 环境坑：Write/Read/present_files 与 Windows 版 python 的 `/tmp/...` 解析为 **`C:\tmp\...`**，
+  而 Git Bash 的 `/tmp` 是另一处；跨工具传路径要统一用 `C:/tmp/...`。
+
+## 修复：「按名称搜坐标」输入框与按钮不同行 / 按钮歪（用户反馈）
+
+**两个具体根因**（都用 headless 量数确认）：
+1. **纵向偏移 13.8px**：`label.f` 自带 `margin-bottom: 13px`（`.field` 基线间距），而那行用了 `align-items: flex-end`。
+   flex 是按**外边距盒**底边对齐的 → 标签的 13px 下边距把输入框整体抬高，按钮看起来"矮一截/歪"。
+   实测：1280 下输入框 `top=256.78 h=38.39`，按钮 `top=270.58 h=37.59` → 底边差 **13px**、高度差 0.8px。
+2. **窄屏换行**：输入框写了 `flex:3 1 240px`（基准 240px），`.row` 又是 `flex-wrap: wrap`
+   → 320px 视口下按钮被挤到下一行。实测 320 下 `sameLine=False`，按钮 top 比输入框低 **60.6px**。
+
+**改法**：新增专用类 `.search-row`（`static/css/app.css`），模板 `edit.html` 去掉内联样式：
+```css
+.search-row { display:flex; flex-wrap:nowrap; align-items:flex-end; gap:8px; margin-bottom:12px; }
+.search-row > label.f { flex:1 1 auto; min-width:0; margin-bottom:0; }   /* 归零外边距 + 可收缩 */
+.search-row > .btn { flex:0 0 auto; font-size:14px; }                     /* 与输入框同字号 → 同高 */
+```
+**注意**：`flex:1 1 auto`（可增长）是刻意保持的 —— 项目既有约定就是「宽输入框 + 按钮靠右」
+（`edit.html:74` 地点列表搜索、`layout.html:84` 筛选栏都写 `margin-bottom:0` + `flex:2 1 200px`），不要改成定宽靠左。
+
+**实测（三视口，修复前/后对照）**：1280 / 390 / 320 下修复后均 `同行=True、底边差=0、高度差=0`；
+320 下输入框 right=221、按钮 left=229（8px 间距），无溢出；JS 无报错。
+
+### 待办（已复现，等用户确认再动）
+同类搜索行**在窄屏也会换行**，但未包含在本次改动范围内：
+`edit.html:73` 的「地点列表」搜索行在 **320 和 390 都换行**（实测 320：标签 bottom=1624、按钮组 top=1634；
+390：1391 / 1401）。`layout.html:84` 的筛选栏同理（`flex:2 1 180px` + 可换行）。若用户要统一，把这两处也换成 `.search-row` 即可。
+
+## 推广：「搜索行」统一（用户回「一起改」）
+
+把 `.search-row` 推广到同类位置，并**顺手发现筛选栏有反方向的同类偏移**：
+- `edit.html` 地点列表搜索行（`<form class="row" style="margin:6px 0 12px">`）→ 改 `class="search-row" style="margin-top:6px"`，
+  按钮组加 `.act` 包裹。CSS 相应扩展 `.search-row > .act { display:flex; gap:8px }` 与 `.search-row .btn`。
+- `layout.html` 的 `{{define "filters"}}`（用于 /places、/stats、/timeline）：控件行 `<div class="row">` 原用默认
+  `align-items: center`，而每个 label 是「文字+输入框」整盒（约 63px），按钮组只有 38px → **按钮被居中，底边比输入框高 14px**。
+  改成 `style="align-items:flex-end"`，并删掉按钮组那个没用的 `padding-bottom:1px` 补丁。
+- **保留换行**：filters 是 6 控件筛选卡片，窄屏换行是设计如此（实测 390 底边极差 193px、320 为 412px，即多行），不能强上 nowrap。
+  `notes.html:30` 的筛选行本来就写了 `align-items:flex-end` + `margin:0`，`notes.html:85` 用 `align-items:end` 的 grid —— 都是对的，未动。
+  `map.html` 侧栏筛选 = 控件与按钮本就分行，未动。`places.html:18/30` 是 chip 行，未动。
+
+**复测（底边极差，0 = 齐平）**：按名称搜坐标 390/320 → 0；地点列表搜索 1280/390/320 → 0（320 下按钮 left=163、right=287，确认不换行）；
+筛选栏 1280 → 0（按钮 div bottom=382.8 = 各 label bottom）。JS 无报错。
+
+### 可复用教训（已写进 rond-web-verify 技能）
+- 判断 flex 行是否「同一行」**不能用 `top` 去重**：label 内含文字 span，`top` 天然比按钮高约 25px，
+  会误判成换行。正确判据：竖直重叠 / `button.left >= input.right`；**是否对齐要看 `bottom` 而不是 `top`**。
+
+## 🔴 P0：导出的 .rondbackup 无法回导（rond 提示「备份恢复失败」）——根因取证
+
+用户反馈：导出包只有 85KB，原始包 3402KB；怀疑丢数据/改了库名。**库名没问题**（都是 `LifeEasy.sqlite`），
+但**确实大量缺失**。逐项对比（原始 `data/20260914_151649.rondbackup` vs `storage/export_clean.rondbackup`）：
+
+| 项 | 原始 | 导出 | 说明 |
+|---|---|---|---|
+| 表 | 31 | 12 | 缺 19 张 |
+| 索引 | 47 | 1 | 只重建了表，`CREATE INDEX` 全丢 |
+| 关联表 | 6 张 | 1 张 | 只重建了 `Z_11VISITS_`，`Z_6TAGS_`(2 行) 等全丢 |
+| `.sqlite` | 356KB | 254KB | |
+| `-wal` | 3,094,152B | **0B** | 原始数据主要在 WAL 里 |
+| `-shm` | 32,768B | **0B** | |
+| zip 压缩 | **STORED(0)** | DEFLATE(8) | 与 rond 不一致 |
+
+### 致命根因：缺 `Z_METADATA`（Core Data 靠它判断 store 与模型是否兼容）
+- `Z_METADATA` 有 1 行：`Z_VERSION / Z_UUID / Z_PLIST(1585B)`。plist 键含
+  **`NSStoreModelVersionHashes`（19 个实体的模型哈希：Keyword/UserPhoto/Tag/RawVisit/PoiCategory/Movement…）**、
+  `NSStoreModelVersionHashesDigest`、`NSStoreModelVersionChecksumKey`、`NSPersistenceFrameworkVersion`、`NSStoreType`。
+- 我们的导出**根本没有这张表** → Core Data 打不开库 → 备份恢复失败。`Z_MODELCACHE`(16073B) 同样缺失。
+
+### 代码层根因（`internal/rond/parse.go` + `export.go`）
+1. `captureMeta` 的 DDL 抓取条件 `type='table' AND name LIKE 'Z%'` → **漏掉 `ACHANGE/ATRANSACTION/ATRANSACTIONSTRING`**（非 Z 前缀），
+   也**完全没抓 `type='index'`**。
+2. `buildSQLite` 只按硬编码 `createOrder` 建 11 张表 → `Z_METADATA`、`Z_MODELCACHE`、`ZKEYWORD`(8 行数据!)、
+   `ZACTIVITYGROUP`、`ZTRIP*`、`ZJOURNAL`、`ZUSERPHOTO` 等一律不建，也不写 Core Data 元数据行的内容。
+3. **数据真丢失**：`ZKEYWORD` 8 行、`Z_6TAGS_` 2 行、`ZRAWVISIT` 2246 行。
+4. `parse.go:441` 对 ZRAWVISIT 只 `SELECT count(*)`，从不读行 → **PG 里也没存原始 GPS 采样点**
+   （`datasets.raw_visit_count=2246` 只是统计值），所以现状下无法补导。
+5. `zipBackup` 用默认 DEFLATE，且把 0 字节的 -wal/-shm 也打进去。
+
+### 修复方案（待用户拍板）
+- **方案 A（推荐）基线库 + 覆盖**：导入时把原始 sqlite（checkpoint 合并 WAL 后）留一份基线
+  （如 `storage/data/<dataset_id>/base.sqlite`）；导出时复制基线 → 清空并重写我们管理的实体表
+  （ZLOCATION/ZVISIT/ZACTIVITY/ZTAG/ZTAGGROUP/ZTRANSPORT/ZMOVEMENT/ZHOURLYWEATHER + 全部关联表）
+  → 回写 `Z_PRIMARYKEY.Z_MAX` → checkpoint → **STORED** 打包。
+  好处：`Z_METADATA`/`Z_MODELCACHE`/持久化历史/47 索引/我们不管的表（含 **ZRAWVISIT 2246 个原始点**、ZKEYWORD、ZTRIP*）
+  **全部原样保留**，不需要往 PG 存原始点；最保真。
+  代价：每数据集多存约 3.4MB 基线；已导入的旧数据集要重建基线（可从 `storage/uploads/` 里按 `original_name` 找回，或重传一次）。
+- **方案 B 全量抓结构进 `coredata_meta`**：抓全 sqlite_master（表+索引+触发器）并把 Z_METADATA/Z_MODELCACHE 行以 blob 存进 JSONB。
+  代价：**ZRAWVISIT 2246 行仍然丢**（PG 没存），要真正不丢还得同时改导入新增原始点表，工作量更大、体积也大。
+
+---
+
+## P0 导出回导：方案 A「基线库 + 覆盖」已实现并验证（18:45）
+
+用户拍板走方案 A。改动清单：
+
+| 文件 | 改动 |
+|---|---|
+| `internal/rond/parse.go` | 新增 `WriteBaseline(archivePath, dst)`：解包 + `wal_checkpoint(TRUNCATE)` 后 `VACUUM INTO` 出单文件基线（退路是直接复制合并过 WAL 的主库）；`copyFile`。顺手删掉只用过一次的 `MetaFromArchive`（其存在理由已消失） |
+| `internal/rond/export.go` | 全量重写。新签名 `ExportRondbackup(ctx, db, datasetID, baselinePath, dst io.Writer)`；`patchSQLite` 复制基线 → 只 `DELETE`/`INSERT` 7 张管理表 + 访问↔标签表；`loadEntities`/`discoverVisitTagJoin`/`tableExists` 从基线探测结构，**不再依赖 `coredata_meta`**；`Z_PRIMARYKEY.Z_MAX` 只上调；`zipBackup` 改 `zip.Store` |
+| `internal/web/handlers_export.go` | `baselinePath`（`<data_dir>/baselines/<id>.sqlite`）、`ensureBaseline`（缺失时自愈）、`findSourceArchive`（按 `sha256` 去 `upload_dir` 找回原包） |
+| `internal/web/handlers_admin.go` | 导入成功后写基线；sha256 去重分支从「补抓 coredata_meta」改成「补写基线」 |
+| `internal/web/handlers_edit.go` | `HasMeta` → `CanExport`：改为调 `ensureBaseline` 判断，老数据集访问编辑页即自愈 |
+| `internal/web/templates/admin/edit.html` | 提示文案改为「基线库不可用…重新上传即可恢复导出」 |
+| `internal/rond/export_roundtrip_test.go` | 新增 `TestBaselineKeepsCoreData`（守 `Z_METADATA`/`Z_MODELCACHE`/表索引集合/`ZRAWVISIT`），用 `ROND_SRC` 门控 |
+
+### 踩到的坑：`SetMaxOpenConns(1)` 自死锁（卡 5 分钟、零输出、零报错）
+`patchSQLite` 里 `BeginTx` 已经独占那唯一连接，之后又用 `sdb.QueryContext` 读 `ZTAGGROUP` → 永久等连接。
+**改为 `tx.QueryContext`**。规律记进 skill 了：开事务后要么走 `tx`，要么把只读查询挪到 `BeginTx` 之前。
+
+### 验证结果（实测，非推断）
+原始包 = `storage/uploads/1789372176-20260914_151649.rondbackup`（3402 KB，sha 匹配 dataset #1）。
+
+```
+HTTP GET /admin/export/rondbackup   → 200，2,871,700 B（≈2804 KB，不再是 85 KB）
+包内：LifeEasy.sqlite / -wal(0) / -shm(0)，method=0（Store，与 rond 一致）
+表 31 / 索引 47 / Z_METADATA ✅ / Z_MODELCACHE ✅(1 行 16073B) / ZRAWVISIT 2246 / ZKEYWORD 8
+Z_METADATA.Z_PLIST 字节哈希 502bf007e218c077 …与原始包逐字节相同 ✅
+表集合、索引集合与原始包完全一致；Z_PRIMARYKEY 22 个实体不变，仅 Z_MAX 上调（Location 323→324、Visit 824→825）
+导出 → 再导出：各项计数完全一致（幂等）✅
+```
+
+导出内容 = **PG 当前状态**：PG 里 324 地点 / 824 到访（比原包多 1 个地点），导出与之逐项吻合 ——
+说明「编辑页补录的记录会随导出回写」这条链路也是通的。
+
+### 遗留 / 可选项
+- `coredata_meta` 现在只作为结构快照留档，**不再参与导出**。想彻底清掉的话，要一起动
+  `Backup.Meta`、`captureMeta`、`CoreDataMeta`、`ingest` 的两处写入、以及 schema 里的 `coredata_meta` 列。属可选清理，未做。
+- 每数据集多存约 2.8 MB 基线（`storage/data/baselines/`，已 gitignore）。
+- **仍未真机验证**：导出包在 iPhone 上能否被 rond 成功恢复，需要用户实测。已留
+  `storage/roundtrip-check.rondbackup` 供其直接 AirDrop 试。
+- 基线里保留了原始持久化历史（`ACHANGE`/`ATRANSACTION*`），而业务表是被直接 SQL 覆盖的，
+  历史与实际数据不再对应；Core Data 一般不做交叉校验，但若真机恢复失败，这里是第一处可怀疑点
+  （退路：清空历史表并重置 history token）。
+
+---
+
+## 导出闭环验证 + 发现两个老数据问题（19:00）
+
+### 闭环：导出 → 回传 → 被识别为同一份数据 ✅
+把 `/admin/export/rondbackup` 产出的包直接回传到 `POST /admin/upload`：
+
+```
+flash[ok]: 这份备份的记录与已有数据集 #1 完全一致（824 条到访、323 个地点），未新建快照，当前展示不变
+```
+
+这是不依赖真机的最强证明——导出包能被我们自己的解析器读回来，且内容指纹与原数据集逐键一致
+（824 个 `(Z_PK, arrival.Unix())` 键完全相同，说明 Core Data 浮点时间戳的往返在秒级精度上无损）。
+
+### 发现 1（P1，已修）：老数据集 `content_hash` 为 NULL，内容去重永远不命中
+- `datasets.content_hash` 是后来加的列；**在它出现之前导入的数据集（如 #1）该列是 NULL**。
+- `ingest.Import` 的去重查询 `WHERE user_id=$1 AND content_hash=$2` 永远匹配不到 NULL →
+  「内容相同、字节不同」的包（典型就是自己导出的 rondbackup）会**新建重复数据集并切走展示**。
+- sha256 去重挡不住这种场景（rond 每次导出字节都不同）。
+- **修复**：手工给 #1 回填了正确指纹 `ba2712819f710b43…`（用临时 Go 程序按 `ingest.contentHash`
+  同一套逻辑实算，不能用 psql/Python 复刻——跨语言算出来对不上，实测证明）。
+- **建议后续做**：启动时或导入时对 `content_hash IS NULL` 的数据集批量回填，否则其它老库照样重复。
+  若历史上还有别的老数据集，这条要补。
+
+### 发现 2（P2，未修）：`datasets.place_count/visit_count` 是缓存值，编辑页新增后不更新
+回传导出包时 flash 显示「323 个地点」，但 `places WHERE dataset_id=1` 实际 324 条。
+`handlers_edit.go` 的增删改只动业务表，没同步 `datasets` 上的计数列 → 后台 flash 与统计数字会漂。
+低危，但要修的话应在编辑处理里重算或改成实时 count。
+
+### 教训：跨语言复刻哈希逻辑不可信
+为回填 content_hash 我先用 psql+Python 复刻 Go 的 `contentHash`，结果算出的值与 Go 实算不一致
+（键集合明明逐条相同）。**凡是要写回库里的指纹/哈希，必须用原实现（Go）算**，别跨语言复刻。
+
+---
+
+## 「固定」状态 + P2 计数漂移 已修（19:35）
+
+### 用户反馈
+真机导入成功，但导入的新地点在 rond 里默认是「固定」状态；另外让顺手修 P2（计数漂移）。
+
+### 「固定」根因（实测定位，非猜测）
+逐列对比真机原始包 vs 我们的导出包，发现**所有被重写的行**都丢了 rond 自己写的列：
+
+- `ZLOCATION.ZPINSTYLE_`：真机 323 行全是 `0`，我们导出全是 `NULL`
+- 同样丢的还有 `ZTYPE_/ZBOOKMARKED/ZUSERADDED/ZUSERIGNORED/ZRADIUS/ZRAWLAT(ZLON)/ZLASTARRIVALDATE_/ZSUBTHOROUGHFARE/…`
+- `ZVISIT.ZRAW(785)/ZIDENTIFIER_(822)/ZMERGEDTO(52)/ZPARENT(10)`、`ZMOVEMENT.ZTYPE_(791)/ZISMODIFIED`、
+  `ZHOURLYWEATHER.ZPRECIPITATION_/ZDEWPOINT_`、`ZACTIVITY.ZUID_`、`ZTAG.ZLASTARRIVALDATE_` —— 共 48 列
+
+原因：`patchSQLite` 是 DELETE+INSERT，INSERT 只列出我们管理的十几个列，其余全成 NULL。
+rond 对 `ZPINSTYLE_` 等标志位 NULL 的行按「固定」处理。
+
+### 修复：导出改为 UPDATE-in-place（internal/rond/export.go 重写 patchSQLite）
+- 基线里**已有**的主键 → `UPDATE` 只动我们管理的列，rond 写的其余列**原样保留**
+- **新增**的行 → `INSERT`，并把 rond 会写的标志位补成 `0`（照真机包取值分布抄）
+- PG 里已删除的行 → `finish()` 时 `DELETE` 同步
+- `Z_ENT`/`Z_OPT` 只在 INSERT 时写；UPDATE 不碰，避免动 Core Data 的乐观锁版本
+- 结构性重构：PG 侧行先取回内存再统一写 SQLite（避免两库交错），新增 `tableWriter`
+  （write/finish）与 `knownPKs`；各表列清单与默认值集中在构造处，一眼可查
+
+### 顺手修掉的连带 bug：基线被「导出包」污染
+重传导出包时，我此前的代码会在 Identical 分支**之前**重写基线 → 用退化副本覆盖了原始基线，
+导致后一次导出是在坏基线上做的（第一次复检时 48 列仍全 NULL，就是这个原因）。
+修复：`handlers_admin.go` 只在 `!st.Identical` 时写基线；重传一律交给 `ensureBaseline`
+按 sha256 找回原始包重建。本次实测：删掉坏基线 → 访问编辑页自愈 → 导出恢复正常。
+
+### 复检结果（原始 vs 新导出）
+- 丢列清单：**只剩 `ZVISIT.ZEMOJINAME_`（真机里是 `''` 空串，我们写 NULL，语义等价，可接受）**
+- `ZLOCATION.ZPINSTYLE_` 323→324（多出的 1 行是编辑页新增的地点，且 **全标志位=0，不再 NULL**）
+- `ZVISIT.ZRAW/ZIDENTIFIER_/ZMERGEDTO/ZPARENT`、`ZMOVEMENT.ZTYPE_`、`ZHOURLYWEATHER.ZPRECIPITATION_` 等
+  全部 100% 保留；`Z_METADATA` 哈希仍是 `502bf007e218c077`
+- 回传导出包仍被识别为「与数据集 #1 完全一致，未新建快照」✅
+
+### P2 修复（internal/web/handlers_edit.go）
+`refreshDatasetAgg` 原来只重算 `visit_count/first/last`，补上 `place_count`。
+实测：新增地点 → `place_count` 324→325，删除 → 回到 324，与实际行数一致。
+（`raw_visit_count` 不重算——PG 不存原始采样点，它只是导入时的统计值。）
+
+### 待用户真机复测
+重新导出一份再导入 rond，确认新地点不再显示「固定」。
+注意：手机上已导入的那份还是旧导出包（标志位是 NULL），要用新导出的包覆盖导入。

.workbuddy/memory/2026-09-16.md

@@ -0,0 +1,923 @@
+# 2026-09-16
+
+## rond-with-you：编辑页表单必填收紧 + 换 flatpickr 时间选择器
+
+### 需求
+到达时间、离开时间、活动设为必选；备注可选但不折叠；原生 datetime-local 不好用，换别的。
+
+### 改动
+- **新建地点**：`<details class="opt-visit">` 折叠移除，到访三要素平铺显示且必填（到达/离开/活动），
+  备注可选；语义从「可选同时创建到访」变为「与地点同时创建到访」。
+- **新增到访**：离开时间、活动必填；「类型」改叫「活动」，默认 option 从「（无）」改「请选择活动」。
+- **编辑到访（行内）**：离开时间也必填（历史 departure 0 条 NULL，无副作用）；
+  活动不强制（历史 73 条 NULL 活动，强制会拦住编辑）。
+- **时间选择器**：引入 flatpickr v4.6.13（vendor 到 `internal/web/static/vendor/flatpickr/`，
+  含 l10n/zh.js，共 ~69KB，离线可用）；`Page.Flatpickr` 开关控制 layout 按页加载；
+  24 小时制、中文、`allowInput` 可手输，`dateFormat: 'Y-m-dTH:i'` 保证提交值仍是
+  datetime-local 格式，服务端 `parseLocalDT` 无需改动。
+- **服务端**：`parseVisitTimes` 离开时间必填；`editVisitCreate` / `editPlaceCreate` 活动必填
+  （resolveActivity 返回 nil 即拒）；editPlaceCreate 删除「arrival 空则不建到访」分支。
+- **CSS**：`.flatpickr-calendar` 圆角/阴影与站点一致，选中/今天/hover 用 `--accent`。
+
+### 验证
+HTTP 实测：缺活动 → 「请选择活动类型」；缺离开 → 「请填写离开时间」；三要素齐 → 创建成功；
+测试数据已删（visits 回到 823）。管理员密码已还原。
+
+## 追加修复：搜索失效（flatpickr l10n 崩溃）+ 地点下拉信息不足
+
+### 搜索失效根因
+配置文件没动过（`conf/app.ini` 的 `geocode_key` 原样在，直调高德 API 也正常）。
+真正根因是我给编辑页加的 flatpickr 初始化写错了 API：flatpickr 的语言包静态属性是
+**`flatpickr.l10ns`（复数）**，我写成 `flatpickr.l10n.zh` → 读取 undefined 的 `.zh` 抛
+TypeError → 同一个 `whenReady` 回调里**后面的地图初始化和地点搜索绑定全部没执行**。
+表现就是「搜索按钮点了没反应」。
+修复：`flatpickr.l10ns.zh` + 整段 try/catch 兜底（防止一处错毁掉全部初始化）。
+教训：给页面加同步脚本时，先于其它初始化的代码必须自行兜错。
+
+### 第二个坑（排查中新引入又修复）
+改「新增到访」地点下拉时，`COALESCE(NULLIF(sublocality,''), NULLIF(district,''))` 在两列
+同为 NULL 时结果仍是 NULL，pgx 扫进 string 报错 → **整个 /admin/edit 页面 500**。
+COALESCE 兜底要兜到底：末尾再加一个 `''`。
+
+### 地点下拉信息不足（用户反馈「看不出是哪次到访、有重复、太笼统」）
+原 Label 只有「城市 · 名称」。改为从库里的 province/city/区县(sublocality 缺失时退 district)/
+街道拼完整地址 + 到访次数 + src_pk：
+`#196 家 — 广西壮族自治区 河池市 金城江区 西环路（246次）`
+src_pk 直接对应「新增行程」表单里要填的值。相邻重复段去重（直辖市不会出现「北京市北京市」）。
+
+### 无头验证结论
+CDP 实测：0 JS 报错、flatpickr 中文包注册成功、Leaflet 地图初始化完成（执行流走完整）、
+页内 XHR 调 `/api/geocode?q=南宁东站` 返回 8 条。
+
+## 再修正：离开时间不该必填（用户纠正）
+
+用户指出逻辑错误：补录「家」这类高频地点的到访，常常只知道到达时间（刚到家/只记到达），
+强制填离开时间不成立。已回退：离开时间恢复可选，留空=只记了到达（原语义），
+前端 required/星号移除，`parseVisitTimes` 恢复原实现。
+新增单元测试 `internal/web/parse_visit_times_test.go` 覆盖四种情况
+（只到达/双时间/缺到达/离开早于到达），无需重置密码即可验证服务端逻辑。
+保持必填的：到达时间、活动（用户未质疑）。
+
+教训：把「必填」要求落到每个字段前先想补录场景——必填清单该由「这条数据不填就无意义」决定，
+而不是照单全收；用户说的"必选"清单可能覆盖不了真实的补录姿势。
+
+## 再修正：到达时间默认当前时刻（用户质疑「246 次到家还让我手填到达时间」）
+
+**这版方向错了，用户又否定了**（见下节）。到达时间预填当前时刻已回退。
+
+## 根因澄清：不是必填问题，是「新增到访」语义传达失败
+
+用户三层质疑（离开必填→到达重复→填一个时间代表什么）拼起来，真正的意思是：
+**用户以为选了「家（246次）」后，表单填的时间要「代表」这个地点的全部到访**——
+"246 次到达时间都不一样，填一个时间代表它们当然不合理"。
+而功能的真实语义是「往时间线追加一条**独立的**新到访（比如某次忘带手机的那段）」，
+每次提交一条、互不影响。UI 从没把这层讲清楚。
+
+修正：
+1. 回退「预填当前时刻」——补录的永远是历史时刻（忘带手机的那天），预填当下只会诱导提交错误数据。
+2. 表单文案写明：「追加一次单独的到访……每提交一次就是一条全新的独立记录，和该地点已有的到访互不影响，
+   更不是去『代表』它们；下拉里的次数只是参考。时间凭当时记忆填个大概即可」。
+3. flatpickr `minuteIncrement` 1→5：补录靠回忆，没人记得 12:59:47，5 分钟步进贴合「大概那个点」。
+
+教训（重要）：**用户连续质疑表单逻辑时，先怀疑语义传达，而不是急着调必填/默认值**。
+我顺着「必填是否合理」修了三轮，实际是用户没看懂这个表单在创建什么。
+
+## 融合表单：新增地点 + 新增到访合一（用户最终指令）
+
+用户拍板：「把新增地点和新增到访融合起来，而不是分开，到访时间和日期选填，但是不要折叠选项。」
+
+实现（internal/web/handlers_edit.go + templates/admin/edit.html + server.go）：
+- 一个融合表单（action 仍为 /admin/edit/place），radio 切两种模式：
+  `new`=新建地点（名称/坐标必填，地图选点+搜索）；`existing`=给已有地点补到访（下拉选地点）。
+- 到访时段**整体选填平铺**（到达/离开/活动/备注/收藏/标签）：
+  到达留空 → 只建地点；填了到达 → 同时追加一条独立到访（活动也可不选，存 NULL）。
+  补已有地点时到达必填（否则没意义），后端给出明确提示。
+- 删除独立「新增到访」card 与 `editVisitCreate` + 路由 POST /admin/edit/visit
+  （update/delete 保留）。到访的增删改现在全部走融合表单。
+- HTML5 required 不能写在会被隐藏的字段上（display:none 仍会拦截提交），校验全交后端。
+- 模式切换时 Leaflet 在 display:none 容器里会拿到 0 尺寸，切回 new 模式时
+  `window.dispatchEvent(new Event('resize'))` 触发 invalidateSize。
+
+端到端实测（用 site_cdp.py 签名 cookie，无需动密码）：四条路径
+（补到访缺到达→拒 / 补到访→成 / 新地点无到访→只建地点 / 新地点带到访→地点+到访）
+全部正确；测试数据经 HTTP 删除，计数核对 places=324（323 原始+昆明站）、visits=823、家=246。
+
+## 编辑页三项易用性改进（用户第 4 轮反馈）
+
+1. **补到访的地点选择器**：324 个地点用原生 `<select>` 无法搜索/收起。改为
+   `input#place-search`（按名称/城市/#编号过滤）+ `#place-results` 结果列表（最多 30 条，
+   复用 `.geo-item` 样式）+ `hidden input[name=existing_place]`；选中后收起输入框、
+   显示「已选：xxx 重选」。
+2. **类别可直选**：新建地点的「类别」加 `datalist`，选项来自库里 `DISTINCT poi_category`。
+   原值是 MapKit 的 `MKPOICategoryRestaurant` 这类标识符（12 个），配了中文映射
+   （`poiCategoryText`），`<option value="原值" label="中文">`——提交值仍是原值，
+   与 rond 保持一致（rond 靠它取图标）。
+3. **活动可新建**：新增 `POST /admin/edit/activity`（JSON），表单里「或新建活动」输入框 +
+   按钮，创建后即时 append 进活动下拉并选中；Enter 键也触发（preventDefault 防止误提交）。
+   新活动 `src_pk=MAX+1`、`color='blue'`。
+
+### 踩坑
+- **模板里别用 `{{printf "%q" .Label}}` 生成 JS 字面量**：html/template 会在 `<script>`
+  上下文再做一次 JS 转义，得到 `"\"#196 家…\""`（值里混进引号）。改成把数据渲染进隐藏的
+  `<select id="place-options">`，JS 读它的 option——彻底绕开模板转义问题。
+- **验证脚本 site_cdp.py 默认只等 2.5s**，本页含地图瓦片，`whenReady`（等 load）还没跑完就去
+  eval 会得到「事件没绑上、结果为空」的假象。测这个页面要 `--wait 5`。
+- **`<datalist>` 无输入时不展开、`<option label>` 兼容性差**，用户反馈「类别下拉是空的」。
+  类别只有十来个，直接用 `<select>` + 「自定义…」项。
+
+## 类别下拉（second take）+ 数据库/站点审阅
+
+### 类别改成 select（新建 + 每行行内编辑）
+`EditPlace.CategoryOptions`（已有类别 + 当前值若不在其中则补上，避免真机里少见类别被静默改掉）；
+`pickCategory()` 处理「自定义…」→ 旁边 `category_custom` 输入框；`poiCategoryText` 中文映射
+（value 仍是 `MKPOICategoryXxx` 原值，与 rond 一致）。行内编辑 40 行全部生效。
+
+### 审计发现（tools/audit_db.sql，可复用）
+全绿：聚合漂移 0、悬空引用 0（含 movements 的 place/visit 两端、weather、visit_tags 跨数据集）、
+时间倒挂 0、笔记/投票错位 0。留档差集只有 1 行且是 `skipped=t`（那条孤独到访，正常）。
+
+**已加固（防患于未然，当前数据未触发）**：
+1. `pruneEntityRaw()`：删除地点/到访后清掉留档里已不在库的行。风险链是
+   「删除 → 新建取 MAX(src_pk)+1 → 复用被删编号 → 新行继承旧留档的 rond 私有字段」。
+   `skipped=TRUE` 的行保留。
+2. 删除地点/到访时清理 `movements`（端点没了就是悬空引用）、`weather.visit_src` 置 NULL
+   （天气有独立价值，只解除关联）。
+
+**数据特征（非缺陷，rond 原始数据自带）**：11 组同名同坐标重复地点（柳州站×3…）、
+1 条零时长、1 条超 30 天（家 50517 分钟）、70 条无活动、218 个地点无类别。
+
+**待用户决定的优化**：行程/天气表单仍要手填 src_pk（建议改可搜索下拉）；
+活动只能新建不能删改；place_notes/place_votes 缺 dataset_id（多数据集切换会串）。
+
+
+## rond-with-you：导入导出字段级一致（entity_raw 全字段留档）
+
+### 需求
+「引入 rondbackup 时就应该保留所有字段和数据」——把现有数据清空、用 `data/20260914_151649.rondbackup` 重新导入，
+并要求导出包与原始包**逐字段一致**；编辑表单把必填字段标出来。
+
+### 做法
+1. `entity_raw` 表（JSONB）在导入时存下每个实体的**完整原始行**（8 张业务表共 2540 行），
+   导出时不依赖基线库补字段，直接按留档逐列还原。
+2. 写入改成 `INSERT OR REPLACE` 写全列：管理列取 PG 当前值，其余列取留档原值。
+3. `entity_raw.skipped` 标记「因缺必填字段没能进 PG」的行（如无到达时间的孤独到访 ZVISIT#191），
+   导出时按留档原样补回——用户在站点上删掉的行不在此列，不会被复活。
+
+### 本轮修掉的 5 个不一致（对比脚本 tools/verify_rondbackup.py）
+| 问题 | 根因 | 修法 |
+|---|---|---|
+| ZVISIT 少 1 条 | 导入时 `Arrival == nil` 被跳过 | `skipped` 标记 + 导出补回 |
+| ZVISIT.ZLOCATION/ZACTIVITY_ 全成 NULL | `placeSrcByID` 用 `SrcPK` 当 key，而 `v.PlaceID` 是 PG 自增 id | queryPlaces/queryActivities 改查 `id`，用 id 作 key |
+| 时间戳差 1 微秒 | `Duration(float64秒 * 1e9)` 超出 float64 精确整数范围(2^53) | 整数秒与小数分开算：`int64(sec)*1e6 + round(frac*1e6)` |
+| ZREMARK_/ZEMOJINAME_ 空串变 NULL | 空串当未填写存成 NULL | `keepEmptyString()`：PG 值为 nil 且留档是 `""` 时写回 `""` |
+| 新建地点区县丢失 | 表单「区县」写的是 `district` 列，而导出映射的是 `sublocality` | 导出取 `COALESCE(sublocality, district)` |
+
+另外给 `newRowDefaults["ZLOCATION"]` 补 `ZRADIUS: 100.0`（真机地点都有值，NULL 可能触发 rond 异常状态）。
+
+### 结果
+12 张表（8 托管 + ZRAWVISIT/ZKEYWORD/ZPOICATEGORY/ZACTIVITYGROUP）逐列逐行 **总差异 = 0**；
+31 张表 / 47 个索引 / Z_METADATA(1585B) 结构完全一致；导出包 2871700B。
+新建「昆明站」后重导出：仅 ZLOCATION 多 1 条，其余仍 0 差异；
+新地点 ZPINSTYLE_=0 / ZTYPE_=0 / ZUSERADDED=0（不会再显示「固定」）。
+
+### 编辑表单必填标记
+- CSS 加 `.req`（红色星号）与 `.req-tip`（表单顶部说明行）。
+- 必填：地点=名称/纬度/经度；到访=地点/到达时间；行程=起止到访 src_pk；天气=时间。
+- 服务端补了 `editPlaceCreate` 的名称非空校验；`editPlaceUpdate` 名称留空时保留原值
+  （历史数据里有 1 个无名称地点，不该逼着补名字）。
+
+### 踩坑
+- `patchSQLite` 里 `sdb.SetMaxOpenConns(1)`：`BeginTx` 后任何 `sdb.QueryContext` 都会静默死锁
+  （表现为导出卡 5 分钟无输出）。所有只读查询必须在 `BeginTx` 之前做完。
+- Git Bash 的 `/tmp` ≠ `C:/tmp`，脚本要写到项目内路径。
+- psql 在 `/c/OtherFiles/PostgreSQL/18/bin/`（不是 Program Files）；`pg_restore` 必须带 `-f`。
+
+### 数据
+- 清库前备份 `storage/backup/rond-with-you-20260916-0012.dump`（custom 格式）。
+- 清库时误删了 place_notes(14) / place_votes(4)，已从该备份用 `pg_restore -t ... --data-only` 恢复。
+- 管理员凭据被临时重置过，已从备份还原原始 password_hash（原本就没启用 2FA）。
+
+## 第 5 轮：4 项优化 + 专题展示功能
+
+### 四项优化（用户「都修改」）
+1. **行程 / 天气表单不再手填 src_pk**：抽了通用可搜索选择器 `.picker`
+   （`data-source` 指向隐藏 select，JS 读 option 当数据源——避开模板 JS 上下文转义），
+   地点、起始到访、结束到访、天气关联到访四处复用；新增 `EditData.VisitOptions`（最近 500 条到访）。
+2. **活动可改名 / 删除**：`/admin/edit/activity/update|delete`；删除时把引用它的到访
+   `activity_id` 置 NULL 并清 `is_home/is_work` 冗余标记，再 pruneEntityRaw。
+3. **place_notes / place_votes 加 dataset_id**：主键扩成 (user_id, dataset_id, src_pk)，
+   用 DO 块判断主键列是否已是三列再重建（幂等）；旧数据回填到当前激活数据集。
+   notes/votes 包所有方法加 datasetID 参数，web 层调用点全部跟着改；
+   stats 里 `place_votes` 的 EXISTS 关联加 `pv.dataset_id = p.dataset_id`。
+   place_visitor_votes 保持不挂 dataset_id（设计上刻意跟地点走，注释已写明）。
+4. **异常时长裁剪**：`maxDwellMin = 10080`（7 天），stats 里 6 处 sum + 1 处子查询、
+   refreshPlaceAgg 全部改成 `sum(LEAST(COALESCE(duration_min,0), 10080))`；
+   存量 `places.dwell_minutes` 用等价 SQL 重算过（总停留 259096 → 218659 分钟）。
+
+### 专题展示（新功能）
+- **数据模型** `topics`：标题/副标题/说明、时间范围、中心点+半径（半径 0 = 不限区域）、
+  show_fog、enabled（是否对外展示）、sort_order。
+- **内容**：时间范围内的到访聚合出地点列表；区域过滤用写进 SQL 的 haversine 表达式
+  （`topicHaversineSQL`），一次查询同时完成过滤与统计。
+- **迷雾**不落库：地图用 `rondMap.full()`，瓦片按视口自动呈现——所以只要把视野限到
+  区域（或地点包围盒）即可。为此给 rond-map.js 的 full() 加了 `fitCircle` / `fitBBox` 覆盖默认的点集贴合。
+- **页面**：`/admin/topics`（新建/编辑/删除/开关/排序 + 列表）、`/topics`（卡片列表，只列 enabled，
+  站长看得到未展示的）、`/topics/{id}`（KPI + 地图 + 地点表；未展示的专题访客 404、站长可预览）。
+- 导航入口仅在数据集有专题时出现（`Page.HasTopics`，pageBase 里用一次 EXISTS 查）。
+
+### 两个坑
+- **`#map { height: 100% }` 是 ID 选择器**，`.topic-map { height: 520px }` 压不过它 →
+  容器高度算成 0，地图一片空白且 `fitBounds` 退化到 zoom 3。规则要写成 `#map.topic-map`。
+- 新增页面模板必须在 `pageFiles` 里登记，否则报「未知页面模板」——embed 的 glob 只是把文件带进
+  二进制，页面集仍按 map 显式列举。
+
+### 补：专题页地图不可见（用户反馈）
+用户看到专题页只有表格、没有地图——是我修 `#map` 高度塌陷之前的版本（CSS 优先级 bug）。
+服务端渲染一直是正常的（容器 1058×520、18 张瓦片、3 个聚类）。
+加固：地图高度改为 inline style（`style="height:520px"`，窄屏由 JS 改 360），
+再也不会被外部 CSS 的 ID 选择器影响；容器内加「地图加载中/被拦」兜底提示，
+脚本就绪（容器带上 leaflet-container 类）后 1.2s 自动隐藏。
+
+### 专题页布局与时间精度（用户第 6 轮反馈）
+用户嫌时间范围「缩成一团拆成三行」。根因：时间范围原本塞在 4 列 KPI 网格里，
+23px 字号放不下 `2026-08-14 09:00 ~ 2026-08-16 18:30`。
+
+- **时间范围独立成行**（`.topic-range`，13.5px），详情页放在标题/副标题之下；
+  列表页卡片同样独立一行。
+- **KPI 只放数字**：详情页去掉「时间范围」项，保留 地点/到访次数/涉及城市/累计停留（4 项，桌面 4 列、移动 2 列）；
+  列表页卡片改为 地点/到访/天数（`.kpis-3`，移动也保持 3 列）。
+- **说明文字**从 KPI 卡片里挪出来独立成卡（`.topic-desc`）。
+- **时间精确到分钟**：后台表单 date → datetime-local，并加载 flatpickr（`p.Flatpickr = true`）；
+  后端 `parseTopicTime` 同时接受 `2006-01-02T15:04` 与 `2006-01-02`（老表单兼容），
+  只给日期时把结束补到当天 23:59:59。
+- **显示规则**：整天（00:00 ~ 23:59）只显示日期，避免「00:00 ~ 23:59」噪音；
+  任一端带时刻则完整显示到分钟。
+- 移动端：KPI 2 列、卡片 3 列、时间范围 1 行、地图 360px、无横向滚动（均已实测）。
+
+**坑**：flatpickr 初始化后会把 input 的 `type` 改成 `text`，
+验证脚本里 `querySelectorAll('input[type=datetime-local]')` 会得到空数组——要按 `name` 查。
+
+### 到访记录加搜索（用户第 7 轮）
+之前只有地点列表能搜，到访记录只有分页。现在两处各有独立搜索词：
+- 地点列表 `q`、到访记录 `vq`（`EditData.VisitQuery`）；两个搜索表单互相带隐藏字段，
+  分页链接也带上对方的关键词，切来切去不会丢条件。
+- 到访搜索匹配：地点名 / 城市 / 备注 / 活动名 / **日期**（`to_char(arrival,'YYYY-MM-DD') ILIKE`）
+  / src_pk 精确命中。实测：「喜洲」5 条、「2026-08-14」7 条、「08-14」9 条（模糊）、「196」1 条。
+- 加了 `escapeLike()` 转义 ILIKE 通配符（搜 `%` 不再命中全部、`_` 不再变成任意字符），
+  地点列表的 `q` 也一并转义。
+
+**坑（第二次踩）**：Go 源文件是 CRLF，Python 里用 `"\n".join(...)` 拼出的替换串永远匹配不到。
+这类批量替换必须 `io.open(..., newline='')` 读入后按实际换行符拼串；替换后要 grep 验证真的写进去了
+（本次日期条件第一遍就是静默没生效，靠「搜日期返回 0 条」才发现的）。
+
+### 后台操作后不再跳回页顶（用户第 8 轮）
+后台的收藏 / 删除 / 搜索 / 翻页 / 专题开关都是传统表单提交 + 整页刷新，浏览器一律回到顶部。
+
+做法（layout.html 底部一段通用脚本，只在 `/admin` 下生效）：
+- `submit` 事件（捕获阶段）与「同路径 <a> 点击」时把 `scrollY` + 时间戳写进
+  `sessionStorage["rond:scroll:"+pathname]`；
+- 新页面 **load 之后**读出来滚回去（`document.readyState==="complete"` 时直接执行）。
+- 10 秒有效期：用户点了删除又在确认框里取消时留下的记录，不该在下次打开页面时把视图拽走。
+- 只对后台生效：前台「主页 → 详情」本来就该从头看。
+
+**两个坑**：
+1. 恢复必须在 `load` 之后做。放在 `</body>` 前的同步脚本里，文档高度还没定，
+   `scrollTo` 会被截断到 0（表现为「偶尔不生效」，CDP 直接 Page.navigate 时必现）。
+2. 验证要模拟真实路径：`form.submit()` 不触发 submit 事件，得点 `button[type=submit]`；
+   两步导航的验证脚本 import `site_cdp` 复用它的 CDP 类即可。
+
+## 新功能：照片批量导入（EXIF → 预览确认 → 落库）
+
+用户要「批量选照片 → 读 EXIF 生成地点 → 逐个修改确认 → 入库；拍照时间=到达时间，
+离开默认 +10 分钟可改」。
+
+### 实现
+- **`internal/exif`（新包，零依赖）**：手写 JPEG EXIF 解析。
+  只读两样：ExifIFD 的 `DateTimeOriginal(0x9003)` 与 GPS IFD 的度分秒 + 南北/东西半球。
+  流程：SOI 后逐段扫描 → APP1 且以 `Exif\0\0` 开头 → TIFF header（II/MM）→ IFD0 →
+  0x8769 指向 ExifIFD、0x8825 指向 GPS IFD。值 ≤4 字节内联在条目里，否则是偏移。
+  测试用「手工拼的最小 JPEG」覆盖：正常坐标 / 南纬西经 / 非 JPEG / 无 EXIF。
+- **`handlers_photos.go` + `templates/admin/photos.html`**：
+  `GET /admin/photos` 选照片 → `POST /admin/photos/parse` 解析并渲染可编辑确认表
+  （每行：是否导入 / 地点名 / 经纬度 / 到达 / 离开 / 说明）→ `POST /admin/photos/import` 落库。
+  上传与导入分两步，预览表单带着全部数据，不需要服务端暂存。
+- **坐标必须转**：EXIF 是 WGS-84，库内是 GCJ-02，用 `geo.WGS84ToGCJ02`。
+  实测 (25.6890,100.1560) → (25.686043,100.157229)，偏移约 350m，符合纠偏特征。
+- 每张照片 → 一个 place + 一条 visit（`is_user_added=TRUE`），src_pk 取 MAX+1 递增。
+- 上限：60 张 / 单张 25MB；HEIC 直接给出「暂无 EXIF 支持」的明确提示。
+
+### 边界
+- 无 GPS / 无拍摄时间 → 该行给出说明，默认取消勾选。
+- **GPS 写 (0,0) 的情况**（相机没定位时的常见写法）要当成无 GPS，否则会生成几内亚湾的点。
+- 导入时再校验一次坐标与时间，无效行跳过并在 flash 里说明跳了几张。
+
+### 追加：HEIC/HEIF 支持（用户反馈「现在手机默认都是 HEIC」）
+在 `internal/exif` 里加了 HEIF 容器解析（`heif.go`），并把 `Parse` 改成按魔数分发：
+JPEG（FFD8）走 `parseJPEG`，ISO BMFF（第 5~8 字节是 ftyp）走 `parseHEIF`。
+
+HEIC 的结构与取 EXIF 的路径：
+- 顶层找 `meta`（FullBox，负载前 4 字节是 version+flags）；
+- `iinf` 里遍历 `infe`，取 `item_type == "Exif"` 的 item_ID（v2 起 item_type 在 payload+8）；
+- `iloc` 里按 item_ID 找数据段：注意 offset/length/base_offset 的长度是「字节长度字段」，
+  v1/v2 还多一个 construction_method 与 index_size，必须逐个 readN 推进指针；
+- Exif item = 4 字节 TIFF 偏移 + 标准 TIFF → 后半段直接复用 `parseTIFF`（与 JPEG 完全共用）。
+
+要点：
+- 不引 libheif：内网/离线构建下 CGO 依赖太麻烦，而我们只要 EXIF；
+- `Parse` 的读取上限提到 32MB：HEIC 的 Exif item 位置由 iloc 指到绝对偏移，可能在文件靠后；
+- 新增测试：HEIC 正常解析、只有 meta 没有 Exif item、以及**截断到各种长度都不 panic**
+  （上传中断/文件损坏在真实世界都会出现，边界检查得逐个 readN 做）。
+- 实测：同一个表单里 HEIC + JPEG 混合上传，两张都正确解析出坐标与拍摄时间并成功入库。
+
+### 时间线排序按钮无效（用户第 9 轮）
+症状：「最早在前」点了没变化。
+根因：`timelinePage` 里把排序方向**硬编码**写死成 `"desc"`：
+`s.q.Visits(..., "desc")` —— 按钮生成的 `?sort=asc` 被完全忽略（查询层 `Visits` 本来就支持 asc）。
+修好后按 `p.Sort` 决定方向。
+
+实测：默认首日 2026-09-13 / 首条 20:40；`?sort=asc` 首日 2025-02-10 / 首条 12:00，
+按天分组的**天序与组内顺序都跟着反转**（groupByDay 按输入顺序建组，无需另改）。
+顺带核实地点库的 4 个排序按钮（到访次数 / 停留时长 / 最近到访 / 名称）数据确实会重排，无同类问题；
+翻页链接里也带了 sort（filterPairs 已包含），切页不会丢排序。
+
+**教训**：这类「按钮看得见但没反应」的 bug，根因多半是 handler 没用页面传来的参数
+（硬编码常量兜底），排查时先顺着「模板生成什么参数 → handler 读了没有」这条线走，比查 SQL 快得多。
+
+### 排序按钮（续）：切回默认不生效的真根因
+上一轮只修了「handler 硬编码 desc」，用户复现出第三类问题：
+**进入（默认）→ 最早在前（成功）→ 再点最新在前（失败）**。
+
+两个叠加的根因（都在链接拼装层，与 SQL 无关）：
+1. 「最新在前」按钮写成 `{{.Link .FilterBase}}`，而 `filterPairs()` 会把当前的 `sort=asc`
+   一起带上 → 点它得到的还是 `?sort=asc`。模板要显式清键：`{{.Link .FilterBase "sort" ""}}`
+   （`buildURL` 会跳过空值，所以空串等价于删除该参数）。
+2. `Link()` 把 extra 直接 append 到筛选参数后面，同键会拼成 `?sort=dwell&sort=name`，
+   而 `q.Get()` 只取**第一个** → 地点库从一个排序切到另一个也「点了没反应」。
+
+一并修掉：`Link()` 现在让 extra **覆盖**同名键（先按 extra 的键过滤 kv，再追加），
+值为空则等于删掉。地点库「到访次数」也改成显式清 sort。
+
+实测完整链路（进入 → 最早在前 → 最新在前）：首日 2026-09-13 → 2025-02-10 → **回到 2026-09-13** ✓；
+地点库在任一排序下点其他项，href 都是单一 sort 参数、点「到访次数」回到 `/places`。
+
+**教训**：页面筛选类的「点了没反应」，除了看 handler 有没有读参数，还要看**链接里参数有没有被正确替换/清除**——
+重复参数（`?a=1&a=2`）会让 `Get` 只认第一个，表现为「只能单向切」。
+
+### 照片导入改为「浏览器读 EXIF」（用户实测 51 张 334MB 崩掉）
+用户问得对：**原来的 EXIF 是在后端读的**，意味着每张照片都要先传到服务器。
+实测 51 张 / 334MB → 直接崩，原因链：
+- `http.MaxBytesReader(..., photoMaxBytes*4)` = **100MB 请求体上限**，334MB 当场被截断；
+- 即使放宽，`ParseMultipartForm` 会把超出内存的部分落磁盘，1C1G 上很难看；
+- 而且早期 handler 里只读前 2MB 交给解析器，**HEIC 的 Exif item 可能在文件后部**，本来就会漏。
+
+**改成前端解析**（`static/js/photo-exif.js`，算法与 Go 版一一对应，但必须分片读）：
+- 先 `file.slice(0, 64KB)` 读头部：JPEG 的 APP1、HEIC 的 meta/iinf/iloc 都在这一段；
+- HEIC 的 Exif item 位置由 iloc 给的是**绝对偏移**，若超出已读范围就再按偏移读那一小段；
+- 串行逐个读（并发几十个 FileReader 在手机上容易吃满内存）；
+- 页面只提交文本：`n` + 每行 name/lat/lon/arrival/departure + `wgs84=1`；
+  坐标转换仍放在服务端（`geo.WGS84ToGCJ02`），避免前后端两份实现跑偏。
+
+实测：**51 张 334MB → 1.2 秒**读完、51 张全部拿到坐标、表格 51 行、0 报错；
+服务端确认照片不过网（file input 无 name、form 无 multipart）。
+坐标链路单独验过：提交 WGS-84 (28.191654,106.123456) → 库存 GCJ-02 (28.188390,106.127306)，
+与 `geo.WGS84ToGCJ02` 的期望值一致。
+
+**加了世代号保护**：测试时发现 change 触发两次会让表格出现**双份行**（真实场景里用户连续选两次文件同样会中招）。
+用 `gen` 计数，旧一轮的解析结果一律丢弃。
+
+服务端 `internal/exif` 包保留（已无调用点）：它是 JS 实现的对照物，未来 JS 解析出问题时可以拿 Go 版交叉验证；
+若确定不再需要，可连同 `internal/web/handlers_photos.go` 里已删的上传路径一起清理。
+
+### 照片导入：地址反查 + 地图预览 + 坐标系可选
+用户反馈「只看经纬度看不出点对不对」+「不是所有手机都用 WGS-84」。
+
+1. **逆地理编码（新增 `POST /api/regeo`）**：坐标交给服务端 → 转成 GCJ-02 → 调高德 regeo
+   → 返回 formatted_address + 省/市/区/街道/乡镇。要点：
+   - **按 5 位小数去重**：同一地点拍的多张只查一次（省配额也省时间）；
+   - 4 并发 + 30 秒超时；
+   - 结果带 `key` 原样回传（前端传行号），否则去重后配不回原来的行。
+2. **名称默认用地名**：反查成功后，若名称还停在文件名（用 `dataset.initial` 判断用户是否改过），
+   换成「区县 + 街道/乡镇」——`IMG_20251219_095042` → `雨花区花侯路`。
+3. **地图预览**：`rondMap.preview` 把所有点画出来；坐标系选错时会跑到国外/海里，一眼可见。
+4. **坐标系可选**：WGS-84（默认）/ 已经是 GCJ-02（部分国产手机直接写 GCJ-02）。
+   实测同一坐标两种选择反查出的街道不同（相差几百米），说明选择真的生效。
+5. **每行「更多」**：类别/省份/城市/区县/街道/时区，反查结果自动预填，可改；导入时一并落库。
+
+实测 51 张 334MB：4.2 秒（含 51 次反查），51 个点位全部成功，0 报错。
+
+**坑**：`photo-exif.js` 一开始放在页面底部，DOM 还没解析到它就执行了内联脚本，
+`window.rondExif` 还是 undefined → 内联脚本直接 return，表现为「选了文件毫无反应」。
+把脚本移到页面最前面解决。另外 curl 在 Git Bash 里测静态文件大小会显示 0B（write error），
+用 `curl -s ... | wc -c` 才准。
+
+### 照片导入的字段补齐到与「新增地点」一致
+用户要求：类别、活动也要像新增地点那样是**可选下拉**，字段完全对齐。
+
+「更多」区现在分三行：
+1. **类别（下拉，16 项：已有类别中文 + 「自定义…」）**、国家代码、省份、城市、区县、街道、时区；
+2. **活动（下拉，31 个活动）**、备注、标记为收藏；
+3. 标签（多选 chips，与新增地点同款）。
+反查到的省/市/区/街道自动预填，类别与活动由用户选。
+
+实现要点：
+- 选项数据与数据编辑页**同源**（`editOptions` 查 activities/tags，类别查 `DISTINCT poi_category`），
+  保证两处能选的东西完全一致；
+- 选项通过**隐藏 select** 传给前端（内联 JSON 会被模板 JS 上下文转义搞坏，这个坑踩过）；
+- 写入复用 `insertVisit()`（内部含标签关联与 `refreshPlaceAgg`），
+  与「新增到访」走同一条路径——活动/备注/收藏/标签的行为因此天然一致；
+- 类别支持「自定义…」（`categoryCustomValue` 常量与数据编辑页共用）。
+
+实测落库：poi_category / country_code / province / city / district / thoroughfare / timezone /
+activity_id(纪念馆) / remark / bookmarked / visit_tags(羊肉粉店) 全部正确。
+
+**验证脚本的坑**：`DOM.getDocument` 拿到的 nodeId 在页面尚未就绪时会失效，
+报 `Could not find node with given id`——要等页面稳了再取，并加重试。
+
+### 照片导入：单点地图 + 高德限速
+用户反馈「所有点挤在一张图看不出哪个是哪个」+「一次性请求太多也不好」。
+
+1. **总图保留、每行可单独看图**：说明列加了「地图」链接（与「更多」并列），点开是个弹窗，
+   里面一张街区级（zoom 16）的地图指着这个点，标题是地点名、副标题是「地址 · 坐标」。
+   - **只建一个 Leaflet 实例**反复用（`setPoints` + `setView` + `invalidateSize`），
+     否则 51 行各建一个地图会直接卡死浏览器；
+   - 单点 `fitBounds` 会顶到最大缩放，所以底图就绪后用 `setView(..., 16)` 覆盖；
+   - 支持 Esc / 点遮罩关闭。
+2. **高德限速 10 QPS**：`time.NewTicker(time.Second / regeoQPS)` 逐个发令牌，
+   超出的请求排队等待（原来的「4 并发」只限制了并发数、没限制速率）。
+   51 个点位的反查耗时从 4.2 秒变成 6.3 秒——变慢正是限速生效的证据，也避免触发
+   `CUQPS_HAS_EXCEEDED_THE_LIMIT`。请求超时相应放宽到 60 秒。
+
+实测：总图 51 个点；单点弹窗标题「雨花区花侯路」、副标题「湖南省长沙市雨花区东山街道平阳路 · 28.141772, 113.067569」、
+zoom=16、9 张瓦片；关掉再点另一行，地图中心切到新点（实例复用成功）。
+
+### 「地图」两字被拆成两行
+原因：**中文默认可以在任意字之间断行**（`word-break: normal` 对 CJK 就是逐字断），
+说明列窄（220px）里放着说明文字 + 「地图」「更多」两个链接，链接被挤到只剩一个字宽。
+
+修法：
+1. 两个操作链接包进一个 `white-space:nowrap` 的容器，与说明文字分行；
+2. CSS 加一条通用规则 `.tb a { white-space: nowrap; }` —— 表格里的行内链接一律不许折行，
+   免得以后再加「编辑」「删除」这类两字链接又踩同一个坑。
+
+**扫描全站时学到的判据**：想查「短文本有没有被拆行」，别用元素高度
+（按钮的 padding、emoji 都会让高度超标），要用 Range 量文本实际占几行：
+```js
+var r = document.createRange(); r.selectNodeContents(el);
+r.getClientRects() 里 top 去重后的个数 = 行数
+```
+并且要跳过**含子元素**的节点（emoji 圆点都是子元素，会量出多个矩形）。
+收紧判据后扫 12 个页面：零命中。
+
+### 照片导入表：把「更多」挤出视口 → 改固定列宽
+症状：8 列加起来超出视口，最右边的「地图/更多」要横向拖动才看得到。
+根因：每个 input 自带 `min-width`（我原来给地点名 120px、坐标 98px、时间 170px…），
+列宽由内容撑开，总和必然超过屏幕。
+
+改法：`table-layout: fixed` + `<colgroup>` 百分比列宽（4/10/12/12/20/14/14/14），
+输入框统一 `width:100%; min-width:0` 跟着格子走。
+
+实测：1440 / 1280 / 1024 三种宽度**都没有横向滚动**、8 列全部可见，
+「地图@1098-1122」「更多@1132-1156」都在 1440 视口内。
+手机端（≤700px）额外隐藏信息量最低的「文件」列，最小宽度从 880px 降到 640px
+（8 列表格在 390px 屏上物理上放不下，滑动仍不可避免，但滚动量小了）。
+
+**注意**：`tInput` 里我一度写了个未定义的 `inPhotoTable` 变量——`node --check` 只查语法，
+这种运行时 ReferenceError 查不出来，是靠读代码发现的。这类模板内联 JS 的改动，
+除了语法检查还要过一眼变量引用。
+
+### 照片导入：失败重试 + 最近店名
+用户问「查不到的地址能否再查」「能否给最近的地点（店名）而不是街道」。
+
+1. **重试**：
+   - 网络层：`amapGet` 失败退避重试 3 次（400ms / 800ms）；
+   - 交互层：新增「重新反查未成功的」按钮，只挑地址列还是占位符「—」的行重发。
+2. **店名（关键）**：不要用 regeo 的 `pois`——`extensions=all` 返回的 30 条多是行政单位
+   （实测「雨花区黎托乡东山村村民委员会」）。改用**周边搜索** `place/around`：
+   `radius=200 & offset=1 & sortrule=distance`，按距离排序取第一条才是店名
+   （实测「悦达餐厅」95m、「浏阳蒸菜…」145m）。
+   显示成「店名（距离）· 完整地址」，地点名默认也用店名；取不到就退化成「区县+街道」。
+3. **限速位置调整**：原来的令牌桶放在 `apiRegeo` 的循环里（按点位发），
+   现在每个点位要发 2 次请求（regeo + around），按点位限速就不准了 →
+   把限速挪进 `amapGet`，所有高德请求统一 10 QPS。51 张照片耗时 6.3s → 11.3s（102 个请求），符合预期。
+4. 实测：51/51 点位反查成功，其中 **31 个拿到店名**（其余 20 个周边 200m 内没收录）。
+
+**踩的坑**：`rowRefs` 定义在 change 回调内部，而 `applyOne`/重试按钮在外层作用域 →
+运行时报 `rowRefs is not defined`，表格地址全空。提到外层解决。
+另有：用 Python 改模板 JS 时，替换后残留了一段旧回调代码，`node --check` 抓到了多余的大括号
+——**改完模板内联 JS 一定要跑一次语法检查**。
+
+### 导出 fwss 缺内容（用户怀疑得对）+ 收藏按钮被挤出视口
+
+**1. 收藏被挤出**：`.row` 里的备注设了 `flex:1 1 220px`（会自动拉伸占满剩余空间），
+把最右边的「标记为收藏」顶出了可见区域。改成 `flex:0 1 260px`（不拉伸）后三者紧凑排列：
+活动右边界 376 / 备注 646 / 收藏 748，都在 1440 视口内。
+
+**2. fwss 导出确实缺数据**（这是本轮最重要的发现）。
+fog of world 的快照里有**三类瓦片**，我们原来只解析了第一类：
+
+| 目录 | 原始包里 | 每块字节 | 原来 |
+|---|---|---|---|
+| `Model/*` | 52 个 | 512 + 3（位图 + 元信息） | 解析并导出 ✓ |
+| `Model/~` | 52 个 | 512（纯位图） | **被跳过** ✗ |
+| `Model/#` | 54 个 | 3（仅元信息） | **被跳过** ✗ |
+
+体积正好对得上：`*` 类未压缩 6.18MB / 三类 13.8MB ≈ 45%，而导出是 299KB / 原始 680KB ≈ 44%。
+
+修法（`internal/fog/layers.go` + `fog_raw_files` 表）：
+- 新增 `RawLayers(data)`：从快照里挑出**非 `Model/*`** 的条目，存**原始压缩字节**（不解压、不重组）；
+- 上传时调 `SaveRawLayers` 落库；导出时 `LoadRawLayers` 读出、原样写回 zip；
+- `Encode(blocks, layers)` 签名相应增加一个参数；
+- 已用一次性脚本把现有快照的 106 个文件补录进库。
+
+实测：导出 **299KB → 701KB**，条目 158→169（`*` 63 + `~` 52 + `#` 54），
+往返解析块数/格数完全一致（10542 块 / 670565 格）。
+（`*` 比原始多 11 个瓦片，是因为库里是多次导入合并后的 10542 块，比单个快照的 8701 块多。）
+
+**教训**：解析第三方文件格式时，先**枚举压缩包里的全部条目并按目录分组**，
+别看到一类目录就以为全了——`Model/*` 那 52 个文件只是三分之一。
+
+### 程序新建的地点显示「无数据」——最近活跃时间（ZLOCATION.ZLASTARRIVALDATE_）
+
+**现象**：app 里加的地点（如贺州站(出站口)）能显示「最近活跃时间」，程序（照片导入 / 手工新增）建的地点一律显示「无数据」。
+
+**取证**（别再靠猜，实测数据如下）：
+- 枚举 ZLOCATION 全部 33 列，时间类只有 `ZLASTARRIVALDATE_` 一列，
+  贺州站(#97) 该列 = 2025-09-21 17:43 = 它唯一一次到访的到达时间 → 它就是「最近活跃时间」。
+- 原始包 323 个地点的分布：有到访 281 个写最新到访时间、2 个写 distantPast 哨兵（app 自己漏更新）；
+  无到访 38 个写哨兵、2 个写 NULL。**哨兵值 = -63114076800**（Core Data 的 distantPast，
+  换算即公元 1 年），判空时不能只看 IS NULL。
+- 我们这边：`ZLASTARRIVALDATE_` 在代码里**零引用**——parse 不读、export 不写。
+  数据库里 367 个地点有 326 个 `places.last_visit_at` 有值（refreshPlaceAgg 算得很准），
+  只是导出没把它写进包，新行留 NULL → rond 显示「无数据」。
+
+**修法**（`internal/rond/export.go`）：
+1. `ZLASTARRIVALDATE_` 加进 `managedCols["ZLOCATION"]`，值取 `places.last_visit_at`（`appleSeconds`）；
+2. 新增 `keepNilCols`：PG 侧为 NULL 时**保持基线原值**——从没到访过的地点，
+   app 写的是哨兵或 NULL，站点复现不了就别用 NULL 去覆盖。
+   落到 `tableWriter.keep`：UPDATE 分支跳过该列、writeFull 分支回退留档原值（新增 `typeOf` 取列类型）；
+3. `pgPlace` 加 `LastVisitAt sql.NullTime`，`queryPlaces` 多取一列。
+
+**实测**：导出 367 个地点里「有到访却为空」从 43 个降到 **0**；程序新建的地点现在都带时间
+（茶颜悦色 → 2025-12-21 14:01）。无到访的 41 个保持原样（38 哨兵 + 3 NULL）。
+与原始包逐行比对：除用户手改过的 4 条到访（导出跟随真值，是应该的）+ 哨兵回填 2 条，零漂移。
+
+**新增回归测试** `TestLastArrivalDateMatchesVisits`（需 ROND_EXPORT）：断言每个有到访的地点
+该列 == max(ZVISIT.ZARRIVALDATE_)。拿旧导出跑会失败 —— 已验证它抓得住这个 bug。
+
+**顺带**：
+- `tools/verify_rondbackup.py` 原来把两个包路径写死在文件头，改成可传命令行参数。
+- `TestExportRoundtrip` 是「同一份数据」的严格对比，数据一旦被编辑过就会失败
+  （旧导出文件现在跑同样失败），不是本次改动引起的。
+
+**留了个待批的小问题**：照片导入是「先 INSERT places、再 insertVisit」两步且无事务，
+写到访失败时地点会留下成为孤儿（visit_count=0），它导出去照样显示「无数据」。
+另外手工新增地点的「到访时段」是选填的，留空就只建地点——这种本该显示「无数据」，属正常。
+
+### 照片导入并入事务 + 全库「输入了但导出缺东西」的系统排查
+
+**1. 照片导入/手工新增改成事务**（`internal/web`）
+- 新增 `execer` 接口（`*sql.DB` 与 `*sql.Tx` 的公共子集）与 `Server.withTx`；
+  `insertVisit` / `saveVisitTags` / `refreshPlaceAgg` 加一个 `ex execer` 参数，其余调用点传 `s.db`。
+- 照片导入：每张照片的「建地点 + 建到访」放进一个事务；失败整体回滚并把 `nextPlaceSrc--` 让出主键。
+- 手工新增（`editPlaceCreate`）：**把所有校验提到落库之前**，再开事务写「地点 + 到访」。
+  以前是先建地点、再校验时段，时段不合法就留一个没有到访的地点（提示还写「地点已新增」）。
+  实测：非法到达时间提交后 places/visits 计数完全不变；合法提交则地点+到访一起落库。
+
+**2. 系统性排查「用户输入了、导出到 rond 却缺东西」**（这次最有价值的部分）
+两步法，缺一不可：
+ - **代码层**：把 `internal/web` 的 INSERT/UPDATE 列与 `export.go` 的 `managedCols` /
+   `newRowDefaults` 对照，找出「站点写了但导出不写」的列；
+ - **数据层**：拿原始包（app 造的行）与导出包（程序新建的行，`Z_PK > 基线最大主键`）
+   **逐列比对非空计数**。注意各表主键区间不同，基线最大主键要**按表分别算**。
+   凡是「app 高覆盖、新建行全空」的就是缺口。
+
+查出并修掉的缺口（`internal/rond/export.go`）：
+| 列 | 真机覆盖 | 修法 |
+|---|---|---|
+| `ZLOCATION.ZRAWLATITUDE/ZRAWLONGITUDE` | 323/323 | 新地点用 `geo.GCJ02ToWGS84(lat,lon)` 反算填上 |
+| `ZVISIT.ZIDENTIFIER_` | 822/824 | 新到访补确定性 UUID（16 字节） |
+| `ZACTIVITY.ZUID_` | 30/30 | 新活动补确定性 UUID |
+| `ZACTIVITY.ZLASTARRIVALDATE_` | 29/30 | 由「该活动下最晚到访」算（已逐行验证 28/30 精确相等） |
+| `ZTAG.ZLASTARRIVALDATE_` | 8/8 | 由关联表聚合（验证 6/8 相等） |
+| `ZACTIVITY.ZICON_` | 30/30 | 站点无图标入口，缺省 `📍`（同站点模板 `iconor` 兜底） |
+
+**关键发现：raw 坐标是 WGS-84**。`ZLATITUDE` 是 `gcj(ZRAWLATITUDE)`——用 Python 复刻 GCJ-02
+正变换验证 293/323 精确命中（另 30 个是用户挪过点的）。所以新地点要反算 WGS-84，不能直接复制。
+
+**UUID 必须确定性**：真机存的是 v4 随机值，但站点用它当身份标识，随机会导致每次导出都变、
+rond 把同一批记录当成新的。改用 UUIDv5（命名空间 + `表名/src_pk`，src_pk 跨快照稳定）。
+
+**新增测试**（`internal/rond/export_roundtrip_test.go`）：
+- `TestUUIDv5`：同名校验确定性、版本/变体位、跨表不碰撞；
+- `TestProgramRowsFillNativeColumns`：导出包里「新建行」的原生列必须全部有值
+  （拿旧包跑会失败，已验证抓得住）。
+
+**确认不是缺口的列**（真机自己也是空的，别去「修」）：`ZVISIT.ZRAW`（是整数，原始采样点
+**数量**；真机手工加的到访同样为空）、`ZMERGEDTO`/`ZPARENT`/`ZTIMEZONEIDENTIFIER`、
+`ZLOCATION.ZNOTE_`（站点另有 place_notes，且是 rond→站点的单向汇总，不回写）。
+
+**顺带确认的两件事**：
+- `TestExportRoundtrip` 是「同一份数据」的严格对比，数据被编辑过就会失败（旧包现在也失败），
+  别把它当成本次改动的回归信号。
+- `gofmt -l` 会把全仓库都列出来：文件是 CRLF 行尾，属既有状态，不是格式坏了。
+
+### 迷雾（fog of world）这边有没有同类问题——有，修掉了
+
+用户问「另一边的迷雾数据库会不会有类似问题」。方法是把整条往返链路**逐字节**比对：
+写一个临时程序（`fog.Decode` + `RawLayers` → `fog.Encode`）拿真机快照
+`data/Snapshot-20260914T154839+0800.fwss` 做「解析→重打包」，再逐条目、逐块、按格比对。
+
+**结论：位图 0 差异、瓦片名 0 差异、块索引结构 0 差异，但 3 字节元信息 8701/8701 全部不一致。**
+- 真机：`[0x00, hi, lo]`，那 3 字节其实是一个**大端 24 位数 = 置位数×2+1**
+  （118 格 → 0x0000ED = 237 ✓）。64×64 块最多 4096 格 → 值 ≤ 0x2001，**最高字节在数学上恒为 0**。
+- 旧 `extraBytes` 却按臆造的 `0x10, 0x80|…` 生成（大概是早先写体积对比实验时的猜测被抄进了实现）。
+  修法：`return []byte{0x00, byte(sum>>8), byte(sum&0xFF)}`，并写清楚为什么最高字节恒为 0。
+
+顺带搞清了包的层级结构（之前只模糊知道「三类瓦片」）：
+- `Model/*/` = 头 32768 + 每块 515（512 位图 + 3 元信息），id 区间 110996~115099；
+- `Model/~/` = 头 + 每块 512（纯位图）；`Model/#/` = 头 + 每块 3（纯元信息）。
+  这两层的**文件名用另一套编码，与 `*` 完全不重叠**（三者的名字集合两两交集为 0），
+  所以无法一一对应；只要**原样留住**就不会丢东西——实测这两层导出后逐字节一致。
+- `.fwss` 的 zip **条目内容本身就是 zlib 流**，不是明文（这点搞错过一次：拿解压后内容去比压缩字节，
+  白白困惑了一阵）。
+
+**另外两处同类隐患，一并修了**：
+- `RawLayers` 原来只留 `Model/` 之下的条目，若快照出现别的顶层条目就会被丢掉；
+  改成「留住全部条目，剔除已探索层与被 Decode 解析掉的瓦片（按文件名判断，避免解析一遍又写一遍）」。
+  顺手把「超 8MB 就报错」加上，不再用 `LimitReader` 静默截断。
+- `清空迷雾` 只删了 `fog_blocks`，留存的 `~`/`#` 还在 → 导出的快照会有图层条目却没有对应的
+  `Model/*` 瓦片。现在 `清空` 与 `整体替换(cover)` 都会连 `fog_raw_files` 一起处理。
+
+**实测（站点实际导出，10542 块）**：
+- 每块元信息符合公式 **10542/10542**，首字节全为 0；
+- `Model/~` 52/52、`Model/#` 54/54 与原始快照**逐字节一致**；`Model/*` 瓦片 0 缺失；
+- 「导出 → 清空 → 重新上传 → 再导出」**169 个条目 0 差异**（清空后库为 0/0，还原后 10542/106）。
+
+**新增测试** `internal/fog/fog_test.go`：
+- `TestNativeSnapshotRoundtrip`（需 FOG_SRC）：条目名集合、按格逐块比对位图与元信息、其它层逐字节；
+  拿旧的 `extraBytes` 跑会失败（已验证）；
+- `TestExtraBytesEncoding`：钉住 3 字节编码，含满块 4096 格 → 002001。
+
+**留待真机验证的一点**：`~`/`#` 两层覆盖的瓦片与 `*` 完全不同，我们无法为「新点亮的迷雾」生成这两层
+的条目。若 fog of world 实际读的是这两层，那么站内新加的迷雾就不会体现在那里——但站点本身没有
+手工点亮格子之类的功能，迷雾只会来自上传的快照，所以这条影响面很小，标记为待真机确认。
+
+### 迷雾图层默认打开（前端）
+
+用户反馈：迷雾浓度滑杆一直摆在图上，但图层默认是关的，会让人以为功能已经开了。
+根因：`rond-map.js` 的 `full()` 里 `fogLayer` 只注册进 `L.control.layers()` 的 overlays，
+**从没 `addTo(map)`**（Leaflet 的 overlay 默认不勾选），而滑杆却无条件创建。
+
+改法（`internal/web/static/js/rond-map.js`）：
+- `addFogOpacityControl` 返回控件本身（原来是 `new Ctl().addTo(map)` 丢弃返回值），
+  这样能拿到 `getContainer()` 去显隐；
+- 默认 `fogLayer.addTo(map)`；只有用户自己关过（`localStorage['rond.fogOff']==='1'`）才不显示；
+- 监听 `map.on('overlayadd overlayremove')`（判 `e.name === '世界迷雾'`）同步：
+  图层关掉就把浓度滑杆一并 `display:none`，并把开关状态写回 `rond.fogOff`。
+  这样「控制项」和「实际状态」永远一致，不会再出现「滑杆在、迷雾不在」。
+
+**注意**：静态资源走 `//go:embed static`，只有 `debug=true` 时才直读磁盘
+（见 `server.go` 的 routes：debug 下 `http.Dir("internal/web/static")`）。
+本项目 conf/app.ini 是 `debug = true`，所以改 JS 不用重编即可验证；但**生产模式必须重编**。
+
+**无头实测**（`rond-web-verify` 技能，1440 与 390 两个视口）：
+- 首次打开：图层勾选 true、浓度控件可见（116×49，在视口内、与图层/缩放控件不重叠）、
+  滑杆默认值 90、迷雾瓦片 30 个全部加载（移动端 12 个）、无 JS 报错；
+- 取消勾选：瓦片全部撤下、浓度控件 `display:none`、`rond.fogOff=1`；
+- 再勾选：全部恢复；
+- 专题页 `/topics/3` 同样 18/18 瓦片加载；首页走 `preview()`，本来就没有迷雾与滑杆，未受影响。
+
+**顺手发现的（未改，等确认）**：专题管理页那个「展示世界迷雾」勾选框（`topics.show_fog`）
+**在前端根本没被读**——`topic.html` 调 `rondMap.full()` 时没把 `ShowFog` 传进去，
+`view.go` 的 `ShowFog` 字段也没有渲染消费方。也就是说它一直是个死控件。
+库里唯一的专题 `show_fog=t`，所以当前行为无差异；要不要把它接上（专题页可不显示迷雾）等用户定。
+
+### 专题迷雾开关接上 + 用户名可改 + 登录验证码
+
+**1. 专题的「展示世界迷雾」生效**
+`topics.show_fog` 一直是个死控件：`topic.html` 调 `rondMap.full()` 时没传，`view.go` 也没有消费方。
+现在模板传 `showFog: {{if .Topic.ShowFog}}true{{else}}false{{end}}`，
+JS 侧 `var wantFog = opts.showFog !== false;` —— 为 false 时图层、浓度滑杆、图层选项都不出现。
+实测：把 show_fog 置 false → fog 瓦片 0 个、无浓度滑杆；还原 true → 18/18 瓦片、滑杆回来。
+
+**2. 用户名可改**（`/admin/password` 页面升级为「账号设置」，导航按钮同步改名）
+- `auth.Store.ChangeUsername(ctx, userID, current, name)`：先验当前口令，再查占用，最后 UPDATE。
+  新增 `ErrUsernameTaken`。**改名不会踢掉当前登录**——会话 cookie 只含 uid 与口令摘要，都不含用户名。
+- 校验（`validateUsername`）：2~32 个字符（按 rune 数）、不含空白与控制字符、不能与当前同名。
+- 新增路由 `POST /admin/username`；失败时带上 `Username` 回显。
+- 实测：四条负路径（同名/太短/含空格/口令错）文案都对且库未被改动；
+  正路径用一个**临时用户**的 DB 测试覆盖（`ROND_DSN` 门控）：口令错 → ErrInvalidCredentials、
+  占用 → ErrUsernameTaken、改名成功 → UserByID 拿到新名、旧会话 token 仍有效、原口令仍可登录，
+  结束自动删除临时用户。
+
+**3. 登录图形验证码**（新包 `internal/captcha`）
+- 自绘 PNG，**不引新依赖**：内置 5×7 点阵（数字 + 大写字母），放大 4 倍后逐字符抖动，
+  再叠干扰线与噪点。取码字符集去掉 0/O、1/I/L。
+  **踩过的坑**：字符宽 20、步长 26 时抖动后最小间距只剩 2px，相邻笔画会串在一起
+  （回读测试把 L 读成了 E）→ 步长改 30，画布 130×40。
+- 服务端只存答案：`Store`（内存 map + 过期 + 上限剔除），一次性使用，10 分钟过期。
+  `Issue()` 出图并返回 id（写进 `rond_captcha` cookie），`Verify()` 无论对错都作废。
+- `GET /captcha` 出图（`Cache-Control: no-store`）；登录页 `<img>` 引用它，点击带时间戳换一张；
+  `loginSubmit` **先验码再验口令**，失败提示「验证码不正确或已过期」。
+- 测试：`internal/captcha` 覆盖一次性/过期/大小写容错/清理，以及**从图里逐位回读答案**
+  （模板匹配，命中加分误命中扣分）——这条同时保证「图里画的确实是答案」，否则用户会被自己锁在门外。
+- 端到端（真实 HTTP + 从 PNG 回读验证码）：正确码 + 错口令 → 走到「用户名或密码错误」；
+  同一张码二次使用 → 被拒；新码 + 错码 → 被拒；无 cookie → 被拒。
+
+**登录页布局踩的坑**：`input[type=text]` 全局 `width:100%` 会把验证码图挤到下一行；
+且 `label.f > span` 的 `display:block` 会盖掉 `.row` 的 flex（`.f > span` 特异性更高）。
+改用 `div class="row"` + 输入框内联 `flex:1 1 0;width:auto;min-width:0`。
+实测 1440/390/320 三个宽度：输入框与图同一行、间距 8px、无横向溢出、无 JS 报错。
+
+**说明**：验证码能挡住傻瓜机器人，但**挡不住 OCR**（可回读就是证明）。
+真正的防线仍是已有的 TOTP 两步验证——这点在回复里跟用户讲清楚了。
+
+### app.ini 里的库不存在时自动创建
+
+`db.Open` 原先只会 Ping 一次然后报错。现在：Ping 失败且错误是**「库不存在」**（SQLSTATE 3D000，
+驱动只给文本时按消息兜底）时，连维护库把它建出来再重试一次。
+
+- 维护库优先 `postgres`，没有就退回 `template1`；库名走 `pgx.Identifier{}.Sanitize()` 转义，
+  配置里写什么名字都拼不坏语句；并发启动撞到 "already exists" 视为成功。
+- **只在库不存在时兜底**：端口不通、口令错这些原样报错，不会被误当成「那就建个新的」——
+  否则 DSN 里库名打错也会静悄悄建个空库，用户看到的是个空站点。这条专门写了测试。
+- 建库时打日志「数据库 X 不存在，已自动创建」，让配置写错的情况看得见。
+- 权限不足时报「（当前账号可能没有 CREATEDB 权限）」。
+- 用 `pgx.ParseConfig` 复用 dsn 里除库名外的全部参数（主机/端口/账号/口令/sslmode），
+  不用自己拆 URL（pgx v5 的 `ConnConfig` 没有 `ConnString()`，所以维护连接用 `pgx.ConnectConfig` 直连）。
+
+实测：
+- 临时配置指向 `rond_autocreate_check`（库不存在）→ 日志出现「已自动创建」，
+  库建好、18 张表建全、初始管理员也建了、服务正常监听；
+- 端口改成 5499 → 报连接失败且**没有**建库；口令改错 → 报认证失败（28P01）；
+- 新增 `internal/db/db_test.go`（ROND_DSN 门控）：自动建库 + 建表 + 用完自动 DROP，
+  既有库正常连接，以及 `isDatabaseMissing` 的识别边界。跑完测试库已清理干净。
+
+### 上传备份后没有任何提示 + 配置样例不完整
+
+**1. 提示被吞掉（根因）**
+`adminFlash` 把消息挂在 URL 上重定向到 `/admin?ok=`/`?err=`，但 `adminHome` **从来没读这两个参数**
+（photos/notes/topics/edit/settings/password 都读了，唯独后台首页漏了）。
+于是上传备份、导入/清空迷雾、开关两步验证、删除数据集的所有提示全都无声无息——
+用户反馈的「rond 文件上传后没有任何提示」就是这么来的。
+
+修法：给 `Page` 加 `SetFlashFromQuery(r)`（把「跳回本页的处理必须接住提示」写在注释里，
+免得下次再漏），`adminHome` 与 `twofaPage` 都改用它。
+实测：错误文件 → 页面显示「文件类型不正确…」；重复内容 → 显示「与已有数据集 #9 完全一致
+（866 条到访、367 个地点），未新建快照」。
+
+**顺手校正的数据**：`datasets.visit_count/place_count` 还是 867/368，比实时数据多 1——
+是我上次用裸 SQL 删测试地点时没走 `refreshDatasetAgg`。已按同一语句重算为 866/367。
+（教训：动 places/visits 一定要同步数据集缓存计数。）
+
+**2. 配置样例不完整**
+对照 `config.Load` 真正读取的键（以 `get(kv,...)`/`getInt(kv,...)` 为准）扫了一遍：
+- 样例缺 `geocode_key`（后台「按名称搜坐标」的高德 Web 服务 Key）→ 补上，并写清它与瓦片 JS Key
+  不是同一种、留空则功能关闭。
+- 顺带发现 **`base_url` 是个死键**：struct 里有、会解析，但全仓库（代码/模板/JS/README）无人使用
+  → 直接把 `Config.BaseURL` 删掉。留着「填了没反应」的键，比没有更容易让人怀疑自己。
+- 样例里补上：库不存在会自动创建（及需要 CREATEDB 权限）、目录会自动创建、环境变量
+  `ROND_ADMIN_USER` / `ROND_ADMIN_PASSWORD` 的作用。
+- 新增 `internal/config/config_test.go` **双向**校验样例与代码：代码读的键必须在样例里出现，
+  样例里出现的键也必须真被读取（拼错或死键都会失败）。已验证能抓到（注释掉 geocode_key 即红）。
+
+### 调查：删掉的地点又出现 + 城市黑名单与迷雾
+
+**1.「建设路」删掉后地图还在显示——没复现出 bug，是「快照式导入」把它带回来了**
+在测试库（`conf/app-test.ini` → `rond_fog_test`，现在已自动建库并导入了同一份备份）完整复现：
+- 通过站点删除 src_pk=119 的建设路 → `/api/points` 立刻不再返回它（278 个点），删除**本身是好的**；
+- 再传**同一份**文件 → 走「内容完全一致」分支，**不会**重新导入，删除保持 ✓；
+- 传一份**内容不同**的备份 → 新建数据集 #2 并接管展示，**建设路又出现了** ✓ ← 这就是用户看到的现象。
+
+结论：站点是快照式语义（每次导入 = 一个新数据集接管展示，内容以备份为准），
+所以「先删、后传备份」必然把删掉的地点带回来。生产库的活动数据集是今天 00:48 导入的，时间线吻合。
+- 顺手把上传卡片的说明改写清楚（原话只有一句「重复上传同一份备份会替换原有数据」，会误导）；
+- 另记：站点上新加的地点属于当时那个数据集，传新备份后要看它们得在数据集列表里切回。
+- 待用户决定（未实现）：是否要「删除墓碑」——导入时把站点上删除过的 src_pk 再删一遍，让删除真正持久。
+
+**2. 城市黑名单（`settings.regions` + `regions_mode`）**
+- **只对访客生效**：`filterOf` 里写着「站长自己要看全部数据」，所以登录状态下试是不会有变化的
+  ——这很可能是「好像无效」的第一层原因。
+- 审计了所有直接查 `places` 的公开路径，修掉三处漏过滤（`apiCityAgg` 作者已经处理过并留了注释）：
+  | 位置 | 泄漏内容 | 修法 |
+  |---|---|---|
+  | `fogCoverage` | 迷雾「涉及城市」列表里带出黑名单城市 | 加 `regionSQL(f.Regions, f.RegionsExclude)` |
+  | `extremePlace` | 报告页「最北/最南」直接显示**地点名与城市** | 同上 |
+  | 报告页「新地点」计数 | 数字里含黑名单区域的地点 | 同上 |
+  实测（测试库把河池市/长沙市/贵阳市设为黑名单）：访客的迷雾城市列表不再出现河池市（站长仍可见）；
+  报告页「最北」由「小平香辣老素粉·贵阳市」变成「喜洲古镇洱海环境监测站」；新地点计数 47 → 24。
+- **迷雾瓦片图层无法按城市过滤**：迷雾是站点级数据（`fog_blocks` 不分数据集），
+  格子上没有任何城市归属信息，要按城市遮罩得先有行政区划边界。这条只能如实告诉用户。
+
+### 追查「未命名」点：不是删除留下的残影
+
+用户提示「删掉建设路后刷新页面大概率会变成未命名」。在测试库照做，结论是**不会**：
+- 删掉建设路（src_pk=119）后 `/api/points` 322 → 321，不含建设路，`visits` 里 place_id 为空的记录 0 条
+  （`visits.place_id` 是 ON DELETE CASCADE ✓ 到访跟着删）；
+- 空名字的点只有一个，**删除前就已经存在**：测试库 id=365 / 生产库 id=1987，都是 **src_pk=42**，
+  地址字段全空、1 次到访（2025-10-16 22:26→22:46），坐标 24.6898/108.0365，
+  与建设路相距约 1.9km、到访日期也不同 → **两条不同记录**。
+- 名字为空的源头在**原始备份里**：`ZLOCATION` Z_PK=42 本来就是 `ZNAME_=NULL, ZLOCALITY=NULL`
+  （整包仅此 1 条），是 rond 自己记的无名停留点，不是我们导入丢的。
+- 生产库的建设路**仍然存在**（id=2064，1 次到访 2025-10-18），我未动生产库。
+
+**黑名单「无效」的完整解释（三层）**：
+1. **只对访客生效**（`filterOf` 有意为之）→ 登录状态下试必然没变化；
+2. 迷雾瓦片无法按城市过滤（雾是站点级、格子无城市归属）；
+3. 黑名单匹配的是 `province/city/district` **文本字段** → 地址全空的点匹配不上。
+   实测黑名单=河池市：访客侧 92 个 `city='河池市'` 的点全部消失，但 src_pk=42 那个空地址点**照样返回**。
+
+**可提议的改进（未实现，等用户定）**：导入时对地址为空的点用高德 regeo 反查补上 city/district
+（站点已有 `geocode_key`），这样黑名单能覆盖它们，顺便这类点也能显示成真实地名而不是「未命名」。
+代价是要吃反查配额，得限量/串行。
+
+### 反查补全无地址地点 + 迷雾遮罩区（对访客隐藏的范围）
+
+**A. 反查补全**（`internal/web/backfill.go` 新增）
+- `backfillPlaceAddresses(ctx, datasetID, limit)`：只挑「地址全空或名字为空」的地点，
+  **只填空着的列**（不覆盖已有值）；名字为空时依次尝试：最近 POI（`amapNearestPOI`，与 rond 自己的命名方式一致）
+  → 街道 → 乡镇。复用现成的 `amapRegeo` 与 `amapGet` 里的全局 10QPS 限速，`limit` 兜住配额。
+- 三处接线：① 导入成功后自动跑（限 20 条，结果拼进 flash）；
+  ② 后台首页数据集卡片上的「补全缺失地址」按钮（每次 100 条，点了会告知还剩多少）；
+  ③ 路由 `POST /admin/places/backfill`。
+- **实测**：测试库那条 `name=''`/`city=NULL` 的点 → 「寿乡雪花牛肉 · 广西壮族自治区 河池市 金城江区」；
+  **生产库也跑了一遍**（用户说「有的都反查」）：id=1987/src_pk=42 同样的结果，库里已无缺地址的地点；
+  导入钩子单独验证 —— 先清空该点名字、从测试库导出一份**内容不同**的备份再上传，
+  提示里出现「已自动反查补全 1 个缺地址的地点」✓（内容相同的备份会走「完全一致」分支，不触发导入）。
+- 顺带：`conf/app-test.ini` 原来没配 `geocode_key`，这功能在测试环境是关闭的 → 补上。
+
+**B. 迷雾遮罩区**（新表 `fog_masks`、`internal/fog/mask.go`、`internal/web/fog_mask.go` + 管理页）
+- 数据模型是**圆**：中心（存 GCJ-02，与 places 同系）+ 半径（米）。
+- 判定前把中心换算到迷雾网格（WGS-84）；注意网格纵向边长恒定、横向随纬度乘 cos(φ) 收缩，
+  所以「地上的圆」在网格里是**椭圆**（横向更宽）——按正圆算的话高纬度会明显偏窄。
+- `RenderTile(blocks,z,x,y,crs,masks)`：被遮住的格子既不画填充，**也不算「未探索」的邻居**，
+  否则遮罩边缘会被描出一圈轮廓，等于把隐藏范围本身暴露了（为此加了 hole 缓冲）。
+  低缩放级（格子小于 1px）按块中心判定。
+- `handleFogTile` 只给**访客**带遮罩（站长要看完整迷雾才能核对遮哪里）；覆盖率同样只对访客扣掉
+  遮罩内的地点与格子（`MaskSet.MaskedCells` 只遍历遮罩包围盒内的块，不做全库扫描）。
+- 管理页 `/admin/fog/mask`（入口在后台迷雾卡片上，带数量）：Leaflet 地图点选圆心、marker 可拖、
+  半径输入实时改圈、已有区域画出来；列表可编辑（回填表单 + 地图跟过去）与删除。
+- **实测**：无遮罩时访客与站长的同一张瓦片完全一致（2104 像素）；加一块 1500m 遮罩后
+  访客只剩 346 像素、站长不变；覆盖率 575,753 格/47.8 km²（站长）vs 570,569 格/47.4 km²（访客），
+  差的正是圆内的迷雾。
+- **踩的坑**：页面漏了 `p.HasMap = true` —— 布局按这个标记条件加载 Leaflet，漏了地图整块不出现
+  （页面只有 3 个 script、`window.L` 是 undefined）。CDP 检查抓到的。
+  另外 inline 脚本要等 `load` 再初始化（Leallet 在 content 之后引入），与后台「新增地点」同一条约定。
+
+### 行程轨迹泄漏黑名单城市 + 统计页的备份文件名
+
+**1. 轨迹（`apiTrack`）漏了区域限制**
+根因：那个 handler 只处理了 `f.From/f.To` 与「家/工作」，**没套区域限制**——而它是
+`movements JOIN places pf/pt` 后返回两端坐标，所以只要线段碰了黑名单城市，那个坐标就露出来了。
+修法：区域限制套在**两端**上（任一端在被隐藏区域，整段都不返回；只按起点过滤的话终点照样画得出来）。
+为此把 `regionSQL` 加上表别名参数（原来写死 `p.`），7 处调用点同步更新。
+
+实测：
+- 测试库（黑名单=贵阳市）：站长 192 段 / 访客 145 段 / 隐藏 47 段，
+  **47 段全部是贵阳市相关、0 段误伤**，访客结果里贵阳市相关 0 段（可复现，跑两次一致）。
+- **生产库**（黑名单=河池市，正是用户设的）：站长 298 / 访客 146 / 隐藏 **152** 段，
+  152 段全部河池市相关、0 误伤，访客侧 0 泄漏 —— 也就是线上原本漏了 152 段。
+
+**2. 统计页对访客显示「数据来自 xxx.rondbackup」**
+`stats.html` 那行副标题把备份文件名给了所有人看。改成只有站长可见
+（`{{if .IsAdmin}}`），访客只留时间范围。
+顺手把访客可见的 7 个页面（/ /stats /report /places /map /timeline /topics）扫了一遍：
+「rondbackup」「数据来自」字样均为 0 ✓。
+
+**待说明**：GPX 图层（用户上传的 .gpx 轨迹）没有城市信息，无法按区域过滤——那是另一份独立数据。
+
+### 报告页占位卡片 / KPI 灰格 / 追踪脚本 / 完整 debug
+
+**1. 报告页「迷雾版图」是空白** —— 不是渲染问题：那张卡里**从来只有标题和一句说明**，
+没接任何内容（本来想放地图但没接上）。报告页本身也没有地图（只有首页/地图页/地点页有）。
+改成与统计页一致的四个数字（面积 / 点亮率 / 点亮地点 / 快照块数），标题改为「世界迷雾」。
+
+**2. KPI 灰格**（用户说「有两个格子是灰色的，其他地方也有」）
+`.kpis` 原是 `grid-template-columns: repeat(4, …)` + `gap:1px` + **底色画间隔**，
+所以不满行时空格子会露出底色 → 灰块。KPI 个数又常是 6（报告）、7（统计）这种除不尽的。
+改成 `display:flex; flex-wrap:wrap` + `.kpi{flex:1 1 158px}`：最后一行自己撑满，
+任何个数、任何宽度都不会有空格。`.kpis-3` 同步改成 `flex: 1 1 30%`。
+实测（CDP 量每行缺口）：1440 下 6 个 KPI 一行排满、4 个一行排满；700 下 4+2 与 3+1 都撑满；
+390 下 2+2+2 与 2+2 —— 全部 1px（就是边框），无灰格 ✓
+
+**3. app.ini 新增 `track_script`（第三方统计脚本）**
+填 URL（http/https 开头）→ 渲染成 `<script defer src="…">`；含尖括号则整段原样输出
+（百度统计/Plausible 这类要带属性或初始化代码的）。形如 URL 却夹引号/尖括号的视为配置写错，宁可不挂。
+只注入**公开页面**（`{{if and .TrackScript (ne .Nav "admin")}}`），后台与登录页不挂。
+实测：`/`、`/map`、`/stats`、`/report` 有；`/admin`、`/admin/login` 无；主实例没配则为 0 ✓
+
+**4. 完整 debug（按用户要求）—— 找到并修掉的问题**
+- 🔴 **专题页泄漏**：`topicContent`（专题详情页 + 专题列表页的统计）**没套区域限制** →
+  访客能在 `/topics/{id}` 与其地图上看到黑名单城市的全部地点。修：加区域参数 +
+  新增 `visitorRegions(p)` 把「只对访客生效」收敛成一个入口（filterOf 也改用它）。
+  实测：访客 0 个点、站长 76 个点 ✓
+- 🔴 **迷雾瓦片的共享缓存泄漏**：访客与站长的瓦片 **URL 完全相同**，却都返回
+  `Cache-Control: public, max-age=3600` → CDN/反代会把站长那份**未遮罩**的瓦片发给访客。
+  修：站长那份改 `private, no-store` ✓
+- 🟠 **删除数据集后的静默失败**：`adminDelete` 里「自动启用最新一份」那步**忽略错误** →
+  失败时站上一份生效数据都没有、页面全空，提示却说「已删除」。修：检查错误并明确提示 ✓
+- 已确认**没问题**的：所有 `/admin/*` 都有 requireAdmin ✓；排序/方向/表名都是白名单或转义
+  （无 SQL 注入面）✓；设置**没有**内存缓存（不存在改了不生效）✓；瓦片代理有图层白名单
+  （不是开放代理）✓；上传与表单都有大小上限 ✓；访客可写入口只有投票（整型参数）✓。
+- 记下**未改**的：`apiVotes` 仍下发黑名单地点的票数（按 src_pk、无名称坐标，信息量极低）；
+  GPX 图层无城市信息无法过滤；登录只有验证码、没有失败次数限流。

.workbuddy/memory/2026-09-17.md

@@ -0,0 +1,626 @@
+# 2026-09-17
+
+## 迷雾遮罩：生效时机、重叠语义、访客默认页（提问）回复
+
+用户三问：①遮罩生效需要时间吗 ②重叠遮罩有效吗 ③能否设置访客默认页面。
+
+**① 生效时机：服务端即时，访客端原来最长 1 小时**
+`handleFogTile` 每个请求都 `LoadMasks` 实时读库（遮罩**不在** `fogIndex` 的 sync.Once 缓存里），
+所以保存/删除后下一次请求即生效、无需重启。**但**访客瓦片是 `public, max-age=3600`，
+而瓦片 URL 的 `?v=` 来自 `ix.Version()`（只跟**迷雾数据**走）→ 设完遮罩 URL 不变，
+访客浏览器/CDN 继续用旧瓦片，看起来像「遮罩没生效」。
+修：新增 `fog.MaskFingerprint(masks)`（FNV-1a 64，按 id|lat|lon|radius 求哈希），
+`mapConfig` 的 `fog.ver` 变成 `"<ix.Version()>-<指纹>"`（string）。遮罩一变 URL 就变，缓存自然失效。
+实测：无遮罩 `1789578442-0` → 加一块 `…-7e72b20aa455d2f9` → 再加一块 `…-5cc45ddb03dc0230` → 删光回到 `…-0` ✓
+
+**② 重叠遮罩：渲染有效，但统计原来会重复扣数（已修）**
+- 渲染/判定本来就是并集：`MaskSet.Hit` 遍历所有圆、任一命中即隐藏 ✓，重叠无副作用。
+- **但 `MaskedCells` 是「逐遮罩累加命中格数」**——重叠区域被统计多遍，`cov.Cells` 扣多
+  （面积走的是另一套逐格算法 `AreaKm2Excluding`，于是两个数字互相矛盾）。
+  修：改成**逐格判一次 `Hit`** + 用 `done` 集合对「遮罩包围盒覆盖到的块」去重。
+- 新增 `internal/fog/mask_test.go`：
+  `TestMaskedCellsUnion`（重叠时 == 暴力并集）、`TestMaskedAreaMatchesCells`（面积差换算成格数与 MaskedCells 一致，1e-6 m²）、
+  `TestMaskFingerprint`（增删改都会换指纹）。
+  **验证测试有效**：退回旧算法 → 303019 vs 并集 189470（多扣 60%）→ FAIL ✓
+- 实测（测试库 8701 块迷雾）：无遮罩访客=站长；一块 2000m 遮罩 → 访客像素 77959→71689、格数 575753→571692，站长不变；
+  再加一块**完全相同**的遮罩 → 访客数字**一点不变**（旧实现会扣两倍 8122 格）✓；删光后双方复原 ✓
+
+**③ 访客默认页面：目前没有这个功能**
+`/` 固定走 `home`；页面级控制只有 `setting.AllPages`（map/places/timeline/stats/report 的可见性开关）。
+已在回复里给方案让用户选（后台下拉 / .ini 配置 / 不做）。
+
+## 新增「访客默认页面」（后台设置下拉）
+
+需求确认后按「后台设置加下拉」实现：
+- `setting.Settings.VisitorHome`（json `visitor_home`，缺键/非法值一律回落 `VisitorHomeMain="home"`），
+  `VisitorHomePath()` 只在**目标页已对访客开放**时返回 `/<key>`，否则返回空串不跳。
+  收敛用 `NormalizeVisitorHome()`（表单被改坏时回落主页）。
+- `home` handler：在「没导入数据」分支之后，`!IsAdmin && VisitorHomePath()!=""` → 302。
+  刻意不跳的三种情况：站长自己访问、没配、目标页没开放；另外**没数据时不跳**
+  （让访客留在主页看引导，比落到空地图有用）。
+- 后台「公开页面」卡片下方加下拉（主页 + AllPages 五项）。
+- 新增 `internal/setting/setting_test.go`：纯逻辑用例 + `TestVisitorHomeStore`（ROND_DSN 门控，
+  **库名不含 test 时自动跳过**，避免动到正式站的 settings；用例内先备份原值、defer 还原）。
+
+实测（测试库 HTTP）：
+| 场景 | 访客 / | 站长 / |
+|---|---|---|
+| 默认（home） | 200 主页 | 200 主页 |
+| 设为 map（页面全开） | **302 → /map** | 200 主页（不受影响） |
+| 设为 map 但 map 未对访客开放 | 200 不跳（/map 本身 404） | 200 |
+| 库里被塞非法值 `//evil.com` | 200 不跳 | 200 |
+CDP 复核下拉：6 个选项、正确回填（map 时选中「足迹地图」）、无 JS 报错。
+生产库没有这个键 → 缺键回落默认，访客行为不变 ✓
+
+## 到访热力无效 + CPU/内存优化 + 点地图跳 /map（+ 回归）
+
+### 1. 「到访热力」无效：热力图恒为空
+`full()` 里 `var points = opts.points || []`，而地图页首屏是 `full({points: []})`（地点随后走
+`/api/points` 拉回），`setPoints` 只写了 `st.points`，**没同步闭包里的 `points`**；
+`buildHeat` 用的正是闭包那个 → 恒为空数组。
+修：`buildHeat` 改用 `st.points`，并让 `setPoints` 同时写 `points = st.points = pts`
+（与 `preview()` 里已有的写法一致）。
+**实测（awaitPromise 探针 + canvas 像素统计）**：旧写法画布在但**非透明像素 0**；
+修复后 59258 像素（生产站访客视角 51049）✓ 这就是「勾了没反应」。
+
+### 2. 点击地图跳 /map：改成按需启用
+`preview()` 里硬编码 `map.on('click', () => location.href='/map')`，而 preview 被 4 处复用：
+主页（要）、地点详情页（不想要，上面本来就有「在地图中查看」按钮）、后台照片页 2 处
+（**最不该有，点一下就被甩出后台**）。
+修：加 `opts.clickToFull`，只有主页传 true。实测：主页 `home-map` 有 1 个 click 监听；
+地点页 `place-map` 为 **0** ✓
+
+### 3. CPU / 内存优化（先测量后动手）
+**基线**：`/stats` 379ms（访客）/ 505ms（站长），fog 瓦片 7.9ms，其余 <50ms。
+**根因（测出来的，不是猜的）**：
+- 单个统计查询只要 **2–3ms**（psql 也是 3ms），但页面 379ms → 逐段计时日志显示
+  `weather` 任务 400–700ms。测出**建一条 PG 连接要 307ms**（psql 建连同样 0.55–0.7s）——
+  Windows 上新建 backend 进程就是这么贵。
+- 池配置 `MaxOpenConns(12)` + **`MaxIdleConns(4)`**：串行页面只需 1 条连接（首次付 300ms，
+  之后复用），**并发超过 4 条时反复重建连接**，于是「并行反而更慢」。
+- 另外 `fogCoverage` 每次要 `ix.All()` **三次**，而 `All()` 会复制 10542 个块并**排序**。
+
+**改动**：
+1. `internal/db/db.go`：`MaxIdleConns` 提到与 `MaxOpenConns` 相同（8/8），
+   新增 `WarmUp(d, 6)` 在启动时并发预建连接（main.go 调用）。
+2. `internal/web/parallel.go`：`runJobs` 并发执行页面里互不依赖的查询（上限 6），
+   debug 下打印 >30ms 的慢查询（**这条日志就是定位到建连问题的关键**）；statsPage 的 13 个查询改用它。
+3. `internal/fog`：`Index` 预存 `areaM2`（写入索引时顺手算），新增 `Index.AreaKm2()`；
+   `maskedStats`/`Index.MaskedStats` 直接在索引上按遮罩包围盒算（不再复制整张块表），
+   删掉旧的 `MaskedCells` 与 `AreaKm2Excluding`。
+4. `internal/web/mask_cache.go`：缓存遮罩列表 + 指纹（30s TTL，保存/删除时**主动失效**），
+   瓦片渲染结果也进 `fogTiles` 缓存（key 含 crs 与遮罩指纹，站长用 "-"）。
+
+**结果**：`/stats` **379→38ms / 505→29ms**；fog 瓦片 **7.9→1.8ms**；
+rond.exe RSS 42–44MB（压测 200 次请求后不涨，无泄漏）；
+单次 `/stats` 约 15.6ms CPU。剩下的 2 条慢查询是启动后第一次请求的冷连接。
+
+### 4. 回归检查又发现两处区域限制遗漏（同「轨迹」那类）
+`Overview` 的**总里程**与 `TransportStats`（出行方式）都重建了 `where` 而**丢掉 `f.Regions`**
+→ 访客看到的里程/出行里程里含黑名单区域。新增 `Filter.movementsWhere()` 统一（按两端的
+`places` 判定，黑白名单语义与 `visitsWhere` 一致），两处都换过去。
+实测生产站：访客里程 **16861.9 → 4678.8 km**，站长不变 ✓
+新增 `internal/stats/stats_test.go`（ROND_DSN 门控、**只读**）：
+与手工 SQL 逐项对账 + 区域过滤对 visits/movements 双向生效 + 时间范围仍有效。
+**验证测试有效**：退回旧写法 → 立刻报「白名单 广西壮族自治区 后里程没减少」✓
+
+其余巡检：8 个公开页 + 7 个后台页全部 200；遮罩保存/删除**立即生效**（28ms 内访客数字与瓦片
+同步变化，站长不受影响）；全量测试通过。
+
+### 主实例「退出」事件排查：不是崩溃，是端口被另一个进程接管
+
+收到后台任务完成通知（我启动的 8080 实例结束），排查结论：
+- **事件日志没有任何 rond 崩溃记录**（Application 日志里 Application Error / WER 均无）；
+  rond 自己的日志也没有 panic → 是**被正常终止**，不是崩溃。
+- 进程清单（Get-CimInstance Win32_Process）给出了真相：
+  | PID | 启动时间 | 命令行 |
+  |---|---|---|
+  | 11992 | 01:33:08 | `bin\rond.exe -c conf/app-test.ini`（我起的 8081 测试实例） |
+  | 14556 | **02:36:42** | `bin\rond.exe -c conf/app.ini` —— **没有日志重定向** |
+- 日志里的 `02:36:46 已启动` + `02:36:47 服务异常退出: listen tcp :8080: bind ...`
+  是**我的重启尝试**：它在 02:36:42 那个进程占住端口后才启动，于是 bind 失败退出。
+  （main.go 是先打印「已启动」再 ListenAndServe，所以会看到这两行连在一起。）
+- 结论：**用户在 02:36 自己重启了服务**（命令行没有 `tee` 重定向，所以它的日志不落在
+  storage/rond-main.log 里，这正是「日志里看不到我这次请求」的原因）。我停止抢占 8080。
+- 已验证当前实例是**最新构建**（`/api/map-config` 的 `fog.ver` 带 `-0` 遮罩指纹后缀，
+  这是本轮才有的），/stats 实测 59ms、8081 对照 45ms（整机当时有浏览器等负载，属正常波动）。
+
+**运维提示（值得记住）**：`main.go` 先打印「足迹站点已启动」再真正 ListenAndServe，
+所以端口被占时会出现「已启动」+「服务异常退出: bind」两行连在一起 —— 看到这对组合
+就是**有另一个实例抢着占了端口**，而不是启动成功后又崩了。
+
+---
+
+## 出行（ZMOVEMENT）后台增改删 + 导出保真（本轮新增功能）
+
+需求：编辑页能对「出行区间的方式 / 时长 / 时间」做新增、修改、删除，且导回 rond 正常可用。
+
+**先反推真机语义**（拿 `data/20260914_151649.rondbackup` 逐列实测，脚本跑完即删）：
+- `ZMOVEMENT` 11 列，`ZTYPE_` **791/791 非空**：2=无交通方式（中位速度 5.0km/h≈步行）、
+  5=有交通方式（中位 17km/h），另有 23 条 4、1 条 0 → **不能写 NULL**，站点只给新行补 2/5。
+- 时间窗口硬不变量：`ZSTART_ >= 起点到访离开`、`ZEND_ <= 终点到访到达`（760/756 条 0 违例）。
+- `ZTRANSPORT` 是全局表，站点侧从位移聚合；`ZVISITFROM_/ZVISITTO_` 真机就有 35 条为空。
+
+**改动**（`internal/rond/export.go`、`internal/web/handlers_edit.go`、`view.go`、`server.go`、
+`templates/admin/edit.html`、`static/css/app.css`）：
+1. 编辑页新增「行程记录」卡片：搜索（地点/方式/日期/#编号）+ 分页 + 行内改（起止到访、
+   时间区间、方式）+ 删除；「新增行程」表单重做（时间留空自动按两端到访推断、方式可内联新建）。
+2. 落库补齐派生字段：`from_place_id`/`to_place_id`（**区域黑名单按两端 places 判定，留空会绕过过滤**）、
+   `distance_km`、`duration_min`，与导入路径同源。
+3. 编号复用防护 `nextSrcPK`（取库内/coredata_meta/留档三者上限 +1）。
+4. 导出侧：`ZMOVEMENT.ZTYPE_` 进 `keepNilCols` + 新行补值；`queryTransports` 改 `GROUP BY`
+   （原来 `DISTINCT` 会在同名冲突时产出两个同 `Z_PK` → 撞主键让整次导出失败）；
+   `ZTRANSPORT` 的名称/颜色/图标「空则保留基线」+ `keepMissing`（没有行程引用的方式不再被删）。
+
+**验证（可复现，全部实测）**
+- 新增 `internal/web/movement_e2e_test.go`：真导入真机包 → 调真实处理函数 → 导出 → 读导出 SQLite 核对。
+  门控 `ROND_TEST_CONF` + `ROND_SRC`，在测试库建一次性账号、跑完连数据集一起删。
+  实测：删基线最大位移 #791 后新建拿到 #792（防复用生效）；新行 `ZTYPE_`=5/2、`ZTRANSPORT` 指向新方式、
+  原名保真；`tools/verify_rondbackup.py` 比对 → **ZMOVEMENT/ZTRANSPORT valuediff=0**，只有我动过的行在差。
+- 纯净往返（不增删改）对照组：新旧代码的比对输出**逐行相同**（总差异 3，全是 `ZLOCATION.
+  ZLASTARRIVALDATE_` 的「站点重算最近活跃时间」，属既有行为）→ 证明改动没波及别处。
+- 项目自带断言全过：`TestExportRoundtrip`（坐标 0 偏差、时间 0 偏差）、`TestBaselineKeepsCoreData`、
+  `TestProgramRowsFillNativeColumns`（新行 2 条 `ZTYPE_` 全有值）、新加 `TestMovementTypeNeverNull`。
+- 无头 Chrome（`rond-web-verify` 技能）实测编辑页：**0 JS 报错**，6 张卡片顺序正确，40 行行内表单、
+  41 个方式下拉、165 个 flatpickr 全初始化；方式联动（选已有→预填名称/颜色/图标、新建→清空、
+  无→禁用）与时长实时提示（「时长 1 小时 35 分钟」/「结束时间必须晚于开始时间」）均按预期。
+- 移动端：发现行程行高 206px（到访行 115px），把时间压成一行 + 窄屏隐藏城市名后降到 165px
+  （卡片 10607→7332px），320/390 无横向溢出；桌面 61px vs 到访 57px，基本齐平。
+
+**注意**：8080 主实例已用新构建重启（`bin/rond.exe~` 是改动前的旧二进制，可回滚）。
+
+### 反馈三点：改方式不生效（真 bug）、卡片折叠、筛选改选项框
+
+**1) 「改方式保存不了」的根因（我上一轮引入的）**
+页面时间输入只到分钟，回填后原样提交 → 服务端把 `20:03:21.323` 截成 `20:03:00`：
+① 顺带改掉了时间（数据漂移）；② 截断值早于起点到访的离开时间（`20:03:21`），被上一轮
+新加的时间窗口校验直接拒掉。用户那行是 **movement #385（09-13 20:03→20:31，电🐔）**，
+起点到访 #403 的离开时间正是 `20:03:21.323088`——卡在秒上。
+修法：**与库里同分钟就沿用库里原值**（`keepStoredTime`；行程走 `resolveMovementEnd`），
+手填越界仍给硬校验（带 1 分钟取整余量）。到访的 `editVisitUpdate` 是同一类病，一起修了
+（改备注也会磨掉 `ZARRIVALDATE_` 的秒）。回归用例：
+`TestKeepStoredTime`、`TestMovementWindowKeepsStoredSeconds`，E2E 的「只改方式」用例
+专门挑「截到分钟就会越界」的行，并断言导出包里 `ZSTART_/ZEND_` 与原始包逐位一致。
+
+**2) 卡片折叠**：编辑页 6 张卡片各加 `data-card` 键 + 标题右侧箭头（标题整行可点），
+状态记 localStorage，页头加「全部折叠/展开」。选点地图做了延迟初始化
+（折叠着就不建，展开时经 `window.__pickerMapInit` 补建）——否则 Leaflet 在
+`display:none` 容器里初始化会拿到 0 尺寸。
+
+**3) 行程筛选**：把手输关键词换成三个选项框——交通方式（全部/无方式/各方式含段数）、
+地点（起或止，取前 300 个地点）、开始时间从/到（date）。分页链接改由 Go 生成
+（`EditData.PageLink` 返回 `template.URL`）——直接拼在 href 里会被转义成 `mt%3d4`，
+翻页会静默丢筛选。
+
+**实测**：`mt=4`→332 段（与下拉里的「332 段」一致）、`mt=none`→390 段（= 791−401 ✓）、
+日期区间 2026-09-01~30→37 段；`?mt=4&mpage=2` 第 2/9 页且选中态保持；折叠/展开/全部折叠
+与 localStorage 读取均正常；桌面筛选行底边极差 0（按钮不歪）、390/320 无横向溢出；
+全程 0 JS 报错。8080 已用最新构建重启。
+
+### 再反馈：默认折叠 + 选择器收不回/被覆盖
+
+**默认折叠**：折叠脚本的默认值从「未记录=展开」翻成「未记录=折叠」（`state[k] !== false`），
+只有明确记过展开的卡片才展开。实测 6/6 折叠、页面高度 = 视口高（不再一屏拉不到底）。
+选点地图的延迟初始化因此成了常态路径：折叠时 `startMap()` 不执行、也不建 Leaflet，
+展开时经 `window.__pickerMapInit` 补建（实测展开瞬间就发出 `/api/map-config` 请求）。
+
+**选择器「只能选不能收回 + 被其他元素覆盖」**——量出来的根因是 CSS 不是 z-index：
+`.picker-results` 有 `max-height:200px` 但 `overflow:visible`（flex 子项不会因上限收缩），
+30 条候选实际溢出 **1020px**，溢出部分被后面 DOM 里的表单元素压住
+（`elementFromPoint` 在框下方 20px 处拿到的是 `BUTTON.geo-item`，即「看得见点不着」）。
+修法：`.picker-results{overflow-y:auto}` → 200px 内滚（框下方 20px 处已变回 `DIV.row`）。
+交互上补：点空白处 / Esc / 失焦都收回候选列表；行内编辑表单里隐藏域已有值时
+直接渲染成「已选： #173 2026-09-13 20:40 家 + 重选」，用户能看到当前值、也能清空重选
+（原来预填了隐藏域却不显示，看着像「选了就收不回」）。
+
+### 地点坐标换算（有些点没做过 GCJ-02 偏移）
+
+需求：地点列表每个点能就地做坐标系换算，并能看到前后变动，不用删了重填。
+
+**先反推判据**（实测 `data/20260914_151649.rondbackup` 的 323 个地点）：
+`gcj(raw)==lat` **305** 个（正常）、`raw` 与 `lat` **一字不差 18 个**（= 当初没偏移，显示坐标
+其实还是 WGS-84，偏 500~540m）、其他 0 个。⇒ 「哪个点没偏移」可自动判定：`raw == lat`
+且在中国外接矩形内（境外的点本就不该偏移，必须排除，否则误报）。
+顺带纠正了记忆里「293/323」的旧数字（实测 305）。
+
+**实现**：`GET /api/coords?mode=wgs2gcj|gcj2wgs`（站长限定，geo 包是唯一实现，实测
+21.428836,109.116822 → 21.426460,109.121113 / 517m 往东南，与离线 Python 分析逐位一致）；
+编辑页每行加「坐标系换算」下拉 + 前后对照行（`原 → 新（移动 N 米 · 往X）`），
+换算前先记 base，来回切方向不会越换越偏；地点列表加「疑似 WGS-84」橙标 + 「坐标系」筛选
+（实测生产站正好筛出 18 个）+ 「比导入时移动了 N 米」；保存后的提示带上移动距离与方位。
+「导入时的原值」取自 entity_raw 留档里的 ZLATITUDE/ZLONGITUDE，所以改动后能一直对照。
+
+**实测（端到端）**：换算 亚平村二巷 #33 后，导出包里 `ZRAWLATITUDE/ZRAWLONGITUDE` **一字未动**、
+只有 `ZLATITUDE/ZLONGITUDE` 变了，且 `gcj(原始GPS) == 显示坐标` 重新成立（rond 的坐标模型）。
+`verify_rondbackup.py` 差异明细：`PK 33 differs: [('ZLATITUDE', 21.428836, 21.42646),
+('ZLONGITUDE', 109.116822, 109.121113)]` —— 正是要动的那两列。
+
+另外给验证脚本 `site_cdp.py` 加了 `--await`（async 表达式等 resolve 再取值），
+这次要验 fetch 驱动的换算界面才发现原来不支持；SKILL.md 补了用法。
+
+### 站长给的实例：IMG_20260418_181404.jpg 的坐标到底对不对
+
+站长截图给了「源图 GPS」，我读不了图，但照片本体在 `Downloads/temp2/` 找到了 —— 直接读 EXIF：
+`22°51'11.58"N 113°15'11.04"E` = **22.853216, 113.253067（与站点里存的完全相同）**，
+相机 HUAWEI Mate 80 Pro Max。结论：**导入时没做偏移**（导入页默认会转，所以是当时选了
+「已经是 GCJ-02」）。EXIF 按标准就是 WGS-84 → 这个点在 GCJ 底图上偏了 **626m**。
+
+**怎么裁决**（不靠猜）：站长说手机地图上显示在「银星雅苑西北门/柏景楼二期/翠庭轩/咖研社
+这个十字路口」。用这些地物名走 `/api/geocode` 取坐标再比距离：
+- 银星雅苑 22.849159,113.258707 → 距现状 733m、距换算后的点 **144m**
+- 翠庭轩 22.850376,113.259255 → 距现状 708m、距换算后的点 **91m**
+⇒ 手机是对的，站点偏了。已按真实保存路径换算：**22.853216,113.253067 → 22.850420,113.258373**，
+提示「坐标移动到 22.850420, 113.258373（626 米，东南方向）」，复测新位置距地物 91~144m。
+
+**补了回归断言**（`movement_e2e_test.go` 5d）：站点新建（= 照片导入同类）的地点换算后，
+导出包必须 `ZRAWLATITUDE=22.853216,113.253067`（换算前输入值）+ `ZLATITUDE=22.850420,113.258373`
+（换算后），且 `gcj(原始GPS)==显示坐标`。这条覆盖了「新行 ZRAW 由显示坐标反算」的分支。
+
+站长选了**先不补**「照片导入的坐标来源」记录 → 这类点仍然不在「疑似 WGS-84」判据里，
+只能按上头的「地物名裁决」人工核。这条限制已写进 MEMORY.md。
+
+### 生产环境「这两天导入的照片全是错坐标」——排查与补救清单
+
+站长在生产（life.shiroko.one）导了一批照片，都是按「已经是 GCJ-02」导的 → 坐标没转换。
+
+**排查手段（不登录也能做）**：公开 `GET /api/points` 带 `sp`(=src_pk) 与全精度经纬度。
+生产 281 个可见点里：195 个长小数全部 sp≤323（= rond 导入基线），85 个 ≤6 位小数全部 sp>323
+（= 站点新建，即照片导入）。**站长从没手工点选新增过地点**，所以这 85 个就是全量受影响面。
+（生产中还有被区域黑名单/迷雾遮罩挡住的点，完整清单要登录后取。）
+
+**判定命中**：拿仓库 `data/images/` 的 51 张长沙原图 EXIF 对账生产数据，24 个可判定的点
+**全部**是 `stored == round(exif,6)`（没转换），**0 个**是 `gcj(exif)`。本地环境同样 24/24。
+偏移 351~673m，方向南/东南（随纬度变化）。清单：`tmpfog/photo-coord-fix-preview.csv`。
+
+**关键坑**：不能靠库内字段自证——逆地理用的是同一个错坐标，省市区/街道/名称自洽；
+`places`/`visits` 无 created_at，也没记录导入时的坐标系选择。只有原图 EXIF 能定罪。
+
+**生产环境事实**：跑的是 v7（`/api/coords` 在、`app.css` 含 `.tag.warn`），所以现成接口能用；
+只走 IPv4（curl 必须 `-4`，IPv6 超时）；登录有验证码，cookie 形如 `uid|token`（HMAC，不绑
+IP/UA），站长复制过来即可用 curl 操作。
+
+待站长定：会话怎么给 / 照片目录是否提供（把 61 个未匹配的点也逐张核实）/ 是否补「导入来源」记录。
+
+### 照片错坐标：86 个站点新建地点的最终裁定（含判据标定）
+
+对生产 86 个 `sp>323` 的点做了三路证据对账，结论 **63 修 / 23 不动**。
+
+**判据 A（铁证）· 47 个**：库内坐标与某张原图 EXIF **六位小数逐位相等** → 当时没换算。
+长沙 24（sp344-367）+ 佛山 23（sp387-409）。原图在本机 Downloads/桌面等 4 个目录下。
+
+**判据 B（列签名）· 16 个**：`places.country_code='CN'` 且 `timezone='Asia/Shanghai'`。
+机制：`photos.html` 的 `tInput(name,value,...)` 把 country/timezone 写成**表单默认值**，
+而 `edit.html` 的同名字段只有 placeholder（空 value），且 `search()` 只回填
+name/province/city/district/坐标，**不回填** country/timezone/街道。
+标定（60 个已知答案）：47 个照片导入**全部**命中；13 个按名搜索只有 1 个例外
+（324 昆明站，坐标与 POI 完全一致、且与 325 是重复点 → 归为「不动」）。→ 判据可信。
+命中的是荔波 368-383（荔波原图不在本机，无法用 A 复核）。
+
+**判据 C（不动）· 23 个**：昆明 2 + 大理 18 + 荔波 384/385 + 南宁 386。创建于「新增地点」页，
+坐标来自高德 POI 或地图点选，本来就是 GCJ-02。
+
+**被否证的两条判据（别再捡起来）**：
+- **「按名搜索同名 POI」的对称距离判据不可用**。在 47 个已知「需修」点上标定：
+  只有 17/31 有候选的点判对（55%），**14 个把需修的点判成「正确」**（如 sp409 柠季
+  same=16.7/fix=630 → 判「正确」但实际是 EXIF 原值）；16 个连候选都搜不到。
+  只有 `same<=10m`（坐标就是 POI 坐标本身）这一档是可信的——47 个需修点里**没有一个**
+  落在该档。即「same≈0 ⇒ 按名搜索」成立，其余档位一律不可信。
+- **迷雾栅格不可用**。荔波 16 个点里 12 个两侧都是 0%；大理更是出现与已知正确点
+  （sp333 喜洲古镇北区停车场，same=0.0）**相反**的结果（C=0%、gcj(C)=23%）。作废。
+
+**其他相关事实**：
+- 导出的 `ZISPHOTOIMPORT` 恒为 0（站点导出不给新建行补这个值），所以 rond 里分不出
+  「照片导入」与「手工新增」——这是继「坐标来源」之后第二个该补的缺口。
+- `editPlaceUpdate` 的 UPDATE 不含 `thoroughfare`，所以「只改坐标」不会动到街道字段（好消息）；
+  但省/市/区/街道是按**错坐标**反查来的，改完坐标后会与新位置差约 600m（多为同区，可接受）。
+- 生产备份里 `ZVISIT.ZUSERADDED` 85 个新建到访**全部为 1**，`ZISPHOTOIMPORT` 全 0。
+
+产物：`tmpfog/fix-list-final.csv`（63 行）、`tmpfog/keep-list-final.csv`（23 行）、
+`tmpfog/fix-review.html`（前后对照表）、`tmpfog/live-preview.csv`（对生产只读试运行，
+已验证会话有效、线上值与备份一致）。写库走 `tools/photo_coord_audit.py --apply`，
+换算调服务端 `/api/coords?mode=wgs2gcj`（与错导入正好互逆）。**尚未写库，等站长确认范围**。
+
+### 已执行：63 个坐标全部换算回 GCJ-02（生产）
+
+站长选「全部 63 个 / 只改坐标」。用 `tools/photo_coord_audit.py --include-unverified --only <63> --apply`
+写库（换算走服务端 `/api/coords?mode=wgs2gcj`）：**成功 63 / 失败 0**。随后重新拉 `/api/points` 逐点复核，
+`63 一致 / 0 不符 / 最大偏差 0.00m`，23 个「本来正确」的点坐标一字未动。
+
+**执行后才发现并解决的重大疑点（差点误判成「改错了」）**：用同名高德 POI 当标尺时，有 6 个点显示
+「旧值离 POI 只有 17~78m」→ 像是在说旧值本来就是 GCJ。**真相是循环论证**：这些点的**名称本身就是
+「用那个错坐标做逆地理」生成的**（`/api/regeo` 会把最近的 POI 名回填到名称框），所以名称必然贴着旧坐标。
+用 `/api/regeo` 在旧坐标上重跑一遍即可判定：名称出现在反查结果里 ⇒ 名称无证据力。
+逐点跑完：**63 个里 13 个名称是反查来的、50 个是站长自己命名的**。
+- 6 个「疑似改错」的点（349 天心阁、364、372、387 钟楼公园、394 顺德体育中心、409 柠季）**全部**落在
+  「反查来的」这 13 个里 → 全是伪证。
+- 而「修后离同名 POI 4~39m」的（348 茶颜悦色、352 长沙南站、354 肉丸店、390 萨莉亚、407 大地醉鹅、
+  375 小七孔古桥…）**全部**落在「站长自己命名」那 50 个里 —— 站长按自己当时所在命名，新坐标落在同名
+  地物上，这才是有效证据。两组完全互斥，逻辑自洽。
+
+**EXIF 基准的决定性证明（回答「照片 EXIF 到底是不是 WGS-84」）**：13 个按名搜索的点，坐标与高德 POI
+六位小数完全一致 ⇒ 它们是已知 GCJ 真值。拿大理原图去对，3 个真值点各有一张照片，**EXIF 换算成 GCJ 后
+落在 5.2 / 19.0 / 31.4m 内，且拍摄时刻与到访时刻相差 8~78 分钟**（`IMG_20260815_101254.heic` → 九孃
+豌豆粉店 5.2m、晚 8 分钟）。不换算则离真值 238~370m。⇒ **EXIF 确为 WGS-84，换算方向正确**。
+换算函数另在基线真机数据上验证 **305/323 逐位一致**，各地偏移量与真值吻合（贵阳实测 -0.00354/+0.00373，
+函数给 -0.00353/+0.00377）。
+
+**旁证：高德 POI 是 GCJ-02**（别再怀疑）：拿贵阳基线的 76 个真值点验证，64 个高德 POI 落在
+「显示坐标（GCJ）」3m 内、离「原始 GPS（WGS）」约 540m。
+
+**修复后新出现的瑕疵**：13 个「名称/地址由错坐标反查而来」的点，坐标改对后名称与位置差了约 600m
+（如 sp349 现在在天心阁东南 630m，名字还叫「天心阁」）。已列清单，等站长定是否按新坐标重跑一次逆地理刷新。
+
+产物：`tmpfog/fix-report.html`（最终报告，含前后坐标、验证结论、遗留项）、`tmpfog/applied.csv`、
+`tmpfog/_name_origin.json`、`tmpfog/_old_datum.json`、`tmpfog/_exif_dist.json`。
+
+### 按新坐标刷新地址（生产）+ 坐标来源留档上线（根治方案）
+
+站长指令：**「1、按新坐标重跑一次逆地理刷一致；2、按根治方案动手」**。两件都做完了。
+
+#### 一、名称「与位置差 600m」的裁定：**不改名称，只刷省市区街道**
+
+上一轮说「13 个点的名称/地址是旧坐标反查产物」用的是**宽松判据**（名称出现在旧坐标 regeo 的 blob 里），
+这轮校准出它**过宽**：`#349` 的 blob 里出现「天心阁」只是因为里面有「8117咖啡(天心阁**店**)」和「天心**公园**」。
+真正的判据只有两条（照片导入页 `applyOne` 只会用这两种方式自动填名）：
+① 名称 == 旧坐标 200m 内最近 POI 的店名；② 名称 == 「区县 + 街道/乡镇」兜底拼法。
+按这两条重判：**13 个里只有 `#409`（柠季，旧坐标最近 POI 一字不差、17m）和 `#377`（荔波县瑶山瑶族乡，兜底拼法）是软件填的**，
+其余 11 个是站长自己的标注 → **一律不动**。
+
+**「同名地物离旧坐标更近」不是反证**（差点把它当成改错了）：13 个里有 7 个被判「名称属于旧坐标」，
+但旧坐标附近往往有一批同名 POI（天心阁古玩城/钟楼公园店/华莱士·钟楼公园店…），
+更多是**站长照着导入页显示的那一行地址（`店名（N米） · 完整地址`）抄下来的**——地址也是错坐标反查出来的。
+站长的 `#409` 就是实例。
+
+**同一批次同一定律（这才是决定性的）**：一次导入里所有点用的是同一个坐标系选择、同一台手机。
+长沙批次里 `#348 茶颜悦色`（旧坐标距同名 POI **647m**，远超反查半径 200m ⇒ 不可能是自动填的）、
+`#354 肉丸店`(674m→11m)、`#352 长沙南站`(566m→12m)、`#360 四方坪三十栋饭店`(629m→35m)、
+`#356 坡子街派出所`(322m→32m) 等 **8 个站长自己命名的点，换算后全部落在同名地物 11~383m 内**
+⇒ 换算方向对整个批次成立 ⇒ 剩下那几个「旧坐标更近」的只能是名称伪证。
+
+**设备同一性（补完最后一块证据）**：长沙原图 `data/images/IMG_20251219_*.jpg`、大理 `IMG_20260815_*.heic`、
+佛山 `IMG_20260418_181404.jpg` **全是 HUAWEI Mate 80 Pro Max**。大理那 3 张已独立证明 EXIF=WGS-84
+（gcj(EXIF) 落在高德真值 5.2/19.0/31.4m 内），佛山那张经站长肉眼复核（银星雅苑/翠庭轩 91~144m）。
+同机同约定 ⇒ 长沙批次也是 WGS-84 ⇒ 上一轮 63 个点的换算全部正确，**无需回退**。
+
+#### 二、地址刷新（已落库，39 行）
+
+派生字段（省/市/区/街道）还是按旧坐标反查来的——长沙 24 个、荔波 16 个的**「区县」干脆是空的**
+（顺带说明：这 40 行是**老版**照片导入页建的，那时表单还没有区县字段；佛山那批才带区县——
+所以「区县为空」可以给「老版照片导入」当旁证）。
+以**新坐标**调 `/api/regeo`（coord=gcj02，不再换算），只覆盖反查给出值的字段，反查失败不清空。
+`tmpfog/addr_apply.py --apply` → **成功 39 / 失败 0**；复核 **区县异常 0 ｜ 名称/类别变动 0 ｜ 坐标偏移 0**
+（回退清单 `tmpfog/addr-rollback.csv`）。佛山 23 行本来就对。`#367` 首次反查空返回，单独重试补上（开福区）。
+**街道（thoroughfare）这轮没提交**——线上还是旧二进制会忽略该字段，等部署后再跑一轮。
+
+#### 三、根治方案：places 加 4 列坐标来源留档（已实现，待部署）
+
+列：`coord_source`（rond / photo / manual，空=历史行无留档）、`coord_sys`（wgs84 / gcj02）、
+`src_lat`/`src_lon`（**换算前**的原始坐标）。三者齐全时 **显示坐标 == 按 coord_sys 换算 src_lat/src_lon**。
+
+- `schema.sql`：4 列 + 存量回填（有 ZLOCATION 留档 → rond/wgs84/`ZRAWLATITUDE`）。**不拿启发式猜**——
+  猜错比留空更糟，那 45 行（生产 86 行）宁可先空着，标「未留档」。
+  本地实测回填 323 行，其中 18 行 src==显示坐标（正是「当初没偏移」的那批）。
+- `ingest.go` 加 `backfillCoordSource`：导入完 rondbackup 后按同一判据补，新导入的包立刻有档。
+- `handlers_photos.go`：写入 `photo` + 用户选的坐标系 + 换算前坐标（换算前先存 `srcLat/srcLon`）。
+- `handlers_edit.go`：新增记 `manual`/`gcj02`；`editPlaceUpdate` 拆出 `updatePlaceRow`，规则：
+  **表单没提交的列一个字不动**（批量工具只改坐标时不能把留档/街道抹掉）；**坐标动过才更新留档**（否则改个名字就冲掉原始坐标）；
+  走换算时原始坐标记换算前那份 + `coord_sys` 记来源坐标系；选「未记录」整组清空。
+- `edit.html`：列表加来源标记（`rond 导入 · WGS-84` / `未留档`）+ 来源筛选下拉（带各来源计数）；
+  行内新增「按坐标刷新地址」按钮、`coord_source`/`coord_sys` 下拉、街道输入框；换算下拉联动修正留档
+  （`coord_sys` 设成来源系、`src_lat/src_lon` 填换算前的值），隐藏字段用全精度带出（原先 `%.6f` 会截断留档）。
+- `place_coord_test.go`（新增，6 条断言）：导入自动补档、只改名称不动留档与街道、换算带原始坐标且 `显示==gcj(src)`、
+  选「未记录」清空、后台新增 manual/gcj02、照片导入 photo/(wgs84|gcj02) + 原始坐标。
+
+**实测**：`bin/rond.exe` 重编后本地起站（伪造会话 uid=2）→ 列表标记/筛选正确（368 / rond 323 / 未留档 45 / photo 0）；
+用 `rond-web-verify` 的无头 Chrome 真点按钮：反查把空的区县填成「金城江区」、街道保留、提示带地址与最近 POI（13m）、**0 JS 报错**；
+换算下拉实测 `24.689928,108.042479`（WGS）→ `24.687112,108.046675`（527m 往东南），
+`src_lat/src_lon` 变成换算前的值、`coord_sys=wgs84`，切回「保持原样」原值（含全精度）完整还原。
+导出侧回归：`TestMovementCRUDExportE2E` PASS；纯净往返 `verify_rondbackup.py` **总差异 3**
+（全是既有的 `ZLOCATION.ZLASTARRIVALDATE_` 站点重算，与改动前逐行相同）。
+
+**部署**：`bash scripts/build-linux.sh` → `dist/rond-linux-amd64` 已生成，替换后 `systemctl restart rond-with-you`
+（启动自动跑增量迁移，幂等）。留档列不参与导出，rond 侧列一字不变。
+
+**遗留**：① 街道需部署后再跑一轮（目标值在 `tmpfog/addr-plan.csv`）；② 86 个历史行的留档仍为空
+（审计结论已能逐行定性，等站长要就按结论回填）；③ `#324–343、#384、#385` 缺区县（新增地点页建的正确点）；
+④ 导出 `ZISPHOTOIMPORT` 恒 0（有了 `coord_source` 后很容易补，属导出侧改动，单独一轮）。
+
+产物：`tmpfog/report-coordsource.html`（本轮报告）、`tmpfog/addr-plan.csv`、`tmpfog/addr-rollback.csv`、
+`tmpfog/regeo-plan.csv`（13 个名称点的新旧反查对照）、`tmpfog/regeo_refresh.py` / `addr_plan.py` / `addr_apply.py` / `addr_verify.py` / `name_check.py`。
+
+### 部署后复测：发现并修掉「导出合成行」这个真 bug（v7 之后）
+
+站长指令：**「继续未完成的任务，并检查最近的修改是否引入了什么逻辑错误或者bug」**。
+
+#### 一、真 bug：62 个照片导入的点被误标成 `rond 导入 · WGS-84`
+
+**根因（两条，都在我上一轮自己写的代码里）**：
+1. **判据错**：回填写的是「有 ZLOCATION 留档 = rond 导入」。但生产这份数据集是**用站点自己
+   导出的包回导**出来的，而 `export.go:247` 会给站点新建的地点**合成** ZLOCATION 行
+   （`ZRAWLATITUDE = GCJ02ToWGS84(导出那一刻的显示坐标)`）。于是 324–385 这些照片/手工点
+   全都"有留档"，被整批当成 rond。386–409 是那次导出之后才建的，没有留档行，所以是空的。
+2. **列错位**：`src_lon` 取的是 `ZLONGITUDE`（显示经度），应为 `ZRAWLONGITUDE`（原始经度）。
+   纬度取对了、经度复制粘贴错。本地实测 323 行里只有 18 行碰巧对。
+
+**判据（唯一可靠的那条）**：合成行的 `ZRAW` 是我们自己写进去的，所以**位级**满足
+`ZRAWLATITUDE == GCJ02ToWGS84(该留档行自己的 ZLATITUDE)`；真机行的 ZRAW 是独立采样值，
+从不满足（基线 321 行**零命中**，Go 实测）。**必须用留档行自己的 ZLAT 比，不能用 `places.lat`**
+——344–383 的显示坐标在导出之后被改过，拿当前值比会漏掉这 40 行。
+
+**修法**：`internal/ingest/coord.go`（新）写 `BackfillCoordSource`：
+- 合成行 → 有 `coord_source='rond'` 且 `src_lat==ZRAW` 的**撤回**（清成 NULL，宁可留空不猜）
+- 非合成行 → 空的补 rond/wgs84 + src=ZRAW；src_lon 是显示经度的**顺手改回原始经度**
+- **境外点跳过**：境外不做偏移，`GCJ02ToWGS84` 是恒等，合成行与真机行长得一模一样、判不出来
+启动时 `BackfillAllCoordSource` 跑一遍（`main.go`），schema.sql 里那段 SQL 回填删掉（写不出 geo 判据）。
+
+#### 二、生产数据订正（`tmpfog/repair_coord_source.py`，86/86 成功）
+
+| 组 | 行数 | 目标留档 | 依据 |
+|---|---|---|---|
+| 344–383、387–409 | 63 | `photo` / `wgs84` / src=换算前的 EXIF | `tmpfog/fix-list-final.csv` |
+| 324–343、384、385、386 | 23 | `manual` / `gcj02` / src=显示坐标 | `tmpfog/keep-list-final.csv` |
+
+顺带补完上一轮遗留：**街道**（`addr-plan.csv` 的「新街道」；84/86 有值）+ **324–343、384、385
+的区县**（反查补齐，86 行零缺失）。写库前先验不变式「显示坐标 == 按 coord_sys 换算 src」，
+86 行全过才提交。复核：321 rond / 63 照片导入 / 23 后台新增 / **0 未留档**。
+回退清单 `tmpfog/repair-rollback.csv`（注意：留档那几列回退等于退回已知有 bug 的状态）。
+
+#### 三、导出侧补 `ZISPHOTOIMPORT`（`export.go`）
+
+rond 靠这一位分「照片导入 / 手工新增」，站点没这个字段，但 `coord_source='photo'` 说得清楚。
+做法：`queryPlaces` 多取 `coord_source`，ZLOCATION 写完统一 `UPDATE ZLOCATION SET
+ZISPHOTOIMPORT=1 WHERE Z_PK IN (...)`（分块 500）——新建行与「走整行还原」的行都覆盖得到，
+而真机行（`coord_source='rond'`）不碰。列不存在时跳过（`loc.typeOf`）。
+
+#### 四、顺手发现并修掉的两个 bug
+
+1. **「按坐标刷新地址」按钮从来不填街道**（`edit.html`）：接口给的是 `street`/`township`，
+   JS 却读 `it['thoroughfare']` → 永远 undefined。改成 `it.street || it.township`。
+   无头 Chrome 实测：修前街道保持空，修后填出「西环路」，0 JS 报错。
+2. **行内保存会把坐标截到 6 位小数**（`handlers_edit.go`）：表单经纬度框是 `%.6f`，真机基线
+   的点带长小数。实测只改名称也把 `26.46800422211455` 写成 `26.468004`。照 `keepStoredTime`
+   的同一套办法加 `keepStoredCoord`：落在同一个 6 位小数上就沿用库里那份。实测修后不再截断。
+
+#### 五、还没动、留给站长拍板的
+
+`adminPhotosImport` / `editPlaceCreate` / 天气新增 都用 `SELECT MAX(src_pk)+1`，没走
+`nextSrcPK`（那个还会看 `coredata_meta` 与 `entity_raw` 的最大编号），也没调 `clearStaleRaw`。
+`entity_raw` 里**确实存在 skipped 行**（本地 ZVISIT#191），意味着某个编号可能没有对应实体行却
+一直占着号；删掉最大号的地点后再新建就会复用，导出时被当旧行。位移/交通方式两条路径是走对了的，
+地点与天气没走。当前生产没踩到（places max 409 > entity_raw max 385，且删地点有 pruneEntityRaw 兜底）。
+
+产物：`internal/ingest/coord.go`、`tmpfog/repair_coord_source.py`、`tmpfog/repair-regeo.csv`、
+`tmpfog/repair-rollback.csv`、`dist/rond-linux-amd64`。新增测试：
+`TestCoordSourceSkipsExportSynthetic`、`TestExportPhotoImportFlag`、`TestInlineSaveKeepsFullPrecisionCoord`。
+纯净往返差异仍是 **3**（全是既有的 `ZLASTARRIVALDATE_`）。
+
+### 站长部署后的复核 + 编号分配收口
+
+站长指令：**「我已经在正式环境部署了最新的源码编译版本，你再检查下你在本地测试的结果是否正确。
+另外你发现的地点与天气没走 nextSrcPK 问题，一并收口，做完再次完整测试。」**
+
+#### 一、生产复核（`tmpfog/verify_deploy.py`，全绿）
+
+| 检查项 | 结果 |
+|---|---|
+| 来源标记分布 | 321 rond / 63 照片导入 / 23 后台新增 / **0 未留档** |
+| 基础行留档自愈（321 行） | `src_lat`、`src_lon` 与导出包 `ZRAWLAT/ZRAWLON` **全精度逐行相等，0 不符** |
+| 导出侧 `ZISPHOTOIMPORT` | 照片行全 = 1、手工行全 = 0 |
+| 不变式「显示 == 按 coord_sys 换算 src」 | 407 行 0 不符 |
+| 新增行地址完整度 | 区县 0 缺失；街道缺 367、386（高德未返回，可接受） |
+
+⇒ **启动自愈真的跑了、跑对了**：`src_lon` 那个「取成显示经度」的笔误在生产上被自动改回原始经度，
+且 86 行手工订正的留档一个没被动。本地测试结论在真实环境成立。
+
+#### 二、编号分配收口（本轮新改动）
+
+原来只有位移/交通方式走 `nextSrcPK`，其余全是 `SELECT MAX(src_pk)+1`。**统一改成
+`nextSrcPK` + `clearStaleRaw`**，新增四个编号空间：
+
+```go
+placeSeq    = srcPKSeq{"places", "src_pk", "Location", "ZLOCATION"}
+visitSeq    = srcPKSeq{"visits", "src_pk", "Visit", "ZVISIT"}
+activitySeq = srcPKSeq{"activities", "src_pk", "Activity", "ZACTIVITY"}
+weatherSeq  = srcPKSeq{"weather", "src_pk", "HourlyWeather", "ZHOURLYWEATHER"}
+```
+
+改动点：`adminPhotosImport`（原来在循环外算一次、失败还 `nextPlaceSrc--`，现在每行在事务里
+按三处上限取号）、`editPlaceCreate`、`editWeatherCreate`（原来是裸 `s.db` 插入，顺手包进事务）、
+`insertVisit`（新增到访 / 照片导入共用）、活动内联新建。全项目已无 `COALESCE(MAX(src_pk),0)+1`。
+
+新增 `internal/web/seq_test.go` 的 `TestNewRowNumberingSkipsArchivedPKs`：造一条
+「只有留档、没有实体行」的 ZLOCATION（`skipped=true`，**raw 里必须带 `Z_PK`**，判据就是靠它算上限），
+再走手工新增与照片导入两条路径，断言编号绕开它、且留档行本身不被误清。
+
+**踩过的坑**：第一版测试 fixture 的 raw JSON 忘了写 `Z_PK`，`nextSrcPK` 读不到，
+于是「绕开」断言失败 —— 反过来说明这条测试确实在盯 `entity_raw` 的最大号。
+
+#### 三、复测
+
+`go test ./internal/...` 全绿；`go vet` 干净；纯净往返 `verify_rondbackup.py` 总差异仍是 **3**。
+产物 `dist/rond-linux-amd64`（19:29）与 `bin/rond.exe` 均已重编。本轮只改编号分配、不涉及数据订正，
+部署替换二进制即可。
+
+### 三个新需求：地图底图可选 / 文字折行 / 地点图片（前端转 WebP）
+
+站长指令原文：**「一，地图放到最大时会显示很多信息显得杂乱，看不清自己的点，能否只显示街道或
+有其他表现形式可选（可在后台选择）；二，不少地方文字显示异常，一行只有一个字就截断到第二行；
+三，加一个展示图片的功能，点开地点用按钮显示管理员维护的图片，图片可存本地或 S3（R2），
+已有地点可编辑添加、新增地点可选择是否保留图片，要转 WebP 且**在前端完成转码**。
+请逐项完成，每项做完测试是否引入新 bug 或与其他功能冲突。」**
+
+#### 一、文字「一字一行」：表格被压扁（已修，全站回归 0 处）
+
+**取证方式**：写了段 CDP 诊断脚本，用 `Range.getClientRects()` 数**真实行盒**
+（按 top 以半字号为容差聚类，避免同一行里不同字体被算成多行），再算「每行平均字数」，
+扫 10 个页面 × 6 个宽度（360/390/480/620/768/1024）。
+
+**发现**：只有 `/places` 与 `/admin` 两处，都在 `table.tb` 上。根因是
+`table.tb { width: 100% }` + CJK 允许逐字断行 ⇒ 窄屏时**列被榨到一两个字宽**而不是溢出
+（`/places` 7 列在 390px 下每列约 68px，「一般公共场所」排成 **6 行、一行一个字**）。
+
+**修法**：`.tw > table.tb { min-width: 640px }` —— 给表格一个内容下限，放不下交给 `.tw` 横滚。
+修后 60 个组合全部 `[]`（无挤压）。
+
+#### 二、地图底图可选「纯路网」（已做，后台可切 + 访客自选优先）
+
+**先确认了「杂乱」来自底图自带的 POI/路名标注**（地图上我们自己的点只有 hover 气泡，没有常驻标注）。
+`style=8`（当前「街道」）与 `style=7` 对比实测：同一块的**近黑像素占比**（≈文字量）
+长沙 1.46% vs 0.21%、香港 1.27% vs 0.82% —— **style=7 是纯路网，几乎不标注**。
+
+改动：`tiles.go` 加 `amap-roadnet`（style=7）；后台「设置 → 地图底图」加「默认用哪张底图」
+下拉（`setting.MapDefaultBase`，取值按当前实际图层校验，换过 map_provider 的旧值自动失效）；
+`/api/map-config` 下发 `default`；`rond-map.js` 的 `pickBase()` 三级回落
+**访客在图上切过的那张（localStorage `rond.base`）→ 后台默认 → 第一张**，
+并监听 `baselayerchange` 记住。无头 Chrome 实测：后台设 `amap-roadnet` 后地图真的铺 style=7；
+同一会话里写 localStorage 为 amap-street/amap-roadnet，铺的分别是 style=8/style=7。
+
+**踩过的坑**：`setting.Load()` 是**逐字段显式覆盖**的，新加的字段忘了写那一行 ⇒ 库里存了、
+读出来是默认值。加设置字段时**必须同时改 Default()/Load()/settingsSubmit() 三处**。
+
+#### 三、地点图片（已做，前端转 WebP + 本地/R2 双后端）
+
+站长拍板：**照片导入时勾选保留** / **经本站后端中转** / **选择放后台、凭据放 app.ini**。
+
+- `internal/media`（新）：`Save/Delete/PublicURL`，后端 `local`（`data_dir/media/...`，
+  由 `GET /media/` 直出、内容寻址可强缓存）或 `s3`（**手写 SigV4**，PUT/DELETE，路径式）。
+  零新依赖——go.mod 只有 pgx 与 sqlite，为这个引一个 SDK 不划算。
+- `place_images` 表：`storage` + `object_key` 分别记住每张图**实际**在哪，
+  换存储后端后老图仍取得到。key = `<dataset>/<src_pk>/<sha256[:20]>.webp`（内容寻址、天然去重）。
+- `POST /admin/place/images`（multipart）、`POST /admin/place/images/delete`、`GET /media/`。
+- 前端 `static/js/place-image.js`：canvas 转 WebP（长边 2000px、q0.82），
+  **`blob.type !== 'image/webp'` 必须显式判错**——不支持编码的浏览器会静默给回 PNG。
+- 地点页：访客一个「图片 N」按钮 → 全屏画廊（深底、Esc/点空白关闭、锁背景滚动）；
+  站长多一块管理面板（缩略图墙 + 多选上传 + 单张删除）。
+- 照片导入页：新增「存图」列（默认不勾），提交时**拦下 submit → 逐张转码 → 塞进隐藏的
+  `<input type=file>`（DataTransfer）→ 再 `form.submit()` 放行**；表单改 `multipart/form-data`。
+
+**两个真 bug（都是测试逼出来的）**：
+
+1. **`r.ParseForm()` 会毒化后续的 multipart 读取**。前端用 `FormData` 发（multipart），
+   `ParseForm` 只解析 urlencoded，却会把 `r.Form` 先填成「不含 multipart 字段」的那一份；
+   `FormValue` 只在 `r.Form == nil` 时才去解析 ⇒ 之后再怎么读都是空。图片删除按钮点了没反应
+   就是这个。**规则：收 multipart 的 handler 不要先 ParseForm**，直接 `ParseMultipartForm`
+   （注意 urlencoded 调用方会收到 `ErrNotMultipart`，要 `errors.Is` 放过，否则测试与脚本全挂）。
+2. **把照片导入表单改成 multipart 后，原 `ParseForm` 直接让 `n` 读成 0**，整批导入静默失败
+   （报「没有可导入的照片」）。同一个根因，同一次修。
+
+顺带加了防护：导入请求 `http.MaxBytesReader` 60MB（勾了存图才可能有几百 KB×N），
+前端勾超过 60 张先 confirm 提示。
+
+**验收**：`TestPlaceImageUploadDelete`（multipart 上传→落盘→`/media` 字节一致→非 WebP 被拒→
+multipart 删除两处都清）、`TestPhotoImportWithImage`（勾选存图→地点与图都建好、宽高记对）、
+`TestPlaceImageS3Backend`（httptest 假装 S3，断言路径式 URL + SigV4 Authorization + 公开域名取址 +
+切 s3 后本地不再落盘）、`internal/media/media_test.go` 的
+**`TestSignV4MatchesAWSExample`（AWS 官方向量，签名逐位相符）** + escape/canonicalURI/取址/路径穿越。
+浏览器实测：CDP 造一张 PNG 塞进文件框，页面自己转成 WebP（落盘确为 `WEBP (800,600) 4954 bytes`）
+并出现在缩略图墙；全站 8 个页面 JS 报错 0。
+
+**测试间互相污染**：多个测试共用一个库，S3 那个测试把 `media_backend` 留着没还，
+后面的本地上传就失败。加了 `setMediaBackend()` + `t.Cleanup` 还原本。
+
+#### 复测
+
+`go test ./internal/...` 全绿；`go vet` 干净；纯净往返总差异仍是 **3**。
+产物 `dist/rond-linux-amd64`（22:58）。本轮**新增表 `place_images`**，启动迁移会自动建；
+`conf/app.ini` 多了 6 个 `s3_*` 空键（不填 = 只能存本地）。

.workbuddy/memory/2026-09-19.md

@@ -0,0 +1,509 @@
+# 2026-09-19
+
+## 真机反馈「移动端还是要左右滑」：容器查询是错的，改回媒体查询（阈值 800）
+
+站长 00:09 反馈：在本地环境用移动端测试，还是得左右滑动，否则只能看到一部分信息。
+
+### 根因：我上一轮把堆叠判据换成 @container 是个错误决定
+
+无头 Chrome（新版）里容器查询工作正常，390 下表格都堆叠了；但**容器查询要 iOS 16 / Chrome 105
+起才支持**，不支持的浏览器会把整块 `@container` 规则当不认识的东西**整块丢弃** ⇒ 表格完全不堆叠、
+8 列要横滑 328~388px。站长的手机浏览器大概率就落在这一档，于是「还是得左右滑、只能看到一部分」。
+（顺带：媒体查询 620 那个旧版本同样有漏 —— 视口 621~792 的卡片既放不下表格又没窄到 620 以下。）
+
+### 改法
+
+`app.css` 末尾：`@container (max-width: 699px)` + `.tw{container-type:inline-size}` →
+**`@media (max-width: 800px)`**。800 是从「卡片能不能放下表格」换算来的：卡片内容宽 ≈ 视口 − 93，
+最宽的表 min-width 700 ⇒ 视口 793 以上才放得下，取 800 留几像素余量（注释里写清了换算依据）。
+`wide_table_layout_test.go` 的 CSS 断言同步改成：**每条 tb-stack 规则都必须落在 max-width ≥ 792
+的 @media 里**（容器查询会被判为「不在任何 @media 里」，退回 620 会被判「阈值太小」）。
+
+### 实测
+
+- 形态切换点：360/390/620/800 → 堆叠；801/900/1440 → 表格。**全部横滑 0**（/places、/stats、/report）。
+- **禁用容器查询的环境下依然堆叠**（注入脚本删 CSSContainerRule：删到 0 条、横滑仍 0）⇒ 旧手机不会再退化。
+- 两次变异验证：阈值退回 620 → FAIL（「视口 621~792 的卡片放不下表格」）；
+  改回 @container → FAIL（「不在任何 @media 里」）。
+- 四轮全站审计（390 站长 / 390 访客 / 1440 / 320）与改动前**逐值一致**（溢出全 0、0 JS 报错）。
+- 两段式全量：纯净包 PASS → 11 包 ok、0 FAIL。
+
+### 移动端还剩哪三处能左右滑（普查全站所有 overflow-x:auto 的元素）
+
+| 位置 | 需滑 | 性质 |
+| --- | --- | --- |
+| `.nav-links`（每个页面顶部） | 107~137px | 7 个导航项在 390 里放不下（内容 321 / 可视 214），`overflow-x:auto` + 隐藏滚动条 |
+| `.heat`（首页「活跃日历」） | 513px | 有意的横向滚动（一周 53 格） |
+| `.temp-strip`（统计页「天气与气温」逐月气温条） | 32px | 有意的横向滚动 |
+
+表格已全部不滑。导航那处每个页面都有、且用户看不出「还能滑」，是下一个候选（方案：换行两行 /
+「更多」菜单 / 保持滑动但加渐隐提示），等站长定。
+
+### 教训
+
+**"更精确"的技术特性要先看兼容性代价**：容器查询在无头 Chrome 里完美，我却没评估旧浏览器会
+整块失效——这是把「自己环境的验证通过」当成了「用户环境可用」。凡是写 CSS/JS 判据，
+先问一句「不支持这个特性时会发生什么」，退化路径比精确性更重要。
+
+## 站长补充定位：「后台数据编辑页面，比如地点列表等地方」
+
+我把问题定位到 `/admin/edit`：**三张表（地点列表 / 到访记录 / 行程记录）从来没有打过 `tb-stack`**，
+390 下 5 列要横滑 316px。之所以上两轮全站审计没发现，是因为它们默认折叠在 `data-card` 卡片里、
+探针量到的是 `display:none` —— **默认态测不出隐藏内容的横滑**，这是漏页的真正原因。
+
+### 改动
+
+- `admin/edit.html`：三张表加 `tb-stack`，非首格补 `data-label`（城市/坐标/到访/地点/类型/备注/路线/方式/里程）；
+  末尾那个只放「编辑」的操作格**不加标签**（表头本来就是空的 `<th></th>`，硬加会把按钮/表单挤窄）。
+- 三处行内编辑表单的 `style="min-width:280/300/320px"` → `style="--efw:280/300/320px"`；
+  CSS 里 `.inline-edit form { min-width: var(--efw, 280px) }`，放不下宽表时再放开成 0。
+  用 CSS 变量而不是 `!important`：inline 的 min-width 压不过后面的媒体查询覆盖，变量没有优先级问题。
+- **操作格的 `white-space:nowrap` 从 inline style 挪成类 `.ops`**（`table.tb td.ops`）：`white-space`
+  会继承到格内的编辑表单，堆叠后「已选：#403 2026-09-13 19:53 · 某某地」这一行不换行、把卡片顶出 44px。
+  同样的 nowrap 还出现在 `admin/index.html` 与 `admin/topics.html`，一并改成类。
+- 堆叠态放开：`td:not([data-label])` 与 `td.ops` 都 `white-space: normal`。
+
+### 测试（重点：让「漏页」不再可能）
+
+- `tb_stack_test.go` targets 加 `/admin/edit`（12 张表）；**标签豁免规则改成跟着表头走**：
+  表头为空的列不需要 `data-label`（正好覆盖操作格，规则自洽）。
+- `wide_table_layout_test.go` targets 加 `/admin/edit`、`/admin/photos`；div 栈同时跟踪 `.tw`，
+  新增判据 **「凡被 .tw 包住的表格都必须带 tb-stack」**（照片表按既有方案单独处理，显式豁免）。
+  这条是通用的：以后任何新页面漏加，测试直接报出来。
+
+### 实测
+
+- 展开三张表后：360/390/620/801/1440 横滑**全部 0**（改前 390 是 316）。
+- 每张表各展开一行编辑表单：28 个可见控件逐个 `elementFromPoint` 点测 **0 个点不到**，
+  表单不超出卡片（390 下 302px 放进 324px）；0 JS 报错。桌面 1440 仍是表格、`td.ops` 仍 nowrap。
+- 后台各页（edit / photos / admin / topics）展开后全站可横滑元素只剩 `.nav-links`（导航，107px）。
+- 两段式全量：纯净包 PASS → 11 包 ok、0 FAIL（`tb_stack_test` 12 张表、`wide_table_layout_test` 12 张表 13 条规则）。
+- 四轮审计与上一版**逐值一致**（表格改的都是折叠区内容，默认态审计看不出来）。
+
+### 两个坑
+
+1. **折叠/隐藏区域里的内容，默认态探针测不到** —— 审计脚本跑的是页面默认态，`/admin/edit` 三张表
+   一直是 `display:none`。凡是"某个区块要展开/切换才出现"的页面，必须**先展开再量**。
+2. **CDP 独占**：我在审计脚本运行期间并发跑了截图命令，两边抢同一个 Chrome/9333，
+   审计数字当场就歪了（`/timeline` 小触控 181 → 6、`/map` 13 → 6）。审计/探针/截图一律串行。
+
+## 导航栏：保持可滑动 + 右缘渐隐提示（站长选的方案）
+
+站长的第二问选了「保持滑动，加渐隐提示」。7 个导航项在 390 下内容 321 / 可视 214，硬塞不下
+（每项 2~3 个汉字 + 44px 触控高度，缩字号内边距也省不出 107px），换行或「更多」菜单都动结构，
+所以按他选的做提示。
+
+- `layout.html` 的 `nav` 定义里加 9 行脚本（跟在 `</nav>` 后）：按
+  `scrollWidth - clientWidth - scrollLeft > 2` 给 `.nav-links` 加/去 `.overflow-right`，
+  监听 `scroll`（passive）与 `resize`。
+- `app.css` 620 块里加 `.nav-links.overflow-right { mask-image: linear-gradient(...) }`。
+  用 **mask** 而不是盖一层渐变伪元素——伪元素会把链接文字一起遮住，mask 是让内容本身渐隐。
+  不支持 mask 的浏览器只是少个提示，滑动照旧（退化安全）。
+
+实测：390 溢出 107 → 有类、mask 生效；滑到末端类自动消失、滑回开头回来；1440 无溢出无类、mask=none。
+**像素级验证渐隐可见**：同一页面 A/B（注入脚本摘掉类）截图对比，差异区 `x 516~548`（scale 2）
+正好是 `.nav-links` 右缘那 28px——注意别拿整图最右侧去采样，那里是「后台/退出」按钮、不在 mask 范围内
+（我第一次就这么采的，差 0.0 差点误判成"渐隐没生效"）。
+
+全量测试（含 layout.html/CSS 改动）：纯净包 PASS → 11 包 ok、0 FAIL。改动仍未提交。
+
+## 收尾复查与提交（01:30~01:55）
+
+复查清单与结论：
+- `go build ./...` / `go vet ./...` / `gofmt -l` 全清；CSS 花括号 485/485 平衡；CSS 里 `@container`
+  只出现在注释里（`stripCSSComments` 那条判据就是为它写的：注释里的 `@media/@container` 会带偏解析）。
+- **导出验收两段式**：`ROND_CLEAN_OUT=… go test ./internal/web -run TestMovementCleanExport` →
+  `ROND_EXPORT=… go test ./internal/rond -run TestExportRoundtrip`，visits 823/places 323/moves 791 全对上，
+  **坐标偏差 0.000000000、时间偏差 0s**。注意：**这两个测试的相对路径是相对包目录**（`internal/rond`），
+  从仓库根传 `ROND_SRC=data/…` 会报「找不到文件」，必须给绝对路径 `C:/…/data/…`。
+- 全量 `go test -count=1 ./...`（带 `ROND_TEST_CONF` + `ROND_SRC`）：11 包 ok、**0 FAIL 0 SKIP**。
+- CDP 实测（debug=true，模板/CSS 热加载）：390 下 `/admin/edit` `/stats` `/report` 整页溢出 0、
+  每个 `.tw` 横滑 0、`__errs=0`；1440 下同样 0 溢出，且 **nav 无 overflow-right 类**（桌面不该有渐隐），
+  操作格 `white-space`=桌面 nowrap / 堆叠态 normal。三张行内编辑表的字段逐一核对无缺失。
+
+**修了一处测试的逻辑瑕疵**：`checkWideTablesOutsideGrid` 原来「凡在 g2 里的表都报错」，
+但 g2 里放窄表是合法的 → 会误报。改成只判 `tb-stack`（那才是「宽表」的定义），窄表走 .tw 那条判据。
+**做了变异验证**：把 `/stats` 的 grid 改回 g2 → 测试确实报 3 条 FAIL → 还原。
+
+⚠️ **变异验证差点污染工作区**：我图省事用 `b.replace(b'<div class="grid">', b'<div class="grid g2">')`
+全量替换，而 stats.html 里本来就有 2 处没动过的 `grid g2`（「推荐&踩雷」「类型分布+一天中的分布」），
+还原时又被全量换回去 ⇒ 凭空多出 2 处我不想要的改动（diff 从 3 行变 5 行）。
+**教训：变异只改一处、且改完用 `git diff --stat` 跟改前的行数对账**（这次是看到 6→10 才发现）。
+按行号改（不是按内容 replace）才安全。
+
+提交 `9e01923` 并 push（`96e7631..9e01923`，一次带上了前三次未推的提交）。
+
+---
+
+## 评估「导入新备份 → 分析差异 → 合并」（未动生产代码）
+
+用户诉求：`data/20260919_111819.rondbackup` 与运行中的库有明显差异、两边各有对方没有的数据；
+fwss 虽然能选叠加/覆盖，但看不到差异。
+
+**先做实测，结论推翻了朴素设想**。临时探针 `tools/{diffprobe,idprobe,colprobe,fogprobe}/`（一次性，可删）：
+
+1. `diffprobe 20260919 … 9`：867 条到访「同号且一致 0 / 仅备份有 5 / 同号冲突 867」；
+   但按**到达时刻**对齐能命中 866/871 ⇒ 是同一批数据，**Z_PK 被整体重排**（配对全是 1→555、2→276 这种乱序）。
+2. 对照 `diffprobe 20260914 … 9`：同号一致 819/824、1→1 2→2… ⇒ 库内那一份就是 0914 备份
+   （外加 44 条站点补录 `is_user_added` + 4 处站点改过的时间）。所以 0914 时 PK 还是稳的，是这 5 天里变的。
+3. `idprobe`：`ZVISIT.ZIDENTIFIER_` 两次备份 **822 条 UUID 完全交集**（A 独有 0），
+   但 822 条里 **Z_PK 全变**；`ZACTIVITY.ZUID_` 同理（30/31）。⇒ **UUID 才是跨备份稳定键**。
+4. `colprobe`：`ZLOCATION.ZPLACEID` 322/323 为空、`ZEVENTIDENTIFIER` 全空 ⇒ 地点**没有 UUID 可用**，
+   只能「名称+坐标(1e-5)」当键（B 的 367 个地点命中 A 323 个，44 个是新的）。
+5. `fogprobe`：库内 10542 块/670565 格。0914 快照 8701 块对库 overlay 新增 **0 格**（全重复），
+   而 cover 会**静默丢弃 1841 块 / 94401 格**（≈14%）。`fog-export-fixed.fwss` 与库完全一致（0 差异）。
+
+**副产品发现**：`schema.sql` 里「src_pk（rond 内部地点 ID，跨快照稳定）」的注释是错的；
+`ingest.contentHash` 用 `SrcPK|Arrival` 做指纹，被 PK 重排骗过 ⇒ 同批数据重导会被当成新内容、新建数据集。
+
+**给出的方案（待批准，未写代码）**：上传先 dry-run 出差异页（新增/冲突/站点独有，UUID 优先对齐）→
+确认后单事务合并；fwss 先补数字差异面板（重点是 cover 会丢多少），再考虑差异地图预览。
+
+## 用户拍板 + 落地迷雾差异（阶段 1）
+
+三个回答：①**没重装/换设备/恢复 iCloud，"最后一次是从本项目正式环境导出数据覆盖到 rond 里"**
+②冲突策略=全部逐条 ③先做差异。
+
+①是决定性的：**Z_PK 重排不是 iCloud 的锅，是「把站点导出的包导回 rond」这个动作本身**，
+即每次往返都会发生。于是补做了链路验证 `tools/exportprobe`：调 `ExportRondbackup` 导一份，
+再与 0914 原始备份比 —— **822 条 UUID 全部一致、Z_PK 也全部一致**（B 独有 44 条正是站点补录的）。
+⇒ **站点侧导出完好，UUID 是贯穿全链路的唯一稳定键**，合并方案的地基成立。
+
+已实现（`internal/fog/diff.go` + `internal/web/fog*.go` + `templates/admin/fog-preview.html`）：
+
+- `fog.DiffBlocks(cur, inc)` 纯函数，出 GainBlocks/GainCells/GainArea、Overlap/SameBlocks、
+  LostBlocks/LostCells/LostArea；面积按块中心纬度 cos 修正。
+- 导入改**三段式**：`POST /admin/fog/preview`（暂存到 `data_dir/fog-staging/`，令牌 32 位 hex，
+  TTL 2h）→ `GET /admin/fog/preview/{token}`（现算差异，**不落库**）→ `POST /admin/fog?stash=…`
+  （此时是 urlencoded，`PostFormValue` 能读到 mode；无 stash 才走原 multipart，向后兼容）。
+- 差异页把两件事摆出来：叠加能补多少；**整体替换会丢多少块/格/面积**（快照缺 Model/~、Model/# 时另给警示）。
+
+真实数据实测（开发库 10542 块 / 670565 格 vs `data/Snapshot-20260914T154839+0800.fwss`）：
+叠加 **+0**（全是重复）⇒ 文案报「已被完全覆盖」；整体替换会丢 **1841 块 / 94401 格 / 7.7 km²**。
+页面数字与独立探针 `tools/fogprobe` 逐项吻合。CDP 量过 1440/390 均无横向溢出、按钮 84×44 达标。
+
+验证：`fog/diff_test.go`（5 例）+ `web/fog_preview_test.go`（预览不落库、叠加真写、替换丢数据、
+令牌挡路径穿越）。**变异验证**：把 `ix.Import(..., mode=="overlay")` 改成 `true`，
+`TestFogPreviewWarnsBeforeCoverLosesData` 立刻失败（"应有 3 格，实际 5"）。
+`go test ./internal/web/ ./internal/fog/` 全绿；全量 `./...` 也绿（`internal/rond` 那条
+`TestBaselineKeepsCoreData` 要传**绝对路径**的 `ROND_SRC`，相对路径会报"不是有效的 zip"）。
+
+探针仍在 `tools/{diffprobe,idprobe,colprobe,fogprobe,exportprobe}/`，后续做 rondbackup 合并还要用。
+
+**下一步（未做）**：rondbackup 差异预演页（UUID 对齐 + 地点用名称/坐标兜底），冲突全部逐条选。
+
+## rondbackup 差异预演（本次）
+
+`internal/rond/diff.go`（纯函数：`DiffVisits`/`DiffPlaces`/`DiffActivities` + `Counts`）
++ `rond.Parse` 新增 `Backup.VisitUUID`/`ActivityUUID`（从 SQLite `hex(ZIDENTIFIER_)` 读）
++ `web/backup_diff.go`（库侧加载 + `POST /admin/preview` 暂存 + `GET /admin/preview/{token}` 渲染）
++ `templates/admin/backup-preview.html`。后台上传区改成两个按钮：**分析差异**（primary）/ 直接导入（普通）。
+暂存逻辑同时抽成通用 `stashPut/stashRead/stashSweep`（迷雾与备份共用），迷雾那套测试原样通过。
+
+### 过程中撞到并修掉的两个真问题
+
+1. **无 UUID 的到访被双算**：真机 824 条到访里有 2 条没写 UUID，只按 UUID 配对 ⇒ 同一条既进
+   「备份新增」又进「仅站内有」。修法是加「到达时间（到秒）+ 地点坐标」兜底配对
+   （`timeKey`；只到秒是因为苹果时间戳是浮点秒、PG 存微秒）。
+2. **地点改名造成 17 条假冲突**：首版地点键是「名称+坐标」，而站点的 `backfillAfterImport`
+   把「体育馆美食街」反查成了「河池市国民体质监测中心」（坐标一字未动），于是一整个地点的
+   17 条到访全被报成「换了地点」。改成**地点只认坐标**（`PlaceCoordKey`），名称降级为比较字段；
+   配不上再按名称兜底（覆盖站点把坐标纠偏过的情况）。改完真实数据上冲突 **17 → 0**。
+
+### 真实数据实测（0919 备份 vs 库内 0914 数据集）
+
+| 实体 | 备份 | 站内 | 备份新增 | 仅站内有 | 冲突 | 一致 |
+|---|---|---|---|---|---|---|
+| 到访 | 872 | 867 | 49 | 45 | **0** | **822** |
+| 地点 | 367 | 368 | 1 | 2 | 4 | 362 |
+| 活动 | 31 | 31 | 0 | 0 | 0 | 31 |
+
+账目（`tools/keyprobe` 逐条核过）：0914 备份 824 行 = 822 有 UUID + 2 无（#16、#191）；
+其中 #191 无到达时间，导入时就被跳过且**不写 visits 但写了留档**，所以库里是 821 条有 UUID 的到访。
+0919 备份 872 行 = 870 有 UUID + 2 无（#365、#372 无到达时间）。
+于是：**821 条按 UUID 配对**、**49 条是 0919 新出现的 UUID**（870−821）、
+**#365 靠「到达时间+地点坐标」兜底配上库里的 #16**、
+库里 45 条站点补录无 UUID 也没留档 ⇒ **仅站内有 45**。四个数字全部自洽。
+（一度以为「有 1 条无 UUID 没配上」，是把补录数记成 44 了 —— `is_user_added` 实际是 45 条。）
+
+地点 4 条冲突正是反查补全留下的：
+改名 1 条、站内比备份更全 1 条、坐标被纠偏 2 条（28.141772→28.144964 这类）。
+
+### 验证
+
+`rond/diff_test.go` 11 例（UUID 对齐/字段差异/编号撞号不得误配/兜底配对/改名/坐标纠偏/活动重命名）
++ `web/backup_diff_test.go` 3 例端到端（同一份备份报一致、站内改动静默识别、**渲染前后行数不变**）。
+**变异验证**：去掉 `used[i] = true`，fog 与 web 两层同时失败。
+完整验收（带 `ROND_SRC`/`ROND_EXPORT`/`ROND_DSN`/`FOG_SRC`/`ROND_CLEAN_OUT`）见当次结果。
+
+### 按建议补做的三项
+
+1. **`ingest.contentHash` 换稳定键**（原为 `SrcPK|Arrival`）：改成按到访 UUID / 活动 UUID /
+   地点「名称+坐标」排序后取摘要，没有 UUID 的老备份退回「到达时间+地点坐标」。
+   回归 `ingest_test.go` 六例，变异验证（把 UUID 换回 `fmt.Sprintf("V%d", pk)`）当场失败。
+2. **修正两处声称「src_pk 跨快照稳定」的注释**（`db/schema.sql`、`rond/export.go`），
+   改成「只在单个数据集内稳定」并写明跨备份要靠 UUID。
+3. **复查「1 条配对不上」**：用 `tools/keyprobe` 把两边的键逐条打出来，结论是**没有 bug**，
+   是补录条数记错（45 而非 44）。兜底配对实际工作正常。
+
+**顺带确认**：「站点补录行占用 nextSrcPK 号段」这个隐患**不影响正确性** ——
+跨备份对齐走 UUID，导出时新行是 INSERT（基线里没有该号），回导实机后 pk 重排也无所谓。
+
+## 合并执行（本次）
+
+`rond/merge.go`（纯逻辑：`Choices` + `BuildMergePlan`，把「差异 + 页面上逐条的选择」翻成改动清单）
++ `web/backup_merge.go`（真执行）+ 差异页的合并表单（`form=` 属性把各表格里的 radio 关联到同一个 `#merge-form`）
+→ `POST /admin/preview/{token}/merge`。
+
+**语义**：新增类勾选才并；「仅站内有」一律保留；冲突逐条选（用实机/用站内/跳过，默认**用站内**，没提交或怪值也退回用站内）。
+**不做删除** —— 删地点会级联删掉它的全部到访。
+
+**合并顺序**：地点 → 活动 → 标签 → 到访 → 位移/天气 → 重算地点聚合与数据集汇总，全在一个 `withTx` 里。
+
+### 三个实测撞出来的坑（都已修）
+
+1. **位移/天气被整份复制**：一开始遍历 `b.Movements` 只要两端能映射就插，而映射表里包含**所有**备份到访
+   ⇒ 库里已有的位移又插了一遍（791 → 1547）。改成只处理「至少一端是这一轮新插入的到访」。
+2. **天气重复**：站内删到访时是把 `weather.visit_src` 置 NULL 而保留记录（`editVisitDelete`），
+   合并把到访找回来时又插一条同 `at` 的天气。改成插入前先**认领**「同一时刻、`visit_src IS NULL`」的那条。
+3. **测试自己的手法问题**：直接 `DELETE FROM visits` 会留下孤儿天气/位移（`weather.visit_src` 没有外键），
+   数字对不上。改成按站点的方式删（删位移、天气置 NULL、删到访）。
+
+### 验证
+
+`rond/merge_test.go` 4 例（选择翻译、怪值退回用站内、跳过、活动键优先 UUID）
++ `web/backup_merge_test.go` 3 例端到端：**删两条到访 → 合并 → 到访/位移/天气全部复原 → 再比对「零差异」（幂等）**、
+冲突选「用实机」真覆盖 / 选「用站内」不动、什么都不勾则一个字节都不写。
+**变异验证**：把新行的 `writeRawRow` 去掉，留档变 821/823 且**幂等性当场破**（合并后再比对报「新增 1 / 仅站内有 1」）。
+
+真实数据只验证了**渲染**（radio 分组正确、390 宽无溢出），**没有在开发库上真执行合并**——那会改动你 0914 那套真实数据。
+
+## 附属数据改挂坐标键（迁移）
+
+**动因**：备注/结论/图片原本挂 `(dataset_id, src_pk)`，换个数据集就全看不见——这是用户最初的痛点之一。
+用户这次明确要求：**迁移可以，但导出出去的 .rondbackup 与 .fwss 必须还是原有结构**。
+核对过：这次只动 PG 的三张附属表，`ExportRondbackup` 走的 visits/places/movements/weather/entity_raw
+一个没碰，迷雾那几张表也没碰，所以导出结构不受影响（并用往返测试实测确认）。
+
+**做法**：`place_key` = 经纬度各 6 位小数（约 0.1m）。`place_notes`/`place_votes` 主键换成
+`(user_id, place_key)`；`place_images` 加列 + 索引查。Store 的**对外签名一律不变**（仍是
+userID/datasetID/srcPK），内部改成按 key 存查，所以调用方一处没改。
+
+**关键前提验证**：Go 的 `%.6f` 与 PG 的 `FM999990.000000` 必须逐位一致——先在真实数据上
+比了 **368/368 全同**才敢动。
+
+### 撞出来的一个大坑：迁移块互相打架
+
+改完后测试报 `没有匹配 ON CONFLICT 说明的唯一或者排除约束`。查测试库发现：`place_key` 列**在**、
+主键却还是老的 `(user_id, dataset_id, src_pk)`。
+
+根因：`schema.sql` 里**早就有一段**把主键改回三列的 DO 块（当年加 dataset_id 时写的），
+守卫是「有 src_pk 列」——而 src_pk 永远存在，于是它**每次启动都执行**，把我刚改成 place_key 的主键
+又改回去。**每次都停在最后执行的那个块上**。
+
+修法两条：① 老块先判「没有 place_key 列」再动手（让位）；② 新块的判据从「列在不在」改成
+**「主键列组合对不对」**，这样「列已补、主键还老」的半迁移库也能自愈
+（测试库正好卡在这个状态，改完立刻验证通过）。
+
+**结论**：`schema.sql` 里所有改同一约束的块都会互相覆盖，**必须让老块能被新块取代**。
+
+### 访客票一并迁移（用户确认了猜法）
+
+用户明确：**访客投票只属于本站，rondbackup 里没有这一项**；但它同样要认得出是哪个地点，
+「如果两边都有就跟着活跃的走」。于是 `place_visitor_votes` 也改挂坐标键，
+主键换成 `(place_key, voter_key)`；这张表没有 dataset_id，回填时按**活跃数据集**认领
+（同编号在多个数据集里也只认活跃的那个），认不出的留 `orphan:<pk>` 不丢票。
+
+连带把**所有按这两张表统计的地方**都改成按坐标键 join `places`：`voteTotals`、
+`verdictPlaces`、备注页的排序与两处关联、`stats` 的 `Verdict` 过滤。
+按它们自己的 `dataset_id` 过滤会漏掉「从别的数据集写进来的票」。
+
+`apiVote` 原本没有数据集上下文，补了 `datasetFor`。
+
+开发库实测：1 条访客票迁到 `26.471574|106.673434`，与活跃数据集里 `src_pk=162`
+（孔学堂-礼仪广场）的坐标完全一致；`/api/votes` 返回 `tallies:{"162":{"up":1}}`、
+`verdicts` 4 条都对得上。新增 `TestVisitorVotesFollowPlaceAcrossDatasets`
+（换数据集票还在、从任一侧点两次都能撤掉同一张票）。
+
+### 验证
+
+- 开发库：迁移后行数不变（notes 14 / votes 3 / images 5）、无空键、无孤儿键、
+  `place_key` 与实际坐标 0 条不符；**重启两次主键稳定**（收敛）
+- 新增 `place_identity_test.go` 两例：**换数据集后备注与结论照旧跟在同一个地点**、
+  坐标差 0.1 度的地点**不会互相认领**
+- 全量复测（含 `TestExportRoundtrip` 与 `TestNativeSnapshotRoundtrip`）见当次结果
+
+## 合并的删除（上一轮）
+
+「仅站内有」的记录**默认一条都不删**，要清的逐条勾「合并时删除」（`dv_<src_pk>` / `dp_<src_pk>` / `da_<src_pk>`）。
+键用 `src_pk` 而不是 UUID —— 站点补录的行压根没有 UUID。
+
+**顺序：到访 → 活动 → 地点**，删到访时连 `movements`、`entity_raw` 一起清、`weather.visit_src` 置空（与站点
+`editVisitDelete` 一致）。**名下有到访的地点直接拒绝**（外键是 `ON DELETE CASCADE`，真删会带走到访），
+拒绝后整体回滚。
+
+**测试**：`TestBackupMergeDeletesOnlyChecked`（勾一条只删一条、没勾的不动、留档一起清、再合并不勾仍不删）
++ `TestBackupMergeRefusesDeletingPlaceInUse`（空地点可删、有到访的地点被拒且数据不变）。
+**变异验证**：把「有到访就拒绝」改成 `n > 100000`，测试当场失败。
+
+页面实测：45 个 `dv_` 勾选框**默认全未勾**、12 个冲突 radio、`add_new` 默认勾选；
+那两个「仅站内有」的地点因为 `visit_count > 0`，按设计不给删除框（显示「还有到访，不能删」）。
+
+**踩的坑**：`TestBackupDiffIdentical` 一开始断言整页含「完全一致」四个字——结果被**说明文字里的
+「UUID 完全一致」**命中，成了假阳性；且断言整页 `data-label="冲突">0</td>` 会被地点行张冠李戴。
+改用 `visitCounts()` 正则取「到访」那一行。另外「上传同一份备份」在地点层面**本来就有差异**
+（导入后反查补全改过名称/地址），所以不能拿整页 Identical 当断言。
+
+## 差异地图（用户要求「差异部分在地图上展示」）
+
+新增 `internal/fog/render_diff.go`：`RenderDiffTile(cur, inc, z, x, y, crs)` 出三色瓦片
+（绿=叠加会新增 `{36,164,90}`、灰=两边都有 `{126,134,146}`、红=替换会丢 `{214,56,56}`）。
+**精度分两级**：z≥14（scale≥1）逐格精确；更粗的级别下一个块还不到一像素，按块内多数类整块涂
+（`dominantKind`，绘制顺序 both→gain→lost，让绿/红压住灰）。不做描边（三色已够，粗级别会糊）。
+
+`internal/web/fog_diff.go`：瓦片端点 + 两边块集的单槽缓存（按 token，TTL 10 分钟，
+否则每张瓦片都要重解一遍 680KB 的 .fwss）。`diffBounds` 算两边包围盒给前端 `fitBounds`
+（按底图 crs 换算，否则视野偏几百米）。
+
+**踩的坑（值得记）**：第一次 CDP 测出 `container=NO`、`diffTiles=0` 且**控制台零报错** ——
+原因是页面没设 `p.HasMap=true`，layout 因此不引 Leaflet，而脚本里 `if(!window.L) return`
+静默退出。记忆里本来就写着这条，还是漏了。判据要认 `leaflet-container` 类，不能只看有没有报错。
+
+真实数据验证（0914 快照 vs 开发库）：`container=ok diffTiles=15 ok=15 bad=0`，
+三色像素 **gain=0 / lost=557 / both=2473** —— 绿色为 0 与页面上「叠加 +0」完全自洽。
+390/1440 均无横向溢出（地图 324/1042 宽，高 400）。
+
+测试：`render_diff_test.go`（逐格三色、单边整块、粗级别多数类、边界、dominantKind、计数）
++ `fog_preview_test.go` 的 `TestFogDiffTileColors`（端点颜色语义 + 越界/无效令牌 404；
+第一版用例把 `(0,0)` 当越界，被测试自己纠正成 `x=262144`）。**变异验证**：把 `cellKind` 的
+gain/lost 反过来，fog 与 web 两层测试同时失败。
+
+### 后台服务任务的假失败（12:44）
+`bin/rond.exe` 的后台任务报 failed，查下来是**重复启动**撞端口：旧实例还占着 8080，新进程只打一行
+「bind: Only one usage」就退出（日志写进的是*新进程*那个文件，真正在服务的实例日志在
+`storage/_rond_new.log`）。判据：用唯一 URL（`/probe-<pid>-<rand>`）打一下，看**哪个日志文件**出现这条记录，
+那个文件对应的才是活着的实例。别急着重编——先看日志确认是不是 bind 冲突。
+本次实例是 12:44:09 起的、一直在正常服务（各页 200），templates/CSS 在 debug=true 下热加载，不受影响。
+
+## 地点补全（本轮）
+
+用户要的：新增/活动和类别为空的地点，**根据地名自动判断填充**；匹配不上就新增或手工填。
+
+摸底：dataset 9 有 368 个地点，**217 个没类别**、**52 个完全没活动**（71 条到访无活动）、41 个零到访空地点。
+`poi_category` 存的是 **Apple MapKit 枚举**（真机用过 12 种），不是高德分类 —— 补的时候必须写这种形状。
+
+实现：`fillup.go`（页面/列表/写入）+ `fillup_rules.go`（词表与映射）+ `fillup.html`。
+三层判断：本地词表 → 高德周边搜索（按坐标，比按名字准）→ 人工。**只填空**，活动**按地点批量**设。
+
+### 撞出来的三件事
+
+1. **规则匹配要先掐括号、再按词长优先**：否则「尚优居客栈(大理古城步行街店)」命中「步行街」、
+   「马鞍山公园」命中「山」。
+2. **单字关键词必须删掉**：「独山路28-17号」被猜成「山」——误命中率太高，这类交给高德更稳。
+3. **页面一度 927KB**：每行两个 30+ 选项的 `<select>`，218 行就是 13000 个 option。
+   改成 `input + datalist` 后降到 169KB。
+
+### 验证
+
+真实数据跑十批高德：218 个待补里 **71 个拿到建议**（活动 25、类别 47），
+其中词表 10 个、其余来自高德。剩下的高德查过但类型映射不上（邮局、公司、地名地址这类），
+缓存记下不再重试，所以批次跑几轮就收敛。
+
+测试：`fillup_rules_test.go`（用真实地名做用例）+ `fillup_test.go`
+（按地点批量设活动 / **已有值不被覆盖** / 填陌生名字自动建活动类型）。
+**变异验证**：去掉 `AND activity_id IS NULL`，`TestFillupNeverOverwrites` 当场失败。
+完整验收（含导出往返）全绿。
+
+### 补：高德参考列 + 类别安全标注
+
+没映射出建议的行原先一片空白，但高德其实已经说了「这里是什么」。多了一列「高德参考」
+（POI 名 + 类型原文），「中国邮政 / 生活服务;邮局」这种一眼就能判断该填什么。
+类别下拉加了中文标签，并标出哪 12 种是**真机确实用过**的。
+
+**顺带实测回答了一个重要问题**：`poi_category` 改动后导出的 rondbackup 还能不能导回 rond ——
+**能**。用 `exportprobe` 导一份再读 `ZLOCATION.ZCATEGORY_`，值与真机备份**同格式**
+（都是 `MKPOICategoryXxx` 字符串）。当时还写了「**真机自己也会写中文类别**」——
+**⚠️ 这条 2026-09-20 已证伪，见下面那次的更正：真机从没写过非枚举值。**
+
+### 补：下拉改回 select
+
+`input + datalist` 只在下拉展开时显示 label，**框里永远显示 value**
+（`MKPOICategoryPark` 这种枚举名），站长看不懂。改成 `<select>` 后选中项直接是中文。
+页面原始 940KB、**gzip 后 22KB**（选项高度重复），体积不是问题，不必再为它绕路。
+
+`datalist` 这个坑值得记：**要用它就得接受「框里显示 value」**，想显示中文只能用 select。
+
+## 全量回归（今天所有改动 + 原有功能）
+
+三层都跑了，**没发现回归，也没改任何代码**。
+
+**1. 代码层** `go test ./...`（带齐 ROND_TEST_CONF / ROND_SRC / ROND_EXPORT / ROND_DSN / FOG_SRC）：
+所有包 ok、零 FAIL。关键细节：fwss 往返核对 8701 块 / 106 个其它层条目；
+rondbackup 往返逐项一致（visits 823 / places 323 / tags 8 / acts 30 / moves 791 / weather 557 / rawvisits 2246），
+**坐标偏差 0.000000000、时间偏差 0s**；`tb_stack_test` 检查了 12 张表；访客页面 6 个子测试全过。
+
+**2. HTTP 层**（curl 全站扫）：站长 18 页全 200；访客 9 页全 200；
+访客访问 /admin/* 四个都 303 跳登录（权限边界正常）；API 五支全 200 且都有数据
+（points 64KB / track 108KB / cities / votes / map-config）；导出四支全 200
+（geojson 108KB / gpx 62KB / rondbackup 2.9MB / fwss 693KB）；迷雾瓦片三档全 200 且访客也能取。
+新增的三个页面（迷雾差异 / 备份差异 / 地点补全）也各 200，备份差异页数字与之前一致（49/45/0）。
+
+**3. 渲染层**（CDP，390 宽）：`run_all.py` 扫的 14 个页面**横向溢出全部为 0**；
+新增三页 × 两种视口也是溢出 0、零 JS 报错。
+
+**两个改进点**（不是 bug）：
+- `/admin/fillup` 在 390 下页高 54870px —— 218 行堆叠确实很长，**该加分页**（每页 30 行）。
+- `/stats` 小字 40、`/map` iOS 自放大 1，都是**既有**的（技能笔记里就记着），与本次改动无关。
+
+### 补：补全页分页
+
+每页 30 行。390 宽下页高 **54870 → 8126**。页码夹紧（`?page=999` 停在末页、解析不出来回第一页），
+提交后留在同一页；翻页前若有改过还没提交的下拉会先 confirm（预选的建议不算改过，靠记录初始值判断）。
+测试：`TestClampPage`（8 个边界）+ `TestFillupPagination`（造 35 个地点验两页与越界）。
+**变异验证**：去掉夹紧逻辑，两个测试同时失败。
+
+### ⚠️ 测试基础设施的已知脆弱点（不是代码 bug）
+
+`go test ./...`（默认并行跑包）时 `internal/stats` 偶发 SKIP —— 它的 `setup` 读**全局**的
+`datasets WHERE is_active LIMIT 1`，而 `internal/web` 的 fixture 会在导入期间**临时把 is_active
+指向自己的数据集**、cleanup 时再删掉。两者撞上就是「没有生效数据集」或「找不到可用省份」而 skip。
+
+**单独跑 stats 包 5 个测试全过**，`-p 1` 串行跑也不会有这问题。
+以后做「完整验收」建议用 `go test -p 1`，或者把 stats 测试也改成自带数据集。
+
+### 补：修 UI 回归（用户报的）
+
+用户报「活动和类别变得无法手工填写」+「选不动后点用高德分析就锁死了」。根因都是我上一版改 select 引入的：
+
+1. **纯 select 把手工填写的路堵死了** —— 活动改回可输入的 input（活动名本来就是中文，没有显示问题）；
+   类别保留 select 但末尾加「其它（自己写）…」，选中露出文本框（后端认 `cat_<id>__custom`）。
+   （当时以为「真机自己也存中文类别」所以让用户随便写中文 —— **那条判断是错的，见 2026-09-20 的更正**：
+   真机只写过 `MKPOICategoryXxx`，中文全是站内自己写进去的。）
+2. **建议被强制预选 ⇒ 用户表达不了「不动」** —— 而且点「用高德分析」会整页重载，
+   刚选的全丢，看起来就像锁死。改成**默认什么都不选**，批量采纳走「采纳本页建议」按钮；
+   分析前把本页填过的存进 sessionStorage，回来恢复，提交时清掉。
+
+**教训**：`select` 只适合「选项可穷举」的字段。活动是用户可自由新增的，就绝不能做成纯下拉。
+
+顺带被测试抓到一次：分页测试数 `name="cat_` 时把新加的 `cat_X__custom` 也算进去了（30 行变 60），
+口径改成数 `<select name="cat_`。
+
+### 补：活动与类别统一样式（用户报的）
+
+用户说「类别和活动的选择样式好像不一样」。上一版我为了恢复手工填写，把活动做成 input+datalist、
+类别做成 select+「其它」，同一行两个格子长得不一样。
+
+现在活动也改成 select + 「其它（自己写）…」+ 文本框，与类别完全同款：
+- 模板两处结构一字不差，只换 `act_`/`cat_` 前缀；CSS 类合并成 `fill-sel`（原 `cat-sel` 全部替换）
+- 后端 `act_<id>` 读到 `__custom__` 就读 `act_<id>__custom`
+- 删掉 `datalist#fill-act`；「采纳本页建议」与草稿存取改走 `select.fill-sel` 一次遍历
+- 草稿恢复对 SELECT 派发 `change` ⇒ 「其它」文本框能跟着恢复显示（否则值在、框被隐藏）
+
+实测（CDP）：390 宽下两者完全一致 229×37；1440 宽下同字号/内边距/边框，宽度由内容撑开略有差。
+**新增两个测试**：`TestFillupCustomActivity`（写文本框里的名字）、`TestFillupCustomActivityEmptyIsSkipped`（空名不建类型）。
+
+**验收插曲**：第一次串行跑出现 `--- SKIP: TestMovementCleanExport` —— 不是回归，是我把
+`ROND_CLEAN_OUT` 只写在第一条命令的前缀里（前缀 env 只作用于那一条），整链跑时没导出。
+改成 `export` 全部环境变量后重跑：12 个包全 ok，零 FAIL 零 SKIP。**教训：验收链要用 `export`，
+不要用命令前缀**，否则导出验收会在完整跑里静默跳过、看着像全绿其实没跑。
+提交 `bf23fc6`。

.workbuddy/memory/2026-09-20.md

@@ -0,0 +1,253 @@
+# 2026-09-20
+
+### 补全页：手工填过的值自动进下拉候选
+
+用户报「手工填了之前没有的活动/类别，后面同类地点还得再手工打一遍，效率低」。
+根因：下拉候选是**页面渲染时定好的**（活动来自 `activities` 表、类别来自静态表），
+本页新填的值在提交前进不了候选。
+
+做法（全部在 `templates/admin/fillup.html` 的脚本里，后端没动）：
+- `sessionStorage['rond-fillup-newopts']` 存 `{act:[],cat:[]}`；本页文本框里的值 + 从别处带来的值，
+  一起补进同类下拉，插在**建议之后、真候选之前**（不沉到列表最底下），标成「新填：X」，带 `data-local` 标记
+- 本页打字即生效；翻页/「用高德分析」重载也留得住（重载时读回来重新 paint）；提交成功后清掉
+- 先 paint 再恢复草稿：草稿里选中的可能就是新填的值，选项不在跟前 `select.value` 设不进去
+- 草稿保存改成**按 name 合并**（`delete` 掉本页明确清空那些），翻页不再覆盖上一页；分页链接也接了保存
+- **重画候选前要留住「这一格已选中的新填值」再还回去**，否则改一下文本框会把别的行选好的值抹成空
+
+**两个坑**：
+1. 文本框监听**不能委托到 `document`**：`new Event('input')` 默认**不冒泡**，探针第一次就是这么假绿的。
+   直接 `box.addEventListener` 更稳，也少一层隐式约定。（用户真实打字是冒泡的，但别赌这个）
+2. 验收时我用了**新的** `ROND_CLEAN_OUT` 文件名，`-p 1` 下 `internal/rond` 按字母序**排在 `internal/web` 之前**，
+   导出文件还没生成 → `TestExportRoundtrip` 等 4 个测试全红。**这是假警报**，
+   先跑 web 的 `TestMovementCleanExport` 生成文件、或沿用上次的文件名即可。
+提交 `ffee082`。
+
+### 数据编辑页加「活动与类别」卡片
+
+用户要求「在数据编辑页添加一个模块，对活动和类别进行更改、删除和新增」。先摸清现状：
+
+- **活动**：`activities` 表，31 条。后端 create/update/delete **三个端点早就有**，
+  但 UI 只藏在「到访记录」卡片里——要先在下拉选中某个活动，再点按钮弹 `prompt/confirm`，
+  入口隐蔽、也看不见「哪些活动一条到访都没挂」（实测有「学习」0 条）。
+- **类别**：**根本没有表**，就是 `places.poi_category`。16 种值在用（12 个 MapKit 枚举 + 4 个中文）。
+  候选来源还两套：编辑页/照片页读 `DISTINCT`（只有用过的才出现），补全页读静态表 `fillupCategories()`。
+  → 库里真在用的中文类别（一般道路/彩票店/租车点/美食街）在补全页下拉里选不到。这是**已存在的 bug**，记下了。
+
+**用户拍板的选择**（问过才动手）：类别**不加字典表**、不预置空字典项，只做批量改名/合并/清空；
+活动**要合并**。
+
+实现：
+- 新端点 `category/rename`（改成已有值就是合并，同一条 UPDATE）、`category/clear`（写 NULL）、
+  `activity/merge`（事务内把到访转过去 + 抄目标活动的 `is_home/is_work` + 删源活动 + `pruneEntityRaw`）
+- `EditData` 加 `ActivityRows`/`CategoryRows`；编辑页原来那条 `DISTINCT poi_category` 查询
+  顺手改成 `GROUP BY` 带计数（一份数据两用，不额外查）
+- 卡片 `data-card="taxonomy"` 放页首，是**唯一默认展开**的卡片（脚本里给 `taxonomy` 开了小灶）
+
+**自己踩的坑（值得记）**：表我写成 `class="tb-stack"`，漏了配对的 `tb`。
+CSS 全是 `.tw > table.tb.tb-stack …`，结果一条堆叠规则都没命中，390 宽下表还是 640px 底宽——
+**而且守卫测试没拦住**（它只查 `tb-stack` 在不在），页面也不横滑（横滑在 `.tw` 里滚），
+是探针量到「表宽 560 > 卡片宽 362」才发现的。已给 `wide_table_layout_test.go` 补上
+「有 tb-stack 必须有 tb」的判据，并做了变异验证（去掉 tb → 守卫报错）。
+另外宽度**别用行内 min-width** 写死，堆叠态的 `min-width:0` 会被 inline 压过去。
+
+实测（CDP，全程拦截 fetch 保证不动真实数据）：默认展开、31 活动/16 类别行、「家」引用 250、
+改名没变→只提示不请求、删除确认带条数、清空确认、合并同一个→拒绝、合并确认带两个名字和条数、0 次请求。
+
+### 补：补全页的类别候选取「在用的 ∪ 静态表」
+
+上一轮记下的「两页候选不一致」用户决定修掉（原话：不然使用时会有异常）。
+
+改动只在 `internal/web/fillup.go`：
+- 新增 `(*Server).usedCategories(ctx, dsID)`：`SELECT poi_category, count(*) … GROUP BY 1 ORDER BY 2 DESC, 1`
+- `fillupCategories(inUse []fillupCategory)` 现在三段拼：**在用的**（按地点数降序，标签 `中文名（在用 N）`）
+  → 真机用过的 12 种（`（真机用过）`）→ 其余常见 MapKit 类别。用 `push` + `seen` 去重，
+  **同一个值只出现一次**，在用的那份信息更准、顶掉静态说明。
+- 标签统一走 `poiCategoryLabel`（MKPOICategoryX→中文；未知枚举去掉前缀；中文值原样返回）。
+
+**实测真实数据**：36 项 = 16 在用 + 18 未用过的静态 +（不动）+（其它「自己写」），零重复。
+前几项：餐厅（在用 51）/ 商店（在用 29）/ 公共交通（在用 22）/ 酒店（在用 14）/ 地标（在用 10）/
+**一般道路（在用 5）**/ 菜市场（在用 4）…；这个数据集里静态表的 12 种恰好全都在用，所以「真机用过」组为空。
+
+写测试时踩了两次自己的口径错误（都不是产品的错）：
+1. 数「值出现几次」时把整页数了——**下拉每行渲染一份**，30 行就是 30 次。改成先截出第一个 `<select>…</select>` 再数。
+2. 断言「餐厅（在用 1）」——**夹具导的是真实备份**，那类别本来就有 51 个地点在用。改成只断言 `value="X">中文（在用 ` 前缀，不钉数字。
+
+### ⚠️ 更正一条错误结论：真机**从没**写过非枚举的类别值
+
+用户问「类别这里部分显示中文、部分显示 MKPOICategoryBeach，直接改会有影响吗」，
+顺手把数据核了一遍，结果**推翻了我 2026-09-19 的判断**（那条写在 `knownMKCategories` 附近：
+「真机自己也会写中文类别（一般道路/彩票店/美食街/租车点）⇒ 这列本来就是自由文本」）。
+我从「库里看到中文值」直接推成了「真机写的」，**没查这些值到底是谁写进去的**。
+
+实测（活跃数据集）：
+
+```sql
+-- 真机留档里的 ZCATEGORY_ 分布
+SELECT COALESCE(NULLIF(r.raw->>'ZCATEGORY_',''),'--empty--'), count(*)
+  FROM entity_raw r WHERE r.dataset_id=… AND r.entity='ZLOCATION' GROUP BY 1;
+--  →  201 空 + 12 种 MKPOICategoryXxx，非枚举值 **0 条**
+-- 站内值与留档不一致的地点：**只有 2 个**（公园 1 + 美食街 1）
+-- 4 个中文类别全部落在「真机本来就没给类别」的地点上（留档为空，或那行站内新建、根本没有留档）
+```
+
+⇒ **结论**：`ZCATEGORY_` 在真机那边就是 MapKit 枚举串；中文值是**站内**（补全页手填 / 高德建议 / 自定义）写进去的。
+当时我还把这句错误结论当成依据安抚用户「写中文完全安全」，**这句得撤回**：
+写中文不会坏数据（导出侧不校验、站内显示原样），但 **app 那边很可能显示不出类别**，
+而且我们**没有任何实测样本**能保证 app 怎么处理未知值 —— 只能说「不损坏」。
+
+**教训**：看到「库里某个值不符合预期形状」时，先分成「谁写的」——查 `entity_raw` 里的留档
+（站内新建的行**没有留档**，`raw IS NULL` 就是最强指纹），别把「站内写进去的」当成「真机的行为」。
+
+### 类别「显示名」可维护（枚举 ↔ 中文对照）
+
+用户：「MKPOICategoryBeach 下边标注海滩，我希望能够改，一一对应的或者现在没有对应值的让我来填写补充」。
+根因：中文名是 **Go 里硬编码的两张 map**，用户根本改不了；而且两张表还对不上。
+
+**先合并两套中文名**（这次的关键清理）：
+- `view.go` 的 `poiNames`（38 条，给补全页静态项 + GPX）与 `handlers_edit.go` 的 `poiCategoryText`（33 条，给编辑页）
+  **冲突 3 处**：FoodMarket 菜市场/食品市场、Cafe 咖啡馆/咖啡厅、FitnessCenter 健身房/健身中心；
+  还有 `ATM`/`Atm` 大小写各写一份、一条永远匹配不上的死条目 `MKPOICategoryMarina2`。
+- 合并成 `poiCategoryText` 一张（42 条，冲突处取编辑页那套），删掉 `poiNames`/`poiName`。
+- **连带清掉两个模板函数** `catName` / `poiname`（它们绑在旧函数上）。模板里算不出显示名（要读站点覆盖），
+  所以改成在 Go 侧算好塞进数据：`FillupRow.CatLabel`、`PlaceData.CategoryLabel`。
+
+**新增可维护层**：
+- 表 `category_labels(value PK, label)`，**站点级、不挂 dataset_id**（值本身是稳定键）。
+  内置表降级为「默认值」，`categoryLabel(v, custom)` 的兜底顺序：自定义 > 内置 > 去掉前缀的原值。
+- 端点 `POST /admin/edit/category/label`；**传空 label = 删除覆盖行、恢复默认**（UPSERT/ DELETE 两条路）。
+- 类别台账那行改成两个带前缀标签的输入框：`导出值`（会写回手机）+ `显示名`（只影响显示），
+  外加「保存显示名」按钮；`Missing`（是 MKPOICategory* 但内置表没有）提示「填一个中文名」。
+  placeholder 分两种：缺名 →「填一个中文名」；否则「留空＝默认「X」」。
+
+**必须记住的不变量**：显示名**绝不写进 `places.poi_category`**——那是导出回手机的值，
+中文跟着写进去就污染数据了。测试 `TestCategoryLabelNeverTouchesValue` 专门钉这一条。
+
+实测：类别行「导出值=MKPOICategoryBeach / 显示名=空 / placeholder=留空＝默认「海滩」」，
+点保存发出 `value=MKPOICategoryBeach&label=海边`；390 宽卡内无溢出；访客地点页副标题照常显示「海滩」。
+
+### 修：「填了显示名却还说没有中文名」+ 枚举拼错拦一道
+
+用户报：原来「租车」那行，把导出值改成 `MKPOICategoryCarRent`、再手工添了显示名「租车」，
+保存后页面仍显示「还没有中文名」。
+
+**根因 1（真 bug）**：`Missing` 判定只看内置表（`categoryLabelMissing(v)`），
+**没看有没有自定义覆盖** ⇒ 填过了还照样提示。改成 `categoryLabelMissing(c) && catNames[c] == ""`。
+补了回归测试 `TestCategoryLabelMissingRespectsOverride`，并做了变异验证（去掉那半个条件 → 测试报错）。
+
+**根因 2（用户真正踩的坑）**：`MKPOICategoryCarRent` **不是真机的枚举**，正确是 `MKPOICategoryCarRental`
+（少了个 `al`）。站内看不出任何异常，但导回手机后那个地点显示不出类别——正是上一轮提醒过的风险。
+
+**加的一道防线**：编辑页把内置枚举名渲染成 JS 数组 `KNOWN`，`okEnum(v)` 在**写 poi_category 的两个入口**
+（类别台账的「改名」按钮、地点行内编辑的「自定义类别」提交）都拦一下：
+不在 KNOWN 里就 confirm，还能猜「你是不是想写 MKPOICategoryCarRental」（双向前缀匹配）。
+中文值不拦（不是枚举），已知枚举不拦（返回 true 不打扰）。
+实测：普通提交/自定义中文/已知枚举都不拦，拼错的才拦。
+
+**数据现状（用户的数据，等他们决定）**：地点 id=2290 `大理星羽阁精品民宿(古城店)`
+（原来是「租车点」）的类别现在是 `MKPOICategoryCarRent`；还有一条孤儿覆盖行
+`category_labels.MKPOICategoryCarRent → 租车`。正确做法是把导出值改成 `MKPOICategoryCarRental`
+（内置名就是「租车」，覆盖行随即可删）。
+
+### ⚠️ 教训：用脚本改模板时 `\n` 会被多转义一层
+
+我通过 `Bash` + Python heredoc 往 `edit.html` 写 JS 时，写的是 `'\n\n你去…'`，
+结果落到文件里变成**真换行** ⇒ JS 单引号字符串含裸换行 ⇒ **整块 `<script>` 语法错误**，
+页面上所有交互静默失效。而 `TestPageTemplatesParse` 照样通过（模板语法本身没问题），
+`present_files`/构建也不报错——只有 CDP 探针的「JS 报错」和实际点不动才发现。
+
+三条处置：
+1. **改含转义的文本一律用 Edit 工具**（它按字面写入），或 Python 里用 `chr(92)+'n'` 显式拼；
+2. 新增守卫测试 `inline_script_test.go`：扫模板里所有内联 `<script>`，**发现字符串跨行就报错**
+   （带文件名+行号）。跳过注释/模板串/`{{…}}`。已做变异验证（放一个坏样本 → 精准报错）。现在扫 31 个脚本块。
+3. **改完模板必须用 CDP 看「JS 报错」是否为空**——这条已在技能里，但这次才是它真正救命的场景。
+
+### 排查「导出包导不回 rond」
+
+用户给了一个从**生产环境**导出的包（`data/20260914_151649-export-20260916(1)-export-20260917-export-20260920.rondbackup`）
+导回手机失败，要我和真机原版 `data/20260914_151649.rondbackup` 对比。
+
+**排查方法（可复用）**：先跑现成工具，再补三项工具没覆盖的检查。
+1. `tools/verify_export_structure.py rondbackup <原版> <导出>` → 表/索引/CREATE TABLE 逐字符、
+   `integrity_check`、`foreign_key_check`、关键不变量、派生列重算 —— **结构一致性：通过**。
+2. `tools/verify_rondbackup.py` 逐字段比对 → 差异全部能解释成「用户在站点上的编辑」（改名/新增/删除/设类别）。
+3. 工具没覆盖、我补查的：
+   - **NOT NULL 违例**（`integrity_check` 和 `foreign_key_check` 都不查这个！真出的话 Core Data 打不开）
+   - `Z_METADATA.Z_PLIST` / `Z_UUID` / `Z_MODELCACHE.Z_CONTENT` 的**字节哈希**（技能只要求「相等」，工具只比了行数）
+   - `Z_PRIMARYKEY.Z_MAX` vs 各表实际 `MAX(Z_PK)`
+   - **所有列**逐值比对（不只技能清单里那几列）→ 只暴露出时间戳最后一位差 ~0.1µs，
+     是 PG `timestamptz` 只有微秒精度造成的，在技能认可的 ≤1ms 容差内，**不是 bug**
+   - 确定性：同数据导两次，`sha256` 完全相同 ✓
+   - zip 条目顺序（我们 `sqlite,wal,shm` vs 真机 `sqlite,shm,wal`，都是 Store 不压缩）
+   - `ACHANGE`(4810) 内容、`ZRAWVISIT` 抽样、78 个 sqlite 对象（含 sqlite_ 内部）── 全一致
+
+**找到的唯一实质缺陷**：新建的交通方式「步行」导成 `ZTRANSPORT.ZCOLOR_=NULL / ZICON_=NULL`，
+而真机原有 5 条**全部**有值（`cyan`/`cablecar.fill` …）。真机这两列**从不写 NULL、也不写空串**。
+成因链：站点不单独维护交通方式表（颜色/图标是从 `movements` 上聚合的）→ 建方式时没选就是空
+→ `queryTransports` 的 `FILTER (WHERE ... IS NOT NULL)` 聚成 NULL → `ns()` 把空串/NULL 都变 nil → 写进包里是 NULL。
+
+**修法**（`internal/rond/export.go`）：**只对新建的行**（`!known["ZTRANSPORT"][src]`）补占位
+`gray` / `circle.fill`；**基线已有的行不碰**——那种情况 `keepNilCols["ZTRANSPORT"]` 会保留真机原值，
+擅自补占位反而会把真机的真值盖掉。与「新建活动补 `blue`/`📍`」同一套做法。
+
+**新增通用守卫** `internal/web/export_placeholder_test.go`：判据是
+「**基线里 100% 有值的列，导出里的新行也不许为空**」——对所有托管表逐列扫。
+这才是这类问题的根治办法（单点修 ZTRANSPORT 只是治标）。已做变异验证（关掉修复 → 精准报错）。
+
+**没法部署时的临时办法**：在编辑页把用了「步行」的**任意一条行程**的方式颜色/图标补上保存
+（`editMovementUpdate` 只改那一条，但聚合取「最新一条非空的」），再重新导出，`ZCOLOR_/ZICON_` 就有值了。
+
+### 真机报「备份恢复失败，你的当前数据未被更改」→ 找到悬空关系
+
+用户重试仍失败，真机只给一句「错误，备份恢复失败，你的当前数据未被更改」。
+「当前数据未被更改」说明它是**先校验、整体回滚**，即在校验阶段被拒。
+
+**关键醒悟**：**Core Data 的 SQLite 表里没有真正的外键约束**（关系由 Core Data 自己维护），
+所以之前跑的 `PRAGMA foreign_key_check` 报 0 违例**毫无意义** —— 它压根没有可检查的约束。
+必须自己按「关系列 → 目标表 Z_PK」手查悬空引用。
+
+手查结果（8 组关系列全扫）：
+
+```
+原版：悬空引用 0
+导出：⚠️ ZRAWVISIT.ZVISIT → ZVISIT 悬空 2 条   (2051→到访46, 465→到访200)
+```
+
+正是用户在站点上删掉的那两条到访（46、200）：`ZRAWVISIT`（原始 GPS 采样点）是**不托管实体**、
+导出原样保留，删到访后就留下了指向已删记录的悬空引用。原版 0 条，且真机删到访时采样点跟着**级联删**。
+
+**修法**（`internal/rond/export.go`，`visit.finish()` 之后）：删掉 `ZVISIT` 指向不存在到访的
+`ZRAWVISIT` 行。选「删」而不是「置空 ZVISIT」的理由：真机「未归并采样点」虽有 1461/2246 条（置空合法），
+但**留成未归并会让 app 重新推出一条到访、把用户删掉的记录复活**。
+
+**顺手加固**：
+- `tools/verify_export_structure.py` 新增 1.45 节「关系完整性」手查悬空（8 组关系列），
+  有悬空就把结论标成「有差异」——`foreign_key_check` 那条查不出来的坑，从此进标准验收清单。
+- `internal/web/export_placeholder_test.go` 加 `TestExportDropsOrphanedRawVisits`：
+  删一条带采样点的到访 → 导出 → 断言没有悬空。已做变异验证。
+
+**为了让用户在部署前就能验证**，直接对那个失败包做了两份修复包（`data/` 下）：
+A = 只修数据（保持原条目顺序）；B = 修数据 + 条目顺序对齐真机（sqlite, shm, wal）。
+两份都复核过：结构逐字符一致、悬空 0、交通方式空值 0、采样点 2246→2244。
+
+### ✅ 结案：A 包导入成功，根因确认是悬空引用
+
+用户实测 `data/20260920-fixed-A-数据修复.rondbackup` **能正常导入**。
+
+- A 包 = 你那个失败包 + 清 2 条悬空采样点 + 补交通方式颜色/图标，**zip 条目顺序保持原样**
+  ⇒ **条目顺序不影响真机导入**（B 包不用试了，可以删）
+- ⇒ 根因就是**悬空关系引用**（`ZRAWVISIT.ZVISIT` 指向已删到访）被真机的校验拒掉
+- A 里同时含「交通方式补颜色/图标」，所以严格说没单独隔离出它的影响；但悬空是**关系完整性**问题，
+  正是 Core Data 校验的对象，主因没有疑问。**不再让用户复做归因实验**（价值低、还要覆盖手机数据）
+
+**今天的两个修复都在代码里了**：`56c7283`（新建行不留 NULL）、`78865fc`（清悬空采样点）。
+**但都还没 push、没部署** —— 生产站点的导出包仍然会带悬空引用，除非部署后重导。
+
+### 技能 `rond-backup-parse` 的四处修正（今天的实测推翻了里面的旧断言）
+
+1. 保真度清单**补上「关系完整性」**（手查悬空，必须 0）并加了专节；
+2. 明确警告 **`foreign_key_check` 在这个库里永远报 0**（Core Data 没有外键约束）——
+   旧版把它列进了必查项，等于给了个假的通行证；`integrity_check` 也不查 NOT NULL；
+3. 旧的「时间往返**零差异**，出现 1µs 偏差就是精度写法有问题」**是错的**：
+   实测 ~625 条到访带 0.1µs 偏差（PG `timestamptz` 只有微秒精度），**而这样的包能导入**。
+   改成「秒级零差异 + 说明 µs 偏差的成因，别去修」；
+4. 「新建行」那条补上机械判据：**基线里一条空值都没有的列，新行也不许留空**。

.workbuddy/memory/2026-09-21.md

@@ -0,0 +1,373 @@
+# 2026-09-21
+
+## 记忆维护
+
+- `MEMORY.md` 超限（25KB）被注入截断 ⇒ 已收敛：把 details 未覆盖的新知识（跨备份 UUID、坐标键主键、合并执行、迷雾三段式、tb-stack、活动/类别、补全页交互、导出排除顺序）并入 `MEMORY-details.md`（新增第 19–27 节，36.7KB），`MEMORY.md` 重写为 ~6.5KB 索引（只留「违反了会静默出 bug」的判据）。
+
+## 全量排查（产出 `audit-2026-09-21.md`）
+
+范围：77 条路由 / 23 个页面集 / 96 个 Go 文件 / 24 模板 / 4 前端脚本 + app.css。方法：4 路只读深挖 + 关键结论回读复验 + 模板行为实测 + `go build`/`vet`/`test` 实跑。
+
+### 新确认的 P0（本次实测坐实）
+
+- **`internal/web/parallel.go:43-57` `runJobs` 子 goroutine 无 recover** ⇒ 任一 job panic **终止整个进程**（`server.go:317` 的 recover 只管请求 goroutine）。可用性最严重。
+- **`internal/auth/auth.go:199` `hash[:min(len(hash),16)]` 恒为常量**（`pbkdf2$sha256$21`）⇒ MAC 只绑 `uid|exp`，**改密码不失效旧会话**（注释声称相反）。`SignPending2FA` 同。
+
+### 新确认的 P1
+
+- `layout.html:215` `{{d .Dataset.Last}}`：`d` 收 `time.Time` 而 `.Last` 是 `*time.Time`。**实测**：非 nil 会被模板解一层指针、正常工作；**nil 时报错并截断输出**。`refreshDatasetAgg`（LEFT JOIN）在数据集零到访时写 NULL，编辑路径调用 9 次 ⇒ 可达。后果是 HTTP 200 + 页脚之后整段不渲染（含 Leaflet/脚本引入），服务端只有一行 log。
+- `server.go:447` `serverError` 回显 `err.Error()`，调用点含 `home`/`mapPage`/`placesPage`/`placePage`/`reportPage` 等**公开页**与公开 JSON 接口。
+- `stats.go:195` `movementsWhere` 比 `visitsWhere` 少了 City/Province/ActivityIDs/MinDwell/TagID/Keyword ⇒ 按这些维度筛选时「总里程/出行方式」仍是全量。
+- `rond-map.js` tooltip 未转义（382/772/818/836）而 popup 已 `esc()`（340-348）——同文件内不一致。
+- 多语句写操作未包事务：`handlers_edit.go:699/1235/1411/1332+1342/1832+1848`（建地点+建到访、合并两处反而是对的）。
+- 解压无上限：`rond/parse.go:201`、`fog/fog.go:134/199`（上传只限压缩后体积）。
+- `^-?[0-9.]+$` 不是浮点校验却紧跟 `::float8`：`handlers_edit.go:2315`（suspectWGS）、`coord.go:40`；`:187` 那处连正则都没有。
+- `main.go:50-52` 默认口令 `rond-admin`，登录只有一次性验证码、无失败限速。
+
+### 其他值得记的
+
+- **`go test ./...` 全绿是假信号**：本机 62 SKIP / 59 PASS（缺 5 个环境变量），`internal/web`/`rond`/`stats`/`fog` 的重用例全在 skip 里。
+- `html/index.html`（856 行）已不被服务（`go:embed` 与 routes 都无引用）。
+- ✅ 已核对**不是**问题：SQL 全参量化、`ORDER BY` 白名单、`serveMedia` 路径穿越、无 SSRF、验证码不可重放、无模板 XSS 与 405、26 张 tb-stack 表类名成对且 data-label 全齐。
+
+## 修复落地：第 1–4 批 + 途中新发现 1 个 panic
+
+**纪律**：每条都先做变异验证（先确认测试能变红，再还原确认变绿）。全量套件（含 `-p 1` 验收）0 失败。
+
+### 新增回归
+`web/tx_atomicity_test.go`、`web/server_error_test.go`、`web/map_escape_test.go`、`web/tb_static_test.go`、`rond/limit_test.go`、`fog/limit_test.go`、`auth/guard_test.go`、`web/login_guard_test.go`、`stats/placecols_test.go`、`web/topic_stats_test.go`、`fog/tilename_test.go`。
+
+### 性能 P1：placeCols 的相关子查询缺索引前导列（已实测）
+`idx_visits_place` 是 `(dataset_id, place_id)`，6 个子查询只写 `place_id=p.id` ⇒ 每轮为库里每个 dataset 各下一次索引。
+Index Searches 2371→366、Buffers 23737→5669、actual time 53.4ms→31.5ms。跨 dataset 的到访 0 条 ⇒ 该谓词语义冗余。
+
+### 性能 P2：专题列表 N+1 → 一条 UNION ALL
+新增 `fillTopicStatsBatch`（顺手发现「天数」查询与点位查询的到访集合完全相同，纯重复）；删掉 `fillTopicStats`，列表页与详情页共用 `topicAreaCond`。回归以详情页 `topicContent` 为预言机（3 轮 × 5 专题）。
+
+### 新发现 bug：`fog.tileName`/`tileIDFromName` 单数字编号越界 panic
+- 导出：`Encode` 里 `id := t[0]+t[1]*MapTiles`，第一列就是 0~9 ⇒ M2 尾缀循环起点 `len(s)-2 = -1` ⇒ `s[-1]` 越界。
+- 导入：长度守卫 `len(name)<7` **恰好放行**「4 位 md5 + 1 位掩码 + 2 位尾缀」的 7 字节名，md5 公开可算 ⇒ 构造 .fwss 上传即 panic（DoS）。
+- 修复：`tileDigits(id)` 不足两位补前导 0、编解码共用；守卫收紧到 `len(name)<8`。真机编号 ≥2 位 ⇒ 导出字节不变。
+
+### 两个踩过的坑（会静默浪费时间）
+- **`time.Time` 的 `==` 会连内部 `*Location` 指针一起比**：pgx 每次 Scan 都新建 Location ⇒ 「值相同」也判不等（366 行里假报 325 行差异）。比对数据库行一律 `json.Marshal` 后比字符串。
+- **静态 SQL 守卫必须按子查询分段**：`placeCols` 里 v2 出现 3 次，全文 `Contains` 会被另外两处顶包，变异跑不出红。要先按 `FROM visits (vN)` 的匹配位置切段再判。
+
+### 尚未处理
+P2 的 S1–S9 / D1–D8 / F4–F10、F14、F16–F18，性能 P3–P8。
+建议优先：S5（CSRF token / JSON 端点 Origin 校验）、S4（cookie 无 `Secure`）、S3（两处 `//evil.com` 协议相对跳转）、D2（`writeRawRow` 的 marshal 失败只 log ⇒ 留档静默丢失）、P4（导出整包进 buffer，受 `WriteTimeout 120s` 约束）。
+
+## 修复落地（第二批）：S3 / S4 / S5 / D2
+
+### S3 协议相对跳转 ✅
+同一份判据在仓库里有**三份实现**：`view.go` 的 `backFromRequest` 是加固过的正确版，
+`handlers_admin.go` 的 next 与 `handlers_vote.go` 的投票后跳转是**手写的弱化版**（只判 `HasPrefix(next, "/")`，放行 `//evil.com`）。
+⇒ 抽成纯函数 `safeInternalPath`，三处 + 登录跳转共用。回归：`redirect_target_test.go`
+（21 个拒绝样例 + 静态守卫 `TestNoWeakRedirectPrefixCheck`，守卫还自查扫到的文件数防假绿）。
+
+### S4 会话 cookie 补 Secure ✅
+**不能无条件打**：本机 http 调试与 CDP 验证流程都跑在 http，打了 Secure 谁都登不进去。
+按「本次请求是否 https」判断：`r.TLS != nil`，或 `X-Forwarded-Proto`（多段取首段）。`login` 签名多了 `*http.Request`。
+回归：`session_cookie_test.go` 五种来源 + 断言 HttpOnly/Path/SameSite 未被顺手改掉。
+
+### S5 CSRF 纵深防御 ✅
+先取证：**全部改状态的路由都是 POST**（没有 GET 改状态）✓，cookie 已是 `SameSite=Lax`（跨站 POST 本就带不上 cookie）。
+故定位为纵深防御。新增 `csrf.go` 的 `csrfOriginGuard`（只对 POST/PUT/PATCH/DELETE 生效）：
+有 `Origin` 必须本站（`null` 一律拒）→ 无则看 `Referer` → 都没有则放行（跨站 POST 浏览器必带 Origin）。
+**一行模板都不用改**。拒绝时日志带 Origin/Referer/Host，反代配错一眼可见。
+部署前提：反代要传原始 Host（或用 `X-Forwarded-Host` 兜底）。
+回归：`csrf_test.go`（14 例单元 + 走完整中间件链的接线测试）。变异两轮：①摘掉中间件（只有接线测试红）②判据恒真（都红）。
+
+### D2 留档静默丢失 ✅
+`writeRawRow` 的 `json.Marshal` 失败原来只 log 后 `return nil` ⇒ 调用方以为写成功、合并照常提交、原始列永久缺失。
+改为上抛由 `withTx` 整笔回滚。回归：`entity_raw_test.go` 用 `math.NaN()` 触发真实序列化失败，
+断言「必须报错 + 失败不留半截行 + 正常值仍写得进去」（第三条防断言假绿）。
+
+### 下一批建议
+🔴 **S1**（`fogResetIndex()` 无锁写，全报告唯一真 data race）、🔴 **S7**（TOTP 不消耗验证码 + `login2FA` 无限速，`auth.Guard` 现成可复用）、
+🟠 **S2**（图片上传缺 `MaxBytesReader`，一行改动）、🟠 **D3**（`parse.go` 不查 `rows.Err()`）、🟠 **P4**（导出整包 buffer + WriteTimeout）。
+
+
+
+---
+
+# 第三批（S1 / S7 / S2 / D3 / P4）✅
+
+### 先说两个会让验证白跑的坑
+1. **`-race` 需要 cgo + C 编译器**，本机原本没有 gcc（`go env CC` 写着 gcc 但 PATH 里没有）。
+   解法：`scoop install mingw`（装到 `~/scoop/apps/mingw/current/bin`），
+   跑法：`export PATH="$HOME/scoop/apps/mingw/current/bin:$PATH"; CGO_ENABLED=1 go test -race ...`。
+2. **用 `newMovementFixture` 的新测试会静默 SKIP**（它同时要 `ROND_TEST_CONF` 与 `ROND_SRC`）。
+   只带 `ROND_TEST_CONF` 时结果是 `ok`，看起来全绿其实一条没跑——这轮就这样骗过了一次变异验证
+   （变异后仍「通过」，一打印 body 才发现根本没进函数）。**验收一律用 `-v` 数 SKIP，别只看 ok。**
+
+### S1 迷雾索引 data race ✅
+`fogIndexV` 普通指针 → `atomic.Pointer[fog.Index]`（`Load`/`Store`）。
+**这条是全报告唯一真正的 data race，也是第一次真跑出 -race 报告**：
+变异回普通指针后 `-race` 报 `WARNING: DATA RACE`（write @fog.go:453 `fogResetIndex` vs read @fog.go:45 `fogIndex`），
+恢复 atomic 后干净通过。回归 `fog_race_test.go`（8 读者 + 1 重置者）。
+
+### S7 两步验证限速 + 验证码一次性 ✅
+`login2FA` 接 `loginGuard`，键 `"2fa:"+用户名`（与口令环分开计数）；新增 `auth.CodeReplay`
+（`Consume(uid, code)`，`replayTTL = 3*totpStep = 90s` 覆盖 ±1 步窗口）。
+重放**不计入爆破计数**（用户手抖重复提交也会撞上，不该越锁越久）。
+阈值是第 5 次失败才上锁（`guardFreeTries=5`）⇒ 测试里「几次才锁」要写成循环探测，别硬编码次数。
+变异两轮：摘掉入口 `RetryAfter`（锁定期内递正确码能登录成功）、`Consume` 短路成 `if false`（同码拿到 303）——都红。
+
+### S2 图片上传缺请求体上限 ✅
+补 `r.Body = http.MaxBytesReader(w, r.Body, imageMaxBytes+1<<20)`。
+判据要认准：`ParseMultipartForm` 的 `maxMemory` 只限内存，超出**无上限**落临时文件；
+`mime/multipart` 内部另有 `maxMemory+10MB` 的松量，所以拿 9MB 去打 8MB 是能过的——必须大到越过上限。
+变异后文案变 `图片超过 6MB`（走的是单张 6MB 上限那条），据此判红。
+
+### D3 rows.Err() ✅
+`parse.go` 加 `drainRows(rows, what)`，13 处循环收尾全走它。
+守卫 `internal/rond/parse_rows_test.go`：抓出所有 `for x.Next()` 的变量名，逐个要求 `x.Err()` 或 `drainRows(x,`；
+再单独校验 `drainRows` 本体确实既查 `Err()` 又 `Close()`（防空壳）。
+往返验收全等（823/323/8/30/791/557/2246，坐标 0.000000000、时间 0s）。
+
+### P4 导出下载 ✅
+导出补 `Content-Length` + 用 `http.NewResponseController(w).SetWriteDeadline(+10min)` **只放宽这一条路由**；
+`gzipWriter` 补 `Unwrap() http.ResponseWriter`（少了它 ResponseController 一律 `ErrNotSupported`）。
+注意：测试里用 `httptest.ResponseRecorder` 会打日志「无法延长写超时」，那是预期的降级路径，不是 bug。
+
+### 验收
+- 全量 `go test -count=1 -v ./...`：**209 PASS / 0 FAIL**；只带单次 env 时 5 SKIP（全是两段式导出的），
+  预置 `ROND_CLEAN_OUT`/`ROND_EXPORT` 产物后 0 SKIP。两段式单独跑也全绿。
+- `gofmt -l` 干净、`go vet` 干净、无残留 MUTATION 标记。
+
+### ⚠️ 待查：`TestPlaceUpdateBatchActivity` 偶发失败（4 次全量里 1 次）
+症状：`导出包里只有 245/246 条到访`（`place_activity_test.go`）。
+**已排除本轮改动**：
+- 导出链路完全不经过 `rond.Parse`（只有 `backup_diff`/`backup_merge`/`handlers_admin` 上传用），D3 无关；
+- `f.export` 读的是 recorder 的 body，zip 若被截断 `rond.Open` 会直接失败（中央目录没了），
+  所以 P4 的 `WriteHeader`/`Content-Length`/`buf.WriteTo` 也无关；
+- 那一轮和上一轮的唯一差别是 3 个模板/JS 文件的 CRLF→LF，影响不到到访条数。
+**已加诊断**：失败时打印「包里缺哪些 Z_PK / pks 自身有无重复 / 包内 ZVISIT 总行数」，
+三种成因（少写一行 / 两行撞号 / 选错了数据集）一眼可分。
+**怀疑方向（未证实）**：`datasetFor` 是**全局**取活跃数据集
+（`WHERE is_active AND status='done' ORDER BY uploaded_at DESC LIMIT 1`，**没有 tiebreaker**），
+而用例的 `pks` 来自 fixture 自己的 `dsID`；若有两份导入同时 `is_active` 且 `uploaded_at` 同秒，
+导出可能取到另一份「几乎一样」的数据集 —— 差异正好是这种个位数级别。
+下次复发时看新诊断输出即可定性。
+
+### 收尾
+- 全量 `./internal/web/`（带两段式产物，CRLF 归一后重跑）：**113 PASS / 0 FAIL / 0 SKIP**。
+- 全量 `./...`：**214 PASS / 0 FAIL / 0 SKIP**。
+
+---
+
+## 第四批：S6 / D5 / D1 / P5 + N1 定位（2026-09-21 下午）
+
+顺序：先把上一批留下的 **D1 编译中断**修完（`activityFlags` 签名改 3 返回值、`fillup.go:384` 补错误处理、
+`handlers_photos.go:236` 接 `logAggFailure`），再依次做 S6/D5/P5。
+
+### S6 `X-Forwarded-For` 只认最后一段 ✅
+`clientIP` 改为「末段 + `netip.ParseAddr` 校验，不合法退回 `RemoteAddr`」。
+回归 `client_ip_test.go`（12 组表驱动 + 伪造前缀不改身份）；变异回「取首段」⇒ 红。
+副作用写进注释：投票身份 = `hash(cookie, IP)`，取法变即身份变；单反代没伪造时首末段相同、无影响；
+反代前再叠 CDN 时末段变 CDN 的 IP ⇒ 访客被叠成同一来源（cookie 仍各异，不会认错人）。
+
+### D5 收藏切换一条语句 ✅
+`UPDATE ... RETURNING bookmarked`。静态守卫（不许再有 `SELECT bookmarked` / `err == nil && on`）+
+行为用例（连点两次，提示与库内实况必须一致；不存在的记录不许回成功提示）。
+
+### D1 聚合刷新不再吞错 ✅
+四个助手统一返回 error：事务内上抛、提交后走 `logAggFailure`（只记日志不改判请求）。
+回归 `agg_error_test.go`：取消 context ⇒ 必错；裸调用静态扫描；签名必须以 `) error` 结尾。
+变异两处（`return nil` 吞错 / 改回裸调用）分别打红。顺带全仓确认再无「语句形式丢弃返回值」的 DB 调用。
+
+### P5 `findSourceArchive` 先按大小筛再算摘要 ✅
+新增 `pickArchiveBySha(files, sha, size, hash)`；`sha=''` 的退化路径不筛。
+`hash` 做成参数是为了让用例**数「算了几次摘要」**——只看返回哪个文件新旧写法没有区别。
+变异删掉大小筛 ⇒ 红并报「实际算了 3 次（白读了 2 份整包）」。
+
+### ⚠️ 自查：静态守卫的 cwd 依赖（本轮自己踩出来的坑）
+`TestVisitBookmarkTogglesInOneStatement` 用 `os.ReadFile("handlers_edit.go")` 单跑绿、跟夹具混跑红
+——因为 `newMovementFixture` 会 `os.Chdir` 到仓库根，而 `-run` 选中的用例集不同，cwd 就不同。
+`TestNoWeakRedirectPrefixCheck` 的 `filepath.Walk(".")` 同理，更阴：不报错，但扫的子树从
+`internal/web` 悄悄变成整仓。
+**修法**：新增 `internal/web/testpaths_test.go`（`moduleRoot(t)` / `pkgFile(t,name)`，从
+`runtime.Caller(0)` 往上找 `go.mod`），三处守卫全部改用它；`Walk` 起点改成仓库根并把「自查文件数」
+从「只在 found==0 时查」改成**无条件查**。验收跑了「单跑」+「跟夹具混跑」两遍，并在包外
+（`internal/config/config.go`）注入一次探针确认整仓覆盖真的生效。
+→ 已同步到技能 `rond-fix-verify`。
+
+### ★ N1 定位：不是导出丢行，是测试把 SQL 参数绑错了位
+症状「导出包里只有 245/246 条到访（缺 []，pks 内重复 []）」在第四轮全量里复现。
+根因：断言 SQL 是 `SELECT count(*), count(*) FILTER (WHERE ZACTIVITY_=?) FROM ZVISIT WHERE Z_PK IN (?,…)`，
+`FILTER` 的 `?` 是**第一个**占位符，而 `args` 是 `[pks…, actSrc]` ⇒ FILTER 绑到 `pks[0]`，
+IN 列表变成 `pks[1:] ∪ {actSrc}`，于是条数偶尔少 1、`converted` 只有碰巧 `pks[0]==actSrc` 时才成立。
+（「缺失列表为空」正是错位的指纹：缺的 `pks[0]` 被 `actSrc` 顶替了。）
+修法：`actSrc` 放最前、`ph`/`args` 同循环成对生成 + `Count(q,"?") != len(args)` 自检。
+验证：连跑 6 次全绿；变异 `export.go` 的 `actPK = sp` → `actPK = v.ActivityID.Int64` ⇒ 稳定红
+（`导出包里只有 0/246 条到访的活动换成了 #1（站点内部 id 75881）`）。
+**意味着这条断言以前是靠巧合绿的，等于没守住「导出写的是 rond 的 src_pk」。**
+先前怀疑的 `datasetFor` 全局取数据集已排除（包内 ZVISIT 始终 824 行）。
+
+### 验收（本轮收尾）
+- 全量 `go test -count=1 -v ./...`：**211 PASS / 0 FAIL / 0 SKIP，exit=0**（12 包全 ok）。
+- 两段式：`TestMovementCleanExport` → `TestExportRoundtrip`，823/323/8/30/791/557/2246 全等、
+  坐标 0.000000000、时间 0s；迷雾 8701 块一致。
+- `gofmt -l` 干净、`go build`/`go vet` 干净、`export.go` 与 HEAD 无差异（变异已完全还原）。
+- ⚠️ 本轮踩了一次环境变量：`ROND_DSN` 指了 `postgres` 维护库 ⇒ `TestChangeUsername` 失败
+  （关系 users 不存在）+ 6 个 stats skip + `TestVisitorHomeStore` skip。**必须指 `rond_fog_test`。**
+- 清理：删掉临时 `tmp-verify/`（含日志与中间包）与探针文件。
+
+### 遗留
+- **D7 待用户定语义**：`Filter.Verdict` 只在 `Places` 生效，`Cities`/`ActivityCounts`/`ActivityStats`
+  连 `Filter` 都没接。直接加会让「点被藏了、轨迹还在」——需要先决定「verdict 过滤是否也管轨迹」。
+- 其余：S8、S9、D4、D6、D8、F4–F10、F14、F16–F18、P3、P6–P8。
+
+---
+
+## 第五批（S8 / S9 / D7）——按用户「全部，但先从安全入手」
+
+### S8 GPX 轨迹两个入口都按属主收口
+- `/api/gpx`（公开无鉴权）原来全表吐；`adminGpxDelete` 只按 `id` 删。改成：取生效数据集的
+  `user_id`（`is_active AND status='done'` 最近一份）→ 取不到返空，`WHERE user_id=$1`；
+  delete 用 `WHERE id=$1 AND user_id=$2` + **查 `RowsAffected()==0`**（只改 WHERE 不看行数 ⇒
+  删他人轨道静默「成功」）。
+- 守卫 `gpx_owner_test.go`（行为 + 静态）。**静态守卫差点假绿**：写成 `strings.Contains(body,"user_id")`
+  时，一句中文注释就能糊过去 ⇒ 改成**只扫反引号里的 SQL 文本** + 「一段 SQL 都没扫到就 Fatal」。
+  变异：删 `WHERE user_id=$2` ⇒ 红。
+
+### S9 下载文件名可逃出引号
+- 四个 `Content-Disposition`（geojson/gpx/rondbackup/fwss）裸拼 `datasets.original_name` ⇒ 带 `"`
+  或换行即可注入头部。新增 `downloadDisposition`（`filename=` ASCII 兜底 + `filename*=UTF-8''…`）、
+  `rfc5987Escape`、`asciiSafe`、`hasAlnum`；四个出口全部改走它。
+- 守卫 `download_name_test.go` 三条。**反过来抓出实现自身两处 bug**：正则漏 `-`（合法名判不符）、
+  `asciiSafe` 漏 `=`（`a;b=c` 能溜过）——都修了。变异：某调用点改回裸拼 ⇒ 红；`asciiSafe` 删 `=` ⇒ 红。
+
+### D7 verdict 筛选全域一致（用户定「全域一致」口径）
+- 原来 `Filter.Verdict` 只在 `Places` 生效，`Cities`/`ActivityCounts`/`ActivityStats` 不认。
+  把 verdict 条件**下沉到 `visitsWhere`**（`place_key` 坐标键 `EXISTS(place_votes…)`），所有走
+  `visitsWhere` 的统计自动一致；`hasVisitConds()` 同步加 `|| f.Verdict != 0`；`Places` 那段重复
+  特殊-case 删掉。`place_key` 表达式抽成 `placeKeyExpr(alias)`（原来散在三处）。
+- 守卫 `stats/verdict_scope_test.go`：fixture **自建封闭数据集**（坐标 89.9/100.x、独立 user、
+  **故意不设 is_active**，避免并行测试按坐标键串味）；`Verdict=99` ⇒ 14 口径全空；只投 p1/p2 ⇒
+  visits=3/dwell=110/places=2/cities=2/provinces=1/movements=2/distance=12.00/weather=1。
+  变异：去掉 visitsWhere 下推 ⇒ 红；从 hasVisitConds 删 verdict ⇒ 只 movements/weather 清空 ⇒ 红。
+- 全量回归结果见下方「第五批验收」。
+
+### 第五批验收
+- 全量 `go test -count=1 -v ./...`（四件套齐全、DSN 指 `rond_fog_test`）：**218 PASS / 0 FAIL / 0 SKIP，exit=0**
+  （第四批 211 + 本批 S8/S9/D7 共 7 条）。两段式 823/323/8/30/791/557/2246 全等、坐标 `0.000000000`、时间 `0s`、迷雾 8701 块一致。
+- 已更新 `audit-2026-09-21.md`（新增「修复记录（第五批）」+ 重写「尚未处理」表，删掉 S8/S9/D7/P5；验收数字改 218）。
+- 已更新 `.workbuddy/memory/MEMORY.md`（GPX 属主 / Content-Disposition / verdict 全域一致三条硬规矩）与技能 `rond-fix-verify`（静态守卫三反模式）。
+
+---
+
+## 第六批（D4）——脏备份的伪时间与越界坐标
+
+### 实测复现（临时探针调 appleTime）
+Go 对超范围浮点转 int64 **是回绕不是饱和**：`NaN/±Inf/1e30/±1e30 → 2001-01-01`（恰好回绕到基准点，
+看着完全正常）、`1e12 → 2123-10-28`、`-1e12 → 1878-03-08`。
+要命的是 `ingest` 拿所有到达时间做 min/max 写 `datasets.first_visit_at/last_visit_at` ⇒ 一条脏行让
+整条时间轴从 2001 年起算。**只卡结果没用**（回绕后可能又落回合法区间），必须先卡输入秒数再乘。
+
+### 改法
+- `parse.appleTime`：`NaN/±Inf` 或秒数超出 `[1970,2100)` ⇒ nil（接上既有「装不下就 skip+留档」契约）。
+- 新增 `parse.validCoord`：NaN/±Inf/越界 ⇒ 读 `ZLOCATION` 时归一成 `(0,0)`（与 `COALESCE(NULL,0)` 一致，
+  顺带让 `place_key`/`contentHash` 对脏行稳定）。
+- 位移的脏时间**保留行、时间置空**（本就可空、导出走 `sql.NullTime`），不制造「无声消失的行程」。
+
+### 回归 + 变异
+- `internal/rond/dirty_test.go`：纯函数 + 静态守卫 + **真的建一个 Core Data 版 sqlite 走一遍 `Parse`**。
+- `internal/ingest/dirty_import_test.go`（DB，独立用户跑完即删）：脏到访不进 visit_count、留档为 skipped、
+  `first_visit_at` 不被污染。
+- 变异 5 次全红：去窗口检查 / 去 NaN 检查（两者互补） / 去地点归一化（静态+端到端双红） /
+  ingest 改「补零时间」/ ingest 只跳过不留档。
+- 已更新 `audit-2026-09-21.md`（新增「修复记录（第六批）」+ 尚未处理表移除 D4）。
+
+### ⚠️ 自查：新写的 ingest 用例把统计用例「串」成了假 skip（本轮自己踩出来的）
+第六批全量首跑 `220 PASS / 0 FAIL / 4 SKIP`——4 条 stats 用例报「没有天气数据可测 / 找不到可用省份」。
+根因两层：
+1. `stats` 夹具是 `SELECT id FROM datasets WHERE is_active LIMIT 1`，**不带 user 过滤**；我的 ingest 用例
+   `Import` 时会把临时数据集的 `is_active` 切成 true ⇒ 运行期间别的包可能选中这份几乎空的数据集 ⇒ skip。
+2. 更糟的是**清理没生效**：`defer d.Close()` 在 `t.Cleanup` 之前执行（defer 先跑），Cleanup 里
+   `d.Exec(DELETE FROM users …)` 拿到的连接已经关了，静默失败 ⇒ 库里留下 5 个 `__dirty_*` 用户、
+   5 个生效数据集，把所有 stats 用例永久污染。
+**修法**：派生**专用库**（`ROND_DSN` 库名加 `_ingest` 后缀、`db.Open` 自动建）+ 把 `d.Close()` 也放进
+`t.Cleanup` 并**先注册**（后进先出 ⇒ 删用户时才还连着）。清掉残留用户后重跑，共享库 `users=1/active=1`。
+→ 已同步到技能 `rond-fix-verify` 与 `MEMORY.md`。
+
+### 第六批验收
+- 全量 `go test -count=1 -v ./...`：**224 PASS / 0 FAIL / 0 SKIP，exit=0**（12 包全 ok；第五批 218 + D4 新增 6）。
+- 两段式导出数字与第五批完全一致（823/323/8/30/791/557/2246、坐标 0.000000000、时间 0s、迷雾 8701 块）
+  —— D4 只拦脏值，干净备份路径零变化。
+- 验收数字已写入 `audit-2026-09-21.md`「验收状态」。
+
+---
+
+## 第七批（F4/F7）——异步回包把已关掉的图层又画回来
+
+### 症状与根因
+勾选图层 → 请求发出 → 立刻取消 → 回包 → **图层照画**（开关显示「关」，地图上却有东西）。
+四个出口全中：`setGpx`/`setHeat`/`setCityAgg`（`rond-map.js`）+ 模板里的行程轨迹 `refreshTrack`（`map.html`）。
+共同写法是取消时 `xxxLayer = null` 就 return，**在途那次请求没人作废**。
+
+### 改法
+每次调用发递增序号；关键是**序号必须在 `if (!on) return;` 之前递增**（否则取消这条路径不改序号，
+在途请求照样合法），回包首行 `if (seq !== xxxSeq) return;`。序号顺带解决「连点筛选/切底图」的旧回包盖新回包。
+`refreshTrack` 的 `.then` 与 `.catch` 两个分支都要挡。
+
+### 验证
+- 守卫 `map_async_cancel_test.go`：按大括号配平取函数体，断言**两个异步分支的相对顺序**
+  （递增早于早退、作废检查早于画）。变异 3 次全红。
+- **CDP A/B（比静态守卫硬）**：`--inject` 给 `/api/track|gpx|cities` 回包各加 900ms 延迟撑开竞态窗口，
+  探针「勾选 → 120ms → 取消 → 2.2s」后数 `path.leaflet-interactive`：
+  有守卫 `2→2 delta=0`；去掉守卫 `2→758 delta=756`（**开关关着画了 756 条线，且 errs=0**）。
+- 临时的 inject/探针脚本写在 `storage/_*`，跑完已删。
+- → CDP 手法（延迟注入 + 数 DOM 做 A/B）已同步到技能 `rond-web-verify`。
+
+## 第八批（D8 / P8）
+
+### D8 上传失败后把半成品留在 uploads 里
+`adminUpload` 先落盘再解析（`rond.Open`/`Parse`/`ingest.Import` 任一失败都直接 return），
+原来只有「sha 完全相同」那条早退分支才 `os.Remove` ⇒ 坏包反复上传堆垃圾，而 `findSourceArchive`
+正要遍历这个目录。改法：落盘后挂 `keepStored` + `defer`，只有「新导入成功」那一支置 true
+（那份上传件是导出的基线源）；顺带修掉 `st.Identical` 分支的同类泄漏。
+回归 `upload_cleanup_test.go`（DB）：投垃圾 `.rondbackup`，断言 303 带 err + 目录无新增；
+**带前提守卫**（Location 必须含「解析备份失败」，否则落在更早分支时断言会空过）。
+变异：清理改空操作 ⇒ 红并报出泄漏文件名。
+
+### P8 recover 在响应已写出时追加错误体
+`http.Error` 无条件调用 ⇒ handler 写了半页才 panic 时会二次 `WriteHeader`
+（`superfluous response.WriteHeader`）并把错误体接在半个页面后面。
+改法：`recover` 用 `headerSent` 包装 ResponseWriter（`WriteHeader`/`Write` 任一即置 sent），
+已写出就只记日志。包装层必须实现 **`Unwrap()`**（又踩到 P4 给 gzipWriter 补过的同一个坑：
+少了它 `NewResponseController` 拿不到 `SetWriteDeadline`，导出的 10 分钟写死线静默失效）。
+回归 `server_error_test.go` 三条（半页+panic / 未写+panic / 用现成 `deadlineRecorder` 验 Unwrap）。
+变异：还原无条件 http.Error ⇒ 红；删 Unwrap ⇒ 红（feature not supported）。
+
+### 第八批验收
+- 全量 `go test -count=1 -v ./...`：**229 PASS / 0 FAIL / 0 SKIP，exit=0**（12 包全 ok；第八批新增 4 条）。
+- 两段式导出与第六批逐项相同（823/323/8/30/791/557/2246、坐标 0.000000000、时间 0s、迷雾 8701 块）
+  —— 七、八两批都没碰数据路径。
+- ⚠️ 变异验证会在 `storage/uploads-test/` 留一个泄漏文件（清理被改成空操作那轮），
+  已清掉；正常测试轮不留（用例自带断言）。
+
+## 第九批（D6）——轨迹图层与里程统计的区域判定不一致
+
+原报告写「可见性口径不一致」，查清后具体是**区域判定的连接方式**不同（与迷雾遮罩无关）：
+`apiTrack` 是 `regionSQL("pf") + regionSQL("pt")` ⇒ 白名单下**两端都要命中**；
+`movementsWhere` 是 `EXISTS(... pmv.id IN (from,to) ...)` ⇒ **任一端命中**。
+黑名单下两种写法恰好等价，白名单下才分叉：一端在北京、一端在上海的位移，白名单只选北京时
+图层画不出来（缺上海那端）、总里程却算进去。图层那侧「两端都要在」才是安全侧
+（白名单的用意就是不暴露区域外坐标）。
+
+**改法**：`movementsWhere` 的区域条件改成对两端各判一次、两端 AND（与 regionSQL 同款），
+并把 `IN` 换成 `COALESCE(col,'') = $n` —— `district` 常 NULL，`NULL IN (...)` 得 NULL，
+黑名单的 `NOT (...)` 跟着变 NULL ⇒ **整行被误删**（regionSQL 早用 COALESCE 绕过，这是第三点分叉）。
+
+**回归**：`internal/web/region_consistency_test.go` 是**对账测试**（不是各写一遍 SQL 互比）：
+自建封闭数据集（3 地点 / 2 段位移：一端在外 10km、两端在内 20km），一边跑**真 regionSQL** 拼的
+图层谓词、一边跑**真 `stats.Overview`**，断言相等。变异：还原成「任一端命中」⇒ 红，
+报「图层 20.00 km，统计 30.00 km」。
+→ 已更新 `audit-2026-09-21.md` 与 `MEMORY.md`（区域判定必须两端 AND + COALESCE）。
+
+### 第九批验收
+
+- 全量 `go test -count=1 -v ./...`：**230 PASS / 0 FAIL / 0 SKIP，exit=0**（12 包全 ok；第九批新增 1 条对账用例）。
+- 两段式导出 823/323/8/30/791/557/2246 全等、坐标 0.000000000、时间 0s；迷雾 8701 块逐字节一致（未碰数据路径）。

.workbuddy/memory/2026-09-22.md

@@ -0,0 +1,39 @@
+# 2026-09-22
+
+## 第十批（P6 / P7 / P3）——性能：缓存上限、重复查询、批量往返
+
+### P6 `fillupCache` 无界增长
+`fillup.go` 的 `fillupCache` 是全局 map 只写不清。改成**带上限的 FIFO**：超过 `fillupCacheMax`(2048)
+丢最旧的四分之一（`fillupOrder` 记插入顺序），覆盖写同一键不重复记账（否则 order 比 cache 长、淘汰错删）。
+守卫 `fillup_cache_test.go`；变异（阈值抬到 ×1000）⇒ 红。
+
+### P7 统计页「周几」查两遍
+`handlers_public.go` 的 `d.Weekday` 已在 `runJobs` 的 weekday 任务里查过，渲染前又同步查了一遍
+（第二个纯多余）。删掉后者。守卫 `stats_weekday_once_test.go`（`s.q.Weekday(` 必须恰好 1 次）；变异 ⇒ 红。
+
+### P3 `adminNotesBulk` 逐条往返
+三个分支原本都是 `for _, id := range ids` 逐条调 store（勾 50 个地点 = 50 次、清空 100 次往返）。
+新增 `notes.DeleteBulk` / `notes.SetNoteBulk` / `votes.SaveVerdictBulk`，统一用 `p.src_pk = ANY($3::bigint[])`。
+`SetNoteBulk` 两条语句等价于逐条 `SetNote(..., "")`：先删「别名与 rond 备注都空」的行、再清其余行的
+手写 note（顺带把 `dataset_id/src_pk` 刷成当前数据集的值，与逐条 upsert 对齐）。
+守卫 `admin_notes_bulk_test.go`：①静态扫描（函数体不许再出现逐条的 `Delete(`/`SetNote(`/`SaveVerdict(`、
+必须有三个 `*Bulk`）；②端到端（3 个地点依次走 结论/清空/取消/删除，每步断言**全部**生效）。
+变异：①退回逐条循环 ⇒ 静态守卫红；②给批量 INSERT 加 `LIMIT 1` ⇒ 端到端红（「实际 1」）。
+
+**新事实**：pgx v5 stdlib（走 `database/sql`）**直接接受 `[]int64` 作为 `ANY($3::bigint[])` 的数组参数**，
+既不用 `pq.Array`，也不必手写 `IN` 占位符——实测通过（`TestAdminNotesBulkAppliesToEveryCheckedPlace`）。
+
+### 第十批验收
+- 全量 `go test -count=1 -v ./...`：**234 PASS / 0 FAIL / 0 SKIP，exit=0**（第十批新增 4 条）。
+- 两段式导出 823/323/8/30/791/557/2246 全等、坐标 0.000000000、时间 0s；迷雾 8701 块逐字节一致（未碰 rond 数据路径）。
+- → 已更新 `audit-2026-09-21.md`（新增「修复记录（第十批）」+ 重写「尚未处理」表，删掉 P3/P6/P7；
+  「尚未处理」只剩 F5/F6/F8–F10/F14/F16–F18 这批前端交互/无障碍细节）。
+
+## 收尾：MEMORY.md 精简（注入被截断）
+
+`.workbuddy/memory/MEMORY.md` 注入时被截断——尾部「安全/跳转」「口径/404/验收」两节根本进不来，
+等于白写。就地精简：**12452 → 8888 字符（-29%）**，保留全部规矩与守卫名，把「验证机制细节」
+（四件套环境变量之外的那些：静态守卫禁相对路径、`?` 绑定顺序、`-race` 的 mingw PATH 等）
+指向技能 `rond-fix-verify`，只留两个最容易「假绿」的坑（缺 `ROND_SRC` 静默 skip、共用库写数据集串味）。
+（随后第十批又补了 2 条性能规矩，当前 9277 字符 —— 已贴近注入上限，**后续新规矩优先写进
+`MEMORY-details.md` 或技能，别再往这个索引里堆**。）

.workbuddy/memory/2026-09-23.md

@@ -0,0 +1,24 @@
+# 2026-09-23 工作日志
+
+## 第十一批（前端 P2 收尾）完成 + 全量审查
+
+- 修掉原报告 P2 前端剩下的 8 条：F5/F6（`rond-map.js`：localStorage 走 `lsGet`/`lsSet`；
+  `previewQueue` 在 `if (live)` 之前排队）、F8/F9（`photo-exif.js`：EXIF 时间范围校验、
+  `findExifItemID` 读宽度守卫）、F14（`app.css` 删死内边距）、F16（`edit.html` 三个筛选表单带全 8 个参数）、
+  F17（`view.go` 删 `safe`）、F18（`place.html` aria-label + alt）。
+- 新增 `internal/web/frontend_fixes_test.go`，本批 9 条守卫（含补的 F10：`fillup.html` 的
+  sessionStorage 读写必须包 try）。全部逐条变异验证（注入→红→还原→绿）。
+- **重要发现：F10 的代码早在提交 `82e6341` 就修好了**，原报告「尚未处理」清单与表格 ✅ 标记是陈旧的。
+  审查时把 F11/F12/F13/F15 也复核了一遍——同样是在更早批次已修，只是表格漏标。
+- 最终验收：**243 PASS / 0 FAIL / 0 SKIP**，12 个包全 `ok`；导出 823/323/8/30/791/557/2246 全等、
+  坐标偏差 0、时间偏差 0s、迷雾 8701 块一致（本批不碰数据路径）。
+- 完整审查另抽查复核 3 条早期批次守卫（D6 区域判定、S8 GPX 属主 ×2）——重新注入原始 bug 全部转红，
+  报文与当时记录逐字相同；还原后 `git diff --stat` 与注入前一致。
+- 报告 `audit-2026-09-21.md` 已补「修复记录（第十一批）」「完整审查（2026-09-23 收尾）」，
+  「尚未处理」清空，验收状态更新到 243。
+
+## 记忆整理
+
+- `MEMORY.md` 之前 14,471 字符，注入时被截断（尾部「安全/跳转」「口径/验收」收不到）。
+  已把完整判据搬进 `MEMORY-details.md` 新增的**第二十八节**，索引压到 **8,650 字符**
+  （只留一句话判据 + 守卫名）。**以后新规矩写 details / 技能，别再堆索引。**

.workbuddy/memory/2026-09-24.md

@@ -0,0 +1,100 @@
+# 2026-09-24 工作日志
+
+## 稳定性基线实测（回答「现在稳定了吗」，把数字钉下来）
+
+- 覆盖率（`go test -cover ./...`，全套环境变量）：web 53.2%、stats 62.2%、auth 50.5%、db 53.4%、
+  fog 52.9%、ingest 47.6%、rond 38.8%、exif 69.7%、media 64.6%、setting 85.0%、config 75.0%、
+  captcha 90.6%；**按源码行数加权 ≈ 51%**。
+  `geo`/`gpx`/`notes`/`votes` 报 0.0% 只是 `-cover` 不统计跨包执行，它们被 web/stats 的用例间接跑到。
+- **「不带环境变量 = 假绿」的规模变大了**：只跑 `./internal/web/ ./internal/rond/ ./internal/stats/`
+  （不设四件套）→ 三个包全 `ok`、exit=0，但 **95 PASS / 86 SKIP**。
+  原始报告基线是 62 SKIP；本轮的回归守卫几乎都带 DB 夹具 ⇒ 假绿面反而扩大。
+- 路由触达：92 条注册路由里，41 条在测试里被直接引用过（51 条没有；但不少 handler 是用函数直调
+  覆盖的，这个比例**高估**了缺口）。
+- 无 CI、无 Makefile、无 linter 配置 ⇒ 0-skip 验收完全靠人记住六个环境变量。
+- 仓库卫生：`tools/__pycache__/*.pyc` 已入库（编译产物）；6 个 `tools/*probe` 探针工具在库里
+  （技能里写的是「用完删掉」）。
+- 未提交：48 个修改 + 38 个新增文件仍全在工作区。
+
+## P0（落地）
+
+- **一键验收 `scripts/verify.sh`**（无 make，用 bash）：自己从 `conf/app-test.ini` 取 DSN（不写死口令）；
+  库名不含 `test` 直接拒跑；**数 SKIP 并让非 0 失败**；两段式导出（先产纯净包再全量）；
+  支持 `--fast`（gofmt+vet+build）/`--race`/`--cover`/`--pkg`/`--run`。
+  实测：`--fast` 通过；DSN 指 `postgres` → 拒跑；缺 `ROND_SRC` → 拒跑；未知参数 → exit 2。
+- **仓库卫生**：删掉 6 个一次性探针（colprobe/diffprobe/exportprobe/fogprobe/idprobe/sqlprobe）
+  与误入库的 `tools/__pycache__/photo_coord_audit.cpython-313.pyc`；`.gitignore` 补 `__pycache__/`、`*.pyc`；
+  新增 `tools/README.md` 说明留下的 4 个工具（verify_export_structure / verify_rondbackup /
+  photo_coord_audit / audit_db.sql）与验收命令。
+- **分 3 个提交落地**（工作区已干净）：
+  `b4c2a84` 后端（安全/数据一致性/性能）70 文件、`d5f6dfa` 前端（模板/CSS/JS+无障碍）18 文件、
+  `d2e4392` 验收脚本 + 工具整理 + 排查报告。每个提交都过了 `go build ./... && go vet ./...`。
+  提交顺序说明：前端守卫要读模板/静态文件，所以读前端产物的测试（frontend_fixes / tb_static /
+  templates_test / wide_table_layout / tb_stack / map_async_cancel / map_escape）跟模板放同一提交。
+
+## P1
+
+- **全新库冒烟 `internal/db/fresh_db_test.go`**：空库 → `Open` 自动建库 → `Migrate`（跑两遍验幂等）
+  → 断言 21 张表、迁移块补出来的列（`places.coord_*`、三张表的 `place_key`…）、三张附属表的主键
+  已搬到坐标键、4 个索引，最后用 `stats.DB{DB: d}` 真打 18 个读查询（空库上不报错）。
+  **变异验证**：把 `CREATE INDEX idx_place_images_key` 移到 `CREATE TABLE place_images` 之前
+  ⇒ 新库报 `关系 "place_images" 不存在 (SQLSTATE 42P01)` 变红；同一条语句在老库上
+  `psql -c` 却提示「已存在，跳过」⇒ 正是「开发库无症、新库起不来」。已还原（`git diff` 空）。
+- **web 整包 `-race`**：`./scripts/verify.sh --race --pkg ./internal/web/`（脚本自动把 mingw 加进 PATH）
+  ⇒ **161 PASS / 0 FAIL / 0 SKIP / 0 个 DATA RACE**。此前只有迷雾索引那一条验过 race。
+- 脚本补丁：SKIP/FAIL 计数改成 `^[[:space:]]*--- `，**连子测试一起数**（只数顶层会漏掉子测试的跳过）。
+- 最终验收（HEAD，一条命令）：**244 顶层用例 / 271 含子测试 / 0 FAIL / 0 SKIP**，12 包全 `ok`；
+  往返包 823/323/8/30/791/557/2246 全等、坐标 0、时间 0s、迷雾 8701 块。`--fast` 干净。
+- 提交：`b4c2a84` 后端 → `d5f6dfa` 前端 → `d2e4392` 脚本/工具/报告 → `ff59412` 脚本补丁。
+  中间提交未单独跑全量（实现与其守卫同批落地，拆开必假红），最终状态已验收。
+- 仍剩的 P2（未做）：`rond` 38.8% 覆盖率补主路径、关键页面 CDP 冒烟、**导出包真机导入**（唯一终审）。
+
+## P2（落地，只做了前两项；真机导入仍需站长操作）
+
+### 覆盖率：先纠正口径，`rond` 根本不是 38.8%
+
+- **`go test -cover` 只统计「测试文件所在那个包」自己的执行**。`internal/rond` 一半的代码
+  （`export.go` 1416 行）由 `internal/web` 的 `TestMovementCleanExport` 跑；`geo`/`notes`/`votes` 同理。
+  按 `-cover` 量这些包一律假报 0%（`gpx` 也报 0%，但那条是**真的**）。
+- 正确口径 `-coverpkg=./internal/...`：rond **82.2%**（假读 38.8%）、geo 92.9%（假读 0%）、
+  stats 83.7%（假读 62.2%）、web 53.2%（它自己不假）。**项目合计 62.3%**。
+- ⚠️ 解析 profile 必须**按 `(文件,行段)` 取 max**：`-coverpkg` 下每个测试二进制都给同一段代码写一条，
+  求和 = 语句数乘份数 ⇒ 每包都像只有 `1/N`（第一版 awk 就这么错的，web 印成 4.4%）。
+- `scripts/verify.sh --cover` 已切到该口径并按包打印。
+
+### 补的用例（只补「线上会走到」的，不追 `nil`/错误返回）
+
+- `internal/rond/merge_clash_test.go`：`BuildMergePlan` 的**地点/活动冲突**（`placePick`/`activityPick`
+  长期 0%，而差异页线上确实会提交这两类选择）+ 删除逐条勾选。`merge.go` 64.3% → **96.4%**。
+- `internal/gpx/gpx_test.go`：该包**整包零测试**（0/61 语句），而它解析的是**用户上传的 XML**。
+  8 条用例覆盖 trk/rte 两分支、名字退回 `metadata>name`、`(0,0)` 丢弃、单点轨迹丢弃、非法 XML、
+  无轨迹点、时间错不致命、里程数值。⇒ **0% → 96.0%**。
+- 两处**死代码**（全仓核查含模板后确认零引用）：`rond.Counts.Total()`、`gpx.Track.BBox()`，已删；
+  **没给它们写测试**（给死代码补用例等于把死代码固化）。
+- **一条实测否证**：`gpx.haversine` 没有 `geo.Haversine` 那道 `math.Min(1,…)` 夹子，
+  本以为会出 NaN；实测对跖点 `h` 最多到 `1+2^-52`，而 `sqrt(1+2^-52)` 回舍成正好 `1.0`，
+  `asin(1.0)=π/2` ⇒ **改不动，也没改代码**，只留 `TestLengthKmAntipodalIsFinite` 钉住该性质。
+  三条 haversine 公式两个半径（6371.0 / 6371.0088）差 0.20 m/146 km，纯口径不统一。
+
+### 关键页冒烟 `scripts/smoke.py`（16 页）
+
+- 三种口径：站长浏览器（200 + 落点路径 + 内容区尺寸非 0 + 零 JS 报错）、访客纯 HTTP
+  （公开页 200、后台页必须 **303 跳登录**，不跟随跳转即可，比开 Chrome 快一个数量级）、
+  访客浏览器抽检 `/` 与地点详情。接进 `verify.sh --smoke` / `--all`。
+- 三个坑：①关键区块**不能取 `nav.nav`**（在 layout 里，内容块没渲染它照样在）；
+  ②**用 `.card` 不用 `div.card`**（专题卡片是 `<a class="card topic-card">`，选不中时
+  `querySelector` 返回 null ⇒ 尺寸也是 0，打印出来跟「被压成 0 宽」一模一样）；
+  ③`--min-body` 只兜「整页空白」（专题列表正文天生 166 字）。
+- **变异验证**：`timeline.html` 里塞 `<script>throw new Error(...)</script>`
+  （`debug=true` 模板热加载，不用重启）⇒ 冒烟红在「JS 报错」，而**状态码/内容区尺寸全正常**
+  ⇒ 没有这条断言就会放过它。已还原。
+- ⚠️ `verify.sh` 给 Windows python 传路径要用 `$ABS`（`C:\...`），传 `$ROOT`（`/c/...`）
+  会被拼成 `C:\c\...` 报 `No such file`。
+- `site_cdp.py` 不报 HTTP 状态；用 `performance.getEntriesByType('navigation')[0].responseStatus`。
+
+### 收尾验收与提交
+
+- `./scripts/verify.sh` ⇒ **284 PASS / 0 FAIL / 0 SKIP**（P1 时 244，本轮 +新用例）；
+  `--all` ⇒ 冒烟 16 页全绿；`--cover` ⇒ 62.3%；`--fast` 干净。
+- 提交：`05c6e97` 测试与死代码 → `256620e` 验收脚本与冒烟 → `f2ce664` 报告。工作区已干净。
+

.workbuddy/memory/2026-09-28.md

@@ -0,0 +1,78 @@
+# 2026-09-28
+
+## rondbackup「差异分析 → 合并执行」实测（真机导出包 20260928_183908）
+
+环境 `conf/app.ini`（库 `rond_with_you`、`data_dir=storage/data`、:8080），数据集 id=9；
+把真机新导出的 `data/20260928_183908.rondbackup`（955 到访 / 432 地点）合并进已有 867 到访的数据集。
+
+**主链路生效**（真跑路由 + 站长登录）：`POST /admin/preview` → `GET 差异页` → `POST /admin/preview/{token}/merge`，
+`add_new=1`、冲突留默认 ⇒ 新增 70 地点 / 1 活动 / 134 到访，随到访带入 24 位移 / 32 天气；
+到访 867→1001、地点 368→438、位移 791→815、天气 557→589；**孤儿位移 0、无地点到访 0、重复 UUID 0 组**。
+逐条核对：备份里 953 条带 UUID 的到访全部命中且**到达时间微秒级零误差**；站内 2 条 app 已删的 UUID 到访被正确保留。
+合并后 12 个关键页全 200。报告：`storage/.mergetest/报告-rondbackup合并实测-20260928.md`
+
+**三个问题**
+1. 🟠 同名同坐标的重复地点**不幂等**：`DiffPlaces` 的 `byCoord`/`byName` 是单槽位 map + `used[]`，
+   同一坐标下 N 条备份地点最多只能配 2 条 ⇒ 第 3 条永远判「备份新增」，每次合并多插一条。
+   实测备份里同名同坐标共 10 组、只有「柳州站」count=3 ⇒ **每次合并固定多 1 个重复地点**，差异永不归零
+   （438→439→…）。修法：多值 map 逐条消费 + `mergePlaces` INSERT 前按 `PlaceCoordKey` 去重兜底。
+2. 🟠 到访冲突被「活动改名」放大：`visitFieldChanges` 比的是**活动名称**不是身份；16 个活动改名
+   （餐厅→吃饭…）⇒ 355 条到访冲突全部同因（库内挂在改名活动下的 378 条 − 站内独有 23 条 = 355，精确吻合），
+   活动类型本身只报 16 条。且对到访选「用实机」**不会**改活动名（`activity_id` 按 UUID 映射回同一个）
+   ⇒ 冲突永不收敛。修法：到访层面按活动身份（`ZUID_`/id）比对，改名只在活动层报一次。
+3. 🟡 21 个**长沙**地点两边坐标差 661~748m，实测 20 条满足「站内坐标 == 反纠偏(备份坐标)」
+   ⇒ 坐标系不一致（站内那侧被多做了一次 GCJ→WGS 反向换算）；**差异页冲突的默认选项是「用实机」**，
+   直接点合并会把这批坐标覆盖、地图上跳 ~660m。另有 分类 12 处（站内中文标签 vs 备份 `MKPOICategory*` 原始枚举）。
+
+**备份 / 回滚**：`storage/.mergetest/rond_with_you-before-20260928.sql`（整库 pg_dump）；
+差异页快照 `diff-before-merge.html` / `diff-after-merge.html`。库内最终状态 = 合并一次（我重复跑测试
+多插的 1 个重复地点已回退）。
+
+**方法（可复用）**：临时 Go 测试（`package web`，才能拿到非导出的 `srv.captcha`）——
+`httptest.NewServer(srv.Handler())` + cookie jar + **`CheckRedirect: http.ErrUseLastResponse`**
+（站点用 303，必须关掉自动跟随才能读到 Location）；验证码答案直接读 `captcha.Store.Answer(id)`，
+绕开图像识别；管理员口令是默认 `rond-admin`（pbkdf2 可离线核对）。跑完删掉测试文件，`git status` 保持干净。
+
+## 同日晚：修复 + 复测（回档数据库后重跑）
+
+按上面前两条问题改了代码，**5 个文件 +172/−22**：
+
+1. `internal/rond/diff.go` `DiffPlaces`：`byCoord`/`byName` 由单槽位 map 改为**多值索引**（`map[string][]StoredPlace`），
+   抽出 `take()` 逐条认领未使用的候选（认领即置 `used`）。`classify` 不再自己置 used。
+2. `internal/rond/diff.go` `visitFieldChanges`：到访的「活动」改为**按身份**比（新增参数 `actUUID`），
+   两边都缺 UUID 才退回名称；`DiffVisits` 传入 `b.ActivityUUID`。`StoredVisit` 新增 `ActivityUUID`。
+3. `internal/web/backup_diff.go` `loadStoredVisits`：多 JOIN 一次 `entity_raw`（`entity='ZACTIVITY'`，按 `a.src_pk`）取 `ZUID_`。
+
+**复测结果**（回档 → 重跑同一份备份，同环境）：到访冲突 **253 → 6**（247 条活动改名假冲突消失）；
+地点新增 **70 → 67**，合并后再比对 **地点新增 1 → 0**；再点合并由「再插 1 个重复地点」变成
+「**按当前的选择没有要写入的改动，数据未变**」，地点 435→435、「柳州站」稳定 3 条。
+到访 1001 / 位移 815 / 天气 589 与修复前一致；953 条 UUID 到访全命中、到达时间 0 偏差、孤儿位移 0。
+
+**新增守护**：`TestDiffPlacesAlignsDuplicateNameCoordGroups`（含「站内真少两条仍报新增 2」反向断言）、
+`TestDiffVisitsIgnoresActivityRename`、`TestDiffVisitsReportsActivityChange`、
+`TestDiffVisitsActivityWithoutUUIDFallsBackToName`；`TestBackupDiffIdentical` 补地点新增断言、
+两个 merge 幂等用例补「地点差异归零」。**变异验证**：把两处改回旧逻辑，对应用例确实全挂
+（⚠️ 变异要忠于旧行为：旧 `byCoord` 是 map「后者覆盖前者」＝取最后一条；我第一次写成「取第一条」，
+误报 8 条，与真实旧行为不符，改用 `byCoord[k] = []StoredPlace{sp}` + `byName` 只留第一条才复现出正确的 1 条）。
+
+**仍未动**：21~24 个长沙地点坐标系差 ~660m（默认「用实机」会覆盖站内；现连带 25 条到访「地点」冲突）、
+分类 12 处中文标签 vs `MKPOICategory*` 枚举、16 个活动改名需选「用实机」才同步。
+报告已更新为「实测 → 修复 → 复测」完整版。
+
+## 收尾：回滚 + 推送 + 重建（19:35）
+
+- **回滚**：`DROP/CREATE rond_with_you` + 恢复 `storage/.mergetest/rond_with_you-before-20260928.sql`，
+  核对回到合并前基线 867 到访 / 368 地点 / 31 活动 / 791 位移 / 557 天气 / 2538 留档 / 柳州站 3。
+- **推送**：提交 `10d23e0`（5 文件 +172/−22），`git push origin master`（远端 `git.shiroko.one`）。
+  本地原本就**领先远端 8 个提交**，一并推上去了（`78865fc..10d23e0`）。
+  ⚠️ **推送凭据陷阱**：`~/.git-credentials`（store）与 GCM 里缓存的 token **都已失效**
+  （`remote: Failed to authenticate user`），SSH 22 端口 `Network is unreachable`（只有 HTTP 代理
+  `http.proxy=http://100.104.48.63:11882` 能通）。**别加 `GIT_TERMINAL_PROMPT=0`**——它会让 GCM
+  直接放弃认证；去掉这个变量、让 GCM 自己走一遍交互认证即可成功（13 秒完成）。
+- **重建**：`go build -o bin/rond.exe .`（`bin/rond.exe` 原本还是 9-20 的旧构建，不含修复；
+  旧文件留了副本 `bin/rond.exe.bak-20260920`）。只读冒烟：`/healthz` `/` `/admin/login` 均 200、
+  `/admin` 303，随后 `taskkill //F //IM rond.exe` 停掉、8080 释放，库内计数不变。
+- 注意：`go build` 那次 `bin/rond.exe~`（9-20 12:14 的更旧副本）不见了；原因未查明，
+  两个都是修复前的旧产物，无实际损失。
+
+

.workbuddy/memory/2026-09-29.md

@@ -0,0 +1,484 @@
+# 2026-09-29
+
+## 站长手动合并后追问：3 条「地点 X → X」的冲突为什么
+
+用户按默认（全「用实机」）把我的库合并了，差异页报「两边都有但不一样（3）」，三行都是
+`地点 中国体育彩票 → 中国体育彩票` 这种**两边显示同名**的形态。复现与定性（用真实代码路径 +
+独立探针库 `rond_merge_probe` 恢复快照，不动用户库）：
+
+- 合并前：到访冲突 6（2 地点 + 4 活动）→ 与 9-28 的测量一致。
+- 合并后（用户已合）：**到访冲突 3、地点冲突 2、活动冲突 0**，逐条与用户贴的 3 行**完全一致**。
+- 结论：**「地点」这一项比的是坐标（`rond.PlaceCoordKey`，经纬度 6 位小数），不是名称**；
+  而差异页只把**名称**印出来 ⇒ 名称相同、坐标不同的组合渲染成 "X → X"，看着像没变化。
+  三处的真实坐标差：
+
+  | 到访 | 站内地点 | 实机地点 | 直线距离 |
+  | --- | --- | --- | --- |
+  | 2025-09-20 22:39 中国体育彩票 | 广东佛山 (22.927572,113.222052) | 广西贺州 (24.408376,111.554626) | **236.8 km** |
+  | 2025-12-19 09:50 长沙南站 | (28.146535,113.062164) | (28.141772,113.067569) | **750 m** |
+  | 2025-12-21 14:01 茶颜悦色 | (28.181954,112.986995) | (28.242581,113.037061) | **8.3 km** |
+
+- 成因不是同一个：237km / 8.3km 是**连锁店重名**（实机里「中国体育彩票」3 条、「长沙南站」2 条、
+  「茶颜悦色」2 条），`DiffPlaces` 坐标配不上就**按名称兜底配**，把不同的店配成了一对；
+  750m 那条是坐标系/纠偏那类（站内被多做了一次 GCJ→WGS 反向换算）。
+
+**顺带发现：这次默认「用实机」已经动了库里的坐标**（对照 probe 库 vs 现库）：
+- `中国体育彩票` src_pk=71：贺州 (24.408376,111.554626) → **佛山 (22.927572,113.222052)**，搬了 236.8km（错配导致的误覆盖）
+- `茶颜悦色` src_pk=348：移动 665m；`长沙南站` src_pk=344：移动 750m（这两条属于坐标系修正，是对的）
+
+**已修（用户批准「修两处 + 回滚重跑」后落地，`internal/rond/diff.go` 单文件 + 用例）**：
+1. `takeByName` 加距离上限 `nameMatchMaxKm = 1.0`（`DiffPlaces` 的按名称兜底）：两边都有坐标却超 1km
+   不再配对，改报「备份新增 + 仅站内有」；任一侧无坐标时保持旧行为。
+   ⚠️ **量纲坑**：`geo.Haversine` 返回**公里**不是米（列名 `distance_km` 可佐证），我第一次写成
+   `nameMatchMaxM = 1000.0` 导致用例直接抓到 `TestDiffPlacesNameFallbackNeedsNearby` 变红。
+2. `visitFieldChanges` 的「地点」在**名称相同时**用 `coordSuffix` 把坐标印出来（`name (lat, lon)`，
+   无坐标则 `（无坐标）`），否则那一行看着像没变化、站长无从选择。
+3. 用例 3 条：`TestDiffPlacesNameFallbackNeedsNearby`、`TestDiffPlacesNameFallbackKeepsNearbyCoordFix`、
+   `TestDiffVisitsPlaceConflictShowsCoords`；变异验证全过（去掉距离判断 / 去掉坐标显示 → 对应用例变红）。
+
+**复测（回滚 → 按浏览器默认全选「用实机」重跑，49 组冲突）**：地点新增 67→68、仅站内有 3→4；
+后台回执「新增 68 地点 / 1 活动 / 134 到访；更新 27 地点 / 16 活动 / 6 到访」；
+**「被搬动超过 1km 的地点 = 0 个」**（修复前是 1 个 236.8km）；`中国体育彩票` src_pk=71 仍是贺州 ✓；
+合并后再比对：到访 0/47/1、地点 0/4/1、活动 0/0/0；953 条 UUID 到访全命中、到达时间 0 偏差。
+残余 1 对冲突现在渲染成 `地点 茶颜悦色 (28.181954, 112.986995) → 茶颜悦色 (28.242581, 113.037061)`。
+
+**仍未处理**：`mergePlaces` 的 `placeID` 映射仍是单槽位 byCoord/byName（多条同名备份地点会并到同一个
+站内地点；这次被差异层拦住了，但换数据顺序仍可能让到访挂错分店）。
+
+**方法备忘**：临时探针测试 `ROND_PROBE=1` + `ROND_PROBE_DSN`（可指向从 dump 恢复的独立库）
++ `ROND_PROBE_STASH`（备份暂存路径），走 `srv.loadStored*/parseBackupFile` 真实路径打差异，
+跑完即删；`psql -c` 里带中文会因 Windows 代码页报 `无效的 "UTF8" 编码字节顺序`，**用 heredoc**。
+「按浏览器默认合并」= 从差异页正则抓 `name="(vc_|pc_|ac_)..." value="backup"` 全部提交；
+**这一点很关键**：早先的手写测试只提交 `add_new=1`，走的是「冲突默认保留站内」那条路，与站长点一下
+「合并」的真实行为（全部「用实机」）完全不同。
+
+## 第二轮（用户要求）：修 mergePlaces 的单槽位映射
+
+**病因**：差异层虽然已经不错配了，但 `mergePlaces` 自己又用**单槽位** `byCoord`/`byName` 配了一遍，
+多条同名备份地点全映射到同一行站内地点 → 到访挂到错的分店。
+
+**修法（结构性，不是再抄一遍逻辑）**：抽出 `rond.MatchPlaces(stored, backup) PlaceMatch`
+（坐标优先 + ≤1km 同名兜底 + 多值索引 take），**差异判定与合并执行共用这一份**；
+`mergePlaces` 直接用它的结果，再叠加 `plan.AddPlaces` 的新插入。
+`loadStoredPlaces` 与 `mergePlaces` 的地点查询都加 `ORDER BY id`（候选多于一个时靠顺序定谁配谁，
+两侧必须一致）。顺手删了两个只写不读的死字段 `PlacePatch.CoordKey`、`ActivityPatch.Key`。
+
+**新用例**：`TestMatchPlacesKeepsDuplicateNameGroupsDistinct`（同一坐标 / 邻近同名都要一条配一条）、
+`TestMergePlacesMapsSameNameLocationsOneToOne`（真库+真事务，两条同名备份地点必须映射到两条不同地点）；
+变异验证：认领不标记已用 → rond 用例红；恢复单槽位映射 → web 用例红（41→1195893、42→1195893）。
+
+**复测（探针库，不动本地真库）**：差异页 到访 134/47/6、地点 68/4/27、活动 1/0/16；49 组「用实机」；
+回执「新增 68 地点 / 1 活动 / 134 到访；更新 27 地点 / 16 活动 / 6 到访」→ 1001 / 436 / 32 / 815 / 589。
+两条不变量：**地点被搬动 >1km = 0**；**到访挂错地点（>1km）= 0 / 953 条**。
+合并后再比对三类全 0（到访 0/47/0、地点 0/4/0、活动 0/0/0），再点合并「没有要写入的改动」。
+⇒ **一次按默认点合并即可让差异全部归零**（上一轮残留的那 1 对「茶颜悦色」冲突，根因就是到访挂在
+8.3km 外另一家分店）。
+
+## 第三轮：生产导出被 rond 拒收「备份恢复失败，你的当前数据未被更改」
+
+用户在生产导出 `data/20260914_151649-export-...-export-20260929.rondbackup`（2.93MB）后导不回 rond。
+
+**取证顺序（可复用）**：
+1. `tools/verify_export_structure.py rondbackup <参照> <导出>` —— 表/索引/`CREATE TABLE`/列定义/zip 条目/
+   关键不变量全部一致；`Z_METADATA.Z_PLIST`、`Z_MODELCACHE` 也**逐字节相同**（我自己另验的）；
+   关系完整性 0 悬空（对比参照反而有 2 条：那是旧代码的缺陷，本次已修）。
+2. 写 `tools/audit_export_nulls.py <参照> <导出>` 做**逐列空值画像 + 全关系列悬空 + Z_MAX**：
+   参照里 0 个 NULL、导出里却有的列 = 形状违规。当场只抓到两条：
+   - `ZACTIVITY.ZCOLOR_`：参照 0 → 导出 **1**（33 行里）
+   - `ZLOCATION.ZISOCOUNTRYCODE`：参照 0 → 导出 23 —— **但它不是违规**（真机自己的 09-14 包里就有 1 个 NULL，
+     说明该列容忍 NULL；跳过）
+
+**根因链**：站内「地点补全」建活动时写 `color=''`、`icon=''`（`internal/web/fillup.go` 的 INSERT）
+→ 导出侧 `ns()` 把**空串也当空** → 图标有 `📍` 兜底、**颜色没有** → 写出 `ZACTIVITY.ZCOLOR_ = NULL`
+→ 真机这一列在任何包里都是 0 NULL/0 空串（扫了 data/ + storage/ 全部 15 个包，只有出事的那份有 1 个空）
+→ Core Data 判成损坏数据 → 整包拒收。
+
+**修复（`internal/rond/export.go`）**：加 `activityPlaceholderColor = "gray"`（与 `transportPlaceholderColor`
+同一套写法），导出活动时 `color` 为空则兜底；并把 `TestExportNeverNullsColumnsTheDeviceAlwaysFills`
+（通用守卫：基线里 0 NULL 的列，导出新行也不许 NULL）补上「没选颜色的活动」场景。
+变异验证：去掉兜底 → 两条断言都红（提示语正好复刻生产现象）。全量验收 293 PASS / 0 SKIP。
+
+**顺手交付**：`data/...-export-20260929-fixed-activity-color.rondbackup` —— 只把 `ZACTIVITY.Z_PK=33` 那格
+改成 `'gray'` 的停gap包（`Z_PLIST`/`Z_MODELCACHE` 逐字节未变、zip 仍 Store、`integrity_check` ok），
+用户可不等重新部署直接导入。
+
+⚠️ 遗留（非违规、未改）：`ZLOCATION.ZISOCOUNTRYCODE` 有 23 个 NULL（真机同类位置写的是 `''`）；
+另：包里比实机多一个站内自建活动「一般公共场所」，导入后可能看着多余。
+
+## 第四轮：导出被拒的第二个坑（也是主因）——交通方式编号空间串了
+
+用户把最新源码（含颜色兜底）部署到生产、重新导出 `data/20260929.rondbackup`，**依旧导不回 rond**。
+
+**关键取证方法**：拿**最后一次被真机接受的包** `data/20260920-fixed-A-数据修复.rondbackup`（09-20 记录里
+写着「✅ 结案：A 包导入成功」）当参照，与新导出逐项对比：
+- SQLite 头（page_size/encoding/user_version/application_id/auto_vacuum）✓、31 表 / 47 索引 / CREATE 语句 /
+  列定义 ✓、`Z_METADATA.Z_PLIST` 与 `Z_MODELCACHE` **逐字节相同** ✓
+- 值类型分布（typeof 集合）✓、文本无 NUL/非法 UTF-8 ✓、BLOB 长度集合 ✓、UUID 全 16 字节且无重复 ✓
+- 关系完整性 ✓、`Z_OPT` 全 1 ✓、行级时间不变量 ✓
+- **唯一差异：新导出的 `ZTRANSPORT` 里有两条同名「公交」（Z_PK 2 与 4），而真机与 A 包都只有一条**
+
+**根因**：`mergeVisits` 把**实机的 ZTRANSPORT 编号原样写进** `movements.transport_src`。站点没有交通方式表，
+方式只活在位移的 transport_* 四列里，而两套编号空间的同一个数字含义不同（实测 src=4：站点=电🐔、实机=公交）。
+于是同一个 src 带着两种含义 → 导出按 src 聚合时只能取一个名字 → 另一种含义的位移挂错方式，更糟的是吐出两条
+同名方式（真机整包拒收）。本地库实测：src 3/4/5/6 都撞了（3=高铁|地铁、4=电🐔|公交、5=地铁|高铁、6=步行|电🐔）。
+
+**修复（两处）**：
+1. 合并侧 `mergeVisits`：按**名称**把实机方式归一到站点编号（已有同名就沿用它的号，没有才 `nextSrcPK(
+   transportSeq)` 新发一个）——新增 `(*Server).transportsByName`。
+2. 导出侧 `queryTransports`：改为**按名称归组**（名称就是身份），用量最多的名称优先认领编号，其余编号的位移
+   改挂过去；并把「基线里同名但编号已被归并掉」的旧行删掉（否则 `keepMissing` 把它原样带回、又是两条同名）。
+   ⚠️ 这段清理必须放在**所有托管表写完之后**（我最初放在交通方式段里，兜底判据看到的是基线里还没重写的
+   ZMOVEMENT，误以为还有位移指着旧行就跳过了删除）。
+
+**效果（本地真实数据，同一形状）**：方式恢复成站点原本那套 1火车/2公交/3高铁/4电🐔/5地铁/6步行，无重名；
+位移各挂回自己的方式（电🐔 336、地铁 25、高铁 23、公交 19、火车 9、步行 3——修复前只有 6 条能对上）。
+
+**用例**：`TestExportMergesDuplicateTransportNames`（同名归并 + 位移挂回自己那条 + 无悬空）、
+`TestMergeKeepsTransportNumberingConsistent`（合并后同一 transport_src 不许有两种名称；⚠️ 这条第一次写成了
+**空用例**——夹具里没有新增到访就不会插入位移，必须先按站点方式删一条带方式的位移的端点到访，并加哨兵断言
+「位移确实被补回来了」）。变异验证：去掉改挂 → 导出用例红；去掉旧行清理 → 红；合并侧照抄实机编号 → 合并用例红。
+
+⚠️ 教训：**「导出包」里每条位移的方式名已经丢了**（导出时被压成 src 的一个名字），所以「把生产包重新导入本地
+再导出」并不能修复它——只有**在生产库上用修好的导出器重新导出**才行（生产库的 `movements.transport_name`
+还留着每条位移的真实名称）。给用户的停gap 文件属于「能否导入」的探针，其方式标注是近似值。
+
+
+## 第五轮：真凶是 zip 的 data descriptor（第九次才找到）
+
+用最新源码在生产导出 `data/20260929v2.rondbackup`，**依旧被拒**。此时 v2 已通过所有机械判据
+（空值画像 0 项、悬空 0、Z_MAX、全列重复扫描、与可导入 A 包的完整深度对比**到处一致**）。
+
+**突破口：zip 层的 flag bit 3（data descriptor）。**
+
+| 包 | 本地头 flags | csize/usize | 结果 |
+| --- | --- | --- | --- |
+| 所有 **Go 写的站点导出**（09-16 起每一份） | **0x0008** | **0/0** | 全部被拒 |
+| `20260920-fixed-A-数据修复`（**Python 重打包**） | **0x0000** | 有值 | **真机接受** |
+| 真机自己的包 | 0x0800（UTF-8 标志） | 有值 | 正常 |
+
+Go 的 `zip.Writer` 默认走流式写入：本地头里长度/CRC 留 0、把真值挪到条目尾部的描述符里并置上 bit3。
+**真机的读取器只认「本地头里就写着长度」的条目**，遇到直接判成损坏 → 「备份恢复失败，你的当前数据未被更改」。
+⇒ 09-20 那次「修悬空引用 + 补交通方式颜色」后能导入，其实是因为那份包被 **Python 重新打包**过，
+真正的病根（zip 写法）一直没被发现；这解释了为什么 09-29 一整天「修内容」全部无效。
+
+**修复**：`zipBackup` 用 `zw.CreateRaw(&zip.FileHeader{... CRC32/CompressedSize64/UncompressedSize64})`
+（先把三文件读进内存，3MB 无所谓），不再用 `CreateHeader`。
+新增用例 `TestZipBackupWritesNoDataDescriptor`（直接读**第 0 个条目的本地头**，断言 bit3 为 0 且
+长度/CRC 非 0；变异：改回 `CreateHeader` → 立刻变红 ✔）。真实数据验证：新导出的本地头 flags=0x0000 ✓。
+
+**给用户的即时探针**：`data/20260929v2-reframed-zip.rondbackup`——把 v2 的三个条目原样解出、用 Python
+重新打包（内容逐字节一致，只修 framing）⇒ 若它能导入，即坐实根因。
+
+
+## 第六轮：真机对照实验——`ZISOCOUNTRYCODE` 写空串会让整包被拒（我今天引入的回归，已撤销）
+
+用户拿四份包在真机上做对照：
+
+| 包 | 与 v2 的唯一差异 | 结果 |
+| --- | --- | --- |
+| `probe1-country-null` | 国家码 `''` → **NULL** | **能导入** ✓（但重启后软件里没数据，见下） |
+| `probe2-category-a` | 分类列回退到 A 的取值 | 导入失败 |
+| `probe3-country-and-category` | 上面两处都回退 | 导入失败 |
+| `20260920-fixed-A`（09-20 被接受过） | — | 用户未回报 |
+
+⇒ **`ZLOCATION.ZISOCOUNTRYCODE = ''` 是拦路虎**：真机包里确实有 19 行是 `''`（它自己写得出），
+但**导入侧不吃**——同一份内容、同一台设备，只把这一列从 NULL 改成 `''` 就从「能导入」变成
+「备份恢复失败」。所以「按真机形状补空串」是有害的回归（`d5e96ed` 已撤销，改成原样写 NULL）。
+⚠️ 教训：**真机写得出 ≠ 真机吃得回**；形状美化要拿真机实测，别靠统计推断。
+
+**仍未解决（新问题）**：probe1 能导入，但**重启软件后没有任何数据**。两种可能，需要区分：
+(a) 老数据还在、只是导入的东西没出现在界面（例如被当成另一个「库/数据集」导入）；
+(b) 整个 app 变空（store 被替换但 Core Data 打不开 → 回落到空库）。
+待问用户：rond 是否有「库/数据集」切换？上次成功是哪一步？
+另一个待验证点：`Z_METADATA.Z_UUID`（我方导出固定为基线链的 `FB9A80D0-...`）。若用户手机当前
+store 的 UUID 不同（曾重装/重建过 store），导入可能落到另一个库 ⇒ 表现为「没有数据」。
+→ 让用户**现在从 rond 重新导一份**，对比其 Z_UUID 即可判定，同时这份也是「app 自身往返」的对照。
+
+
+## 第七轮：app 自身「变空后」导出的包（`data/20260929_152324.rondbackup`）与新的行为画像
+
+用户的补充实验把行为画像讲清楚了：
+- **app 数据被清空时**：我方包**能导入**（但**有概率**失败——暗示超时/资源或竞态，不是纯内容校验）
+- **app 里有数据时**：导入会**先把库清空、然后数据没写进去** → app 变空（用户实测并导出为空库包）
+- `probe1`（国家码 NULL）在有数据时也不行；`probe2/3`（含分类回退）在有数据时也失败
+
+**空库包给出的事实**：
+- `Z_PLIST`/`Z_MODELCACHE` 与真机 09-28、我方导出**逐字节相同** ⇒ **不是 app 版本/模型变更**
+- `Z_UUID` 每份不同（空库 `1760D9F5…` / 真机 09-28 `DCBAE704…` / 我方 `FB9A80D0…`），而 09-20 被接受的
+  A 包用的正是 `FB9A80D0` ⇒ **库标识不是门禁**（可排除）
+- 空库 = 19 个 Z_PRIMARYKEY 行（少 CHANGE/TRANSACTION/TRANSACTIONSTRING 三个历史实体）、各表 0 行、历史 0 行
+  ⇒ 是干净的最小 store，结构没问题
+- 我方 vs 真机 Z_MAX 全部 ≥ 各自实际最大 Z_PK；`RawVisit 我方 2246 < 真机 2314`、`CHANGE 4810 < 5171`
+  只是数据量不同，不构成冲突
+
+**又补查了两处盲区（均干净）**：全表 REAL/INTEGER 列的 NaN/Inf 与范围（无异常）、所有时间列（Apple epoch）
+范围（都在合理区间，无哨兵错写）。
+
+**当前最强假设**：app 的导入是「合并式」的——**空库时能落地，有数据时因为与现有行冲突/或清空后落库失败而变空**。
+验证路径：把**真机自己的 09-28 包**导进**当前的空 app**：
+- 若能导入且**有数据** ⇒ app 的导入机制没问题 ⇒ 差异在我方导出的内容里，接下来按表二分；
+- 若也失败/也变空 ⇒ app 导入机制本身坏了（app 侧问题），与站点导出无关。
+
+**新探针**：`data/probe4-no-history.rondbackup`＝已有 probe1 的数据 + **清空 ACHANGE/ATRANSACTION\* 与对应 Z_MAX**
+（单变量测试「持久化历史表是否让 app 变空」）。
+
+
+## 第八轮：决定性对照——真机自己的 09-28 包能导入且能展示
+
+用户实测：**`data/20260928_183908.rondbackup`（真机 09-28，955 到访）导入成功，重启后数据正常展示** ✓；
+且 rond **没有「库/数据集」切换入口** ✓。
+
+⇒ **app 的导入机制是好的**，问题在**我方导出的内容**里 ✓✓（此前所有「app 侧/版本/库标识」的猜测全部排除）。
+
+**二分探针（交叉包，各只换一半）**：
+- `data/probe6-our-skeleton-device-data.rondbackup` = **我方骨架**（ZRAWVISIT 2244 / ACHANGE 4810 / 实体 22）
+  + **真机的托管表**（955 到访 / 432 地点 / 32 活动）✓ integrity ok
+  ⇒ 若这份**失败/无数据** ⇒ 病根在**骨架侧**（未托管的原始采样点、持久化历史、元数据、关联表）
+- `data/probe5-device-skeleton-our-data.rondbackup` = **真机骨架**（ZRAWVISIT 2314 / ACHANGE 5171）
+  + **我方托管表**（994 到访 / 433 地点 / 33 活动）✓ integrity ok
+  ⇒ 若这份**失败/无数据** ⇒ 病根在**我方托管数据**里（下一步按表二分）
+
+⚠️ 造包踩坑记录：真机包的**数据在 `-wal` 里**（主库只有 356KB）。第一次造 probe5 时我只复制了主库文件，
+结果造出一份「骨架全空」的坏包（ZRAWVISIT=0 / ACHANGE=0 / 实体 19）——**必须先连 wal 一起解出来并
+`PRAGMA wal_checkpoint(TRUNCATE)`，再复制/改动**。核对方法：造完必查关键表行数与实体数。
+
+
+## 第九轮【结案】：真正的原因是**编号空间（PK）不同**，不是数据缺什么
+
+用户实测：真机自己的 09-28 包导入成功且**展示正常**；我方导出（含各种修好的变体）一律失败或落库为空；
+rond 没有「库/数据集」切换。⇒ app 的导入机制没问题，问题在**我方导出的编号**。
+
+**决定性证据（按 UUID 对齐同一批到访，真机 09-28 vs 我方导出）**：
+
+| 列 | 不同的行数 | 说明 |
+| --- | --- | --- |
+| `ZVISIT.ZLOCATION` | **920 / 920** | 例：真机指向 `#134`「河池市国民体质监测中心」(24.69183,108.03527)，我方指向 `#188`——**同名同坐标**；而真机的 `#134` 在我方库里是「穿山景区-观景台」 |
+| `ZVISIT.ZACTIVITY_` | **903 / 920** | 例：真机 `#29`「家」（同坐标）vs 我方 `#196`「家」 |
+| `ZRAW` / `ZMERGEDTO` / `ZPARENT` | 783 / 52 / 10 | 附属字段 |
+
+⇒ 同一个到访在两边指向**语义相同、编号完全不同**的地点/活动。**地点与活动没有 UUID**（只有到访有），
+所以 app 恢复时只能靠编号解引用 ⇒ 我们每个到访都指向错的对象（或不存在） ⇒ **数据落不进去 / 落进去也看不见**。
+这也解释了为什么真机自己的包永远没问题（编号自洽），以及为什么前面修内容（颜色/交通方式/历史）全都无效。
+
+**根因**：站点的 `src_pk` 与手机 store 的 `Z_PK` 不是一套编号——站点的基线本身是**导出包**（导入-导出循环），
+PK 早已漂移；导出时直接把站点编号写回，app 那边就对不上。这正是项目笔记里「基线不能用导出包」的
+**实际后果**（以前只知道会「退化」，现在知道会**编号错位**）。
+
+**可用的修法（无需改代码，用现成功能）**：让**真机包成为数据集基线**：
+1. 从 rond 重新导出一份（编号 = 手机当前 store）；
+2. 在站点把它作为**新数据集**上传（基线就是它，编号即手机编号）；
+3. 在这个新数据集上，把旧站点导出包当「备份」合并进来（冲突选「用实机」= 保留站点侧的值）；
+   —— 合并走 `mergePlaces`/`mergeVisits`：**更新的是数据集自己那几行**（`UPDATE ... WHERE id=<数据集行 id>`），
+   新行才用 `nextSrcPK` 取号 ⇒ **合并后编号仍是手机编号空间**（已从代码确认）；
+4. 从这个数据集导出 → 导入 rond ⇒ 编号能对上，数据可展示。
+
+**持久修法（待批准）**：导出侧做「按身份重新编号」——地点按 (坐标,名称)、活动/到访按 UUID、位移/天气按
+所属到访与时间对齐到**基线的 PK**；站点新建的行取基线 Z_MAX 之上的新号。这样任何一次导出都与手机编号对齐。
+
+**探针教训**：probe5/probe6（半真机半我方）都失败——**交叉包会混出新的不一致**（引用与编号错位），
+不适合做二分；二分要在**同一编号空间内**做。另外真机包的**数据在 `-wal` 里**（主库只有 356KB），
+造包必须先连 wal 解出并 `wal_checkpoint(TRUNCATE)`，造完核对关键表行数。
+
+**本地库已还原**：测试留下的数据集 152 已连同 11 张表的关联行清掉，生效数据集恢复为 9 号
+（1001 到访 / 436 地点）。
+
+
+## 第十轮：实现「编号对齐」的持久修法（用户批准）
+
+新增 `internal/rond/export_align.go`：导出时把托管表的行**按身份重新编号到基线的编号空间**
+（基线是这份数据集从手机那儿来的那个 store，所以对齐基线 = 对齐手机）：
+
+- 地点：**坐标键优先**（多值索引，同坐标重复行按序认领），退到「同名且 ≤1km」
+- 活动 / 到访：UUID（读留档 `entity_raw` 的 `ZUID_` / `ZIDENTIFIER_`）
+- 标签 / 交通方式：名称；位移 / 天气：所属到访（已对齐）
+- 基线里没有身份对应的（站点新建的）行，取基线最大编号之上的新号，分配顺序固定
+
+导出流程改动：每张表先建映射再写，写回用 `outPK`；引用（`ZVISIT.ZLOCATION`/`ZACTIVITY_`、
+`ZMOVEMENT.ZVISITFROM_/TO_/ZTRANSPORT_`、`ZHOURLYWEATHER.ZVISIT`）全部改挂；
+`ZVISIT.ZMERGEDTO`/`ZPARENT` 加入托管列并列并**按映射改挂**（留档里是站点编号，不改挂会指错/悬空）；
+`Z_PRIMARYKEY.Z_MAX` 改用「实际写入的编号」；基线的身份查询都加 `ORDER BY Z_PK` 保证确定性。
+
+**验证（决定性）**：本地数据集 9（编号已漂移）+ 真机 09-28 包当基线导出后，按 UUID 对齐的 953 条
+共同到访里，**地点引用一致 933、活动引用一致 951**（修复前是 0 / 7）；剩余 20 条是基线自己重名重复行的
+1:1 归属歧义（名称与坐标相同）。悬空引用 0。
+**用例** `TestExportAlignsPKsToBaseline`（package web）：把库里编号整体平移 500000（模拟「数据来自编号
+完全不同的备份」）再导出，断言**按 UUID 对齐后地点/活动的编号与基线一致率 ≥95%** + 7 类引用无悬空。
+⚠️ 第一版用例只比「名称+坐标」，变异验证时**没变红**（编号不一致但引用自洽，语义检查查不出来）——
+必须比**编号本身**。加强后变异（不做地点对齐）→ 地点一致率 0/822，用例变红 ✓。
+另外：`byCoord` 一开始写成单槽位，同坐标的重复行只能配一条 ⇒ 一致率只有 797/822；改成多值索引后 822/822。
+
+
+## 第十一轮：编号对齐的**首次实现已撤回**（未通过往返测试，未入库）
+
+第十轮那版「按身份重新编号」在**真实数据上验证通过**（本地数据集 + 真机 09-28 当基线：
+953 条共同到访里地点引用一致 933、活动一致 951；回归用例 `TestExportAlignsPKsToBaseline`
+把编号平移 500000 后**地点/活动编号一致率 822/822**，变异验证也会变红），但**两条既有用例被打破**：
+
+1. `TestExportNeverNullsColumnsTheDeviceAlwaysFills`：它按「站点 src_pk」去找新建的活动
+   （`WHERE Z_PK=950001`），而对齐会把它放到「基线最大编号之上」的新号 ⇒ 找不到。属**用例假设**问题，
+   改成按名称/UUID 查即可。
+2. **`TestExportRoundtrip`（核心不变量）**：往返（基线 = 源包本身）本应保持编号不变，却报
+   「导出多出到访 825」⇒ 大量到访被当成了新行。**未在预算内查清原因**，因此整版撤回（`git checkout`
+   + 删掉 `export_align.go` / `export_align_test.go`），保持仓库全绿（两条用例已复跑通过）。
+
+**下一轮排查线索**（按嫌疑排序）：
+- `visitsPKs/actsPKs/...` 这类 helper 返回的字段（要用 `SrcPK`，若返回 PG 的 `ID` 就会全体对不上）；
+- `siteUUIDMap` 的 SQL 在**fixture 数据集**上的返回（我已在 dataset 9 上验证 `encode(decode(...))`
+  与 web 侧 hex 一致，但没在 fixture 上验过）；
+- `alignUUIDs` 里「匹配上却拿到新号」的分支条件（`used` 复用/`known` 判定）。
+
+**重要**：对齐只是「让导出的编号回到基线」，而**基线本身在哪**才是关键——所以即便不做代码改动，
+**用「以真机包为基线的数据集」照样能让编号对齐**（见第九轮的配方，`mergePlaces`/`mergeVisits`
+更新的是数据集自己那几行、新行才另取号，已在代码层面确认）。这条路径**今天就能用**。
+
+
+## 第十二轮：编号对齐定稿（往返失败的真因 = 那条「没有 UUID 的空到访」）
+
+重做实现后带 `ROND_ALIGN_DEBUG=1` 打印每张表的映射规模，夹具上一切正常
+（ZLOCATION 323/323、ZACTIVITY 30/30、ZTAG 8/8、ZTRANSPORT 5/5、ZMOVEMENT 791/791、
+ZHOURLYWEATHER 557/557，**只有 ZVISIT 是 822/823**）——落在夹具上跑本来就是对齐的幂等情形。
+
+跑 `TestExportRoundtrip` 才看清：包内计数完全一致（823 到访 / 323 地点 / …），只有一条
+「导出多出到访 **825**」⇒ 那**唯一一条没匹配上的到访**（= 没有 UUID 的「全空到访」，真机包里也
+在、留档里没有它的身份）被重新发号成了 825。
+
+**修法（关键的一条规则）**：身份匹配不上的行，**若它自己的编号没被别的身份占用，就保持原编号**；
+只有被占用时才另发新号。这样：
+- 往返导出（基线就是源包）**一行都不动** ⇒ `TestExportRoundtrip` 通过；
+- 编号漂移过的库，匹配上的行照旧被拉回基线编号（对齐用例 822/822）。
+（这也避免了「把基线的行覆盖成另一条记录」的情况：被占用说明那个编号在基线里属于别的身份。）
+
+配合的另一个改动：`siteUUIDMap` 改为**读出 base64 字符串后在 Go 里解码**（与 web 侧
+`loadStoredVisits` 同一手法），不再在 SQL 里 `decode/encode` 拼——第一版就是因为这个
+（或与此相关）导致大量行匹配不上。
+
+
+## 第十三轮：「数据双份」的真相 = 站点数据里的历史重复条目（不是导入 bug）
+
+用户以手机包 `20260928_183908.rondbackup` 为数据集、导入生产导出
+`20260928_183908-export-20260929.rondbackup`，**清除 app 数据后导入仍看到「重复」**。
+
+核对两份包：生产导出 **1027 到访 / 433 地点**，其中 `ZMERGEDTO` 56 + `ZPARENT` 10（已并入的隐藏记录）；
+app 显示 **965 到访 / 388 地点** ⇒ 388 ≈ 包内「有到访的地点」390 ✓、965 ≈ 1027 − 隐藏的那些 ✓
+⇒ **导入本身是成功的、app 里就是这份包的数据**（我上一轮「rond 是追加式」的判断错了）。
+
+真正多出来的是**站点侧的历史重复条目**：**72 条**到访与手机包里某条**到达时间 + 地点完全相同**、
+但 UUID 不同（手机包自身也有 31 组这种成对条目，那是 app 自己产生的，合法）。合并按 UUID 认人 ⇒
+站点那条被判成「备份新增」⇒ app 里出现成对的两条。
+
+**处理**：写脚本（以手机包为参照）删掉这 72 条站点侧副本 + 其附属（位移/天气/原始采样），
+并把指向它们的 `ZMERGEDTO`/`ZPARENT` 改指到保留项（否则会把已并入的记录放出来）。自检：
+到访 955（= 手机包）、重复 UUID 0、(时间,地点) 重复正好 31 组（= 手机包自身）、悬空引用 0、
+zip framing 0x0000 ✓。产物 `data/20260928_183908-export-20260929-dedup.rondbackup` +
+清单 `storage/.mergetest/站点侧重复到访清单.csv`。
+
+⚠️ 教训：**去重必须以手机包为参照**（先判「UUID 在不在手机包里」），只按 (时间,地点) 判会把手机包
+自身合法的成对条目一起删掉（第一版就这么错了：955 → 924）。
+永久修法应在**站点侧**清掉这些副本（否则下次导出还会带出来）；可行做法是给 CLI 加 `dedup`，
+参照即数据集的基线（手机包）。
+
+
+## 更正：CLI 名字记混了
+
+本项目（rond-with-you）**没有 `cmd/` 目录、没有子命令 CLI** —— 之前笔记里「管理 CLI（`TamaBox <cmd>`）、
+注册在 `cmd/tamabox.go`」是**另一个项目（TamaBox）**的东西，被我串到这边的笔记里了。本项目的维护脚本
+都在 `tools/*.py`（verify_export_structure.py / verify_rondbackup.py / photo_coord_audit.py / audit_export_nulls.py）。
+
+新增 `tools/dedup_site_visits.py`：以**手机包为参照**清掉站点侧的历史重复到访（默认只预演，
+`--apply` 才删；连带处理位移/天气/留档，并把指向副本的 ZMERGEDTO/ZPARENT 改指到保留项）。
+状态：**已完成并在真实数据上演练通过**。踩了两个 PG 坑：
+  1. `raw->>` 是 text，与数字比较报「text = integer 操作符不存在」→ 工具在动手前整个退出（预演没事、
+     一旦 --apply 就 exit 1）⇒ 必须按字符串比 `(raw->>'ZMERGEDTO') = '956'`；
+  2. 同一 UPDATE 里给 raw 两次赋值报「对同一列 raw 进行了多次分配」⇒ jsonb_set 必须嵌套。
+演练（导入含 72 条副本的包 → --apply → 核对）：到访 1026→954、位移 833→809、天气 621→589
+（与手机包一致）；(时间,地点) 重复组 101→**31**（= 手机包自身）、悬空 0/0 ✓。
+站长也实测：去重后的包导入 rond **正常**了。生产用法（先预演）：
+`python tools/dedup_site_visits.py --dataset <id> --baseline <手机包.rondbackup> --db/--user/--password/--host ...`，
+确认后加 `--apply`。
+
+
+## 待办：「重复到访」清理做进页面（方案已获批，尚未动代码）
+
+用户要求「不能在页面上直接实现吗」→ 已给出变更清单并获批准（「就按你的默认去做」），**本轮未落地**（上下文预算耗尽，
+不愿留半成品在库里）。下一轮直接按这份清单写：
+
+**落点（已侦察）**：
+- 判定逻辑：与 `tools/dedup_site_visits.py` 同规则（UUID 不在基线里 + (到达时间, 地点) 与基线某条一致），
+  Go 侧新建 `internal/web/edit_duplicates.go`；参照 = `s.baselinePath(ds.ID)`（`internal/web/handlers_export.go:196`）。
+- ⚠️ `internal/web` **没有引 sqlite 驱动**（`grep modernc.org/sqlite internal/web/*.go` 为空）→ 读基线库需要
+  加 `_ "modernc.org/sqlite"` 的 import（或复用 `rond` 里现成的读取）。
+- 视图：编辑页的数据结构在 `internal/web/view.go:768` 附近（已有 `Activities []EditOption`、`TransportColors`），
+  加一个 `DupVisits []…` 字段；装配在 `internal/web/handlers_edit.go:25` 的 `editPage` 里（`d.Activities` 在 73 行附近）。
+- 模板：`internal/web/templates/admin/edit.html` 用 `<h3>活动</h3>` + `<div class="tw"><table class="tb tb-stack">` 的卡片风格
+  （活动卡片在 34 行附近）。**该模板只能用 shell 改**（用编辑工具会被注入 `data-page-node-id`）。
+- 路由：新增 POST（如 `/admin/edit/duplicate-visits`），照 `editActivityUpdate` 等的注册方式加。
+- 删除语义照 `editVisitDelete` + 工具已验证的那套：删副本 + 其 movements/weather/entity_raw，
+  并把指向副本的留档（`entity_raw.raw` 的 ZMERGEDTO/ZPARENT）**改指到保留项**（jsonb_set 要嵌套，
+  比较用字符串 `(raw->>'ZMERGEDTO')='956'`——这两个 PG 坑都踩过）。
+- 卡片只在检出 >0 时显示；基线不是手机包时显示一行灰字说明；提交要二次确认；做完闪信 + 刷新。
+- 用例：夹具里造一对副本 → 断言检出 1 对、清理后到访 −1、未勾选的不动、无悬空；然后全量验收。
+
+## 已落地：编辑页「重复到访」卡片（上一轮清单执行完毕）
+
+新增 `internal/web/edit_duplicates.go`（判定 + `editDuplicateVisitsApply` + `cleanDuplicateVisits`）、
+`EditData.DupVisits/DupUnavailable`（view.go）、`editPage` 装配、`POST /admin/edit/dup/clean`、edit.html 卡片（45 行纯新增，编辑工具这次没注入属性）、
+用例 `internal/web/dup_visits_test.go`（4 个）。判定照工具语义，UUID 是前提；与工具刻意不同的一处：改指合并标记只动本来就有的键
+（工具会凭空补 ZMERGEDTO）。变异验证 3 项全绿（其中「丢 UUID 前提」第一次漏判，补了定义性不变量才抓到）。
+
+顺带修了一个**导出必挂**的洞：`rond/export.go` 的 `queryWeather` 把 `is_daylight` 扫进裸 `bool`，
+而站点「新增天气」不写这一列 ⇒ 一补录天气，整包导出 303 +「备份恢复失败」一类报错。改成 `COALESCE(is_daylight,false)`（与 `parse.go` 同口径）。
+
+## 待用户拍板：时间线上的 ZMERGEDTO / ZPARENT 行
+
+用户报「生产+测试时间线上出现重复」，实测是**手机自己标的「已并入 / 子记录」行**（如 09-04 家 20:21 的 #422 `ZMERGEDTO=#562`），
+不是本卡片管的站点副本（那两条 UUID 都在手机包里，删了导出会丢合并信息）。全站没有任何查询识别这两个字段 ⇒ 时间线与日停留都重复计入。
+数据集 9：54 条 `ZMERGEDTO` + 10 条 `ZPARENT`，26 条并入行与原件到达时间相同。方案（A 加派生列 / B where 里 NOT EXISTS）已报给用户等选。
+
+## 验收：301 PASS / 0 FAIL / 0 SKIP（5m49s）
+
+**⚠️ 环境坑（这次卡了 1 小时，务必先做）**：
+- `rond_fog_test` 死元组膨胀到 **3311 MB**（`entity_raw` 2.2GB / places 378MB / visits 233MB），级联
+  `DELETE FROM users` 变成 IO 爬虫 ⇒ 全量验收跑 30 分钟都跑不完。`VACUUM (FULL, ANALYZE)` 后 **3311MB → 16MB**，
+  整套 5m49s 跑完。跑过几十轮全量后会再涨，卡了就先 VACUUM。
+- 库里**必须有生效数据集**：`SELECT id FROM datasets WHERE is_active LIMIT 1` 取不到时 `internal/stats` 的
+  6 个对照用例全 **SKIP**（假 skip，看着像「没环境变量」）。本次先 `UPDATE datasets SET is_active=(id=1)` 才 0 skip。
+- 验收跑着的时候**别并发跑定点测试**（同一个库，会加剧膨胀/timing）；中途 kill 测试进程还会留下孤儿 e2e 数据集
+  （fixture 只在自己正常退出时才清理）。
+- 结果：PASS=301（基线 297 + 本卡 4 个用例）/ FAIL=0 / SKIP=0；第一段纯净往返包 PASS。
+- 二进制已重编（`go build -o rond.exe .` + 拷进 `bin/`，旧版存 `bin/rond.exe.old-20260929d`），站点当时没在跑。
+
+## 已落地：已并入 / 子段到访在读的一侧收口（方案 A）
+
+用户报「生产+测试时间线上有重复」，实测是手机自带 `ZMERGEDTO`（已并入别处）/ `ZPARENT`（某个父段的子段）行：
+app 不单独显示、不计数，本站当成普通到访 ⇒ 时间线上「同时刻同地点两条」、日停留重复计入。
+**不能删**（导出要靠它认这次合并），所以判据只立一份 `stats.SoloVisitSQL`，在读的一侧收口：
+`visitsWhere`/`VisitsByPlace`/`Bookmarked`/`placeCols` 子查询、`handlers_public` 两处、`handlers_topics` 四处、
+三处聚合（ingest / refreshPlaceAgg / recountPlaces）的 count+dwell、`schema.sql` 一段幂等回填。
+**天气与位移不收口**（真实发生过）；**导出侧一个字节不动**（rond 不读 visit_count/dwell，只读 last_visit_at，保持全量）。
+
+审阅中发现并修掉的真 bug：**ingest 的地点聚合回填排在 `insertEntityRaw` 之前** ⇒ 判据读不到留档 ⇒ 每行都算独立到访
+（多算 62~64 条）。是新写的 `hidden_visit_test.go` 抓出来的。另一个是「0 次却有最近到访」（4 个地点），
+展示侧用 `CASE WHEN p.visit_count > 0` 兜住。
+
+实测：places 到访数合计 1001 → 937，停留 249769 → 222399 分（数据集 9，回填已在该库执行）。
+时间线查询 0.35ms → 3.5ms（42 次主键探测），Planning 3.6 → 6.4ms。
+
+验收：**301 → 305 PASS / 0 FAIL / 0 SKIP**（推送后复测也绿）（`internal/stats` 三个对照用例先红后绿：天气/位移一开始也继承了判据，
+`TestWeatherStatsRespectsFilter`、`TestVisitSideFiltersApplyToMovements` 立刻抓出来）。
+环境：一轮全量让测试库涨 ~370MB 死元组，跑前跑后各 `VACUUM (FULL, ANALYZE)`（16MB → 5m49s；385MB → 30 分钟未完）。
+
+## 审阅时又发现一个既有 bug：地图城市圈的「到访次数」差 128 倍
+
+`/api/cities` 把聚合打在 `places ⋈ visits` 上 ⇒ `sum(p.visit_count)` 按到访条数重复累加、`count(*)` 当成地点数。
+实测最大城市显示「到访 72661 次 · 568 个地点」，真值 568 次 / 86 个地点。改成「先按地点聚合、再按城市汇总」，
+并补上已并入/子段的判据；新增 `city_agg_test.go`（手写口径对账 + 变异验证）。
+
+## 收尾（最后一批）
+
+- `scripts/verify.sh`：库 ≥ 200MB 时先 `VACUUM (ANALYZE)`（只做普通版，FULL 会锁库把验收卡住）；
+  同一夹具用例 13.6s → 10.2s。
+- 城市圈首末到访改按可见到访算（`min/max(v.arrival)`），并补了**能区分**的断言：
+  把某地点最晚那次标成已并入后，城市最近到访必须从 09-13 退到 09-08（原来的同口径比对是假绿）。
+- README 补「重复到访卡片」「为什么有些到访在页面上看不到」+ 验收环境说明。
+- **明确不做的两项**（有实测理由）：派生列 `visits.solo`（LIMIT 下只 42 次探测，存列反而要跟着刷）、
+  改指语句批量化（会遇到「一行两个键指向不同副本」只改一个键的边界）。

.workbuddy/memory/2026-09-30.md

@@ -0,0 +1,279 @@
+# 2026-09-30
+
+## 生产时间线「部分重复部分没有」的根因与修复
+
+用户报 https://life.shiroko.one/timeline 上仍有重复。抓页面逐条比对：一屏 180 条里有 **53 对**
+到达时间、离开时间、停留时长**完全相同**的条目——与 09-04 那种「离开时间不同」的已并入行不同，
+`ZMERGEDTO`/`ZPARENT` 判据一条都收不到（43 对里隐藏侧 0）。
+
+真正成因：**站点补录的行没有留档 ⇒ 没有 UUID**，导出时被补上 `v5("ZVISIT/<src_pk>")`；这份包
+再合并回站点时站点侧没有 UUID 可对齐，被当成「备份新增」又插一条（41/43 的副本 UUID 正好等于
+配对行的派生 UUID，实测确认）。
+
+修：rond 里把派生 UUID 抽出来当**对账键**（`DerivedUUID`/`VisitMatchUUID`），差异与合并都用它；
+卡片新增第二类判定（成因「你补录的那条被合并回来的一份」），清理时把副本名下的位移/天气**改挂**
+到保留项。提交 `8dec973`（+ 格式 `aaf65f6`），已推送；全量验收随后跑。
+
+## 「本地测试要十几分钟」的根因：我昨天那个收口把页面拖成了 44~70 秒
+
+- 症状：最慢的 4 个用例占全套 55%（309s/274s/226s/115s），全是「渲染若干页面」的布局用例。
+- 定位：临时逐页计时探针（`/` 43.6s、`/places` 70.1s）→ 变异对照（关掉判据 0.28s）→ CPU profile
+  （135 秒只用 3 秒 CPU ⇒ 在等，不是算）。孤立的 EXPLAIN 只有 12~38ms，**会骗人**。
+- 根因：判据打在 `entity_raw.raw`（TOAST 过的整行 JSON）上，而 /places 是「每个地点 × 5 个子查询」。
+- 修：派生列 `visits.is_merged` + 刷新（ingest / recountPlaces）+ 部分索引；/places 70084ms → 206ms，
+  首页 43633ms → 698ms。新增 `page_render_budget_test.go`（7 个页面卡 10 秒的灾难探测器）。
+- 教训：**别拿单条查询的耗时判断整页性能**；「功能对、就是慢」的退化必须有守卫。
+
+## 生产导出 `data/20260930.rondbackup` 被真机拒收 —— 逐项排查（未定位到形状违规）
+
+按技能里「备份恢复失败」的排查顺序全跑了一遍，**每一层都与手机包/曾被接受的包同形**：
+1. 打包层（头号真凶）：本地头 bit3=0、长度非 0、条目名与顺序与 09-20 被接受的那份一致 ✓
+2. 模型骨架：表 31 / 索引 47 / CREATE TABLE 逐字符 / `Z_PLIST` sha256 / `Z_MODELCACHE` 16073B / `Z_UUID` / `Z_VERSION` —— 与 09-29v2 手机包**完全一致** ✓
+3. 逐列空值画像：唯一差异 `ZLOCATION.ZISOCOUNTRYCODE` 20 个 NULL。**这不是问题**——09-20 被接受过的包也是 23 个 NULL，
+   且 09-29 做过**真机对照实验**（同一份包唯一差异这列）：`''` 被拒、`NULL` 能导入（见 commit `d5e96ed`）⇒ NULL 是对的，
+   **别再去「补空串美化」**（我这次差点又去改它）。
+4. 关系完整性 0 悬空（含 `ZRAWVISIT→ZVISIT`、`ZVISIT.ZLOCATION/ZACTIVITY_`、自引用 `ZMERGEDTO/ZPARENT`）✓
+5. `Z_OPT` 全 ≥1、`Z_ENT` 与参照一致、`ZIDENTIFIER_` 16B 且唯一、值类型分布无新增类别、无非法 UTF-8、
+   行级时间不变量 0 违例、SQLite 文件头（页大小/WAL 版本/编码）一致 ✓
+6. 计数画像同形（1001 到访 / 64 隐藏 / 436 地点 / 392 有到访 / 交通方式 6 条无重名）✓
+7. 包里**仍有 43 组站内副本重复对**（就是 dedup 卡片要清的），但不影响导入 ✓
+
+**下一步（等用户）**：要报错原文 + 两个对照导入把范围切两半——
+`storage/.verify/acceptance-clean.rondbackup`（纯净往返）与 `data/20260920-fixed-A-数据修复.rondbackup`（曾成功）。
+若指向「站点数据」，就用这份失败包做行级二分（按 UUID 拆「手机原有的行」/「站内新建的行」）。
+
+## 拒收排查续：静态判据全过 ⇒ 转真机二分（工具已提交）
+
+用户确认：报错就是「备份恢复失败，你的当前数据未被修改」（QQ 传文件，同一路径传的另一份能导入）⇒
+**导出链路与 App 都没问题，问题在这份数据集的数据里**。
+
+静态排查全过（打包位标志 / Core Data 骨架逐字节 / 空值画像 / 关系完整性含自引用 / 类型分布 /
+Z_OPT·UUID·BLOB / 行级时间不变量 / 位移窗口不变量 / 取值域与数值范围 / SQLite 文件头）。
+顺手排掉四个「看着像」的：
+- `ZISOCOUNTRYCODE` 20 个 NULL：09-20 被接受过的包也是 23 个 NULL，且 09-29 真机对照实验证明「空串被拒、NULL 能进」⇒ 不是它；
+- 站内新建行的 v5 UUID：手机包自己就有 172 个 v5；
+- 43 组精确重复到访：**手机包自己就有 39 组** ⇒ 真机容忍；
+- 位移窗口越界：这份包 0 条（手机包自己倒有 2 条）。
+
+新增 `tools/bisect_export.py`：以被拒包为底生成 V1（去掉站内新建的 22 条到访）、
+V2（+3 个站内新建地点）、V3（手机里也有的行按手机原值重置），都已过审计（悬空 0 / Z_MAX 够 / 打包正常）。
+判读：哪一版开始能进，问题就在上一版删/改掉的那一类里；三版都进不去 ⇒ 问题在「行的集合」（删过/多过的行）。
+
+## 二分结果：V1 ✓ / V2 ✓ / V3 ✗ ⇒ 罪在「站内新建的那 22 条到访」（地点无辜）
+
+- V1（去掉 22 条）能导入、V2（再多去 3 个地点）也能导入、V3（全保留、但把手机里也有的行按手机原值重置）报错
+  ⇒ **问题在这 22 条到访本身或其附属记录**里，与地点、与「共享行被改过的值」无关。
+- 这 22 条的构成：`Z_PK=[46,200]+998..1017`。其中 **46/200 其实是基线（09-14 包）自己的行**
+  （同一 UUID、同一数据），只是**手机在 09-29 前把它们删掉了**（09-29v2 里没有这两个 UUID）——
+  所以「按 UUID 是否在手机包里」分类会把它们误判成站内新建。
+- 下一轮对照（都已过审计、位于 `data/bisect/`）：
+  `V4` = 保留这 22 条但删掉它们的附属记录（15 位移 / 16 天气 / 2 采样）；
+  `V5` = 删 `[46,200,998..1007]`；`V6` = 删 `[1008..1017]`。
+- 判读：V4 ✓ ⇒ 罪在附属记录；V5/V6 哪个 ✓ ⇒ 罪在另一半的那 10~12 条里，继续对半拆。
+
+## 二分第二轮：V4 ✗ / V5 ✓ / V6 ✗ ⇒ 罪在 [46,200,998~1007]，再收紧到 [998~1007]
+
+- V4（保留 22 条、只删它们的附属记录）**报错** ⇒ 附属记录（15 位移 / 16 天气 / 2 采样）无罪；
+- V5（删 [46,200,998~1007]）**能进**、V6（删 [1008~1017]）报错 ⇒ 罪在 V5 删掉的那 12 条里；
+- **46/200 被排除**：它们就是基线自己的行（同 UUID 同数据），而**纯净往返包里也有这两行且能导入** ✓
+  ⇒ 罪在 **[998~1007] 这 10 条站内新建行本身**（其余一切都已被 V5 证明是兼容的）。
+- 静态差分：这 10 条与无辜的 [1008~1017] **逐列完全同形**（同为 v5 UUID、同标志位、ZRAW 都有值、TZ 都是 NULL）
+  —— 看不出任何结构差异，只能继续对半。
+- 第三轮：`V10` = 删 [998~1002]、`V11` = 删 [1003~1007]（都在 `data/bisect/`）。
+
+## 二分定案：罪魁是 `ZVISIT #1000`（09-22 06:16→10:48，挂在重复地点 416 上）
+
+- 五个「只留一条」对照：**只有 P1000 报错**，P998/P999/P1001/P1002 都能导入 ⇒ 单条罪魁 = #1000。
+- 顺带排除的：重复地点本身（手机包自己就有 8 组同名同坐标且都带访，坐标连低位都相同）；
+  UUID（#1000 的 UUID 就是标准的 v5("ZVISIT/1000")，与兄弟们同形）；ZRAW 量级（2305 与手机的 2209 同量级）；
+  重复组的 ZLASTARRIVALDATE_ 规律（手机各组也是各成员各值）。
+- #1000 与四个无辜兄弟的**唯一差异 = 它的地点是 416**，而 416 是「广西壮族自治区邮政公司」的
+  **重复地点行**（与 417 同名同坐标全字段相同，只有 ZLASTARRIVALDATE_ 不同），且**只有 #1000 用它**；
+  V1/V2/V10 能导入，正是因为那时 #1000 已删、416 成了没有到访的空壳。
+- 判别包（都在 `data/bisect/`）：
+  `W1` = 只留 #1000 但把它的地点换成 417；`W2` = 只留 #1000 但把 416 的「最近到访」改成与 417 一致；
+  `W3` = 只留 #1000 但把 ZRAW 改成 1421。
+  W1 能进 ⇒ 罪在「416 这一行 / 这个对」；W1 报错而 W2/W3 能进 ⇒ 罪在 416 的 ZLASTARRIVALDATE_ 或采样数。
+
+## 定案：真机拒收的根因 = `ZVISIT.ZRAW` 超过包内采样行数（已修，commit `d99c63f`）
+
+- 判别包结果：**只有 W3 能进**（W1 改地点、W2 改「最近到访」都报错）⇒ 罪魁是 `ZVISIT #1000` 的
+  **`ZRAW = 2305`**（「这次到访由多少个原始采样点归并而来」的计数）。
+- 不变量：`ZRAW ≤ 包内 ZRAWVISIT 行数`。接受过的三份包（09-14 基线 / 09-20 A 包 / 验收纯净往返）
+  最大值都 ≤ 采样行数；被拒的那份只有 #1000 越界（2305 > 2246）。夹到 2246 以内即可导入
+  （W3 用 1421 验证过；被接受的包里 ZRAW 为 NULL/0 的行本来就有 39~139 条 ⇒ 往下夹安全）。
+- 成因链：合并进来的到访带着**源包**的 ZRAW，而源包的 `ZRAWVISIT` 采样行站点不托管（只从基线带）
+  ⇒ 计数与包内采样行数脱节。导出侧修法：写完行、清完悬空采样点之后，一条 UPDATE 把
+  `ZRAW` 夹到 `count(ZRAWVISIT)` 以内。用例 `TestExportClampsRawSampleCount`（变异验证过）。
+- 顺手：`readDupBaseline` 先 os.Stat（sql.Open 默认 READWRITE|CREATE，路径不存在会静默建空库，
+  报「no such table」而不是「没有基线」）。
+- 给用户的即时包：`data/20260930-fixed-zraw.rondbackup`（就是那份被拒的包，只把 #1000 的
+  ZRAW 2305→2246，其余一字未动，审计干净）。
+- 更彻底的做法（记着）：把数据集的**基线换成一份较新的手机包**——采样行来自基线，
+  基线越新，新到访的采样行越齐，`ZRAW` 也就天然自洽。
+
+## 基线替换：用户按链路操作，差异页显示「完全一致」（= 预期结果，不是失败）
+
+用户把 App 导出的 `20260930_180637.rondbackup` 直接导入成新数据集，再用旧的站点导出
+`20260930.rondbackup` 做差异合并 → 差异页说「与当前数据集完全一致：没有新增、没有被删、也没有冲突」。
+
+原因：喂给 App 的那份包**就是站点自己的导出**（`20260930-fixed-zraw.rondbackup` = 站点导出只夹了 ZRAW），
+所以 App 再导出来内容当然一样 ⇒ **换基线这一步已经达成**（新数据集的基线 = 一份新鲜手机包 ✓），
+清单里的「把旧站点导出合并进去」在他这条路径上是**多余的**（那一步是为「上传一份全新手机包、
+里面没有站点数据」的路径准备的）。
+
+顺带记：新数据集的收益主要是**编号/存储对齐**（App 导入时会重排 Z_PK，新数据集的 src_pk 与它的基线同一套）；
+采样行（ZRAWVISIT）**不会**因此变多——那些采样点从来不在我们的包里（真实缺失），
+以后靠导出侧的 ZRAW 夹取兜住即可。
+
+## 闭环完成：换基线成功并验证（2026-09-30 18:20）
+
+用户流程：App 导出的 `20260930_180637.rondbackup` 直接导入成新数据集 → 网页端显示 **937 条到访**
+（= 包内 1001 − 64 条隐藏行 ✓ 说明 App 那份把数据放在 `-wal`（3.16MB）里也被我们完整读入 ✓）→
+以它为基线在网页端导出 `20260930_180637-export-20260930.rondbackup` → **导入 App 正常** ✓✓。
+
+我这边独立验证（新导出 vs 新基线）：跨表计数 **全部 ±0**（1001 到访 / 436 地点 / 815 位移 / 589 天气 /
+2246 采样 / 6 方式 / 32 活动 / 8 标签）；表 31/31、索引 47/47、`CREATE TABLE` 逐字符、
+`Z_PLIST`/`Z_MODELCACHE` sha256 全部一致；`ZRAW` 最大 2246 ≤ 采样行 2246 ✓；打包层 bit3=0 ✓。
+（App 那份的 zip flags 是 `0x0800`——只有 UTF-8 位，数据在 `-wal` 里，与我们 `0x0000` 的写法不同但都被接受。）
+
+技术结论已写进 `rond-backup-parse` 技能：ZRAW 不变量、逐行二分手法（`tools/bisect_export.py`）、
+换基线六步 + 自检、以及排查顺序里新增的「先验纯净往返包」与「值域不变量」两步。
+
+## 项目记忆纳入版本控制 + 注入上限取证（2026-09-30 18:30）
+
+用户要求「记忆跟着项目走」，把 `.workbuddy/memory/` 从 gitignore 里放出来。
+
+- `.gitignore` 挡路的是 `.workbuddy/` 那行。改成「反忽略」六行：`.workbuddy/` → `!.workbuddy/`
+  → `.workbuddy/*` → `!.workbuddy/memory/` → `.workbuddy/memory/*` → `!.workbuddy/memory/*.md`。
+  ⚠️ 别用 `!.workbuddy/memory/**`——它把 memory 下的**任何**文件都放行。实测 `./web.test.exe` 混进
+  暂存过，所以收紧成只认 `.md`。复核用 `git check-ignore -q --no-index <path>` 逐条打靶：
+  `memory/*.png`、`memory/sub/x.md`、`memory/MEMORY.md.bak`、`plans/a.md` 全 IGNORED，
+  三个 `.md` 全 included，`git add -An .workbuddy/` 恰好 16 个文件。
+- 记忆里**没有真凭据**（唯一命中是 `2026-09-14.md` 里的 `password=rond-admin`，那是项目默认口令）。
+- **注入上限取证**（以前一直靠猜）：`app.asar` 里 `getWorkingMemoryContent()` 用
+  `var MAX_MEMORY_CHARS = 1e4`，比较的是 JS `content.length`——**字符数（UTF-16 单元），不是字节**；
+  中文 1 字算 1。超了就 `substring(0,1e4)` 且尾部静默丢失，只在当轮挂一句「ACTION REQUIRED」。
+  ⇒ 以前按「15.6KB 字节」判断是否超限是**错的**（中文文本 1 万字符≈1.5 万字节）。
+  本 details 与每日日志**都不参与注入**，只有 `MEMORY.md` 一个文件受约束。
+- 索引现状：`MEMORY.md` 6604 字符 / 10526 字节，距上限留 34% 余量；仍有 12 节，34 节正文在 details。
+
+本次知识已抽成**跨项目**技能：`~/.workbuddy/skills/workbuddy-memory-versioning/SKILL.md`
+（反忽略六行写法 + 只放行 .md 的理由 + `git check-ignore --no-index` 打靶复核 +
+`MAX_MEMORY_CHARS=1e4` 按字符判定 + 只有 MEMORY.md 参与注入 + CRLF 归一与
+「`grep -c $'\r'` 在 Git Bash 里会全命中」这个假信号）。
+
+## 「换基线」做进后台（2026-09-30 18:55）
+
+上一轮用户手工走的换基线闭环，这轮做成了后台动作：`/admin/baseline`（后台首页加了入口）。
+**站点数据一行不动，只换导出底稿**——这正是「底座必须是手机包」这条铁律的可操作形态。
+
+三道闸，顺序不可挪（写在 `internal/web/baseline.go` 的文件头注释里）：
+1. **重合判据**：拿新包里的到访 UUID 与站点侧带 UUID 的到访比（站点补录行本来就没 UUID，不计入分母）。
+   `matched==0` ⇒ 硬拒，**force 也不给过**（干跑只验结构，一份不相干的包照样导得出，但换下去站点每行都
+   认不出身份 ⇒ 全按新行插到最大编号之后 ⇒ 真机上「这些到访全变成新的」）。`matched*2 < withUUID` ⇒
+   要显式确认；判据没过不当场报错了事——包已收好，页面给一个 `?pending=<sha>` 的「强制替换」按钮，不必重传 20MB。
+2. **干跑导出**（`ExportRondbackup(..., tmp, io.Discard)`）：底座缺表/缺实体编号在这步就挡住，
+   不会出现「换完了才发现导不出、原来那份已经不知去哪」。
+3. **旧底座留档 + 记档**：`datasets.baseline_name/baseline_sha256/baseline_at`。
+
+踩到两个坑，都写进了 details 卅三：
+- ⚠️ **留档名不能只用秒级时间戳**：「替换后紧接着回滚」落在同一秒时，回滚那次 rename 会把刚生成的
+  留档覆盖掉，于是回滚「回了个寂寞」——`TestRollbackBaselineRestoresPrevious` 当场红给我看。改用
+  `baselineBackupName()`（`20060102-150405` + 冲突自增）。
+- ⚠️ **`ensureBaseline` 必须先看记档**：只认 `datasets.sha256`（= 最初那份包）的话，底座一丢就静默
+  重建回旧包，换基线白做且毫无提示。共用实现 `ensureBaselineTo(ctx, dsID, dst)`；「重建」入口写临时
+  文件再 rename，不做破坏性删除。用例里带了**反证**（清掉记档后同一条路必须走不通），免得被别的兜底弄绿。
+- 另一个小坑：算摘要的落盘要在 `uploads` **之外**，否则 `findUploadBySha` 会把自己认成「已存在」。
+
+第一次跑定点用例时还红了一条 `换底座后导出包里的到访数 824 != 站点 823`——那是**我的断言写错了**：
+导出条数与站点条数本来就不严格相等（导入会跳过内容重复的行），既有用例都只做「导出前后相对比较」。
+改成更锋利的判据：换底座前后导出包里 `ZVISIT` 的 **UUID 集合逐条一致**——编号会换、身份不该换。
+
+验收：`./scripts/verify.sh` 全量 **PASS=318 FAIL=0 SKIP=0**（10m15s）。
+新增用例 7 条（`internal/web/baseline_swap_test.go`）。
+
+### 补记：导出条数 ≠ 站点条数（19:00）
+
+收尾时想到一个真实的认知陷阱：站长会以为「换一份更新的手机包当底座 ⇒ 导出的包里就有手机上的新记录」。
+写文案时顺手去核这条，结果**先把自己写错的断言给纠正了**。
+
+`tableWriter.finish()` 是**两段**：先删「基线里有、PG 已没有」的行（`known` − `seen`），
+再把「导入时进不了 PG 但留档还在」的行（`w.skipped` × `raws`）按原样补回——否则「导入→导出」一趟
+会凭空少数据。所以实测那份 823 条到访的数据集导出包里有 **824** 条，差值正常。
+（我第一次写成功路径用例时断言「导出 == 站点」，红在 824 != 823，就是没意识到这一段。）
+
+同一段代码也定下了换基线的语义：**新底座里站点没有的行会被清掉**（进 `known` 没进 `seen`）。
+所以「换更新的手机包」不会把手机新记录偷偷带进导出包；要带得先走「分析差异」合并。
+这条既写进了页面提示与 flash 文案，也用 `TestSwapBaselineDoesNotCarryRowsTheSiteDoesNotHave`
+钉住了（站内补一条到访 → 导出成包 → 从站内删掉 → 换底座 → 断言导出里既没有那条的派生 UUID、
+UUID 集合也与换之前逐条一致）。
+
+第二轮全量验收：**PASS=319 FAIL=0 SKIP=0**。技能 `rond-backup-parse` 补了「导出条数 ≠ 站点条数」
+与「换基线已做成后台动作」两处。
+
+## 图片丢失的根因与恢复（2026-09-30 19:40）
+
+用户报「之前上传的照片现在找不到了，应该是因为清了应用数据换基线」。查下来**跟 App 侧无关**，
+是站点自己的外键口径不一致：
+
+- `place_images.dataset_id` 带 `ON DELETE CASCADE`，而**读取按 `place_key` 坐标键、跨数据集**。
+- 于是「删掉旧数据集」把图片**行**级联删了，**文件却留在 `<data_dir>/media/<数据集>/…`**。
+- 本机实测：`datasets` 只剩 155 号，`place_images` **0 行**，盘上 4 个 `.webp` 好端端躺着。
+  同一批附属数据里备注（17）与结论（3+1）因为早就迁到坐标键，**毫发无损**——只有图片倒霉。
+
+做的三件事：
+1. **恢复**：`internal/web/image_recovery.go` + 后台首页「图片挂载恢复 → 扫描并恢复」（`POST /admin/images/recover`）。
+   只插行、不动文件、可反复点（按 `object_key` 判重，`apply=false` 是预演）。认地点两处来源：
+   ① 数据集还在就查它的 `places`；② 数据集已删就读它留下的 `baselines/<id>.sqlite` 还原「地点号 → 坐标」。
+   对象键两种历史布局都认（`<ds>/<YYYYMM>/<srcPK>-<hash>.webp` 与 `<ds>/<srcPK>/<hash>.webp`）。
+2. **防复发**：schema 里 `CREATE TABLE place_images` 去掉外键 + 幂等 `DROP CONSTRAINT`；
+   删图的接口不再按 `dataset_id` 过滤；后台「删除数据集」的确认文案改成实话（专题也会删、附属数据不受影响）。
+3. **同类陷阱报告**：`topics` 仍带 CASCADE —— 专题随数据集一起删且**没有恢复来源**（本机 0 行，
+   之前那次换数据集就没了）。专题内容本来是「时间+区域」派生的，可以做成跨数据集的，但列表/详情都按
+   `dataset_id` 过滤，要改就一起改 —— **等用户拍板**，没擅自动。
+
+本机预期可恢复 4 张：`上班` ×1（旧地点号 286）、`海之尚酒店` ×3（旧地点号 309），靠 `baselines/9.sqlite` 认。
+
+踩到的测试坑（都写进 details 卅四）：图片「按坐标键跨数据集读」+「按 object_key 判重」都**不看数据集**，
+用例之间会互相污染两处——盘上文件（「应当 2 张、实际 10 张」）与库里的行
+（`Already:1` 让兜底分支根本没跑到，用例差点假绿）。加了 `isolateImageState`（换空 DataDir + 按 place_key 清行），
+并给夹具补了收尾清理（外键没了，必须自己清）。
+
+新增用例 4 条（`image_recovery_test.go`）。
+
+### 补记（23:20）：对象存储上的图 + 专题一并改
+
+用户：「一并做，而且有部分资源在 R2 上，怎么办？」
+
+**R2 侧**：行没了就只剩桶里有那些键，不列桶无从得知它们叫什么 ⇒ 给 `internal/media` 加了
+`ListObjects`（ListObjectsV2 + SigV4 + 翻页 + XML）。两个坑：查询串必须**先编码再签**
+（`canonicalQuery` 按原样取 RawQuery，prefix 里的 `/` 得写成 `%2F`，否则签名与发送不是同一份字节）；
+R2 的 Token 默认没有 `s3:ListBucket` ⇒ 403。列不动时**不让整个恢复失败**：本地那半照救，
+原因进 `Warnings`（页面红色提示条）。另外「挂回了却没配 `s3_public_base`」会让行有了、页面一片空白，
+比「没恢复」更难懂，也写进 warning。
+
+**专题**：按用户拍板做成归人不归数据集。外键摘掉，所有查询 `dataset_id` → `user_id`
+（`loadTopics`/`topicPage`/保存/删除/开关/`HasTopics`）；**内容仍照生效数据集算**（`topicContent` 不动）。
+`Dataset` 补 `UserID`（`datasetFor` 多查一列）供前台按属主定位用户级数据。
+用例除「删数据集后专题还在」外，还直接查 `pg_constraint` 确认外键确实不在——只看行为可能被别的原因弄绿。
+
+**导出链路没碰**：`place_images` / `topics` / `Dataset.UserID` 都不参与 `.rondbackup` 导出。
+
+### 再补（23:50）：认不出 33 张 —— 「能读出数据」≠「读对了那一版」
+
+用户跑到真数据上：扫描 40 个对象（对象存储 19），只挂回 7 张，**认不出 33 张**，
+报错「数据集 #1 里没有编号 389 的地点」。
+
+根因：我的 `srcPKCoords` 是「第一个能读到的来源就返回」，而**换基线会覆盖 `baselines/<id>.sqlite`** ⇒
+当前那份未必是上传那会儿的编号空间，旧编号很可能还在同一份底座的 `.bak` 留档里。
+
+改了三处：
+1. 来源**全部读入合并**：库里 places → `entity_raw` 里 ZLOCATION 的整行留档 → `baselines/<id>.sqlite`
+   及**每一份 `.bak-*`**（读不动的跳过，不再第一份成功就返回）。
+2. 同一编号**保留多组候选坐标**，逐个试到能在当前数据集里对上（站点纠过偏/来源不一致的情况）。
+3. 认不出要能排查：理由写明「已查来源 …」与试过的坐标；提示条**按数据集归并**上报，
+   不再刷「另有 31 张」；完整清单（前 30 条）进服务端日志。
+
+可复用的教训：从「可能被覆盖过的留档」里还原编号/坐标时，必须把历史版本一起纳入，
+并在失败信息里列出已查过的来源——否则用户只看到「认不出」，无从下手。

.workbuddy/memory/2026-10-01.md

@@ -0,0 +1,72 @@
+# 2026-10-01
+
+## 防复发：把「删数据集带走自建数据」做成结构性门禁（00:30）
+
+用户放弃继续救那批旧图：「我只想避免类似的事件再次发生」。于是把这次的教训固化成三件东西
+（`internal/web/dataset_ownership_test.go` + `schema.sql` 抬头 + README 新章节）：
+
+1. **归属铁律**：判断标准只有一句——**这份记录能不能从备份重新导入？**
+   能（places/visits/movements/weather/activities/tags/entity_raw）⇒ 可挂 CASCADE；
+   不能（place_images/place_notes/place_votes/topics）⇒ 只留 dataset_id 当出处、不许挂外键。
+2. **两道门禁**：运行时查 `pg_constraint`（表必须在白名单里，反向也查）+ 静态扫 `schema.sql`
+   （新建的库走 CREATE TABLE，只看运行时有盲点）。做变异验证时确认了静态那条**真的会响**。
+3. **体检常驻后台首页**：库里 N 张 / 本地盘上 M 个 / 落单 K 个（`imageHealth`），落单 >0 直接报警。
+   事故的本质不是「删数据集」本身，而是**行与对象悄悄对不上、没人发现**——让它当场可见。
+
+变异验证的收获（比测试本身更有价值）：
+- 运行时门禁单独看**不够**：夹具每次跑迁移，迁移自己就把坏外键摘了 ⇒ 它永远不会在不健康的库上报警。
+  补了 `TestMigrationDropsStaleDatasetForeignKeys`：注入事故原样的外键再跑迁移，断言被摘掉。
+- 这条自愈用例又抓出缺口：`place_notes`/`place_votes` 上同类外键**迁移并不会摘**
+  （原先只写了 place_images 与 topics 两句 DROP）⇒ 补成四张自建数据表全覆盖。
+  **部署出去的库要能自愈，DROP 必须覆盖全部同类表。**
+- 静态扫描必须先跳过 `--` 注释行：规矩的说明文字里就写着 `REFERENCES datasets(id)`，
+  不跳过会把自己写的文档当成违规。
+
+顺带订正：后台「删除数据集」的二次确认文案在专题改完后已说过时话（说专题会一起删），改成实话。
+
+### 补记：迁移块排序的老规矩我又踩了一次（00:55）
+
+把「摘外键」那五句 ALTER 收成一段放在 `topics` 之后，而 `place_images` 的 CREATE 在这段**之后**
+⇒ 开发库（表已存在）毫无症状，**全新库起不来**：`ALTER TABLE place_images …` 报「关系不存在」。
+正是记忆里那条老规矩：「迁移块必须收敛且排在依赖表之后（插在 place_images 前：开发库无症、新库起不来）」。
+被 `TestFreshDatabaseServesAppQueries` 当场抓住（这条门存在的意义）。
+
+改成整段排在 `place_images` 建表之后（它是五张里最后一张），并把这个坑写进 schema.sql 的注释里。
+教训：**凡是 ALTER 某个表的迁移块，先确认那张表在文件里已经建过了**——
+只在本机库上跑一遍是测不出来的，必须跑 fresh-database 用例。
+
+## 统计页：站长结论与访客点赞拆成两块（01:40）
+
+用户问「数据统计处的推荐地点和踩雷地点只针对站长吗？应该分开，用户的点赞点踩单独做一块」。
+他看到的没错：那张卡的**列表全是站长结论**，访客票只在副标题露了个总数。
+
+- 新增 `votes.TopVisitorVoted`（`HAVING` 只算至少有一票的方向，否则 0 票地点塞满榜；
+  同票按 `visit_count DESC, p.id` 保证顺序稳定）。
+- 「推荐 & 踩雷（我的结论）」只讲站长；另起一张卡「访客点赞」，列 👍/👎 票最多的地点并带票数。
+- 两个 pageJob 并行加载；两块共用 `IsAdmin || MarksPublic`（与地点页投票区一致）。
+- 用例按卡片标题切 HTML 断言「A 只在站长块、B 只在访客块」，比数总数更能证明没串台。
+
+⚠️ 又踩同一个坑：票表按坐标键跨数据集读、`place_visitor_votes` 还没有 user_id ⇒
+上一轮跑剩的票会被算进来。新增 `isolateVoteState` 按 place_key 清两张表（前置 + cleanup）。
+
+顺带订正 README：那里还写着站长结论「按 src_pk 存」，其实早就是坐标键了。
+
+## 措辞分身份：访客不该看到「我的结论」（02:05）
+
+用户：「无论是否登陆，都显示『推荐 & 踩雷（我的结论）』，这对访客是不是会产生困扰，再检查类似的表述」。
+顺着 `grep "[我你咱]"` 把访客可见模板 + `static/js` 过了一遍，共 4 处同病（都是**站在站长视角下笔、
+而那一块对访客公开**）：
+
+1. `stats.html`：标题「我的结论」→ 按身份分支（站长「我的结论」/ 访客「站长结论」）；
+   副标题「只统计你自己…」→ 站长「你自己」/ 访客「站长」；两列「我推荐/我踩雷的地点」同理。
+2. `stats.html` 访客块副标题：「你标你的，访客投访客的」→ 对两边都成立的「各存各的表，谁也不会覆盖谁」。
+3. `home.html`：「我的标签」→「足迹标签」（同级卡片全是中性的：足迹地图/城市足迹/天气足迹…）。
+4. `report.html`：「这一年里，**你**第一次踏足…」→ 去掉人称（年报是站长的回顾）。
+
+已写对的（照它学）：`place.html` 投票区早就是 `{{if .IsAdmin}}` 分支，`rond-map.js` 气泡同理。
+
+门禁 `TestVisitorPagesUseThirdPersonCopy`：以访客 ctx（无 user）渲染 `/`、`/stats`、`/report`，
+逐个禁用词断言，同时确认站长那份仍说「我的」（别改过头）。
+
+⚠️ 变异验证又踩老坑：**直接 `go test -run` 缺环境变量会静默 skip 并报 ok**（0.17s 就 ok，一眼假绿），
+必须走 `verify.sh`。改用 verify.sh 后变异被正确抓住（`visitor_copy_test.go:85` 报「我的结论」）。

.workbuddy/memory/2026-10-08.md

@@ -0,0 +1,92 @@
+# 2026-10-08
+
+## 排查：模板字段报「can't evaluate field」= 二进制比源码旧
+
+现象：`渲染 admin/index 失败: template: index.html:116:31: executing "content" at <.ImgRows>: can't evaluate field ImgRows in type web.AdminData`
+
+结论：不是代码 bug，是跑的二进制比模板旧。取证链：
+- 字段在 `view.go:669` + `handlers_admin.go:177` 都有，引入于 `4c3032c`（2026-10-01 01:15）
+- `go version -m rond.exe` → `vcs.revision=d99c63f`，`2026-09-30T09:35:59Z`
+- `strings rond.exe | grep -c ImgRows` = 0（同批 `FogMasks` 有）
+- `git show d99c63f:internal/web/view.go | grep -c ImgRows` = 0
+
+**机制**：`conf/app.ini` 的 `debug=true` 让 `server.go:488` 的 `pageSet()` 每次请求都
+`ParseFiles` 重读磁盘 ⇒ **模板是磁盘新版、结构体是二进制旧版**，改 Go 不重启就错配。
+（与「debug=false 下模板走 go:embed，改 html 必须重编」是同一根轴的两面。）
+
+处置：`go build -o rond.exe .` 重启即可，无需改代码。
+后续可加固：`pageSet` 命中字段解析失败时提示「模板比二进制新，请重新编译」。
+
+## 排查：时间框手动输入不跳段（flatpickr allowInput）
+
+现象：想输 `2026/6/6`，实际要打到 `202666` 才进月份段。
+
+实测取证（最小复现页 + 真派发按键，见下「无头测不到原生分段」）：
+- flatpickr 把原 `datetime-local` **就地改成 `type="text"`**（实测 `el.type === 'text'`、
+  `altInput` 未生成、`sameNode=true`）⇒ 原生分段编辑器被彻底替换掉，谈不上自动跳段
+- 项目三处配置一致：`admin/edit.html:807`、`admin/photos.html:512`、`admin/topics.html:99`
+- `inst.parseDate(s,'Y-m-dTH:i')` 实测：
+  - `2026` → y=2026 mo=**1**；`20266` → 同上；**`202666` → mo=6**（用户看到的就是这个）
+  - `2026/6/6` → 正常 y/mo/d=2026/6/6（**带分隔符能解析**）；`20260606` → y=**2030** mo=**12**（错）
+- `setDate` 回写：`2026` → `2026-01-01T00:00`；`202666` → `2026-06-01T00:00`；`2026-6-6` → `2026-06-06T00:00`
+
+**根因**：`allowInput` 是「整串解析」语义，不是「逐段消费」语义。年份要满 4 位才被认，
+之后月份位还要再吃 2 位才出结果 ⇒ 表现为「年份很长才跳下一位」。
+
+**无头测不到原生分段**：`--headless=new` 下原生 `datetime-local` 的
+`el.shadowRoot` 是 `null`（`shadow:false`），`sr.querySelectorAll('input.edit')` 直接抛
+TypeError；且真派发按键后 `input.value` 恒为 `''`、`selectionStart` 为 `null`
+—— UA 内部 shadow 段落在无头下不暴露。**要对比原生行为必须用有头 Chrome，
+本机 CDP 脚本测不了，别把「原生 value 恒空」误当成原生没有分段。**
+
+修复方向（未落地，等批准）：`parseDate` 换成自定义解析器，接受
+`2026/6/6`、`2026-6-6`、`20260606`、`2026` 等写法并做**歧义拒绝**
+（`20260606` 必须判非法，不能悄悄解析成 2030-12-6）。服务端格式约束是
+`2006-01-02T15:04`（`handlers_edit.go:1717`、`handlers_topics.go:26`），解析器须产出同一形状。
+
+## 落地：时间框跳段 + 无歧义解析（方案 B，已完成）
+
+用户拍板：**只做严格标准格式**（`xxxx年xx月xx日` 的数字形态，月/日/时/分一律两位、
+不自动补零、不做前滚）。理由：少一套猜测逻辑、行为完全可预测。
+
+**新增** `internal/web/static/js/datetime-input.js`（+ 同目录 `.test.js`，34 断言纯 node 跑）：
+- `parseDateStrict(dateStr)`：flatpickr 的 `parseDate` 钩子。接受 `2026`/`2026/6/6`/
+  `2026-6-6`/`20260606`/`2026-06-06T09:30`/`202606060930` 等；
+  **纯数字只收 4/6/8/12/14 位**（5/7/9/10/11 位一律拒——`2026060630` 到底是
+  「日=30」还是「时06分30」说不清）。也拒 `2026/2/30`、`2026/13/6`、尾部残留。
+- `layout(raw)`：把框里值按 [年4][月2][日2][时2][分2] 切分排版，**段满即补分隔符**，
+  于是敲完第 4 位年份立刻变 `2026-` 且光标跳到月份位（= 原版做不到的那件事）。
+  逐位取数时**必须跳过分隔符**（`2026-0` 的数字是 `20260` 不是 `2020`，否则整体错位一格）。
+- `placeCaret(pos)`：**同步设一次 + 微任务再补一次**。flatpickr 自己监听 input/setDate
+  会在我们之后改 `selectionStart`，只设一次会被它抢走 ⇒ 下次按键插到分隔符**前面**
+  （实测退化成 `2026-6`）。
+- `attachPicker(el)`：三处页面共用的挂载入口，`_rondPickerReady` 守卫防重复
+  （照片页 `initPickers` 会被反复调）。配置与原先完全一致，只多 `parseDate` + 引导。
+- 越界（月 66、日 45、时 25）**原样保留交解析器报错，绝不静默改成合法值**——
+  把 13 月悄悄改成 1 月比报错坏得多。
+
+**改动面**：`layout.html` 加一行 script（放 `.Flatpickr` 块内、flatpickr 之后）；
+`admin/edit.html`、`admin/photos.html`、`admin/topics.html` 三处配置收敛成
+`window.rondDatetime.attachPicker(el)`（模板净减 5 行）。
+
+**验证**（真实站点 `localhost:8080`，CDP 派发真按键）：
+逐跳 `2→20→202→2026-→2026-06-→2026-06-06T` 正确；
+`20260606`/`202606060930`/`2026/6/6`/`2026-6-6` 四种写法解析全 OK，
+`2026666`/`20260230` 正确拒绝，`errs=0`；照片页动态框连调三次 attachPicker
+（二三次返 null）+ 跳段正常。Go 测试 14 包全绿，`gofmt` 干净。
+变异验证两次都被抓到：① `sep=''` ⇒ 跳段退化成 `2026`；② 放行 7 位纯数字。
+
+## 环境坑（下次直接照抄）
+
+- ⚠️ **`site_cdp.py` 的会话签名算法已过期**，签出来的 cookie 服务一律 303。
+  `internal/auth/auth.go` 现在是 `hmac(secret, payload+"\x00"+**完整** password_hash)`，
+  且 **secret 用裸字符串不是 hex 解码**（`server.go:118` 是 `[]byte(cfg.SecretKey)`）。
+  过期脚本还在用「前 16 位摘要」⇒ 本地验后台页必须自己签。
+- Git Bash 下传 `--base http://...` 给 python 会被吃掉 `//`（`Cannot navigate to invalid URL`），
+  须加 `MSYS_NO_PATHCONV=1`。
+- flatpickr 挂载后 input **`type` 被改成 `text`** ⇒ CDP 探针里
+  `querySelectorAll('input[type=datetime-local]')` 一律数到 0，必须用
+  `input.flatpickr-input`。
+- 自定义 `parseDate` 返回 `false` 时 flatpickr 会走
+  `errorHandler(new Error("Invalid date provided: ..."))` 并清空 `selectedDates`
+  ——不是静默忽略，所以「拒绝」在页面上表现为框被清空。

.workbuddy/memory/2026-10-09.md

@@ -0,0 +1,272 @@
+# 2026-10-09
+
+## 排查：/admin/settings 报错（旧二进制 + 新模板）
+
+**现象**：「统计脚本做成后台开关」那次提交（4015ddf）之后，访问 /admin/settings 报错。
+
+**根因（已实测复现）**：跑的是**旧二进制**（根目录 `rond.exe`，10-08 18:06 编译，早于 18:27 的提交），
+磁盘上的模板却是新的。`debug=true` 下 `pageSet()` 每次渲染都从磁盘重解析模板，
+于是新 `settings.html:148` 引用了旧 `setting.Settings` 结构体里没有的 `TrackEnabled` → 执行期报错：
+
+```
+渲染 admin/settings 失败: template: settings.html:148:85: executing "content"
+at <.Settings.TrackEnabled>: can't evaluate field TrackEnabled in type setting.Settings
+```
+
+`render` 是流式直写 ⇒ header 已发（HTTP 200）但表单在「统计脚本」卡片处截断，
+没保存按钮、没 `</form></html>`。这就是用户看到的「报错」。
+
+**判据**：`strings <二进制> | grep -c cleanTrackScript` —— 旧根二进制 0，新编译的 2。
+（注意别用 `strings | grep TrackScript` 判定，config 里本来就有这个名字，旧二进制也命中。）
+
+**修复**：`go build -o rond.exe .`（+ `bin/rond.exe`），重启。旧二进制备份到
+`bin/rond.exe.old-20261008-stale`。修后 /admin/settings 完整（19642B，含 `</html>`/保存按钮）。
+
+**教训**：Go 结构与模板字段是成对改的，`debug=true` 的热加载只覆盖模板 —— 改 Go 必须重编译重启，
+否则就是「新模板 + 旧结构 = 执行期报错」。想根治可在启动时把所有页面各渲染一遍做冒烟（现在没有）。
+
+## 其他发现（未改代码）
+
+1. **P1 待确认**：`settings` 行 `pages=null`（写入时间 2026-10-08 18:14:05）⇒ 访客侧
+   `/map /places /timeline /stats /report` 全部 404、导航只剩 1 个链接。代码语义是
+   「全不选 = 访客只能看主页」，属合法状态，像是测 404 分档时留下的。**没动数据，等确认**。
+2. **P2**：`cleanTrackScript` 的 `src=` 检查是**全文 `strings.Index`**，会误伤脚本体内的
+   `src=`。实测：`<script>var i=new Image();i.src=u;</script>` → 返回 `""`（整段被静默清空），
+   而页面仍提示「设置已保存」⇒ 静默失效。建议只在标签属性里查 src，或把「被清空」回传前端显式提示。
+3. **P2**：开闭标签只拒 `shut > open`；末尾未闭合 `<script>`（`open > shut`）会吞掉后面内容。
+   实测 `<script>x</script><script>y` 与 `<script>y` 都被放行。建议改成要求 `open == shut`。
+4. **运维**：根 `rond.exe` 与 `bin/rond.exe` 两份二进制容易走偏（这次根目录那份就是旧的）。
+   考虑只保留 `bin/`，或在启动日志打印构建时间便于比对。
+
+**回归**：`go vet` 干净、`gofmt -l` 空、JS 单测 34/34、`go test ./...` 13 包全 ok 0 FAIL。
+（注：`internal/web` 里 110 例是 DB 门控的，不开 `ROND_TEST_CONF`/`ROND_SRC` 会 skip，不算真跑过。）
+
+---
+
+## 用户确认后的收尾（四件）
+
+用户反馈：「管理员访问也只剩主页，这好像不对」+ P2 按建议修 + 二进制只留根目录 + 防复发一并做。
+
+### 1. P1 更正：不是配置问题，是导航缺 IsAdmin 分支
+
+上面第 1 条判断得不完整。实测：站长访问 /map /places /timeline /stats /report **全是 200**
+（`guardPage` 只拦访客），但导航里只有「主页」⇒ `layout.html` 的页面显隐写的是
+`{{if .Settings.HasPage "x"}}`，**没有 IsAdmin 分支**，与 `guardPage` 口径不一致。
+改成 `{{if or .IsAdmin (.Settings.HasPage "x")}}` 五处。门禁 `nav_visibility_test.go`
+（三向不变量 + 变异验证）。**访客侧的 pages=null 没动**（仍是「只对访客关」的配置状态）。
+
+### 2. P2 修复：`cleanTrackScript` 重写
+
+- `src=` 只在 `<script …>` **开标签内部**找（原来对整段 `strings.Index`，`i.src=u` 被误伤清空）。
+- 开闭标签从「只拒 `shut > open`」改成**严格配平**（末尾未闭合的开标签原来会被放行）。
+- 签名改 `(script, warn string)`，说明码经 `?warn=` 回显成人话；判危险时**整段不采纳、
+  库里原脚本与开关不动**。
+- 实测（测试实例 8081 / `rond_fog_test`，用完已还原）：`i.src=u` 现在原样落库；
+  不配平 → `?warn=unbalanced` 且库值不变；`javascript:` → `?warn=badsrc` 且库值不变；
+  5000 字符 → `?warn=truncated` 且落库 4096。注入范围精确复核：只在公开页（/、/map），
+  后台与登录页 0。
+
+### 3. `bin/` 删除
+
+15 个 exe、412MB 全删；只保留根 `rond.exe`。技能 `rond-web-verify` 与 details 十八的
+`bin/rond.exe` 写法已同步改掉。
+
+### 4. 防复发：启动自检 `smokeRender`
+
+`template_smoke.go`：`pageProbe`（24 个页面各一份最小可用数据，键与 `pageFiles` 双向校验）
++ `New()` 里全量渲染一遍，失败即 `log.Fatalf` 拒启。实测：往 settings.html 插一个不存在的
+字段 → 启动报 `模板自检未通过…admin/settings: can't evaluate field …`，退出码 1。
+门禁 `template_smoke_test.go`（含变异验证：把探针换成字段更少的类型必须报错）。
+
+### 5. 用户裁决 + 文案订正
+
+- **访客侧 `pages=null` 不动**：用户明确说「访客那一侧是根据我在后台配置的显示范围公开的，
+  倒不如说原来默认就是这样才对」⇒ 那是**预期配置**，不是故障。已把这个结论写进
+  details 四十一，免得后续会话又去「修」数据。
+- **settings.html 的统计脚本文案订正**（P3）：原文两处不准 ——
+  ①「多一个 `</script>` 会被判为粘贴错误」漏了「少一个也会拒」（判据已改成严格配平）；
+  ②「`conf/app.ini` 的 `track_script` 会作为这里的默认值」有歧义：它**不会回填文本框**，
+  而是「这个框留空时，注入时回落到 ini 的值」。已改成准确说法。
+  实测热加载生效（debug=true，无需重编），页面 19996B、含 `</html>`，旧文案 0 命中。
+- 验收：官方 `./scripts/verify.sh` → **PASS=346 FAIL=0 SKIP=0**（改动前那次全量；
+  之后只动了这一个模板文案，重跑了全部模板门禁与 `TestSmokeRender*`，全绿）。
+
+## 提交 + 前端现代化方案
+
+**提交**：`d4e4257`「启动模板自检 + 站长导航放行 + 统计脚本关口收紧」（12 文件，+564/−75）。
+
+⚠️ **`shots/` 里的截图是旧状态，做视觉判断前必须现场重截**：`mobile-home.png` 还显示顶栏
+折成 3 行、右按钮竖排，实测现在 390 下品牌名只留 🐾、按钮「后台」、`navH=51` 且不溢出。
+差点拿旧图当现状写进方案。
+
+**现状实测（CDP，真实视口）**：
+- 卡片：17 个盒子（`.card`/`.kpi`/`.filters-card`）**只有 2 种样式指纹** ⇒ 层级扁平。
+- 字阶 8 档（10/12/13/14/15/18/21/23），10–15px 挤了 5 档；字重 400/500/600/**650**。
+- 正文色只有 4 种；类型色 10 种只用在圆点与柱子，没进界面语义层。
+- 站长导航 `scrollWidth=277`：430→254（溢 23）、390→214（溢 63）、320→144（溢 133）；
+  390 下「统计」被切成半个字紧贴「后台」，`.overflow-right` 的渐隐看不见。
+- 已有优点别改坏：KPI 已是 `tabular-nums`、`--text-3` 按 AA 调过、暗色模式已有 3 段 media。
+
+**产出**：`frontend-plan-2026-10-09.md`（仓库根，与 `audit-2026-09-21.md` 并列）。
+四批：A 设计令牌收敛（字阶砍到 6 档、字重 3 档、间距/圆角/阴影令牌）→ B 卡片分 hero/常规/次级
++ 首屏 1 个大数 → C 手写图表加基线/峰值/轴标（不上图表库）→ D 类型色语义化 + 窄屏导航。
+**明确不做**：前端框架/构建链、图表库、信息架构重构。建议先做 A+B（约 1.5 天，纯 CSS + 少量 class）。
+方案**未改任何代码**，等选批次。
+
+---
+
+## 落地：A + B 批次（用户选了「先按 A-B 去做」）
+
+**做法**：先跑基线存档（`ab.js` 探针 + `audit/run_all.py --mobile 390` / `--overflow 1440`），
+再改，再用同一份探针跑一遍逐值 diff。CSS 改动量 187+/150−，另有 19 个模板共 54 处内联字号并档。
+
+**关键结果**（同一探针，改动前 → 后）：
+- `/` 的 (字号,字重) 组合 390：**13 → 10**、1440：**15 → 10**；`/places` 10 → **5**；
+  `/timeline` 10 → **6**；`/stats` 15 → **9**；`/admin/settings` 10 → **7**。
+- 最小字号到处都 ≥11px（原来有 10 / 10.5px）。
+- 卡片样式档：`/` 2 → **3**，`/admin/settings` 1 → **2**。
+- 溢出：移动端审计**逐值一致**；桌面 1440 唯一差异是 `/map` 露外元素 9 → 8。
+- 验收 `./scripts/verify.sh`：**PASS=347 FAIL=0 SKIP=0**。
+
+**踩到的四处**（都只有「量 DOM 的 (字号,字重) 组合」才看得见，截图上看都正常）：
+1. **Leaflet 字号跟着根字号漂**：vendor `.leaflet-container { font-size: .75rem }`，
+   根 14 → 13px 后地图署名/比例尺掉到 **9.8px**、弹窗正文也跟着缩。
+   已在 app.css 钉死（容器 `--fs-sm`、署名/比例尺 `--fs-xs`）。
+2. **项目自带的静态守卫抓到我**：`TestNavLinksNarrowRuleHasNoDeadPadding` 写死了 `font-size: 13px`，
+   并档后它红了。守卫是对的，改判据为「钉规则还在、且设了字号」；另补 `TestNoBareFontSizePx`
+   （静态扫 app.css + 模板禁裸 px 字号，做过变异验证）。
+3. **`h1..h4` 从没设过字号**（原来只有字重与 margin），靠浏览器默认 `2em/1.5em/1.17em` ⇒ 也跟着根字号漂：
+   根 14 → 13px 后，`/stats` 里没被 `.card > h2` 命中的两个 h2 从 21px 变成 19.5px，比同页卡片标题（15px）大一圈。
+   已显式给出 h1/h2/h3 字号，实测 12 个 h2 统一 `15px/600`。
+4. **`<b>/<strong>` 浏览器默认 700**，比全站最高层级（标题 600）还重 ⇒ 已钉成 600。
+
+**教训（已写进 details 四十二）**：quiet 卡片第一版用 `--bg-2`(#fafbfb)，
+与页面底 #f6f7f8 只差 4/255 ⇒ 实测看不出边界、像「破了个洞」。**配色差异必须量，不能凭「应该能看出来」。**
+
+**运维提醒**：测试库跑到 180MB / 21 万死元组时 `verify.sh` 会从 8 分钟拖到 12 分钟以上
+（脚本 200MB 才自动 VACUUM）；手动 `VACUUM (ANALYZE)` 后回到 ~10 分钟、137MB / 0 死元组。
+
+**发现未修**：7 个模板工作区里是 CRLF，而 `.gitattributes` 要求 `eol=lf`
+（`admin/index.html`、`admin/login.html`、`admin/twofa-login.html`、`admin/twofa.html`、
+`map.html`、`places.html`、`timeline.html`）。本批按字节替换保住了各自行尾、diff 无行尾噪声，
+要不要统一另开一次清理。
+
+---
+
+## 落地：C + D 批次（用户选了「C和D继续做」）
+
+**C 图表**：月度分布加基线 + 峰值柱标次数（`.pv`，副标题不再重复写「最高 N 次」）；
+一天中的分布把「0/6/12/18 四个数字」换成 **6 小时一段的标尺**（深夜/上午/下午/晚上），
+用**同一套 24 列 grid** 保证段边界与柱子严格对齐；首页月度图同样加峰值（给 `HomeData` 补了 `MaxMonthly`）。
+**空态那条划掉了** —— 查下来已经统一（8 页共用 `emptystate`、局部走 `.empty`）。
+
+**D1 类型色**：先算对比度，结论推翻了原计划 ——
+
+- 白底上 6 个色低于图形 3:1（yellow 1.87 / mint 2.12 / orange 2.20 / green 2.22 / cyan 2.54 / teal 2.57）
+- 暗底只有 indigo 2.90 不够
+
+所以**没有**把类型色做成 chips / 表格类型列 / KPI 强调（那几处要的是文字色，会更难读）——
+这恰好解释了全站为什么一直只用 8px 小圆点做标记。浅色 6 个色一个没动（是手机端/地图的同一套身份色）。
+实际做了：色值收口成 `--cat-*` + `--cat-*-soft`（26 个变量）、模板 `colorof` → `csscolor`/`csssoft`（19 处）、
+暗色只提亮 indigo。`colorOf` 已成死代码，删掉。
+
+⚠️ **踩到 `ZgotmplZ`**：`html/template` 的 CSS 过滤器不认识 `var()`，函数返回普通 string 会被替换成
+`ZgotmplZ`，页面上所有圆点当场变透明、**且不报错、模板测试照过**。
+必须返回 `template.CSS`；而挂了它等于关掉过滤，所以数据侧色值先过严格校验（只有 `#`+6 位 hex 放行）。
+已加守卫 `TestCSSColorSurvivesTemplateSanitizer`（两个方向都钉，做过变异验证）。
+
+**D2 窄屏导航**：≤620px 整行收进 `.nav-menu`（原生 `<details>`，JS 只补点外面/Esc/点链接后收起）。
+⚠️ 顶栏 z-index 抬到 `--z-nav: 1200`（必须高于地图浮层 1100，否则展开的菜单被筛选面板盖住），
+已在 `/map` 用 `elementFromPoint` 实测。改前 390 溢 63px、320 溢 133px（「统计」被切半个字）。
+
+**回归**：`verify.sh` **PASS=348 FAIL=0 SKIP=0**；320/390 溢出**全 0**（改前 `/admin` 在 320 还溢 34px）；
+桌面 1440 与改前一致；**7 个页面都没有低于 11px 的文字**；暗色下菜单/类型色/阴影均按暗色变量生效。
+
+---
+
+## 提交 + 完整回归（含「原有代码是否受影响」专项）
+
+**提交**：`ab7ccd2`「前端改造：设计令牌 + 卡片层级 + 图表可读性 + 类型色收口 + 窄屏导航」
+（32 文件，+997/−283）。A/B 与 C/D 本想拆两笔，但 `app.css`/`layout.html`/`view.go` 里两批改动交织，
+按文件拆不开、按 hunk 拆容易做出「中间那笔编译不过」的历史，**合并成一笔、消息里分段**，并在提交消息里写明原因。
+
+**完整验证链**（一次跑齐，全部串行）：
+- `./scripts/verify.sh`：**PASS=348 FAIL=0 SKIP=0**
+- `./scripts/verify.sh --pkg ./internal/fog/ --race`：**PASS=22 FAIL=0 SKIP=0**（mingw 在 PATH 里，-race 可用）
+- JS 单测 34/34
+- 移动端 320 / 390 + 桌面 1440 审计：**320/390 溢出全 0**；1440 只有 −15（滚动条宽，既有口径）
+
+**「原有代码受影响」专项检查**（静态扫描 + 逐文件回读 diff）：
+- 自定义属性：定义 90 / 使用 61，**「用了但没定义」为 0**（先前一轮报的 12 个全是我正则的假阳性：
+  CSS 一行写多个属性、`--cat-*` 是 Go 侧动态拼的、模板 `:root` 里也有定义）。
+- 定义了没人用的：只剩 28 个 `--cat-*`（Go 动态拼接，运行时实测 14 种颜色都渲染出来了）——
+  另外揪出 `--sp-5` 真没人用，已用到「停一下」页的留白上（正好是大间距场景）。
+- 模板函数：**没有真孤儿**（先前列表是正则把 `appleColors` 的键当成了函数名）。
+- 已删项残留：`colorof`/`--radius`/`--shadow`/旧测试名 全部 0 残留（`app.css` 里那句注释也顺手改对了）。
+- 逐文件回读：19 个模板的 diff 只有字号替换与 `colorof`→`csscolor`，没有误伤；
+  Go 侧 diff 只有 `MaxMonthly`、`cssColor/cssColorSoft`、注册表与 `regexp` 导入。
+- 顺带发现（**既有、与本批无关**）：`.g3`/`.g4` 是 HEAD 里就有的死类（模板/JS 都没引用）；
+  `.notice-card` 等不是死类 —— 它在 `notice.go` 里由 Go 拼 HTML，我的模板侧扫描覆盖不到。
+
+**验证中抓到的一例失败（已实证是环境抖动）**：
+`TestOpenCreatesMissingDatabase` 报「建库后首次连接超时」10.02s。根因是 `db.Open` 的 ping **写死 10s**，
+当时库正被验收 + autovacuum + CDP 审计一起压着；停掉审计单独跑 **4.1s 通过**。
+⚠️ 这条测试失败还会把临时库 `rond_test_autocreate_*` **留在库里**（清库的 defer 在 `Open` 成功之后才注册）——已清掉残留。
+两条结论都写进了 details 三十二的验收小节。
+
+
+
+
+
+---
+
+## 第三批：日期框（用户报的硬 bug）+ 两处观感
+
+**用户报**：① 逐月平均气温图在桌面端很小；② 日期框敲 `20260606` 变成 `202606/06`（要「永远解决」）；
+③ 类型分布与一天中的分布同行高度不齐、下面一大片空白。
+
+### ② 日期框：**实测复现**后定位（写了真实按键工具 `storage/_type.py`）
+技能里的 `--press` 只给 Enter 带 `text`，数字敲不进去（Chrome 不执行默认动作），所以单独写了一个
+CDP 打字脚本（每字符 keyDown(text) + keyUp）。用它复现：
+- 敲之前 `INPUT|date|`、`attached=false`；敲完 `202606/06`、`value=""` —— 截图为证。
+- **根因**：筛选区的「起始/结束日期」是原生 `<input type="date">`，而挂载代码只写了
+  `querySelectorAll('input[type=datetime-local]')` ⇒ **type=date 从没人管**。
+  Chrome 的年段允许 >4 位数字（年份上限 275760），8 位被切成 年=202606 + 月=06。
+  原生分段状态读不到、`setSelectionRange` 对 date 类输入直接抛 ⇒ 修不了，只能换控件。
+
+**做法**：`datetime-input.js` 加只日期模式（`SPEC.date`：年/月/日，输出 `Y-m-d`）+ **统一入口
+`attachAll(root)`** 按 `el.type` 分派；`attach` 里先把控件换成 `text`（引导会写 `2026-06-` 这种半成品，
+原生控件对非法值一律置空）。`datetime-input.js` 改为**无条件引入**（公共页筛选区也要用），
+挂载在 body 末尾**立刻**跑一次（别只等 DOMContentLoaded，否则先露原生框再变文本框）。
+三个后台页改用 `attachAll`（顺带覆盖 `mfrom/mto`，且 date 类走 `enableTime:false`）。
+
+**验证**：真实按键敲 20260606 → `value="2026-06-06"` ✓；端到端 `from=2025-08-01&to=2025-08-31`
+筛出 **186 次**，与月度图峰值月（186）完全吻合 ✓（排除「解析成空导致恒 0」）。
+守卫 `TestDateInputsGoThroughAttachAll`（模板出现按 type 挑的选择器即红；变异验证过）。
+
+### ① 气温图：10 个月只用了 1042px 里的 396px
+`.temp-col` 固定 36×84。改成宽屏 `flex: 1 1 36px; max-width: 96px` + 轨道 130px + 字号提到 `--fs-sm`；
+窄屏保持固定宽 + 横滚（否则月份标签糊成一团）。
+
+### ③ 同行卡片高度不齐：grid 默认 stretch
+「类型分布」1411px 把「一天中的分布」也拉成 1411px，后者内部一大片空白。
+`.grid { align-items: start }` 后两项各按自然高（256px）。
+
+**回归**：verify.sh 348 例 0 skip、JS 单测 **45/45**（新增 11 条逐键模拟）、移动端 390 / 桌面 1440 审计溢出与改前一致。
+⚠️ **纪律（又踩一次）**：验收跑着的时候别并发跑别的（我并发跑了变异测试，verify 当场把注入的旧写法抓成 FAIL ——
+守卫是对的，但那轮结果得作废重跑）。这条上次已写进 details 三十二，这次是实锤。
+
+---
+
+## 补：日历弹层也要（用户确认手机上好操作、多 18KB 可以接受）
+
+前面把筛选区的 `type=date` 换成了纯手输文本框、没有日历弹层；用户要日历。最终决定：
+**flatpickr 与 datetime-input.js 都改成无条件加载**（js+css+l10n 约 18KB gzip），
+`Page.Flatpickr` 字段与三处 `p.Flatpickr = true` 一并删掉 —— 不再用「按页开开关」，
+因为那正是这次日期框 bug 的根源（只挂了 datetime-local、type=date 没人管）。
+
+实测（展开筛选面板后）：390/320 下 /stats /map /places 的日历都在最上层（z-index 99999）、
+完全在视口内、`elementFromPoint` 命中日历本身；打字 20260606 → 2026-06-06 不变。
+守卫 `TestDateInputsGoThroughAttachAll` 相应改成钉「无条件加载 + 不许再出现 {{if .Flatpickr}}」。
+
+回归：verify.sh **PASS=349 FAIL=0 SKIP=0**、JS 45/45、320/390/1440 溢出与改前一致。

.workbuddy/memory/2026-10-10.md

@@ -0,0 +1,47 @@
+# 2026-10-10
+
+## 日历弹层返工 + 统计页排版（承接 10-09 的日期框改造）
+
+用户反馈两点：① 日历「空间显示异常」且是英文、和项目割裂；② 类型分布与一天中的分布仍是
+一左一右、右边下面一大片空白。
+
+### ① 日历：两个独立的坑
+
+**a) 英文文案**：`flatpickr.localize(l10ns.zh)` 原先只写在三个后台页的 `whenReady` 里；
+昨天把 flatpickr 放到公共页（筛选区）之后就漏了 ⇒ 日历全是 Sun/Mon/January…
+修法：移到 `datetime-input.js` 的 `attachPicker` 里（`localizeOnce()`，全局只调一次），
+三个后台页里那三行重复调用删掉。
+
+**b) 头部重叠（用户说的「空间异常」）**：月份下拉被撑满整行、压在年份输入上。
+根因是**站点全局的 `input/select` 样式扫进了日历内部** —— 那条规则带 `width:100%`、
+7px 内边距、边框与 16px 控件字号（`input.numInput` 是 `type=number`，`select.flatpickr-monthDropdown-months`
+是 select，都躲不过）。
+⚠️ 第一版修法是错的：我在后面补了一条 `.flatpickr-calendar input{...}` 去对冲，
+**压不过**——全局选择器带 10 个 `:not([type=…])`，特异性 (0,10,1)，实测年份框仍是站点样式。
+正确做法是在**全局规则里排除**：`input…:not(.numInput)`、`select:not(.flatpickr-monthDropdown-months)`，
+`input:focus` 的焦点环同理（否则年份框上套一圈主色光圈）。
+实测日历内部只有 4 个控件：`select.flatpickr-monthDropdown-months` +
+`input.numInput.cur-year / .flatpickr-hour / .flatpickr-minute`。
+
+实测结果：星期「周日 周一 …」、月份「十月」、`overlap=0`（月份 82px、年份紧接其后）、无 JS 报错。
+
+### ② 统计页：体量差太多的卡片别并排
+
+`align-items: start` 只消掉了**卡内**空白，消不掉并排本身的空 —— 类型分布 1411px 与
+一天中的分布 256px 并排，右侧下面必然空一大片。
+改成 `<div class="grid">`（单列）：两张卡各占整行（1080px），24 根柱终于有宽度可用，
+列表也像「城市排行」那样横铺。实测 top=1183 → 2625，都全宽。
+
+**回归**：verify.sh **PASS=349 FAIL=0 SKIP=0**、JS 单测 45/45、移动端 390 溢出全 0、
+桌面 1440 与改前一致（−15 是滚动条宽）。
+
+## 专题的迷雾按区域收口
+
+用户问「我创建了一个专题，但是迷雾好像无法根据选择显示范围？」——查下来是**实现缺口**：
+专题的中心/半径只用来 `fitCircle` 定视图，迷雾图层一直是全局的；管理页那句
+「区域内的世界迷雾由地图按视野自动呈现，不需要单独圈选」属于**文档与实现不符**（把「没做」写成「不用做」）。
+用户选定口径：**按专题区域收口**（迷雾是累积快照、无时间维度，所以不按时间范围收口）。
+
+改 4 个文件：`rond-map.js`（新建 `rondFog` pane + `clip-path: circle()`）、`topic.html`（`.Topic.HasArea` 时下发
+`fogArea`）、`admin/topics.html`（把那句错提示删掉、补正确说明）、`frontend_fixes_test.go`（守卫）。
+细节与三个坑（不能裁 `tilePane`、圆心要 `project()`、注册必须排在 `applyFit()` 之后）见 details 四十五。

.workbuddy/memory/2026-10-12.md

@@ -0,0 +1,136 @@
+# 2026-10-12
+
+## 专题的「迷雾显示区域」改成一组圆（多圆 + 地图点选）
+
+用户提出两点：① 显示区不该只有一个圆，应该能圈多个；② 应该在**地图上点选**，
+而不是让他手填经纬度和半径。
+
+### 方案（先出清单获批，分批落地）
+
+先摸清了现状：单圆硬编码在 6 处（`topics` 三列 / `HasArea` / `topicAreaCond` /
+`fitParams` / 后台三个输入框 / `topic.html` 的 `fogArea`）。同时发现项目里**已经有**
+一套现成的地图选圆交互（`/admin/fog-mask` 那个页面：点选圆心 + 拖拽 + 半径可调 +
+多圆列表），可以直接抄它的模式。而 `fog_masks` 是**另一个语义**（圈内迷雾对访客隐藏），
+用户明确这轮不动它。
+
+三个岔路口问过用户，都选了推荐项：只改专题（不做站点级）、后台做成**专题表单内嵌地图**
+（不是独立管理页）、不动遮罩区。
+
+原计划 B1（存 areas）/B2（查询认多圆）之间会留一个「存了但只认第一个圆」的陷阱状态，
+所以合并成一批：数据层与查询层一起做，后台先用兼容桥（仍手填单圆，落进 areas）。
+
+### 落地（三个提交）
+
+- `1bb35db` 后端与查询层：`topics.areas` jsonb 数组 + 存量回填；`Topic.AreaList()`
+  归一（改为空格时退回老的三列，未回填的老行与直接构造 Topic 的调用方都继续工作）；
+  `topicAreaCond` 改成 N 个圆的 OR；`fitParams` 改用所有圆的并集外接矩形。
+- `44763df` 前台渲染：`clip-path` 从 `circle()` 换成 `path()`（多子路径、同绕向 ⇒
+  nonzero 下自然并集）；拼路径抽成 `fog-clip.js` 以便跑 node 单测；顺带清掉已死的
+  `fitCircle`；`verify.sh` 挂进前端单测。
+- 待办（B3）：**后台地图编辑器**还没做（专题表单目前仍是三个手填输入框）——
+  这是用户最初诉求的第二半，下一批做。
+
+### 关键取舍
+
+- **为什么不单开一张表**：圆是专题定义的组成部分、与专题一起读写、没有独立生命周期；
+  单开表还要过一遍「能不能从备份重导」的归属口径、改 `dataset_ownership_test` 白名单、
+  注意迁移块顺序。jsonb 一次全绕开。
+- **废弃列保留并镜像第一个圆**：回滚旧二进制时退化成「第一个圆」总比「没有区域」强。
+- **`fitCircle` 删掉**：多圆表达不了「圆心 + 半径」，留着就是两套并行的贴合口径。
+
+### 只在这轮踩到的坑
+
+- **CSSOM 会把 `clip-path` 规范化**：`style.clipPath` 读回来被补上空格
+  （`path("M 405 296 a 87 87 …")`），且位置不固定（`296 a87`）、第一个子路径尾部
+  还可能多个空格。想解析回几何必须每处分隔都用 `\s*`/`\s+` 容忍，别写死 ——
+  我连着写错两版正则（先是 `Z$` 卡在尾部空格）。
+- **`--clip` 截图的 `pad=10`**（×scale）又咬了一次：这次用**自校准**绕开的 ——
+  用单圆掩码反解出 scale 与 offset（实测 2.0 / 19.2），不再手算元素坐标。
+
+## 后台的显示区编辑器（B3，用户诉求的后半）
+
+三个手填输入框（中心纬度/经度/半径）换成**地图 + 圆列表**：点地图加圆、拖圆心移动、
+拖圆边改半径、列表里可改半径/定位/删除、可一次清空；改动立刻写进隐藏字段
+`areas`(JSON) 与 `crs`，随专题表单一起提交。复用 `/admin/fog-mask` 那套约定
+（`/api/map-config` 取底图、底图坐标系随表单带上、后端换算成 GCJ-02），不另起炉灶。
+
+### 实测抓到的 bug（探针一跑就现形）
+
+`/admin/topics` **没设 `p.HasMap = true`** ⇒ 布局不引入 Leaflet。表现极隐蔽：
+脚本加载了、`rondTopicAreas` 也在，就是 `window.L` 永远 undefined，`init` 静默返回、
+**控制台不报错**、页面看着像「什么都没发生」。已加守卫
+`TestTopicsAdminPageLoadsLeaflet`（按函数体截取后断言含 `HasMap = true`）。
+记忆里那条「带地图页须 `p.HasMap=true`」是真的会咬人。
+
+### 两个设计上的取舍
+
+- **areas 的初值渲染进隐藏字段**（`value="{{.Form.AreasJSON}}"`），JS 也从隐藏字段读初值，
+  而不是另传一份。这样脚本没加载上时，表单提交的仍是服务端渲染的原值 ——
+  否则一次保存就把已有显示区**静默清空**。守卫
+  `TestTopicAdminUsesMapEditorNotCoordInputs` 钉住了「初值来源」与「旧输入框必须没了」。
+- **上限两边各写一份**（前端 `MAX_AREAS/MIN_KM/MAX_KM` vs 后端 Go 常量），并加守卫
+  `TestTopicAreaLimitsMatchBetweenGoAndJS` 直接比对数字。不一致的表现很别扭：
+  前端放行、后端拒绝，用户看到一句红字却不知道改哪里。
+
+### 小坑
+
+- 半径输入框套了一层**定宽容器**：站点全局 input 规则是 `width:100%` 且带 10 个 `:not()`
+  （特异性 (0,11,1)），直接给 input 写宽度压不过。
+- `topic-areas.js` 只把**纯函数**（校验/序列化/增删改/几何换算）暴露出来供 node 单测，
+  另加一个最小测试钩子 `api._map` 供无头验证（同 `window.rondMap._state` 惯例）——
+  不给把手就只能真拿鼠标点地图，CDP 下很难稳定复现。
+
+### gofmt / 行尾
+
+`gofmt -l` 报的整文件重写有两层原因，已一并处理：
+① Go 1.19 起 gofmt 会重排**文档注释**里的缩进列表（我写的 `//  ① …` 被要求改成 tab 缩进块）；
+② 工作区是 CRLF 而 `.gitattributes` 声明 `eol=lf`。
+`gofmt -w` 归一后 `git diff` 没有额外噪声 —— 说明 **blob 本来就是 LF，CRLF 只是检出产物**，
+之前担心的「模板 CRLF 与 .gitattributes 冲突」不是仓库内容问题。
+
+### 记忆压缩
+
+`MEMORY.md` 压到 **8919**（原 9285）：合并「归属口径/防复发」与「跨备份/附属数据」两节
+（同属归属）、若干长条目的**理由**下沉 details（规矩一字未删）、收紧自己新加的那条。
+12 节 → 11 节。
+
+## 修 bug：半径输入框被浏览器原生校验误判
+
+用户反馈「输入半径总是提示『请输入一个有效的值，最接近的两个有效值为 XX 和 XX』」。
+
+**根因**：`<input type="number">` 的 **`step` 是相对 `min` 递增**的，不是「`step` 的整数倍」。
+`min=0.05` + `step=0.5` ⇒ 合法值只有 `0.05 / 0.55 / 1.05 …`，于是 3、3.5、7.25 全被判非法。
+关键是**这是浏览器原生提示**：JS 与后端都拦不到，我们自己的校验根本没机会说话。
+
+实测对照（同一元素只换 step）：
+`step=0.5` → 0.05✓ 1✗ 3✗ 3.5✗ 7.25✗ 13.37✗；`step=0.05` → 13.37 仍✗；`step=any` → 全✓。
+采用 `step="any"`，保留 `min/max`（真实边界 + spinner 范围），把校验交给 JS/后端。
+
+**加了一条通配守卫**（`TestNumberInputStepNeverMismatchesMin`）：扫**所有**模板的数字框，
+凡「有 `min` 且有数值 `step`」就要求 `min` 是 `step` 的整数倍（或 `step="any"`）；
+JS 动态建的输入框模板扫不到，另用 `TestTopicAreaRadiusInputAllowsAnyStep` 钉住。
+变异验证过（step 改回 0.5 ⇒ 守卫立刻红）。全站其它数字框（`radius_m` min=50/step=50）
+本来就合法，未动。
+
+**顺带**：把 `admin/topics.html` 的工作区行尾归一到 LF。`git add` 之后**零改动** ⇒
+再次确认 blob 本来就是 LF，CRLF 只是检出产物（那条 CRLF 警告是 stat 缓存假象）。
+
+## 推送这个仓库要认证（非交互环境会卡住）
+
+用户让「提交一次」时本地其实已经全部提交完了（每批做完就提交），工作区干净；
+唯一没做的是推送。结果 `git push origin master` **卡了 7 分钟没有任何输出**。
+
+诊断（下次直接照这个查）：
+
+- 远端 `git.shiroko.one` 的 **读是匿名的**（`upload-pack` HTTP 200）、
+  **写要认证**（`receive-pack` HTTP 401）⇒ 所以 `git fetch` 一切正常、唯独 push 卡住。
+- `tasklist` 里能看到 `git-credential-helper-selector`（**有可见窗口**，标题
+  `CredentialHelperSelector`），`git config credential.helper` = `helper-selector` +
+  PortableGit 自带的 `git-credential-manager.exe`。本机从未推过这个仓库 ⇒ 触发选择器弹窗等人。
+- 判据：`netstat` 里到远端的连接**根本没建立**（ESTABLISHED 全是本机 postgres），
+  说明停在认证之前，不是网络慢。
+- ⚠️ `git push | tail -N` 会把进度缓冲住，看起来「一片空白」——排查时别用管道。
+
+处置：结束掉 push 那几个进程（不动本地提交，也不会留 `.git/*.lock`），
+**由用户在自己的终端里推**（交互式提示看得见）。
+**结论：以后不要在这个环境里代跑 `git push`，直接把命令交给用户。**

.workbuddy/memory/2026-10-13.md

@@ -0,0 +1,49 @@
+# 2026-10-13
+
+## 排查「专题里的圆大小不随缩放变化」（结论：未能复现，行为是对的）
+
+用户反馈：专题里的圆无论怎么缩放，屏幕上的大小都一样；而且「新圆半径 25km 居然覆盖了整个南宁」。
+库里实际存的是 3 个 `radiusKm: 20`（北海 / 南宁 22.815547,108.367767 / 柳州）。
+
+四处实测（无头 CDP，全部换算回地面公里）：
+
+| 位置 | 结果 |
+|---|---|
+| 编辑器 `L.circle`（半径 25） | z9=178px / z11=710px / z13=2842px（每级翻倍），反算始终 25 km，期望 177/711/2847 —— 吻合 |
+| 编辑器「改半径」把手 vs 圆心 | 20.038 km（该圆半径 20 km）—— 位置准确 |
+| 前台专题页的迷雾裁剪圆 | z7→z10 像素半径 17→141（应 142），换算始终 ≈20 km |
+| 同一缩放改「新圆半径」 | 3→42px、10→142、25→356、50→710，与反算 43/142/355/711 一致 |
+
+⇒ **三处画圆全都是地理锚定的、都随缩放正确变化，半径值也确实生效**，复现不出「大小不变」。
+
+「20 km 覆盖整个南宁」是**对的**——用他自己的数据验证：圆心 20 km 内落了他 477 个地点中的
+**45 个**，最远的是西乡塘的广西民族大学相思湖校区（14.5 km）与良庆的五象万象汇（10.2 km），
+也就是从相思湖一直盖到五象新区，正是南宁建成区的跨度（约 20~25 km）。
+20 km 半径 = 40 km 直径；只想圈市中心得用 5~8 km。
+
+### 找到一处真实缺口
+
+**后台编辑器的地图没有比例尺**（`L.control.scale`）：`scaleBar=0`（前台专题页 `=1`）。
+画圆时没有任何长度参照，很容易得出现「这个圆怎么这么大/怎么没变化」的判断 ——
+大概率就是这次困惑的来源。待办：给它加比例尺；圆列表里把半径的后果写出来（如「20 公里（约 40 公里宽）」）。
+
+### 排查时的两个自坑（记下来省时间）
+
+- 地图与迷雾 pane 在 `load` 之后还要等 `/api/map-config` 回来才初始化：`--wait 5` 会拍到
+  「pane 不存在」，`--wait 8` 才稳。别把「还没初始化」当成「功能没生效」。
+- `--eval-file` 里写 `(async function(){...})()` 却**不加 `--await`**，CDP 拿到的是 Promise，
+  `returnByValue` 序列化成 `{}` —— 看着像脚本没执行，其实是漏了参数。
+
+### 处置：补「参照物」（提交 6aee7e4）
+
+用户选定「加比例尺 + 标注直径」。几何逻辑**一行没动** —— 因为问题本来就不在几何：
+
+- 编辑器地图加 `L.control.scale`（公制，`position:'bottomleft'`，跟前台一致）。
+- 新增纯函数 `spanLabel(radiusKm)`：半径 →「约 40 公里宽」（直径）；<1 公里改用米，
+  免得出现「约 0.1 公里宽」。圆列表每行标，**「新圆半径」旁边也实时跟着变**（落点前就能判断）。
+- 守卫 `TestTopicAreaEditorGivesSizeReference` 钉住比例尺与跨度标注（变异验证过）。
+  ⚠️ 它当场抓到我自己的疏漏：模板的 init 调用漏传 `spanId`，靠脚本默认值兜着 ——
+  已改成显式传参（**新增 opts 时记得在模板里也写出来**，否则守卫和外人都看不出这层耦合）。
+
+教训：这次「bug」的本质是**界面缺参照物**，不是算错。以后遇到「大小看起来不对」类反馈，
+先问「用户手上有什么可以量」，而不只是去验算几何。

.workbuddy/memory/MEMORY.md

@@ -0,0 +1,111 @@
+# rond-with-you 硬规矩（索引）
+
+> 全文：`.workbuddy/memory/MEMORY-details.md`（47 节）；验证机制：技能 `rond-fix-verify`；备份包解析/导出：技能 `rond-backup-parse`。本文件只做关键词索引——**新规矩写 details，别堆这里**。
+>
+> ⚠️ 本文件**按字符数**注入，硬上限 1e4（`MAX_MEMORY_CHARS`；中文 1 字算 1，不是按字节）。超了会被 `substring` 截断＝**尾部静默丢失**。日常日志与 details **不参与注入**，可随便写。现值见 `wc -m`，留 20% 余量。
+
+## 落库 / 精度（details 一、四、五、十六、十九、廿八A）
+- 建地点+到访**同一事务**；新行号只走 `nextSrcPK`+`clearStaleRaw`，**禁 `MAX(src_pk)+1`**。`seq_test.go`
+- 行程派生列同导入（`validateMovementForm`）：`from/to_place_id`（留空=绕过区域过滤直露访客）、`distance_km`、`duration_min`。
+- 表单精度低于真值 ⇒ 只改备注也**静默改时间/坐标**：`keepStoredTime`/`resolveMovementEnd`/`keepStoredCoord`；改到访时间须 `clampVisitMovements` 夹行程。
+- `src_pk` 只单数据集内有效；跨备份键=`ZIDENTIFIER_`/`ZUID_`；`contentHash` 别用 `SrcPK|Arrival`。
+- 坐标留档 `coord_source/coord_sys/src_lat/src_lon`；换算只走 geo 包与 `/api/coords`。
+- 脏数据：`appleTime` 超范围浮点转 int64 **回绕非饱和**（先卡秒数）；`validCoord` 非法归 `(0,0)`。`dirty_test.go`
+- 聚合刷新（`saveVisitTags`/`refreshPlaceAgg`/`refreshDatasetAgg`/`activityFlags`）**必须返回 error**。`agg_error_test.go`
+- 收藏切换走单语句 `UPDATE … RETURNING bookmarked`。`visit_bookmark_test.go`
+
+## rond 导出（details 二、廿六）
+- 铁律：**PG 覆盖管理列、`entity_raw` 还原其余列**；基线已有行保真机原值（`keepNilCols`+`known[pk]`）。
+- 新行只补 `ZRAWLATITUDE/LONGITUDE`、`ZVISIT.ZIDENTIFIER_`/`ZACTIVITY.ZUID_`（确定性=表名+src_pk）、`ZICON_`、`ZLASTARRIVALDATE_` 哨兵 `-63114076800`。
+- `ZMOVEMENT.ZTYPE_` 不能 NULL、**别当管理列**（会洗掉 type=4）；`queryTransports` 必须 `GROUP BY transport_src`。
+- rows 收尾必须 `drainRows`（先 `Err()` 再 `Close()`）。`parse_rows_test.go`
+- **扫进裸 `bool` 的列必须先 `COALESCE`**：`weather.is_daylight` 漏写 ⇒ NULL ⇒ 整包拒收（details 卅C）。
+- 核对导出包**别按留档 UUID 找行**：站点新建行会被补派生 UUID（`coreDataUUID`）。
+- **换基线**（`/admin/baseline`）：站点数据一行不动，只换底稿。判据=到访 UUID 重合率（`matched==0` 硬拒）+ 干跑导出；记档 `datasets.baseline_*`，`ensureBaseline` **必须先看记档**；留档名**必须防重名**。`baseline_swap_test.go`（卅三）
+
+## 迷雾 / 遮罩（details 三、九、十、廿二）
+- `.fwss`=zip、条目 zlib；`Model/*/`=头 32768B+每块 515B；`Model/~/`、`Model/#/` 原样写回；清空/替换都要连 `fog_raw_files`。
+- 导入三段式（preview 暂存 → 差异页现算 → `?stash=` 落地）；带 stash=urlencoded、无 stash=multipart 两条都留。
+- `fog_masks` 圆心 GCJ-02+半径，判定前换 WGS-84 网格；遮罩只对访客；`stats.Filter` 有**两套 where**（`visitsWhere`+`movementsWhere`），漏一个=「到访藏了里程还在」。
+- 瓦片须与底图同 `crs`；带地图页须 `p.HasMap=true`。
+- `tileDigits` 补前导 0；`tileName` 尾缀 `len(s)-2` 单数字编号时为 -1 ⇒ panic；解码守卫 `len(name)<8`。
+- `fogIndexV` 必须 `atomic.Pointer`（普通指针=真 data race）。`fog_race_test.go`（-race）
+- **专题显示区＝一组圆（并集）**：存 `topics.areas` jsonb（不单开表）；SQL 是 N 个圆的 **OR**（每圆 3 个占位符，编号须恰好覆盖 `[prefix+1,len(args)]`）。裁剪＝**单独 pane**（不能裁 `tilePane`）＋ `clip-path: path()`，每圆一段**同绕向**子路径（反了重叠处会挖成洞）；圆心须 `project()`；⚠️ 注册必须排在 `applyFit()` **之后**（视图未定会抛「Set map center and zoom first.」并打断后续图层＝迷雾整片消失且不报错）。后台＝地图点选（`topic-areas.js`）；⚠️ areas 初值必须渲染进隐藏字段（脚本没加载就静默清空）、上限两边写死须一致（四十五、四十六）
+
+## 前端 / 模板 / CSS（details 六~八、十七、廿三、廿八D、卅七）
+- ⚠️ **对访客公开的块，措辞必须按身份分支**（`{{if .IsAdmin}}我的…{{else}}站长…{{end}}`）：
+  写模板时人站在站长视角下笔，「我的结论 / 你自己 / 我推荐的地点」露给访客就没人读得懂。
+  照 `place.html` 投票区与 `rond-map.js` 气泡的写法。门禁 `TestVisitorPagesUseThirdPersonCopy`
+  （以访客 ctx 渲染 `/`、`/stats`、`/report` 逐个断言禁用词，并确认站长那份仍说「我的」）。
+- 改 Go 必须重启；模板/CSS/JS 只在 `debug=true` 热加载（`AssetV` 启动哈希）。⚠️ **新模板+旧二进制**＝「渲染到一半仍 200」；启动自检 `smokeRender` 会拒启（四十一）。
+- 字阶/圆角/阴影**只走令牌**，裸 `font-size: 13px` 有静态守卫 `TestNoBareFontSizePx`；卡片三档 `.card--hero/--quiet`。⚠️ 改**根字号**要查 Leaflet（`.75rem` 会跟着漂），（四十二）。
+- 类型色走 `csscolor/csssoft`（**必须返回 `template.CSS`**，否则 `var()` 被换成 `ZgotmplZ` 且不报错）；这套色连 3:1 都不到，**只能当圆点标记**。窄屏导航收进 `.nav-menu`，顶栏 `--z-nav` 必须高于地图浮层（四十三）。
+- 日期控件一律走 `attachAll`（原生 `type=date` 年段会吞 6 位数字 ⇒ 敲 20260606 变 `202606/06` 且值为空），模板里有守卫。`.grid` 必须 `align-items:start`（四十四）。前端单测（`static/js/*.test.js`）已挂进 verify.sh，**node 缺失直接失败不跳过**；可测的纯函数要抽成独立文件（`rond-map.js` 是大 IIFE，取不出函数）。数字框 `step` 须 `any` —— 它相对 `min` 递增，写死小数会把正常值判非法，且那是**浏览器原生**提示、JS/后端都拦不到。（四十六）
+- 拼查询串走返回 `template.URL` 的方法（`PlaceLink`/`EditPlaceLink`/`MapLink`/`EditLink`），勿手工转义。
+- 窄屏覆盖写 `app.css` **末尾那块**；宽表堆叠类名**成对** `class="tb tb-stack"`；触控 44px。`tb_stack_test.go`
+- 加表格列：`PlaceCols`/`scanPlace` **成对**、新列追加最后；CJK 挤换行只抬该表 `min-width`。
+- ⚠️ 模板 JS 别用「heredoc+python」写 `\n`（`<script>` 语法错、交互全哑而模板测试照过）；用 Edit，改完 CDP 验 JS 报错为空。`inline_script_test.go`
+- 只在访客复现的 bug：先比「无 cookie 原始 HTML vs CDP 后 DOM」；别让 JS 从 `{{if .IsAdmin}}` 块读 id。
+- **异步回包一律发序号作废**：`var seq=++xxxSeq;` 在 `if(!on) return;` **之前**，回包首行 `if(seq!==xxxSeq) return;`。`map_async_cancel_test.go`
+- `window.localStorage` 一律经 `lsGet`/`lsSet`（隐私模式裸访问会抛）；`previewQueue[id]` 须在 `if (live)` 之前排队、回调消费后删。
+
+## 编辑页 / 重复到访（details 三十）
+- 「重复到访」卡片：判定与 `tools/dedup_site_visits.py` 同语义、**UUID 是前提**、基线对不上就不给按钮；改指合并标记只动**本来就有**的键（`create_if_missing=false`）。`dup_visits_test.go`
+- **已并入 / 子段（`ZMERGEDTO`/`ZPARENT`）只在读侧收口**，判据唯一一份 `stats.SoloVisitSQL`；天气与位移**不收口**；导出侧一字节不动。收口点清单见 details 卅G。
+- 相对计数断言会**假绿**（变异让基准值一起膨胀），必须写定义性不变量；`render` 是流式直写，`code==200` 不等于渲染完。
+- ⚠️ ingest 地点聚合回填必须排在 `insertEntityRaw` **之后**（判据读 entity_raw）。
+
+## 活动 / 类别（details 廿四、廿五）
+- **活动是表，类别不是**——类别只是 `places.poi_category` 字符串列；显示名**绝不写进该列**（`TestCategoryLabelNeverTouchesValue`），走 `categoryLabel(v,custom)`，Go 侧算好塞。
+- 站内新建行 `entity_raw.raw IS NULL`；`ZCATEGORY_` 真机只有 `MKPOICategoryXxx` 枚举。
+- 类别候选：编辑/照片页=库里在用 `GROUP BY`；补全页=在用 ∪ 静态表；下拉留「其它（自己写）」，默认「不动」。
+
+## 归属口径 / 跨备份 / 附属数据（details 十九~廿一、卅四、卅五）
+- ⚠️ **铁律：这份记录能不能从备份重新导入？** 能 ⇒ 可挂 `dataset_id … ON DELETE CASCADE`
+  （places/visits/movements/weather/activities/tags/entity_raw）；**不能 ⇒ 只留 dataset_id 当出处、不许挂外键**
+  （place_images/place_notes/place_votes/topics）。挂在备份里没有的表上 = 删数据集就永久丢失。
+- 两道门禁都钉着它：运行时查 `pg_constraint`（表必须在白名单里，反向也查）+ **静态扫 `schema.sql`**
+  （新建的库走 CREATE TABLE，只看运行时会有盲点）。`dataset_ownership_test.go`（卅五）
+- **体检常驻后台首页**：库里 N 张 / 本地盘上 M 个 / 落单 K 个（`imageHealth`）——
+  事故的本质是「行与对象悄悄对不上、没人发现」，让它当场可见而不是等照片消失才追。
+- 预演按 `VisitUUID`/`ActivityUUID` 对齐、只读；`raw #>> '{ZIDENTIFIER_,$blob}'` 是 base64 须转 hex 比；地点只认坐标（`PlaceCoordKey` 6 位）。
+- 附属数据（备注/投票/图片）主键=`place_key` 坐标键（非 dataset+src_pk）；Go 与 SQL 两套须逐位一致。
+- **站长结论（`place_votes`）与访客票（`place_visitor_votes`）是两码事**：各存各表、各看各榜（`votes.TopVisitorVoted`，`HAVING` 只算有票的方向）。
+  ⚠️ 票表也按坐标键跨数据集读 ⇒ 用例必须按 `place_key` 清历史票，否则票数越跑越多。（卅六）
+- ⚠️ **附属数据不能挂数据集外键**（`place_images` 曾按 `dataset_id` CASCADE ⇒ 删数据集=删行、**文件还在盘上**）；
+  恢复走后台「图片挂载恢复」，认地点靠 `baselines/<id>.sqlite`（**别清该目录**）；
+  ⚠️ 来源必须**全部读进来合并**（places → entity_raw 留档 → 该 sqlite 及**每份 `.bak`**），只看当前那份会整片认不出。`image_recovery_test.go`
+- ⚠️ 恢复**同时扫对象存储**（R2/S3）：`media.ListObjects`（ListObjectsV2 + SigV4，查询串先编码再签），
+  需 `s3:ListBucket`；列不动时本地照救 + warning。**专题同理**：`topics` 已改成归人不归数据集（`user_id` 过滤，内容仍照生效数据集算）。（卅四）
+- ⚠️ `schema.sql` 迁移块必须收敛且排在依赖表之后（插在 `place_images` 前：开发库无症、**新库起不来**）。
+- 合并 `backup_merge.go`：整个 `withTx`、不删除；新行 `*_visit_src` 写**库里的 src_pk**；必须 `writeRawRow`；删地点前先查有无到访（CASCADE）。
+
+## 后端 / 性能（details 十、廿八C）
+- `findSourceArchive` 先按 `size_bytes` 筛再算 sha256。池 8/8 + `db.WarmUp(d,6)`；页面内查询 `runJobs`(≤6)；别用 `fog.Index.All()`；改遮罩须 `masks.invalidate()`+`fogTiles.clear()`。
+- `placeCols` 子查询必须带 `vN.dataset_id=p.dataset_id`。`stats/placecols_test.go`（按子查询分段判）
+- multipart handler 直接 `ParseMultipartForm`（`r.ParseForm()` 毒化字段）；**之前必须 `MaxBytesReader`**。五个上传口：备份/GPX/迷雾/照片/地点图片。
+- 包了 `ResponseWriter` 必须实现 `Unwrap()`（`gzipWriter`/`headerSent`）；`recover` 写错误页前须看 `headerSent`。`server_error_test.go`
+- 「先落盘再解析」的上传 handler，落盘后每条失败路径都要删半成品。`upload_cleanup_test.go`
+- 批量勾选走 `*Bulk` + `p.src_pk = ANY($3::bigint[])`；**全局内存缓存必须带上限**（`fillupCache` FIFO 淘汰最旧 1/4）；**同一查询别在一个 handler 里查两遍**。`admin_notes_bulk_test.go`+`fillup_cache_test.go`+`stats_weekday_once_test.go`
+- 加 `setting` 字段改三处：`Default()`/`Load()`/`settingsSubmit()`。
+
+## 安全 / 跳转（details 廿八B）
+- 跳转唯一判据 `safeInternalPath`（`view.go`）；四处共用。`redirect_target_test.go`（含禁弱判据静态扫描）
+- cookie `Secure` 按请求判断（`cookieSecure`），否则本机 http 与 CDP 都登不进。
+- CSRF 只加同源 Origin/Referer 守卫（`csrf.go`）：仅写方法、`Origin: null` 拒、两头都缺放行。
+- `clientIP` 只认 XFF **最后一段**（须 `netip.ParseAddr`）；⚠️ 投票匿名身份=`hash(cookie,IP)`⇒改取法即改身份。
+- GPX 按属主收口：`/api/gpx` 取生效数据集 `user_id` 再 `WHERE user_id=$1`；`adminGpxDelete` 查 `RowsAffected()==0`。`gpx_owner_test.go`
+- 下载名走 `downloadDisposition`（ASCII 兜底+`filename*=UTF-8''`）；四出口都经此。`download_name_test.go`
+- `writeRawRow` 必须上抛错误让 `withTx` 回滚。**两步验证两闸都要**：`loginGuard`（键 `"2fa:"+用户名`）+`CodeReplay.Consume`。`twofa_guard_test.go`+`code_replay_test.go`
+
+## 口径 / 404 / 验收（details 十一~十三、廿七、廿八E、卅二）
+- ⚠️ **跑全量验收前**：① `VACUUM (FULL, ANALYZE)`（死元组涨到 3.3GB 后级联 DELETE 变 IO 爬虫，看着像 hang）；② 库内必须有 `is_active` 数据集，否则 `internal/stats` 6 用例**假 skip**。跑着时别并发跑定点测试。
+- 区域判定**两端各过一遍再 AND**（同 `regionSQL`）；`movementsWhere` 也必须两端各判，不能用 `EXISTS(... IN (from,to) ...)`；比较列一律 `COALESCE(col,'')=$n`。`region_consistency_test.go`
+- 其余（累计停留口径、`Filter.Verdict` 下沉、404 分档、验收四件套、覆盖率 `-coverpkg`）见 details 卅二。
+
+## 备份合并 / 导出链路（details 卅一 + 廿一）
+- 对齐键：到访=`ZIDENTIFIER_`、地点=`PlaceCoordKey`（坐标 6 位，**不认名称**）、活动=`ZUID_`；合并前必须**重算差异**。
+- 地点配对只有一份实现 `rond.MatchPlaces`（差异与合并共用）；同名兜底必须有距离上限（`nameMatchMaxKm=1.0`）。
+- 差异页默认 radio 是「**用实机**」；写合并测试要照这个提交（抓 `value="backup"`），否则测的不是真实点击行为。
+- 自检不变量：合并后没有任何地点被搬动 >1km、也没有任何到访离它的实机地点 >1km。
+- **三条铁律**：① app 只靠 `Z_PK` 解引用 ⇒ 导出编号必须与**数据集基线**同一套 ⇒ **基线必须是手机包**；② rond 导入是**整库替换** ⇒ 导入前先清空 app 数据；③ 站点数据是超集 ⇒ 用「手机导出作新数据集 + 旧站点导出当备份合并进去」；`ZRAW` 这类从源包抄来的计数会越界，靠导出侧夹取兜住。

README.md

@@ -33,6 +33,32 @@
 | 设置 | 站点标题与头像、主题色、主页模块开关、访客可见页面、访客可见区域、隐家/隐工作、图片存储、默认底图 |
 | 账号 | 改密码、两步验证（TOTP） |
 
+### 数据编辑页上的「重复到访」
+
+站点里可能多出一条一模一样的到访，成因有两种，卡片上会分别标出来：
+
+- **站点侧副本**：同一次到访在站点存了两份，差别只在 UUID（站点侧生成的那份在手机包里找不到）。
+  合并与差异页都是按 UUID 认人的，于是它被当成「备份新增」。
+- **补录行被合并回来**：站点**补录**的到访没有留档、也就没有 UUID；导出时会被补上一个确定性的
+  派生 UUID（`v5("ZVISIT/<编号>")`）写进包里，手机于是把它当成一条真记录。这份包再合并回站点时，
+  站点这侧没有 UUID 可对齐，又插了一条。
+
+判定以**这份数据集的基线（导入时留下的手机包）**为参照（第二类不用基线）。卡片只在检出时出现在
+数据编辑页，默认全选 + 二次确认；清理会连它的位移 / 天气 / 留档一起清——「补录行被合并回来」那类
+会把位移 / 天气**改挂**到保留项（补录行自己名下没有位移，跟着删就白丢里程），并把指向它的合并
+标记改指到保留项。基线不可用或与本站一条都对不上时，只判第二类，另给一行说明。
+
+命令行有一条等价的工具 **只覆盖第一类**：`tools/dedup_site_visits.py`（默认只预演，加 `--apply` 才动手）。
+
+### 为什么有些到访在页面上看不到
+
+手机包里有两种「不独立成立」的到访：被别的到访**并入**了的（`ZVISIT.ZMERGEDTO`），
+以及某个长驻记录下的**子段**（`ZVISIT.ZPARENT`）。rond 自己既不显示、也不把它们算进次数与停留，
+本站因此也不算——时间线、统计、地点计数、地图城市圈都不含它们。
+
+⚠️ 这些行**不删**：导出包必须原样带着它们，rond 要靠它们认这次合并发生过。
+数据编辑页会照常列出，并打上「已并入 #562 / 子段 #374」，方便核对。
+
 ## 技术栈
 
 | 层 | 选型 |
@@ -110,6 +136,63 @@ go build -o rond .
 - **回导**：后台可导出修改过的 `.rondbackup`（含补录的记录，坐标为 GCJ-02 原样写回），
   可直接导回 rond App。导出走「基线库 + 覆盖」，不重建库
 
+## 换基线（让导出底稿跟着手机换代）
+
+导出**不是**从零重建数据库，而是以一份「底座」（`storage/baselines/<数据集>.sqlite`）为底，
+只覆盖站点托管的那几张实体表。Core Data 元数据、索引、持久化历史、`ZRAWVISIT` 原始采样点、
+`ZTRIP*` 等一律原样带出来——**所以底座必须是手机导出的包**，拿本站导出的包当底座会越导越失真。
+
+底座一旦定下就跟着数据集走。手机那边重新导出后想换代，以前只能整包重新导入成新数据集
+（站点侧补录的行、主题、备注都得重新收拾）。后台「换基线」就是给同一份数据的底座换代用的：
+
+- **站点数据一行不动**，只换底稿；换完导出立刻以新底座为准。
+- 两道判据：① 这份包与当前数据集得是同一批数据（按到访 UUID 认，低于一半要显式确认，
+  一条都对不上直接拒绝）；② 这份底座得真的能导出（先用它干跑一次导出，失败就放弃替换）。
+- 替换前旧底座自动留档（最近 3 份），换错了在页面上一键回滚；回滚本身也留档，可再滚回来。
+- 换过的底座记档在 `datasets.baseline_name/baseline_sha256`：底座文件丢了会**按记档重建**，
+  而不是退回最初那份旧包（否则上一次换基线会静默失效）。
+
+## 数据归属（删掉一份数据集会带走什么）
+
+一条铁律：**从备份导入的数据随数据集删除；站点自建的数据不随数据集删除。**
+
+| 会随数据集删掉 | 不随数据集删掉 |
+|---|---|
+| 到访、地点、位移、天气、活动、标签、原始行留档<br>（重新上传同一份备份就能再导回来） | 备注、结论、地点图片、专题 |
+
+判断标准很简单：**这份记录能不能从备份重新导入？** 能 ⇒ 挂 `dataset_id … ON DELETE CASCADE`；
+不能 ⇒ 只留 `dataset_id` 当出处、**不许挂外键**。图片那次事故就是反过来的：行被级联删了、
+文件却留在盘上，而读取是按坐标键跨数据集的——两套口径打架，删数据集就等于永久丢失。
+
+这条规矩有两道门禁守着，改坏当场红（不用靠记性）：
+- 运行时：查 `pg_constraint`，凡是挂 `datasets` 的表必须在白名单里（`TestOnlyBackupDerivedTablesCascadeFromDatasets`）
+- 静态：直接扫 `schema.sql` 的 `CREATE TABLE`（`TestSchemaDeclaresNoDatasetFKForUserData`）——
+  只看运行时有个盲点：新建的库走的是 CREATE TABLE，开发库可能压根没跑过那次迁移。
+
+另外**图片挂载体检**常驻后台首页（库里 N 张 / 本地盘上 M 个 / 落单 K 个）：
+行与对象对不上时会直接报警，不必等到照片看不见了才追。
+
+## 地点图片
+
+- **字节在浏览器里转成 WebP** 再上传，服务端只做形状校验、不重新编码（1 核机器扛不住解码大图）。
+- **存哪边**由后台设置决定：服务器本地磁盘（`<data_dir>/media/`）或对象存储（S3 / R2）。
+  对象键是 `<数据集>/<上传月份>/<地点号>-<内容哈希>.webp`，按月份分目录、带内容哈希天然去重。
+- **图片认地点靠坐标键**，跟备注、结论同一套：换数据集之后同一个地点照样看到同一张图。
+- ⚠️ **早期版本图片记录挂在数据集上**（`place_images.dataset_id` 带 `ON DELETE CASCADE`），
+  于是「删掉旧数据集」会把图片记录一起删掉，**而文件还留在磁盘上**——读取按坐标键、行却按数据集级联，
+  两套口径打架，实测丢过一批图。现在外键已摘掉，删数据集不再带走图片；已经丢掉的那批可以恢复：
+  后台首页「图片挂载恢复 → 扫描并恢复」，它按坐标把还在的对象挂回当前数据集的地点上
+  （只插记录、不动对象、可反复执行）。**本地磁盘与对象存储都扫**：
+  本地走目录遍历，对象存储走 ListObjectsV2 列桶——行没了就只剩桶里有那些键，不列桶无从得知它们叫什么。
+  ⚠️ 列桶需要凭据上有 **`s3:ListBucket`** 权限（R2 的 API Token 默认只给对象读写），
+  没权限时本地那半照救，页面会把该开哪个权限说明白。
+  认地点要用旧数据集留下的底座库（`<data_dir>/baselines/<id>.sqlite`）来还原「地点号 → 坐标」，
+  **所以别删那个文件**，换基线留下的 `.bak-*` 留档也别清——换过的底座未必还是上传那会儿的编号空间，
+  旧编号往往只在留档里（来源会全部读进来合并，逐个试到对上为止）。都没有才认不出，报告里会列出来。
+- **删除数据集**只清掉从备份导来的记录与原始行留档；备注、结论、图片按坐标键保留。
+- **专题归人不归数据集**：专题是「一段时间 + 一块区域」的定义，换数据集之后照旧成立
+  （内容照当前生效数据集算），删掉旧数据集不会再把它带走。
+
 ## 照片导入（补录没有轨迹的时间段）
 
 手机里的照片带着拍摄时间和 GPS，可以批量补成「地点 + 到访」。
@@ -176,14 +259,17 @@ go build -o rond .
   （把「未命名地点」改成「外婆家」）；备注默认只有站长自己能看到，可在「站点设置 →
   地点备注对访客公开」打开对外展示。
   两者按 rond 的地点 ID（`src_pk`）单独存表，重新上传备份、地点换了数据库 id 也不会丢。
-- **推荐 / 踩雷**：与自由文本备注分开的两类表态，用按钮交互。
+- **推荐 / 踩雷**：与自由文本备注分开的两类表态，用按钮交互。**站长的结论与访客的票是两码事**，
-  - **站长结论**（`place_votes`，按 `src_pk` 存）：详情页「我的结论」一键 👍推荐 / 👎踩雷，
+  各存各的表、各看各的榜，互不影响。
+  - **站长结论**（`place_votes`，按**坐标键**存）：详情页「我的结论」一键 👍推荐 / 👎踩雷，
     再点已选按钮取消；后台备注页也能逐行或批量打标。
-  - **访客投票**（`place_visitor_votes`）：详情页「大家怎么说」可点赞 / 点踩，一人一票、可改可撤；
+  - **访客投票**（`place_visitor_votes`，同样按坐标键）：详情页「大家怎么说」可点赞 / 点踩，
-    匿名身份由 cookie + IP 派生并哈希，清 cookie 也会被识别为同一来源，起轻度防刷作用。
+    一人一票、可改可撤；匿名身份由 cookie + IP 派生并哈希，清 cookie 也会被识别为同一来源，
-  - 展示：地点详情、地点库（行内徽章 + 「推荐 / 踩雷」筛选）、地图气泡；统计页有
+    起轻度防刷作用。
-    「推荐 & 踩雷」区块（站长结论计数、访客票数、两边榜单）。是否对访客公开由
+  - 展示：地点详情、地点库（行内徽章 + 「推荐 / 踩雷」筛选，都是**站长结论**）、地图气泡；
-    「站点设置 → 推荐 / 踩雷标记对访客公开」控制（默认公开）。
+    **统计页分成两块**——「推荐 & 踩雷（我的结论）」只算站长标注的，
+    「访客点赞」单独一块，按 👍/👎 票数列出**被顶得最高的地点**并带票数。
+    是否对访客公开由「站点设置 → 推荐 / 踩雷标记对访客公开」控制（默认公开），两块同一开关。
 - **备注批量管理**：后台「地点备注」页列出**当前数据集的全部地点**（不只已写备注的），
   支持关键词 / 城市 / 状态（全部 / 有备注 / 无备注）/ 排序筛选与分页；每行可就地编辑别名、
   备注并快速打标。顶部批量条可对勾选项**批量设置结论 / 清空备注（保留别名）/ 删除备注**；
@@ -304,3 +390,8 @@ GOOS=linux GOARCH=amd64 CGO_ENABLED=0 go build -trimpath -ldflags "-s -w" -o ron
 - 时间、坐标这类「原样回贴」的字段有讲究：表单精度（分钟 / 6 位小数）往往低于库里真值，
   保存时若与库里已有值落在同一精度上要沿用库里那份，否则只改个备注也会把时间或坐标悄悄改掉。
 - `tools/verify_rondbackup.py` 可以做导入→导出→逐表对账，检查改动有没有破坏备份保真度。
+- 全量验收 `scripts/verify.sh`（要 **0 FAIL / 0 SKIP**）。每个夹具都会导入一整包再删掉，
+  一轮下来测试库能留几百 MB 死元组，级联删除随之变慢（实测 16MB 时约 6 分钟跑完、
+  几百 MB 时半小时都跑不完，看着像卡死）。脚本会在库超过 `VACUUM_MIN_MB`（默认 200MB）
+  时先清一次死元组；手动来一次 `VACUUM (FULL, ANALYZE)` 还能把文件也缩回去。
+  另外要确认库里有生效数据集（`datasets.is_active`），否则 `internal/stats` 的对照用例会假 skip。

frontend-plan-2026-10-09.md

@@ -0,0 +1,210 @@
+# 前端现代化方案
+
+- **日期**：2026-10-09
+- **范围**：视觉层升级 —— `app.css`（1114 行）+ 24 个模板的样式类使用；**不动**信息架构、路由、模板数据结构
+- **方法**：先用无头 Chrome 在真实视口量现状（390 / 430 / 1440），再定方案。下面每个数字都是量的，不是估的
+- **前提约束**（这些都是现状，方案不得破坏）：无前端构建链（服务端渲染 + 单 CSS + 手写 JS）/ 1C1G 服务器 / 已有暗色模式（`prefers-color-scheme` 3 段）/ 已按 WCAG AA 调过 `--text-3`
+
+> ⚠️ `shots/` 里的截图（`mobile-home.png` 等）是**旧状态**：那张顶栏折成 3 行、右按钮竖排的图早就不成立了，
+> 现在 390 下品牌名只留 🐾、按钮是「后台」。做视觉判断前一律**现场重新截图**，别拿 `shots/` 当现状。
+
+## 一、现状实测
+
+| 观测 | 实测值 | 说明 |
+|---|---|---|
+| 卡片样式数 | 17 个卡片盒子（`.card`/`.kpi`/`.filters-card`）→ **只有 2 种样式指纹** | 全站一个「白盒 + 1px 边 + 浅阴影 + 10px 圆角」用到底，KPI / 地图 / 图表 / 表格 / 筛选器全等重 ⇒ 眼睛没有落点 |
+| 字阶 | 字号 **8 档**：10/12/13/14/15/18/21/23px，其中 **10–15px 挤了 5 档** | 中段过密、大段太少；层级挤不出来，只能靠加粗 |
+| 字重 | 400 / 500 / 600 / **650** | 650 是半档，等于没规范 |
+| 正文色 | **4 种**（`--text`/`--text-2`/`--text-3` + 链接）+ 1 个主色 | 整页几乎单色 |
+| 图表 | 手写 `.bars`（无图表库），月度/一天分布只有色块 | 无基线、无峰值标注、无静止态数值 |
+| 类型色 | 10 种（家/工作/餐厅/…）**只用在 8px 圆点和柱子上** | 没进入界面语义层（chips、表格类型列、KPI 都用不到） |
+| 窄屏导航 | 站长导航（6 项）`scrollWidth=277`，可用宽：**430→254（溢 23）**、**390→214（溢 63）**、**320→144（溢 133）** | 靠 `.nav-links` 横向滚动兜底；390 下「统计」被切成半个字紧贴「后台」按钮，渐隐提示实际看不见 ⇒ 像坏了 |
+| 暗色模式 | 已存在（586/590/742 三段 media） | 任何配色改动要同步两套变量 |
+| 已有优点（别改坏） | KPI 数字已是 `tabular-nums`；`--text-3` 按 AA 调过；地图/时间线的 z-index 与安全区已有处理 | 这些是已经踩过坑换来的 |
+
+## 二、为什么不重写（明确排除项）
+
+- **不引入前端框架 / 构建链**（Vue/React/Tailwind/Vite）：现状是 Go 模板直出 + 单 CSS + 无 npm。引构建链会让「改一行字要跑 node」、部署变复杂，而站点是个人足迹站、并发极低 —— 收益不抵成本。
+- **不上图表库**：为几个柱图多背 100KB+ 与一个依赖，不值得。`.bars` 手写继续用，只升级表达力。
+- **不重做信息架构**：页面、路由、模板数据结构都不动；只改「长什么样、怎么看」。
+
+## 三、四批方案（由低风险到高收益）
+
+### 批次 A：设计令牌收敛（纯 CSS，约半天）
+
+1. **字阶砍到 6 档**：`11 / 13 / 15 / 21 / 26 / 34`
+   - 11 = 脚注/单位，13 = 正文（默认），15 = 卡片标题，21 = 页面标题，26 = KPI，34 = 首屏主数
+   - 现在 10/12/14/18/23 全部并档；`--text-3` 的灰阶不动（它承载 a11y 口径）
+2. **字重砍到 3 档**：400 / 500 / 600（删掉 650）。层级主要靠**字号 + 颜色**，不靠加粗 —— 这更接近现代做法
+3. **间距令牌**：`--sp-1..5` = 4/8/12/16/24，替换散落的 padding/margin 字面量
+4. **圆角令牌**：`--r-sm/md/lg` = 6/10/14（现在只有 `--radius:10px` 和一个 8px）
+5. **阴影分 3 档**：`--sh-1`（卡片）/`--sh-2`（浮层）/`--sh-3`（hero）；现在只有 1 档
+
+> 判据：`cardVariants` 2 → ≥3；(字号/字重) 组合 10 → ≤6；CSS 里裸 `border-radius:` 数字 0 处。
+
+### 批次 B：给卡片分主次（约 1 天）
+
+三档面，替代现在唯一的一种：
+
+| 类 | 用途 | 样子 |
+|---|---|---|
+| `.card--hero` | 首屏 KPI 区、地图 | 更大内边距 + `--sh-3`、无边框、左侧 3px 主色条 |
+| `.card`（默认） | 图表、列表、表单 | 保持现状（已够干净） |
+| `.card--quiet` | 说明块、次级列表 | `--bg-2` 浅底、无边框无阴影 |
+
+配套把首屏 KPI 从「4×2 等重白盒」改成 **1 个 hero 大数 + 3 个指标**：首屏必须有一个一眼能落下去的点。手机端同理（hero 占整行，后 3 个两列）。
+
+> 判据：把首屏截图给人看 3 秒，对方能指出「最重要的那个数」。
+
+### 批次 C：让图表说人话（约 1–2 天，仍不用库）
+
+- **月度分布**：加基线、峰值柱顶部标数值 + 一处「最高 197 次」文案、每根柱 `<title>` 与 hover 值
+- **一天分布**：加 0/6/12/18 轴标 + 早/午/晚三段极浅底色，让「作息」这个概念不用读标题也懂
+- **类型分布**：柱色改用类型色（见批次 D），数值列 `tabular-nums`（数字列宽不再跳）
+- **空态统一**：现在有的写「暂无数据」、有的空着；统一一个 `emptystate`（模板里已有这个定义，直接用）
+
+> 判据：不看图例、不看标题，也能说出这张图在讲什么。
+
+### 批次 D：色彩语义化 + 窄屏导航（约 1 天）
+
+1. **类型色升级为语义令牌**：`--cat-home` / `--cat-work` / `--cat-food` … 10 个，并用 `color-mix()` 派生各自浅底（沿用现有 `--accent-soft` 的做法，不手写 10 套浅色）
+   - 用在：筛选 chips、地点表「主要类型」列、KPI 强调、图表
+   - 硬约束：正文用色对比 ≥4.5:1、大字/图形 ≥3:1（延续现有口径），**暗色模式各派生一套**
+2. **窄屏导航**：现状溢出 23–133px。
+   - 第一步（低风险）：主链接收到 4 个（主页/地图/地点/统计），「时间线/报告」进「更多」；把 `.overflow-right` 的渐隐加重到看得见
+   - 第二步（可选，需评估）：底部 tab bar。⚠️ 地图页的浮层 z-index 与 `--nav-h` 已经踩过坑（审计 F11/F12），上底部栏要先确认与 Leaflet 控件、安全区的冲突
+
+> 判据：320/390 下**没有任何链接被切半个字**；导航高度不增（现 51px）；暗色模式下新色阶对比度同样达标。
+
+## 四、建议顺序
+
+先 **A + B**（约 1.5 天）：纯 CSS + 少量模板 class，风险最低、观感提升最直接，改完能立刻判断方向对不对。
+C 独立（图表可以慢慢磨），D 涉及配色与导航，放最后一次性做，避免中途改两次色。
+
+## 五、验收方式（沿用项目既有纪律）
+
+- 视觉：`rond-web-verify` 技能在 **320/390/430/1440** 四个宽度现场截图 + 量数（别用 `shots/` 里的旧图）
+- 不改坏：`./scripts/verify.sh` 必须仍然 **0 skip 全绿**（模板改动会影响 `tb_stack_test`、`TestVisitorPagesUseThirdPersonCopy` 等）
+- 暗色：`--color-scheme dark` 跑同一组断言
+- 无障碍：`audit/a11y.js` 的对比度与字号判据不得比改动前更差（改动前基线要先跑一遍存档）
+- 本次只出方案，**未改任何代码**。
+
+---
+
+# 落地记录：A + B 批次（2026-10-09）
+
+方案通过后先做了 A（设计令牌收敛）与 B（卡片分主次）。下表每个数字都是**同一份探针在改动前后各跑一遍**得到的。
+
+## A：设计令牌收敛
+
+**字阶**：文本 6 档 `--fs-xs/sm/md/lg/xl/2xl` = 11 / 13 / 15 / 21 / 26 / 34px。
+- app.css 原来 19 种字号、96 处声明；模板里另有 54 处内联字号 —— 全部并档。
+- **两个字外档，都不是漏掉的**：`--fs-control: 16px`（窄屏表单控件必须 ≥16px，否则 iOS 聚焦放大整页，属功能约束，不能进字阶）；`--glyph-*` 6 档（✕ / 箭头 / 空态图标，按控件尺寸定 —— 把 22px 的 ✕ 塞进字阶只会把按钮撑坏）。
+- 字重收敛到 400 / 500 / 600（删掉 650 与 700 两个半档）。
+
+**圆角** 4 档 `--r-xs/sm/md/lg` = 3 / 6 / 8 / 12px（原来 2.5/4/5/6/7/8/9/10/12/20px 混用；卡片 10 → 12）。
+**阴影** 3 档 `--sh-1/2/3`（原来只有 1 档变量 + 6 处写死的阴影）；暗色模式整套覆盖。
+**间距** 5 档 `--sp-1..5`。⚠️ **本批只用在卡片内边距这类主节奏上，没有做全量迁移** —— 一次性铺开的改动面太大、收益最低，留到需要时再逐批替换。
+**`--card-pad` 单列**：折叠卡片的标题行要用负 margin 顶到边，两处必须永远相等。
+
+## B：卡片分主次
+
+- `.card--hero`（首屏地图：无边框 + `--sh-3` + 更大内边距）、`.card`（默认）、`.card--quiet`（设置页「地图底图 / 图片存储」两块只读说明：页面底色 + 细边 + 无阴影）。
+  ⚠️ quiet 第一版用 `--bg-2`(#fafbfb)，实测与页面底 #f6f7f8 只差 **4/255** —— 根本看不出边界，卡片像「破了个洞」。改成「页面底色 + 保留细边」才对。
+- 首屏 KPI 从「4×2 等重白盒」改成 `.kpi-lead`（主数 + 城市/省份上下文）+ 5 个常规指标。**8 个数字一个没少**，只是分了主次。
+
+## 改动前后（同一探针）
+
+| 页面 / 视口 | (字号,字重) 组合 | 卡片样式档 | 最小字号 |
+|---|---|---|---|
+| `/` 390 | 13 → **10** | 2 → **3** | 10 → 11 |
+| `/` 1440 | 15 → **10** | 2 → **3** | 10 → 11 |
+| `/places` 390 | 10 → **5** | 2 → 2 | 12 → 12 |
+| `/timeline` 390 | 10 → **6** | 2 → 2 | 11.5 → 11 |
+| `/stats` 1440 | 15 → **9** | 2 → 2 | 10 → 11 |
+| `/admin/settings` 1440 | 10 → **7** | 1 → **2** | 12 → 13 |
+
+首页 390 的字阶从
+`10/400 11.5/400 12.5/400 13/400 13/500 13.5/400 14/400 14/500 15/600 17/400 18/600 21/600 21.8/650`
+收敛到
+`11/400 13/400 13/500 15/500 15/600 18/400 18/600 21/600 21.8/600 28.1/600`
+（字重只剩 400/500/600；多出来的 28.1px 是新加的首屏主数）
+
+## 回归
+
+- `./scripts/verify.sh`：**PASS=347 FAIL=0 SKIP=0**（含本轮新增的两条守卫）
+- 移动端 390 审计（溢出 / 小触控 / 小字 / iOS 自放大）：**逐值一致**
+- 桌面 1440 溢出审计：唯一差异是 `/map` 露外元素 9 → 8
+- 暗色模式：三档阴影与主色强调条都按暗色变量生效（实测 computed 值）
+
+## 途中发现并修掉的四处
+
+1. **Leaflet 的字号跟着根字号漂**。vendor 里 `.leaflet-container { font-size: 0.75rem }`，根字号 14 → 13px 之后，地图右下角的**署名与比例尺缩到 9.8px**（掉到本站 11px 下限之下），弹窗正文也跟着缩。已按自己的字阶钉死：容器 = `--fs-sm`，署名/比例尺 = `--fs-xs`；`/map` 上小于 11px 的元素从 2 个降到 0 个。
+2. **静态守卫抓到并档**。`TestNavLinksNarrowRuleHasNoDeadPadding` 里写死了 `font-size: 13px`，改成令牌后它红了 —— 守卫本身是对的（它就该在写法漂移时叫），已把判据从「钉具体值」改成「钉窄屏那条规则还在、且设了字号」。另补 `TestNoBareFontSizePx`：静态扫 app.css + 全部模板，禁止再出现裸 px 字号（做过变异验证：注入一条 `font-size: 14px` 会红）。
+3. **`h1..h4` 从来就没设过字号**，一直靠浏览器默认的 `2em / 1.5em / 1.17em` —— 也就是跟着根字号漂。根从 14 → 13px 后，`/stats` 里没被 `.card > h2` 命中的两个 h2（「我的结论」「访客点赞」）从 21px 悄悄变成 19.5px，比同页其它卡片标题（15px）大一圈。已显式给出字号：h1 = `--fs-lg`、h2 = `--fs-md`、h3/h4 = `--fs-sm`；实测 `/stats` 的 12 个 h2 现在统一 `15px/600`。
+4. **`<b> / <strong>` 走浏览器默认 700**，比全站最高层级（标题 600）还重。已钉成 600。
+
+> 3 与 4 都是「量 DOM 的 (字号,字重) 组合」才浮出来的：肉眼看页面完全正常，只是觉得「有点不齐」。
+> 这也是为什么这一批要**先存基线、再用同一份探针逐值 diff**，而不是改完看一眼截图。
+
+## 附：一处历史遗留（本批未动）
+
+7 个模板（`admin/index.html`、`admin/login.html`、`admin/twofa-login.html`、`admin/twofa.html`、`map.html`、`places.html`、`timeline.html`）在**工作区里是 CRLF**，而 `.gitattributes` 要求 `eol=lf`。
+本批按字节替换、原样保住了各自行尾，所以 diff 里没有行尾噪声。要不要统一成 LF，另开一次清理。
+
+---
+
+# 落地记录：C + D 批次（2026-10-09）
+
+## C：让图表说人话
+
+- **月度分布**：柱底压一道基线（原来柱子直接悬在空白里，高低只能靠互相比）；峰值柱不透明拉满、并在柱顶标出次数（`.pv`），副标题里就不再重复写一遍「最高 N 次」。
+- **一天中的分布**：原来只能靠 0/6/12/18 四个数字猜。现在换成一行 **6 小时一段的标尺**（深夜 0-6 / 上午 6-12 / 下午 12-18 / 晚上 18-24），用的是**同一套 24 列网格**（不是 `flex: 6`），所以段边界与柱子严格对齐；峰值小时也标了出来。
+- 首页那份「月度活跃度」同样加了峰值锚点 —— 为此给 `HomeData` 补了 `MaxMonthly`，与统计页同一口径（`maxOf`）。
+- **空态这条划掉了**：查下来已经统一 —— 8 个页面共用 `emptystate`，局部空态一律 `<div class="empty">`，没有需要收拾的。
+
+## D1：类型色语义化（结论和原计划差得比较多）
+
+先把 13 个色在浅/暗两个底上**算了对比度**：
+
+| 底 | 结果 |
+|---|---|
+| 白底（浅色面板） | **6 个色低于图形对象 3:1**：yellow 1.87、mint 2.12、orange 2.20、green 2.22、cyan 2.54、teal 2.57 |
+| 暗底 `#1c2024` | 只有 indigo 2.90 不够，其余都在 3.9 以上 |
+
+所以**没有**按原计划把类型色用到 chips / 表格类型列 / KPI 强调 —— 那几处要的是**文字**，这套色连图形 3:1 都到不了，
+做成彩色标签只会更难读。这也正好解释了全站为什么从头到尾只用 8px 小圆点做身份标记。
+浅色那 6 个色**一个没动**：它们是手机端与地图上的同一套身份色，改暗会破坏对应关系；而且它们只当标记、不承载唯一信息。
+
+实际做了三件事：
+
+1. **色值收口到 CSS**：`--cat-*` 13 个（原样 Apple 色名值）+ `--cat-*-soft` 13 个浅底（半透明，两个主题自适应）。
+   Go 侧 `appleColors` 退成「哪些色名合法」的名单；`colorOf` 已成死代码，删掉。
+2. **模板函数换成 `csscolor` / `csssoft`**（17 + 2 处）。⚠️ 返回值必须是 `template.CSS`：
+   `html/template` 的 CSS 上下文过滤器**不认识 `var()`**，普通 string 会被替换成 `ZgotmplZ` ——
+   页面上所有圆点当场变透明，而且不报错、模板测试照过（本批实测踩到）。
+   挂了 `template.CSS` 等于关掉这道过滤，所以数据侧色值必须先过严格校验（只有 `#` + 6 位十六进制放行）。
+   守卫 `TestCSSColorSurvivesTemplateSanitizer` 把两个方向都钉住：不出现 `ZgotmplZ`、恶意色值不得逃出 `style` 属性（做过变异验证）。
+3. **暗色只提亮一个**：`--cat-indigo` 掺 10% 白（2.90 → 3.55:1），其余不动。
+   地图那份调色板（`rond-map.js` 的 `APPLE`）**保持独立**：地图瓦片在暗色下仍是浅色，标记就该用浅色底那套值 —— 硬统一反而会错。
+
+## D2：窄屏导航
+
+改前 ≤620px 靠横向滚动兜底：**390 溢 63px、320 溢 133px**，最深处的「统计」被切成半个字紧贴后面的按钮，
+而 `.overflow-right` 的渐隐提示实际看不出来。现在：
+
+- 链接本体抽成 `{{define "navitems"}}` 渲染两遍：桌面在 `.nav-links` 平铺，窄屏收进 `.nav-menu`（原生 `<details>`，不靠 JS 也能开合）。
+- JS 只补原生不给的三件事：点外面 / Esc / 点链接后收起。
+- ⚠️ **顶栏 z-index 抬到 `--z-nav: 1200`**：菜单属于 `.nav` 这个层叠上下文、自己抬不动，不抬就会被
+  地图页的 `--z-map-overlay`(1100) 盖住。已在 `/map` 用 `elementFromPoint` 实测（`menuOnTop=true`）。
+- 顺手删掉窄屏那几条已经够不着的滚动/遮罩规则；宽屏保留横向兜底（以后又加入口时宁可能滑，也别切字）。
+
+## C + D 的回归
+
+- `./scripts/verify.sh`：**PASS=348 FAIL=0 SKIP=0**
+- 移动端 390 / 320：**溢出全 0**（改前 `/admin` 在 320 还溢 34px，现在也归零）
+- 桌面 1440：溢出与改前一致（−15 是滚动条宽，按既有口径属正常）
+- **7 个页面都没有低于 11px 的文字**（审计的「小字」判据是 <12px，会把我们 11px 的脚注档一并算进去，属设计内）
+- 暗色：菜单、类型色、三档阴影都按暗色变量生效（实测 computed 值）
+
+

go.mod

@@ -1,6 +1,6 @@
 module rond-with-you
 
-go 1.25
+go 1.27.3
 
 require (
 	github.com/jackc/pgx/v5 v5.7.6

internal/auth/auth.go

@@ -169,7 +169,7 @@ func (s *Store) UserByID(ctx context.Context, id int64) (*User, error) {
 	return &u, nil
 }
 
-// 会话令牌 = expiry|uid|hmac(uid|expiry|口令摘要前缀)，口令变更即自动失效。
+// 会话令牌 = uid|expiry|hmac(uid|expiry|口令摘要)，口令变更即自动失效。
 func (s *Store) SignToken(userID int64, hash string) string {
 	exp := time.Now().AddDate(0, 0, s.Days).Unix()
 	payload := fmt.Sprintf("%d|%d", userID, exp)
@@ -195,14 +195,8 @@ func (s *Store) ParseToken(token, hash string) (int64, bool) {
 func (s *Store) mac(payload, hash string) string {
 	m := hmac.New(sha256.New, s.Secret)
 	m.Write([]byte(payload))
-	// 混入口令摘要，改密后旧 cookie 立即作废
+	// 绑完整口令摘要：摘要里带随机 salt，改密后必然不同，旧 cookie 当场作废。
-	m.Write([]byte("|" + hash[:min(len(hash), 16)]))
+	// 别只取摘要前几位——PBKDF2 编码的前缀是固定格式，等于绑了个常量。
+	m.Write([]byte("\x00" + hash))
 	return b64(m.Sum(nil))
 }
-
-func min(a, b int) int {
-	if a < b {
-		return a
-	}
-	return b
-}

internal/auth/auth_test.go

@@ -12,6 +12,30 @@ import (
 	_ "github.com/jackc/pgx/v5/stdlib"
 )
 
+// TestSessionTokenBindsPasswordHash 钉住「改密后旧会话立即作废」这条契约。
+// 令牌的 MAC 必须真的绑上口令摘要：曾经绑的是摘要的前 16 个字符，而 PBKDF2
+// 编码形如 `pbkdf2$sha256$210000$<salt>$<dk>`，前 16 字节恒为 `pbkdf2$sha256$21`
+// ——等于绑了个常量，改密后别的设备上的旧 cookie 照样能用。
+// 不碰数据库：SignToken/ParseToken 只用到 Secret 与 Days。
+func TestSessionTokenBindsPasswordHash(t *testing.T) {
+	st := &Store{Secret: []byte("test-secret"), Days: 7}
+	before, err := HashPassword("old-password-123456")
+	if err != nil {
+		t.Fatal(err)
+	}
+	after, err := HashPassword("new-password-123456")
+	if err != nil {
+		t.Fatal(err)
+	}
+	tok := st.SignToken(1, before)
+	if _, ok := st.ParseToken(tok, before); !ok {
+		t.Fatal("用签名时的口令摘要应能验签")
+	}
+	if _, ok := st.ParseToken(tok, after); ok {
+		t.Error("改密后旧会话仍验签通过：令牌 MAC 没有真的绑上口令摘要")
+	}
+}
+
 // TestChangeUsername 覆盖改名的正向路径、口令校验与占用冲突。
 // 会临时建一个用户并在结束时删掉，所以需要一个可连的库：用 ROND_DSN 指过来，
 // 未设置时跳过（与项目里其它按环境变量门控的测试一致）。

internal/auth/code_replay_test.go

@@ -0,0 +1,47 @@
+package auth
+
+import (
+	"testing"
+	"time"
+)
+
+// TestCodeReplayRejectsReuseInWindow 同一个码在窗口内只能用一次。
+func TestCodeReplayRejectsReuseInWindow(t *testing.T) {
+	r := NewCodeReplay()
+	base := time.Date(2026, 9, 21, 10, 0, 0, 0, time.UTC)
+	r.now = func() time.Time { return base }
+
+	if !r.Consume(7, "123456") {
+		t.Fatal("首次使用应当通过")
+	}
+	if r.Consume(7, "123456") {
+		t.Error("同一个码被重放了")
+	}
+	// 换个用户号的同一个数字码不受影响
+	if !r.Consume(8, "123456") {
+		t.Error("不同用户的同一个码不该互相影响")
+	}
+}
+
+// TestCodeReplayExpiresAfterWindow 条目只活过一个接受窗口（±1 步 = 90 秒），
+// 过期后同一个码可以再被收下——否则条目会越攒越多，且数字复用会误伤。
+func TestCodeReplayExpiresAfterWindow(t *testing.T) {
+	r := NewCodeReplay()
+	now := time.Date(2026, 9, 21, 10, 0, 0, 0, time.UTC)
+	r.now = func() time.Time { return now }
+
+	if !r.Consume(7, "123456") {
+		t.Fatal("首次使用应当通过")
+	}
+	now = now.Add(replayTTL - time.Second)
+	if r.Consume(7, "123456") {
+		t.Error("窗口内不该放行")
+	}
+	now = now.Add(2 * time.Second) // 越过 replayTTL
+	if !r.Consume(7, "123456") {
+		t.Error("过期后应当放行")
+	}
+	if n := len(r.used); n != 1 {
+		t.Errorf("过期条目没被清掉，还剩 %d 条", n)
+	}
+}

internal/auth/guard.go

@@ -0,0 +1,128 @@
+// Package auth 的登录失败短锁。
+package auth
+
+import (
+	"crypto/rand"
+	"math/big"
+	"sync"
+	"time"
+)
+
+// Guard 拦登录爆破：按用户名累计失败次数，到阈值后按指数退避短暂锁住。
+//
+// 键只用用户名、**不带 IP**——clientIP 优先信 X-Forwarded-For 的第一段，
+// 而那是客户端可伪造的，拿它当键就等于「每换一个请求头换一把新锁」。
+// 本站只有一个账号（启动时创建，没有注册入口），用户名是稳定的，
+// 所以它才是可靠的爆破计数键。
+//
+// 状态在内存里：站点是单进程部署，重启即清空，代价可接受。
+type Guard struct {
+	mu    sync.Mutex
+	items map[string]entry
+	now   func() time.Time // 测试注入用
+}
+
+type entry struct {
+	fails int
+	until time.Time // 锁到什么时候
+	seen  time.Time
+}
+
+const (
+	// guardFreeTries 是阈值：前几次失败不锁，正常手滑不该被罚。
+	guardFreeTries = 5
+	// guardBaseLock 是刚过阈值时的锁定时长，之后每次失败翻倍。
+	guardBaseLock = 2 * time.Second
+	guardMaxLock  = 15 * time.Minute
+	// guardMaxKeys 与 guardIdleTTL 只管内存：有人拿随机用户名刷接口时，
+	// 记录不能无限长下去。
+	guardMaxKeys = 1024
+	guardIdleTTL = time.Hour
+)
+
+// NewGuard 建一个空白的失败计数器。
+func NewGuard() *Guard {
+	return &Guard{items: map[string]entry{}, now: time.Now}
+}
+
+// RetryAfter 返回该键还要等多久才能再试；0 表示可以试。
+func (g *Guard) RetryAfter(key string) time.Duration {
+	g.mu.Lock()
+	defer g.mu.Unlock()
+	return g.retryAfterLocked(key)
+}
+
+func (g *Guard) retryAfterLocked(key string) time.Duration {
+	e, ok := g.items[key]
+	if !ok {
+		return 0
+	}
+	if d := e.until.Sub(g.now()); d > 0 {
+		return d
+	}
+	return 0
+}
+
+// Fail 记一次失败，返回这次之后需要等待的时长（0 表示还没到阈值）。
+func (g *Guard) Fail(key string) time.Duration {
+	g.mu.Lock()
+	defer g.mu.Unlock()
+	g.pruneLocked()
+	e := g.items[key]
+	e.fails++
+	e.seen = g.now()
+	if e.fails >= guardFreeTries {
+		// 第 5 次失败锁 2 秒，第 6 次 4 秒……封顶 15 分钟
+		lock := guardBaseLock << uint(e.fails-guardFreeTries)
+		if lock > guardMaxLock || lock <= 0 {
+			lock = guardMaxLock
+		}
+		e.until = g.now().Add(lock)
+	}
+	g.items[key] = e
+	return g.retryAfterLocked(key)
+}
+
+// Succeed 登录成功就清掉计数：口令是对的，之前的失败不再累积到下次。
+func (g *Guard) Succeed(key string) {
+	g.mu.Lock()
+	delete(g.items, key)
+	g.mu.Unlock()
+}
+
+// Reset 清空全部计数（测试与本地排查用）。
+func (g *Guard) Reset() {
+	g.mu.Lock()
+	g.items = map[string]entry{}
+	g.mu.Unlock()
+}
+
+func (g *Guard) pruneLocked() {
+	now := g.now()
+	for k, v := range g.items {
+		if now.Sub(v.seen) > guardIdleTTL {
+			delete(g.items, k)
+		}
+	}
+	for k := range g.items {
+		if len(g.items) < guardMaxKeys {
+			break
+		}
+		delete(g.items, k)
+	}
+}
+
+// RandomPassword 生成 n 位随机口令，字符集去掉了容易看错的 0/O/1/I/L。
+// 用于「没配 ROND_ADMIN_PASSWORD 时别再写死出厂口令」。
+func RandomPassword(n int) (string, error) {
+	const alphabet = "23456789ABCDEFGHJKMNPQRSTUVWXYZabcdefghijkmnpqrstuvwxyz"
+	var b = make([]byte, n)
+	for i := range b {
+		idx, err := rand.Int(rand.Reader, big.NewInt(int64(len(alphabet))))
+		if err != nil {
+			return "", err
+		}
+		b[i] = alphabet[idx.Int64()]
+	}
+	return string(b), nil
+}

internal/auth/guard_test.go

@@ -0,0 +1,147 @@
+package auth
+
+import (
+	"strings"
+	"testing"
+	"time"
+)
+
+// TestGuardLocksAfterThreshold 前几次手滑不该被罚，到阈值才开始锁。
+func TestGuardLocksAfterThreshold(t *testing.T) {
+	g := NewGuard()
+	base := time.Date(2026, 9, 21, 10, 0, 0, 0, time.UTC)
+	g.now = func() time.Time { return base }
+
+	for i := 1; i < guardFreeTries; i++ {
+		if wait := g.Fail("admin"); wait != 0 {
+			t.Fatalf("第 %d 次失败就被锁了 %v，阈值应当是 %d", i, wait, guardFreeTries)
+		}
+		if d := g.RetryAfter("admin"); d != 0 {
+			t.Fatalf("第 %d 次失败后不该有等待时间，实际 %v", i, d)
+		}
+	}
+	wait := g.Fail("admin")
+	if wait <= 0 {
+		t.Fatalf("第 %d 次失败应当上锁", guardFreeTries)
+	}
+	if wait > guardBaseLock {
+		t.Errorf("首次锁定时长 %v 超过了基准 %v", wait, guardBaseLock)
+	}
+	if d := g.RetryAfter("admin"); d != wait {
+		t.Errorf("RetryAfter=%v 与 Fail 返回的 %v 不一致", d, wait)
+	}
+	t.Logf("第 %d 次失败锁 %v", guardFreeTries, wait)
+}
+
+// TestGuardBackoffGrowsAndCaps 继续失败要退避得更久，但封顶。
+func TestGuardBackoffGrowsAndCaps(t *testing.T) {
+	g := NewGuard()
+	base := time.Date(2026, 9, 21, 10, 0, 0, 0, time.UTC)
+	g.now = func() time.Time { return base }
+
+	var prev time.Duration
+	for i := 0; i < guardFreeTries+12; i++ {
+		wait := g.Fail("admin")
+		if wait < prev {
+			t.Fatalf("第 %d 次失败的等待时间 %v 比上一次 %v 还短", i+1, wait, prev)
+		}
+		if wait > guardMaxLock {
+			t.Fatalf("第 %d 次失败锁了 %v，超过上限 %v", i+1, wait, guardMaxLock)
+		}
+		prev = wait
+	}
+	if prev != guardMaxLock {
+		t.Errorf("连续失败后应当封顶在 %v，实际 %v", guardMaxLock, prev)
+	}
+}
+
+// TestGuardReleasesAfterWait 时间走够之后要放行，否则就是永久锁死自己。
+func TestGuardReleasesAfterWait(t *testing.T) {
+	g := NewGuard()
+	base := time.Date(2026, 9, 21, 10, 0, 0, 0, time.UTC)
+	now := base
+	g.now = func() time.Time { return now }
+
+	var wait time.Duration
+	for i := 0; i < guardFreeTries; i++ {
+		wait = g.Fail("admin")
+	}
+	if wait <= 0 {
+		t.Fatal("到阈值却没上锁")
+	}
+
+	now = base.Add(wait - time.Millisecond)
+	if d := g.RetryAfter("admin"); d <= 0 {
+		t.Errorf("还差 1ms 到期，应当仍在锁内，实际 %v", d)
+	}
+	now = base.Add(wait)
+	if d := g.RetryAfter("admin"); d != 0 {
+		t.Errorf("到期后应当放行，实际还要等 %v", d)
+	}
+}
+
+// TestGuardSucceedClears 登录成功要把计数清零，别让几天前的失败把下次正常登录挡住。
+func TestGuardSucceedClears(t *testing.T) {
+	g := NewGuard()
+	base := time.Date(2026, 9, 21, 10, 0, 0, 0, time.UTC)
+	g.now = func() time.Time { return base }
+
+	for i := 0; i < guardFreeTries; i++ {
+		g.Fail("admin")
+	}
+	if g.RetryAfter("admin") <= 0 {
+		t.Fatal("应当处于锁定状态")
+	}
+	g.Succeed("admin")
+	if d := g.RetryAfter("admin"); d != 0 {
+		t.Errorf("成功后不该还有等待时间，实际 %v", d)
+	}
+	// 清零之后又要重新攒满阈值才会锁
+	for i := 1; i < guardFreeTries; i++ {
+		if wait := g.Fail("admin"); wait != 0 {
+			t.Errorf("清零后第 %d 次失败不该上锁，实际 %v", i, wait)
+		}
+	}
+}
+
+// TestGuardSeparatesKeys 不同用户名各算各的。
+func TestGuardSeparatesKeys(t *testing.T) {
+	g := NewGuard()
+	base := time.Date(2026, 9, 21, 10, 0, 0, 0, time.UTC)
+	g.now = func() time.Time { return base }
+
+	for i := 0; i < guardFreeTries; i++ {
+		g.Fail("admin")
+	}
+	if g.RetryAfter("admin") <= 0 {
+		t.Fatal("admin 应当被锁")
+	}
+	if d := g.RetryAfter("someone-else"); d != 0 {
+		t.Errorf("另一个用户名不该受影响，实际 %v", d)
+	}
+}
+
+// TestRandomPassword 确认初始口令有足够熵、字符集不含易混字符。
+func TestRandomPassword(t *testing.T) {
+	const n = 16
+	a, err := RandomPassword(n)
+	if err != nil {
+		t.Fatal(err)
+	}
+	b, err := RandomPassword(n)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(a) != n || len(b) != n {
+		t.Fatalf("长度不对: %d / %d（应为 %d）", len(a), len(b), n)
+	}
+	if a == b {
+		t.Error("两次生成的随机口令相同")
+	}
+	if strings.ContainsAny(a, "0O1Il") {
+		t.Errorf("口令含易混字符: %s", a)
+	}
+	if _, err := RandomPassword(0); err != nil {
+		t.Errorf("长度 0 不该报错: %v", err)
+	}
+}

internal/auth/totp.go

@@ -11,6 +11,7 @@ import (
 	"errors"
 	"fmt"
 	"strings"
+	"sync"
 	"time"
 )
 
@@ -98,6 +99,44 @@ func urlEscape(s string) string {
 	return b.String()
 }
 
+// ---------- 验证码重放 ----------
+
+// replayTTL 要盖过 VerifyTOTP 的整个接受窗口（前后各一步 = 90 秒），
+// 否则同一步长的码会在条目过期后又被收下。
+const replayTTL = 3 * totpStep
+
+// CodeReplay 记住最近用过的验证码，拦住「同一个码在窗口内被用第二次」。
+// VerifyTOTP 只判断「这个码此刻对不对」，不含一次性语义；被偷看到或被日志
+// 截获的码，在它过期前都能再换一个会话。
+type CodeReplay struct {
+	mu   sync.Mutex
+	used map[string]time.Time
+	now  func() time.Time
+}
+
+func NewCodeReplay() *CodeReplay {
+	return &CodeReplay{used: map[string]time.Time{}, now: time.Now}
+}
+
+// Consume 在验证码**已经校验通过**之后登记一次使用；已被用过则返回 false。
+// 键里带用户号：不同账号的同一个数字码互不影响。
+func (r *CodeReplay) Consume(userID int64, code string) bool {
+	now := r.now()
+	key := fmt.Sprintf("%d|%s", userID, code)
+	r.mu.Lock()
+	defer r.mu.Unlock()
+	for k, t := range r.used {
+		if now.Sub(t) > replayTTL {
+			delete(r.used, k)
+		}
+	}
+	if _, ok := r.used[key]; ok {
+		return false
+	}
+	r.used[key] = now
+	return true
+}
+
 // ---------- 用户秘钥存取 ----------
 
 // TOTPState 返回用户的两步验证状态。

internal/db/fresh_db_test.go

@@ -0,0 +1,164 @@
+package db
+
+import (
+	"context"
+	"database/sql"
+	"fmt"
+	"net/url"
+	"os"
+	"testing"
+	"time"
+
+	"rond-with-you/internal/stats"
+)
+
+// TestFreshDatabaseServesAppQueries 在一个全新库里跑完整迁移，再用应用侧的读查询真打一遍。
+//
+// 为什么非要在「全新库」上测：schema.sql 里有一段 DO 块（附属数据改挂坐标键）依赖
+// place_images / place_visitor_votes / places / datasets 已经建好。迁移块一旦排到依赖表
+// 之前，**老库毫无症状**（表早就存在），只有新部署起不来 —— 这类改动在本机开发时根本看不见。
+// 顺带也守住「表/列/索引/主键」在全新库上的最终形态，而不是只看「建了 10 张表就算过」。
+func TestFreshDatabaseServesAppQueries(t *testing.T) {
+	dsn := os.Getenv("ROND_DSN")
+	if dsn == "" {
+		t.Skip("设置 ROND_DSN 后运行全新库冒烟")
+	}
+	name := fmt.Sprintf("rond_test_fresh_%d", time.Now().UnixNano())
+	u, err := url.Parse(dsn)
+	if err != nil {
+		t.Fatalf("解析 ROND_DSN: %v", err)
+	}
+	u.Path = "/" + name
+
+	d, err := Open(u.String())
+	if err != nil {
+		t.Fatalf("全新库应自动建出来: %v", err)
+	}
+	t.Cleanup(func() {
+		d.Close() // 必须放在 dropDatabase 之前：DROP DATABASE 要求没有连接挂着
+		dropDatabase(t, dsn, name)
+	})
+
+	ctx := context.Background()
+	if err := Migrate(ctx, d); err != nil {
+		t.Fatalf("全新库初始化表结构失败（迁移块顺序/依赖问题会让新库起不来）: %v", err)
+	}
+	if err := Migrate(ctx, d); err != nil {
+		t.Fatalf("重复 Migrate 不该报错（部署会重复跑）: %v", err)
+	}
+
+	tables := []string{
+		"users", "datasets", "activities", "tags", "places", "visits", "visit_tags",
+		"movements", "weather", "settings", "category_labels", "fog_blocks", "fog_masks",
+		"fog_raw_files", "gpx_tracks", "topics", "place_notes", "place_votes",
+		"place_visitor_votes", "place_images", "entity_raw",
+	}
+	for _, tbl := range tables {
+		if !hasTable(t, d, tbl) {
+			t.Errorf("全新库里缺表 %s", tbl)
+		}
+	}
+
+	// 这些列全靠迁移块补出来：列不在 = 块没跑到 / 被插到了依赖表前面
+	cols := map[string][]string{
+		"places":              {"coord_source", "coord_sys", "src_lat", "src_lon"},
+		"place_notes":         {"place_key", "rond_note", "dataset_id"},
+		"place_votes":         {"place_key", "dataset_id"},
+		"place_visitor_votes": {"place_key"},
+		"place_images":        {"place_key", "storage", "object_key"},
+		"datasets":            {"content_hash", "coredata_meta"},
+		"users":               {"totp_secret", "totp_enabled"},
+		"entity_raw":          {"skipped"},
+	}
+	for tbl, want := range cols {
+		for _, col := range want {
+			if !hasColumn(t, d, tbl, col) {
+				t.Errorf("全新库里 %s.%s 没有建出来", tbl, col)
+			}
+		}
+	}
+
+	// 附属数据的主键必须已经搬到坐标键上：停在老主键就是「半迁移」状态
+	for tbl, want := range map[string]string{
+		"place_notes": "user_id,place_key", "place_votes": "user_id,place_key",
+		"place_visitor_votes": "place_key,voter_key",
+	} {
+		var got string
+		err := d.QueryRow(`SELECT string_agg(a.attname, ',' ORDER BY array_position(c.conkey, a.attnum))
+			FROM pg_constraint c
+			JOIN pg_attribute a ON a.attrelid = c.conrelid AND a.attnum = ANY(c.conkey)
+			WHERE c.conrelid = $1::regclass AND c.contype = 'p'`, tbl).Scan(&got)
+		if err != nil {
+			t.Fatalf("读 %s 主键失败: %v", tbl, err)
+		}
+		if got != want {
+			t.Errorf("%s 的主键是 (%s)，期望 (%s)", tbl, got, want)
+		}
+	}
+
+	// DO 块之后才建的索引：块顺序错了它就会在缺表时报错
+	for _, idx := range []string{"idx_place_images_key", "idx_pvv_key", "idx_places_geo", "idx_visits_place"} {
+		if !hasIndex(t, d, idx) {
+			t.Errorf("全新库里缺索引 %s", idx)
+		}
+	}
+
+	// 应用侧读查询真打一遍空库：任何查询引用了没建出来的列，这里就会报错
+	sd := stats.DB{DB: d}
+	f := stats.Filter{DatasetID: 1}
+	reads := map[string]func() error{
+		"Overview":       func() error { _, err := sd.Overview(ctx, f); return err },
+		"Places":         func() error { _, _, err := sd.Places(ctx, f, "visits", 20, 0); return err },
+		"MapPlaces":      func() error { _, err := sd.MapPlaces(ctx, f, 20); return err },
+		"Visits":         func() error { _, _, err := sd.Visits(ctx, f, 20, 0, "desc"); return err },
+		"RecentVisits":   func() error { _, err := sd.RecentVisits(ctx, f, 5); return err },
+		"CityStats":      func() error { _, err := sd.CityStats(ctx, f, 10); return err },
+		"ProvinceStats":  func() error { _, err := sd.ProvinceStats(ctx, f); return err },
+		"ActivityStats":  func() error { _, err := sd.ActivityStats(ctx, f); return err },
+		"ActivityCounts": func() error { _, err := sd.ActivityCounts(ctx, f); return err },
+		"TransportStats": func() error { _, err := sd.TransportStats(ctx, f); return err },
+		"TagStats":       func() error { _, err := sd.TagStats(ctx, f); return err },
+		"Monthly":        func() error { _, err := sd.Monthly(ctx, f); return err },
+		"Calendar":       func() error { _, err := sd.Calendar(ctx, f); return err },
+		"Hourly":         func() error { _, err := sd.Hourly(ctx, f); return err },
+		"Weekday":        func() error { _, err := sd.Weekday(ctx, f); return err },
+		"Cities":         func() error { _, err := sd.Cities(ctx, 1, nil, false); return err },
+		"Tags":           func() error { _, err := sd.Tags(ctx, 1); return err },
+		"Activities":     func() error { _, err := sd.Activities(ctx, 1); return err },
+	}
+	for label, run := range reads {
+		if err := run(); err != nil {
+			t.Errorf("全新库上跑 %s 失败（多半是某个列/索引没建出来）: %v", label, err)
+		}
+	}
+}
+
+func hasTable(t *testing.T, d *sql.DB, tbl string) bool {
+	t.Helper()
+	var n int
+	if err := d.QueryRow(`SELECT count(*) FROM information_schema.tables
+		WHERE table_schema='public' AND table_name=$1`, tbl).Scan(&n); err != nil {
+		t.Fatalf("查表 %s: %v", tbl, err)
+	}
+	return n > 0
+}
+
+func hasColumn(t *testing.T, d *sql.DB, tbl, col string) bool {
+	t.Helper()
+	var n int
+	if err := d.QueryRow(`SELECT count(*) FROM information_schema.columns
+		WHERE table_schema='public' AND table_name=$1 AND column_name=$2`, tbl, col).Scan(&n); err != nil {
+		t.Fatalf("查列 %s.%s: %v", tbl, col, err)
+	}
+	return n > 0
+}
+
+func hasIndex(t *testing.T, d *sql.DB, idx string) bool {
+	t.Helper()
+	var n int
+	if err := d.QueryRow(`SELECT count(*) FROM pg_indexes
+		WHERE schemaname='public' AND indexname=$1`, idx).Scan(&n); err != nil {
+		t.Fatalf("查索引 %s: %v", idx, err)
+	}
+	return n > 0
+}

internal/db/schema.sql

@@ -1,5 +1,16 @@
 -- rond-with-you 数据结构
 -- 一次上传 = 一个 dataset，所有事实表挂在其下，支持多份备份共存与切换
+--
+-- ⚠️️ 新增一张带 dataset_id 的表时，先答一个问题：
+--     **它的记录能不能从备份重新导入？**
+--   能（到访/地点/位移/天气/活动/标签/原始行留档）⇒ 可以挂
+--   `REFERENCES datasets(id) ON DELETE CASCADE`：删数据集时它们跟着走是对的。
+--   不能（图片、备注、结论、专题等**站点自建**的数据）⇒ **只留 dataset_id 当出处，不许挂外键**：
+--   删数据集会把它们一起删掉，而这些记录不在任何备份里，删了就是永久丢失
+--   （2026-09-30 图片事故：行被 CASCADE、文件却留在盘上，读取按坐标键、行按数据集级联，
+--    两套口径打架）。参考 place_images / place_notes / place_votes / topics 现在的写法。
+--   这条规矩由 `TestOnlyBackupDerivedTablesCascadeFromDatasets` 与
+--   `TestSchemaDeclaresNoDatasetFKForUserData`（运行时 + 静态两道）守住，改这里会当场红。
 
 CREATE TABLE IF NOT EXISTS users (
     id            BIGSERIAL PRIMARY KEY,
@@ -159,6 +170,15 @@ CREATE TABLE IF NOT EXISTS settings (
     updated_at TIMESTAMPTZ NOT NULL DEFAULT now()
 );
 
+-- 类别值 → 中文显示名 的站点自定义覆盖。**只影响显示，不碰数据**：
+-- 导出到 rond 用的是 places.poi_category 本身，这里改名不会写回手机。
+-- 刻意不挂 dataset_id：类别值是它自己的稳定键，挂数据集会像备注/投票那样换个数据集就失联。
+CREATE TABLE IF NOT EXISTS category_labels (
+    value      TEXT PRIMARY KEY,
+    label      TEXT NOT NULL,
+    updated_at TIMESTAMPTZ NOT NULL DEFAULT now()
+);
+
 -- 世界迷雾（Fog of World）已探索位图，按块粒度存储。
 -- 迷雾与数据集无关（来自另一个应用），挂在用户维度下；
 -- gbx/gby 为全球块坐标（0..65535），一个位对应 2^22 网格里约 9.55m 的一格。
@@ -293,6 +313,15 @@ ALTER TABLE place_notes ADD COLUMN IF NOT EXISTS rond_note TEXT NOT NULL DEFAULT
 -- 需要把原始 .rondbackup 重新上传一次（即便内容相同也会补抓）。
 ALTER TABLE datasets ADD COLUMN IF NOT EXISTS coredata_meta JSONB;
 
+-- 「换基线」的记档：底座库（baselines/<id>.sqlite）是哪一份包换出来的。
+-- 记着它有两个用处：① 底座文件丢了可以按 baseline_sha256 去 uploads 里找回同一份包重建
+-- （否则 ensureBaseline 只会退回 datasets.sha256，也就是最初那份旧包——底座会被悄悄换回去）；
+-- ② 页面上能说清「现在这个底座来自哪个文件」。
+-- baseline_sha256 IS NULL = 从未换过底座，来源就是最初上传的原始包。
+ALTER TABLE datasets ADD COLUMN IF NOT EXISTS baseline_name TEXT;
+ALTER TABLE datasets ADD COLUMN IF NOT EXISTS baseline_sha256 CHAR(64);
+ALTER TABLE datasets ADD COLUMN IF NOT EXISTS baseline_at TIMESTAMPTZ;
+
 -- rond 原始行留档：每条实体在 Core Data 里的**完整一行**（含站点未映射的字段）
 -- 按 JSONB 存下来。有了它，导出不再依赖基线库去补那些字段——
 -- 基线即便丢了也能精确还原，站点侧也具备完整数据，不会因为映射范围窄而漏字段。
@@ -354,11 +383,16 @@ BEGIN
 END $$;
 
 -- 专题：把某段时间内、某个区域里的足迹（地点 + 迷雾）打包成一个可对外展示的页面。
--- 区域用「中心点 + 半径」，半径为 0 表示不限区域（时间范围内的地点画到哪算哪）。
+-- 「区域」是**一组圆**（areas，见下），空数组表示不限区域（时间范围内的地点画到哪算哪）。
+--
+-- ⚠️ dataset_id **故意不带外键**（早期版本带 ON DELETE CASCADE）。
+-- 专题是「一段时间 + 一块区域」的**定义**，不是备份里的数据：换数据集之后它照旧成立
+-- （内容照当前生效数据集算），删掉旧数据集不该把它带走。带 CASCADE 时实测丢过一批专题，
+-- 而且没有恢复来源（专题只存在这张表里）。dataset_id 退化为「当初在哪份数据上建的」。
 CREATE TABLE IF NOT EXISTS topics (
     id          BIGSERIAL PRIMARY KEY,
     user_id     BIGINT NOT NULL REFERENCES users(id) ON DELETE CASCADE,
-    dataset_id  BIGINT NOT NULL REFERENCES datasets(id) ON DELETE CASCADE,
+    dataset_id  BIGINT NOT NULL,
     title       TEXT NOT NULL,
     subtitle    TEXT NOT NULL DEFAULT '',
     description TEXT NOT NULL DEFAULT '',
@@ -375,6 +409,23 @@ CREATE TABLE IF NOT EXISTS topics (
 );
 CREATE INDEX IF NOT EXISTS idx_topics_user ON topics(user_id, sort_order, id);
 
+-- 专题的显示区：**一组圆**，jsonb 数组，元素形如 {"lat":..,"lon":..,"radiusKm":..}。
+-- 坐标是 GCJ-02（与 places 同系）；前台由 rond-map.js 的 project() 换算到底图坐标系。
+-- 落在**任一**圆内就算在区域内（并集）——地点过滤是 SQL 里的 OR，迷雾裁剪是 clip-path: path()
+-- 的多段子路径（同绕向 ⇒ nonzero 填充规则下自然取并集）。
+--
+-- 为什么用 jsonb 而不是单开一张表：这些圆是专题定义的组成部分、跟专题一起读写、没有独立
+-- 生命周期，也就免了「能不能从备份重导」那道归属口径（topics 本来就只归人、不挂数据集）。
+--
+-- ⚠️ center_lat / center_lon / radius_km 三列**已废弃**（早期只支持一个圆），保留只为两件事：
+-- 一是回滚旧二进制时还能退化显示成「第一个圆」，二是下面这段存量回填的输入。
+-- 新代码一律只读 areas；写入时把第一个圆镜像进这三列。
+ALTER TABLE topics ADD COLUMN IF NOT EXISTS areas JSONB NOT NULL DEFAULT '[]'::jsonb;
+UPDATE topics SET areas = jsonb_build_array(
+         jsonb_build_object('lat', center_lat, 'lon', center_lon, 'radiusKm', radius_km))
+ WHERE radius_km > 0 AND areas = '[]'::jsonb;
+
+
 -- fog of world 快照里「非已探索层」的原始瓦片文件（Model/~ 与 Model/#）。
 -- 站点只用已探索层渲染，但导出必须原样写回这两层，否则重导出的快照会丢掉约 55% 的内容。
 -- data 存的是原始（zlib 压缩后的）字节，一个字节都不动。
@@ -419,9 +470,15 @@ ALTER TABLE places ADD COLUMN IF NOT EXISTS src_lon      DOUBLE PRECISION;
 -- 地点图片：站长给地点配的图。字节由**浏览器**转成 WebP 后再上传（服务端只负责收下与转存），
 -- 1 核机器不用扛解码。storage 记这一张实际放在哪、object_key 是本地相对路径或对象存储 key：
 -- 换了存储后端之后旧图仍按各自那一列去取，不会因为改了设置就全变破图。
+--
+-- ⚠️ dataset_id **故意不带外键**（早期版本带 ON DELETE CASCADE，后果见下）。
+-- 图片的「认地点」靠坐标键 place_key，与数据集无关；数据集只是当初上传时的落点。
+-- 带 CASCADE 时删除旧数据集会把图片行一并删掉，而**文件还留在磁盘上**——
+-- 读取按坐标键、行却按数据集级联，两套口径打架，实测就丢过一批图（2026-09-30）。
+-- 备注/结论早就改成坐标键了，图片这里跟上，dataset_id 退化成「出处」这一列。
 CREATE TABLE IF NOT EXISTS place_images (
     id         BIGSERIAL PRIMARY KEY,
-    dataset_id BIGINT NOT NULL REFERENCES datasets(id) ON DELETE CASCADE,
+    dataset_id BIGINT NOT NULL,
     src_pk     INT NOT NULL,
     -- place_key 与备注、结论共用同一套坐标键：换数据集后图片还挂得回原地点。
     -- 对象键里仍然带 dataset_id（那只是存储路径，与「认不认得出是同一个地点」无关）。
@@ -437,6 +494,21 @@ CREATE TABLE IF NOT EXISTS place_images (
 );
 CREATE INDEX IF NOT EXISTS idx_place_images_place ON place_images(dataset_id, src_pk, position);
 
+-- ---------- 站点自建数据：一律摘掉 datasets 的外键 ----------
+-- ⚠️ 这一段必须排在**所有相关 CREATE TABLE 之后**（place_images 是最后一张）：
+-- 迁移块插在建表之前时，开发库（表已存在）毫无症状，**全新库却起不来**
+-- （`ALTER TABLE place_images …` 报「关系不存在」）——`TestFreshDatabaseServesAppQueries`
+-- 就是守这个的，本项目踩过。
+-- 这一段是给**已经部署出去的库**自愈用的，幂等：约束不在时什么都不做。
+-- 五张表全都兜住：只摘 place_images / topics 不够——place_notes / place_votes 是更早那次
+-- 改坐标键时摘的，老库上未必摘干净（变异验证就是这么抓出来的：把外键补回去后发现迁移不管它们）。
+-- 摘掉之后「删数据集」不再带走任何站点自建的数据。
+ALTER TABLE place_images        DROP CONSTRAINT IF EXISTS place_images_dataset_id_fkey;
+ALTER TABLE place_notes         DROP CONSTRAINT IF EXISTS place_notes_dataset_id_fkey;
+ALTER TABLE place_votes         DROP CONSTRAINT IF EXISTS place_votes_dataset_id_fkey;
+ALTER TABLE place_visitor_votes DROP CONSTRAINT IF EXISTS place_visitor_votes_dataset_id_fkey;
+ALTER TABLE topics              DROP CONSTRAINT IF EXISTS topics_dataset_id_fkey;
+
 -- ---------- 附属数据改挂坐标键（一次性迁移）----------
 -- 备注 / 结论 / 图片原本挂 (dataset_id, src_pk)，换个数据集就全看不见了。
 -- 这里把它们搬到坐标键上；只在「还没有 place_key 列」时执行，所以新库直接走上面的
@@ -549,3 +621,59 @@ END $$;
 CREATE INDEX IF NOT EXISTS idx_place_images_key ON place_images(place_key, position);
 
 CREATE INDEX IF NOT EXISTS idx_pvv_key ON place_visitor_votes(place_key);
+
+-- 已并入 / 子段到访不收进地点的到访数与停留（2026-09-29）
+--
+-- 真机里两行到访可能「不独立成立」：ZVISIT.ZMERGEDTO 指向它被并入的那条，
+-- ZPARENT 说明它只是某个父段的一部分。app 对这两种行既不单独显示也不计数，本站以前
+-- 当成普通到访 ⇒ 时间线上出现「同一时刻同一地点两条」、日停留重复计入（实测数据集 9
+-- 有 54 + 10 条，26 条的到达时间与原件完全相同）。
+--
+-- 判据与 internal/stats/stats.go 的 SoloVisitSQL 同口径，只在**读**的一侧收口：
+-- 导出的包照旧原样带着这些行（rond 靠它们认这次合并发生过），所以这里只动
+-- visit_count / dwell_minutes 两列，first_visit_at / last_visit_at 保持全量
+-- （后者会被导出成 ZLOCATION.ZLASTARRIVALDATE_）。
+--
+-- 只动「名下真有这种行」的地点，且幂等：重跑到收敛，没有这种行的库一次也不改行。
+UPDATE places p SET
+    visit_count = sub.c,
+    dwell_minutes = sub.d
+FROM (
+    SELECT v.place_id,
+        count(*) FILTER (WHERE NOT EXISTS (SELECT 1 FROM entity_raw er
+            WHERE er.dataset_id = v.dataset_id AND er.entity = 'ZVISIT' AND er.src_pk = v.src_pk
+              AND (er.raw->>'ZMERGEDTO' IS NOT NULL OR er.raw->>'ZPARENT' IS NOT NULL))) AS c,
+        COALESCE(sum(LEAST(COALESCE(v.duration_min,0), 10080)) FILTER (WHERE NOT EXISTS (SELECT 1 FROM entity_raw er
+            WHERE er.dataset_id = v.dataset_id AND er.entity = 'ZVISIT' AND er.src_pk = v.src_pk
+              AND (er.raw->>'ZMERGEDTO' IS NOT NULL OR er.raw->>'ZPARENT' IS NOT NULL))), 0) AS d
+    FROM visits v
+    WHERE v.place_id IS NOT NULL
+    GROUP BY v.place_id
+) sub
+WHERE p.id = sub.place_id
+  AND EXISTS (SELECT 1 FROM visits v JOIN entity_raw er
+        ON er.dataset_id = v.dataset_id AND er.entity = 'ZVISIT' AND er.src_pk = v.src_pk
+      WHERE v.place_id = p.id
+        AND (er.raw->>'ZMERGEDTO' IS NOT NULL OR er.raw->>'ZPARENT' IS NOT NULL));
+
+-- 「这次到访不独立成立」（已并入别处 / 只是某个父段的一部分）做成派生列（2026-09-30）
+--
+-- 读侧到处要判它（时间线、统计、地点列的 5 个子查询、专题……），原来是每行去 entity_raw 里
+-- 取回**整行 Core Data JSON** 再解析 raw->>'ZMERGEDTO'：实体表里的 raw 是 TOAST 过的整行，
+-- 一次探针要几毫秒，地点库那种「每个地点 × 5 个子查询」的量级下实测 70 秒才出页面。
+-- 派生成一列之后读侧只看布尔值（实测 /places 5.3s → 0.01s 量级）。
+--
+-- ⚠️ 写入侧要跟着刷：导入（internal/ingest）、合并（backup_merge 的 recountPlaces）都会重算。
+-- 直接改 entity_raw 的合并标记（比如 tools/ 里的脚本）之后也要重跑一次这里的 UPDATE。
+ALTER TABLE visits ADD COLUMN IF NOT EXISTS is_merged BOOLEAN NOT NULL DEFAULT FALSE;
+
+UPDATE visits v SET is_merged = TRUE
+ FROM entity_raw er
+WHERE er.dataset_id = v.dataset_id AND er.entity = 'ZVISIT' AND er.src_pk = v.src_pk
+  AND (er.raw->>'ZMERGEDTO' IS NOT NULL OR er.raw->>'ZPARENT' IS NOT NULL)
+  AND NOT v.is_merged;
+
+-- 给「从 entity_raw 重算 is_merged」用：只索引确实带合并标记的那几十行，
+-- 不用取回 raw 就能判定（上面那条回填与导入回填都走它，否则一次导入要多花几秒）。
+CREATE INDEX IF NOT EXISTS idx_entity_raw_visit_flags ON entity_raw (dataset_id, src_pk)
+  WHERE entity = 'ZVISIT' AND (raw->>'ZMERGEDTO' IS NOT NULL OR raw->>'ZPARENT' IS NOT NULL);

internal/fog/fog.go

@@ -65,9 +65,19 @@ var popcount = func() [256]byte {
 	return t
 }()
 
+// tileDigits 返回瓦片编号的规范十进制串，不足两位补前导 0。
+// 文件名格式固定以 2 位 M2 尾缀结尾（见 tileName），单数字编号不补齐就无法往返。
+func tileDigits(id int) string {
+	s := strconv.Itoa(id)
+	if len(s) < 2 {
+		return "0" + s
+	}
+	return s
+}
+
 // tileIDFromName 从文件名还原瓦片编号，并校验 md5 前缀与 M2 尾缀。
 func tileIDFromName(name string) (int, bool) {
-	if len(name) < 7 || len(name[4:]) < 3 {
+	if len(name) < 8 || len(name[4:]) < 4 {
 		return 0, false
 	}
 	digits := make([]byte, 0, len(name))
@@ -82,7 +92,7 @@ func tileIDFromName(name string) (int, bool) {
 	if err != nil {
 		return 0, false
 	}
-	s := strconv.Itoa(id)
+	s := tileDigits(id)
 	if fmt.Sprintf("%x", md5.Sum([]byte(s)))[:4] != name[:4] {
 		return 0, false
 	}
@@ -97,7 +107,7 @@ func tileIDFromName(name string) (int, bool) {
 
 // tileName 把瓦片编号编码回文件名。
 func tileName(id int) string {
-	s := strconv.Itoa(id)
+	s := tileDigits(id)
 	sum := fmt.Sprintf("%x", md5.Sum([]byte(s)))
 	var b strings.Builder
 	b.WriteString(sum[:4])
@@ -110,6 +120,15 @@ func tileName(id int) string {
 	return b.String()
 }
 
+// maxTileRawBytes / maxTileZBytes 是单个迷雾瓦片的「压缩后 / 解压后」上限。
+// 实测瓦片压缩后约 250KB；解压后结构上最多 headerSize + 65535*blockSize ≈ 33MB
+// （头部的每个索引是 uint16），给到 64MB 已足够宽松。不设上限的话，
+// 一个几 KB 的 zip bomb 就能把 1C1G 的机器打爆。
+const (
+	maxTileRawBytes = 16 << 20
+	maxTileZBytes   = 64 << 20
+)
+
 // Decode 读取 .fwss（或任何包含迷雾瓦片文件的 zip），返回去重后的块与格子总数。
 // 兼容 Model/*/、Sync/、根目录等布局：凡文件名能通过瓦片校验的都算。
 func Decode(data []byte) ([]Block, int, error) {
@@ -131,11 +150,14 @@ func Decode(data []byte) ([]Block, int, error) {
 		if err != nil {
 			return nil, 0, fmt.Errorf("读取 %s: %w", f.Name, err)
 		}
-		raw, err := io.ReadAll(rc)
+		raw, err := io.ReadAll(io.LimitReader(rc, maxTileRawBytes+1))
 		rc.Close()
 		if err != nil {
 			return nil, 0, fmt.Errorf("读取 %s: %w", f.Name, err)
 		}
+		if len(raw) > maxTileRawBytes {
+			return nil, 0, fmt.Errorf("瓦片 %s 压缩后超过 %d 字节，疑似异常快照", f.Name, maxTileRawBytes)
+		}
 		zdata, err := zlibDecompress(raw)
 		if err != nil {
 			return nil, 0, fmt.Errorf("解压 %s: %w", f.Name, err)
@@ -196,7 +218,15 @@ func zlibDecompress(raw []byte) ([]byte, error) {
 		return nil, err
 	}
 	defer zr.Close()
-	return io.ReadAll(zr)
+	out, err := io.ReadAll(io.LimitReader(zr, maxTileZBytes+1))
+	if err != nil {
+		return nil, err
+	}
+	// zlib 流本身可以解出任意长度，必须在读的时候掐住
+	if len(out) > maxTileZBytes {
+		return nil, fmt.Errorf("解压后超过 %d 字节，疑似 zip bomb", maxTileZBytes)
+	}
+	return out, nil
 }
 
 // Encode 把块集还原成 .fwss 结构（Model/*/ 由块重建），可用于导出与再导入。

internal/fog/limit_test.go

@@ -0,0 +1,78 @@
+package fog
+
+import (
+	"archive/zip"
+	"bytes"
+	"compress/zlib"
+	"strings"
+	"testing"
+)
+
+// TestZlibDecompressRejectsBomb 守住「zlib 流能解出任意长度」这个口子。
+// 几十 MB 的全零数据压出来只有几十 KB，解压时不设上限就是一个标准 zip bomb——
+// 上传接口只有站长能用，但 1C1G 的机器被打爆一次就够受。
+func TestZlibDecompressRejectsBomb(t *testing.T) {
+	var buf bytes.Buffer
+	zw := zlib.NewWriter(&buf)
+	zeros := make([]byte, 1<<20)
+	written := 0
+	for written <= maxTileZBytes {
+		if _, err := zw.Write(zeros); err != nil {
+			t.Fatal(err)
+		}
+		written += len(zeros)
+	}
+	if err := zw.Close(); err != nil {
+		t.Fatal(err)
+	}
+	t.Logf("构造出 %d 字节的 zlib 流，解压后 %d 字节", buf.Len(), written)
+
+	if _, err := zlibDecompress(buf.Bytes()); err == nil {
+		t.Errorf("解压出 %d 字节（上限 %d）的流应当被拒绝", written, maxTileZBytes)
+	} else {
+		t.Logf("已拒绝: %v", err)
+	}
+}
+
+// TestZlibDecompressNormalStream 反向确认：正常大小的流仍能原样解出，
+// 免得上面那条把限额做得太紧、把真快照也一起挡了。
+func TestZlibDecompressNormalStream(t *testing.T) {
+	var buf bytes.Buffer
+	zw := zlib.NewWriter(&buf)
+	want := strings.Repeat("rond", 4096)
+	if _, err := zw.Write([]byte(want)); err != nil {
+		t.Fatal(err)
+	}
+	zw.Close()
+
+	got, err := zlibDecompress(buf.Bytes())
+	if err != nil {
+		t.Fatalf("正常流不该被拒: %v", err)
+	}
+	if string(got) != want {
+		t.Errorf("解压结果不一致: %d 字节 → %d 字节", len(want), len(got))
+	}
+}
+
+// TestDecodeRejectsOversizedTileEntry 确认 Decode 这一层也限住了「压缩后」的体积：
+// 条目本身就超限时直接报错，而不是先整个读进内存再判断。
+func TestDecodeRejectsOversizedTileEntry(t *testing.T) {
+	var buf bytes.Buffer
+	zw := zip.NewWriter(&buf)
+	w, err := zw.Create("Model/*/" + tileName(42))
+	if err != nil {
+		t.Fatal(err)
+	}
+	if _, err := w.Write([]byte(strings.Repeat("x", maxTileRawBytes+1))); err != nil {
+		t.Fatal(err)
+	}
+	if err := zw.Close(); err != nil {
+		t.Fatal(err)
+	}
+
+	if _, _, err := Decode(buf.Bytes()); err == nil {
+		t.Errorf("压缩后超过 %d 字节的瓦片应当被拒绝", maxTileRawBytes)
+	} else {
+		t.Logf("已拒绝: %v", err)
+	}
+}

internal/fog/tilename_test.go

@@ -0,0 +1,48 @@
+package fog
+
+import (
+	"crypto/md5"
+	"fmt"
+	"testing"
+)
+
+// 瓦片编号 0..9 是合法的（tx=0, ty=0 那块就是 0），编码/解码都必须能往返。
+func TestTileNameRoundtripAllIDs(t *testing.T) {
+	for _, id := range []int{0, 1, 5, 9, 10, 11, 99, 100, 511, 512, 262143, 1 << 20} {
+		name := tileName(id)
+		got, ok := tileIDFromName(name)
+		if !ok || got != id {
+			t.Errorf("id=%d → name=%q → (%d,%v)，往返不一致", id, name, got, ok)
+		}
+	}
+}
+
+// 4 位 md5("5") 前缀 + mask1 掩码 + 2 位 M2 尾缀 = 7 字节：旧的长度守卫会放行、
+// md5 校验也通过，随后在 s[len(s)-2+i] 处越界 panic（上传构造过的 .fwss 即可触发）。
+func TestTileIDFromNameRejectsCraftedShortName(t *testing.T) {
+	name := fmt.Sprintf("%x", md5.Sum([]byte("5")))[:4] +
+		string(mask1[5]) + string(mask2[5]) + string(mask2[5])
+	if len(name) != 7 {
+		t.Fatalf("构造名长度应为 7，实为 %d (%q)", len(name), name)
+	}
+	if id, ok := tileIDFromName(name); ok {
+		t.Fatalf("构造名 %q 不应被接受（解出 id=%d）", name, id)
+	}
+}
+
+// 网格第一列（tx=0）的瓦片编号就是 0..9，Encode 不能 panic，且能原样解回。
+func TestEncodeHandlesSingleDigitTile(t *testing.T) {
+	bm := make([]byte, bitmapSize)
+	bm[0] = 0x80
+	data, err := Encode([]Block{{GX: 0, GY: 0, Bitmap: bm}}, nil)
+	if err != nil {
+		t.Fatalf("Encode: %v", err)
+	}
+	blocks, cells, err := Decode(data)
+	if err != nil {
+		t.Fatalf("Decode: %v", err)
+	}
+	if len(blocks) != 1 || blocks[0].GX != 0 || blocks[0].GY != 0 || cells != 1 {
+		t.Fatalf("往返得到 %+v (cells=%d)，期望 1 块 (0,0)、1 格", blocks, cells)
+	}
+}

internal/gpx/gpx.go

@@ -125,26 +125,6 @@ func (t Track) LengthKm() float64 {
 	return sum
 }
 
-// BBox 返回 [minLon, minLat, maxLon, maxLat]。
-func (t Track) BBox() [4]float64 {
-	b := [4]float64{180, 90, -180, -90}
-	for _, p := range t.Points {
-		if p.Lon < b[0] {
-			b[0] = p.Lon
-		}
-		if p.Lat < b[1] {
-			b[1] = p.Lat
-		}
-		if p.Lon > b[2] {
-			b[2] = p.Lon
-		}
-		if p.Lat > b[3] {
-			b[3] = p.Lat
-		}
-	}
-	return b
-}
-
 func haversine(a, b Point) float64 {
 	const r = 6371.0
 	dLat := (b.Lat - a.Lat) * math.Pi / 180

internal/gpx/gpx_test.go

@@ -0,0 +1,166 @@
+package gpx
+
+import (
+	"math"
+	"strings"
+	"testing"
+	"time"
+)
+
+const trkGPX = `<?xml version="1.0"?>
+<gpx version="1.1" creator="test">
+  <metadata><name>元数据名</name></metadata>
+  <trk>
+    <name>轨迹名</name>
+    <trkseg>
+      <trkpt lat="30.100000" lon="120.200000"><ele>12.5</ele><time>2026-08-13T07:00:00Z</time></trkpt>
+      <trkpt lat="30.101000" lon="120.200000"><ele>13.5</ele><time>2026-08-13T07:00:30Z</time></trkpt>
+    </trkseg>
+  </trk>
+</gpx>`
+
+func TestParseTrk(t *testing.T) {
+	ts, err := Parse([]byte(trkGPX))
+	if err != nil {
+		t.Fatalf("解析失败: %v", err)
+	}
+	if len(ts) != 1 {
+		t.Fatalf("应得 1 条轨迹，实际 %d", len(ts))
+	}
+	tr := ts[0]
+	if tr.Name != "轨迹名" {
+		t.Errorf("trk 有 name 时用它，实际 %q", tr.Name)
+	}
+	if len(tr.Points) != 2 {
+		t.Fatalf("应得 2 个点，实际 %d", len(tr.Points))
+	}
+	if tr.Points[0].Ele != 12.5 {
+		t.Errorf("trkpt 的高程该带出来，实际 %v", tr.Points[0].Ele)
+	}
+	want := time.Date(2026, 8, 13, 7, 0, 0, 0, time.UTC)
+	if !tr.Points[0].T.Equal(want) {
+		t.Errorf("时间解析错: %v", tr.Points[0].T)
+	}
+}
+
+// trk 没写 name 时退回 metadata>name——否则整条轨迹会没名字。
+func TestParseTrackNameFallsBackToMetadata(t *testing.T) {
+	src := strings.Replace(trkGPX, "<name>轨迹名</name>", "", 1)
+	ts, err := Parse([]byte(src))
+	if err != nil {
+		t.Fatalf("解析失败: %v", err)
+	}
+	if ts[0].Name != "元数据名" {
+		t.Errorf("应退回 metadata 名字，实际 %q", ts[0].Name)
+	}
+}
+
+// 没有 trk 时退回 rte/rtept。
+func TestParseFallsBackToRoute(t *testing.T) {
+	src := `<?xml version="1.0"?>
+<gpx version="1.1"><metadata><name>路线</name></metadata>
+  <rte><name>回家</name>
+    <rtept lat="30.100000" lon="120.200000"><ele>9</ele></rtept>
+    <rtept lat="30.102000" lon="120.200000"><ele>11</ele></rtept>
+  </rte></gpx>`
+	ts, err := Parse([]byte(src))
+	if err != nil {
+		t.Fatalf("解析失败: %v", err)
+	}
+	if len(ts) != 1 || ts[0].Name != "回家" || len(ts[0].Points) != 2 {
+		t.Fatalf("route 应解析成一条轨迹: %+v", ts)
+	}
+	// 与 trkpt 分支不一致：rtept 的高程没被带出来。当前 Point.Ele 全仓无人消费，
+	// 所以不影响功能；这条断言是把现状钉住，将来若决定统一，改这里会立刻提醒。
+	if ts[0].Points[0].Ele != 0 {
+		t.Errorf("rte 分支当前不带高程，实际 %v（如已统一请更新本用例）", ts[0].Points[0].Ele)
+	}
+}
+
+// (0,0) 是 GPX 里常见的空点，必须丢掉，否则「几内亚湾」会被算进里程。
+func TestParseSkipsNullIsland(t *testing.T) {
+	src := `<?xml version="1.0"?>
+<gpx version="1.1"><trk><trkseg>
+  <trkpt lat="0" lon="0"/>
+  <trkpt lat="30.100000" lon="120.200000"/>
+  <trkpt lat="30.101000" lon="120.200000"/>
+</trkseg></trk></gpx>`
+	ts, err := Parse([]byte(src))
+	if err != nil {
+		t.Fatalf("解析失败: %v", err)
+	}
+	if len(ts[0].Points) != 2 {
+		t.Fatalf("(0,0) 该被丢掉，实际剩 %d 个点: %+v", len(ts[0].Points), ts[0].Points)
+	}
+}
+
+// 只有一个点算不出里程，整条丢掉；全丢光就报错，别让调用方以为成功。
+func TestParseDropsSinglePointTrack(t *testing.T) {
+	src := `<?xml version="1.0"?>
+<gpx version="1.1"><trk><trkseg>
+  <trkpt lat="30.100000" lon="120.200000"/>
+</trkseg></trk></gpx>`
+	if ts, err := Parse([]byte(src)); err == nil {
+		t.Fatalf("单点轨迹应当报错，实际返回 %+v", ts)
+	}
+}
+
+func TestParseErrors(t *testing.T) {
+	if _, err := Parse([]byte("这不是 XML")); err == nil ||
+		!strings.Contains(err.Error(), "GPX 解析失败") {
+		t.Errorf("非法 XML 要报「GPX 解析失败」，实际 %v", err)
+	}
+	empty := `<?xml version="1.0"?><gpx version="1.1"><metadata><name>x</name></metadata></gpx>`
+	_, err := Parse([]byte(empty))
+	if err == nil || !strings.Contains(err.Error(), "没有找到轨迹点") {
+		t.Errorf("没有轨迹点要明确报出来，实际 %v", err)
+	}
+}
+
+// 时间格式不对时不该整个失败，只是那个点没有时间。
+func TestParseToleratesBadTime(t *testing.T) {
+	src := `<?xml version="1.0"?>
+<gpx version="1.1"><trk><trkseg>
+  <trkpt lat="30.100000" lon="120.200000"><time>2026/08/13 07:00</time></trkpt>
+  <trkpt lat="30.101000" lon="120.200000"/>
+</trkseg></trk></gpx>`
+	ts, err := Parse([]byte(src))
+	if err != nil {
+		t.Fatalf("解析失败: %v", err)
+	}
+	if !ts[0].Time.IsZero() {
+		t.Errorf("时间解析不出来时应为零值，实际 %v", ts[0].Time)
+	}
+}
+
+// 对跖点附近 h 会因浮点误差略大于 1（实测最多到 1+2^-52）。geo.Haversine 用
+// math.Min(1, …) 夹了一道，gpx 这份没有——但那个夹子在这里其实够不着：sqrt(1+2^-52)
+// 会回舍成正好 1.0，asin(1.0)=π/2，出不了 NaN。这条用例把「对跖点不出 NaN」钉住，
+// 将来若有人换公式或去掉开方，会立刻红。
+func TestLengthKmAntipodalIsFinite(t *testing.T) {
+	for _, c := range [][4]float64{
+		{45, 0, -45, 180},
+		{0, 0, 0, 180},
+		{30.5, 10.25, -30.5, -169.75},
+	} {
+		tr := Track{Points: []Point{{Lat: c[0], Lon: c[1]}, {Lat: c[2], Lon: c[3]}}}
+		if got := tr.LengthKm(); math.IsNaN(got) {
+			t.Errorf("对跖点 %v 算出了 NaN", c)
+		}
+	}
+}
+
+func TestLengthKm(t *testing.T) {
+	// 纬度差 1 度 ≈ 6371*π/180 = 111.19 km
+	tr := Track{Points: []Point{{Lat: 30, Lon: 120}, {Lat: 31, Lon: 120}}}
+	got := tr.LengthKm()
+	if math.Abs(got-111.195) > 0.01 {
+		t.Errorf("1 度纬度该约 111.19 km，实际 %.4f", got)
+	}
+	if n := (Track{Points: []Point{{Lat: 30, Lon: 120}}}).LengthKm(); n != 0 {
+		t.Errorf("单点里程该为 0，实际 %v", n)
+	}
+	if n := (Track{}).LengthKm(); n != 0 {
+		t.Errorf("空轨迹里程该为 0，实际 %v", n)
+	}
+}

internal/ingest/coord.go

@@ -6,6 +6,7 @@ import (
 	"fmt"
 
 	"rond-with-you/internal/geo"
+	"rond-with-you/internal/rond"
 )
 
 // querier 让回填既能跑在导入事务里，也能跑在启动时的连接池上。
@@ -30,15 +31,15 @@ type querier interface {
 // ZRAWLONGITUDE。按「src_lon 恰好等于显示经度」精确识别后改写，不碰用户手工订正过的值。
 func BackfillCoordSource(ctx context.Context, q querier, datasetID int64) (int, error) {
 	rows, err := q.QueryContext(ctx, `SELECT p.src_pk, COALESCE(p.coord_source,''), p.src_lat, p.src_lon,
-		(r.raw->>'ZLATITUDE')::float8, (r.raw->>'ZLONGITUDE')::float8,
+		`+rond.RawFloat8(`r.raw->>'ZLATITUDE'`)+`, `+rond.RawFloat8(`r.raw->>'ZLONGITUDE'`)+`,
-		(r.raw->>'ZRAWLATITUDE')::float8, (r.raw->>'ZRAWLONGITUDE')::float8
+		`+rond.RawFloat8(`r.raw->>'ZRAWLATITUDE'`)+`, `+rond.RawFloat8(`r.raw->>'ZRAWLONGITUDE'`)+`
 	  FROM places p JOIN entity_raw r
 	    ON r.dataset_id=p.dataset_id AND r.entity='ZLOCATION' AND r.src_pk=p.src_pk
 	 WHERE p.dataset_id=$1
-	   AND (r.raw->>'ZLATITUDE')     ~ '^-?[0-9.]+$'
+	   AND (r.raw->>'ZLATITUDE')     ~ '`+rond.RawFloatPattern+`'
-	   AND (r.raw->>'ZLONGITUDE')    ~ '^-?[0-9.]+$'
+	   AND (r.raw->>'ZLONGITUDE')    ~ '`+rond.RawFloatPattern+`'
-	   AND (r.raw->>'ZRAWLATITUDE')  ~ '^-?[0-9.]+$'
+	   AND (r.raw->>'ZRAWLATITUDE')  ~ '`+rond.RawFloatPattern+`'
-	   AND (r.raw->>'ZRAWLONGITUDE') ~ '^-?[0-9.]+$'`, datasetID)
+	   AND (r.raw->>'ZRAWLONGITUDE') ~ '`+rond.RawFloatPattern+`'`, datasetID)
 	if err != nil {
 		return 0, fmt.Errorf("读留档行: %w", err)
 	}

internal/ingest/dirty_import_test.go

@@ -0,0 +1,108 @@
+package ingest
+
+import (
+	"context"
+	"database/sql"
+	"fmt"
+	"net/url"
+	"os"
+	"strings"
+	"testing"
+	"time"
+
+	_ "github.com/jackc/pgx/v5/stdlib"
+
+	"rond-with-you/internal/db"
+	"rond-with-you/internal/rond"
+)
+
+// ingestTestDSN 把 ROND_DSN 的库名换成专用库。Import 会把该用户的 is_active 切到自己那份，
+// 而 stats 的夹具是「WHERE is_active LIMIT 1」找数据集（不带 user 过滤）——共用库时，
+// 本用例运行期间那份临时数据集会被别的包选中，直接串味。换个库谁都不影响谁（库不存在 db.Open 会建）。
+func ingestTestDSN(base string) string {
+	u, err := url.Parse(base)
+	if err != nil || u.Path == "" {
+		return base
+	}
+	u.Path = strings.TrimSuffix(u.Path, "/") + "_ingest"
+	return u.String()
+}
+
+// 脏时间（parse 阶段被 appleTime 判成 nil 的到访）导入后必须：
+//   - 不进站点模型（visit_count 不含它）；
+//   - 按「跳过」留档，导出时原样补回（否则一趟导入导出就少一条）；
+//   - 绝不污染 datasets.first_visit_at —— 旧实现会把它回绕成 2001，时间轴直接从 2001 起算。
+func TestImportKeepsDirtyTimeOutOfTimeline(t *testing.T) {
+	base := os.Getenv("ROND_DSN")
+	if base == "" {
+		t.Skip("未设置 ROND_DSN")
+	}
+	ctx := context.Background()
+	d, err := db.Open(ingestTestDSN(base))
+	if err != nil {
+		t.Fatal(err)
+	}
+	// 先注册 close、后注册删用户：Cleanup 是后进先出，删用户时连接还没关。
+	t.Cleanup(func() { d.Close() })
+	if err := db.Migrate(ctx, d); err != nil {
+		t.Fatal(err)
+	}
+
+	var userID int64
+	uname := fmt.Sprintf("__dirty_%d", time.Now().UnixNano())
+	if err := d.QueryRowContext(ctx,
+		`INSERT INTO users (username, password_hash) VALUES ($1,'x') RETURNING id`, uname).Scan(&userID); err != nil {
+		t.Fatal(err)
+	}
+	t.Cleanup(func() { d.Exec(`DELETE FROM users WHERE id=$1`, userID) })
+
+	good := time.Date(2026, 9, 20, 8, 0, 0, 0, time.UTC)
+	b := &rond.Backup{
+		VisitUUID:    map[int]string{1: strings.Repeat("a", 32)},
+		ActivityUUID: map[int]string{},
+		Locations:    []rond.Location{{SrcPK: 1, Name: "家", Lat: 24.1, Lon: 109.1}},
+		Visits: []rond.Visit{
+			{SrcPK: 1, Arrival: &good, LocationSrcPK: intp(1)},
+			{SrcPK: 2, Arrival: nil, LocationSrcPK: intp(1)}, // 脏时间被 appleTime 判成 nil
+		},
+		RawRows: map[string]map[int]map[string]any{
+			"ZVISIT": {2: {"Z_PK": int64(2), "ZARRIVALDATE_": 1e30}},
+		},
+	}
+
+	datasetID, st, err := Import(ctx, d, userID, "dirty.rondbackup", strings.Repeat("0", 64), 1, b)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	if st.Visits != 1 {
+		t.Errorf("只该导入 1 条到访（脏时间那条跳过），实际 %d", st.Visits)
+	}
+
+	var stored int
+	if err := d.QueryRowContext(ctx,
+		`SELECT count(*) FROM visits WHERE dataset_id=$1`, datasetID).Scan(&stored); err != nil {
+		t.Fatal(err)
+	}
+	if stored != 1 {
+		t.Errorf("库里到访应为 1 条，实际 %d", stored)
+	}
+
+	var archived int
+	if err := d.QueryRowContext(ctx,
+		`SELECT count(*) FROM entity_raw WHERE dataset_id=$1 AND entity='ZVISIT' AND skipped`, datasetID).Scan(&archived); err != nil {
+		t.Fatal(err)
+	}
+	if archived != 1 {
+		t.Errorf("脏时间的到访应当留档为 skipped，实际 %d 条", archived)
+	}
+
+	var first, last sql.NullTime
+	if err := d.QueryRowContext(ctx,
+		`SELECT first_visit_at, last_visit_at FROM datasets WHERE id=$1`, datasetID).Scan(&first, &last); err != nil {
+		t.Fatal(err)
+	}
+	if !first.Valid || !first.Time.Equal(good) {
+		t.Errorf("first_visit_at 应等于合法到访的时间 %s，实际 %v", good.Format(time.RFC3339), first)
+	}
+}

internal/ingest/ingest.go

@@ -17,6 +17,7 @@ import (
 
 	"rond-with-you/internal/geo"
 	"rond-with-you/internal/rond"
+	"rond-with-you/internal/stats"
 )
 
 type Stats struct {
@@ -205,13 +206,6 @@ func Import(ctx context.Context, db *sql.DB, userID int64, originalName, sha str
 
 	// 地点
 	placeID := map[int]int64{}
-	type locAgg struct {
-		count int
-		dwell int64
-		first *time.Time
-		last  *time.Time
-	}
-	agg := map[int]*locAgg{}
 	locCoord := map[int][2]float64{}
 	for _, l := range b.Locations {
 		var id int64
@@ -225,7 +219,6 @@ func Import(ctx context.Context, db *sql.DB, userID int64, originalName, sha str
 			return 0, nil, fmt.Errorf("写入地点: %w", err)
 		}
 		placeID[l.SrcPK] = id
-		agg[l.SrcPK] = &locAgg{}
 		locCoord[l.SrcPK] = [2]float64{l.Lat, l.Lon}
 	}
 
@@ -282,18 +275,6 @@ func Import(ctx context.Context, db *sql.DB, userID int64, originalName, sha str
 		vcount++
 
 		if v.LocationSrcPK != nil {
-			if a, ok := agg[*v.LocationSrcPK]; ok {
-				a.count++
-				if dur != nil {
-					a.dwell += int64(dur.(int))
-				}
-				if a.first == nil || v.Arrival.Before(*a.first) {
-					a.first = v.Arrival
-				}
-				if a.last == nil || v.Arrival.After(*a.last) {
-					a.last = v.Arrival
-				}
-			}
 			visitPlace[v.SrcPK] = *v.LocationSrcPK
 		}
 		if first == nil || v.Arrival.Before(*first) {
@@ -374,14 +355,6 @@ func Import(ctx context.Context, db *sql.DB, userID int64, originalName, sha str
 		}
 	}
 
-	// 回填地点聚合
-	for src, a := range agg {
-		if _, err := tx.ExecContext(ctx, `UPDATE places SET visit_count=$1, dwell_minutes=$2,
-			first_visit_at=$3, last_visit_at=$4 WHERE id=$5`, a.count, a.dwell, a.first, a.last, placeID[src]); err != nil {
-			return 0, nil, fmt.Errorf("回填地点统计: %w", err)
-		}
-	}
-
 	// 汇总
 	st := &Stats{Visits: vcount, Skipped: skipped, Places: len(b.Locations), RawVisits: b.RawVisitNum, FirstVisit: first, LastVisit: last}
 	if _, err := tx.ExecContext(ctx, `UPDATE datasets SET status='done', visit_count=$1, place_count=$2,
@@ -403,6 +376,29 @@ func Import(ctx context.Context, db *sql.DB, userID int64, originalName, sha str
 		return 0, nil, err
 	}
 
+	// 派生列：从留档里认「已并入 / 子段」的到访（读侧只看这一列，见 stats.SoloVisitSQL）。
+	// ⚠️ 同样必须排在 insertEntityRaw 之后——留档还没写盘时一条都认不出来。
+	if _, err := tx.ExecContext(ctx, stats.RefreshMergedFlagsSQL, datasetID); err != nil {
+		return 0, nil, fmt.Errorf("回填合并标记: %w", err)
+	}
+
+	// 回填地点聚合：走与刷新路径（refreshPlaceAgg / recountPlaces）同一条 SQL，
+	// 口径才不会在两处漂移——到访数与停留按访客口径（stats.SoloVisitSQL，不含已并入 / 子段），
+	// 首末到访保持全量。原来这里在 Go 里另算一遍，还漏了停留上限（LEAST(...,10080)）。
+	//
+	// ⚠️ 必须排在 insertEntityRaw **之后**：判据读的是 entity_raw，留档还没写盘时
+	// 每一行都会被当成独立到访（实测会整整多算一个「已并入」的量，26 条）。
+	if _, err := tx.ExecContext(ctx, `UPDATE places p SET visit_count=sub.c, dwell_minutes=sub.d,
+		first_visit_at=sub.f, last_visit_at=sub.l
+		FROM (SELECT vis.place_id,
+			count(*) FILTER (WHERE `+stats.SoloVisitSQL("vis")+`) c,
+			COALESCE(sum(LEAST(COALESCE(vis.duration_min,0),10080)) FILTER (WHERE `+stats.SoloVisitSQL("vis")+`),0) d,
+			min(vis.arrival) f, max(vis.arrival) l
+			FROM visits vis WHERE vis.dataset_id=$1 AND vis.place_id IS NOT NULL GROUP BY vis.place_id) sub
+		WHERE p.id = sub.place_id`, datasetID); err != nil {
+		return 0, nil, fmt.Errorf("回填地点统计: %w", err)
+	}
+
 	// 坐标来源留档要等 entity_raw 写完才能做（原始 GPS 只在留档行里）。
 	if _, err := BackfillCoordSource(ctx, tx, datasetID); err != nil {
 		return 0, nil, err

internal/media/media.go

@@ -11,6 +11,7 @@ import (
 	"crypto/hmac"
 	"crypto/sha256"
 	"encoding/hex"
+	"encoding/xml"
 	"errors"
 	"fmt"
 	"io"
@@ -136,7 +137,97 @@ func (s *Store) pruneEmptyDirs(dir string) {
 	}
 }
 
-/* ---------- S3 兼容对象存储：只实现 PUT / DELETE + SigV4 签名 ---------- */
+/* ---------- S3 兼容对象存储：只实现 PUT / DELETE / LIST + SigV4 签名 ---------- */
+
+// Object 是对象存储里的一个对象（列表用，只要键与大小）。
+type Object struct {
+	Key  string
+	Size int64
+}
+
+// listBucketResult 是 ListObjectsV2 的响应里我们关心的部分。
+type listBucketResult struct {
+	IsTruncated           bool   `xml:"IsTruncated"`
+	NextContinuationToken string `xml:"NextContinuationToken"`
+	Contents              []struct {
+		Key  string `xml:"Key"`
+		Size int64  `xml:"Size"`
+	} `xml:"Contents"`
+}
+
+// ListObjects 列出某个前缀下的对象（S3 ListObjectsV2，自动翻页）。
+//
+// 为什么需要它：「图片挂载恢复」要从对象存储里找回**库里已经没有记录**的图片——
+// 那些对象的键只剩下桶里有（上传时落的那行被级联删了），不列桶就无从得知它们叫什么。
+//
+// ⚠️ 需要凭据上有 s3:ListBucket 权限（R2 的 API Token 默认只给对象读写）。
+// 没权限时报错会把 HTTP 状态与响应体前一段带出来，照着开权限即可。
+func (s *Store) ListObjects(ctx context.Context, prefix string) ([]Object, error) {
+	if !s.cfg.S3Ready() {
+		return nil, errors.New("对象存储未配置齐全（需要 s3_endpoint / s3_bucket / s3_access_key / s3_secret_key）")
+	}
+	var out []Object
+	token := ""
+	for page := 0; ; page++ {
+		// 防御：桶里对象极多（或服务端一直说「还有下一页」）时别把内存与时间耗光
+		if page >= 200 {
+			return out, fmt.Errorf("对象列表翻页过多（已取 %d 个对象）", len(out))
+		}
+		q := "list-type=2&prefix=" + escape(prefix)
+		if token != "" {
+			q += "&continuation-token=" + escape(token)
+		}
+		req, err := s.s3ListRequest(ctx, q)
+		if err != nil {
+			return nil, err
+		}
+		s.sign(req, nil)
+		resp, err := s.client.Do(req)
+		if err != nil {
+			return nil, err
+		}
+		body, rerr := io.ReadAll(io.LimitReader(resp.Body, 8<<20))
+		resp.Body.Close()
+		if resp.StatusCode/100 != 2 {
+			tail := strings.TrimSpace(string(body))
+			if len(tail) > 300 {
+				tail = tail[:300] + "…"
+			}
+			return nil, fmt.Errorf("列出对象失败：HTTP %d %s（对象存储凭据需要 s3:ListBucket 权限）",
+				resp.StatusCode, tail)
+		}
+		if rerr != nil {
+			return nil, rerr
+		}
+		var parsed listBucketResult
+		if err := xml.Unmarshal(body, &parsed); err != nil {
+			return nil, fmt.Errorf("解析对象列表失败：%w", err)
+		}
+		for _, c := range parsed.Contents {
+			if c.Key == "" {
+				continue
+			}
+			out = append(out, Object{Key: c.Key, Size: c.Size})
+		}
+		if !parsed.IsTruncated || parsed.NextContinuationToken == "" {
+			return out, nil
+		}
+		token = parsed.NextContinuationToken
+	}
+}
+
+// s3ListRequest 拼「列桶」请求：路径只到桶（不带对象键），查询串自己编码好交给签名。
+// 查询串必须**先编码再签**：canonicalQuery 是按原样取 RawQuery 的，两边得是同一份字节。
+func (s *Store) s3ListRequest(ctx context.Context, rawQuery string) (*http.Request, error) {
+	u := s.cfg.S3Endpoint + "/" + escapePath(s.cfg.S3Bucket) + "?" + rawQuery
+	req, err := http.NewRequestWithContext(ctx, http.MethodGet, u, nil)
+	if err != nil {
+		return nil, err
+	}
+	req.Header.Set("x-amz-content-sha256", sha256Hex(nil))
+	return req, nil
+}
+
 func (s *Store) putS3(ctx context.Context, key string, data []byte, contentType string) error {
 	if contentType == "" {
 		contentType = "application/octet-stream"

internal/media/s3_list_test.go

@@ -0,0 +1,134 @@
+package media
+
+import (
+	"context"
+	"fmt"
+	"net/http"
+	"net/http/httptest"
+	"strings"
+	"testing"
+
+	"rond-with-you/internal/config"
+)
+
+// ---------- 列桶（ListObjectsV2）----------
+//
+// 为什么要它：「图片挂载恢复」要找回**库里已经没有记录**的图片，而那些对象的键只剩下
+// 桶里有。列不出来就只救得回本地磁盘那一半。
+// 这几条用例守的是请求形状、翻页、以及「没权限时要说清楚该怎么办」。
+
+func testStore(t *testing.T, endpoint string) *Store {
+	t.Helper()
+	return New(&config.Config{
+		S3Endpoint: endpoint, S3Region: "auto", S3Bucket: "rond",
+		S3AccessKey: "ak", S3SecretKey: "sk",
+	})
+}
+
+// listXML 拼一份最小的 ListObjectsV2 响应。
+func listXML(keys []string, truncated bool, token string) string {
+	var b strings.Builder
+	b.WriteString(`<?xml version="1.0" encoding="UTF-8"?><ListBucketResult><Name>rond</Name>`)
+	for _, k := range keys {
+		b.WriteString("<Contents><Key>" + k + "</Key><Size>1234</Size></Contents>")
+	}
+	fmt.Fprintf(&b, "<IsTruncated>%v</IsTruncated><KeyCount>%d</KeyCount>", truncated, len(keys))
+	if token != "" {
+		b.WriteString("<NextContinuationToken>" + token + "</NextContinuationToken>")
+	}
+	b.WriteString(`</ListBucketResult>`)
+	return b.String()
+}
+
+func TestListObjectsSignsAndParses(t *testing.T) {
+	var gotPath, gotQuery, gotAuth string
+	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		gotPath, gotQuery, gotAuth = r.URL.Path, r.URL.RawQuery, r.Header.Get("Authorization")
+		w.Header().Set("Content-Type", "application/xml")
+		fmt.Fprint(w, listXML([]string{"9/202609/309-abc.webp"}, false, ""))
+	}))
+	defer srv.Close()
+
+	s := testStore(t, srv.URL)
+	objs, err := s.ListObjects(context.Background(), "9/")
+	if err != nil {
+		t.Fatalf("列出对象失败: %v", err)
+	}
+	if len(objs) != 1 || objs[0].Key != "9/202609/309-abc.webp" || objs[0].Size != 1234 {
+		t.Fatalf("解析结果不对: %+v", objs)
+	}
+	// 路径式访问：只到桶，不带对象键
+	if gotPath != "/rond" {
+		t.Errorf("请求路径应为 /rond，实际 %q", gotPath)
+	}
+	// 查询串必须**先编码再签**：prefix 里的 / 要写成 %2F，签名与发送必须是同一份字节
+	if gotQuery != "list-type=2&prefix=9%2F" {
+		t.Errorf("查询串不对: %q", gotQuery)
+	}
+	if !strings.HasPrefix(gotAuth, "AWS4-HMAC-SHA256 Credential=ak/") || !strings.Contains(gotAuth, "/auto/s3/aws4_request") {
+		t.Errorf("签名头不对: %q", gotAuth)
+	}
+}
+
+func TestListObjectsFollowsContinuationToken(t *testing.T) {
+	var pages int
+	var seen []string
+	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		pages++
+		q := r.URL.Query()
+		seen = append(seen, q.Get("continuation-token"))
+		w.Header().Set("Content-Type", "application/xml")
+		if pages == 1 {
+			fmt.Fprint(w, listXML([]string{"9/a.webp"}, true, "tok-1"))
+			return
+		}
+		fmt.Fprint(w, listXML([]string{"9/b.webp"}, false, ""))
+	}))
+	defer srv.Close()
+
+	s := testStore(t, srv.URL)
+	objs, err := s.ListObjects(context.Background(), "9/")
+	if err != nil {
+		t.Fatalf("列出对象失败: %v", err)
+	}
+	if pages != 2 {
+		t.Errorf("应当翻两页，实际 %d", pages)
+	}
+	if len(objs) != 2 || objs[0].Key != "9/a.webp" || objs[1].Key != "9/b.webp" {
+		t.Errorf("两页结果没合并: %+v", objs)
+	}
+	// 第二页要把 token 带上，且同样要编码
+	if seen[0] != "" || seen[1] != "tok-1" {
+		t.Errorf("continuation-token 没带上（或顺序不对）: %v", seen)
+	}
+}
+
+// TestListObjectsReportsPermission 没权限（403）时要把「需要 s3:ListBucket」说清楚——
+// R2 的 API Token 默认只给对象读写，第一次点恢复多半就撞在这里。
+func TestListObjectsReportsPermission(t *testing.T) {
+	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		w.WriteHeader(http.StatusForbidden)
+		fmt.Fprint(w, `<Error><Code>AccessDenied</Code></Error>`)
+	}))
+	defer srv.Close()
+
+	s := testStore(t, srv.URL)
+	_, err := s.ListObjects(context.Background(), "")
+	if err == nil {
+		t.Fatal("403 应当报错")
+	}
+	if !strings.Contains(err.Error(), "403") || !strings.Contains(err.Error(), "s3:ListBucket") {
+		t.Errorf("错误里没说清该怎么办: %v", err)
+	}
+	if !strings.Contains(err.Error(), "AccessDenied") {
+		t.Errorf("错误里没带服务端的响应体（不好排查）: %v", err)
+	}
+}
+
+// TestListObjectsRejectsUnconfigured 没配齐凭据时不该发出请求。
+func TestListObjectsRejectsUnconfigured(t *testing.T) {
+	s := New(&config.Config{})
+	if _, err := s.ListObjects(context.Background(), ""); err == nil {
+		t.Fatal("没配齐应当报错")
+	}
+}

internal/notes/notes.go

@@ -69,6 +69,29 @@ func (s *Store) SetNote(ctx context.Context, userID, datasetID int64, srcPK int,
 	return s.Save(ctx, userID, datasetID, srcPK, alias, content)
 }
 
+// SetNoteBulk 批量「清空备注、保留别名」，语义与逐条 SetNote(..., "") 一致，但只发两条语句
+// （逐个来是 2N 次往返，勾几十个地点在 1C1G 的机器上是能感觉到的）：
+// 先删掉「别名与 rond 备注都为空」的行，再把其余行的手写 note 清空。
+func (s *Store) SetNoteBulk(ctx context.Context, userID, datasetID int64, srcPKs []int64) error {
+	if len(srcPKs) == 0 {
+		return nil
+	}
+	if _, err := s.DB.ExecContext(ctx, `DELETE FROM place_notes n USING places p
+		WHERE n.user_id=$1 AND p.dataset_id=$2 AND p.src_pk = ANY($3::bigint[])
+		  AND n.place_key = `+placeKeyExpr("p")+`
+		  AND btrim(COALESCE(n.alias,''))='' AND n.rond_note=''`,
+		userID, datasetID, srcPKs); err != nil {
+		return err
+	}
+	// 顺带把 dataset_id/src_pk 刷成当前数据集的值，与逐条 Save 的 upsert 行为对齐
+	_, err := s.DB.ExecContext(ctx, `UPDATE place_notes n
+		SET note='', dataset_id=p.dataset_id, src_pk=p.src_pk, updated_at=now()
+		FROM places p
+		WHERE n.user_id=$1 AND p.dataset_id=$2 AND p.src_pk = ANY($3::bigint[])
+		  AND n.place_key = `+placeKeyExpr("p"), userID, datasetID, srcPKs)
+	return err
+}
+
 // Delete 删除某地点的整条备注与别名。
 func (s *Store) Delete(ctx context.Context, userID, datasetID int64, srcPK int) error {
 	_, err := s.DB.ExecContext(ctx, `DELETE FROM place_notes n USING places p
@@ -77,6 +100,17 @@ func (s *Store) Delete(ctx context.Context, userID, datasetID int64, srcPK int)
 	return err
 }
 
+// DeleteBulk 一次删掉多个地点的整条备注与别名（后台批量勾选时用，一条语句代替 N 次往返）。
+func (s *Store) DeleteBulk(ctx context.Context, userID, datasetID int64, srcPKs []int64) error {
+	if len(srcPKs) == 0 {
+		return nil
+	}
+	_, err := s.DB.ExecContext(ctx, `DELETE FROM place_notes n USING places p
+		WHERE n.user_id=$1 AND p.dataset_id=$2 AND p.src_pk = ANY($3::bigint[])
+		  AND n.place_key = `+placeKeyExpr("p"), userID, datasetID, srcPKs)
+	return err
+}
+
 // Save 写入别名与备注；两者都为空时清空手写内容（rond 回填的那一块要留着）。
 func (s *Store) Save(ctx context.Context, userID, datasetID int64, srcPK int, alias, content string) error {
 	alias = strings.TrimSpace(alias)

internal/rond/diff.go

@@ -3,7 +3,10 @@ package rond
 import (
 	"fmt"
 	"sort"
+	"strings"
 	"time"
+
+	"rond-with-you/internal/geo"
 )
 
 // 两份数据的比对。
@@ -27,6 +30,7 @@ type StoredVisit struct {
 	PlaceKey     string // 地点对齐键，空 = 该到访没有地点
 	PlaceName    string // 仅用于展示
 	ActivityName string
+	ActivityUUID string // 该到访所挂活动的对齐键，空 = 站点新建的活动
 }
 
 // StoredPlace 是库里的一个地点。
@@ -108,8 +112,40 @@ func PlaceCoordKey(lat, lon float64) string {
 	return fmt.Sprintf("%.6f|%.6f", lat, lon)
 }
 
+// nameMatchMaxKm 是「按名称兜底配对」允许的最大距离（公里）。
+//
+// 名称不是唯一键：连锁店同名是常态（实测真机里「中国体育彩票」3 条、「长沙南站」2 条、
+// 「茶颜悦色」2 条）。没有距离上限时，坐标配不上的两条同名地点会被强行配成一对——
+// 实测把佛山的「中国体育彩票」配给了贺州那条（直线 236.8km），站长一勾「用实机」就把
+// 站内那条地点的坐标搬到另一座城市、名下到访集体跳城。1km 足够覆盖「站点把坐标纠偏过」
+// （实测那批偏移 660~750m），又不会跨城配对。
+const nameMatchMaxKm = 1.0
+
 func coordStr(v float64) string { return fmt.Sprintf("%.6f", v) }
 
+// RawFloat8 返回「把 entity_raw 里的 JSON 值安全地转成 float8」的 SQL 表达式，
+// 值不是合法的数字就给 NULL，而不是抛错。
+//
+// 留档是原样存下来的 JSON，值不一定是数字：空串、字符串形式的 "1.2.3"、
+// "NaN" 都可能出现。直接 `::float8` 会抛 invalid input syntax，代价是**编辑页
+// 整页 500** 或**整次导入失败 / 启动自愈失败**，而且只在特定那一行数据上复现。
+//
+// 两个实现细节都有原因，别简化：
+//   - 写成 CASE 而不是「正则 AND cast」：PG 不保证 AND/OR 各操作数的求值顺序，
+//     正则没挡住时照样会炸；CASE 只求值命中的那个分支。
+//   - 正则把**指数限在两位**，于是最大幅度约 1e109，本身就进不了 float8 的溢出区
+//     （实测 `'1e999'` 这类值在 CASE 里一样会抛 out of range）。这样不依赖
+//     PG 版本——`pg_input_is_valid` 要 PG 16+，本项目的库版本没有写死。
+//     坐标用不上 1e109 以上的写法，也不会小到 1e-100 以下。
+//
+// RawFloatPattern 是同一个正则（不带引号），给「只想判合不合法、不取数值」的地方用：
+// 光一个 `~` 判断不会抛错，所以那种地方可以直接串它。
+const RawFloatPattern = `^[+-]?([0-9]{1,10}(\.[0-9]*)?|\.[0-9]{1,10})([eE][+-]?[0-9]{1,2})?$`
+
+func RawFloat8(expr string) string {
+	return `CASE WHEN ` + expr + ` ~ '` + RawFloatPattern + `' THEN (` + expr + `)::float8 END`
+}
+
 // DiffVisits 按 UUID 对齐两边的到访。
 //
 // 真机偶尔有条目没写 UUID（实测 824 行到访里有 2 行），只按 UUID 配对会让同一条既算
@@ -133,11 +169,12 @@ func DiffVisits(stored []StoredVisit, b *Backup) VisitDiff {
 	byUUID := make(map[string]int, len(stored))
 	byTime := map[string][]int{}
 	for i, sv := range stored {
-		if sv.UUID != "" {
+		// 站点补录的行没有留档 UUID，但它导出过一次之后就带着派生 UUID 在包里
-			byUUID[sv.UUID] = i
+		// （见 VisitMatchUUID）——不拿它当键，同一行会被判成「备份新增」再插一条。
-			continue
+		if u := VisitMatchUUID(sv); u != "" {
+			byUUID[u] = i
 		}
-		if sv.Arrival != nil {
+		if sv.UUID == "" && sv.Arrival != nil {
 			k := timeKey(*sv.Arrival, sv.PlaceKey)
 			byTime[k] = append(byTime[k], i)
 		}
@@ -147,7 +184,7 @@ func DiffVisits(stored []StoredVisit, b *Backup) VisitDiff {
 	classify := func(i int, v Visit) {
 		used[i] = true
 		sv := stored[i]
-		if fields := visitFieldChanges(sv, v, placeKey, placeName, actName); len(fields) > 0 {
+		if fields := visitFieldChanges(sv, v, placeKey, placeName, actName, b.ActivityUUID); len(fields) > 0 {
 			d.Changed = append(d.Changed, VisitConflict{Backup: v, DB: sv, Fields: fields})
 		} else {
 			d.Same++
@@ -170,8 +207,15 @@ func DiffVisits(stored []StoredVisit, b *Backup) VisitDiff {
 		if v.LocationSrcPK != nil {
 			bpk = placeKey[*v.LocationSrcPK]
 		}
-		if list := byTime[timeKey(*v.Arrival, bpk)]; len(list) > 0 {
+		// 照旧按「时间 + 地点」兜底，但要跳过已经被 UUID 那一路认领的行——
-			byTime[timeKey(*v.Arrival, bpk)] = list[1:]
+		// 同一条站点行可能两个索引里都有，重复 classify 会把它算成两条。
+		k := timeKey(*v.Arrival, bpk)
+		list := byTime[k]
+		for len(list) > 0 && used[list[0]] {
+			list = list[1:]
+		}
+		if len(list) > 0 {
+			byTime[k] = list[1:]
 			classify(list[0], v)
 			continue
 		}
@@ -192,7 +236,7 @@ func timeKey(t time.Time, place string) string {
 	return fmt.Sprintf("%d|%s", t.Unix(), place)
 }
 
-func visitFieldChanges(sv StoredVisit, v Visit, placeKey, placeName, actName map[int]string) []FieldChange {
+func visitFieldChanges(sv StoredVisit, v Visit, placeKey, placeName, actName, actUUID map[int]string) []FieldChange {
 	var out []FieldChange
 	add := func(label, from, to string) {
 		if from != to {
@@ -205,20 +249,36 @@ func visitFieldChanges(sv StoredVisit, v Visit, placeKey, placeName, actName map
 	if !sameTime(sv.Departure, v.Departure) {
 		add("离开时间", fmtTime(sv.Departure), fmtTime(v.Departure))
 	}
-	// 地点按坐标判、显示名称；活动按名称判。都不能比 src_pk——两边编号空间不同。
+	// 地点按坐标、活动按身份比对，都不能比 src_pk——两边编号空间不同。
 	bp, bn := "", ""
 	if v.LocationSrcPK != nil {
 		bp, bn = placeKey[*v.LocationSrcPK], placeName[*v.LocationSrcPK]
 	}
 	// 地点按坐标判、显示名称：名称被「补全地址」反查改过，不算换了地点
 	if sv.PlaceKey != bp {
-		out = append(out, FieldChange{Label: "地点", From: sv.PlaceName, To: bn})
+		from, to := sv.PlaceName, bn
+		if from == to {
+			// 名称一样就必须把坐标摊开：这一项比的是坐标，只印名称会渲染成「X → X」，
+			// 站长看不出差在哪（连锁店重名、同一地点两边坐标略有出入都会走到这里）。
+			from, to = coordSuffix(from, sv.PlaceKey), coordSuffix(bn, bp)
+		}
+		out = append(out, FieldChange{Label: "地点", From: from, To: to})
 	}
-	bl := ""
+	// 活动按**身份**判，不按名称：站内与真机对同一个活动改名属于活动层的差异，
+	// 挂在它名下的每条到访都跟着报一遍就会把真差异淹掉（实测 16 个活动改名 → 355 条假冲突），
+	// 而且逐条选「用实机」也改不掉活动名，冲突永远收敛不了。
+	// 两边都有 UUID 才比 UUID；缺 UUID 的老数据退回按名称比。
+	bl, bu := "", ""
 	if v.ActivitySrcPK != nil {
-		bl = actName[*v.ActivitySrcPK]
+		bl, bu = actName[*v.ActivitySrcPK], actUUID[*v.ActivitySrcPK]
+	}
+	if sv.ActivityUUID != "" && bu != "" {
+		if sv.ActivityUUID != bu {
+			add("活动", sv.ActivityName, bl)
+		}
+	} else {
+		add("活动", sv.ActivityName, bl)
 	}
-	add("活动", sv.ActivityName, bl)
 	add("备注", sv.Remark, v.Remark)
 	add("表情", sv.Emoji, v.Emoji)
 	add("收藏", fmtBool(sv.Bookmarked), fmtBool(v.Bookmarked))
@@ -233,42 +293,96 @@ func placeLabel(name string, lat, lon float64) string {
 	return fmt.Sprintf("%.5f, %.5f", lat, lon)
 }
 
-// DiffPlaces 对齐地点。坐标优先（改名不影响配对），配不上再按名称找一遍
+// PlaceMatch 是「备份地点编号 -> 库内地点」的配对结果。
-// （覆盖「站点把坐标纠偏过」这种），两样都对不上才算新增。
+type PlaceMatch map[int]StoredPlace
-func DiffPlaces(stored []StoredPlace, b *Backup) PlaceDiff {
+
-	byCoord := make(map[string]StoredPlace, len(stored))
+// MatchPlaces 把备份地点配到库内地点：坐标优先（改名不影响配对），配不上再退到
-	byName := map[string]StoredPlace{}
+// 「同名且相距不超过 nameMatchMaxKm」。
+//
+// 内部用**多值**索引：真机一个坐标下会有好几条同名同坐标的地点（实测「柳州站」3 条），
+// 单槽位 map 会让同一坐标最多只配上一条，剩下的一律判成「备份新增」——于是每次合并都再插
+// 一条重复地点、差异永远归不了零。认领过的一定要标记已用，否则多条会双双落到同一条上。
+//
+// 差异判定（DiffPlaces）与合并执行（internal/web）**必须共用这一份实现**：两处各配一遍就会
+// 漂移——合并侧原来是单槽位 map 自己再配一次，于是同一坐标/同名的多条备份地点全并到同一条
+// 站内地点上，到访被挂到错的分店（实测「茶颜悦色」两家分店相隔 8.3km）。
+//
+// 两个入参的顺序都要稳定（库内按 id、备份按解析顺序），否则候选多于一个时结果会飘。
+func MatchPlaces(stored []StoredPlace, backup []Location) PlaceMatch {
+	byCoord := make(map[string][]StoredPlace, len(stored))
+	byName := make(map[string][]StoredPlace, len(stored))
 	for _, sp := range stored {
 		if sp.Lat != 0 || sp.Lon != 0 {
-			byCoord[PlaceCoordKey(sp.Lat, sp.Lon)] = sp
+			k := PlaceCoordKey(sp.Lat, sp.Lon)
+			byCoord[k] = append(byCoord[k], sp)
 		}
-		if _, dup := byName[sp.Name]; !dup && sp.Name != "" {
+		if sp.Name != "" {
-			byName[sp.Name] = sp
+			byName[sp.Name] = append(byName[sp.Name], sp)
 		}
 	}
 	used := map[int]bool{}
+	// take 认领第一条还没被用掉的候选，认领即置 used——同一条站内地点不能被两个备份地点配走。
+	take := func(list []StoredPlace) (StoredPlace, bool) {
+		for _, sp := range list {
+			if !used[sp.SrcPK] {
+				used[sp.SrcPK] = true
+				return sp, true
+			}
+		}
+		return StoredPlace{}, false
+	}
+	// takeByName 只在「够近」时认领：两边都有坐标却离得太远，那是两家同名的店，不是同一个地点。
+	// 任一侧没有坐标就没法判距离，按旧行为直接认领。
+	takeByName := func(list []StoredPlace, l Location) (StoredPlace, bool) {
+		for _, sp := range list {
+			if used[sp.SrcPK] {
+				continue
+			}
+			if (sp.Lat != 0 || sp.Lon != 0) && (l.Lat != 0 || l.Lon != 0) {
+				if geo.Haversine(sp.Lat, sp.Lon, l.Lat, l.Lon) > nameMatchMaxKm {
+					continue
+				}
+			}
+			used[sp.SrcPK] = true
+			return sp, true
+		}
+		return StoredPlace{}, false
+	}
+
+	out := make(PlaceMatch, len(backup))
+	for _, l := range backup {
+		if sp, ok := take(byCoord[PlaceCoordKey(l.Lat, l.Lon)]); ok {
+			out[l.SrcPK] = sp
+			continue
+		}
+		if sp, ok := takeByName(byName[l.Name], l); ok {
+			out[l.SrcPK] = sp
+		}
+	}
+	return out
+}
+
+// DiffPlaces 对齐地点。配对规则见 MatchPlaces：配上的比字段，配不上的两边分别是
+// 「备份新增」与「仅站内有」。
+func DiffPlaces(stored []StoredPlace, b *Backup) PlaceDiff {
+	match := MatchPlaces(stored, b.Locations)
+	matched := map[int]bool{}
 	var d PlaceDiff
-	classify := func(sp StoredPlace, l Location) {
+	for _, l := range b.Locations {
-		used[sp.SrcPK] = true
+		sp, ok := match[l.SrcPK]
+		if !ok {
+			d.Added = append(d.Added, l)
+			continue
+		}
+		matched[sp.SrcPK] = true
 		if fields := placeFieldChanges(sp, l); len(fields) > 0 {
 			d.Changed = append(d.Changed, PlaceConflict{Backup: l, DB: sp, Fields: fields})
 		} else {
 			d.Same++
 		}
 	}
-	for _, l := range b.Locations {
-		if sp, ok := byCoord[PlaceCoordKey(l.Lat, l.Lon)]; ok && !used[sp.SrcPK] {
-			classify(sp, l)
-			continue
-		}
-		if sp, ok := byName[l.Name]; ok && !used[sp.SrcPK] {
-			classify(sp, l)
-			continue
-		}
-		d.Added = append(d.Added, l)
-	}
 	for _, sp := range stored {
-		if !used[sp.SrcPK] {
+		if !matched[sp.SrcPK] {
 			d.Removed = append(d.Removed, sp)
 		}
 	}
@@ -278,6 +392,14 @@ func DiffPlaces(stored []StoredPlace, b *Backup) PlaceDiff {
 	return d
 }
 
+// coordSuffix 给「地点」这一项补上坐标键（"lat|lon"）里的人类可读尾巴。
+func coordSuffix(name, key string) string {
+	if key == "" {
+		return name + "（无坐标）"
+	}
+	return name + " (" + strings.Replace(key, "|", ", ", 1) + ")"
+}
+
 // placeFieldChanges 比地点上除对齐键之外的字段。名称也算——按坐标配上之后，
 // 「名字不一样」正是站长最想看到的那类差异。
 func placeFieldChanges(sp StoredPlace, l Location) []FieldChange {
@@ -375,8 +497,6 @@ type Counts struct {
 	Added, Removed, Changed, Same int
 }
 
-func (c Counts) Total() int { return c.Added + c.Removed + c.Changed + c.Same }
-
 func VisitCounts(d VisitDiff) Counts {
 	return Counts{len(d.Added), len(d.Removed), len(d.Changed), d.Same}
 }

internal/rond/diff_test.go

@@ -1,6 +1,7 @@
 package rond
 
 import (
+	"strings"
 	"testing"
 	"time"
 )
@@ -122,6 +123,47 @@ func TestDiffVisitsFallsBackWhenUUIDMissing(t *testing.T) {
 	}
 }
 
+// 站点补录的行（没有留档 UUID）导出过一次之后，包里那条带着的是站点给它补的派生 UUID。
+// 这份包再合并回来时，必须认出「这就是我导出去的那条」——不认就会当成「备份新增」又插一条，
+// 时间线上于是出现两条一模一样的到访（实测数据集 9 有 43 对）。
+func TestDiffVisitsAlignsSiteCreatedRowByDerivedUUID(t *testing.T) {
+	const srcPK = 42
+	b := &Backup{
+		Visits:       []Visit{{SrcPK: 900, Arrival: tp("2026-09-01 10:00"), LocationSrcPK: ip(3)}},
+		Locations:    []Location{{SrcPK: 3, Name: "家", Lat: 24.1, Lon: 109.1}},
+		VisitUUID:    map[int]string{900: DerivedVisitUUID(srcPK)}, // 导出时补给这条的
+		ActivityUUID: map[int]string{},
+	}
+	stored := []StoredVisit{{
+		SrcPK: srcPK, UUID: "", // 站点补录：entity_raw 里没有这一行
+		Arrival: tp("2026-09-01 10:00"), PlaceKey: PlaceCoordKey(24.1, 109.1),
+	}}
+	d := DiffVisits(stored, b)
+	if len(d.Added) != 0 || len(d.Removed) != 0 {
+		t.Fatalf("该认出是同一行（派生 UUID 对上了）: +%d -%d", len(d.Added), len(d.Removed))
+	}
+	if d.Same != 1 {
+		t.Fatalf("应配上 1 条，实际 same=%d changed=%d", d.Same, len(d.Changed))
+	}
+}
+
+// 反例：派生 UUID 是别的编号的，就不该被认领（否则会把两条不同的到访混成一条）。
+func TestDiffVisitsDoesNotAlignOtherDerivedUUID(t *testing.T) {
+	const srcPK = 42
+	b := &Backup{
+		Visits:    []Visit{{SrcPK: 900, Arrival: tp("2026-09-01 10:00"), LocationSrcPK: ip(3)}},
+		Locations: []Location{{SrcPK: 3, Name: "家", Lat: 24.1, Lon: 109.1}},
+		VisitUUID: map[int]string{900: DerivedVisitUUID(srcPK + 1)},
+	}
+	stored := []StoredVisit{{
+		SrcPK: srcPK, Arrival: tp("2026-09-01 10:00"), PlaceKey: PlaceCoordKey(24.1, 109.1),
+	}}
+	d := DiffVisits(stored, b)
+	if len(d.Added) != 1 || len(d.Removed) != 1 {
+		t.Fatalf("派生 UUID 对不上就该分别报出: +%d -%d", len(d.Added), len(d.Removed))
+	}
+}
+
 // 兜底配对要认得出「同一条但时间被改过」——时间不同就配不上，此时按新增 + 仅站内有报出，
 // 总比静默当成同一条好。
 func TestDiffVisitsFallbackNeedsSameTime(t *testing.T) {
@@ -291,3 +333,216 @@ func TestDiffPlacesMatchesByNameWhenCoordMoved(t *testing.T) {
 		t.Fatalf("应报出坐标差异: %+v", d.Changed)
 	}
 }
+
+// 真机一个坐标下会有好几条同名同坐标的地点（实测「柳州站」同一个坐标 3 条，备份里这类分组共 10 组）。
+// 用单槽位 map 时，同一坐标最多只能配上一条，第 3 条永远判「备份新增」→ 每次合并都再插一条
+// 重复地点、差异永远归不了零。
+func TestDiffPlacesAlignsDuplicateNameCoordGroups(t *testing.T) {
+	loc := func(pk int) Location {
+		return Location{SrcPK: pk, Name: "柳州站", Lat: 24.307787, Lon: 109.388309}
+	}
+	sp := func(pk int) StoredPlace {
+		return StoredPlace{SrcPK: pk, Key: PlaceCoordKey(24.307787, 109.388309),
+			Name: "柳州站", Lat: 24.307787, Lon: 109.388309}
+	}
+	b := &Backup{Locations: []Location{loc(41), loc(42), loc(43)}}
+
+	d := DiffPlaces([]StoredPlace{sp(11), sp(12), sp(13)}, b)
+	if len(d.Added) != 0 || len(d.Removed) != 0 || len(d.Changed) != 0 {
+		t.Fatalf("两边各 3 条同名同坐标应一一配上: +%d -%d ~%d", len(d.Added), len(d.Removed), len(d.Changed))
+	}
+	if d.Same != 3 {
+		t.Fatalf("应配上 3 条，实际 %d", d.Same)
+	}
+
+	// 反过来：站内真的少两条时，仍要老老实实报出「备份新增 2」——
+	// 多值配对不能变成「只要有同名同坐标就一律不算新增」。
+	d = DiffPlaces([]StoredPlace{sp(11)}, b)
+	if len(d.Added) != 2 || len(d.Removed) != 0 || d.Same != 1 {
+		t.Fatalf("站内只有 1 条时应报新增 2: +%d -%d same=%d", len(d.Added), len(d.Removed), d.Same)
+	}
+}
+
+// 活动改了名（UUID 还在）：那是活动层的差异，不该在挂着它的每条到访上重复报一遍。
+// 实测真机 16 个活动改名会把 355 条到访全变成假冲突，而且逐条选「用实机」也改不掉活动名。
+func TestDiffVisitsIgnoresActivityRename(t *testing.T) {
+	b := &Backup{
+		Visits:       []Visit{{SrcPK: 5, Arrival: tp("2026-09-01 10:00"), ActivitySrcPK: ip(7)}},
+		Activities:   []Activity{{SrcPK: 7, Name: "吃饭"}},
+		VisitUUID:    map[int]string{5: uuidA},
+		ActivityUUID: map[int]string{7: uuidC},
+	}
+	stored := []StoredVisit{{
+		SrcPK: 1, UUID: uuidA, Arrival: tp("2026-09-01 10:00"),
+		ActivityName: "餐厅", ActivityUUID: uuidC,
+	}}
+	d := DiffVisits(stored, b)
+	if len(d.Changed) != 0 {
+		t.Fatalf("同一个活动改名不该算到访冲突: %+v", d.Changed[0].Fields)
+	}
+	if d.Same != 1 {
+		t.Fatalf("应算作一致，实际 same=%d", d.Same)
+	}
+}
+
+// 换成了另一个活动才是真差异。
+func TestDiffVisitsReportsActivityChange(t *testing.T) {
+	b := &Backup{
+		Visits:       []Visit{{SrcPK: 5, Arrival: tp("2026-09-01 10:00"), ActivitySrcPK: ip(7)}},
+		Activities:   []Activity{{SrcPK: 7, Name: "吃饭"}, {SrcPK: 8, Name: "散步"}},
+		VisitUUID:    map[int]string{5: uuidA},
+		ActivityUUID: map[int]string{7: uuidC, 8: uuidB},
+	}
+	stored := []StoredVisit{{
+		SrcPK: 1, UUID: uuidA, Arrival: tp("2026-09-01 10:00"),
+		ActivityName: "散步", ActivityUUID: uuidB,
+	}}
+	d := DiffVisits(stored, b)
+	if len(d.Changed) != 1 {
+		t.Fatalf("换了活动该报冲突，实际 %d 条", len(d.Changed))
+	}
+	f := d.Changed[0].Fields
+	if len(f) != 1 || f[0].Label != "活动" || f[0].From != "散步" || f[0].To != "吃饭" {
+		t.Fatalf("活动差异不对: %+v", f)
+	}
+}
+
+// 站点自建的活动没有 UUID，退不回身份就按名称比（老数据要保持原样）。
+func TestDiffVisitsActivityWithoutUUIDFallsBackToName(t *testing.T) {
+	b := &Backup{
+		Visits:       []Visit{{SrcPK: 5, Arrival: tp("2026-09-01 10:00"), ActivitySrcPK: ip(7)}},
+		Activities:   []Activity{{SrcPK: 7, Name: "吃饭"}},
+		VisitUUID:    map[int]string{5: uuidA},
+		ActivityUUID: map[int]string{7: uuidC},
+	}
+	// 名称一致 → 不报
+	same := []StoredVisit{{
+		SrcPK: 1, UUID: uuidA, Arrival: tp("2026-09-01 10:00"), ActivityName: "吃饭",
+	}}
+	if d := DiffVisits(same, b); len(d.Changed) != 0 {
+		t.Fatalf("名称相同时不该报冲突: %+v", d.Changed[0].Fields)
+	}
+	// 名称不同 → 报
+	diff := []StoredVisit{{
+		SrcPK: 1, UUID: uuidA, Arrival: tp("2026-09-01 10:00"), ActivityName: "散步",
+	}}
+	d := DiffVisits(diff, b)
+	if len(d.Changed) != 1 || d.Changed[0].Fields[0].Label != "活动" {
+		t.Fatalf("没有 UUID 时应退回按名称比: %+v", d.Changed)
+	}
+}
+
+// 名称兜底配对必须有距离上限：连锁店同名（中国体育彩票、茶颜悦色…）时，坐标配不上的
+// 两条相隔几百公里的同名地点绝不能配成一对——一勾「用实机」就把站内那条搬到另一座城市。
+// 实测踩过：佛山的「中国体育彩票」(22.927572,113.222052) 被配给贺州那条
+// (24.408376,111.554626)（直线 236.8km），合并后站内地点从贺州搬到了佛山。
+func TestDiffPlacesNameFallbackNeedsNearby(t *testing.T) {
+	b := &Backup{Locations: []Location{
+		{SrcPK: 41, Name: "中国体育彩票", Lat: 24.408376, Lon: 111.554626, City: "贺州市"},
+	}}
+	stored := []StoredPlace{
+		{SrcPK: 11, Key: PlaceCoordKey(22.927572, 113.222052), Name: "中国体育彩票",
+			Lat: 22.927572, Lon: 113.222052, City: "佛山市"},
+	}
+	d := DiffPlaces(stored, b)
+	if len(d.Changed) != 0 {
+		t.Fatalf("相隔 236.8km 的同名地点不该被配对: %+v", d.Changed[0].Fields)
+	}
+	if len(d.Added) != 1 || len(d.Removed) != 1 {
+		t.Fatalf("应报成「备份新增 + 仅站内有」: +%d -%d", len(d.Added), len(d.Removed))
+	}
+}
+
+// 但坐标纠偏那种（同一地点，两边差几百米）仍要配上——名称兜底本来就是为它准备的。
+func TestDiffPlacesNameFallbackKeepsNearbyCoordFix(t *testing.T) {
+	b := &Backup{Locations: []Location{
+		{SrcPK: 41, Name: "茶颜悦色", Lat: 28.181954, Lon: 112.986995},
+	}}
+	stored := []StoredPlace{
+		{SrcPK: 11, Key: PlaceCoordKey(28.185360, 112.981422), Name: "茶颜悦色",
+			Lat: 28.185360, Lon: 112.981422},
+	}
+	d := DiffPlaces(stored, b)
+	if len(d.Added) != 0 || len(d.Removed) != 0 {
+		t.Fatalf("相距 665m 的同名地点应配上: +%d -%d", len(d.Added), len(d.Removed))
+	}
+	if len(d.Changed) != 1 || d.Changed[0].Fields[0].Label != "纬度" {
+		t.Fatalf("应报出坐标差异: %+v", d.Changed)
+	}
+}
+
+// 多条同名备份地点必须**一条配一条**（各配最近的那条），不能全并到同一条站内地点上：
+// 合并执行（mergePlaces）沿用的就是这份配对，并错了到访就会挂到错的分店
+// （实测「茶颜悦色」两家分店相隔 8.3km，到访却指向同一条）。
+func TestMatchPlacesKeepsDuplicateNameGroupsDistinct(t *testing.T) {
+	mk := func(pk int, lat, lon float64) StoredPlace {
+		sp := StoredPlace{SrcPK: pk, Name: "茶颜悦色", Lat: lat, Lon: lon}
+		sp.Key = PlaceCoordKey(lat, lon)
+		return sp
+	}
+	stored := []StoredPlace{
+		mk(11, 28.185360, 112.981422), // 与备份 #41 相距约 665m
+		mk(12, 28.245842, 113.031303), // 与备份 #42 相距约 670m
+	}
+	backup := []Location{
+		{SrcPK: 41, Name: "茶颜悦色", Lat: 28.181954, Lon: 112.986995},
+		{SrcPK: 42, Name: "茶颜悦色", Lat: 28.242581, Lon: 113.037061},
+	}
+	m := MatchPlaces(stored, backup)
+	if len(m) != 2 {
+		t.Fatalf("两条都该配上，实际 %d", len(m))
+	}
+	if m[41].SrcPK == m[42].SrcPK {
+		t.Fatalf("两条同名备份地点被并到了同一条站内地点上: 41→%d 42→%d", m[41].SrcPK, m[42].SrcPK)
+	}
+	if m[41].SrcPK != 11 || m[42].SrcPK != 12 {
+		t.Fatalf("应各配最近的一条（41→11、42→12），实际 41→%d 42→%d", m[41].SrcPK, m[42].SrcPK)
+	}
+
+	// 两家分店挨得近（都在 1km 内）时也要一条配一条：坐标键对不上、只能靠名称兜底，
+	// 若认领了却不标记已用，两条会双双落到第一条上。
+	near := []StoredPlace{mk(21, 1.000000, 1.000000), mk(22, 1.005000, 1.005000)}
+	closeBy := []Location{
+		{SrcPK: 51, Name: "茶颜悦色", Lat: 1.002400, Lon: 1.002400},
+		{SrcPK: 52, Name: "茶颜悦色", Lat: 1.002600, Lon: 1.002600},
+	}
+	m2 := MatchPlaces(near, closeBy)
+	if len(m2) != 2 {
+		t.Fatalf("两条都该配上，实际 %d", len(m2))
+	}
+	if m2[51].SrcPK == m2[52].SrcPK {
+		t.Fatalf("两条同名备份地点被并到了同一条站内地点上: 51→%d 52→%d", m2[51].SrcPK, m2[52].SrcPK)
+	}
+}
+
+// 「地点」这一项比的是坐标，只印名称时同名不同坐标会渲染成「X → X」，站长看不出差在哪。
+// 名称一样就必须把坐标带出来。
+func TestDiffVisitsPlaceConflictShowsCoords(t *testing.T) {
+	b := &Backup{
+		Visits:    []Visit{{SrcPK: 5, Arrival: tp("2026-09-01 10:00"), LocationSrcPK: ip(3)}},
+		Locations: []Location{{SrcPK: 3, Name: "长沙南站", Lat: 28.141772, Lon: 113.067569}},
+		VisitUUID: map[int]string{5: uuidA},
+	}
+	stored := []StoredVisit{{
+		SrcPK: 1, UUID: uuidA, Arrival: tp("2026-09-01 10:00"),
+		PlaceName: "长沙南站", PlaceKey: PlaceCoordKey(28.146535, 113.062164),
+	}}
+	d := DiffVisits(stored, b)
+	if len(d.Changed) != 1 {
+		t.Fatalf("坐标不同应算冲突，实际 %d 条", len(d.Changed))
+	}
+	f := d.Changed[0].Fields
+	if len(f) != 1 || f[0].Label != "地点" {
+		t.Fatalf("应只报一项地点差异: %+v", f)
+	}
+	for _, want := range []string{"长沙南站", "28.146535", "113.062164"} {
+		if !strings.Contains(f[0].From, want) {
+			t.Fatalf("站内那侧 %q 应含 %q（否则这一行看着像没变化）", f[0].From, want)
+		}
+	}
+	for _, want := range []string{"长沙南站", "28.141772", "113.067569"} {
+		if !strings.Contains(f[0].To, want) {
+			t.Fatalf("备份那侧 %q 应含 %q", f[0].To, want)
+		}
+	}
+}

internal/rond/dirty_test.go

@@ -0,0 +1,203 @@
+package rond
+
+import (
+	"database/sql"
+	"math"
+	"os"
+	"path/filepath"
+	"runtime"
+	"strings"
+	"testing"
+	"time"
+)
+
+func nullF(v float64) sql.NullFloat64 { return sql.NullFloat64{Float64: v, Valid: true} }
+
+// 脏值必须判成「装不下」（nil）。旧实现直接 int64(sec)，超范围是回绕不是饱和：
+// 实测 NaN/±Inf/1e30 恰好回绕到基准点（2001-01-01）、1e12 落到 2123 年。
+func TestAppleTimeRejectsDirtyValues(t *testing.T) {
+	dirty := map[string]float64{
+		"NaN":   math.NaN(),
+		"+Inf":  math.Inf(1),
+		"-Inf":  math.Inf(-1),
+		"1e30":  1e30,
+		"-1e30": -1e30,
+		"1e12":  1e12, // 会落到 2123 年
+		"-1e12": -1e12,
+		"早于窗口":  appleMinSec - 86400,
+		"晚于窗口":  appleMaxSec + 86400,
+	}
+	for name, v := range dirty {
+		if tm := appleTime(nullF(v)); tm != nil {
+			t.Errorf("%s 应当被拒（nil），实际得到 %s", name, tm.Format(time.RFC3339Nano))
+		}
+	}
+	if appleTime(sql.NullFloat64{}) != nil {
+		t.Error("NULL 应当返回 nil")
+	}
+}
+
+// 合法值要原样保留，尤其是微秒精度——整数/小数分开算就是为了它。
+func TestAppleTimeKeepsLegitValues(t *testing.T) {
+	for _, want := range []time.Time{
+		time.Date(1995, 7, 1, 12, 30, 45, 123456000, time.UTC),
+		time.Date(2018, 3, 9, 21, 4, 5, 987654000, time.UTC),
+		time.Date(2026, 9, 21, 10, 19, 9, 1000, time.UTC),
+	} {
+		got := appleTime(nullF(want.Sub(appleEpoch).Seconds()))
+		if got == nil {
+			t.Fatalf("%s 被误拒", want.Format(time.RFC3339Nano))
+		}
+		if !got.Equal(want) {
+			t.Errorf("时间失真: 期望 %s 得到 %s", want.Format(time.RFC3339Nano), got.Format(time.RFC3339Nano))
+		}
+	}
+	for _, edge := range []float64{appleMinSec, appleMaxSec} {
+		if appleTime(nullF(edge)) == nil {
+			t.Errorf("窗口边界 %.0f 不该被拒", edge)
+		}
+	}
+}
+
+func TestValidCoord(t *testing.T) {
+	for _, c := range [][2]float64{
+		{math.NaN(), 0}, {0, math.NaN()}, {math.Inf(1), 0}, {0, math.Inf(-1)},
+		{91, 0}, {-91, 0}, {0, 181}, {0, -181}, {999, 999},
+	} {
+		if validCoord(c[0], c[1]) {
+			t.Errorf("无效坐标 (%v,%v) 被判成可用", c[0], c[1])
+		}
+	}
+	for _, c := range [][2]float64{{0, 0}, {24.1, 109.1}, {90, 180}, {-90, -180}, {39.9042, 116.4074}} {
+		if !validCoord(c[0], c[1]) {
+			t.Errorf("合法坐标 (%v,%v) 被误拒", c[0], c[1])
+		}
+	}
+}
+
+// 函数再对，没接上去也白搭：读 ZLOCATION 的循环必须过一遍 validCoord。
+func TestParseSanitizesLocationCoords(t *testing.T) {
+	_, self, _, ok := runtime.Caller(0)
+	if !ok {
+		t.Fatal("拿不到测试文件路径")
+	}
+	src, err := os.ReadFile(filepath.Join(filepath.Dir(self), "parse.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	text := string(src)
+	i := strings.Index(text, "FROM ZLOCATION")
+	if i < 0 {
+		t.Fatal("parse.go 里找不到 ZLOCATION 查询")
+	}
+	j := strings.Index(text[i:], "b.Locations = append")
+	if j < 0 {
+		t.Fatal("找不到了 ZLOCATION 循环的收尾")
+	}
+	if !strings.Contains(text[i:i+j], "validCoord(") {
+		t.Error("读 ZLOCATION 的循环没有调用 validCoord 归一化坐标")
+	}
+}
+
+// 端到端：脏备份走一遍真实的 Parse，不许把伪时间／越界坐标带进领域模型。
+func TestParseRejectsDirtyTimeAndCoords(t *testing.T) {
+	good := time.Date(2026, 9, 20, 8, 0, 0, 0, time.UTC)
+	goodSec := good.Sub(appleEpoch).Seconds()
+
+	path := filepath.Join(t.TempDir(), "Backup.sqlite")
+	sdb, err := sql.Open("sqlite", "file:"+filepath.ToSlash(path))
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer sdb.Close()
+	for _, stmt := range []string{
+		`CREATE TABLE ZTAGGROUP (Z_PK INTEGER PRIMARY KEY, ZNAME_ TEXT)`,
+		`CREATE TABLE ZTAG (Z_PK INTEGER PRIMARY KEY, ZNAME_ TEXT, ZCOLOR_ TEXT, ZGROUP INTEGER)`,
+		`CREATE TABLE ZACTIVITY (Z_PK INTEGER PRIMARY KEY, ZNAME_ TEXT, ZCOLOR_ TEXT, ZICON_ TEXT,
+			ZISHOME INTEGER, ZISWORK INTEGER, ZISEXCLUDED INTEGER, ZISARCHIVED INTEGER, ZUID_ BLOB)`,
+		`CREATE TABLE ZTRANSPORT (Z_PK INTEGER PRIMARY KEY, ZNAME_ TEXT, ZCOLOR_ TEXT, ZICON_ TEXT)`,
+		`CREATE TABLE ZLOCATION (Z_PK INTEGER PRIMARY KEY, ZNAME_ TEXT, ZCATEGORY_ TEXT,
+			ZLATITUDE REAL, ZLONGITUDE REAL, ZISOCOUNTRYCODE TEXT, ZADMINISTRATIVEAREA TEXT,
+			ZLOCALITY TEXT, ZSUBLOCALITY TEXT, ZTHOROUGHFARE TEXT, ZSUBTHOROUGHFARE TEXT, ZTIMEZONE TEXT)`,
+		`CREATE TABLE ZVISIT (Z_PK INTEGER PRIMARY KEY, ZLOCATION INTEGER, ZACTIVITY_ INTEGER,
+			ZARRIVALDATE_ REAL, ZDEPARTUREDATE_ REAL, ZBOOKMARKED INTEGER, ZUSERADDED INTEGER,
+			ZREMARK_ TEXT, ZEMOJINAME_ TEXT, ZWEATHERSYMBOL_ TEXT, ZIDENTIFIER_ BLOB)`,
+		`CREATE TABLE Z_11VISITS_ (Z_18VISITS_ INTEGER, Z_11TAGS_5 INTEGER)`,
+		`CREATE TABLE ZMOVEMENT (Z_PK INTEGER PRIMARY KEY, ZTRANSPORT_ INTEGER, ZVISITFROM_ INTEGER,
+			ZVISITTO_ INTEGER, ZSTART_ REAL, ZEND_ REAL)`,
+		`CREATE TABLE ZHOURLYWEATHER (Z_PK INTEGER PRIMARY KEY, ZVISIT INTEGER, ZDATE_ REAL,
+			ZISDAYLIGHT INTEGER, ZTEMPERATURE_ REAL, ZAPPARENTTEMPERATURE_ REAL, ZHUMIDITY_ REAL,
+			ZPRECIPITATIONAMOUNT_ REAL, ZPRECIPITATIONCHANCE_ REAL, ZWINDSPEED_ REAL, ZVISIBILITY_ REAL,
+			ZUVINDEXVALUE_ INTEGER, ZCONDITION_ TEXT, ZSYMBOLNAME_ TEXT, ZUVINDEXCATEGORY_ TEXT,
+			ZWINDCOMPASSDIRECTION_ TEXT)`,
+	} {
+		if _, err := sdb.Exec(stmt); err != nil {
+			t.Fatalf("建表失败: %v", err)
+		}
+	}
+
+	exec := func(q string, args ...any) {
+		t.Helper()
+		if _, err := sdb.Exec(q, args...); err != nil {
+			t.Fatalf("插入失败: %v", err)
+		}
+	}
+	exec(`INSERT INTO ZACTIVITY (Z_PK, ZNAME_, ZCOLOR_, ZICON_, ZISHOME, ZISWORK, ZISEXCLUDED, ZISARCHIVED)
+		VALUES (1,'通勤','#fff','🚇',0,0,0,0)`)
+	// 1=正常；2=坐标越界；3=坐标量级离谱（模拟 NaN 入库前的形态）
+	exec(`INSERT INTO ZLOCATION (Z_PK, ZNAME_, ZLATITUDE, ZLONGITUDE) VALUES (1,'正常',24.1,109.1)`)
+	exec(`INSERT INTO ZLOCATION (Z_PK, ZNAME_, ZLATITUDE, ZLONGITUDE) VALUES (2,'越界',999,-999)`)
+	exec(`INSERT INTO ZLOCATION (Z_PK, ZNAME_, ZLATITUDE, ZLONGITUDE) VALUES (3,'离谱',1e30,0)`)
+	// 1=正常时间；2=ZARRIVALDATE_ 落到 2123 年；3=量级离谱（旧实现回绕成 2001）
+	exec(`INSERT INTO ZVISIT (Z_PK, ZLOCATION, ZACTIVITY_, ZARRIVALDATE_, ZDEPARTUREDATE_)
+		VALUES (1,1,1,?,?)`, goodSec, goodSec+3600)
+	exec(`INSERT INTO ZVISIT (Z_PK, ZLOCATION, ZACTIVITY_, ZARRIVALDATE_) VALUES (2,2,1,1e12)`)
+	exec(`INSERT INTO ZVISIT (Z_PK, ZLOCATION, ZACTIVITY_, ZARRIVALDATE_) VALUES (3,3,1,-1e30)`)
+	// 位移：时间坏了保留「有行、无时间」，不能写成伪时间
+	exec(`INSERT INTO ZMOVEMENT (Z_PK, ZTRANSPORT_, ZVISITFROM_, ZVISITTO_, ZSTART_, ZEND_)
+		VALUES (1,1,1,1,?,?)`, goodSec, goodSec+600)
+	exec(`INSERT INTO ZMOVEMENT (Z_PK, ZTRANSPORT_, ZVISITFROM_, ZVISITTO_, ZSTART_, ZEND_)
+		VALUES (2,1,1,1,1e12,1e12)`)
+
+	b, err := Parse(sdb)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	byLoc := map[int]Location{}
+	for _, l := range b.Locations {
+		byLoc[l.SrcPK] = l
+	}
+	if got := byLoc[1]; got.Lat != 24.1 || got.Lon != 109.1 {
+		t.Errorf("正常坐标被改动了: (%v,%v)", got.Lat, got.Lon)
+	}
+	if got := byLoc[2]; got.Lat != 0 || got.Lon != 0 {
+		t.Errorf("越界坐标应归零，实际 (%v,%v)", got.Lat, got.Lon)
+	}
+	if got := byLoc[3]; got.Lat != 0 || got.Lon != 0 {
+		t.Errorf("量级离谱的坐标应归零，实际 (%v,%v)", got.Lat, got.Lon)
+	}
+
+	byVisit := map[int]Visit{}
+	for _, v := range b.Visits {
+		byVisit[v.SrcPK] = v
+	}
+	if v := byVisit[1]; v.Arrival == nil || !v.Arrival.Equal(good) {
+		t.Errorf("正常到访时间丢了: %v", v.Arrival)
+	}
+	for _, pk := range []int{2, 3} {
+		if v := byVisit[pk]; v.Arrival != nil {
+			t.Errorf("到访 #%d 的脏时间应当被拒，实际 %s", pk, v.Arrival.Format(time.RFC3339))
+		}
+	}
+
+	if len(b.Movements) != 2 {
+		t.Fatalf("位移条数不对: %d", len(b.Movements))
+	}
+	if m := b.Movements[0]; m.Start == nil || !m.Start.Equal(good) {
+		t.Errorf("正常位移时间丢了: %v", m.Start)
+	}
+	if m := b.Movements[1]; m.Start != nil || m.End != nil {
+		t.Errorf("脏位移时间应当为空而不是伪时间: start=%v end=%v", m.Start, m.End)
+	}
+}

internal/rond/export.go

@@ -8,10 +8,12 @@ import (
 	"encoding/base64"
 	"encoding/json"
 	"fmt"
+	"hash/crc32"
 	"io"
 	"math"
 	"os"
 	"path/filepath"
+	"sort"
 	"strings"
 	"time"
 
@@ -37,7 +39,8 @@ var managedCols = map[string][]string{
 	"ZTAG":       {"ZNAME_", "ZCOLOR_", "ZGROUP", "ZLASTARRIVALDATE_"},
 	"ZTRANSPORT": {"ZNAME_", "ZCOLOR_", "ZICON_"},
 	"ZVISIT": {"ZLOCATION", "ZACTIVITY_", "ZARRIVALDATE_", "ZDEPARTUREDATE_",
-		"ZBOOKMARKED", "ZUSERADDED", "ZREMARK_", "ZEMOJINAME_", "ZWEATHERSYMBOL_", "ZIDENTIFIER_"},
+		"ZBOOKMARKED", "ZUSERADDED", "ZREMARK_", "ZEMOJINAME_", "ZWEATHERSYMBOL_", "ZIDENTIFIER_",
+		"ZMERGEDTO", "ZPARENT"},
 	"ZMOVEMENT": {"ZTRANSPORT_", "ZVISITFROM_", "ZVISITTO_", "ZSTART_", "ZEND_", "ZTYPE_"},
 	"ZHOURLYWEATHER": {"ZVISIT", "ZDATE_", "ZISDAYLIGHT", "ZTEMPERATURE_", "ZAPPARENTTEMPERATURE_", "ZHUMIDITY_",
 		"ZPRECIPITATIONAMOUNT_", "ZPRECIPITATIONCHANCE_", "ZWINDSPEED_", "ZVISIBILITY_", "ZUVINDEXVALUE_",
@@ -86,6 +89,14 @@ var keepNilCols = map[string][]string{
 	"ZTRANSPORT": {"ZNAME_", "ZCOLOR_", "ZICON_"},
 }
 
+// 新建行没选颜色/图标时的占位值。真机这几列从来不空（NULL 和空串都没有），写 NULL 是
+// 它没见过的形状；颜色取 rond 系统色名，图标取一个必定存在的 SF Symbol。
+const (
+	transportPlaceholderColor = "gray"
+	transportPlaceholderIcon  = "circle.fill"
+	activityPlaceholderColor  = "gray"
+)
+
 // movementTypeDefault 给站点新建的位移补 ZTYPE_：真机里这条规律覆盖 757/791 行
 // （有交通方式→5、没有→2），剩下的是用户在 app 里手改过的不规则取值。
 func movementTypeDefault(transportSet bool) int {
@@ -231,7 +242,13 @@ func patchSQLite(ctx context.Context, db *sql.DB, datasetID int64, sqlitePath st
 		return err
 	}
 	loc := w("ZLOCATION", "Location")
+	// 编号对齐（见 export_align.go）：把站点编号映射到基线的编号空间
+	placeAlign, err := alignPlaces(ctx, tx, places)
+	if err != nil {
+		return fmt.Errorf("对齐地点编号: %w", err)
+	}
 	for _, p := range places {
+		outPK := placeAlign[p.SrcPK]
 		placeSrcByID[int64(p.ID)] = p.SrcPK
 		raw := raws["ZLOCATION"][p.SrcPK]
 		// 地点详情的「最近活跃时间」= 该地点最晚一次到访的到达时间，没有到访就不写
@@ -243,10 +260,13 @@ func patchSQLite(ctx context.Context, db *sql.DB, datasetID int64, sqlitePath st
 		// 有留档就用真机那份（它才是真正的原始定位，哪怕用户后来挪过点）；
 		// 站点新建的地点没有留档，用显示坐标反算一个，否则这列会空着。
 		var rawLat, rawLon any
-		if p.Lat.Valid && p.Lon.Valid && !known["ZLOCATION"][p.SrcPK] {
+		if p.Lat.Valid && p.Lon.Valid && !known["ZLOCATION"][outPK] {
 			rawLat, rawLon = geo.GCJ02ToWGS84(p.Lat.Float64, p.Lon.Float64)
 		}
-		if err := loc.write(p.SrcPK, []any{ns(p.Name), ns(p.Category), nf(p.Lat), nf(p.Lon),
+		// 国家码写成 NULL，**不要**补空串：2026-09-29 实测——只把这一列从 NULL 改成 ''
+		// 就让真机从「能导入」变成「备份恢复失败」（同一份包、同一台设备，唯一差异就是这列）。
+		// 站点新建的地点这一项本来就是 NULL，保持原样最安全。
+		if err := loc.write(outPK, []any{ns(p.Name), ns(p.Category), nf(p.Lat), nf(p.Lon),
 			ns(p.Country), ns(p.Province), ns(p.City), ns(p.Sublocality), ns(p.Thoroughfare), ns(p.Timezone),
 			lastArrival, rawLat, rawLon},
 			raw); err != nil {
@@ -264,7 +284,7 @@ func patchSQLite(ctx context.Context, db *sql.DB, datasetID int64, sqlitePath st
 		var pks []any
 		for _, p := range places {
 			if p.CoordSource.Valid && p.CoordSource.String == "photo" {
-				pks = append(pks, p.SrcPK)
+				pks = append(pks, placeAlign[p.SrcPK])
 			}
 		}
 		for len(pks) > 0 {
@@ -293,7 +313,12 @@ func patchSQLite(ctx context.Context, db *sql.DB, datasetID int64, sqlitePath st
 		return err
 	}
 	act := w("ZACTIVITY", "Activity")
+	actAlign, err := alignUUIDs(ctx, db, tx, datasetID, "ZACTIVITY", "ZUID_", actsPKs(activities))
+	if err != nil {
+		return fmt.Errorf("对齐活动编号: %w", err)
+	}
 	for _, a := range activities {
+		outPK := actAlign[a.SrcPK]
 		actSrcByID[int64(a.ID)] = a.SrcPK
 		raw := raws["ZACTIVITY"][a.SrcPK]
 		// 站点没有图标入口，新建的活动在 rond 里会是空图标；站点自己渲染时缺省用 📍
@@ -301,14 +326,21 @@ func patchSQLite(ctx context.Context, db *sql.DB, datasetID int64, sqlitePath st
 		if icon == nil {
 			icon = "📍"
 		}
+		// 颜色同样要兜底：ns() 把空串也当空，而「地点补全」新建的活动 color 就是空串
+		// （见 fillup.go），不兜底这里会写出 ZCOLOR_=NULL。真机这列从来不空——2026-09-29
+		// 生产导出就是因为这一格被 rond 判成损坏数据，提示「备份恢复失败，你的当前数据未被更改」。
+		color := ns(a.Color)
+		if color == nil {
+			color = activityPlaceholderColor
+		}
 		// 活动列表里的「最近活跃时间」：同 ZLOCATION，取该活动最晚一次到访
 		var last any
 		if t, ok := actLast[int64(a.ID)]; ok {
 			last = appleSeconds(t)
 		}
-		if err := act.write(a.SrcPK, []any{ns(a.Name), ns(a.Color), icon,
+		if err := act.write(outPK, []any{ns(a.Name), color, icon,
 			bint(a.Home), bint(a.Work), bint(a.Excluded), bint(a.Archived), last,
-			coreDataUUID(!known["ZACTIVITY"][a.SrcPK], "ZACTIVITY", a.SrcPK)},
+			coreDataUUID(!known["ZACTIVITY"][outPK], "ZACTIVITY", a.SrcPK)},
 			raw); err != nil {
 			return fmt.Errorf("写入活动类型失败: %w", err)
 		}
@@ -365,6 +397,10 @@ func patchSQLite(ctx context.Context, db *sql.DB, datasetID int64, sqlitePath st
 		return err
 	}
 	tag := w("ZTAG", "Tag")
+	tagAlign, err := alignTags(ctx, tx, tags)
+	if err != nil {
+		return fmt.Errorf("对齐标签编号: %w", err)
+	}
 	tagLast, err := queryTagMaxArrival(ctx, db, datasetID)
 	if err != nil {
 		return err
@@ -382,7 +418,7 @@ func patchSQLite(ctx context.Context, db *sql.DB, datasetID int64, sqlitePath st
 		if tm, ok := tagLast[int64(t.SrcPK)]; ok {
 			last = appleSeconds(tm)
 		}
-		if err := tag.write(t.SrcPK, []any{ns(t.Name), ns(t.Color), grp, last},
+		if err := tag.write(tagAlign[t.SrcPK], []any{ns(t.Name), ns(t.Color), grp, last},
 			raws["ZTAG"][t.SrcPK]); err != nil {
 			return fmt.Errorf("写入标签失败: %w", err)
 		}
@@ -392,15 +428,36 @@ func patchSQLite(ctx context.Context, db *sql.DB, datasetID int64, sqlitePath st
 	}
 
 	// 6) 交通方式 ZTRANSPORT（从位移里聚合而来）
-	transports, err := queryTransports(ctx, db, datasetID)
+	transports, transByNameSite, err := queryTransports(ctx, db, datasetID, maxPKOf(known["ZTRANSPORT"], nil)+1)
 	if err != nil {
 		return err
 	}
 	tr := w("ZTRANSPORT", "Transport")
 	// 没有任何行程引用的方式保持基线原样，不当成「已删除」
 	tr.keepMissing = true
+	transAlign, err := alignTransports(ctx, tx, transports)
+	if err != nil {
+		return fmt.Errorf("对齐交通方式编号: %w", err)
+	}
 	for _, t := range transports {
-		if err := tr.write(t.SrcPK, []any{ns(t.Name), ns(t.Color), ns(t.Icon)}, raws["ZTRANSPORT"][t.SrcPK]); err != nil {
+		name, color, icon := ns(t.Name), ns(t.Color), ns(t.Icon)
+		// 真机这三列从来没出现过空值（NULL 和空串都没有），而站点不单独维护交通方式表、
+		// 颜色/图标是从位移上聚合的，用户建方式时没选就是空。**新建的行**必须补占位，
+		// 否则会把 NULL 写进包里——rond 拿到的是它自己从来不会产生的形状
+		// （2026-09-20：新建的「步行」就是这样导出的，与新建活动补 blue/📍 同一套做法）。
+		// 基线里已有的行不碰：那种情况交给 keepNilCols 保留真机原值。
+		if !known["ZTRANSPORT"][transAlign[t.SrcPK]] {
+			if name == nil {
+				name = "未命名"
+			}
+			if color == nil {
+				color = transportPlaceholderColor
+			}
+			if icon == nil {
+				icon = transportPlaceholderIcon
+			}
+		}
+		if err := tr.write(transAlign[t.SrcPK], []any{name, color, icon}, raws["ZTRANSPORT"][t.SrcPK]); err != nil {
 			return fmt.Errorf("写入交通方式失败: %w", err)
 		}
 	}
@@ -414,21 +471,30 @@ func patchSQLite(ctx context.Context, db *sql.DB, datasetID int64, sqlitePath st
 		return err
 	}
 	visit := w("ZVISIT", "Visit")
+	visitAlign, err := alignUUIDs(ctx, db, tx, datasetID, "ZVISIT", "ZIDENTIFIER_", visitsPKs(visits))
+	if err != nil {
+		return fmt.Errorf("对齐到访编号: %w", err)
+	}
 	for _, v := range visits {
+		outPK := visitAlign[v.SrcPK]
 		var locPK, actPK any
 		if v.PlaceID.Valid {
 			if sp, ok := placeSrcByID[v.PlaceID.Int64]; ok {
-				locPK = sp
+				locPK = placeAlign[sp]
 			}
 		}
 		if v.ActivityID.Valid {
 			if sp, ok := actSrcByID[v.ActivityID.Int64]; ok {
-				actPK = sp
+				actPK = actAlign[sp]
 			}
 		}
-		if err := visit.write(v.SrcPK, []any{locPK, actPK, appleSeconds(v.Arrival), nt(v.Departure),
+		// ZMERGEDTO / ZPARENT 是自引用：留档里存的是站点编号，对齐后必须跟着改挂，
+		// 否则会指到别的到访、甚至不存在的行。
+		mergedTo := alignedVisitRef(raws["ZVISIT"][v.SrcPK], "ZMERGEDTO", visitAlign)
+		parent := alignedVisitRef(raws["ZVISIT"][v.SrcPK], "ZPARENT", visitAlign)
+		if err := visit.write(outPK, []any{locPK, actPK, appleSeconds(v.Arrival), nt(v.Departure),
 			bint(v.Bookmarked), bint(v.UserAdded), ns(v.Remark), ns(v.Emoji), ns(v.WeatherSymbol),
-			coreDataUUID(!known["ZVISIT"][v.SrcPK], "ZVISIT", v.SrcPK)},
+			coreDataUUID(!known["ZVISIT"][outPK], "ZVISIT", v.SrcPK), mergedTo, parent},
 			raws["ZVISIT"][v.SrcPK]); err != nil {
 			return fmt.Errorf("写入访问记录失败: %w", err)
 		}
@@ -436,6 +502,25 @@ func patchSQLite(ctx context.Context, db *sql.DB, datasetID int64, sqlitePath st
 	if err := visit.finish(); err != nil {
 		return err
 	}
+	// 站点删掉到访之后，它的原始采样点会失去目标。ZRAWVISIT 是不托管实体（原样保留），
+	// 而 Core Data 的关系由它自己维护、SQLite 里没有外键约束，所以这种悬空引用不会报错，
+	// 但它是**真机自己绝不会产生的形状**——真机删到访时采样点跟着级联删。
+	// 留着还有副作用：app 会把「没归并的采样点」重新推成一条到访，删掉的记录又回来了。
+	if _, err := tx.ExecContext(ctx, `DELETE FROM ZRAWVISIT WHERE ZVISIT IS NOT NULL
+		AND NOT EXISTS (SELECT 1 FROM ZVISIT v WHERE v.Z_PK = ZRAWVISIT.ZVISIT)`); err != nil {
+		return fmt.Errorf("清理失去目标的原始采样点失败: %w", err)
+	}
+
+	// ZVISIT.ZRAW 是「这次到访由多少个原始采样点归并而来」的计数，而采样点表 ZRAWVISIT 是
+	// **不托管实体**（原样从基线带过来）。合并进来的到访带着源包的计数，可源包里的那些采样行
+	// 站点没留下 ⇒ 计数会超过包里实际有的采样行数。2026-09-30 实测：真机会因此**整包拒收**
+	// （「备份恢复失败，你的当前数据未被修改」）——#1000 声称 2305 个采样点而包里只有 2246 行，
+	// 把它夹到 2246 以内立刻就能导入。被真机接受过的包里 ZRAW 为 NULL/0 的行本来就有 39~139 条，
+	// 所以往下夹是安全的（夹取只降不升）。
+	if _, err := tx.ExecContext(ctx, `UPDATE ZVISIT SET ZRAW = (SELECT count(*) FROM ZRAWVISIT)
+		WHERE ZRAW IS NOT NULL AND ZRAW > (SELECT count(*) FROM ZRAWVISIT)`); err != nil {
+		return fmt.Errorf("夹原始采样点数失败: %w", err)
+	}
 
 	// 8) 访问↔标签关联（列名从基线探测得到；纯两列关系，全量重写即可）
 	if join.Name != "" && join.VisitCol != "" && join.TagCol != "" {
@@ -472,23 +557,40 @@ func patchSQLite(ctx context.Context, db *sql.DB, datasetID int64, sqlitePath st
 		return err
 	}
 	mov := w("ZMOVEMENT", "Movement")
+	movVisit := map[int]int{}
 	for _, m := range movements {
+		if m.FromVisit.Valid {
+			movVisit[m.SrcPK] = visitAlign[int(m.FromVisit.Int64)]
+		}
+	}
+	movAlign, err := alignByVisitRef(ctx, tx, "ZMOVEMENT", "ZVISITFROM_", movsPKs(movements), movVisit)
+	if err != nil {
+		return fmt.Errorf("对齐位移编号: %w", err)
+	}
+	for _, m := range movements {
+		outPK := movAlign[m.SrcPK]
 		var trv, fromv, tov any
 		if m.Transport.Valid {
-			trv = m.Transport.Int64
+			// 方式按**这条位移自己的名称**归并（见 queryTransports）：同一个 src 在站点里可能
+			// 带着两种含义，只有当条的名称才能认出它到底是哪一种，否则会挂到错的方式上。
+			if x, ok := transByNameSite[m.TransportName]; ok {
+				trv = transAlign[x]
+			} else {
+				trv = transAlign[int(m.Transport.Int64)]
+			}
 		}
 		if m.FromVisit.Valid {
-			fromv = m.FromVisit.Int64
+			fromv = visitAlign[int(m.FromVisit.Int64)]
 		}
 		if m.ToVisit.Valid {
-			tov = m.ToVisit.Int64
+			tov = visitAlign[int(m.ToVisit.Int64)]
 		}
 		// ZTYPE_ 只有站点新建的行才补（已在基线里的行保持真机原值，见 keepNilCols）
 		var mvType any
-		if !known["ZMOVEMENT"][m.SrcPK] {
+		if !known["ZMOVEMENT"][outPK] {
 			mvType = movementTypeDefault(m.Transport.Valid)
 		}
-		if err := mov.write(m.SrcPK, []any{trv, fromv, tov, nt(m.Start), nt(m.End), mvType},
+		if err := mov.write(outPK, []any{trv, fromv, tov, nt(m.Start), nt(m.End), mvType},
 			raws["ZMOVEMENT"][m.SrcPK]); err != nil {
 			return fmt.Errorf("写入位移失败: %w", err)
 		}
@@ -503,12 +605,23 @@ func patchSQLite(ctx context.Context, db *sql.DB, datasetID int64, sqlitePath st
 		return err
 	}
 	wx := w("ZHOURLYWEATHER", "HourlyWeather")
+	wxVisit := map[int]int{}
 	for _, row := range weather {
+		if row.VisitSrc.Valid {
+			wxVisit[row.SrcPK] = visitAlign[int(row.VisitSrc.Int64)]
+		}
+	}
+	wxAlign, err := alignByVisitRef(ctx, tx, "ZHOURLYWEATHER", "ZVISIT", wxPKs(weather), wxVisit)
+	if err != nil {
+		return fmt.Errorf("对齐天气编号: %w", err)
+	}
+	for _, row := range weather {
+		outPK := wxAlign[row.SrcPK]
 		var vsrc any
 		if row.VisitSrc.Valid {
-			vsrc = row.VisitSrc.Int64
+			vsrc = visitAlign[int(row.VisitSrc.Int64)]
 		}
-		if err := wx.write(row.SrcPK, []any{vsrc, nt(row.At), bint(row.Daylight),
+		if err := wx.write(outPK, []any{vsrc, nt(row.At), bint(row.Daylight),
 			nf(row.Temp), nf(row.App), nf(row.Hum), nf(row.Pa), nf(row.Pc), nf(row.Ws), nf(row.Vis), ni(row.UV),
 			ns(row.Cond), ns(row.Symbol), ns(row.UVCat), ns(row.WindDir)},
 			raws["ZHOURLYWEATHER"][row.SrcPK]); err != nil {
@@ -519,15 +632,62 @@ func patchSQLite(ctx context.Context, db *sql.DB, datasetID int64, sqlitePath st
 		return err
 	}
 
+	// 10.5) 清掉被归并掉的交通方式旧行
+	// 基线里「同名但编号已被归并掉」的旧行必须删掉：keepMissing 会把没写到的基线行原样留下，
+	// 于是包里又出现两条同名方式（正是 2026-09-29 生产导出被拒的形状）。名称没有被任何新行认领的
+	// 基线方式仍然保留——站点侧「删掉某方式的最后一条行程」不等于用户想删掉这个方式。
+	canonical := map[string]int{}
+	for _, t := range transports {
+		if t.Name.Valid && t.Name.String != "" {
+			canonical[t.Name.String] = t.SrcPK
+		}
+	}
+	if len(canonical) > 0 {
+		var stale []int
+		rows, err := tx.QueryContext(ctx, `SELECT Z_PK, COALESCE(ZNAME_,'') FROM ZTRANSPORT`)
+		if err != nil {
+			return fmt.Errorf("读取基线的交通方式: %w", err)
+		}
+		for rows.Next() {
+			var pk int
+			var name string
+			if err := rows.Scan(&pk, &name); err != nil {
+				rows.Close()
+				return err
+			}
+			if keep, ok := canonical[name]; ok && keep != pk {
+				stale = append(stale, pk)
+			}
+		}
+		rows.Close()
+		if err := rows.Err(); err != nil {
+			return err
+		}
+		for _, pk := range stale {
+			// 兜底：还有位移指着它就不删（宁可有重复，也不要留悬空引用）
+			var refs int
+			if err := tx.QueryRowContext(ctx,
+				`SELECT count(*) FROM ZMOVEMENT WHERE ZTRANSPORT_ = ?`, pk).Scan(&refs); err != nil {
+				return err
+			}
+			if refs > 0 {
+				continue
+			}
+			if _, err := tx.ExecContext(ctx, `DELETE FROM ZTRANSPORT WHERE Z_PK = ?`, pk); err != nil {
+				return fmt.Errorf("清理被归并的交通方式 %d: %w", pk, err)
+			}
+		}
+	}
+
 	// 11) 回写 Z_PRIMARYKEY.Z_MAX：只上调，避免 rond 下次插入撞键
 	bumps := map[string]int{
-		"Location":      maxPKOf(known["ZLOCATION"], placesPKs(places)),
+		"Location":      maxPKOf(known["ZLOCATION"], mapValues(placeAlign)),
-		"Activity":      maxPKOf(known["ZACTIVITY"], actsPKs(activities)),
+		"Activity":      maxPKOf(known["ZACTIVITY"], mapValues(actAlign)),
-		"Tag":           maxPKOf(known["ZTAG"], tagsPKs(tags)),
+		"Tag":           maxPKOf(known["ZTAG"], mapValues(tagAlign)),
-		"Transport":     maxPKOf(known["ZTRANSPORT"], transPKs(transports)),
+		"Transport":     maxPKOf(known["ZTRANSPORT"], mapValues(transAlign)),
-		"Visit":         maxPKOf(known["ZVISIT"], visitsPKs(visits)),
+		"Visit":         maxPKOf(known["ZVISIT"], mapValues(visitAlign)),
-		"Movement":      maxPKOf(known["ZMOVEMENT"], movsPKs(movements)),
+		"Movement":      maxPKOf(known["ZMOVEMENT"], mapValues(movAlign)),
-		"HourlyWeather": maxPKOf(known["ZHOURLYWEATHER"], wxPKs(weather)),
+		"HourlyWeather": maxPKOf(known["ZHOURLYWEATHER"], mapValues(wxAlign)),
 		"TagGroup":      maxGroupPK,
 	}
 	for name, mx := range bumps {
@@ -988,37 +1148,121 @@ type pgTransport struct {
 	Name, Color, Icon sql.NullString
 }
 
-// queryTransports 把位移里用到的交通方式聚合成 ZTRANSPORT 的行。
+// queryTransports 把位移里用到的交通方式按**名称**归并成 ZTRANSPORT 的行，并给出
+// 「方式名 -> 编号」——每条位移照自己的 transport_name 改挂过去。
 //
-// 必须按 transport_src 唯一：DISTINCT 在「同一方式的不同行程取名不一致」时会返回
+// 为什么不按 transport_src 聚合：站点没有交通方式表，方式只活在位移的 transport_* 四列里，
-// 两行同一个 Z_PK（编辑页允许改方式名，历史数据里也已经有这种脏数据），
+// 而 transport_src 是**两套编号空间**——把实机备份合并进来时实机的编号被写进了同名列，于是同一个
-// 导出时会往 ZTRANSPORT 插两次同一个主键——新建的方式直接撞唯一约束让整次导出失败。
+// src 带着两种含义（实测 src=4 既是「电🐔」又是「公交」）。按 src 聚合只能给一个 src 取一个名字，
-// 取名取最近编辑过的那条（id 最大）的非空值。
+// 另一种含义的位移就被挂到错的方式上；更糟的是会吐出两条同名方式——同名在真机那边是模型唯一约束
-func queryTransports(ctx context.Context, db *sql.DB, datasetID int64) ([]pgTransport, error) {
+// 级别的违规，整包会被拒收（2026-09-29 生产导出踩的第二个坑）。
-	rows, err := db.QueryContext(ctx, `SELECT transport_src,
+//
-		(array_agg(transport_name  ORDER BY id DESC) FILTER (WHERE transport_name  IS NOT NULL))[1],
+// 归一规则：**名称就是身份**。按各名称的位移数从多到少依次认领编号——优先用它原本用得最多、
+// 且还没被别的名称认领的那个；都被占了就新发一个。实测这套规则会把编号恢复成站点原本那一套，
+// 每条位移也都能挂回自己真正的方式上。
+//
+// floor 是「新编号至少要从多少开始」，用来避开基线里已有的编号（避免把新行当成基线行改写）。
+func queryTransports(ctx context.Context, db *sql.DB, datasetID int64, floor int) ([]pgTransport, map[string]int, error) {
+	type cand struct{ src, n int }
+	byName := map[string][]cand{}
+	total := map[string]int{}
+	rows, err := db.QueryContext(ctx, `SELECT COALESCE(transport_name,''), transport_src, count(*)
+		FROM movements WHERE dataset_id=$1 AND transport_src IS NOT NULL
+		GROUP BY 1,2`, datasetID)
+	if err != nil {
+		return nil, nil, fmt.Errorf("读取交通方式: %w", err)
+	}
+	maxSrc := 0
+	for rows.Next() {
+		var name string
+		var src, n int
+		if err := rows.Scan(&name, &src, &n); err != nil {
+			rows.Close()
+			return nil, nil, err
+		}
+		byName[name] = append(byName[name], cand{src, n})
+		total[name] += n
+		if src > maxSrc {
+			maxSrc = src
+		}
+	}
+	rows.Close()
+	if err := rows.Err(); err != nil {
+		return nil, nil, err
+	}
+
+	// 颜色/图标：每个名称取最近编辑过的那条位移上的非空值（真机这两列从来不空，空值在写回时补占位）
+	colorIcon := map[string][2]sql.NullString{}
+	rows, err = db.QueryContext(ctx, `SELECT COALESCE(transport_name,''),
 		(array_agg(transport_color ORDER BY id DESC) FILTER (WHERE transport_color IS NOT NULL))[1],
 		(array_agg(transport_icon  ORDER BY id DESC) FILTER (WHERE transport_icon  IS NOT NULL))[1]
 		FROM movements WHERE dataset_id=$1 AND transport_src IS NOT NULL
-		GROUP BY transport_src ORDER BY transport_src`, datasetID)
+		GROUP BY 1`, datasetID)
 	if err != nil {
-		return nil, fmt.Errorf("读取交通方式: %w", err)
+		return nil, nil, fmt.Errorf("读取交通方式颜色: %w", err)
 	}
-	defer rows.Close()
-	var out []pgTransport
 	for rows.Next() {
-		var t pgTransport
+		var name string
-		var ts sql.NullInt64
+		var color, icon sql.NullString
-		if err := rows.Scan(&ts, &t.Name, &t.Color, &t.Icon); err != nil {
+		if err := rows.Scan(&name, &color, &icon); err != nil {
-			return nil, err
+			rows.Close()
+			return nil, nil, err
 		}
-		if !ts.Valid {
+		colorIcon[name] = [2]sql.NullString{color, icon}
-			continue
+	}
+	rows.Close()
+	if err := rows.Err(); err != nil {
+		return nil, nil, err
+	}
+
+	names := make([]string, 0, len(byName))
+	for name := range byName {
+		names = append(names, name)
+	}
+	// 用量多的先认领编号；数量相同按名称排，保证结果与遍历顺序无关
+	sort.Slice(names, func(i, j int) bool {
+		if total[names[i]] != total[names[j]] {
+			return total[names[i]] > total[names[j]]
+		}
+		return names[i] < names[j]
+	})
+
+	next := maxSrc + 1
+	if next < floor {
+		next = floor
+	}
+	claimed := map[int]bool{}
+	transByName := map[string]int{}
+	out := make([]pgTransport, 0, len(names))
+	for _, name := range names {
+		list := byName[name]
+		sort.Slice(list, func(i, j int) bool {
+			if list[i].n != list[j].n {
+				return list[i].n > list[j].n
+			}
+			return list[i].src < list[j].src
+		})
+		src := 0
+		for _, c := range list {
+			if !claimed[c.src] {
+				src = c.src
+				break
+			}
+		}
+		if src == 0 {
+			src = next
+			next++
+		}
+		claimed[src] = true
+		transByName[name] = src
+		t := pgTransport{SrcPK: src, Color: colorIcon[name][0], Icon: colorIcon[name][1]}
+		if name != "" {
+			t.Name = sql.NullString{String: name, Valid: true}
 		}
-		t.SrcPK = int(ts.Int64)
 		out = append(out, t)
 	}
-	return out, rows.Err()
+	sort.Slice(out, func(i, j int) bool { return out[i].SrcPK < out[j].SrcPK })
+	return out, transByName, nil
 }
 
 type pgVisit struct {
@@ -1056,10 +1300,12 @@ type pgMovement struct {
 	SrcPK                         int
 	Transport, FromVisit, ToVisit sql.NullInt64
 	Start, End                    sql.NullTime
+	TransportName                 string // 该条位移自己的方式名（归并用，见 queryTransports）
 }
 
 func queryMovements(ctx context.Context, db *sql.DB, datasetID int64) ([]pgMovement, error) {
-	rows, err := db.QueryContext(ctx, `SELECT src_pk, transport_src, from_visit_src, to_visit_src, started_at, ended_at
+	rows, err := db.QueryContext(ctx, `SELECT src_pk, transport_src, from_visit_src, to_visit_src, started_at, ended_at,
+		COALESCE(transport_name,'')
 		FROM movements WHERE dataset_id=$1 ORDER BY id`, datasetID)
 	if err != nil {
 		return nil, fmt.Errorf("读取位移: %w", err)
@@ -1068,7 +1314,7 @@ func queryMovements(ctx context.Context, db *sql.DB, datasetID int64) ([]pgMovem
 	var out []pgMovement
 	for rows.Next() {
 		var m pgMovement
-		if err := rows.Scan(&m.SrcPK, &m.Transport, &m.FromVisit, &m.ToVisit, &m.Start, &m.End); err != nil {
+		if err := rows.Scan(&m.SrcPK, &m.Transport, &m.FromVisit, &m.ToVisit, &m.Start, &m.End, &m.TransportName); err != nil {
 			return nil, err
 		}
 		out = append(out, m)
@@ -1087,7 +1333,10 @@ type pgWeather struct {
 }
 
 func queryWeather(ctx context.Context, db *sql.DB, datasetID int64) ([]pgWeather, error) {
-	rows, err := db.QueryContext(ctx, `SELECT src_pk, visit_src, at, is_daylight, temperature_c, apparent_c, humidity,
+	// is_daylight 必须兜底成 false：真机 557/557 都有值，但站点「补录天气」建的行
+	// 没填昼夜标记（editWeatherCreate 不写这一列），而扫进 bool 遇到 NULL 会让**整包导出失败**。
+	// 取 0 与导入侧同口径（parse.go 读真机包用的就是 COALESCE(ZISDAYLIGHT,0)）。
+	rows, err := db.QueryContext(ctx, `SELECT src_pk, visit_src, at, COALESCE(is_daylight,false), temperature_c, apparent_c, humidity,
 		precipitation_amount, precipitation_chance, wind_speed, visibility, uv_index,
 		COALESCE(condition,''), COALESCE(symbol,''), COALESCE(uv_category,''), COALESCE(wind_direction,'')
 		FROM weather WHERE dataset_id=$1 ORDER BY id`, datasetID)
@@ -1289,19 +1538,23 @@ func zipBackup(sqlitePath string, dst io.Writer) error {
 			}
 		}
 		name := "LifeEasy.sqlite" + suffix
-		if err := func() error {
+		// 必须用 CreateRaw 把长度与 CRC 先写进本地头：zip.Writer 默认走流式写入，会把这三项留成 0
-			f, err := os.Open(p)
+		// 并在 flag 里置 bit3（data descriptor）、把真值挪到条目尾部——真机的读取器只认本地头里就
-			if err != nil {
+		// 写着长度的条目，遇到这种包会直接判成损坏（实测 2026-09-16 起每一份 Go 写的导出都被拒，
-				return err
+		// 而唯一被接受过的那份恰好是 Python 重新打包的，它的 flags 是 0x0000）。
-			}
+		data, err := os.ReadFile(p)
-			defer f.Close()
+		if err != nil {
-			w, err := zw.CreateHeader(&zip.FileHeader{Name: name, Method: zip.Store})
+			return fmt.Errorf("读 %s 失败: %w", name, err)
-			if err != nil {
+		}
-				return err
+		fh := &zip.FileHeader{Name: name, Method: zip.Store}
-			}
+		fh.CRC32 = crc32.ChecksumIEEE(data)
-			_, err = io.Copy(w, f)
+		fh.CompressedSize64 = uint64(len(data))
-			return err
+		fh.UncompressedSize64 = uint64(len(data))
-		}(); err != nil {
+		w, err := zw.CreateRaw(fh)
+		if err != nil {
+			return fmt.Errorf("打包 %s 失败: %w", name, err)
+		}
+		if _, err := w.Write(data); err != nil {
 			return fmt.Errorf("打包 %s 失败: %w", name, err)
 		}
 	}
@@ -1318,11 +1571,36 @@ func appleSeconds(t time.Time) float64 {
 // coreDataUUID 给「基线里没有、站点又没这个字段」的新行补一个确定性 UUID（见 uuidV5）。
 // 基线里已有的行一律返回 nil（交给 keepNilCols 沿用原值）：站点本就没有这个字段，
 // 不该反过来改写真机的身份标识——真机里也确实有 2 条到访这一列是空的。
+// DerivedUUID 是站点给「新建行」补的确定性 UUID（RFC 4122 v5，名字取「表名/编号」）。
+//
+// 导出侧用它填 ZVISIT.ZIDENTIFIER_ / ZACTIVITY.ZUID_；它同时是**对账键**：
+// 站点补录的行自己没有留档 UUID（entity_raw 里没有那一行），但导出过一次之后，
+// 包里那条就是这个名字——这份包再合并回来时必须认得出来，否则同一行会被判成
+// 「备份新增」又插一条（实测数据集 9 有 43 对这样的重复：一半是补录行，一半是它的副本）。
+func DerivedUUID(table string, pk int) []byte {
+	return uuidV5(fmt.Sprintf("%s/%d", table, pk))
+}
+
+// DerivedVisitUUID 是派生 UUID 的小写十六进制形式，与 Backup.VisitUUID / StoredVisit.UUID 同形。
+func DerivedVisitUUID(pk int) string { return fmt.Sprintf("%x", DerivedUUID("ZVISIT", pk)) }
+
+// VisitMatchUUID 返回一条站点到访用来对账的 UUID：留档里有就用留档里的，
+// 没有（站点补录的行）就用导出那一刻会补给它的派生 UUID。
+func VisitMatchUUID(sv StoredVisit) string {
+	if sv.UUID != "" {
+		return sv.UUID
+	}
+	if sv.SrcPK <= 0 {
+		return ""
+	}
+	return DerivedVisitUUID(sv.SrcPK)
+}
+
 func coreDataUUID(isNew bool, table string, pk int) any {
 	if !isNew {
 		return nil
 	}
-	return uuidV5(fmt.Sprintf("%s/%d", table, pk))
+	return DerivedUUID(table, pk)
 }
 
 // uuidNamespace 是本站补 UUID 时用的固定命名空间，取值本身无意义，只要不变即可。

internal/rond/export_align.go

@@ -0,0 +1,459 @@
+package rond
+
+import (
+	"context"
+	"database/sql"
+	"encoding/base64"
+	"fmt"
+	"os"
+	"sort"
+	"strings"
+
+	"rond-with-you/internal/geo"
+)
+
+// 导出时的**编号对齐**。
+//
+// 背景：Core Data 的 store 里**地点与活动没有 UUID**，app 只能靠 Z_PK 解引用
+// （`ZVISIT.ZLOCATION` / `ZVISIT.ZACTIVITY_`）。而站点的 `src_pk` 与手机 store 的 `Z_PK`
+// 并不是同一套编号——站点的基线本身可能是「导出包」，编号会在导入-导出的循环里漂移。
+// 导出若把漂移过的编号原样写回，手机那边每条到访都会指向错的地点/活动（或指向不存在的行）
+// ⇒ 导入后「落不进去 / 看不见数据」。
+//
+// 2026-09-29 实测（真机 09-28 包 vs 站点导出，按到访 UUID 对齐）：地点引用 920/920 不同、
+// 活动引用 903/920 不同，而引用到的地点按「名称 + 坐标」完全一致——语义相同、编号不同。
+// 真机自己导出的包永远没问题（编号自洽）。
+//
+// 做法：把托管表的行**按身份**重新编号到「基线的编号空间」（基线就是这份数据集从手机那儿
+// 来的那个 store，所以对齐基线 = 对齐手机）：
+//
+//	地点：坐标键优先（多值索引），退到「同名且相距 ≤1km」
+//	活动 / 到访：UUID
+//	标签 / 交通方式：名称
+//	位移 / 天气：所属到访（已对齐）
+//
+// 基线里找不到身份对应的（站点新建的）行，取「基线最大编号之上」的新号；分配顺序固定，
+// 保证同一份数据每次导出编号一致。
+//
+// 设 ROND_ALIGN_DEBUG=1 会在 stderr 打出每张表的映射规模，便于排查。
+
+// pkAlloc 按「基线最大编号 + 1」起逐个发号，避免与基线的行相撞。
+type pkAlloc struct {
+	next  int
+	used  map[int]bool
+	cache map[int]int
+}
+
+func newPKAlloc(baseMax int) *pkAlloc {
+	return &pkAlloc{next: baseMax + 1, used: map[int]bool{}, cache: map[int]int{}}
+}
+
+func (al *pkAlloc) take(srcPK int, reserved map[int]bool) int {
+	if v, ok := al.cache[srcPK]; ok {
+		return v
+	}
+	for al.used[al.next] || reserved[al.next] {
+		al.next++
+	}
+	al.used[al.next] = true
+	al.cache[srcPK] = al.next
+	al.next++
+	return al.cache[srcPK]
+}
+
+func alignDebug(kind string, base, site, rows, matched int) {
+	if os.Getenv("ROND_ALIGN_DEBUG") == "" {
+		return
+	}
+	fmt.Fprintf(os.Stderr, "ALIGN %-12s 基线 %4d / 站点留档 %4d / 待写 %4d / 身份匹配 %4d\n",
+		kind, base, site, rows, matched)
+}
+
+// alignPlaces 地点：坐标键优先（多值索引），退到同名且 ≤ nameMatchMaxKm。
+func alignPlaces(ctx context.Context, tx *sql.Tx, places []pgPlace) (map[int]int, error) {
+	byCoord, byName := map[string][]int{}, map[string][]int{}
+	base := map[int]StoredPlace{}
+	maxPK := 0
+	// 多值索引：真机一个坐标下有多条同坐标同名的地点（实测「柳州站」3 条），
+	// 单槽位会让其余行永远配不上，引用就会错位。ORDER BY 保证结果确定。
+	rows, err := tx.QueryContext(ctx, `SELECT Z_PK, COALESCE(ZNAME_,''), COALESCE(ZLATITUDE,0), COALESCE(ZLONGITUDE,0)
+		FROM ZLOCATION ORDER BY Z_PK`)
+	if err != nil {
+		return nil, err
+	}
+	for rows.Next() {
+		var sp StoredPlace
+		if err := rows.Scan(&sp.SrcPK, &sp.Name, &sp.Lat, &sp.Lon); err != nil {
+			rows.Close()
+			return nil, err
+		}
+		if sp.Lat != 0 || sp.Lon != 0 {
+			sp.Key = PlaceCoordKey(sp.Lat, sp.Lon)
+			byCoord[sp.Key] = append(byCoord[sp.Key], sp.SrcPK)
+		}
+		if sp.Name != "" {
+			byName[sp.Name] = append(byName[sp.Name], sp.SrcPK)
+		}
+		base[sp.SrcPK] = sp
+		if sp.SrcPK > maxPK {
+			maxPK = sp.SrcPK
+		}
+	}
+	rows.Close()
+	if err := rows.Err(); err != nil {
+		return nil, err
+	}
+
+	out := make(map[int]int, len(places))
+	used := map[int]bool{}
+	alloc := newPKAlloc(maxPK)
+	var leftover []pgPlace
+	matched := 0
+	for _, p := range places {
+		key := ""
+		if p.Lat.Valid && p.Lon.Valid && (p.Lat.Float64 != 0 || p.Lon.Float64 != 0) {
+			key = PlaceCoordKey(p.Lat.Float64, p.Lon.Float64)
+		}
+		picked := 0
+		for _, id := range byCoord[key] {
+			if !used[id] {
+				picked = id
+				break
+			}
+		}
+		if picked != 0 {
+			used[picked] = true
+			out[p.SrcPK] = picked
+			matched++
+			continue
+		}
+		leftover = append(leftover, p)
+	}
+	for _, p := range leftover {
+		if id, ok := matchPlaceByName(byName, base, used, p); ok {
+			used[id] = true
+			out[p.SrcPK] = id
+			matched++
+			continue
+		}
+		if !used[p.SrcPK] {
+			used[p.SrcPK] = true
+			out[p.SrcPK] = p.SrcPK
+			continue
+		}
+		out[p.SrcPK] = alloc.take(p.SrcPK, used)
+	}
+	alignDebug("ZLOCATION", maxPK, len(places), len(places), matched)
+	return out, nil
+}
+
+func matchPlaceByName(byName map[string][]int, base map[int]StoredPlace, used map[int]bool, p pgPlace) (int, bool) {
+	if !p.Name.Valid || p.Name.String == "" {
+		return 0, false
+	}
+	for _, id := range byName[p.Name.String] {
+		if used[id] {
+			continue
+		}
+		sp, ok := base[id]
+		if !ok {
+			continue
+		}
+		if p.Lat.Valid && p.Lon.Valid && (sp.Lat != 0 || sp.Lon != 0) {
+			if geo.Haversine(sp.Lat, sp.Lon, p.Lat.Float64, p.Lon.Float64) > nameMatchMaxKm {
+				continue
+			}
+		}
+		return id, true
+	}
+	return 0, false
+}
+
+// alignUUIDs 活动 / 到访：按留档里的 UUID 对齐到基线同一 UUID 的那一行。
+func alignUUIDs(ctx context.Context, db *sql.DB, tx *sql.Tx, datasetID int64,
+	entity, col string, srcPKs []int) (map[int]int, error) {
+	base, maxPK, err := baselineUUIDMap(ctx, tx, entity, col)
+	if err != nil {
+		return nil, err
+	}
+	site, err := siteUUIDMap(ctx, db, datasetID, entity, col)
+	if err != nil {
+		return nil, err
+	}
+	out := make(map[int]int, len(srcPKs))
+	used := map[int]bool{}
+	alloc := newPKAlloc(maxPK)
+	matched := 0
+	for _, pk := range srcPKs {
+		if u, ok := site[pk]; ok {
+			if id, ok := base[u]; ok && !used[id] {
+				used[id] = true
+				out[pk] = id
+				matched++
+				continue
+			}
+		}
+		if !used[pk] {
+			used[pk] = true
+			out[pk] = pk
+			continue
+		}
+		out[pk] = alloc.take(pk, used)
+	}
+	alignDebug(entity, len(base), len(site), len(srcPKs), matched)
+	return out, nil
+}
+
+func baselineUUIDMap(ctx context.Context, tx *sql.Tx, table, col string) (map[string]int, int, error) {
+	out := map[string]int{}
+	maxPK := 0
+	q := fmt.Sprintf(`SELECT Z_PK, hex(%s) FROM %s WHERE %s IS NOT NULL ORDER BY Z_PK`, col, table, col)
+	rows, err := tx.QueryContext(ctx, q)
+	if err != nil {
+		return nil, 0, err
+	}
+	defer rows.Close()
+	for rows.Next() {
+		var pk int
+		var hex string
+		if err := rows.Scan(&pk, &hex); err != nil {
+			return nil, 0, err
+		}
+		if hex != "" {
+			out[strings.ToLower(hex)] = pk
+		}
+		if pk > maxPK {
+			maxPK = pk
+		}
+	}
+	return out, maxPK, rows.Err()
+}
+
+// siteUUIDMap 读站点留档里的「src_pk -> UUID(hex)」。站点新建的行没有留档 ⇒ 不在结果里，
+// 那些行本来就该拿新编号。留档里的 UUID 是 base64 的 16 字节 blob（见 loadStoredVisits）。
+func siteUUIDMap(ctx context.Context, db *sql.DB, datasetID int64, entity, col string) (map[int]string, error) {
+	out := map[int]string{}
+	q := fmt.Sprintf(`SELECT src_pk, raw #>> '{%s,$blob}' FROM entity_raw
+		WHERE dataset_id=$1 AND entity=$2 AND (raw #>> '{%s,$blob}') IS NOT NULL`, col, col)
+	rows, err := db.QueryContext(ctx, q, datasetID, entity)
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+	for rows.Next() {
+		var pk int
+		var b64 string
+		if err := rows.Scan(&pk, &b64); err != nil {
+			return nil, err
+		}
+		if h := base64ToHex(b64); h != "" {
+			out[pk] = h
+		}
+	}
+	return out, rows.Err()
+}
+
+// base64ToHex 把留档里的 base64 blob 转成小写 hex（与基线 `hex(ZIDENTIFIER_)` 同一形式）。
+func base64ToHex(s string) string {
+	b, err := base64.StdEncoding.DecodeString(s)
+	if err != nil || len(b) == 0 {
+		return ""
+	}
+	return strings.ToLower(fmt.Sprintf("%x", b))
+}
+
+// alignTags 标签：按名称（同名取基线上编号最小的那条）。
+func alignTags(ctx context.Context, tx *sql.Tx, tags []pgTag) (map[int]int, error) {
+	base := map[string]int{}
+	maxPK := 0
+	rows, err := tx.QueryContext(ctx, `SELECT Z_PK, COALESCE(ZNAME_,'') FROM ZTAG ORDER BY Z_PK`)
+	if err != nil {
+		return nil, err
+	}
+	for rows.Next() {
+		var pk int
+		var name string
+		if err := rows.Scan(&pk, &name); err != nil {
+			rows.Close()
+			return nil, err
+		}
+		if name != "" {
+			if id, ok := base[name]; !ok || pk < id {
+				base[name] = pk
+			}
+		}
+		if pk > maxPK {
+			maxPK = pk
+		}
+	}
+	rows.Close()
+	if err := rows.Err(); err != nil {
+		return nil, err
+	}
+	out := make(map[int]int, len(tags))
+	used := map[int]bool{}
+	alloc := newPKAlloc(maxPK)
+	matched := 0
+	for _, t := range tags {
+		if t.Name.Valid && t.Name.String != "" {
+			if id, ok := base[t.Name.String]; ok && !used[id] {
+				used[id] = true
+				out[t.SrcPK] = id
+				matched++
+				continue
+			}
+		}
+		if !used[t.SrcPK] {
+			used[t.SrcPK] = true
+			out[t.SrcPK] = t.SrcPK
+			continue
+		}
+		out[t.SrcPK] = alloc.take(t.SrcPK, used)
+	}
+	alignDebug("ZTAG", maxPK, len(base), len(tags), matched)
+	return out, nil
+}
+
+// alignTransports 交通方式：按名称对齐到基线（基线同名方式的编号）。
+func alignTransports(ctx context.Context, tx *sql.Tx, transports []pgTransport) (map[int]int, error) {
+	base := map[string]int{}
+	maxPK := 0
+	rows, err := tx.QueryContext(ctx, `SELECT Z_PK, COALESCE(ZNAME_,'') FROM ZTRANSPORT ORDER BY Z_PK`)
+	if err != nil {
+		return nil, err
+	}
+	for rows.Next() {
+		var pk int
+		var name string
+		if err := rows.Scan(&pk, &name); err != nil {
+			rows.Close()
+			return nil, err
+		}
+		if name != "" {
+			if id, ok := base[name]; !ok || pk < id {
+				base[name] = pk
+			}
+		}
+		if pk > maxPK {
+			maxPK = pk
+		}
+	}
+	rows.Close()
+	if err := rows.Err(); err != nil {
+		return nil, err
+	}
+	out := make(map[int]int, len(transports))
+	used := map[int]bool{}
+	alloc := newPKAlloc(maxPK)
+	matched := 0
+	for _, t := range transports {
+		if t.Name.Valid && t.Name.String != "" {
+			if id, ok := base[t.Name.String]; ok && !used[id] {
+				used[id] = true
+				out[t.SrcPK] = id
+				matched++
+				continue
+			}
+		}
+		if !used[t.SrcPK] {
+			used[t.SrcPK] = true
+			out[t.SrcPK] = t.SrcPK
+			continue
+		}
+		out[t.SrcPK] = alloc.take(t.SrcPK, used)
+	}
+	alignDebug("ZTRANSPORT", maxPK, len(base), len(transports), matched)
+	return out, nil
+}
+
+// alignByVisitRef 位移 / 天气：按「所属到访（已对齐后的编号）」在基线里找没被占用的行。
+// 同一到访下有多条时按编号顺序依次认领，保证确定性。
+func alignByVisitRef(ctx context.Context, tx *sql.Tx, table, visitCol string,
+	srcPKs []int, visitOf map[int]int) (map[int]int, error) {
+	base := map[int][]int{}
+	maxPK := 0
+	q := fmt.Sprintf(`SELECT Z_PK, COALESCE(%s,0) FROM %s ORDER BY Z_PK`, visitCol, table)
+	rows, err := tx.QueryContext(ctx, q)
+	if err != nil {
+		return nil, err
+	}
+	for rows.Next() {
+		var pk, v int
+		if err := rows.Scan(&pk, &v); err != nil {
+			rows.Close()
+			return nil, err
+		}
+		base[v] = append(base[v], pk)
+		if pk > maxPK {
+			maxPK = pk
+		}
+	}
+	rows.Close()
+	if err := rows.Err(); err != nil {
+		return nil, err
+	}
+	out := make(map[int]int, len(srcPKs))
+	used := map[int]bool{}
+	alloc := newPKAlloc(maxPK)
+	matched := 0
+	for _, pk := range srcPKs {
+		for _, id := range base[visitOf[pk]] {
+			if !used[id] {
+				used[id] = true
+				out[pk] = id
+				matched++
+				break
+			}
+		}
+		if _, ok := out[pk]; !ok {
+			if !used[pk] {
+				used[pk] = true
+				out[pk] = pk
+			} else {
+				out[pk] = alloc.take(pk, used)
+			}
+		}
+	}
+	alignDebug(table, maxPK, len(base), len(srcPKs), matched)
+	return out, nil
+}
+
+// alignedVisitRef 把留档里某个「指向到访的列」改挂到对齐后的编号：留档存的是站点编号，
+// 对齐之后直接写回会指到别的到访（甚至不存在的行）。空值仍写 NULL。
+func alignedVisitRef(raw map[string]any, col string, visitAlign map[int]int) any {
+	if raw == nil {
+		return nil
+	}
+	v, ok := raw[col]
+	if !ok || v == nil {
+		return nil
+	}
+	var pk int
+	switch t := v.(type) {
+	case float64:
+		pk = int(t)
+	case int64:
+		pk = int(t)
+	case int:
+		pk = t
+	default:
+		return nil
+	}
+	if pk <= 0 {
+		return nil
+	}
+	if out, ok := visitAlign[pk]; ok {
+		return out
+	}
+	return nil // 找不到对应（那条到访已不在站点数据里）——宁可置空也不要指错
+}
+
+// mapValues 取映射的值集合，给 Z_PRIMARYKEY 的 Z_MAX 用（要覆盖实际写入的编号）。
+func mapValues(m map[int]int) []int {
+	out := make([]int, 0, len(m))
+	for _, v := range m {
+		out = append(out, v)
+	}
+	sort.Ints(out)
+	return out
+}

internal/rond/export_zip_test.go

@@ -0,0 +1,66 @@
+package rond
+
+import (
+	"archive/zip"
+	"bytes"
+	"encoding/binary"
+	"hash/crc32"
+	"os"
+	"path/filepath"
+	"reflect"
+	"testing"
+)
+
+// 导出包不许用「数据描述符」——zip 的 flag bit 3。
+//
+// Go 的 zip.Writer 默认走流式写入：本地头里的长度与 CRC 留成 0，真值挪到条目尾部的描述符里，
+// 并把 bit 3 置上。真机的读取器只认**本地头里就写着长度**的条目，遇到这种包直接判成损坏，
+// 报「备份恢复失败，你的当前数据未被更改」。
+//
+// 2026-09-16 起每一份 Go 写的导出都被拒，而唯一被真机接受过的那份（20260920-fixed-A）恰好是
+// Python 重新打包的、flags 为 0x0000 —— 09-29 一整天「修内容却一直失败」的真凶就是这里。
+func TestZipBackupWritesNoDataDescriptor(t *testing.T) {
+	dir := t.TempDir()
+	base := filepath.Join(dir, "LifeEasy.sqlite")
+	content := bytes.Repeat([]byte("TamaBox-zip-check/"), 256)
+	if err := os.WriteFile(base, content, 0o644); err != nil {
+		t.Fatal(err)
+	}
+
+	var buf bytes.Buffer
+	if err := zipBackup(base, &buf); err != nil {
+		t.Fatalf("打包失败: %v", err)
+	}
+
+	// 1) 条目名与顺序必须与真机一致；-wal/-shm 缺失时要补 0 字节占位
+	zr, err := zip.NewReader(bytes.NewReader(buf.Bytes()), int64(buf.Len()))
+	if err != nil {
+		t.Fatalf("读回打包结果失败: %v", err)
+	}
+	var names []string
+	for _, f := range zr.File {
+		names = append(names, f.Name)
+	}
+	if want := []string{"LifeEasy.sqlite", "LifeEasy.sqlite-wal", "LifeEasy.sqlite-shm"}; !reflect.DeepEqual(names, want) {
+		t.Errorf("条目名/顺序不对：%v，期望 %v", names, want)
+	}
+
+	// 2) 直接读**第一个条目的本地头**（真机看的就是它）
+	b := buf.Bytes()
+	if len(b) < 30 {
+		t.Fatalf("打包结果太短（%d 字节）", len(b))
+	}
+	flags := binary.LittleEndian.Uint16(b[6:8])
+	crc := binary.LittleEndian.Uint32(b[14:18])
+	csize := binary.LittleEndian.Uint32(b[18:22])
+	usize := binary.LittleEndian.Uint32(b[22:26])
+	if flags&0x8 != 0 {
+		t.Errorf("本地头 flags=0x%04x 带了 data descriptor（bit3）：真机会判成损坏数据", flags)
+	}
+	if csize != uint32(len(content)) || usize != uint32(len(content)) {
+		t.Errorf("本地头里的长度是 0 或不对：压缩后 %d / 原始 %d，期望 %d", csize, usize, len(content))
+	}
+	if crc != crc32.ChecksumIEEE(content) {
+		t.Errorf("本地头里的 CRC 不对：0x%08x，期望 0x%08x", crc, crc32.ChecksumIEEE(content))
+	}
+}

internal/rond/limit_test.go

@@ -0,0 +1,98 @@
+package rond
+
+import (
+	"archive/zip"
+	"bytes"
+	"os"
+	"strings"
+	"testing"
+)
+
+// TestCopyLimitedRejectsOverrun 守住备份包解压的体积上限。
+// zip 头里的 UncompressedSize 是攻击者可控字段，不能只信声明——必须在读的时候掐住。
+func TestCopyLimitedRejectsOverrun(t *testing.T) {
+	var buf bytes.Buffer
+	if err := copyLimited(&buf, strings.NewReader(strings.Repeat("a", 100)), 99); err == nil {
+		t.Error("超过上限应当报错")
+	}
+
+	// 恰好等于上限要放过，内容也不能被截断
+	buf.Reset()
+	if err := copyLimited(&buf, strings.NewReader(strings.Repeat("a", 100)), 100); err != nil {
+		t.Errorf("恰好等于上限不该报错: %v", err)
+	}
+	if buf.Len() != 100 {
+		t.Errorf("正常内容被截断了: %d 字节（应为 100）", buf.Len())
+	}
+
+	buf.Reset()
+	if err := copyLimited(&buf, strings.NewReader("短"), 100); err != nil {
+		t.Errorf("正常内容不该报错: %v", err)
+	}
+	if buf.String() != "短" {
+		t.Errorf("内容被改动了: %q", buf.String())
+	}
+}
+
+// TestUnpackArchiveEnforcesLimit 确认上限真的接在 Open 的解压路径上，
+// 而不只是 copyLimited 孤零零地正确。上限抽成参数就是为了能在这里用小值验一遍。
+func TestUnpackArchiveEnforcesLimit(t *testing.T) {
+	// 真上限（2 GiB）没法用一个小包走一遍，退一步把它圈在「挡得住 zip bomb、
+	// 又不至于误伤真备份」的区间里——顺手拦住把常量改成 1<<62 这类手滑。
+	if maxDBBytes < 1<<30 || maxDBBytes > 8<<30 {
+		t.Errorf("maxDBBytes=%d 超出合理区间 [1GiB, 8GiB]", maxDBBytes)
+	}
+
+	const payload = 4096
+	var buf bytes.Buffer
+	zw := zip.NewWriter(&buf)
+	for _, name := range []string{"Backup.sqlite", "Backup.sqlite-wal"} {
+		w, err := zw.Create(name)
+		if err != nil {
+			t.Fatal(err)
+		}
+		if _, err := w.Write(bytes.Repeat([]byte("s"), payload)); err != nil {
+			t.Fatal(err)
+		}
+	}
+	if err := zw.Close(); err != nil {
+		t.Fatal(err)
+	}
+	zr, err := zip.NewReader(bytes.NewReader(buf.Bytes()), int64(buf.Len()))
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	dir := t.TempDir()
+	// 上限低于条目体积：必须报错，而且不留半个文件在盘上
+	if _, err := unpackArchive(zr, dir, payload-1); err == nil {
+		t.Error("条目超过上限时应当报错")
+	} else {
+		t.Logf("已拒绝: %v", err)
+	}
+	if left, _ := filepathGlob(dir); len(left) != 0 {
+		t.Errorf("被拒绝的条目留下了残留文件: %v", left)
+	}
+
+	// 放宽到够用：正常解出主库路径
+	dbPath, err := unpackArchive(zr, dir, payload)
+	if err != nil {
+		t.Fatalf("上限够用时不该报错: %v", err)
+	}
+	if !strings.HasSuffix(dbPath, "Backup.sqlite") {
+		t.Errorf("返回的主库路径不对: %s", dbPath)
+	}
+}
+
+// filepathGlob 列出 dir 下的文件（测试辅助，避免为上一条再引一个包）。
+func filepathGlob(dir string) ([]string, error) {
+	entries, err := os.ReadDir(dir)
+	if err != nil {
+		return nil, err
+	}
+	var out []string
+	for _, e := range entries {
+		out = append(out, e.Name())
+	}
+	return out, nil
+}

internal/rond/merge.go

@@ -46,16 +46,15 @@ type VisitPatch struct {
 	V    Visit
 }
 
-// PlacePatch 同理，键是坐标键。
+// PlacePatch 表示用备份侧的值覆盖库里的那一条。要改哪一条由配对结果决定
+// （DiffPlaces/MatchPlaces 已经配好），所以这里只带备份侧的整条地点。
 type PlacePatch struct {
-	CoordKey string
+	L Location
-	L        Location
 }
 
-// ActivityPatch 键是活动 UUID（没有 UUID 时退回名称）。
+// ActivityPatch 同理。
 type ActivityPatch struct {
-	Key string
+	A Activity
-	A   Activity
 }
 
 // MergePlan 是一次合并要做的全部改动。
@@ -87,7 +86,7 @@ func BuildMergePlan(vd VisitDiff, pd PlaceDiff, ad ActivityDiff, c Choices) Merg
 	}
 	for _, cf := range pd.Changed {
 		if c.placePick(cf.DB.Key) == PickBackup {
-			p.UpdPlaces = append(p.UpdPlaces, PlacePatch{CoordKey: cf.DB.Key, L: cf.Backup})
+			p.UpdPlaces = append(p.UpdPlaces, PlacePatch{L: cf.Backup})
 		}
 	}
 	for _, sp := range pd.Removed {
@@ -101,7 +100,7 @@ func BuildMergePlan(vd VisitDiff, pd PlaceDiff, ad ActivityDiff, c Choices) Merg
 	}
 	for _, cf := range ad.Changed {
 		if c.activityPick(activityKey(cf.DB)) == PickBackup {
-			p.UpdActs = append(p.UpdActs, ActivityPatch{Key: activityKey(cf.DB), A: cf.Backup})
+			p.UpdActs = append(p.UpdActs, ActivityPatch{A: cf.Backup})
 		}
 	}
 	for _, sa := range ad.Removed {

internal/rond/merge_clash_test.go

@@ -0,0 +1,85 @@
+package rond
+
+import "testing"
+
+// 地点/活动冲突此前一条用例都没有：只造过「新增」，所以 placePick / activityPick
+// 与 UpdPlaces / UpdActs 分支始终没被执行过。差异页线上确实会提交这两类选择。
+func TestBuildMergePlanPlaceClash(t *testing.T) {
+	keyA := PlaceCoordKey(30.123456, 120.654321)
+	keyB := PlaceCoordKey(31.000001, 121.000002)
+	keyC := PlaceCoordKey(32.000003, 122.000004)
+	pd := PlaceDiff{Changed: []PlaceConflict{
+		{Backup: Location{SrcPK: 11, Name: "备份名A"}, DB: StoredPlace{SrcPK: 1, Key: keyA, Name: "站内名A"}},
+		{Backup: Location{SrcPK: 12, Name: "备份名B"}, DB: StoredPlace{SrcPK: 2, Key: keyB, Name: "站内名B"}},
+		{Backup: Location{SrcPK: 13, Name: "备份名C"}, DB: StoredPlace{SrcPK: 3, Key: keyC, Name: "站内名C"}},
+	}}
+	p := BuildMergePlan(VisitDiff{}, pd, ActivityDiff{}, Choices{
+		PlaceClash: map[string]string{keyA: PickBackup, keyB: PickDB},
+	})
+	if len(p.UpdPlaces) != 1 {
+		t.Fatalf("只有选了「用实机」的地点该更新: %+v", p.UpdPlaces)
+	}
+	// 带的是备份侧那条的整份值；「改库里的哪一行」由配对（MatchPlaces）决定，计划里不再存键
+	if p.UpdPlaces[0].L.Name != "备份名A" {
+		t.Fatalf("应带备份侧的值: %+v", p.UpdPlaces[0])
+	}
+	if len(p.UpdVisits)+len(p.AddVisits)+len(p.UpdActs)+len(p.AddActs) != 0 {
+		t.Fatal("没勾新增就不该带出到访/活动改动")
+	}
+}
+
+func TestBuildMergePlanActivityClash(t *testing.T) {
+	ad := ActivityDiff{Changed: []ActivityConflict{
+		{Backup: Activity{SrcPK: 21, Name: "散步"}, DB: StoredActivity{SrcPK: 3, Name: "走路", UUID: uuidC}},
+		{Backup: Activity{SrcPK: 22, Name: "跑步"}, DB: StoredActivity{SrcPK: 4, Name: "跑步"}},
+		{Backup: Activity{SrcPK: 23, Name: "游泳"}, DB: StoredActivity{SrcPK: 5, Name: "游泳", UUID: uuidA}},
+	}}
+	p := BuildMergePlan(VisitDiff{}, PlaceDiff{}, ad, Choices{
+		ActClash: map[string]string{uuidC: PickBackup, "n:跑步": PickSkip},
+	})
+	if len(p.UpdActs) != 1 {
+		t.Fatalf("只有选了「用实机」的活动该更新: %+v", p.UpdActs)
+	}
+	// 改名也能对上：选择是按「UUID（没有才退回名称）」提交的，配对早就发生在比对阶段
+	if p.UpdActs[0].A.Name != "散步" {
+		t.Fatalf("应带备份侧的值: %+v", p.UpdActs[0])
+	}
+}
+
+// 删除是逐条勾选的事：没勾的「仅站内有」绝不顺手删掉，勾了的才进计划。
+func TestBuildMergePlanDeletesOnlyWhenChecked(t *testing.T) {
+	vd := VisitDiff{Removed: []StoredVisit{{SrcPK: 51}, {SrcPK: 52}}}
+	pd := PlaceDiff{Removed: []StoredPlace{{SrcPK: 31}, {SrcPK: 32}}}
+	ad := ActivityDiff{Removed: []StoredActivity{{SrcPK: 41}, {SrcPK: 42}}}
+	p := BuildMergePlan(vd, pd, ad, Choices{
+		DelVisits: map[int]bool{52: true},
+		DelPlaces: map[int]bool{31: true},
+		DelActs:   map[int]bool{42: true},
+	})
+	if len(p.DelVisits) != 1 || p.DelVisits[0].SrcPK != 52 {
+		t.Fatalf("只该删勾了的那条到访: %+v", p.DelVisits)
+	}
+	if len(p.DelPlaces) != 1 || p.DelPlaces[0].SrcPK != 31 {
+		t.Fatalf("只该删勾了的那个地点: %+v", p.DelPlaces)
+	}
+	if len(p.DelActs) != 1 || p.DelActs[0].SrcPK != 42 {
+		t.Fatalf("只该删勾了的那个活动: %+v", p.DelActs)
+	}
+}
+
+func TestAppendMissingDedupesBySrcPK(t *testing.T) {
+	places := appendMissingPlaces(
+		[]Location{{SrcPK: 1, Name: "甲"}},
+		[]Location{{SrcPK: 1, Name: "甲"}, {SrcPK: 2, Name: "乙"}},
+	)
+	if len(places) != 2 || places[1].SrcPK != 2 {
+		t.Fatalf("同 src_pk 不该重复加入: %+v", places)
+	}
+	acts := appendMissingActs(
+		[]Activity{{SrcPK: 7, Name: "通勤"}},
+		[]Activity{{SrcPK: 7, Name: "通勤"}, {SrcPK: 8, Name: "散步"}},
+	)
+	if len(acts) != 2 || acts[1].SrcPK != 8 {
+		t.Fatalf("同 src_pk 不该重复加入: %+v", acts)
+	}
+}

internal/rond/parse.go

@@ -24,19 +24,44 @@ import (
 // Core Data 时间戳基准：2001-01-01 UTC
 var appleEpoch = time.Date(2001, 1, 1, 0, 0, 0, 0, time.UTC)
 
+// 允许的时间窗口 [1970, 2100)。脏备份里会出现 NaN / ±Inf / 量级离谱的值，
+// 而 int64 转换对超范围值是回绕而非饱和——实测 1e30 恰好回绕成 0（＝基准点 2001）、
+// 1e12 变成 2123 年，都是「看着正常」的伪时间，再被当成 first/last_visit_at
+// 污染整条时间轴。必须先卡输入秒数：回绕后的结果可能又落回合法区间，只查结果挡不住。
+var (
+	appleMinSec = time.Date(1970, 1, 1, 0, 0, 0, 0, time.UTC).Sub(appleEpoch).Seconds()
+	appleMaxSec = time.Date(2100, 1, 1, 0, 0, 0, 0, time.UTC).Sub(appleEpoch).Seconds()
+)
+
 func appleTime(v sql.NullFloat64) *time.Time {
-	if !v.Valid {
+	if !v.Valid || math.IsNaN(v.Float64) || math.IsInf(v.Float64, 0) {
+		return nil
+	}
+	sec := math.Floor(v.Float64)
+	if sec < appleMinSec || sec > appleMaxSec {
 		return nil
 	}
 	// 秒的整数部分和小数部分分开算：8 亿量级的秒乘 1e6/1e9 已超出 float64 的
 	// 精确整数范围（2^53），一次性相乘再取整会系统性吃掉最后 1 微秒，
 	// 往返导出后时间戳就对不上了。
-	sec := math.Floor(v.Float64)
 	us := int64(sec)*1_000_000 + int64(math.Round((v.Float64-sec)*1e6))
 	t := appleEpoch.Add(time.Duration(us) * time.Microsecond).Local()
 	return &t
 }
 
+// validCoord 判定坐标是否可用。SQLite 的 REAL 列可能塞进 NaN，备份也可能带出
+// ±90 / ±180 之外的值；这类值会让地图与迷雾索引的网格算出 NaN 或越界格。
+// 无效就按「无坐标」处理——与管线里 COALESCE(NULL,0) 的既有约定一致。
+func validCoord(lat, lon float64) bool {
+	if math.IsNaN(lat) || math.IsInf(lat, 0) || lat < -90 || lat > 90 {
+		return false
+	}
+	if math.IsNaN(lon) || math.IsInf(lon, 0) || lon < -180 || lon > 180 {
+		return false
+	}
+	return true
+}
+
 type Activity struct {
 	SrcPK      int
 	Name       string
@@ -165,6 +190,23 @@ type Backup struct {
 	ActivityUUID map[int]string
 }
 
+// maxDBBytes 是备份包内单个 SQLite 文件解压后的上限。真机的库是几十 MB 量级，
+// 2 GiB 足够宽松，但足以挡住 zip bomb——压缩比上千时几 MB 的包能解出 TB 级。
+const maxDBBytes = 2 << 30
+
+// copyLimited 把 r 拷进 w，超过 limit 就报错。
+// zip 头里的 UncompressedSize 是攻击者可控字段，不能只信声明，必须在读的时候掐住。
+func copyLimited(w io.Writer, r io.Reader, limit int64) error {
+	n, err := io.Copy(w, io.LimitReader(r, limit+1))
+	if err != nil {
+		return err
+	}
+	if n > limit {
+		return fmt.Errorf("解压后超过 %d 字节，疑似异常备份包", limit)
+	}
+	return nil
+}
+
 // Open 解压备份包到 dir，返回可用的 SQLite 连接。
 // 调用方负责 Close 与删除 dir。
 func Open(archivePath, dir string) (*sql.DB, error) {
@@ -177,6 +219,28 @@ func Open(archivePath, dir string) (*sql.DB, error) {
 	}
 	defer zr.Close()
 
+	dbPath, err := unpackArchive(&zr.Reader, dir, maxDBBytes)
+	if err != nil {
+		return nil, err
+	}
+
+	db, err := sql.Open("sqlite", "file:"+filepath.ToSlash(dbPath)+"?_pragma=busy_timeout(5000)")
+	if err != nil {
+		return nil, err
+	}
+	db.SetMaxOpenConns(1)
+	// 把 WAL 合并回主库，避免后续读取时依赖 -shm 状态
+	if _, err := db.Exec("PRAGMA wal_checkpoint(TRUNCATE)"); err != nil {
+		db.Close()
+		return nil, fmt.Errorf("合并 WAL 失败: %w", err)
+	}
+	return db, nil
+}
+
+// unpackArchive 把包里的 Core Data 主库及其 WAL / SHM 解压到 dir，返回主库路径。
+// limit 是单个条目解压后的字节上限；抽成参数是为了让上限本身可测
+// （真上限 2 GiB，测试里没法造出一个 2 GiB 的 zip bomb）。
+func unpackArchive(zr *zip.Reader, dir string, limit int64) (string, error) {
 	var dbPath string
 	for _, f := range zr.File {
 		base := filepath.Base(f.Name)
@@ -191,38 +255,39 @@ func Open(archivePath, dir string) (*sql.DB, error) {
 		dst := filepath.Join(dir, base)
 		rc, err := f.Open()
 		if err != nil {
-			return nil, err
+			return "", err
 		}
 		out, err := os.Create(dst)
 		if err != nil {
 			rc.Close()
-			return nil, err
+			return "", err
 		}
-		_, cerr := io.Copy(out, rc)
+		cerr := copyLimited(out, rc, limit)
 		rc.Close()
 		out.Close()
 		if cerr != nil {
-			return nil, cerr
+			os.Remove(dst)
+			return "", fmt.Errorf("解压 %s: %w", base, cerr)
 		}
 		if strings.HasSuffix(low, ".sqlite") {
 			dbPath = dst
 		}
 	}
 	if dbPath == "" {
-		return nil, fmt.Errorf("备份包内未找到 .sqlite 数据库文件")
+		return "", fmt.Errorf("备份包内未找到 .sqlite 数据库文件")
 	}
+	return dbPath, nil
+}
 
-	db, err := sql.Open("sqlite", "file:"+filepath.ToSlash(dbPath)+"?_pragma=busy_timeout(5000)")
+// drainRows 收尾 rows 循环。只 Close 不查 Err：驱动或连接中途出错时 Next() 只会
+// 返回 false、从不报错，半张表就被当成完整的交出去——数据静默变少，日志一片空白。
+func drainRows(rows *sql.Rows, what string) error {
+	err := rows.Err()
+	rows.Close()
 	if err != nil {
-		return nil, err
+		return fmt.Errorf("%s: %w", what, err)
 	}
-	db.SetMaxOpenConns(1)
+	return nil
-	// 把 WAL 合并回主库，避免后续读取时依赖 -shm 状态
-	if _, err := db.Exec("PRAGMA wal_checkpoint(TRUNCATE)"); err != nil {
-		db.Close()
-		return nil, fmt.Errorf("合并 WAL 失败: %w", err)
-	}
-	return db, nil
 }
 
 // Parse 读取 Core Data 库，转换为领域模型。
@@ -244,7 +309,9 @@ func Parse(db *sql.DB) (*Backup, error) {
 		}
 		b.TagGroups[pk] = name
 	}
-	rows.Close()
+	if err = drainRows(rows, "读取标签分组"); err != nil {
+		return nil, err
+	}
 
 	// 标签（含所属分组关系 Z_11TAGS_ 的逆向：ZTAG.ZGROUP -> ZTAGGROUP）
 	tagGroup := map[int]int{}
@@ -260,7 +327,9 @@ func Parse(db *sql.DB) (*Backup, error) {
 		}
 		tagGroup[pk] = g
 	}
-	grows.Close()
+	if err = drainRows(grows, "读取标签分组关系"); err != nil {
+		return nil, err
+	}
 
 	trows, err := db.Query(`SELECT Z_PK, COALESCE(ZNAME_,''), COALESCE(ZCOLOR_,'') FROM ZTAG`)
 	if err != nil {
@@ -275,7 +344,9 @@ func Parse(db *sql.DB) (*Backup, error) {
 		t.GroupName = b.TagGroups[tagGroup[t.SrcPK]]
 		b.Tags = append(b.Tags, t)
 	}
-	trows.Close()
+	if err = drainRows(trows, "读取标签"); err != nil {
+		return nil, err
+	}
 
 	// 类型 / 活动
 	arows, err := db.Query(`SELECT Z_PK, COALESCE(ZNAME_,''), COALESCE(ZCOLOR_,''), COALESCE(ZICON_,''),
@@ -293,7 +364,9 @@ func Parse(db *sql.DB) (*Backup, error) {
 		a.IsHome, a.IsWork, a.IsExcluded, a.IsArchived = h == 1, w == 1, e == 1, ar == 1
 		b.Activities = append(b.Activities, a)
 	}
-	arows.Close()
+	if err = drainRows(arows, "读取活动类型"); err != nil {
+		return nil, err
+	}
 
 	// 交通方式
 	trrows, err := db.Query(`SELECT Z_PK, COALESCE(ZNAME_,''), COALESCE(ZCOLOR_,''), COALESCE(ZICON_,'') FROM ZTRANSPORT`)
@@ -308,7 +381,9 @@ func Parse(db *sql.DB) (*Backup, error) {
 		}
 		b.Transports = append(b.Transports, t)
 	}
-	trrows.Close()
+	if err = drainRows(trrows, "读取交通方式"); err != nil {
+		return nil, err
+	}
 
 	// 地点
 	lrows, err := db.Query(`SELECT Z_PK, COALESCE(ZNAME_,''), COALESCE(ZCATEGORY_,''),
@@ -327,9 +402,14 @@ func Parse(db *sql.DB) (*Backup, error) {
 			lrows.Close()
 			return nil, err
 		}
+		if !validCoord(l.Lat, l.Lon) {
+			l.Lat, l.Lon = 0, 0
+		}
 		b.Locations = append(b.Locations, l)
 	}
-	lrows.Close()
+	if err = drainRows(lrows, "读取地点"); err != nil {
+		return nil, err
+	}
 
 	// 访问记录
 	vrows, err := db.Query(`SELECT Z_PK, ZLOCATION, ZACTIVITY_, ZARRIVALDATE_, ZDEPARTUREDATE_,
@@ -363,7 +443,9 @@ func Parse(db *sql.DB) (*Backup, error) {
 		visitIdx[v.SrcPK] = len(b.Visits)
 		b.Visits = append(b.Visits, v)
 	}
-	vrows.Close()
+	if err = drainRows(vrows, "读取访问记录"); err != nil {
+		return nil, err
+	}
 
 	// 访问 → 标签
 	vtrows, err := db.Query(`SELECT Z_18VISITS_, Z_11TAGS_5 FROM Z_11VISITS_`)
@@ -380,7 +462,9 @@ func Parse(db *sql.DB) (*Backup, error) {
 			b.Visits[i].TagSrcPKs = append(b.Visits[i].TagSrcPKs, tid)
 		}
 	}
-	vtrows.Close()
+	if err = drainRows(vtrows, "读取访问标签"); err != nil {
+		return nil, err
+	}
 
 	// 位移
 	mrows, err := db.Query(`SELECT Z_PK, ZTRANSPORT_, ZVISITFROM_, ZVISITTO_, ZSTART_, ZEND_ FROM ZMOVEMENT`)
@@ -411,7 +495,9 @@ func Parse(db *sql.DB) (*Backup, error) {
 		m.End = appleTime(en)
 		b.Movements = append(b.Movements, m)
 	}
-	mrows.Close()
+	if err = drainRows(mrows, "读取位移记录"); err != nil {
+		return nil, err
+	}
 
 	// 小时级天气
 	wrows, err := db.Query(`SELECT Z_PK, ZVISIT, ZDATE_, COALESCE(ZISDAYLIGHT,0),
@@ -453,7 +539,9 @@ func Parse(db *sql.DB) (*Backup, error) {
 		}
 		b.Weather = append(b.Weather, w)
 	}
-	wrows.Close()
+	if err = drainRows(wrows, "读取天气记录"); err != nil {
+		return nil, err
+	}
 
 	if err := db.QueryRow(`SELECT count(*) FROM ZRAWVISIT`).Scan(&b.RawVisitNum); err != nil {
 		b.RawVisitNum = 0
@@ -645,7 +733,9 @@ func captureMeta(db *sql.DB) (*CoreDataMeta, error) {
 			m.Entities[name] = EntityInfo{Ent: ent, Max: max}
 		}
 	}
-	rows.Close()
+	if err = drainRows(rows, "读取 Z_PRIMARYKEY"); err != nil {
+		return nil, err
+	}
 
 	drows, err := db.Query(`SELECT name, sql FROM sqlite_master WHERE type='table' AND name LIKE 'Z%' AND sql IS NOT NULL`)
 	if err != nil {
@@ -659,7 +749,9 @@ func captureMeta(db *sql.DB) (*CoreDataMeta, error) {
 		}
 		m.DDL[name] = ddl
 	}
-	drows.Close()
+	if err = drainRows(drows, "读取建表 DDL"); err != nil {
+		return nil, err
+	}
 
 	// 访问↔标签关联表：表名形如 Z_<tagEnt>VISITS_，两列分别指向 Visit / Tag 实体。
 	visitEnt, okV := m.Entities["Visit"]
@@ -692,7 +784,11 @@ func captureMeta(db *sql.DB) (*CoreDataMeta, error) {
 					tcol = cname
 				}
 			}
+			cerr := crows.Err()
 			crows.Close()
+			if cerr != nil {
+				continue
+			}
 			if vcol != "" && tcol != "" {
 				m.JoinTable = JoinTableInfo{Name: tname, VisitCol: vcol, TagCol: tcol}
 				break

internal/rond/parse_rows_test.go

@@ -0,0 +1,66 @@
+package rond
+
+import (
+	"os"
+	"path/filepath"
+	"regexp"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+// D3 回归：parse.go 里每个 rows 循环的收尾都必须查 rows.Err()。
+//
+// 只 Close 不查 Err 是「不报错也不算错」的那一类：驱动或连接中途出错时
+// Next() 只返回 false、从不报错，读到一半的表会被当成完整的交出去——
+// 表现成导入后到访/位移莫名变少，日志里一个字都没有。
+//
+// 两种合格写法：循环后 `if err = drainRows(x, "…")`，或自己 `x.Err()`。
+func TestParseDrainsEveryRowsLoop(t *testing.T) {
+	_, self, _, ok := runtime.Caller(0)
+	if !ok {
+		t.Fatal("定位测试文件失败")
+	}
+	src, err := os.ReadFile(filepath.Join(filepath.Dir(self), "parse.go"))
+	if err != nil {
+		t.Fatalf("读 parse.go 失败: %v", err)
+	}
+	text := string(src)
+
+	lits := regexp.MustCompile(`for (\w+)\.Next\(\)`).FindAllStringSubmatch(text, -1)
+	seen := map[string]bool{}
+	for _, m := range lits {
+		name := m[1]
+		if seen[name] {
+			continue
+		}
+		seen[name] = true
+		if !strings.Contains(text, name+".Err()") && !strings.Contains(text, "drainRows("+name+",") {
+			t.Errorf("parse.go 里 %s 的循环收尾没查 %s.Err()（只 Close 会把读一半的表当完整的交出去）", name, name)
+		}
+	}
+	if len(seen) < 10 {
+		t.Fatalf("只认出 %d 个 rows 循环变量（期望 ≥10），判据可能被改写架空，请同步更新本用例", len(seen))
+	}
+
+	// 收尾助手自己必须真的读 Err，否则上面那条判据能被一个空壳 drainRows 骗过去
+	body := between(text, "func drainRows(", "\nfunc ")
+	if body == "" {
+		t.Fatal("找不到 drainRows 的实现")
+	}
+	if !strings.Contains(body, "Err()") || !strings.Contains(body, "Close()") {
+		t.Errorf("drainRows 必须既查 Err() 又 Close()，实际:\n%s", body)
+	}
+}
+
+func between(s, start, end string) string {
+	i := strings.Index(s, start)
+	if i < 0 {
+		return ""
+	}
+	rest := s[i+len(start):]
+	if j := strings.Index(rest, end); j >= 0 {
+		return rest[:j]
+	}
+	return rest
+}

internal/setting/setting.go

@@ -41,6 +41,13 @@ type Settings struct {
 	// MediaBackend 是地点图片存哪：local（服务器磁盘）或 s3（S3 兼容对象存储，如 R2）。
 	// 对象存储的凭据在 conf/app.ini 里（s3_*），不进数据库。
 	MediaBackend string `json:"media_backend"`
+	// TrackEnabled 决定是否注入 TrackScript。默认关闭（false）——
+	// 统计脚本会把自己掌握的访问信息发到第三方，默认不该开。
+	TrackEnabled bool `json:"track_enabled"`
+	// TrackScript 是第三方统计 / 追踪脚本；填 URL 会包成 <script src>，
+	// 需要初始化代码的服务（百度统计、Umami 等）可以把整段 <script> 贴进来。
+	// 仅在 TrackEnabled 为真时注入，且只注入公开页面（后台与登录页不挂）。
+	TrackScript string `json:"track_script"`
 }
 
 // 地点图片的两种存储后端。
@@ -117,6 +124,9 @@ func Default() Settings {
 		VisitorHome: VisitorHomeMain,
 		// 图片默认存服务器本地磁盘；配好 R2 之后再在后台切过去
 		MediaBackend: MediaBackendLocal,
+		// 统计脚本默认关闭：要站长明确打开、并自己填上脚本，才会注入公开页面
+		TrackEnabled: false,
+		TrackScript:  "",
 	}
 }
 
@@ -249,6 +259,14 @@ func (st *Store) Load(ctx context.Context) (Settings, error) {
 	if saved.AccentColor != "" {
 		cur.AccentColor = saved.AccentColor
 	}
+	// 统计脚本两个键都用 present 判：track_enabled 是后加的键，
+	// 历史配置里根本没有它，若直接套 saved.TrackEnabled（零值 false）倒也正好是
+	// 「默认关闭」；但显式判一下能让意图写在代码里，不依赖零值恰好对。
+	if _, ok := present["track_enabled"]; ok {
+		cur.TrackEnabled = saved.TrackEnabled
+	}
+	// 脚本内容可能存过又清空（关掉开关但想留着），所以空串也是合法值，直接赋值
+	cur.TrackScript = saved.TrackScript
 	return cur, nil
 }
 

internal/stats/placecols_test.go

@@ -0,0 +1,169 @@
+package stats_test
+
+import (
+	"context"
+	"regexp"
+	"strings"
+	"testing"
+
+	"rond-with-you/internal/stats"
+)
+
+// placeCols 里每个相关子查询都必须带 `<别名>.dataset_id = p.dataset_id`：
+// idx_visits_place 是 (dataset_id, place_id)，缺了前导列，每轮循环都要为库里
+// 每个 dataset 各下一次索引（实测 Buffer 命中 23737 → 5669，耗时 53ms → 31ms）。
+// 谓词本身冗余，删掉不会报错、也不会算错，只会悄悄变慢 —— 所以只能这么钉。
+func TestPlaceColsCarriesDatasetIDInCorrelatedSubqueries(t *testing.T) {
+	// 去掉全部空白再找，免得因为换行/缩进/等号两边空格的差异误报。
+	compact := strings.NewReplacer(" ", "", "\n", "", "\t", "", "\r", "").Replace(stats.PlaceCols)
+	// 必须按子查询分段判断：v2 出现三次，全文 Contains 会被另外两处顶包。
+	hits := regexp.MustCompile(`FROMvisits(v\d+)`).FindAllStringSubmatchIndex(compact, -1)
+	if len(hits) != 5 {
+		t.Fatalf("placeCols 里的 visits 子查询数量变成 %d（期望 5），请同步更新本用例", len(hits))
+	}
+	for i, m := range hits {
+		alias := compact[m[2]:m[3]]
+		end := len(compact)
+		if i+1 < len(hits) {
+			end = hits[i+1][0]
+		}
+		if seg := compact[m[1]:end]; !strings.Contains(seg, alias+".dataset_id=p.dataset_id") {
+			t.Errorf("placeCols 中 %s 的子查询缺少 %s.dataset_id=p.dataset_id（会导致索引前导列缺失）", alias, alias)
+		}
+	}
+}
+
+// placeCols 里 top 活动三轴（name/color/icon）是三个**互相独立**的众数，
+// 不能合并成一个 GROUP BY：合并后同一活动名下的颜色/图标会跟着最多的那一行走，
+// 而独立众数允许「名字取 A、颜色取 B」。这里用 Go 侧独立数一遍钉住语义。
+// SQL 的并列取法是未定义的，所以只在「三轴都存在唯一严格最大值」的地点上断言。
+func TestPlaceColsTopActivityMatchesIndependentCount(t *testing.T) {
+	db, dsID := setup(t)
+	ctx := context.Background()
+	d := stats.DB{DB: db}
+
+	type counts map[string]int
+	type placeAgg struct {
+		name, color, icon counts
+		home, work        bool
+	}
+	aggs := map[int64]*placeAgg{}
+
+	var placeIDs []int64
+	rows, err := db.QueryContext(ctx, `SELECT id FROM places WHERE dataset_id=$1`, dsID)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for rows.Next() {
+		var id int64
+		if err := rows.Scan(&id); err != nil {
+			t.Fatal(err)
+		}
+		placeIDs = append(placeIDs, id)
+		aggs[id] = &placeAgg{name: counts{}, color: counts{}, icon: counts{}}
+	}
+	rows.Close()
+	if err := rows.Err(); err != nil {
+		t.Fatal(err)
+	}
+
+	// 有活动的到访：top 三轴的独立计数。
+	rows, err = db.QueryContext(ctx, `SELECT v.place_id, a.name, a.color, a.icon
+		FROM visits v JOIN activities a ON a.id=v.activity_id WHERE v.dataset_id=$1`, dsID)
+	if err != nil {
+		t.Fatal(err)
+	}
+	for rows.Next() {
+		var pid int64
+		var name, color, icon string
+		if err := rows.Scan(&pid, &name, &color, &icon); err != nil {
+			t.Fatal(err)
+		}
+		a := aggs[pid]
+		if a == nil {
+			continue
+		}
+		a.name[name]++
+		a.color[color]++
+		a.icon[icon]++
+	}
+	rows.Close()
+	if err := rows.Err(); err != nil {
+		t.Fatal(err)
+	}
+
+	// is_home / is_work 来自 visits 本身，不 join activities。
+	for _, tc := range []struct {
+		q    string
+		mark func(*placeAgg)
+	}{
+		{`SELECT place_id FROM visits WHERE dataset_id=$1 AND is_home`, func(a *placeAgg) { a.home = true }},
+		{`SELECT place_id FROM visits WHERE dataset_id=$1 AND is_work`, func(a *placeAgg) { a.work = true }},
+	} {
+		rows, err := db.QueryContext(ctx, tc.q, dsID)
+		if err != nil {
+			t.Fatal(err)
+		}
+		for rows.Next() {
+			var pid int64
+			if err := rows.Scan(&pid); err != nil {
+				t.Fatal(err)
+			}
+			if a := aggs[pid]; a != nil {
+				tc.mark(a)
+			}
+		}
+		rows.Close()
+		if err := rows.Err(); err != nil {
+			t.Fatal(err)
+		}
+	}
+
+	got, err := d.MapPlaces(ctx, stats.Filter{DatasetID: dsID}, 4000)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(got) == 0 {
+		t.Skip("MapPlaces 返回空，无法比对")
+	}
+
+	strict := func(c counts) (string, bool) { // 唯一严格众数
+		best, n, tie := "", 0, false
+		for v, k := range c {
+			switch {
+			case k > n:
+				best, n, tie = v, k, false
+			case k == n:
+				tie = true
+			}
+		}
+		return best, best != "" && !tie
+	}
+
+	checked := 0
+	for _, p := range got {
+		a := aggs[p.ID]
+		if a == nil {
+			t.Fatalf("MapPlaces 返回了不属于本数据集的地点 %d", p.ID)
+		}
+		if p.IsHome != a.home || p.IsWork != a.work {
+			t.Errorf("地点 %d: is_home=%v is_work=%v，独立统计为 %v/%v",
+				p.ID, p.IsHome, p.IsWork, a.home, a.work)
+		}
+		name, nOK := strict(a.name)
+		color, cOK := strict(a.color)
+		icon, iOK := strict(a.icon)
+		if !nOK || !cOK || !iOK {
+			continue // SQL 的并列取法未定义，跳过
+		}
+		checked++
+		if p.TopActivity != name || p.TopColor != color || p.TopIcon != icon {
+			t.Errorf("地点 %d: top 三轴 = %q/%q/%q，独立数出 %q/%q/%q",
+				p.ID, p.TopActivity, p.TopColor, p.TopIcon, name, color, icon)
+		}
+	}
+	if checked == 0 {
+		t.Skip("本数据集没有「三轴唯一众数」的地点，比不了")
+	}
+	t.Logf("已比对 %d/%d 个地点（其余有并列，跳过）", checked, len(got))
+}

internal/stats/stats.go

@@ -36,10 +36,23 @@ type Filter struct {
 	// RegionsExclude 为 true 时是黑名单（命中即排除），false 时是白名单（命中才保留）。
 	Regions        []string
 	RegionsExclude bool
-	// Verdict 非 0 时只保留站长标记为该结论的地点（1 推荐 / -1 踩雷）。
+	// Verdict 非 0 时只保留站长标记为该结论的地点：**连同它们名下的到访与位移一起**
+	// （1 推荐 / -1 踩雷）。它不是「只筛地点列表」的镜头——判据下推到 visitsWhere /
+	// movementsWhere，页面上所有数字跟着一起变，否则会出现「点没了、里程还在」这种
+	// 自相矛盾的视图。
 	Verdict int
 }
 
+// placeKeyExpr 把 places 某个别名下的坐标换算成 place_key。
+// **必须与 Go 侧 rond.PlaceCoordKey 逐位一致**（notes / votes / handlers_images / stats
+// 各有一份，改一处搜全仓）：
+//
+//	fmt.Sprintf("%.6f|%.6f")  ↔  to_char(x,'FM999990.000000')||'|'||to_char(y,'FM999990.000000')
+func placeKeyExpr(alias string) string {
+	return fmt.Sprintf(
+		"to_char(%[1]s.lat,'FM999990.000000')||'|'||to_char(%[1]s.lon,'FM999990.000000')", alias)
+}
+
 type where struct {
 	conds []string
 	args  []any
@@ -95,11 +108,48 @@ func (w *where) andSQL() string {
 	return " AND " + strings.Join(w.conds, " AND ")
 }
 
-// visitsWhere 构造作用于 visits 表别名 v 的过滤条件。
+// SoloVisitSQL 生成「这次到访是独立成立的」SQL 条件（alias 是 visits 表的别名）。
+//
+// 真机把它**并入了别的到访**（ZVISIT.ZMERGEDTO），或它**只是某个父段的一部分**（ZVISIT.ZPARENT）时，
+// app 既不单独显示它、也不把它算进次数与停留——本站以前把这两种行当成普通到访，
+// 于是时间线上出现「同一时刻同一地点两条」（实测数据集 9 有 64 条，26 条的到达时间与原件完全相同），
+// 日停留也跟着重复计入。
+//
+// 判据取派生列 `visits.is_merged`（导入 / 合并时从 entity_raw 算好，见 RefreshMergedFlagsSQL）：
+// 早先是每行去 entity_raw 取回**整行 Core Data JSON** 再解析 raw->>'ZMERGEDTO'，
+// 而 raw 是 TOAST 过的整行——地点库「每个地点 × 5 个子查询」的量级下，一个页面实测要 70 秒。
+//
+// ⚠️ 只在**读**的一侧收口：导出包必须原样带着这些行（rond 靠它们认这次合并发生过），
+// 所以 internal/rond 与 backup_diff / backup_merge 的实体对齐一律不加这个条件。
+//
+// 判据只此一份，别在别处手抄——抄一份迟早跟这里漂移（区域限制那套就犯过一次）。
+func SoloVisitSQL(alias string) string { return "NOT " + alias + ".is_merged" }
+
+// RefreshMergedFlagsSQL 从 entity_raw 重算 visits.is_merged。
+// 导入、合并（以及任何直接改过留档里 ZMERGEDTO / ZPARENT 的操作）之后都要跑一次。
+const RefreshMergedFlagsSQL = `UPDATE visits v SET is_merged = TRUE
+	FROM entity_raw er
+	WHERE er.dataset_id = v.dataset_id AND er.entity = 'ZVISIT' AND er.src_pk = v.src_pk
+	  AND (er.raw->>'ZMERGEDTO' IS NOT NULL OR er.raw->>'ZPARENT' IS NOT NULL)
+	  AND v.dataset_id = $1 AND NOT v.is_merged`
+
+// visitsWhere 构造作用于 visits 表别名 v 的过滤条件（**访客口径**：已并入 / 子段的到访不算数）。
 // off 用于嵌套：子查询里的占位符从 off+1 开始编号，避免与外层冲突。
-func (f Filter) visitsWhere(off int) *where {
+func (f Filter) visitsWhere(off int) *where { return f.visitConds(off, true) }
+
+// visitConds 是 visitsWhere 的实现。
+//
+// solo=false 时不筛「已并入 / 子段」——天气与位移用的是这一支：那几小时、那段路是真的
+// 发生过的，不该因为这次到访在 app 里不单独显示就从统计里消失（实测数据集 9 有 12 条
+// 天气行、5 条位移挂在被并入的行上）。
+func (f Filter) visitConds(off int, solo bool) *where {
 	w := &where{off: off}
 	w.cond("v.dataset_id = ?", f.DatasetID)
+	// 已并入 / 子段不算一条独立到访（判据见 SoloVisitSQL）。放在这里是为了**全域一致**：
+	// 时间线、首页、统计、城市 / 省份、活动计数、星期分布、地点列的到访数都从这份条件派生。
+	if solo {
+		w.cond(SoloVisitSQL("v"))
+	}
 	if f.From != nil {
 		w.cond("v.arrival >= ?", *f.From)
 	}
@@ -148,6 +198,15 @@ func (f Filter) visitsWhere(off int) *where {
 		w.cond(`EXISTS (SELECT 1 FROM places px WHERE px.id=v.place_id
 			AND (px.name ILIKE ? OR px.city ILIKE ? OR px.poi_category ILIKE ?))`, kw, kw, kw)
 	}
+	if f.Verdict != 0 {
+		// 结论挂坐标键（换数据集也跟得住），所以判据是「这次到访所属地点的键」。
+		//
+		// 放在 visitsWhere 而不是 Places 里，是为了**全域一致**：地图点、城市/省份统计、
+		// 类型计数、概览，以及靠 movementVisitConds 派生的里程 / 出行数，全都从这一份
+		// 条件派生出来，不会各认各的。
+		w.cond(`EXISTS (SELECT 1 FROM place_votes pv JOIN places pvp ON pvp.id = v.place_id
+			WHERE pv.place_key = `+placeKeyExpr("pvp")+` AND pv.verdict = ?)`, f.Verdict)
+	}
 	return w
 }
 
@@ -157,8 +216,11 @@ func (f Filter) visitsWhere(off int) *where {
 // 这些失去归属的天气行仍然属于「某段时间里经历的天气」。所以只按时间筛选时不该
 // 额外要求它们能关联到到访，否则一删到访、那几天的天气就凭空少一截。
 func (f Filter) hasVisitConds() bool {
+	// Verdict 也算：movements/weather 只在「有这类条件」时才会包一层 EXISTS 到访，
+	// 漏掉它就别指望位移会跟着筛选走。
 	return len(f.ActivityIDs) > 0 || f.MinDwell > 0 || f.ExcludeHome || f.ExcludeWork ||
-		f.City != "" || f.Province != "" || f.TagID > 0 || len(f.Regions) > 0 || f.Keyword != ""
+		f.City != "" || f.Province != "" || f.TagID > 0 || len(f.Regions) > 0 || f.Keyword != "" ||
+		f.Verdict != 0
 }
 
 // weatherWhere 构造作用于 weather 表别名 w 的过滤条件。
@@ -179,7 +241,7 @@ func (f Filter) weatherWhere() *where {
 	if f.hasVisitConds() {
 		rest := f
 		rest.From, rest.To = nil, nil // 时间已经按 w.at 判过了
-		vw := rest.visitsWhere(len(w.args))
+		vw := rest.visitConds(len(w.args), false)
 		w.conds = append(w.conds,
 			"EXISTS (SELECT 1 FROM visits v WHERE v.src_pk = w.visit_src AND "+vw.expr()+")")
 		w.args = append(w.args, vw.args...)
@@ -187,6 +249,35 @@ func (f Filter) weatherWhere() *where {
 	return w
 }
 
+// movementVisitConds 是「必须落到某次到访上才能判定」的那几档条件（活动 / 最短停留 /
+// 城市 / 省份 / 标签 / 关键词），专门给位移用——movements 自己只有两端到访，
+// 没有城市、活动这些字段。
+//
+// 这里**复用 visitsWhere 拼出来的表达式**，而不是再抄一遍：抄一遍迟早跟 visitsWhere
+// 漂移，漏掉一个维度就是「到访数变了、里程还是全量」（区域那档已经犯过一次）。
+// 清掉三类条件，剩下的正是可以按到访判的：
+//   - 时间：位移按 movements.started_at 判，再按到访的 arrival 判一次就是另一套口径；
+//   - 区域：位移要按**两端 places** 判（任一端命中即算），见 movementsWhere；
+//   - 家 / 工作：那边是「两端都不是」的 NOT EXISTS，塞进这里的 EXISTS 会松成「任一端不是」；
+//   - 已并入 / 子段：位移照算（里程与轨迹是真实发生过的），见 visitConds 的 solo 参数。
+func (f Filter) movementVisitConds(off int) *where {
+	rest := f
+	rest.From, rest.To = nil, nil
+	rest.Regions = nil
+	rest.ExcludeHome, rest.ExcludeWork = false, false
+	return rest.visitConds(off, false)
+}
+
+// hasMovementVisitConds 表示「带上了只有到访才判得出的筛选条件」。
+// 从 hasVisitConds 派生，免得两处再各写一份清单；减掉的正是 movementVisitConds
+// 里被清掉的那两类（家工作、区域），它们由 movementsWhere 自己判。
+func (f Filter) hasMovementVisitConds() bool {
+	rest := f
+	rest.ExcludeHome, rest.ExcludeWork = false, false
+	rest.Regions = nil
+	return rest.hasVisitConds()
+}
+
 // movementsWhere 构造作用于 movements 表的过滤条件（off 的语义同 visitsWhere）。
 //
 // 与 visitsWhere 一样必须带区域限制：movements 本身没有城市字段，要按两端的 places
@@ -215,20 +306,45 @@ func (f Filter) movementsWhere(off int) *where {
 			AND (` + strings.Join(flags, " OR ") + `))`)
 	}
 	if len(f.Regions) > 0 {
-		var prov, city, dist []string
+		// 每一段都要**两端分别**过同一套判定，与地图轨迹图层保持一致：apiTrack 就是
+		// 用 regionSQL 拼出 pf / pt 两段 AND 起来的。只按「任一端命中」的话，白名单下
+		// 同一段里程在图层里画不出来、却算进了总里程（黑名单下两种写法恰好等价，
+		// 所以这个洞只在白名单时露出来）。
+		phs := make([]string, 0, len(f.Regions))
 		for _, r := range f.Regions {
-			prov = append(prov, w.ph(r))
+			phs = append(phs, w.ph(r))
-			city = append(city, w.ph(r))
-			dist = append(dist, w.ph(r))
 		}
-		expr := `EXISTS (SELECT 1 FROM places pmv
+		endpoint := func(col string) string {
-			WHERE pmv.id IN (movements.from_place_id, movements.to_place_id)
+			var conds []string
-			AND (pmv.province IN (` + strings.Join(prov, ",") + `) OR pmv.city IN (` +
+			for _, ph := range phs {
-			strings.Join(city, ",") + `) OR pmv.district IN (` + strings.Join(dist, ",") + `)))`
+				// 必须 COALESCE：district 常为 NULL，NULL = 'x' 得 NULL，
-		if f.RegionsExclude {
+				// 黑名单的 NOT (...) 也跟着变 NULL，整行被误删（regionSQL 同样处理）。
-			expr = "NOT " + expr
+				conds = append(conds, "COALESCE(pmv.province,'') = "+ph,
+					"COALESCE(pmv.city,'') = "+ph, "COALESCE(pmv.district,'') = "+ph)
+			}
+			expr := "EXISTS (SELECT 1 FROM places pmv WHERE pmv.id = movements." + col +
+				" AND (" + strings.Join(conds, " OR ") + "))"
+			if f.RegionsExclude {
+				return "NOT " + expr
+			}
+			return expr
 		}
-		w.conds = append(w.conds, expr)
+		w.conds = append(w.conds, endpoint("from_place_id"), endpoint("to_place_id"))
+	}
+	// 活动 / 城市 / 省份 / 标签 / 最短停留 / 关键词这几档只长在到访上，位移得靠两端
+	// 的到访带过来，否则筛完之后「到访数变了、里程和出行数还是全量」。
+	// 判定用「**任一端**命中即算」——和上面区域那条同一个理由：位移横跨两个地点，
+	// 改成「两端都得命中」会让城际段在每张筛选视图里都消失，而「任一端」才和到访列表
+	// 对得上（一次通勤的起点和终点，在两边各自的视图里都该看得到）。
+	// 两端都关联不到到访的位移（真机有 31/791 这种）在带这类筛选时不参与：
+	// 它们没法证明自己落在筛选范围内。
+	if f.hasMovementVisitConds() {
+		vc := f.movementVisitConds(len(w.args))
+		w.conds = append(w.conds, `EXISTS (
+			SELECT 1 FROM visits v WHERE v.dataset_id = movements.dataset_id
+			AND (v.src_pk = movements.from_visit_src OR v.src_pk = movements.to_visit_src)
+			AND `+vc.expr()+`)`)
+		w.args = append(w.args, vc.args...)
 	}
 	return w
 }
@@ -654,23 +770,31 @@ type Place struct {
 	Down    int
 }
 
-const placeCols = `p.id, COALESCE(p.name,''), COALESCE(p.poi_category,''), COALESCE(p.lat,0), COALESCE(p.lon,0),
+// 每个相关子查询都带上 dataset_id = p.dataset_id：它是 idx_visits_place(dataset_id, place_id)
+// 的前导列，缺了它每次循环都要为库里每个 dataset 各下一次索引（实测 Buffer 命中 23737 → 5669）。
+// 谓词本身冗余（到访与所属地点的 dataset 必然相同），纯粹是给计划器的。
+var placeCols = `p.id, COALESCE(p.name,''), COALESCE(p.poi_category,''), COALESCE(p.lat,0), COALESCE(p.lon,0),
 	COALESCE(p.city,''), COALESCE(p.province,''), COALESCE(p.district,''), COALESCE(p.timezone,''),
-	p.visit_count, p.dwell_minutes, p.first_visit_at, p.last_visit_at,
+	p.visit_count, p.dwell_minutes,
+	-- 首末到访这两列**存的是全量**（last_visit_at 会写成导出包里的 ZLOCATION.ZLASTARRIVALDATE_，
+	-- 不能在库里改口径）。于是「到访数按访客口径、日期按全量」会凑出「0 次却有最近到访」这种
+	-- 自相矛盾的行（实测数据集 9 有 4 个地点名下只剩已并入 / 子段到访），这里按可见到访数兜一下。
+	CASE WHEN p.visit_count > 0 THEN p.first_visit_at END,
+	CASE WHEN p.visit_count > 0 THEN p.last_visit_at END,
 	COALESCE((SELECT a.name FROM visits v2 JOIN activities a ON a.id=v2.activity_id
-		WHERE v2.place_id=p.id GROUP BY a.name ORDER BY count(*) DESC LIMIT 1),''),
+		WHERE v2.place_id=p.id AND v2.dataset_id=p.dataset_id AND ` + SoloVisitSQL("v2") + ` GROUP BY a.name ORDER BY count(*) DESC LIMIT 1),''),
 	COALESCE((SELECT a.color FROM visits v2 JOIN activities a ON a.id=v2.activity_id
-		WHERE v2.place_id=p.id GROUP BY a.color ORDER BY count(*) DESC LIMIT 1),''),
+		WHERE v2.place_id=p.id AND v2.dataset_id=p.dataset_id AND ` + SoloVisitSQL("v2") + ` GROUP BY a.color ORDER BY count(*) DESC LIMIT 1),''),
 	COALESCE((SELECT a.icon FROM visits v2 JOIN activities a ON a.id=v2.activity_id
-		WHERE v2.place_id=p.id GROUP BY a.icon ORDER BY count(*) DESC LIMIT 1),''),
+		WHERE v2.place_id=p.id AND v2.dataset_id=p.dataset_id AND ` + SoloVisitSQL("v2") + ` GROUP BY a.icon ORDER BY count(*) DESC LIMIT 1),''),
-	EXISTS (SELECT 1 FROM visits v3 WHERE v3.place_id=p.id AND v3.is_home),
+	EXISTS (SELECT 1 FROM visits v3 WHERE v3.place_id=p.id AND v3.dataset_id=p.dataset_id AND v3.is_home AND ` + SoloVisitSQL("v3") + `),
-	EXISTS (SELECT 1 FROM visits v4 WHERE v4.place_id=p.id AND v4.is_work),
+	EXISTS (SELECT 1 FROM visits v4 WHERE v4.place_id=p.id AND v4.dataset_id=p.dataset_id AND v4.is_work AND ` + SoloVisitSQL("v4") + `),
 	p.src_pk,
 	EXISTS (SELECT 1 FROM place_images pi WHERE pi.place_key =
 		to_char(p.lat,'FM999990.000000')||'|'||to_char(p.lon,'FM999990.000000'))`
 
 // PlaceCols 与 ScanPlace 配对，供包外构造只取单个地点的查询。
-const PlaceCols = placeCols
+var PlaceCols = placeCols
 
 func scanPlace(s interface{ Scan(...any) error }) (Place, error) {
 	var p Place
@@ -707,15 +831,8 @@ func (d DB) Places(ctx context.Context, f Filter, sortBy string, limit, offset i
 	}
 
 	args := append([]any{f.DatasetID}, inner.args...)
+	// verdict 条件已经在 visitsWhere 里，这里不用再补一份（补了就是同一个 EXISTS 跑两遍）。
 	base := `FROM places p WHERE p.dataset_id = $1 AND EXISTS (SELECT 1 FROM visits v WHERE ` + inner.expr() + `)`
-	if f.Verdict != 0 {
-		// 结论挂坐标键（换数据集也要跟得住），按本数据集的地点圈定范围；
-		// 占位符接在内层条件之后。
-		args = append(args, f.Verdict)
-		base += fmt.Sprintf(` AND EXISTS (SELECT 1 FROM place_votes pv WHERE pv.place_key =
-			to_char(p.lat,'FM999990.000000')||'|'||to_char(p.lon,'FM999990.000000')
-			AND pv.verdict = $%d)`, len(args))
-	}
 	q := `SELECT ` + placeCols + ` ` + base + ` ORDER BY ` + order + fmt.Sprintf(` LIMIT %d OFFSET %d`, limit, offset)
 
 	rows, err := d.QueryContext(ctx, q, args...)
@@ -872,7 +989,8 @@ func (d DB) VisitsByPlace(ctx context.Context, datasetID, placeID int64, limit i
 	q := `SELECT ` + visitCols + ` FROM visits v
 		LEFT JOIN places p ON p.id = v.place_id
 		LEFT JOIN activities a ON a.id = v.activity_id
-		WHERE v.dataset_id=$1 AND v.place_id=$2 ORDER BY v.arrival DESC LIMIT ` + fmt.Sprint(limit)
+		WHERE v.dataset_id=$1 AND v.place_id=$2 AND ` + SoloVisitSQL("v") +
+		` ORDER BY v.arrival DESC LIMIT ` + fmt.Sprint(limit)
 	rows, err := d.QueryContext(ctx, q, datasetID, placeID)
 	if err != nil {
 		return nil, err
@@ -893,7 +1011,8 @@ func (d DB) Bookmarked(ctx context.Context, datasetID int64, limit int) ([]Visit
 	q := `SELECT ` + visitCols + ` FROM visits v
 		LEFT JOIN places p ON p.id = v.place_id
 		LEFT JOIN activities a ON a.id = v.activity_id
-		WHERE v.dataset_id=$1 AND v.bookmarked ORDER BY v.arrival DESC LIMIT ` + fmt.Sprint(limit)
+		WHERE v.dataset_id=$1 AND v.bookmarked AND ` + SoloVisitSQL("v") +
+		` ORDER BY v.arrival DESC LIMIT ` + fmt.Sprint(limit)
 	rows, err := d.QueryContext(ctx, q, datasetID)
 	if err != nil {
 		return nil, err

internal/stats/stats_test.go

@@ -43,9 +43,16 @@ func TestOverviewMatchesManualSQL(t *testing.T) {
 	}
 	var places, cities, days, visits, movements int
 	var dist float64
+	// 判据按**访客口径**在手写 SQL 里独立写一遍（不复用 stats.SoloVisitSQL）：已并入 / 子段的
+	// 到访在 app 里既不算次数也不占天数——独立写一份，正好在口径写错时把它抓出来。
+	// 位移/里程那两行**不**加这个条件：那段路是真的发生过的，收口只管到访本身。
 	if err := db.QueryRow(`SELECT count(DISTINCT v.place_id), count(DISTINCT p.city),
 			count(DISTINCT (v.arrival AT TIME ZONE 'Asia/Shanghai')::date), count(*)
-		FROM visits v LEFT JOIN places p ON p.id = v.place_id WHERE v.dataset_id=$1`, dsID).
+		FROM visits v LEFT JOIN places p ON p.id = v.place_id
+		WHERE v.dataset_id=$1
+		  AND NOT EXISTS (SELECT 1 FROM entity_raw er
+			WHERE er.dataset_id=v.dataset_id AND er.entity='ZVISIT' AND er.src_pk=v.src_pk
+			  AND (er.raw->>'ZMERGEDTO' IS NOT NULL OR er.raw->>'ZPARENT' IS NOT NULL))`, dsID).
 		Scan(&places, &cities, &days, &visits); err != nil {
 		t.Fatal(err)
 	}
@@ -250,3 +257,75 @@ func TestWeatherStatsRespectsFilter(t *testing.T) {
 		t.Errorf("按城市筛选后行数（%d）不该等于全量（%d）", sum(byCity), wantTotal)
 	}
 }
+
+// TestVisitSideFiltersApplyToMovements 钉住「按活动 / 城市 / 标签 / 关键词筛选时，
+// 里程与出行次数也要跟着变」。
+//
+// movements 自己只有两端到访，没有活动、城市这些字段。曾经 movementsWhere 只认
+// dataset / 时间 / 家工作 / 区域，于是筛完之后「到访数变了、里程还是全量」——
+// 区域那档犯过一次（见上一个测试），这几档是同一个洞没堵完。
+func TestVisitSideFiltersApplyToMovements(t *testing.T) {
+	db, dsID := setup(t)
+	d := stats.DB{DB: db}
+	ctx := context.Background()
+
+	// 挑一个真有到访的活动，且它只覆盖一部分到访（否则筛选前后一样，测不出东西）
+	var actID int64
+	if err := db.QueryRow(`SELECT activity_id FROM visits
+		WHERE dataset_id=$1 AND activity_id IS NOT NULL
+		GROUP BY activity_id ORDER BY count(*) DESC LIMIT 1`, dsID).Scan(&actID); err != nil {
+		t.Skipf("没有带活动的到访：%v", err)
+	}
+	all, err := d.Overview(ctx, stats.Filter{DatasetID: dsID})
+	if err != nil {
+		t.Fatal(err)
+	}
+	one, err := d.Overview(ctx, stats.Filter{DatasetID: dsID, ActivityIDs: []int64{actID}})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if one.Visits >= all.Visits {
+		t.Skipf("活动 %d 覆盖了全部到访，换个数据集再测", actID)
+	}
+
+	// 手写 SQL：两端**任一端**的到访属于该活动的位移
+	var dist float64
+	var n int
+	if err := db.QueryRow(`SELECT COALESCE(sum(m.distance_km),0), count(*) FROM movements m
+		WHERE m.dataset_id=$1 AND EXISTS (SELECT 1 FROM visits v
+			WHERE v.dataset_id=m.dataset_id AND v.activity_id=$2
+			AND (v.src_pk=m.from_visit_src OR v.src_pk=m.to_visit_src))`,
+		dsID, actID).Scan(&dist, &n); err != nil {
+		t.Fatal(err)
+	}
+	if diff := one.DistanceKm - dist; diff > 0.01 || diff < -0.01 {
+		t.Errorf("按活动筛选后里程 %.4f，手写 SQL %.4f（筛选没作用到里程上？）", one.DistanceKm, dist)
+	}
+	if one.Movements != n {
+		t.Errorf("按活动筛选后出行次数 %d，手写 SQL %d", one.Movements, n)
+	}
+
+	// 同一条路径也覆盖城市：movementVisitConds 里所有维度共用一个 EXISTS
+	var city string
+	if err := db.QueryRow(`SELECT p.city FROM visits v JOIN places p ON p.id=v.place_id
+		WHERE v.dataset_id=$1 AND p.city IS NOT NULL AND p.city<>''
+		GROUP BY 1 ORDER BY count(*) DESC LIMIT 1`, dsID).Scan(&city); err != nil {
+		t.Skipf("没有带城市的到访：%v", err)
+	}
+	byCity, err := d.Overview(ctx, stats.Filter{DatasetID: dsID, City: city})
+	if err != nil {
+		t.Fatal(err)
+	}
+	var cityDist float64
+	if err := db.QueryRow(`SELECT COALESCE(sum(m.distance_km),0) FROM movements m
+		WHERE m.dataset_id=$1 AND EXISTS (SELECT 1 FROM visits v
+			WHERE v.dataset_id=m.dataset_id
+			AND EXISTS (SELECT 1 FROM places px WHERE px.id=v.place_id AND px.city=$2)
+			AND (v.src_pk=m.from_visit_src OR v.src_pk=m.to_visit_src))`,
+		dsID, city).Scan(&cityDist); err != nil {
+		t.Fatal(err)
+	}
+	if diff := byCity.DistanceKm - cityDist; diff > 0.01 || diff < -0.01 {
+		t.Errorf("按城市「%s」筛选后里程 %.4f，手写 SQL %.4f", city, byCity.DistanceKm, cityDist)
+	}
+}

internal/stats/verdict_scope_test.go

@@ -0,0 +1,355 @@
+package stats_test
+
+import (
+	"context"
+	"database/sql"
+	"fmt"
+	"os"
+	"testing"
+	"time"
+
+	_ "github.com/jackc/pgx/v5/stdlib"
+
+	"rond-with-you/internal/stats"
+)
+
+// verdictFixture 是一套**自造**的数据集，坐标故意取在远端（89.9 / 100.x），
+// 与任何真实备份、任何测试夹具都不会重合。
+//
+// 为什么不复用 setup(t) 的活跃数据集：`place_key` 是**坐标键**，而所有夹具导入的都是
+// 同一份备份、坐标完全相同。往活跃数据集上写 place_votes 会顺着坐标键漏进并行跑的
+// 其它包（internal/web 有用例要读某个地点的 verdict），把别人的断言弄脏。
+// 这里只建自己的数据集，并且**不碰 is_active**——改它会让并行跑的统计用例选到空库。
+type verdictFixture struct {
+	db         *sql.DB
+	ds         int64
+	uid        int64
+	p1, p2, p3 int64 // p1/p2 打「推荐」，p3 不打
+}
+
+func newVerdictFixture(t *testing.T) *verdictFixture {
+	t.Helper()
+	dsn := os.Getenv("ROND_DSN")
+	if dsn == "" {
+		t.Skip("未设置 ROND_DSN")
+	}
+	db, err := sql.Open("pgx", dsn)
+	if err != nil {
+		t.Fatal(err)
+	}
+	t.Cleanup(func() { db.Close() })
+	ctx := context.Background()
+
+	tag := fmt.Sprint(time.Now().UnixNano())
+	var uid int64
+	if err := db.QueryRowContext(ctx, `INSERT INTO users (username, password_hash, display_name)
+		VALUES ($1,'x','verdict-scope') RETURNING id`, "verdict-scope-"+tag).Scan(&uid); err != nil {
+		t.Fatalf("建临时账号失败: %v", err)
+	}
+	var ds int64
+	sha := fmt.Sprintf("%064x", time.Now().UnixNano())
+	if err := db.QueryRowContext(ctx, `INSERT INTO datasets (user_id, original_name, sha256, status)
+		VALUES ($1,'verdict-scope',$2,'done') RETURNING id`, uid, sha).Scan(&ds); err != nil {
+		t.Fatalf("建临时数据集失败: %v", err)
+	}
+	t.Cleanup(func() {
+		db.ExecContext(ctx, `DELETE FROM place_votes WHERE user_id=$1`, uid)
+		// 数据集级联带走 places / visits / movements / weather / activities
+		db.ExecContext(ctx, `DELETE FROM datasets WHERE id=$1`, ds)
+		db.ExecContext(ctx, `DELETE FROM users WHERE id=$1`, uid)
+	})
+
+	// 到访的到达时间固定写死，避免「今天」漂移导致天数/月份断言不稳
+	at := func(iso string) time.Time {
+		v, err := time.Parse(time.RFC3339, iso)
+		if err != nil {
+			t.Fatal(err)
+		}
+		return v
+	}
+	mkPlace := func(pk int, lat, lon float64, city, prov string) int64 {
+		t.Helper()
+		var id int64
+		if err := db.QueryRowContext(ctx, `INSERT INTO places
+			(dataset_id, src_pk, name, lat, lon, city, province)
+			VALUES ($1,$2,$3,$4,$5,$6,$7) RETURNING id`,
+			ds, pk, fmt.Sprintf("P%d", pk), lat, lon, city, prov).Scan(&id); err != nil {
+			t.Fatalf("建地点失败: %v", err)
+		}
+		return id
+	}
+	f := &verdictFixture{db: db, ds: ds, uid: uid}
+	f.p1 = mkPlace(1, 89.900001, 100.100001, "CityA", "ProvA")
+	f.p2 = mkPlace(2, 89.900002, 100.100002, "CityB", "ProvA")
+	f.p3 = mkPlace(3, 89.900003, 100.100003, "CityC", "ProvB")
+
+	var actID int64
+	if err := db.QueryRowContext(ctx, `INSERT INTO activities (dataset_id, src_pk, name)
+		VALUES ($1,1,'家') RETURNING id`, ds).Scan(&actID); err != nil {
+		t.Fatalf("建活动失败: %v", err)
+	}
+	mkVisit := func(pk int, placeID int64, iso string, dur int) {
+		t.Helper()
+		if _, err := db.ExecContext(ctx, `INSERT INTO visits
+			(dataset_id, src_pk, place_id, activity_id, arrival, duration_min)
+			VALUES ($1,$2,$3,$4,$5,$6)`, ds, pk, placeID, actID, at(iso), dur); err != nil {
+			t.Fatalf("建到访失败: %v", err)
+		}
+	}
+	mkVisit(101, f.p1, "2026-01-05T10:00:00+08:00", 60)
+	mkVisit(102, f.p1, "2026-01-06T10:00:00+08:00", 30)
+	mkVisit(103, f.p2, "2026-02-10T10:00:00+08:00", 20)
+	mkVisit(104, f.p3, "2026-02-11T10:00:00+08:00", 10)
+
+	mkMove := func(pk, from, to int, placeID int64, km float64, iso string) {
+		t.Helper()
+		if _, err := db.ExecContext(ctx, `INSERT INTO movements
+			(dataset_id, src_pk, from_visit_src, to_visit_src, from_place_id, to_place_id,
+			 started_at, ended_at, distance_km)
+			VALUES ($1,$2,$3,$4,$5,$5,$6,$6,$7)`, ds, pk, from, to, placeID, at(iso), km); err != nil {
+			t.Fatalf("建位移失败: %v", err)
+		}
+	}
+	// m1 跨 p1→p2（两端都在 S 内）· m2 跨 p3→p1（任一端在 S 内就该算）· m3 两端都在 p3（该被排除）
+	mkMove(201, 101, 103, f.p1, 5.0, "2026-01-07T10:00:00+08:00")
+	mkMove(202, 104, 101, f.p1, 7.0, "2026-02-12T10:00:00+08:00")
+	mkMove(203, 104, 104, f.p3, 11.0, "2026-02-13T10:00:00+08:00")
+
+	mkWeather := func(pk, visitSrc int, iso, cond string) {
+		t.Helper()
+		if _, err := db.ExecContext(ctx, `INSERT INTO weather
+			(dataset_id, src_pk, visit_src, at, condition) VALUES ($1,$2,$3,$4,$5)`,
+			ds, pk, visitSrc, at(iso), cond); err != nil {
+			t.Fatalf("建天气失败: %v", err)
+		}
+	}
+	mkWeather(301, 101, "2026-01-05T10:00:00+08:00", "Clear")
+	mkWeather(302, 104, "2026-02-11T10:00:00+08:00", "Cloudy")
+
+	// 只给 p1 / p2 打「推荐」。键用 Go 侧的 %.6f —— 顺便验证它与 SQL 的
+	// to_char(...,'FM999990.000000') 逐位一致（不一致这里就查不到，断言会红）。
+	mark := func(placeID int64, lat, lon float64, verdict int) {
+		t.Helper()
+		key := fmt.Sprintf("%.6f|%.6f", lat, lon)
+		if _, err := db.ExecContext(ctx, `INSERT INTO place_votes
+			(user_id, place_key, dataset_id, src_pk, verdict) VALUES ($1,$2,$3,1,$4)`,
+			uid, key, ds, verdict); err != nil {
+			t.Fatalf("写 verdict（键 %s）失败: %v", key, err)
+		}
+	}
+	mark(f.p1, 89.900001, 100.100001, 1)
+	mark(f.p2, 89.900002, 100.100002, 1)
+	return f
+}
+
+func (f *verdictFixture) filter(v int) stats.Filter {
+	return stats.Filter{DatasetID: f.ds, Verdict: v}
+}
+
+func sumBuckets(bs []stats.Bucket) int {
+	n := 0
+	for _, b := range bs {
+		n += b.Count
+	}
+	return n
+}
+
+// D7 回归：verdict 必须作用到**每一个**统计口径上。
+//
+// 用户已定口径「全域一致」——筛选条上看得见的这枚条件，页面上所有数字都得跟着变，
+// 否则就是「点没了、里程还在」这种自相矛盾的视图（P1-3 是同一类问题的另一个面）。
+//
+// 判据用**不可能存在的结论值 99**：没有任何地点会被它匹配，于是**每一个**统计都必须退回
+// 空集。任何一处漏了下推（地图点、城市/省份、类型计数、概览、里程/出行、天气、时间分布）
+// 都会在这一条上暴露成一个非零数——比逐个统计写断言更彻底。
+func TestVerdictScopesEveryStatistic(t *testing.T) {
+	f := newVerdictFixture(t)
+	ctx := context.Background()
+	d := stats.DB{DB: f.db}
+
+	// 先确认夹具本身有数据（否则「为空」是废话）
+	all, err := d.Overview(ctx, f.filter(0))
+	if err != nil {
+		t.Fatalf("Overview(无筛选) 失败: %v", err)
+	}
+	if all.Visits != 4 || all.Places != 3 || all.Movements != 3 {
+		t.Fatalf("夹具数据不对：visits=%d places=%d movements=%d，期望 4/3/3", all.Visits, all.Places, all.Movements)
+	}
+
+	// ① 不可能存在的结论 ⇒ 全域都该是空的
+	none := f.filter(99)
+	ov, err := d.Overview(ctx, none)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if ov != (stats.Overview{}) {
+		t.Errorf("Verdict=99 时 Overview 应当全零，实际 %+v", ov)
+	}
+	places, total, err := d.Places(ctx, none, "visits", 100, 0)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(places) != 0 || total != 0 {
+		t.Errorf("Verdict=99 时地点列表应当为空，实际 %d 条（total=%d）", len(places), total)
+	}
+	mapped, err := d.MapPlaces(ctx, none, 100)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(mapped) != 0 {
+		t.Errorf("Verdict=99 时地图点应当为空，实际 %d 个", len(mapped))
+	}
+	if rows, n, err := d.Visits(ctx, none, 100, 0, "desc"); err != nil || len(rows) != 0 || n != 0 {
+		t.Errorf("Verdict=99 时到访列表应当为空，实际 %d 条（total=%d, err=%v）", len(rows), n, err)
+	}
+	if as, err := d.ActivityStats(ctx, none); err != nil || len(as) != 0 {
+		t.Errorf("Verdict=99 时类型分布应当为空，实际 %d 组（err=%v）", len(as), err)
+	}
+	if ac, err := d.ActivityCounts(ctx, none); err != nil || len(ac) != 0 {
+		t.Errorf("Verdict=99 时类型计数应当为空，实际 %d 项（err=%v）", len(ac), err)
+	}
+	if cs, err := d.CityStats(ctx, none, 10); err != nil || len(cs) != 0 {
+		t.Errorf("Verdict=99 时城市分布应当为空，实际 %d 组（err=%v）", len(cs), err)
+	}
+	if ps, err := d.ProvinceStats(ctx, none); err != nil || len(ps) != 0 {
+		t.Errorf("Verdict=99 时省份分布应当为空，实际 %d 组（err=%v）", len(ps), err)
+	}
+	if ws, err := d.WeatherStats(ctx, none); err != nil || len(ws) != 0 {
+		t.Errorf("Verdict=99 时天气汇总应当为空，实际 %d 组（err=%v）", len(ws), err)
+	}
+	if ms, err := d.Monthly(ctx, none); err != nil || sumBuckets(ms) != 0 {
+		t.Errorf("Verdict=99 时月度分布应当为空，实际 %d 次（err=%v）", sumBuckets(ms), err)
+	}
+	if cal, err := d.Calendar(ctx, none); err != nil || len(cal) != 0 {
+		t.Errorf("Verdict=99 时日历应当为空，实际 %d 天（err=%v）", len(cal), err)
+	}
+	if bs, err := d.Hourly(ctx, none); err != nil || sumBuckets(bs) != 0 {
+		t.Errorf("Verdict=99 时小时分布应当为空，实际 %d 次（err=%v）", sumBuckets(bs), err)
+	}
+	if bs, err := d.Weekday(ctx, none); err != nil || sumBuckets(bs) != 0 {
+		t.Errorf("Verdict=99 时星期分布应当为空，实际 %d 次（err=%v）", sumBuckets(bs), err)
+	}
+	if ts, err := d.TransportStats(ctx, none); err != nil || len(ts) != 0 {
+		t.Errorf("Verdict=99 时出行方式应当为空，实际 %d 组（err=%v）", len(ts), err)
+	}
+}
+
+// D7 正向：只给 p1/p2 打「推荐」时，每个口径都必须**恰好**收窄到它们名下的数据。
+// 上一条证明「不会漏下推」，这一条证明「下推之后选对了」。
+func TestVerdictNarrowsEveryStatisticToMarkedPlaces(t *testing.T) {
+	f := newVerdictFixture(t)
+	ctx := context.Background()
+	d := stats.DB{DB: f.db}
+	on := f.filter(1)
+
+	// S = {p1, p2}：3 条到访（60+30+20 分钟）、2 个地点、2 个城市、1 个省、3 个不同日期
+	ov, err := d.Overview(ctx, on)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if ov.Visits != 3 || ov.Places != 2 || ov.Cities != 2 || ov.Provinces != 1 || ov.Days != 3 {
+		t.Errorf("Overview 收窄不对：visits=%d places=%d cities=%d provinces=%d days=%d，期望 3/2/2/1/3",
+			ov.Visits, ov.Places, ov.Cities, ov.Provinces, ov.Days)
+	}
+	if ov.DwellMin != 110 {
+		t.Errorf("停留 %d 分钟，期望 110", ov.DwellMin)
+	}
+	// 位移按「任一端在 S 内」：m1(p1→p2) 与 m2(p3→p1) 算，两端都在 p3 的 m3 不算
+	if ov.Movements != 2 || ov.DistanceKm < 11.99 || ov.DistanceKm > 12.01 {
+		t.Errorf("位移收窄不对：movements=%d distance=%.2f，期望 2 / 12.00", ov.Movements, ov.DistanceKm)
+	}
+
+	places, total, err := d.Places(ctx, on, "visits", 100, 0)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if total != 2 || len(places) != 2 {
+		t.Errorf("地点列表应当只剩 2 个，实际 %d 条（total=%d）", len(places), total)
+	}
+	got := map[int64]bool{}
+	for _, p := range places {
+		got[p.ID] = true
+	}
+	if !got[f.p1] || !got[f.p2] || got[f.p3] {
+		t.Errorf("地点列表选错：%v（应当只有 p1/p2）", got)
+	}
+
+	mapped, err := d.MapPlaces(ctx, on, 100)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(mapped) != 2 {
+		t.Errorf("地图点应当只剩 2 个，实际 %d 个（这一处以前完全没认 verdict）", len(mapped))
+	}
+
+	// 每个「按到访计数」的口径都必须与 Overview.Visits 对得上
+	if ac, err := d.ActivityCounts(ctx, on); err != nil {
+		t.Fatal(err)
+	} else {
+		n := 0
+		for _, c := range ac {
+			n += c
+		}
+		if n != ov.Visits {
+			t.Errorf("类型计数合计 %d，与到访数 %d 不符", n, ov.Visits)
+		}
+	}
+	if as, err := d.ActivityStats(ctx, on); err != nil {
+		t.Fatal(err)
+	} else {
+		n := 0
+		for _, a := range as {
+			n += a.Count
+		}
+		if n != ov.Visits {
+			t.Errorf("类型分布合计 %d，与到访数 %d 不符", n, ov.Visits)
+		}
+	}
+	if cs, err := d.CityStats(ctx, on, 10); err != nil {
+		t.Fatal(err)
+	} else {
+		n := 0
+		for _, c := range cs {
+			n += c.Count
+		}
+		if n != ov.Visits || len(cs) != 2 {
+			t.Errorf("城市分布应当 2 组共 %d 次，实际 %d 组共 %d 次", ov.Visits, len(cs), n)
+		}
+	}
+	if ps, err := d.ProvinceStats(ctx, on); err != nil {
+		t.Fatal(err)
+	} else {
+		n := 0
+		for _, p := range ps {
+			n += p.Count
+		}
+		if n != ov.Visits || len(ps) != 1 || ps[0].Province != "ProvA" {
+			t.Errorf("省份分布应当只有 ProvA 共 %d 次，实际 %d 组共 %d 次", ov.Visits, len(ps), n)
+		}
+	}
+	if ms, err := d.Monthly(ctx, on); err != nil || sumBuckets(ms) != ov.Visits {
+		t.Errorf("月度分布合计 %d，与到访数 %d 不符（err=%v）", sumBuckets(ms), ov.Visits, err)
+	}
+	if bs, err := d.Hourly(ctx, on); err != nil || sumBuckets(bs) != ov.Visits {
+		t.Errorf("小时分布合计不对（err=%v）", err)
+	}
+	if bs, err := d.Weekday(ctx, on); err != nil || sumBuckets(bs) != ov.Visits {
+		t.Errorf("星期分布合计不对（err=%v）", err)
+	}
+	// 天气挂在到访上：只有 p1 那条该留下
+	if ws, err := d.WeatherStats(ctx, on); err != nil {
+		t.Fatal(err)
+	} else {
+		n := 0
+		for _, w := range ws {
+			n += w.Count
+		}
+		if n != 1 {
+			t.Errorf("天气应当只剩 1 条（挂在 p1 上那条），实际 %d 条", n)
+		}
+	}
+	// 到访列表也要跟着收窄
+	if rows, n, err := d.Visits(ctx, on, 100, 0, "desc"); err != nil || len(rows) != 3 || n != 3 {
+		t.Errorf("到访列表应当只剩 3 条，实际 %d 条（total=%d, err=%v）", len(rows), n, err)
+	}
+}

internal/votes/votes.go

@@ -87,6 +87,32 @@ func (s *Store) SaveVerdict(ctx context.Context, userID, datasetID int64, srcPK,
 	return err
 }
 
+// SaveVerdictBulk 一次给多个地点设置（verdict=1/-1）或取消（verdict=0）站长结论，
+// 语义同逐条 SaveVerdict，但一条语句代替 N 次往返。
+func (s *Store) SaveVerdictBulk(ctx context.Context, userID, datasetID int64, srcPKs []int64, verdict int) error {
+	if len(srcPKs) == 0 {
+		return nil
+	}
+	if verdict == 0 {
+		_, err := s.DB.ExecContext(ctx, `DELETE FROM place_votes v USING places p
+			WHERE v.user_id=$1 AND p.dataset_id=$2 AND p.src_pk = ANY($3::bigint[])
+			  AND v.place_key = `+placeKeyExpr, userID, datasetID, srcPKs)
+		return err
+	}
+	// 先按坐标键算出每条地点该挂在哪，找不到该地点就什么也不写
+	_, err := s.DB.ExecContext(ctx, `INSERT INTO place_votes
+			(user_id, place_key, dataset_id, src_pk, verdict, updated_at)
+		SELECT $1, `+placeKeyExpr+`, $2, p.src_pk, $4, now()
+		FROM places p
+		WHERE p.dataset_id=$2 AND p.src_pk = ANY($3::bigint[])
+		  AND p.lat IS NOT NULL AND p.lon IS NOT NULL
+		ON CONFLICT (user_id, place_key) DO UPDATE SET
+			verdict=EXCLUDED.verdict, dataset_id=EXCLUDED.dataset_id,
+			src_pk=EXCLUDED.src_pk, updated_at=now()`,
+		userID, datasetID, srcPKs, verdict)
+	return err
+}
+
 // placeKeyOf 把某个数据集里的地点编号换算成坐标键——访客票也是挂在坐标上的，
 // 换数据集之后票仍然跟着同一个地点。
 func (s *Store) placeKeyOf(ctx context.Context, datasetID int64, srcPK int) (string, error) {
@@ -134,6 +160,46 @@ func (s *Store) Tally(ctx context.Context, datasetID int64, srcPK int) (Tally, e
 	return t, err
 }
 
+// VotedPlace 是「访客票榜」上的一条：某个地点收到的 👍/👎 票数。
+type VotedPlace struct {
+	ID    int64
+	SrcPK int
+	Name  string
+	City  string
+	Up    int
+	Down  int
+}
+
+// TopVisitorVoted 按访客票数排地点榜：vote 传 1 取「👍 最多」、传 -1 取「👎 最多」。
+//
+// 只算**至少有一票**的那个方向（HAVING），否则「0 票」的地点会把榜单塞满；
+// 同票数时按到访次数、再按编号排，保证顺序稳定（不同页面刷新之间不会跳来跳去）。
+//
+// 票按坐标键挂（换数据集仍跟着同一地点），所以得 join 回当前数据集的地点才定位得到。
+func (s *Store) TopVisitorVoted(ctx context.Context, datasetID int64, vote, limit int) ([]VotedPlace, error) {
+	rows, err := s.DB.QueryContext(ctx, `SELECT p.id, p.src_pk, COALESCE(p.name,''), COALESCE(p.city,''),
+			count(*) FILTER (WHERE vv.vote=1), count(*) FILTER (WHERE vv.vote=-1)
+		FROM places p JOIN place_visitor_votes vv ON vv.place_key = `+placeKeyExpr+`
+		WHERE p.dataset_id=$1 AND p.lat IS NOT NULL AND p.lon IS NOT NULL
+		GROUP BY p.id
+		HAVING count(*) FILTER (WHERE vv.vote=$2) > 0
+		ORDER BY count(*) FILTER (WHERE vv.vote=$2) DESC, p.visit_count DESC, p.id
+		LIMIT $3`, datasetID, vote, limit)
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+	var out []VotedPlace
+	for rows.Next() {
+		var vp VotedPlace
+		if err := rows.Scan(&vp.ID, &vp.SrcPK, &vp.Name, &vp.City, &vp.Up, &vp.Down); err != nil {
+			return nil, err
+		}
+		out = append(out, vp)
+	}
+	return out, rows.Err()
+}
+
 // VoterAll 返回该访客投过的全部票：src_pk -> vote，供地图一次性标注「我投的」。
 func (s *Store) VoterAll(ctx context.Context, datasetID int64, voterKey string) (map[int]int, error) {
 	out := map[int]int{}

internal/web/admin_notes_bulk_test.go

@@ -0,0 +1,108 @@
+package web
+
+import (
+	"net/http"
+	"net/http/httptest"
+	"net/url"
+	"os"
+	"strconv"
+	"strings"
+	"testing"
+)
+
+// adminNotesBulk 必须走批量语句。
+//
+// 旧实现是 `for _, id := range ids` 里逐条 Delete/SetNote/SaveVerdict：勾 50 个地点就是
+// 50（清空是 100）次数据库往返，在 1C1G 的机器上体感很明显。这条守卫钉住「不许退回逐条循环」。
+func TestAdminNotesBulkUsesBulkStatements(t *testing.T) {
+	b, err := os.ReadFile(pkgFile(t, "handlers_admin.go"))
+	if err != nil {
+		t.Fatalf("读取 handlers_admin.go 失败: %v", err)
+	}
+	fn := funcBody(string(b), "func (s *Server) adminNotesBulk(")
+	if fn == "" {
+		t.Fatal("在 handlers_admin.go 里找不到 adminNotesBulk（写法变了，这条守卫就失效了）")
+	}
+	for _, banned := range []string{"s.notes.Delete(", "s.notes.SetNote(", "s.votes.SaveVerdict("} {
+		if strings.Contains(fn, banned) {
+			t.Errorf("adminNotesBulk 不该再逐条调用 %s —— 应改用对应的 *Bulk 方法", banned)
+		}
+	}
+	for _, want := range []string{"s.notes.DeleteBulk(", "s.notes.SetNoteBulk(", "s.votes.SaveVerdictBulk("} {
+		if !strings.Contains(fn, want) {
+			t.Errorf("adminNotesBulk 未改用批量方法 %s", want)
+		}
+	}
+}
+
+// 批量勾选必须真的作用到**每一个**被勾的地点（不是只改第一条）。
+func TestAdminNotesBulkAppliesToEveryCheckedPlace(t *testing.T) {
+	f := newMovementFixture(t)
+	uid := userFrom(f.ctx).ID
+	pks := []int64{680001, 680002, 680003}
+
+	for i, pk := range pks {
+		if _, err := f.pg.ExecContext(f.ctx, `INSERT INTO places (dataset_id, src_pk, name, lat, lon)
+			VALUES ($1,$2,'批量点',$3,$4)`, f.dsID, pk,
+			30.0+float64(i)*0.01, 120.0+float64(i)*0.01); err != nil {
+			t.Fatalf("建地点失败: %v", err)
+		}
+	}
+	t.Cleanup(func() {
+		f.pg.ExecContext(f.ctx, `DELETE FROM place_notes WHERE user_id=$1`, uid)
+		f.pg.ExecContext(f.ctx, `DELETE FROM place_votes WHERE user_id=$1`, uid)
+		f.pg.ExecContext(f.ctx, `DELETE FROM places WHERE dataset_id=$1 AND src_pk = ANY($2::bigint[])`,
+			f.dsID, pks)
+	})
+
+	post := func(vals url.Values) {
+		t.Helper()
+		rec := httptest.NewRecorder()
+		req := httptest.NewRequest("POST", "/admin/notes/bulk", strings.NewReader(vals.Encode()))
+		req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
+		f.srv.adminNotesBulk(rec, req.WithContext(f.ctx))
+		if rec.Code != http.StatusSeeOther {
+			t.Fatalf("批量操作应跳回页面: code=%d body=%s", rec.Code, rec.Body.String())
+		}
+	}
+	bulk := func(action string, extra ...string) url.Values {
+		v := url.Values{"action": {action}}
+		for i := 0; i+1 < len(extra); i += 2 {
+			v.Set(extra[i], extra[i+1])
+		}
+		for _, pk := range pks {
+			v.Add("src_pk", strconv.FormatInt(pk, 10))
+		}
+		return v
+	}
+
+	// 先把三个地点都写上别名 + 备注
+	for _, pk := range pks {
+		if err := f.srv.notes.Save(f.ctx, uid, f.dsID, int(pk), "别名", "备注"); err != nil {
+			t.Fatalf("预置备注失败: %v", err)
+		}
+	}
+
+	post(bulk("verdict", "verdict", "1"))
+	if n := f.scalar(t, `SELECT count(*) FROM place_votes WHERE user_id=$1 AND verdict=1`, uid); n != len(pks) {
+		t.Fatalf("三个地点都该设上结论，实际 %d", n)
+	}
+
+	post(bulk("clear"))
+	if n := f.scalar(t, `SELECT count(*) FROM place_notes WHERE user_id=$1 AND note <> ''`, uid); n != 0 {
+		t.Fatalf("清空后不该还有手写备注，剩 %d 条", n)
+	}
+	if n := f.scalar(t, `SELECT count(*) FROM place_notes WHERE user_id=$1 AND alias='别名'`, uid); n != len(pks) {
+		t.Fatalf("清空备注要保留别名，实际剩 %d 条", n)
+	}
+
+	post(bulk("verdict", "verdict", "0"))
+	if n := f.scalar(t, `SELECT count(*) FROM place_votes WHERE user_id=$1`, uid); n != 0 {
+		t.Fatalf("取消结论后不该还有记录，剩 %d 条", n)
+	}
+
+	post(bulk("delete"))
+	if n := f.scalar(t, `SELECT count(*) FROM place_notes WHERE user_id=$1`, uid); n != 0 {
+		t.Fatalf("删除后不该还有备注，剩 %d 条", n)
+	}
+}

internal/web/agg_error_test.go

@@ -0,0 +1,81 @@
+package web
+
+import (
+	"context"
+	"os"
+	"regexp"
+	"strings"
+	"testing"
+)
+
+// TestAggHelpersPropagateErrors 是 D1 的行为守卫：四个「重算聚合 / 写标签」的辅助函数
+// 必须把数据库错误返回给调用方。
+//
+// 它们原先的签名是 `(isHome, isWork bool)` / 无返回值，Scan 的错误被直接丢掉——
+// 于是「查询炸了」和「查到了 false/false」在调用方看来一模一样：到访会被写得没有归属活动，
+// 计数会静默地停在旧值上。用一个已取消的 context 就能逼出这一层错误。
+func TestAggHelpersPropagateErrors(t *testing.T) {
+	f := newMovementFixture(t)
+
+	// 已取消的 context：任何一次 Query/Exec 都会立刻以 context.Canceled 返回。
+	ctx, cancel := context.WithCancel(f.ctx)
+	cancel()
+
+	if err := f.srv.refreshDatasetAgg(ctx, f.pg, f.dsID); err == nil {
+		t.Error("refreshDatasetAgg 吞掉了错误：ctx 已取消却返回 nil")
+	}
+	if err := f.srv.refreshPlaceAgg(ctx, f.pg, 1); err == nil {
+		t.Error("refreshPlaceAgg 吞掉了错误：ctx 已取消却返回 nil")
+	}
+	if err := f.srv.saveVisitTags(ctx, f.pg, f.dsID, 1, nil); err == nil {
+		t.Error("saveVisitTags 吞掉了错误：ctx 已取消却返回 nil")
+	}
+	if _, _, err := f.srv.activityFlags(ctx, f.pg, 1); err == nil {
+		t.Error("activityFlags 吞掉了错误：ctx 已取消却返回 nil")
+	}
+}
+
+// TestNoAggCallSiteSwallowsError 是 D1 的静态守卫：这三个辅助函数「返回 error」只有在
+// 每个调用点都接住它时才有意义。裸调用（语句形式、丢掉返回值）会随第一个新加的调用点回归，
+// 而且编译器不会拦——这里按行扫描源码，把裸调用钉死。
+func TestNoAggCallSiteSwallowsError(t *testing.T) {
+	// 只匹配「整行就是一次调用」的裸语句，合法写法前面一定还有 `if err := `、`return `、
+	// `logAggFailure(` 等前缀，因此不会被误伤。
+	bare := regexp.MustCompile(`^\s*s\.(refreshDatasetAgg|refreshPlaceAgg|saveVisitTags)\(`)
+
+	for _, name := range []string{
+		"handlers_edit.go",
+		"handlers_photos.go",
+		"fillup.go",
+	} {
+		path := pkgFile(t, name)
+		data, err := os.ReadFile(path)
+		if err != nil {
+			t.Fatalf("读 %s 失败: %v", path, err)
+		}
+		for i, line := range strings.Split(string(data), "\n") {
+			if bare.MatchString(line) {
+				t.Errorf("%s:%d 裸调用吞掉了 error：%s", name, i+1, strings.TrimSpace(line))
+			}
+		}
+	}
+}
+
+// TestAggHelpersHaveErrorReturn 钉住签名本身：如果谁把它们改回无返回值，
+// 上面两条用例会失去意义（编译期就不会再有 error 可断言）。
+func TestAggHelpersHaveErrorReturn(t *testing.T) {
+	data, err := os.ReadFile(pkgFile(t, "handlers_edit.go"))
+	if err != nil {
+		t.Fatalf("读 handlers_edit.go 失败: %v", err)
+	}
+	src := string(data)
+	for _, sig := range []string{
+		"func (s *Server) saveVisitTags(ctx context.Context, ex execer, datasetID int64, visitSrc int, tagIDs []string) error",
+		"func (s *Server) refreshPlaceAgg(ctx context.Context, ex execer, placeID int64) error",
+		"func (s *Server) refreshDatasetAgg(ctx context.Context, ex execer, datasetID int64) error",
+	} {
+		if !strings.Contains(src, sig) {
+			t.Errorf("签名被改掉了（不再返回 error）：%s", sig)
+		}
+	}
+}

internal/web/archive_pick_test.go

@@ -0,0 +1,129 @@
+package web
+
+import (
+	"bytes"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+)
+
+// mkFile 造一个指定字节数的候选文件。
+func mkFile(t *testing.T, dir, name string, n int) string {
+	t.Helper()
+	p := filepath.Join(dir, name)
+	if err := os.WriteFile(p, bytes.Repeat([]byte("x"), n), 0o644); err != nil {
+		t.Fatalf("造 %s 失败: %v", name, err)
+	}
+	return p
+}
+
+// P5 回归：按摘要找回备份包时，必须先按字节数筛一遍再算摘要。
+//
+// 只看「最终返回哪个文件」新旧写法完全一样——真正的差别是**算了几次 sha256**，
+// 而 uploads 里每份备份动辄几百 MB，多算一次就是几百 MB 的读盘。所以这里注入一个
+// 会计数的 hash，把「有没有白算」直接钉住。
+func TestPickArchiveSkipsWrongSizedFilesWithoutHashing(t *testing.T) {
+	dir := t.TempDir()
+	// 两个诱饵都比正主新（会排在候选前面），大小都和正主不同
+	d1 := mkFile(t, dir, "decoy-newest.rondbackup", 10)
+	d2 := mkFile(t, dir, "decoy-mid.rondbackup", 20)
+	right := mkFile(t, dir, "right.rondbackup", 30)
+
+	hashed := 0
+	got := pickArchiveBySha([]string{d1, d2, right}, "sha-right", 30, func(f string) (string, error) {
+		hashed++
+		// 按文件名给摘要：这样「选中谁」和「算了几次」互相独立——
+		// 去掉预筛时选中的仍然是 right，但白读了两个诱饵（hashed=3）。
+		return "sha-" + strings.TrimSuffix(filepath.Base(f), ".rondbackup"), nil
+	})
+	if got != right {
+		t.Errorf("应当选中 %s，实际 %s", filepath.Base(right), filepath.Base(got))
+	}
+	if hashed != 1 {
+		t.Errorf("只该对大小相符的那份算摘要，实际算了 %d 次（白读了 %d 份整包）", hashed, hashed-1)
+	}
+}
+
+// 反向约束：筛选只许按大小筛，不许把大小恰好相符的候选也一起跳过。
+// 三份大小相同、只有最后一份摘要对得上 ⇒ 必须老老实实算三次。
+func TestPickArchiveHashesEverySameSizedCandidate(t *testing.T) {
+	dir := t.TempDir()
+	a := mkFile(t, dir, "a.rondbackup", 30)
+	b := mkFile(t, dir, "b.rondbackup", 30)
+	c := mkFile(t, dir, "c.rondbackup", 30)
+
+	hashed := 0
+	got := pickArchiveBySha([]string{a, b, c}, "sha-c", 30, func(f string) (string, error) {
+		hashed++
+		return "sha-" + strings.TrimSuffix(filepath.Base(f), ".rondbackup"), nil
+	})
+	if got != c {
+		t.Errorf("应当选中 c.rondbackup，实际 %s", filepath.Base(got))
+	}
+	if hashed != 3 {
+		t.Errorf("大小都相符时不能跳过任何一份，实际只算了 %d 次", hashed)
+	}
+}
+
+// 退化路径：库里没记 sha（老数据）时不按大小筛，保持「取最新的那份」的旧行为——
+// 否则会因为记不到 size 而突然一份都选不中，导出直接失败。
+func TestPickArchiveKeepsNewestWhenNoSha(t *testing.T) {
+	dir := t.TempDir()
+	newest := mkFile(t, dir, "newest.rondbackup", 10)
+	older := mkFile(t, dir, "older.rondbackup", 999)
+
+	hashed := 0
+	got := pickArchiveBySha([]string{newest, older}, "", 0, func(f string) (string, error) {
+		hashed++
+		return "whatever", nil
+	})
+	if got != newest {
+		t.Errorf("没有 sha 时应当取第一份可读的，实际 %s", filepath.Base(got))
+	}
+	if hashed != 1 {
+		t.Errorf("没有 sha 时不该多算，实际算了 %d 次", hashed)
+	}
+}
+
+// 目录与读不到的文件要跳过，不能因为一份坏候选就整段失败。
+func TestPickArchiveSkipsDirsAndUnreadable(t *testing.T) {
+	dir := t.TempDir()
+	if err := os.Mkdir(filepath.Join(dir, "subdir"), 0o755); err != nil {
+		t.Fatal(err)
+	}
+	missing := filepath.Join(dir, "does-not-exist.rondbackup")
+	ok := mkFile(t, dir, "ok.rondbackup", 5)
+
+	got := pickArchiveBySha([]string{missing, filepath.Join(dir, "subdir"), ok}, "sha-ok", 5, func(f string) (string, error) {
+		if f == ok {
+			return "sha-ok", nil
+		}
+		t.Errorf("不该对 %s 算摘要", f)
+		return "nope", nil
+	})
+	if got != ok {
+		t.Errorf("应当跳过缺失与目录后选中 ok.rondbackup，实际 %q", got)
+	}
+
+	// 找不到时返回空串（调用方据此报「请重新上传」）
+	if s := pickArchiveBySha([]string{ok}, "sha-none", 5, func(string) (string, error) { return "other", nil }); s != "" {
+		t.Errorf("没有命中时应返回空串，实际 %q", s)
+	}
+}
+
+// findSourceArchive 必须把 size_bytes 一起查出来——只查 sha 的话上面那道筛选就永远不生效，
+// 而且编译器不会拦（筛挂掉、越筛越慢，行为测试看不出来）。
+func TestFindSourceArchiveConsultsSizeBytes(t *testing.T) {
+	src, err := os.ReadFile(pkgFile(t, "handlers_export.go"))
+	if err != nil {
+		t.Fatalf("读 handlers_export.go 失败: %v", err)
+	}
+	body := sliceFunc(t, string(src), "func (s *Server) findSourceArchive(")
+	if !strings.Contains(body, "size_bytes") {
+		t.Error("findSourceArchive 没有读取 size_bytes：按大小预筛会永远拿不到目标大小")
+	}
+	if !strings.Contains(body, "pickArchiveBySha(") {
+		t.Error("findSourceArchive 没有走 pickArchiveBySha：按大小预筛没有生效")
+	}
+}

internal/web/backup_diff.go

@@ -239,17 +239,21 @@ func (s *Server) countOther(ctx context.Context, datasetID int64) (movements, we
 
 // loadStoredVisits 读出该数据集的全部到访，并把原始行留档里的 UUID 解出来当对齐键。
 // 没有留档的行就是站点新建的（真机不会给它 UUID），对齐键留空。
+// 所挂活动的 UUID 也一样：到访层面按活动身份比对，才不会因活动改名而全线报冲突。
 func (s *Server) loadStoredVisits(ctx context.Context, datasetID int64) ([]rond.StoredVisit, error) {
 	rows, err := s.db.QueryContext(ctx, `
 		SELECT v.src_pk, v.arrival, v.departure, COALESCE(v.remark,''), COALESCE(v.emoji,''),
 		       v.bookmarked, v.is_user_added, COALESCE(p.src_pk,0),
 		       COALESCE(p.name,''), COALESCE(p.lat,0), COALESCE(p.lon,0), COALESCE(a.name,''),
-		       COALESCE(er.raw #>> '{ZIDENTIFIER_,$blob}','')
+		       COALESCE(er.raw #>> '{ZIDENTIFIER_,$blob}',''),
+		       COALESCE(aer.raw #>> '{ZUID_,$blob}','')
 		FROM visits v
 		LEFT JOIN places p ON p.id = v.place_id
 		LEFT JOIN activities a ON a.id = v.activity_id
 		LEFT JOIN entity_raw er ON er.dataset_id = v.dataset_id
 			AND er.entity = 'ZVISIT' AND er.src_pk = v.src_pk
+		LEFT JOIN entity_raw aer ON aer.dataset_id = v.dataset_id
+			AND aer.entity = 'ZACTIVITY' AND aer.src_pk = a.src_pk
 		WHERE v.dataset_id = $1`, datasetID)
 	if err != nil {
 		return nil, err
@@ -263,9 +267,9 @@ func (s *Server) loadStoredVisits(ctx context.Context, datasetID int64) ([]rond.
 		var placePK int
 		var placeName string
 		var lat, lon float64
-		var b64 string
+		var b64, actB64 string
 		if err := rows.Scan(&sv.SrcPK, &arr, &dep, &sv.Remark, &sv.Emoji, &sv.Bookmarked,
-			&sv.UserAdded, &placePK, &placeName, &lat, &lon, &sv.ActivityName, &b64); err != nil {
+			&sv.UserAdded, &placePK, &placeName, &lat, &lon, &sv.ActivityName, &b64, &actB64); err != nil {
 			return nil, err
 		}
 		sv.Arrival = &arr
@@ -278,15 +282,18 @@ func (s *Server) loadStoredVisits(ctx context.Context, datasetID int64) ([]rond.
 			sv.PlaceKey = rond.PlaceCoordKey(lat, lon)
 		}
 		sv.UUID = uuidFromBase64(b64)
+		sv.ActivityUUID = uuidFromBase64(actB64)
 		out = append(out, sv)
 	}
 	return out, rows.Err()
 }
 
+// loadStoredPlaces 读地点。**必须按 id 排序**：配对的候选多于一个时（同坐标/同名的重复地点）
+// 靠顺序决定谁配谁，合并侧（mergePlaces）用的是同一份顺序与同一套规则。
 func (s *Server) loadStoredPlaces(ctx context.Context, datasetID int64) ([]rond.StoredPlace, error) {
 	rows, err := s.db.QueryContext(ctx, `SELECT src_pk, COALESCE(name,''), COALESCE(lat,0), COALESCE(lon,0),
 		COALESCE(province,''), COALESCE(city,''), COALESCE(poi_category,''), visit_count
-		FROM places WHERE dataset_id=$1`, datasetID)
+		FROM places WHERE dataset_id=$1 ORDER BY id`, datasetID)
 	if err != nil {
 		return nil, err
 	}

internal/web/backup_diff_test.go

@@ -62,16 +62,22 @@ func previewBackupToken(t *testing.T, f *movementFixture, path string) (string,
 }
 
 // visitCounts 从概览表里取出「到访」那一行的 (备份新增, 仅站内有, 冲突)。
-// 不能全页 Contains 数字——地点行也有同样的 data-label，会张冠李戴。
 func visitCounts(t *testing.T, page string) (added, gone, clash int) {
 	t.Helper()
-	row := regexp.MustCompile(`(?s)<td>到访</td>(.*?)</tr>`).FindStringSubmatch(page)
+	return overviewCounts(t, page, "到访")
+}
+
+// overviewCounts 取概览表里任意一行（到访 / 地点 / 活动类型）的三个计数。
+// 不能全页 Contains 数字——三行有同样的 data-label，会张冠李戴。
+func overviewCounts(t *testing.T, page, label string) (added, gone, clash int) {
+	t.Helper()
+	row := regexp.MustCompile(`(?s)<td>` + label + `</td>(.*?)</tr>`).FindStringSubmatch(page)
 	if row == nil {
-		t.Fatal("概览表里找不到「到访」行")
+		t.Fatalf("概览表里找不到「%s」行", label)
 	}
 	nums := regexp.MustCompile(`data-label="(备份新增|仅站内有|冲突)">(\d+)<`).FindAllStringSubmatch(row[1], -1)
 	if len(nums) != 3 {
-		t.Fatalf("到访行应有三个计数，实际 %d", len(nums))
+		t.Fatalf("「%s」行应有三个计数，实际 %d", label, len(nums))
 	}
 	for _, n := range nums {
 		v, _ := strconv.Atoi(n[2])
@@ -87,19 +93,70 @@ func visitCounts(t *testing.T, page string) (added, gone, clash int) {
 	return
 }
 
+// shiftSrcPKs 把库里的编号整体平移，模拟「这份数据其实来自另一份编号完全不同的备份」。
+//
+// 这不是臆造的场景：rond 每次导出/同步都会重排 Z_PK，所以「把本地和后来新增的备份合并」
+// 时，两边编号一定对不上，唯一稳定的键只有到访 `ZIDENTIFIER_` / 活动 `ZUID_`。
+// 夹具导入的就是 ROND_SRC 本身，编号与备份逐条相同（实测 823/823），
+// 所以不平移的话，比对会走「编号直接命中的快路径」，UUID 对齐这条真正在用的路径反而测不到。
+//
+// 平移量取得足够大（远超库里最大编号），单条 UPDATE 就不会在语句中途撞上唯一约束；
+// 同时把指向到访编号的外键（movements.from/to_visit_src、weather.visit_src）和留档一起挪。
+func (f *movementFixture) shiftSrcPKs(t *testing.T, delta int) {
+	t.Helper()
+	for _, q := range []string{
+		`UPDATE visits SET src_pk = src_pk + $2 WHERE dataset_id=$1`,
+		`UPDATE places SET src_pk = src_pk + $2 WHERE dataset_id=$1`,
+		`UPDATE activities SET src_pk = src_pk + $2 WHERE dataset_id=$1`,
+		`UPDATE movements SET src_pk = src_pk + $2,
+			from_visit_src = from_visit_src + $2, to_visit_src = to_visit_src + $2 WHERE dataset_id=$1`,
+		`UPDATE weather SET src_pk = src_pk + $2, visit_src = visit_src + $2 WHERE dataset_id=$1`,
+		`UPDATE entity_raw SET src_pk = src_pk + $2 WHERE dataset_id=$1`,
+	} {
+		if _, err := f.pg.ExecContext(f.ctx, q, f.dsID, delta); err != nil {
+			t.Fatalf("平移编号失败: %v\n%s", err, q)
+		}
+	}
+}
+
 // 同一份备份再传一次：UUID 对得上、字段也没变，到访应当一条不差。
 //
-// 这条也顺带钉住「按 UUID 而不是编号对齐」：库内那些行的编号与备份里完全不同
+// ⚠️ 注意这条用例**没有**验证「按 UUID 对齐」：夹具导入的就是 f.src 本身，
-// （rond 重排过），只按编号比会让 800 多条全变冲突。
+// 库里的 src_pk 与备份的 Z_PK 逐条相同（实测 823/823），它是靠编号直接命中的。
+// 真正钉住 UUID 对齐的是 TestBackupDiffAlignsByUUIDNotSrcPK / TestBackupMergeRenumberedBackup。
 //
 // 只断言到访，不断言「完全一致」整句：导入后站点会反查补全地点（改名称/地址），
 // 地点层面因此真的存在差异，那是预期行为，不该由这个用例来管。
+//
+// 但**「备份新增」必须是 0**：导入就是把备份的地点一条一条写进去的（含同名同坐标的重复项），
+// 比对再认不出它们就会每次都判「多出来一条」⇒ 合并时反复插重复地点。真机备份里
+// 「柳州站」在同一个坐标上有 3 条，正是这个形状。
 func TestBackupDiffIdentical(t *testing.T) {
 	f := newMovementFixture(t)
 	page := previewBackup(t, f, f.src)
 	if a, g, c := visitCounts(t, page); a != 0 || g != 0 || c != 0 {
 		t.Fatalf("同一份备份的到访不该有差异: 新增 %d 仅站内有 %d 冲突 %d", a, g, c)
 	}
+	if a, g, _ := overviewCounts(t, page, "地点"); a != 0 || g != 0 {
+		t.Fatalf("刚导入就到比对，地点不该有新增或仅站内有: 新增 %d 仅站内有 %d"+
+			"（同名同坐标的重复地点没被一一配上）", a, g)
+	}
+}
+
+// 编号全被平移后（= 数据来自另一份重排过 Z_PK 的备份），同一份内容再比一次仍须零差异。
+//
+// 这是「本地 + 后来新增的备份」合并的真正前提：rond 每次导出都重排编号，
+// 若比对退回按编号对齐，这里会报成「几百条备份新增 + 几百条仅站内有」，
+// 勾一下「并进来」就会把整份足迹**复制一遍**。
+func TestBackupDiffAlignsByUUIDNotSrcPK(t *testing.T) {
+	f := newMovementFixture(t)
+	f.shiftSrcPKs(t, 500000)
+
+	page := previewBackup(t, f, f.src)
+	if a, g, c := visitCounts(t, page); a != 0 || g != 0 || c != 0 {
+		t.Fatalf("编号平移后内容其实没变，差异应为 0；实际 新增 %d 仅站内有 %d 冲突 %d"+
+			" ⇒ 比对是靠编号对齐的，跨备份合并会把足迹复制一遍", a, g, c)
+	}
 }
 
 // 站内改过备注、又补录了一条到访，差异页要把这两件事分别认出来。

internal/web/backup_merge.go

@@ -14,6 +14,7 @@ import (
 	"rond-with-you/internal/geo"
 	"rond-with-you/internal/ingest"
 	"rond-with-you/internal/rond"
+	"rond-with-you/internal/stats"
 )
 
 // 差异页确认后的合并执行。
@@ -200,30 +201,34 @@ func (s *Server) applyMergePlan(ctx context.Context, ds *Dataset, b *rond.Backup
 	return st, nil
 }
 
-// mergePlaces 先把备份地点映射到库里的 places.id（已存在的直接映射），
+// mergePlaces 先把备份地点映射到库里的 places.id，再处理冲突更新与新增，
-// 再处理冲突更新与新增，返回「备份地点编号 -> 库 id」。
+// 返回「备份地点编号 -> 库 id」。
+//
+// 配对直接沿用比对阶段那一份（rond.MatchPlaces）：**这里绝不能自己再配一遍**。原先用
+// 单槽位 map 配，同坐标/同名的多条备份地点会全部映射到同一条站内地点上，到访于是被挂到
+// 错的分店（实测「茶颜悦色」两家分店相隔 8.3km，到访却指向同一条）。
 func (s *Server) mergePlaces(ctx context.Context, ex execer, dsID int64, b *rond.Backup,
 	plan rond.MergePlan, st *mergeStats) (map[int]int64, error) {
-	byCoord, byName := map[string]int64{}, map[string]int64{}
+	// 顺序必须稳定（按 id）且与 loadStoredPlaces 一致，否则候选多于一个时配对会飘
-	rows, err := ex.QueryContext(ctx, `SELECT id, COALESCE(name,''), COALESCE(lat,0), COALESCE(lon,0)
+	stored := make([]rond.StoredPlace, 0, 512)
-		FROM places WHERE dataset_id=$1`, dsID)
+	bySrcPK := map[int]int64{}
+	rows, err := ex.QueryContext(ctx, `SELECT id, src_pk, COALESCE(name,''), COALESCE(lat,0), COALESCE(lon,0)
+		FROM places WHERE dataset_id=$1 ORDER BY id`, dsID)
 	if err != nil {
 		return nil, err
 	}
 	for rows.Next() {
 		var id int64
-		var name string
+		var sp rond.StoredPlace
-		var lat, lon float64
+		if err := rows.Scan(&id, &sp.SrcPK, &sp.Name, &sp.Lat, &sp.Lon); err != nil {
-		if err := rows.Scan(&id, &name, &lat, &lon); err != nil {
 			rows.Close()
 			return nil, err
 		}
-		if lat != 0 || lon != 0 {
+		if sp.Lat != 0 || sp.Lon != 0 {
-			byCoord[rond.PlaceCoordKey(lat, lon)] = id
+			sp.Key = rond.PlaceCoordKey(sp.Lat, sp.Lon)
-		}
-		if _, dup := byName[name]; !dup && name != "" {
-			byName[name] = id
 		}
+		stored = append(stored, sp)
+		bySrcPK[sp.SrcPK] = id
 	}
 	rows.Close()
 	if err := rows.Err(); err != nil {
@@ -231,28 +236,14 @@ func (s *Server) mergePlaces(ctx context.Context, ex execer, dsID int64, b *rond
 	}
 
 	placeID := map[int]int64{}
-	for _, l := range b.Locations {
+	for srcPK, sp := range rond.MatchPlaces(stored, b.Locations) {
-		if l.Lat != 0 || l.Lon != 0 {
+		if id, ok := bySrcPK[sp.SrcPK]; ok {
-			if id, ok := byCoord[rond.PlaceCoordKey(l.Lat, l.Lon)]; ok {
+			placeID[srcPK] = id
-				placeID[l.SrcPK] = id
-				continue
-			}
-		}
-		if l.Name != "" {
-			if id, ok := byName[l.Name]; ok {
-				placeID[l.SrcPK] = id
-			}
 		}
 	}
 
 	for _, up := range plan.UpdPlaces {
 		id := placeID[up.L.SrcPK]
-		if id == 0 {
-			id = byCoord[up.CoordKey]
-		}
-		if id == 0 {
-			id = byName[up.L.Name]
-		}
 		if id == 0 {
 			return nil, fmt.Errorf("找不到要更新的地点（%s）", up.L.Name)
 		}
@@ -264,7 +255,6 @@ func (s *Server) mergePlaces(ctx context.Context, ex execer, dsID int64, b *rond
 			nullStr(up.L.Sublocality), nullStr(up.L.Thoroughfare), nullStr(up.L.Timezone), id); err != nil {
 			return nil, fmt.Errorf("更新地点: %w", err)
 		}
-		placeID[up.L.SrcPK] = id
 		st.UpdPlaces++
 	}
 
@@ -428,8 +418,9 @@ func (s *Server) mergeVisits(ctx context.Context, ex execer, dsID int64, b *rond
 	visSrc := map[int]int{}
 	storedByUUID := map[string]rond.StoredVisit{}
 	for _, sv := range storedVisits {
-		if sv.UUID != "" {
+		// 站点补录的行没有留档 UUID，用它的派生 UUID 当键（与差异页同一套对齐，见 rond.VisitMatchUUID）
-			storedByUUID[sv.UUID] = sv
+		if u := rond.VisitMatchUUID(sv); u != "" {
+			storedByUUID[u] = sv
 		}
 	}
 	for _, v := range b.Visits {
@@ -527,6 +518,28 @@ func (s *Server) mergeVisits(ctx context.Context, ex execer, dsID int64, b *rond
 	for _, t := range b.Transports {
 		transName[t.SrcPK], transColor[t.SrcPK], transIcon[t.SrcPK] = t.Name, t.Color, t.Icon
 	}
+	// 交通方式是**两套编号空间**：站点的 movements.transport_src 用自己的编号（站点没有交通方式表，
+	// 方式只活在位移的 transport_* 四列里），而 m.TransportSrc 是实机的编号。同一个数字两边含义
+	// 常常不同（实测实机 4=公交、站点 4=电🐔），照抄会把一个 src 变成两种含义——导出按 src 聚合时
+	// 会吐出两条同名方式，真机那边（以及 Core Data 的唯一约束）会判成损坏数据、整包拒收。
+	// 按**名称**归一：站点已有同名方式就沿用它的编号，没有才新发一个。
+	siteTrans, transNext, err := s.transportsByName(ctx, ex, dsID)
+	if err != nil {
+		return err
+	}
+	transSrc := map[int]int{}
+	for _, t := range b.Transports {
+		if t.Name == "" {
+			continue
+		}
+		if src, ok := siteTrans[t.Name]; ok {
+			transSrc[t.SrcPK] = src
+			continue
+		}
+		siteTrans[t.Name] = transNext
+		transSrc[t.SrcPK] = transNext
+		transNext++
+	}
 	coordOf := map[int][2]float64{}
 	for _, l := range b.Locations {
 		coordOf[l.SrcPK] = [2]float64{l.Lat, l.Lon}
@@ -581,11 +594,21 @@ func (s *Server) mergeVisits(ctx context.Context, ex execer, dsID int64, b *rond
 		if err != nil {
 			return err
 		}
+		// transport_src 写**站点编号空间**里的号（见上面 transSrc 的说明）：照抄实机编号会让
+		// 同一个 src 出现两种含义，导出时吐出两条同名方式、整包被真机拒收。
+		var transFK any
+		if m.TransportSrc != nil {
+			if x, ok := transSrc[*m.TransportSrc]; ok {
+				transFK = x
+			} else {
+				transFK = *m.TransportSrc
+			}
+		}
 		if _, err := ex.ExecContext(ctx, `INSERT INTO movements
 			(dataset_id, src_pk, transport_src, transport_name, transport_color, transport_icon,
 			 from_visit_src, to_visit_src, from_place_id, to_place_id, started_at, ended_at, duration_min, distance_km)
 			VALUES ($1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11,$12,$13,$14) ON CONFLICT DO NOTHING`,
-			dsID, pk, m.TransportSrc, tname, tcolor, ticon, fsrc, tsrc,
+			dsID, pk, transFK, tname, tcolor, ticon, fsrc, tsrc,
 			fromPID, toPID, m.Start, m.End, dur, dist); err != nil {
 			return fmt.Errorf("新增位移: %w", err)
 		}
@@ -638,6 +661,40 @@ func (s *Server) mergeVisits(ctx context.Context, ex execer, dsID int64, b *rond
 	return nil
 }
 
+// transportsByName 读站点现有的交通方式，按**名称**归并成一个「名称 -> 编号」表（同名取用得多
+// 的那个编号，并列取小），并给出下一个可用编号。站点没有交通方式表，方式只活在位移的
+// transport_src / transport_name 里，所以这里从 movements 里聚合。
+func (s *Server) transportsByName(ctx context.Context, ex execer, dsID int64) (map[string]int, int, error) {
+	rows, err := ex.QueryContext(ctx, `SELECT transport_src, transport_name, count(*)
+		FROM movements
+		WHERE dataset_id=$1 AND transport_src IS NOT NULL AND COALESCE(transport_name,'') <> ''
+		GROUP BY 1,2`, dsID)
+	if err != nil {
+		return nil, 0, err
+	}
+	defer rows.Close()
+	count, best := map[string]int{}, map[string]int{}
+	for rows.Next() {
+		var src, n int
+		var name string
+		if err := rows.Scan(&src, &name, &n); err != nil {
+			return nil, 0, err
+		}
+		cur, seen := count[name]
+		if !seen || n > cur || (n == cur && src < best[name]) {
+			count[name], best[name] = n, src
+		}
+	}
+	if err := rows.Err(); err != nil {
+		return nil, 0, err
+	}
+	next, err := s.nextSrcPK(ctx, ex, dsID, transportSeq)
+	if err != nil {
+		return nil, 0, err
+	}
+	return best, next, nil
+}
+
 // applyDeletions 处理「仅站内有」里被勾选删除的记录。顺序是到访 → 活动 → 地点：
 // 删地点会级联删掉它名下的全部到访（外键 ON DELETE CASCADE），所以反过来会误删；
 // 而且**有到访引用时直接拒绝**，让站长先处理到访，而不是悄悄带走一批。
@@ -700,17 +757,25 @@ func (s *Server) applyDeletions(ctx context.Context, ex execer, dsID int64, plan
 
 // recountPlaces 重算地点聚合与数据集汇总。全量重算而不是只动受影响的行：
 // 367 个地点两条 SQL 就够，省得漏掉任何一条派生列。
+//
+// 到访数与停留按**访客口径**（不含已并入 / 子段，见 stats.SoloVisitSQL），与 stats.Filter 一致；
+// 首末到访与数据集计数保持全量（last_visit_at 会写进导出包，datasets.visit_count 是后台口径）。
 func (s *Server) recountPlaces(ctx context.Context, ex execer, dsID int64) error {
+	// 先把派生列刷新（合并刚插进来的行带着留档），下面的聚合读的就是它
+	if _, err := ex.ExecContext(ctx, stats.RefreshMergedFlagsSQL, dsID); err != nil {
+		return err
+	}
 	if _, err := ex.ExecContext(ctx, `UPDATE places SET visit_count=0, dwell_minutes=0,
 		first_visit_at=NULL, last_visit_at=NULL WHERE dataset_id=$1`, dsID); err != nil {
 		return err
 	}
 	if _, err := ex.ExecContext(ctx, `UPDATE places p SET visit_count=sub.c, dwell_minutes=sub.d,
 		first_visit_at=sub.f, last_visit_at=sub.l
-		FROM (SELECT place_id, count(*) c,
+		FROM (SELECT vis.place_id,
-				COALESCE(sum(LEAST(COALESCE(duration_min,0),10080)),0) d,
+				count(*) FILTER (WHERE `+stats.SoloVisitSQL("vis")+`) c,
-				min(arrival) f, max(arrival) l
+				COALESCE(sum(LEAST(COALESCE(vis.duration_min,0),10080)) FILTER (WHERE `+stats.SoloVisitSQL("vis")+`),0) d,
-			FROM visits WHERE dataset_id=$1 AND place_id IS NOT NULL GROUP BY place_id) sub
+				min(vis.arrival) f, max(vis.arrival) l
+			FROM visits vis WHERE vis.dataset_id=$1 AND vis.place_id IS NOT NULL GROUP BY vis.place_id) sub
 		WHERE p.id = sub.place_id`, dsID); err != nil {
 		return err
 	}
@@ -731,8 +796,10 @@ func writeRawRow(ctx context.Context, ex execer, dsID int64, entity string, pk i
 	}
 	blob, err := json.Marshal(raw)
 	if err != nil {
-		log.Printf("留档 %s#%d 序列化失败: %v", entity, pk, err)
+		// 这里以前只 log 后 return nil：调用方会以为留档成功，合并照常提交，
-		return nil
+		// 于是这行的原始列永久缺失（下次比对认不出 UUID、导出也还原不回去）。
+		// 必须上抛，让整个合并事务回滚。
+		return fmt.Errorf("留档 %s#%d 序列化失败: %w", entity, pk, err)
 	}
 	_, err = ex.ExecContext(ctx, `INSERT INTO entity_raw (dataset_id, entity, src_pk, raw, skipped)
 		VALUES ($1,$2,$3,$4,false)

internal/web/backup_merge_test.go

@@ -5,6 +5,8 @@ import (
 	"net/http/httptest"
 	"strings"
 	"testing"
+
+	"rond-with-you/internal/rond"
 )
 
 // mergeBackup 走真实的合并处理函数；失败（重定向里带 err=）直接判错。
@@ -54,6 +56,10 @@ func (f *movementFixture) scalar(t *testing.T, q string, args ...any) int {
 //   - 新增行用 nextSrcPK 发新号，且**写进 entity_raw**（否则下次比对认不出 UUID）；
 //   - 位移/天气的外键指向库里的新编号（写错就成孤儿）；
 //   - 合并是幂等的：再传同一份备份，差异归零。
+//
+// 注意：这里库内编号与备份逐条相同（夹具导入的就是 f.src 本身，实测 823/823），
+// 所以走的是「编号直接命中」的快路径。编号重排过的真实场景见
+// TestBackupMergeRenumberedBackupRestoresOnlyMissing。
 func TestBackupMergeRestoresMissingVisits(t *testing.T) {
 	f := newMovementFixture(t)
 
@@ -120,11 +126,99 @@ func TestBackupMergeRestoresMissingVisits(t *testing.T) {
 		t.Errorf("孤儿位移变多了：%d → %d", orphans0, orphans)
 	}
 
-	// 幂等：再比一次应当完全一致
+	// 幂等：再比一次应当完全一致（地点也一样——同名同坐标的重复地点必须一一配上，
+	// 否则每次合并都会再插一条重复地点）
 	page = previewBackup(t, f, f.src)
 	if a, g, c := visitCounts(t, page); a != 0 || g != 0 || c != 0 {
 		t.Fatalf("合并后再比对应当没有差异，实际 新增 %d / 仅站内有 %d / 冲突 %d", a, g, c)
 	}
+	if a, g, _ := overviewCounts(t, page, "地点"); a != 0 || g != 0 {
+		t.Fatalf("合并后再比对，地点应当归零，实际 新增 %d / 仅站内有 %d"+
+			"（重复地点会被反复当成「备份新增」→ 每合并一次多一条）", a, g)
+	}
+}
+
+// 「本地 + **后来新增的备份**」合并的真实形态：备份里的编号被 rond 全部重排过，
+// 与库里的编号对不上，而备份里还多了几条新记录。
+//
+// 这条要钉住的是最贵的一种错：如果比对退回按编号对齐，那 800 多条老记录会被判成
+// 「备份新增 + 仅站内有」，用户勾一下「并进来」就把整份足迹**复制一遍**（数量翻倍、
+// 地图上每个点都重影）。必须在平移编号的前提下，差异仍然只有真正缺的那 2 条。
+func TestBackupMergeRenumberedBackupRestoresOnlyMissing(t *testing.T) {
+	f := newMovementFixture(t)
+
+	visitCount := func() int {
+		return f.scalar(t, `SELECT count(*) FROM visits WHERE dataset_id=$1`, f.dsID)
+	}
+	all := visitCount()
+	movCount := f.scalar(t, `SELECT count(*) FROM movements WHERE dataset_id=$1`, f.dsID)
+	weatherCount := f.scalar(t, `SELECT count(*) FROM weather WHERE dataset_id=$1`, f.dsID)
+	if all == 0 || movCount == 0 {
+		t.Skip("这份备份没有足够的到访/位移可测")
+	}
+
+	// ① 库里的编号整体平移：等价于「这批数据其实来自另一份编号完全不同的备份」
+	f.shiftSrcPKs(t, 500000)
+
+	// ② 再按**站点删到访的方式**删掉最早两条：备份里还有它们，所以差异应当正好是 2 条。
+	// 和平移前的用例一样，必须连带清位移、清天气归属，否则留下的是测试手法造成的孤儿。
+	var pk1, pk2 int
+	if err := f.pg.QueryRowContext(f.ctx, `SELECT
+		(SELECT src_pk FROM visits WHERE dataset_id=$1 ORDER BY arrival LIMIT 1),
+		(SELECT src_pk FROM visits WHERE dataset_id=$1 ORDER BY arrival OFFSET 1 LIMIT 1)`,
+		f.dsID).Scan(&pk1, &pk2); err != nil {
+		t.Fatalf("取待删到访失败: %v", err)
+	}
+	for _, q := range []string{
+		`DELETE FROM movements WHERE dataset_id=$1 AND (from_visit_src IN ($2,$3) OR to_visit_src IN ($2,$3))`,
+		`UPDATE weather SET visit_src=NULL WHERE dataset_id=$1 AND visit_src IN ($2,$3)`,
+		`DELETE FROM visits WHERE dataset_id=$1 AND src_pk IN ($2,$3)`,
+	} {
+		if _, err := f.pg.ExecContext(f.ctx, q, f.dsID, pk1, pk2); err != nil {
+			t.Fatalf("预置删除失败: %v", err)
+		}
+	}
+	if got := visitCount(); got != all-2 {
+		t.Fatalf("预置失败：应有 %d 条，实际 %d", all-2, got)
+	}
+
+	token, page := previewBackupToken(t, f, f.src)
+	if a, g, c := visitCounts(t, page); a != 2 || g != 0 || c != 0 {
+		t.Fatalf("编号重排过、只缺 2 条 ⇒ 差异应当正好 2 条新增；实际 新增 %d 仅站内有 %d 冲突 %d"+
+			"（判成 800+ 就是把整份足迹当新记录，合并会复制一遍）", a, g, c)
+	}
+
+	mergeBackup(t, f, token, "add_new=1")
+
+	if got := visitCount(); got != all {
+		t.Fatalf("合并后到访数应回到 %d 且不重不漏，实际 %d", all, got)
+	}
+	if got := f.scalar(t, `SELECT count(*) FROM movements WHERE dataset_id=$1`, f.dsID); got != movCount {
+		t.Errorf("位移应恢复到 %d，实际 %d（恢复到新编号时外键映射错了）", movCount, got)
+	}
+	if got := f.scalar(t, `SELECT count(*) FROM weather WHERE dataset_id=$1`, f.dsID); got != weatherCount {
+		t.Errorf("天气应恢复到 %d，实际 %d", weatherCount, got)
+	}
+	// 补进来的那两条必须真的挂回了某个经历，不能因为编号变了就成孤儿
+	if got := f.scalar(t, `SELECT count(*) FROM movements m WHERE m.dataset_id=$1
+		AND m.from_visit_src IS NOT NULL AND NOT EXISTS (
+			SELECT 1 FROM visits v WHERE v.dataset_id=$1 AND v.src_pk=m.from_visit_src)`, f.dsID); got != 0 {
+		t.Errorf("恢复后出现了 %d 条起点悬空的位移", got)
+	}
+	// 地点是按**坐标**对齐的（不是按编号），所以编号平移不该让补回来的到访挂空 ——
+	// place_id 可空，映射错了不会报错，只会变成地图上没地点的孤点到访。
+	if got := f.scalar(t, `SELECT count(*) FROM visits WHERE dataset_id=$1 AND place_id IS NULL`, f.dsID); got != 0 {
+		t.Errorf("恢复后有 %d 条到访没挂上地点（按编号映射就会这样）", got)
+	}
+
+	// 幂等：再比一次必须归零（否则每合并一次就多一批）
+	page = previewBackup(t, f, f.src)
+	if a, g, c := visitCounts(t, page); a != 0 || g != 0 || c != 0 {
+		t.Fatalf("合并后再比对应当没有差异，实际 新增 %d 仅站内有 %d 冲突 %d", a, g, c)
+	}
+	if a, g, _ := overviewCounts(t, page, "地点"); a != 0 || g != 0 {
+		t.Fatalf("合并后地点差异也该归零，实际 新增 %d 仅站内有 %d", a, g)
+	}
 }
 
 // 冲突逐条选「用实机」就把备份的值写进去，选「用站内」就原样不动。
@@ -271,3 +365,107 @@ func TestBackupMergeRefusesDeletingPlaceInUse(t *testing.T) {
 		t.Errorf("被拒绝后到访数不该变，实际 %d（期望 %d）", got, beforeVisits+1)
 	}
 }
+
+// 两条同名备份地点在合并时必须各配一条站内地点。以前这里用**单槽位** map 自己再配一遍，
+// 两条同名地点会映射到同一条站内地点上，到访于是被挂到错的分店——实测「茶颜悦色」两家
+// 分店相隔 8.3km，到访却都指向同一条。现在配对直接沿用比对阶段那一份（rond.MatchPlaces）。
+func TestMergePlacesMapsSameNameLocationsOneToOne(t *testing.T) {
+	f := newMovementFixture(t)
+
+	// 两条同名的站内地点，放在不太可能与真实数据撞车的坐标上
+	if _, err := f.pg.ExecContext(f.ctx, `INSERT INTO places (dataset_id, src_pk, name, lat, lon)
+		VALUES ($1, 920001, '同名测试店', 1.000000, 1.000000),
+		       ($1, 920002, '同名测试店', 1.100000, 1.100000)`, f.dsID); err != nil {
+		t.Fatalf("插入站内地点失败: %v", err)
+	}
+	t.Cleanup(func() {
+		f.pg.ExecContext(f.ctx, `DELETE FROM places WHERE dataset_id=$1 AND src_pk IN (920001,920002)`, f.dsID)
+	})
+
+	// 备份各一条同名地点，分别距上面两条约 700m（属于坐标纠偏，该配上）；
+	// 与另一条相距 15km，远超 1km 上限，不该被配走
+	b := &rond.Backup{Locations: []rond.Location{
+		{SrcPK: 41, Name: "同名测试店", Lat: 1.004500, Lon: 1.004500},
+		{SrcPK: 42, Name: "同名测试店", Lat: 1.095500, Lon: 1.095500},
+	}}
+
+	var placeID map[int]int64
+	if err := f.srv.withTx(f.ctx, func(ex execer) error {
+		var err error
+		placeID, err = f.srv.mergePlaces(f.ctx, ex, f.dsID, b, rond.MergePlan{}, &mergeStats{})
+		return err
+	}); err != nil {
+		t.Fatalf("mergePlaces 失败: %v", err)
+	}
+	if len(placeID) != 2 {
+		t.Fatalf("两条都该配上，实际 %d 条", len(placeID))
+	}
+	if placeID[41] == placeID[42] {
+		t.Fatalf("两条同名备份地点被映射到同一条站内地点上: 41→%d 42→%d", placeID[41], placeID[42])
+	}
+	srcOf := func(id int64) int {
+		t.Helper()
+		var pk int
+		if err := f.pg.QueryRowContext(f.ctx, `SELECT src_pk FROM places WHERE id=$1`, id).Scan(&pk); err != nil {
+			t.Fatalf("反查 id=%d 失败: %v", id, err)
+		}
+		return pk
+	}
+	if got := srcOf(placeID[41]); got != 920001 {
+		t.Errorf("备份 #41 应配到最近的 920001，实际 %d", got)
+	}
+	if got := srcOf(placeID[42]); got != 920002 {
+		t.Errorf("备份 #42 应配到最近的 920002，实际 %d", got)
+	}
+}
+
+// 交通方式的编号是**两套空间**：站点用自己的 transport_src 编号，而备份里的 m.TransportSrc 是
+// 实机的编号。合并时照抄实机编号，会让同一个 src 带上两种含义（实测 src=4 既是「电🐔」又是
+// 「公交」）——导出时按名称归并前会吐出两条同名方式，真机整包拒收。合并必须按名称把实机的方式
+// 归一到站点的编号上。
+func TestMergeKeepsTransportNumberingConsistent(t *testing.T) {
+	f := newMovementFixture(t)
+	ctx, pg, dsID := f.ctx, f.pg, f.dsID
+	movCount := func() int {
+		return f.scalar(t, `SELECT count(*) FROM movements WHERE dataset_id=$1`, dsID)
+	}
+	before := movCount()
+
+	// 把站点所有方式改名（编辑页允许改方式名，这就是真实操作）：于是站点的「1 号」与实机的
+	// 「1 号」含义不同——两套编号空间撞车的形状
+	if _, err := pg.ExecContext(ctx, `UPDATE movements SET transport_name = transport_name || '（站内）'
+		WHERE dataset_id=$1 AND transport_src IS NOT NULL`, dsID); err != nil {
+		t.Fatalf("预置改名失败: %v", err)
+	}
+
+	// 删掉一条**带交通方式**的位移的端点到访，好让合并把它连同位移一起补回来
+	// （没有新到访就不会插入任何位移，用例会变成空的）
+	var pk int
+	if err := pg.QueryRowContext(ctx, `SELECT from_visit_src FROM movements
+		WHERE dataset_id=$1 AND transport_src IS NOT NULL AND from_visit_src IS NOT NULL
+		ORDER BY id LIMIT 1`, dsID).Scan(&pk); err != nil {
+		t.Fatalf("挑端点到访失败: %v", err)
+	}
+	for _, q := range []string{
+		`DELETE FROM movements WHERE dataset_id=$1 AND (from_visit_src=$2 OR to_visit_src=$2)`,
+		`UPDATE weather SET visit_src=NULL WHERE dataset_id=$1 AND visit_src=$2`,
+		`DELETE FROM visits WHERE dataset_id=$1 AND src_pk=$2`,
+	} {
+		if _, err := pg.ExecContext(ctx, q, dsID, pk); err != nil {
+			t.Fatalf("预置删除失败: %v", err)
+		}
+	}
+
+	token, _ := previewBackupToken(t, f, f.src)
+	mergeBackup(t, f, token, "add_new=1")
+
+	if got := movCount(); got < before {
+		t.Fatalf("合并没有把删掉的位移补回来（%d → %d），这条用例会变成空的", before, got)
+	}
+	n := f.scalar(t, `SELECT count(*) FROM (SELECT transport_src FROM movements
+		WHERE dataset_id=$1 AND transport_src IS NOT NULL
+		GROUP BY transport_src HAVING count(DISTINCT transport_name) > 1) x`, dsID)
+	if n != 0 {
+		t.Fatalf("%d 个交通方式编号带上了两种名称（实机编号被照抄进站点的编号空间了）", n)
+	}
+}

internal/web/baseline.go

@@ -0,0 +1,701 @@
+package web
+
+import (
+	"context"
+	"database/sql"
+	"errors"
+	"fmt"
+	"io"
+	"log"
+	"net/http"
+	"os"
+	"path/filepath"
+	"sort"
+	"strconv"
+	"strings"
+	"time"
+
+	"rond-with-you/internal/ingest"
+	"rond-with-you/internal/rond"
+)
+
+// 「换基线」：把当前数据集的底座库（导出时铺数据的底稿）换成另一份手机导出的包。
+//
+// 为什么必须能换：导出只是以底座为底、覆盖我们托管的那七张实体表，其余内容
+// （Core Data 元数据、索引、持久化历史、ZRAWVISIT 采样点、ZTRIP* 等）全部从底座原样带出来。
+// 所以底座**必须是手机导出的包**——拿本站导出的包当底座，编号空间与真机对不上，
+// 导出会越导越失真。而底座一旦定下就跟着数据集走；手机那边再导出新包时，
+// 以前唯一的办法是整包重新导入成新数据集，站点侧补录的行、主题、备注都得重新收拾。
+// 这个动作就是给「同一份数据的底座换代」用的：站点数据一行不动，只换底稿。
+//
+// 与「上传备份」的区别：上传是重建数据（新数据集），换基线不动数据、只换底稿。
+
+// baselineBackupKeep 是旧底座留档的保留份数（最近 N 份）。替换前一律留档，
+// 换错了能一键回滚——底座是导出的命根子，写坏了整个数据集就导不出去了。
+const baselineBackupKeep = 3
+
+// minOverlapVisits 是「重合率」判据生效所需的最小样本量。站点侧带 UUID 的到访太少时
+// （比如数据集本来就是站点手工建的），重合率没有统计意义，不拦。
+const minOverlapVisits = 20
+
+// baselineStatus 是底座的现状画像。
+type baselineStatus struct {
+	Path    string
+	Exists  bool
+	Size    int64
+	ModTime *time.Time
+	// Name / SHA / At 是「换基线」记档：这份底座是从哪份包换过来的。
+	// SHA 为空表示从未换过，来源就是数据集最初上传的那份原始包。
+	Name string
+	SHA  string
+	At   *time.Time
+	// Backups 是留档的旧底座（新的在前）。
+	Backups []baselineBackup
+}
+
+type baselineBackup struct {
+	Name string
+	Size int64
+	At   time.Time
+}
+
+// baselineCount 是底座里某张表的行数（页面上的「底稿画像」）。
+type baselineCount struct {
+	Table string
+	Label string
+	N     int
+}
+
+// baselineTableLabels 是画像要列的表，顺序按对导出的重要程度。
+var baselineTableLabels = []struct{ Table, Label string }{
+	{"ZVISIT", "到访"},
+	{"ZLOCATION", "地点"},
+	{"ZMOVEMENT", "位移"},
+	{"ZHOURLYWEATHER", "天气"},
+	{"ZRAWVISIT", "原始定位采样"},
+	{"ZACTIVITY", "活动类型"},
+	{"ZTAG", "标签"},
+	{"ZTRANSPORT", "交通方式"},
+}
+
+// openBaselineRO 只读打开底座库（Core Data 单文件）。
+//
+// 驱动只认 _pragma / _time_format 这几个 DSN 参数，没有 mode=ro；底座库是 rollback journal
+// 模式（VACUUM INTO 的产物），只做 SELECT 不会落下任何旁写文件，再加 query_only 兜住
+// 「误写底座库」这条路——底座是导出的底稿，写坏了整个数据集就导不出去了。
+func openBaselineRO(path string) (*sql.DB, error) {
+	// 先确认文件在：sql.Open 默认是 READWRITE|CREATE，路径不存在时会**建一个空库**，
+	// 于是查表报「no such table」而不是「没有底座」——那种错误很难查。
+	if _, err := os.Stat(path); err != nil {
+		return nil, err
+	}
+	sdb, err := sql.Open("sqlite", "file:"+filepath.ToSlash(path)+"?_pragma=query_only(1)&_pragma=busy_timeout(5000)")
+	if err != nil {
+		return nil, err
+	}
+	sdb.SetMaxOpenConns(1)
+	return sdb, nil
+}
+
+// baselineStatusOf 读出底座的现状：文件、记档、留档列表。
+func (s *Server) baselineStatusOf(ctx context.Context, datasetID int64) (*baselineStatus, error) {
+	st := &baselineStatus{Path: s.baselinePath(datasetID)}
+	if fi, err := os.Stat(st.Path); err == nil {
+		st.Exists = true
+		st.Size = fi.Size()
+		t := fi.ModTime()
+		st.ModTime = &t
+	}
+	if err := s.db.QueryRowContext(ctx, `SELECT COALESCE(baseline_name,''), COALESCE(baseline_sha256,''),
+		baseline_at FROM datasets WHERE id=$1`, datasetID).Scan(&st.Name, &st.SHA, &st.At); err != nil {
+		return nil, err
+	}
+	baks, _ := filepath.Glob(st.Path + ".bak-*")
+	for _, b := range baks {
+		fi, err := os.Stat(b)
+		if err != nil {
+			continue
+		}
+		st.Backups = append(st.Backups, baselineBackup{Name: filepath.Base(b), Size: fi.Size(), At: fi.ModTime()})
+	}
+	// 新的在前：回滚要的是最近一份，页面也要按时间倒序列
+	sort.Slice(st.Backups, func(i, j int) bool { return st.Backups[i].At.After(st.Backups[j].At) })
+	return st, nil
+}
+
+// baselineCounts 数底座里各表的行数。表不存在（老包缺某张表）就跳过，不报错——
+// 画像只是给人看的，缺一行不该拦住换底座。
+func baselineCounts(ctx context.Context, path string) ([]baselineCount, error) {
+	sdb, err := openBaselineRO(path)
+	if err != nil {
+		return nil, err
+	}
+	defer sdb.Close()
+
+	rows, err := sdb.QueryContext(ctx, `SELECT name FROM sqlite_master WHERE type='table'`)
+	if err != nil {
+		return nil, err
+	}
+	have := map[string]bool{}
+	for rows.Next() {
+		var n string
+		if err := rows.Scan(&n); err != nil {
+			rows.Close()
+			return nil, err
+		}
+		have[strings.ToUpper(n)] = true
+	}
+	rows.Close()
+	if err := rows.Err(); err != nil {
+		return nil, err
+	}
+
+	var out []baselineCount
+	for _, t := range baselineTableLabels {
+		if !have[t.Table] {
+			continue
+		}
+		var n int
+		if err := sdb.QueryRowContext(ctx, `SELECT count(*) FROM `+t.Table).Scan(&n); err != nil {
+			continue
+		}
+		out = append(out, baselineCount{Table: t.Table, Label: t.Label, N: n})
+	}
+	return out, nil
+}
+
+// visitUUIDOverlap 数「站点里带 UUID 的到访」有多少条能在这份底座里找到。
+//
+// 这是唯一能挡住「换错包」的闸。干跑导出验证的是**结构**（表齐、实体编号齐），
+// 一份完全不相干的包照样能导出成功——但换下去以后，导出的包就不是这份数据了：
+// 站点每一行都会在底座里找不到身份，于是全都按「新行」插到最大编号之上，
+// 真机上表现为「这些到访全变成新的、老记录还在」。
+//
+// 站点补录/新建的行（没有 UUID）不计入分母：真机包里本来就没有它们。
+func (s *Server) visitUUIDOverlap(ctx context.Context, datasetID int64, baselinePath string) (matched, withUUID int, err error) {
+	base, err := readDupBaseline(ctx, baselinePath)
+	if err != nil {
+		return 0, 0, err
+	}
+	site, err := s.loadStoredVisits(ctx, datasetID)
+	if err != nil {
+		return 0, 0, err
+	}
+	for _, sv := range site {
+		if sv.UUID == "" {
+			continue
+		}
+		withUUID++
+		if base.uuids[sv.UUID] {
+			matched++
+		}
+	}
+	return matched, withUUID, nil
+}
+
+// baselineBackupName 生成一个不与已有文件冲突的留档名。
+//
+// **必须防重名**：替换与回滚可能落在同一秒里，秒级时间戳直接当文件名的话，
+// 后一次 os.Rename 会把前一次的留档**覆盖掉**——而被覆盖的那一份正是要恢复的旧底座。
+// 实测「换底座紧接着回滚」就踩过：回滚把新底座改名成 dst.bak-<同一秒>，
+// 恰好压掉刚生成的旧底座留档，于是「回滚」回了个寂寞。
+func baselineBackupName(dst string, now time.Time) string {
+	base := fmt.Sprintf("%s.bak-%s", dst, now.Format("20060102-150405"))
+	p := base
+	for i := 1; ; i++ {
+		if _, err := os.Stat(p); err != nil {
+			return p
+		}
+		p = fmt.Sprintf("%s-%d", base, i)
+	}
+}
+
+// errBaselineMismatch 表示这份包与当前数据集对不上，需要站长显式确认才换。
+type errBaselineMismatch struct {
+	matched, withUUID int
+	zero              bool // 一条都对不上：连「强制」都不给过
+}
+
+func (e *errBaselineMismatch) Error() string {
+	if e.zero {
+		return fmt.Sprintf("这份备份跟当前数据集的 %d 条到访一条都对不上，几乎可以肯定不是同一份数据的手机包，"+
+			"换下去会让导出包整个错位，已放弃", e.withUUID)
+	}
+	return fmt.Sprintf("这份备份与当前数据集只对得上 %d/%d 条到访，可能不是同一批数据。确认无误请勾选「强制替换」再试",
+		e.matched, e.withUUID)
+}
+
+// baselineReport 是一次换底座的结果，用来给页面/提示提供具体数字。
+type baselineReport struct {
+	Name       string
+	SHA        string
+	Size       int64
+	Matched    int
+	WithUUID   int
+	Counts     []baselineCount
+	Replaced   bool // 是否真的换掉了（false = 原本没有底座，是首次建立）
+	Backup     string
+	SiteVisits int // 站内到访条数，用来提示「新底座里多出来的那些不会进包」
+	ElapsedMs  int64
+}
+
+// swapBaseline 把当前数据集的底座换成 archive 那份包。
+//
+// 顺序是有讲究的，三步都不能挪：
+//  1. 先在新底座上**干跑一次导出**。导出失败（缺表、缺实体编号、写入报错）在这里就挡住，
+//     绝不会出现「底座已经换了、才发现导不出、而原来那份已经不知道去哪了」。
+//  2. 旧底座改名留档，新的原子改名就位。中途失败要把旧的换回来，至少不能让数据集没底座。
+//  3. 记档（来源文件名 + sha）。底座文件以后丢了，ensureBaseline 要按它找同一份包重建；
+//     只认 datasets.sha256 的话会把底座悄悄退回最初那份旧包。
+//
+// 站点数据（places/visits/…）一行都不动：换的只是导出的底稿。
+func (s *Server) swapBaseline(ctx context.Context, datasetID int64, archive, name, sha string, force bool) (baselineReport, error) {
+	start := time.Now()
+	rep := baselineReport{Name: name, SHA: sha}
+
+	dst := s.baselinePath(datasetID)
+	tmp := dst + ".new"
+	_ = os.Remove(tmp)
+	if err := rond.WriteBaseline(archive, tmp); err != nil {
+		return rep, fmt.Errorf("读取这份备份生成底座失败：%w", err)
+	}
+	// 成功路径会把 tmp 改名走，这里只兜住失败路径（改名后 Remove 失败无害）
+	defer func() { _ = os.Remove(tmp) }()
+	if fi, err := os.Stat(tmp); err == nil {
+		rep.Size = fi.Size()
+	}
+
+	// 判据一：这份包得跟当前数据集是同一批数据
+	matched, withUUID, err := s.visitUUIDOverlap(ctx, datasetID, tmp)
+	if err != nil {
+		return rep, fmt.Errorf("比对这份备份与当前数据集失败：%w", err)
+	}
+	rep.Matched, rep.WithUUID = matched, withUUID
+	if withUUID >= minOverlapVisits && matched == 0 {
+		return rep, &errBaselineMismatch{matched: matched, withUUID: withUUID, zero: true}
+	}
+	if !force && withUUID >= minOverlapVisits && matched*2 < withUUID {
+		return rep, &errBaselineMismatch{matched: matched, withUUID: withUUID}
+	}
+
+	// 判据二：这份底座得真的能导出（结构完整）
+	if err := rond.ExportRondbackup(ctx, s.db, datasetID, tmp, io.Discard); err != nil {
+		return rep, fmt.Errorf("用这份备份当底座导不出包，已放弃替换：%w", err)
+	}
+	if counts, err := baselineCounts(ctx, tmp); err == nil {
+		rep.Counts = counts
+	}
+	// 站内到访条数：新底座里多出来的那些不会进导出包（导出的行集合始终等于站点数据），
+	// 这点反直觉，要在提示里说出来。
+	_ = s.db.QueryRowContext(ctx, `SELECT count(*) FROM visits WHERE dataset_id=$1`, datasetID).
+		Scan(&rep.SiteVisits)
+
+	if _, err := os.Stat(dst); err == nil {
+		rep.Replaced = true
+		rep.Backup = baselineBackupName(dst, time.Now())
+		if err := os.Rename(dst, rep.Backup); err != nil {
+			return rep, fmt.Errorf("留档旧底座失败：%w", err)
+		}
+	}
+	if err := os.Rename(tmp, dst); err != nil {
+		// 尽力把旧的换回来：宁可换基线失败，也不能让数据集没有底座
+		if rep.Backup != "" {
+			if rerr := os.Rename(rep.Backup, dst); rerr != nil {
+				log.Printf("换基线失败且旧底座恢复不回去（%s）: %v", rep.Backup, rerr)
+			}
+		}
+		return rep, fmt.Errorf("替换底座失败：%w", err)
+	}
+	rep.ElapsedMs = time.Since(start).Milliseconds()
+
+	if _, err := s.db.ExecContext(ctx, `UPDATE datasets SET baseline_name=$2, baseline_sha256=$3, baseline_at=now()
+		WHERE id=$1`, datasetID, name, sha); err != nil {
+		// 底座已经换好了，导出照常；只是丢了「来源是谁」的记档，不值得回滚
+		log.Printf("换基线记档失败（数据集 %d）: %v", datasetID, err)
+	}
+	s.pruneBaselineBackups(dst)
+	return rep, nil
+}
+
+// pruneBaselineBackups 只留最近 N 份旧底座。底座库几十 MB，不留上限会慢慢堆满磁盘。
+func (s *Server) pruneBaselineBackups(dst string) {
+	baks, _ := filepath.Glob(dst + ".bak-*")
+	if len(baks) <= baselineBackupKeep {
+		return
+	}
+	sort.Slice(baks, func(i, j int) bool {
+		fi, ei := os.Stat(baks[i])
+		fj, ej := os.Stat(baks[j])
+		if ei != nil || ej != nil {
+			return false
+		}
+		return fi.ModTime().After(fj.ModTime())
+	})
+	for _, b := range baks[baselineBackupKeep:] {
+		if err := os.Remove(b); err != nil {
+			log.Printf("清理旧底座留档失败（%s）: %v", b, err)
+		}
+	}
+}
+
+// rollbackBaseline 把最近一份留档的旧底座换回来。
+//
+// 记档要一并清空：留档恰好就是「换之前的那份底座」，而换之前的那份多半是从最初上传的
+// 原始包重建的。留着新那份的 sha 会让 ensureBaseline 在文件丢失时重建出错的那一份。
+// 清空后退回「按 datasets.sha256 找原始包」的旧行为，与留档的实际来源一致。
+func (s *Server) rollbackBaseline(ctx context.Context, datasetID int64) (string, error) {
+	dst := s.baselinePath(datasetID)
+	st, err := s.baselineStatusOf(ctx, datasetID)
+	if err != nil {
+		return "", err
+	}
+	if len(st.Backups) == 0 {
+		return "", errors.New("还没有可回滚的旧底座")
+	}
+	newest := st.Backups[0]
+	consumed := filepath.Join(filepath.Dir(dst), newest.Name)
+	// 先把当前这份也留档，回滚本身也要可逆（万一回滚错了还能再滚回来）
+	if st.Exists {
+		if err := os.Rename(dst, baselineBackupName(dst, time.Now())); err != nil {
+			return "", fmt.Errorf("留档当前底座失败：%w", err)
+		}
+	}
+	if err := os.Rename(consumed, dst); err != nil {
+		return "", fmt.Errorf("恢复旧底座失败：%w", err)
+	}
+	if _, err := s.db.ExecContext(ctx, `UPDATE datasets SET baseline_name=NULL, baseline_sha256=NULL, baseline_at=NULL
+		WHERE id=$1`, datasetID); err != nil {
+		return "", fmt.Errorf("记档清理失败：%w", err)
+	}
+	s.pruneBaselineBackups(dst)
+	return newest.Name, nil
+}
+
+// ---------- 页面与动作 ----------
+
+// baselineFlash 回「换基线」页并带上提示（extra 是额外要带的查询参数，如待确认的 sha）。
+func (s *Server) baselineFlash(w http.ResponseWriter, r *http.Request, kind, msg string, extra ...string) {
+	sep := "?"
+	u := "/admin/baseline"
+	for _, e := range append([]string{kind + "=" + urlQueryEscape(msg)}, extra...) {
+		if e == "" {
+			continue
+		}
+		u += sep + e
+		sep = "&"
+	}
+	http.Redirect(w, r, u, http.StatusSeeOther)
+}
+
+// baselinePendingPrefix 标记「这份包要强制替换」的查询参数。带上它时页面多渲染一个确认按钮，
+// 不必让人把几十 MB 的包再传一遍。
+const baselinePendingPrefix = "pending="
+
+// adminBaselinePage 渲染「换基线」页。
+func (s *Server) adminBaselinePage(w http.ResponseWriter, r *http.Request) {
+	ctx := r.Context()
+	p, err := s.pageBase(r, "admin", "换基线")
+	if err != nil {
+		s.serverError(w, r, err)
+		return
+	}
+	p.SetFlashFromQuery(r)
+	d := BaselineData{Page: p, MaxSize: maxUploadBytes}
+	ds, err := s.datasetFor(ctx)
+	if err != nil {
+		s.serverError(w, r, err)
+		return
+	}
+	if ds == nil {
+		s.render(w, "admin/baseline", d)
+		return
+	}
+	d.Dataset = ds
+	st, err := s.baselineStatusOf(ctx, ds.ID)
+	if err != nil {
+		s.serverError(w, r, err)
+		return
+	}
+	d.Status = st
+	if st.Exists {
+		counts, err := baselineCounts(ctx, st.Path)
+		if err != nil {
+			d.CountsErr = "读不出底座里的行数：" + err.Error()
+		} else {
+			d.Counts = counts
+		}
+	}
+	// 数据集最初上传的那份包，用来判断「当前底座是否就是它」
+	if err := s.db.QueryRowContext(ctx, `SELECT COALESCE(original_name,''), COALESCE(sha256,'')
+		FROM datasets WHERE id=$1`, ds.ID).Scan(&d.OrigName, &d.OrigSHA); err != nil {
+		s.serverError(w, r, err)
+		return
+	}
+	d.FromOriginal = st.SHA == "" || st.SHA == d.OrigSHA
+	// 待强制确认的那份包（刚上传、判据没过，但内容已经收进 uploads 了）
+	if sha := r.URL.Query().Get("pending"); sha != "" {
+		if _, err := s.findUploadBySha(sha, 0); err == nil {
+			q := r.URL.Query()
+			d.PendingSHA = sha
+			d.PendingName = q.Get("pname")
+			if d.PendingName == "" {
+				d.PendingName = "刚上传的那份备份"
+			}
+			d.PendingMatched, _ = strconv.Atoi(q.Get("pm"))
+			d.PendingWith, _ = strconv.Atoi(q.Get("pw"))
+		}
+	}
+	s.render(w, "admin/baseline", d)
+}
+
+// adminBaselineUpload 收下作为新底座的备份并立即尝试替换。
+//
+// 判据没过时**不报错就算了**：包已经收进 uploads，页面给一个「强制替换」按钮，
+// 让站长确认后直接用它，不必为了勾一下复选框把几十 MB 再传一遍。
+func (s *Server) adminBaselineUpload(w http.ResponseWriter, r *http.Request) {
+	ctx := r.Context()
+	ds, err := s.datasetFor(ctx)
+	if err != nil {
+		s.serverError(w, r, err)
+		return
+	}
+	if ds == nil {
+		s.baselineFlash(w, r, "err", "还没有可换底座的数据集，请先导入一份备份")
+		return
+	}
+	r.Body = http.MaxBytesReader(w, r.Body, maxUploadBytes+1<<20)
+	if err := r.ParseMultipartForm(32 << 20); err != nil {
+		s.baselineFlash(w, r, "err", "读取上传内容失败："+err.Error())
+		return
+	}
+	file, hdr, err := r.FormFile("backup")
+	if err != nil {
+		s.baselineFlash(w, r, "err", "请选择要作为底座的 .rondbackup 文件")
+		return
+	}
+	defer file.Close()
+	name := filepath.Base(hdr.Filename)
+	lower := strings.ToLower(name)
+	if !strings.HasSuffix(lower, ".rondbackup") && !strings.HasSuffix(lower, ".zip") {
+		s.baselineFlash(w, r, "err", "文件类型不正确，请上传 rond 导出的 .rondbackup 备份")
+		return
+	}
+
+	// 先落到临时目录算摘要（不能在 uploads 里算：那一份会把自己认成「已存在」）
+	tmpDir, err := ingest.TempDir(s.cfg.DataDir, "baseline")
+	if err != nil {
+		s.serverError(w, r, err)
+		return
+	}
+	defer os.RemoveAll(tmpDir)
+	incoming := filepath.Join(tmpDir, sanitize(name))
+	out, err := os.Create(incoming)
+	if err != nil {
+		s.serverError(w, r, err)
+		return
+	}
+	n, cerr := io.Copy(out, io.LimitReader(file, maxUploadBytes+1))
+	if err := out.Close(); err != nil && cerr == nil {
+		cerr = err
+	}
+	if cerr != nil {
+		s.baselineFlash(w, r, "err", "读取文件失败："+cerr.Error())
+		return
+	}
+	if n > maxUploadBytes {
+		s.baselineFlash(w, r, "err", "备份文件过大，疑似不是 rond 备份")
+		return
+	}
+	sha, size, err := ingest.File(incoming)
+	if err != nil {
+		s.baselineFlash(w, r, "err", "读取备份失败："+err.Error())
+		return
+	}
+	stored, err := s.stashUpload(incoming, name, sha, size)
+	if err != nil {
+		s.serverError(w, r, err)
+		return
+	}
+
+	rep, err := s.swapBaseline(ctx, ds.ID, stored, name, sha, r.FormValue("force") != "")
+	if err != nil {
+		var mism *errBaselineMismatch
+		if errors.As(err, &mism) && !mism.zero {
+			// 包已经收好了，让站长在页面上点一下确认即可，不必重传
+			s.baselineFlash(w, r, "err", err.Error(),
+				baselinePendingPrefix+sha, "pname="+urlQueryEscape(name),
+				fmt.Sprintf("pm=%d", mism.matched), fmt.Sprintf("pw=%d", mism.withUUID))
+			return
+		}
+		s.baselineFlash(w, r, "err", err.Error())
+		return
+	}
+	s.baselineFlash(w, r, "ok", baselineSwapMessage(rep, ds.Name))
+}
+
+// adminBaselineConfirm 用页面上的「强制替换」按钮落地一份已经收好的包（不重传）。
+func (s *Server) adminBaselineConfirm(w http.ResponseWriter, r *http.Request) {
+	ctx := r.Context()
+	ds, err := s.datasetFor(ctx)
+	if err != nil {
+		s.serverError(w, r, err)
+		return
+	}
+	if ds == nil {
+		s.baselineFlash(w, r, "err", "还没有可换底座的数据集")
+		return
+	}
+	if err := r.ParseForm(); err != nil {
+		s.baselineFlash(w, r, "err", "读取表单失败："+err.Error())
+		return
+	}
+	sha := strings.TrimSpace(r.FormValue("sha"))
+	if len(sha) != 64 {
+		s.baselineFlash(w, r, "err", "要替换的备份已失效，请重新上传")
+		return
+	}
+	stored, err := s.findUploadBySha(sha, 0)
+	if err != nil {
+		s.baselineFlash(w, r, "err", "找不到那份备份了，请重新上传")
+		return
+	}
+	name := filepath.Base(stored)
+	if n := strings.TrimSpace(r.FormValue("name")); n != "" {
+		name = filepath.Base(n)
+	}
+	rep, err := s.swapBaseline(ctx, ds.ID, stored, name, sha, true)
+	if err != nil {
+		s.baselineFlash(w, r, "err", err.Error())
+		return
+	}
+	s.baselineFlash(w, r, "ok", "已按确认强制替换。"+baselineSwapMessage(rep, ds.Name))
+}
+
+// adminBaselineRollback 回滚到上一份底座。
+func (s *Server) adminBaselineRollback(w http.ResponseWriter, r *http.Request) {
+	ctx := r.Context()
+	ds, err := s.datasetFor(ctx)
+	if err != nil {
+		s.serverError(w, r, err)
+		return
+	}
+	if ds == nil {
+		s.baselineFlash(w, r, "err", "还没有可换底座的数据集")
+		return
+	}
+	name, err := s.rollbackBaseline(ctx, ds.ID)
+	if err != nil {
+		s.baselineFlash(w, r, "err", "回滚失败："+err.Error())
+		return
+	}
+	s.baselineFlash(w, r, "ok", "已回滚到旧底座（"+name+"）。当前底座记录的来源已清空，导出照常可用。")
+}
+
+// adminBaselineRebuild 按记档（或最初上传的包）重建底座文件。
+// 底座库被误删、或换了机器没带 baselines 目录时用得上——导出时其实也会自动重建，
+// 这里给一个能立刻看到结果、并把「重建不出来」说清楚的入口。
+func (s *Server) adminBaselineRebuild(w http.ResponseWriter, r *http.Request) {
+	ctx := r.Context()
+	ds, err := s.datasetFor(ctx)
+	if err != nil {
+		s.serverError(w, r, err)
+		return
+	}
+	if ds == nil {
+		s.baselineFlash(w, r, "err", "还没有可换底座的数据集")
+		return
+	}
+	path := s.baselinePath(ds.ID)
+	tmp := path + ".new"
+	_ = os.Remove(tmp)
+	// 先写临时文件、成功了再改名就位：重建失败时不能让数据集连底座都没有
+	if err := s.ensureBaselineTo(ctx, ds.ID, tmp); err != nil {
+		_ = os.Remove(tmp)
+		s.baselineFlash(w, r, "err", "重建底座失败："+err.Error())
+		return
+	}
+	if err := os.Rename(tmp, path); err != nil {
+		_ = os.Remove(tmp)
+		s.baselineFlash(w, r, "err", "就位底座失败："+err.Error())
+		return
+	}
+	fi, _ := os.Stat(path)
+	size := int64(0)
+	if fi != nil {
+		size = fi.Size()
+	}
+	s.baselineFlash(w, r, "ok", fmt.Sprintf("已重建底座（%s）。", fmtSize(size)))
+}
+
+// stashUpload 把一份上传件收进 uploads，供以后按摘要找回（换基线记档要用）。
+// 内容已经在 uploads 里就不再存第二份：底座库几十 MB，重复堆几份纯属浪费。
+func (s *Server) stashUpload(incoming, name, sha string, size int64) (string, error) {
+	if exist, err := s.findUploadBySha(sha, size); err == nil && exist != "" {
+		return exist, nil
+	}
+	if err := os.MkdirAll(s.cfg.UploadDir, 0o755); err != nil {
+		return "", err
+	}
+	dst := filepath.Join(s.cfg.UploadDir, fmt.Sprintf("%d-%s", time.Now().Unix(), sanitize(name)))
+	if err := os.Rename(incoming, dst); err != nil {
+		// 跨卷（临时目录与 uploads 不在同一个卷）时退回复制
+		if cerr := copyFileShallow(incoming, dst); cerr != nil {
+			return "", fmt.Errorf("保存备份失败：%w", cerr)
+		}
+	}
+	return dst, nil
+}
+
+// copyFileShallow 是给 stashUpload 用的兜底拷贝（rename 跨卷失败时）。
+func copyFileShallow(src, dst string) error {
+	in, err := os.Open(src)
+	if err != nil {
+		return err
+	}
+	defer in.Close()
+	out, err := os.Create(dst)
+	if err != nil {
+		return err
+	}
+	if _, err := io.Copy(out, in); err != nil {
+		out.Close()
+		return err
+	}
+	return out.Close()
+}
+
+// baselineSwapMessage 拼一条说清楚「换了什么」的提示：替换前后底座的行数对比。
+func baselineSwapMessage(rep baselineReport, datasetName string) string {
+	var b strings.Builder
+	if rep.Replaced {
+		fmt.Fprintf(&b, "已换底座：%s（%s）。旧底座已留档，可回滚。", rep.Name, fmtSize(rep.Size))
+	} else {
+		fmt.Fprintf(&b, "已为数据集 #%s 建立底座：%s（%s）。", datasetName, rep.Name, fmtSize(rep.Size))
+	}
+	if rep.WithUUID > 0 {
+		fmt.Fprintf(&b, " 这份包与站内 %d/%d 条带 UUID 的到访对得上。", rep.Matched, rep.WithUUID)
+	}
+	for _, c := range rep.Counts {
+		if c.Table == "ZVISIT" || c.Table == "ZLOCATION" {
+			fmt.Fprintf(&b, " %s %d；", c.Label, c.N)
+		}
+	}
+	b.WriteString(" 站点数据一行没动，导出即刻以新底座为准。")
+	// 反直觉的一条：底座里比站内多出来的到访会被导出清掉（导出的行集合以站点数据为准）。
+	// 不说清楚的话，站长会以为「换了更新的手机包 ⇒ 导出的包里就有手机上的新记录」。
+	if extra := baselineCountValue(rep.Counts, "ZVISIT") - rep.SiteVisits; extra > 0 {
+		fmt.Fprintf(&b, " ⚠️ 新底座里有 %d 条到访是站内还没有的，它们不会进导出包"+
+			"（导出的行集合以站点数据为准）：想让它们进包，先用「分析差异」把这份备份合并进来，再来换底座。", extra)
+	}
+	return b.String()
+}
+
+// baselineCountValue 取画像里某张表的行数（没有这张表就是 0）。
+func baselineCountValue(counts []baselineCount, table string) int {
+	for _, c := range counts {
+		if c.Table == table {
+			return c.N
+		}
+	}
+	return 0
+}

internal/web/baseline_swap_test.go

@@ -0,0 +1,561 @@
+package web
+
+import (
+	"bytes"
+	"crypto/sha256"
+	"database/sql"
+	"encoding/base64"
+	"encoding/hex"
+	"errors"
+	"mime/multipart"
+	"net/http"
+	"net/http/httptest"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+	"time"
+
+	"rond-with-you/internal/ingest"
+	"rond-with-you/internal/rond"
+)
+
+// ---------- 换基线 ----------
+//
+// 这些用例守的是「底座换代」这件事的几条底线：
+// 站点数据一行不动、底座文件真的换了、旧底座留档可回滚、记档能撑住重建、
+// 以及**不能把一份不相干的包换进来**（那是唯一会让导出包整个错位的操作）。
+
+func baselineSHA(t *testing.T, path string) string {
+	t.Helper()
+	b, err := os.ReadFile(path)
+	if err != nil {
+		t.Fatalf("读 %s 失败: %v", path, err)
+	}
+	sum := sha256.Sum256(b)
+	return hex.EncodeToString(sum[:])
+}
+
+// baselinePackageFile 把一份包写到临时文件，当作「新底座」用。
+// 传当前数据集的导出结果最贴近真实情形：它与原始包不是同一个文件（编号、WAL、私有列都不同），
+// 但到访 UUID 与站点完全一致。
+func baselinePackageFile(t *testing.T, name string, blob []byte) (path, sha string, size int64) {
+	t.Helper()
+	p := filepath.Join(t.TempDir(), name)
+	if err := os.WriteFile(p, blob, 0o644); err != nil {
+		t.Fatalf("写 %s 失败: %v", p, err)
+	}
+	sha, size, err := ingest.File(p)
+	if err != nil {
+		t.Fatalf("算摘要失败: %v", err)
+	}
+	return p, sha, size
+}
+
+// exportVisitUUIDs 读导出包里全部到访的身份（小写 hex），排序后返回。
+// 这是「换底座有没有把行搬到别的编号空间」最锋利的判据：编号会换、身份不该换。
+func exportVisitUUIDs(t *testing.T, edb *sql.DB) []string {
+	t.Helper()
+	rows, err := edb.Query(`SELECT COALESCE(hex(ZIDENTIFIER_),'') FROM ZVISIT ORDER BY 1`)
+	if err != nil {
+		t.Fatalf("读导出包的到访身份失败: %v", err)
+	}
+	defer rows.Close()
+	var out []string
+	for rows.Next() {
+		var s string
+		if err := rows.Scan(&s); err != nil {
+			t.Fatalf("读导出包的到访身份失败: %v", err)
+		}
+		out = append(out, s)
+	}
+	if err := rows.Err(); err != nil {
+		t.Fatalf("读导出包的到访身份失败: %v", err)
+	}
+	return out
+}
+
+func sameStrings(a, b []string) bool {
+	if len(a) != len(b) {
+		return false
+	}
+	for i := range a {
+		if a[i] != b[i] {
+			return false
+		}
+	}
+	return true
+}
+
+// siteCounts 数站点的到访与地点，用来断言「换底座不动数据」。
+func siteCounts(t *testing.T, f *movementFixture) (visits, places int) {
+	t.Helper()
+	if err := f.pg.QueryRowContext(f.ctx, `SELECT
+		(SELECT count(*) FROM visits WHERE dataset_id=$1),
+		(SELECT count(*) FROM places WHERE dataset_id=$1)`, f.dsID).Scan(&visits, &places); err != nil {
+		t.Fatalf("数站点数据失败: %v", err)
+	}
+	return
+}
+
+// baselineRecord 读换基线的记档。
+func baselineRecord(t *testing.T, f *movementFixture) (name, sha string, at sql.NullTime) {
+	t.Helper()
+	if err := f.pg.QueryRowContext(f.ctx, `SELECT COALESCE(baseline_name,''), COALESCE(baseline_sha256,''), baseline_at
+		FROM datasets WHERE id=$1`, f.dsID).Scan(&name, &sha, &at); err != nil {
+		t.Fatalf("读记档失败: %v", err)
+	}
+	return
+}
+
+// scrambleVisitUUIDs 把站内到访留档里的 UUID 换成同一组假值：换完之后，
+// 任何真实包里都找不到这些身份。
+//
+// 只动留档（entity_raw），不动 visits 表——到访本身还在，只是「认不出身份」了。
+// 这正是「拿一份别的数据集的包来换底座」时站内看到的样子。
+func scrambleVisitUUIDs(t *testing.T, f *movementFixture, only int) {
+	t.Helper()
+	fake := base64.StdEncoding.EncodeToString([]byte("0123456789abcdef"))
+	q := `UPDATE entity_raw SET raw = jsonb_set(raw, '{ZIDENTIFIER_,$blob}', to_jsonb($2::text))
+		WHERE dataset_id=$1 AND entity='ZVISIT' AND raw->'ZIDENTIFIER_' IS NOT NULL`
+	if only > 0 {
+		q += ` AND src_pk IN (SELECT src_pk FROM entity_raw WHERE dataset_id=$1 AND entity='ZVISIT'
+			AND raw->'ZIDENTIFIER_' IS NOT NULL ORDER BY src_pk LIMIT $3)`
+		if _, err := f.pg.ExecContext(f.ctx, q, f.dsID, fake, only); err != nil {
+			t.Fatalf("改写留档 UUID 失败: %v", err)
+		}
+		return
+	}
+	if _, err := f.pg.ExecContext(f.ctx, q, f.dsID, fake); err != nil {
+		t.Fatalf("改写留档 UUID 失败: %v", err)
+	}
+}
+
+// TestSwapBaselineRebasesExportAndKeepsData 换底座成功路径：
+// 底座文件真的换了、旧底座留档、记档写入、站点数据一行不动、导出内容逐条不变。
+func TestSwapBaselineRebasesExportAndKeepsData(t *testing.T) {
+	f := newMovementFixture(t)
+	ctx, dsID, srv := f.ctx, f.dsID, f.srv
+	if _, err := srv.ensureBaseline(ctx, dsID); err != nil {
+		t.Fatalf("准备底座失败: %v", err)
+	}
+	base := srv.baselinePath(dsID)
+	oldSHA := baselineSHA(t, base)
+	visitsBefore, placesBefore := siteCounts(t, f)
+	var arrivalBefore time.Time
+	if err := f.pg.QueryRowContext(ctx, `SELECT arrival FROM visits WHERE dataset_id=$1
+		ORDER BY src_pk LIMIT 1`, dsID).Scan(&arrivalBefore); err != nil {
+		t.Fatalf("取样本到访失败: %v", err)
+	}
+
+	// 拿「换底座之前导出的那一份包」当新底座。先记下它的内容，换完再对一遍。
+	blob := f.export(t)
+	edbBefore := openExport(t, blob)
+	visitsInExport := countExportAll(t, edbBefore)
+	uuidsBefore := exportVisitUUIDs(t, edbBefore)
+	pkg, sha, _ := baselinePackageFile(t, "new-base.rondbackup", blob)
+
+	rep, err := srv.swapBaseline(ctx, dsID, pkg, "new-base.rondbackup", sha, false)
+	if err != nil {
+		t.Fatalf("换底座失败: %v", err)
+	}
+	if rep.WithUUID < minOverlapVisits {
+		t.Fatalf("样本量太小（%d 条带 UUID 的到访），用例前提不成立", rep.WithUUID)
+	}
+	// 同一批数据的包应当条条对得上：对不上就说明这条判据本身有问题
+	if rep.Matched != rep.WithUUID {
+		t.Errorf("同一批数据的包应当全部对上，实际 %d/%d", rep.Matched, rep.WithUUID)
+	}
+	if !rep.Replaced {
+		t.Error("原本已有底座，应当报告为「替换」而不是「首次建立」")
+	}
+
+	// ① 底座文件真的换了，旧的那份进了留档
+	if got := baselineSHA(t, base); got == oldSHA {
+		t.Error("底座文件没变，替换没生效")
+	}
+	if rep.Backup == "" {
+		t.Fatal("没有留档旧底座")
+	}
+	if got := baselineSHA(t, rep.Backup); got != oldSHA {
+		t.Errorf("留档的不是旧底座：%s != %s", got, oldSHA)
+	}
+	// ② 记档
+	name, recSHA, at := baselineRecord(t, f)
+	if name != "new-base.rondbackup" || recSHA != sha || !at.Valid {
+		t.Errorf("记档不对：name=%q sha=%q at=%v", name, recSHA, at)
+	}
+	// ③ 站点数据一行没动
+	visitsAfter, placesAfter := siteCounts(t, f)
+	if visitsAfter != visitsBefore || placesAfter != placesBefore {
+		t.Errorf("换底座动了站点数据：到访 %d→%d、地点 %d→%d",
+			visitsBefore, visitsAfter, placesBefore, placesAfter)
+	}
+	var arrivalAfter time.Time
+	if err := f.pg.QueryRowContext(ctx, `SELECT arrival FROM visits WHERE dataset_id=$1
+		ORDER BY src_pk LIMIT 1`, dsID).Scan(&arrivalAfter); err != nil {
+		t.Fatalf("取样本到访失败: %v", err)
+	}
+	if !arrivalAfter.Equal(arrivalBefore) {
+		t.Errorf("样本到访的到达时间被改了：%v → %v", arrivalBefore, arrivalAfter)
+	}
+	// ④ 导出的内容逐条不变：换了编号空间，身份（UUID）不该动。
+	// 只要有一行在新底座里认不出身份，它就会被按「新行」补一个派生 UUID 插到最大编号之后，
+	// 这里立刻会亮。
+	edbAfter := openExport(t, f.export(t))
+	if n := countExportAll(t, edbAfter); n != visitsInExport {
+		t.Errorf("换底座改变了导出包的到访数：%d → %d", visitsInExport, n)
+	}
+	if got := exportVisitUUIDs(t, edbAfter); !sameStrings(got, uuidsBefore) {
+		t.Errorf("换底座改变了导出包里到访的身份（%d 条 → %d 条），说明有行在新底座里没对上",
+			len(uuidsBefore), len(got))
+	}
+}
+
+// TestEnsureBaselinePrefersRecordedPackage 底座文件丢了要按记档重建。
+//
+// 这是换底座必须配的一环：datasets.sha256 指的是**最初**那份包，
+// 只认它的话，底座一丢就会被悄悄重建回旧包——站长上一次换基线白做，且毫无提示。
+func TestEnsureBaselinePrefersRecordedPackage(t *testing.T) {
+	f := newMovementFixture(t)
+	ctx, dsID, srv := f.ctx, f.dsID, f.srv
+	if _, err := srv.ensureBaseline(ctx, dsID); err != nil {
+		t.Fatalf("准备底座失败: %v", err)
+	}
+	base := srv.baselinePath(dsID)
+
+	pkg, sha, size := baselinePackageFile(t, "new-base.rondbackup", f.export(t))
+	// 换底座时上传件会收进 uploads，重建就靠它
+	if _, err := srv.stashUpload(pkg, "new-base.rondbackup", sha, size); err != nil {
+		t.Fatalf("收下上传件失败: %v", err)
+	}
+	stored, err := srv.findUploadBySha(sha, 0)
+	if err != nil {
+		t.Fatalf("收下的包找不回来: %v", err)
+	}
+	t.Cleanup(func() { os.Remove(stored) })
+	if _, err := srv.swapBaseline(ctx, dsID, stored, "new-base.rondbackup", sha, false); err != nil {
+		t.Fatalf("换底座失败: %v", err)
+	}
+
+	// 把「最初那份包」的摘要指向一个不存在的值，逼出「按 datasets.sha256 找原始包」必然失败
+	if _, err := f.pg.ExecContext(ctx, `UPDATE datasets SET sha256=$2 WHERE id=$1`,
+		dsID, strings.Repeat("0", 64)); err != nil {
+		t.Fatalf("改写数据集摘要失败: %v", err)
+	}
+	if err := os.Remove(base); err != nil {
+		t.Fatalf("删底座失败: %v", err)
+	}
+	if _, err := srv.ensureBaseline(ctx, dsID); err != nil {
+		t.Fatalf("应当按记档的那份包重建底座，实际报错: %v", err)
+	}
+	if _, err := os.Stat(base); err != nil {
+		t.Error("底座没有被重建")
+	}
+
+	// 反证：把记档也清掉，同一条路就走不通了 —— 说明上面那次成功确实是记档起的作用，
+	// 不是别的兜底把用例弄绿了。
+	if _, err := f.pg.ExecContext(ctx, `UPDATE datasets SET baseline_sha256=NULL, baseline_name=NULL
+		WHERE id=$1`, dsID); err != nil {
+		t.Fatalf("清记档失败: %v", err)
+	}
+	if err := os.Remove(base); err != nil {
+		t.Fatalf("删底座失败: %v", err)
+	}
+	if _, err := srv.ensureBaseline(ctx, dsID); err == nil {
+		t.Error("记档清掉后不该还能重建（原始包已不可用）")
+	}
+}
+
+// TestSwapBaselineAsksBeforePartialMismatch 重合率偏低时先问一句；
+// 站长点了确认（force）才放行。
+func TestSwapBaselineAsksBeforePartialMismatch(t *testing.T) {
+	f := newMovementFixture(t)
+	ctx, dsID, srv := f.ctx, f.dsID, f.srv
+	if _, err := srv.ensureBaseline(ctx, dsID); err != nil {
+		t.Fatalf("准备底座失败: %v", err)
+	}
+	base := srv.baselinePath(dsID)
+
+	// 先导出（此时包里的 UUID 还是真的），再把大部分站内到访的身份改掉
+	pkg, sha, _ := baselinePackageFile(t, "partial.rondbackup", f.export(t))
+	visitsBefore, _ := siteCounts(t, f)
+	scrambleVisitUUIDs(t, f, visitsBefore*7/10)
+	oldSHA := baselineSHA(t, base)
+
+	_, err := srv.swapBaseline(ctx, dsID, pkg, "partial.rondbackup", sha, false)
+	var mism *errBaselineMismatch
+	if err == nil {
+		t.Fatal("重合率不到一半，不该直接放行")
+	}
+	if !errors.As(err, &mism) || mism.zero {
+		t.Fatalf("应当是「需确认」而不该是「一条都对不上」: %v", err)
+	}
+	if baselineSHA(t, base) != oldSHA {
+		t.Error("被拦下了却已经把底座换了")
+	}
+	if _, recSHA, _ := baselineRecord(t, f); recSHA != "" {
+		t.Error("被拦下了却写了记档")
+	}
+
+	// 站长确认后放行
+	rep, err := srv.swapBaseline(ctx, dsID, pkg, "partial.rondbackup", sha, true)
+	if err != nil {
+		t.Fatalf("确认后仍无法替换: %v", err)
+	}
+	if rep.Replaced && baselineSHA(t, base) == oldSHA {
+		t.Error("确认后底座文件仍然没变")
+	}
+	if _, recSHA, _ := baselineRecord(t, f); recSHA != sha {
+		t.Error("确认替换后没写记档")
+	}
+}
+
+// TestSwapBaselineRefusesTotallyUnrelated 一条都对不上时，连「强制」都不给过。
+// 这种情况下换下去没有任何一处能对齐，等于把整个导出包搬到另一个编号空间上。
+func TestSwapBaselineRefusesTotallyUnrelated(t *testing.T) {
+	f := newMovementFixture(t)
+	ctx, dsID, srv := f.ctx, f.dsID, f.srv
+	if _, err := srv.ensureBaseline(ctx, dsID); err != nil {
+		t.Fatalf("准备底座失败: %v", err)
+	}
+	base := srv.baselinePath(dsID)
+
+	pkg, sha, _ := baselinePackageFile(t, "foreign.rondbackup", f.export(t))
+	scrambleVisitUUIDs(t, f, 0) // 全部
+	oldSHA := baselineSHA(t, base)
+
+	for _, force := range []bool{false, true} {
+		_, err := srv.swapBaseline(ctx, dsID, pkg, "foreign.rondbackup", sha, force)
+		var mism *errBaselineMismatch
+		if err == nil {
+			t.Fatalf("force=%v 时一份完全对不上的包也不该被接受", force)
+		}
+		if !errors.As(err, &mism) || !mism.zero {
+			t.Fatalf("force=%v 时应当判定为「一条都对不上」: %v", force, err)
+		}
+	}
+	if baselineSHA(t, base) != oldSHA {
+		t.Error("被拒绝却已经把底座换了")
+	}
+	if _, recSHA, _ := baselineRecord(t, f); recSHA != "" {
+		t.Error("被拒绝却写了记档")
+	}
+}
+
+// TestSwapBaselineRejectsNonPackage 不是备份包的文件要在第一步就被挡住：
+// 生成底座失败 ⇒ 既不换文件也不写记档，数据集保持原样可用。
+func TestSwapBaselineRejectsNonPackage(t *testing.T) {
+	f := newMovementFixture(t)
+	ctx, dsID, srv := f.ctx, f.dsID, f.srv
+	if _, err := srv.ensureBaseline(ctx, dsID); err != nil {
+		t.Fatalf("准备底座失败: %v", err)
+	}
+	base := srv.baselinePath(dsID)
+	oldSHA := baselineSHA(t, base)
+
+	junk := filepath.Join(t.TempDir(), "junk.rondbackup")
+	if err := os.WriteFile(junk, []byte("这不是备份包"), 0o644); err != nil {
+		t.Fatal(err)
+	}
+	if _, err := srv.swapBaseline(ctx, dsID, junk, "junk.rondbackup", strings.Repeat("a", 64), true); err == nil {
+		t.Fatal("不是备份包却换成功了")
+	}
+	if baselineSHA(t, base) != oldSHA {
+		t.Error("被拒绝却已经把底座换了")
+	}
+	if _, recSHA, _ := baselineRecord(t, f); recSHA != "" {
+		t.Error("被拒绝却写了记档")
+	}
+}
+
+// TestRollbackBaselineRestoresPrevious 回滚要把旧底座换回来、记档清空，
+// 并且当前这份也要留档（回滚本身也得可逆）。
+func TestRollbackBaselineRestoresPrevious(t *testing.T) {
+	f := newMovementFixture(t)
+	ctx, dsID, srv := f.ctx, f.dsID, f.srv
+	if _, err := srv.ensureBaseline(ctx, dsID); err != nil {
+		t.Fatalf("准备底座失败: %v", err)
+	}
+	base := srv.baselinePath(dsID)
+	oldSHA := baselineSHA(t, base)
+
+	pkg, sha, _ := baselinePackageFile(t, "new-base.rondbackup", f.export(t))
+	if _, err := srv.swapBaseline(ctx, dsID, pkg, "new-base.rondbackup", sha, false); err != nil {
+		t.Fatalf("换底座失败: %v", err)
+	}
+	newSHA := baselineSHA(t, base)
+	if newSHA == oldSHA {
+		t.Fatal("换底座没生效，后续断言没有意义")
+	}
+
+	if _, err := srv.rollbackBaseline(ctx, dsID); err != nil {
+		t.Fatalf("回滚失败: %v", err)
+	}
+	if got := baselineSHA(t, base); got != oldSHA {
+		t.Errorf("回滚后底座不是原来那份：%s != %s", got, oldSHA)
+	}
+	if _, recSHA, at := baselineRecord(t, f); recSHA != "" || at.Valid {
+		t.Error("回滚后应当清空记档（表示来源是数据集最初那份包）")
+	}
+	// 被回滚掉的那份也要留档，否则滚错了就回不去
+	st, err := srv.baselineStatusOf(ctx, dsID)
+	if err != nil {
+		t.Fatalf("读底座状态失败: %v", err)
+	}
+	found := false
+	for _, b := range st.Backups {
+		if baselineSHA(t, filepath.Join(filepath.Dir(base), b.Name)) == newSHA {
+			found = true
+		}
+	}
+	if !found {
+		t.Error("回滚时没有把当前这份也留档，滚错了就回不去了")
+	}
+}
+
+// TestBaselineUploadHandlerSwapsAndRecords 走一次真实的「上传并换底座」处理函数：
+// 303 回页面带提示、底座真的换了、上传件留在 uploads（以后底座丢了要按摘要找回它）。
+func TestBaselineUploadHandlerSwapsAndRecords(t *testing.T) {
+	f := newMovementFixture(t)
+	ctx, dsID, srv := f.ctx, f.dsID, f.srv
+	if _, err := srv.ensureBaseline(ctx, dsID); err != nil {
+		t.Fatalf("准备底座失败: %v", err)
+	}
+	base := srv.baselinePath(dsID)
+	oldSHA := baselineSHA(t, base)
+
+	blob := f.export(t)
+	var buf bytes.Buffer
+	mw := multipart.NewWriter(&buf)
+	fw, err := mw.CreateFormFile("backup", "new-base.rondbackup")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if _, err := fw.Write(blob); err != nil {
+		t.Fatal(err)
+	}
+	if err := mw.Close(); err != nil {
+		t.Fatal(err)
+	}
+
+	rec := httptest.NewRecorder()
+	req := httptest.NewRequest("POST", "/admin/baseline", &buf).WithContext(ctx)
+	req.Header.Set("Content-Type", mw.FormDataContentType())
+	srv.adminBaselineUpload(rec, req)
+	if rec.Code != http.StatusSeeOther {
+		t.Fatalf("应当 303 回页面，实际 %d：%s", rec.Code, rec.Body.String())
+	}
+	loc := rec.Header().Get("Location")
+	if !strings.HasPrefix(loc, "/admin/baseline?ok=") {
+		t.Fatalf("应当带着成功提示回页面，实际 Location=%q", loc)
+	}
+	if baselineSHA(t, base) == oldSHA {
+		t.Error("处理函数跑完了但底座没换")
+	}
+	var stored string
+	if err := f.pg.QueryRowContext(ctx, `SELECT COALESCE(baseline_sha256,'') FROM datasets WHERE id=$1`, dsID).
+		Scan(&stored); err != nil {
+		t.Fatalf("读记档失败: %v", err)
+	}
+	if len(stored) != 64 {
+		t.Fatalf("记档里的摘要不对: %q", stored)
+	}
+	path, err := srv.findUploadBySha(stored, 0)
+	if err != nil {
+		t.Fatalf("上传的包没留在 uploads，底座丢了就重建不出来: %v", err)
+	}
+	t.Cleanup(func() { os.Remove(path) })
+}
+
+// TestBaselinePageRenders 页面能渲染到底（含尾部 </html>）。
+//
+// render 是流式直写，模板里的字段错（比如把 *time.Time 传给只认 time.Time 的函数）
+// 会在写到一半时中断：HTTP 200 + 一个「页脚之后整段不存在」的页面，服务端一声不吭。
+// 所以既要断言 200，也要断言动作之后的字和收尾标签。
+func TestBaselinePageRenders(t *testing.T) {
+	f := newMovementFixture(t)
+	ctx, srv := f.ctx, f.srv
+	if _, err := srv.ensureBaseline(ctx, f.dsID); err != nil {
+		t.Fatalf("准备底座失败: %v", err)
+	}
+	rec := httptest.NewRecorder()
+	req := httptest.NewRequest("GET", "/admin/baseline", nil).WithContext(ctx)
+	srv.adminBaselinePage(rec, req)
+	if rec.Code != http.StatusOK {
+		t.Fatalf("页面状态码 %d：%s", rec.Code, rec.Body.String())
+	}
+	body := rec.Body.String()
+	for _, want := range []string{"当前底座", "换成另一份包当底座", "旧底座留档"} {
+		if !strings.Contains(body, want) {
+			t.Errorf("页面里没有「%s」", want)
+		}
+	}
+	if !strings.HasSuffix(strings.TrimSpace(body), "</html>") {
+		tail := body
+		if len(tail) > 200 {
+			tail = tail[len(tail)-200:]
+		}
+		t.Errorf("页面没渲染到底（尾部不是 </html>），多半是模板中途报错了：…%s", tail)
+	}
+}
+
+// TestSwapBaselineDoesNotCarryRowsTheSiteDoesNotHave 守一条反直觉的语义：
+// 新底座里那些站点还没有的到访**不会**进导出包（导出的行集合以站点数据为准）。
+//
+// 站长很容易以为「换了更新的手机包 ⇒ 导出的包里就有手机上的新记录」，所以提示文案里
+// 必须点出这一点；而这条语义本身也不能只靠文案保证——下面用真数据验一遍。
+func TestSwapBaselineDoesNotCarryRowsTheSiteDoesNotHave(t *testing.T) {
+	f := newMovementFixture(t)
+	ctx, dsID, srv := f.ctx, f.dsID, f.srv
+	if _, err := srv.ensureBaseline(ctx, dsID); err != nil {
+		t.Fatalf("准备底座失败: %v", err)
+	}
+	uuidsBefore := exportVisitUUIDs(t, openExport(t, f.export(t)))
+
+	// 先在站内补一条到访（没有留档 ⇒ 导出时会补一个本站派生的确定性 UUID），
+	// 导出成一份「比站内多一条」的包，再把这条从站内删掉：新底座里就留下了一条
+	// 站点没有的行，正是要验证的情形。
+	seed := pickDupBase(t, srv, ctx, dsID)
+	extra, err := srv.nextSrcPK(ctx, f.pg, dsID, visitSeq)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if err := clearStaleRaw(ctx, f.pg, dsID, "ZVISIT", extra); err != nil {
+		t.Fatal(err)
+	}
+	if _, err := f.pg.ExecContext(ctx, `INSERT INTO visits
+		(dataset_id, src_pk, place_id, activity_id, arrival, departure, duration_min)
+		SELECT dataset_id, $3, place_id, activity_id, arrival, departure, duration_min
+		FROM visits WHERE dataset_id=$1 AND src_pk=$2`, dsID, seed.srcPK, extra); err != nil {
+		t.Fatal(err)
+	}
+	pkg, sha, _ := baselinePackageFile(t, "newer.rondbackup", f.export(t))
+	if _, err := f.pg.ExecContext(ctx, `DELETE FROM visits WHERE dataset_id=$1 AND src_pk=$2`,
+		dsID, extra); err != nil {
+		t.Fatal(err)
+	}
+
+	rep, err := srv.swapBaseline(ctx, dsID, pkg, "newer.rondbackup", sha, false)
+	if err != nil {
+		t.Fatalf("换底座失败: %v", err)
+	}
+	if baselineCountValue(rep.Counts, "ZVISIT") <= rep.SiteVisits {
+		t.Fatalf("用例前提不成立：新底座应当比站内多出到访，实际底座 %d / 站内 %d",
+			baselineCountValue(rep.Counts, "ZVISIT"), rep.SiteVisits)
+	}
+	if !strings.Contains(baselineSwapMessage(rep, "数据集"), "不会进导出包") {
+		t.Error("提示里没有点出「底座里多出来的到访不会进导出包」")
+	}
+
+	after := exportVisitUUIDs(t, openExport(t, f.export(t)))
+	if !sameStrings(after, uuidsBefore) {
+		t.Errorf("换到「更新」的底座后导出内容变了（%d 条 → %d 条）", len(uuidsBefore), len(after))
+	}
+	want := rond.DerivedVisitUUID(extra)
+	for _, u := range after {
+		if u == want {
+			t.Errorf("那条只在新底座里的到访（%s）被带进了导出包", u)
+		}
+	}
+}

internal/web/city_agg_test.go

@@ -0,0 +1,185 @@
+package web
+
+import (
+	"encoding/json"
+	"net/http/httptest"
+	"testing"
+
+	"rond-with-you/internal/stats"
+)
+
+// 地图上的城市圈气泡（/api/cities）必须「先按地点聚合、再按城市汇总」。
+//
+// 旧写法把聚合打在 places ⋈ visits 上，于是每个地点的 visit_count / dwell_minutes
+// 会被按它的到访条数重复累加，count(*) 又被当成「地点数」——实测最大那个城市显示
+// 「到访 72661 次 · 568 个地点」，真值是 568 次 / 86 个地点。这里按同一套口径手写一遍对账。
+func TestCityAggCountsOncePerPlace(t *testing.T) {
+	f := newMovementFixture(t)
+	ctx, pg, dsID := f.ctx, f.pg, f.dsID
+
+	rec := httptest.NewRecorder()
+	f.srv.apiCityAgg(rec, httptest.NewRequest("GET", "/api/cities", nil).WithContext(ctx))
+	if rec.Code != 200 {
+		t.Fatalf("取城市聚合失败: code=%d body=%s", rec.Code, rec.Body.String())
+	}
+	var payload struct {
+		Cities []struct {
+			City   string `json:"city"`
+			Visits int    `json:"visits"`
+			Places int    `json:"places"`
+			Dwell  int64  `json:"dwell"`
+			First  string `json:"first,omitempty"`
+			Last   string `json:"last,omitempty"`
+		} `json:"cities"`
+	}
+	if err := json.Unmarshal(rec.Body.Bytes(), &payload); err != nil {
+		t.Fatalf("解析城市聚合失败: %v", err)
+	}
+	if len(payload.Cities) == 0 {
+		t.Skip("夹具没有带城市的到访")
+	}
+
+	// 手写一份同一口径的对照（判据独立写，不复用 stats.SoloVisitSQL）：
+	// 不含已并入 / 子段，也不含「家 / 工作」地点——与 apiCityAgg 保持一致。
+	rows, err := pg.QueryContext(ctx, `SELECT p.city, count(*), count(DISTINCT p.id),
+			COALESCE(sum(LEAST(COALESCE(v.duration_min,0),10080)),0),
+			to_char(min(v.arrival), 'YYYY-MM-DD'), to_char(max(v.arrival), 'YYYY-MM-DD')
+		FROM places p JOIN visits v ON v.place_id = p.id AND v.dataset_id = p.dataset_id
+		WHERE p.dataset_id = $1 AND p.city IS NOT NULL AND p.city <> '' AND p.lat IS NOT NULL
+		  AND NOT EXISTS (SELECT 1 FROM entity_raw er
+			WHERE er.dataset_id=v.dataset_id AND er.entity='ZVISIT' AND er.src_pk=v.src_pk
+			  AND (er.raw->>'ZMERGEDTO' IS NOT NULL OR er.raw->>'ZPARENT' IS NOT NULL))
+		  AND NOT EXISTS (SELECT 1 FROM visits vh WHERE vh.place_id = p.id
+			AND (vh.is_home OR vh.is_work))
+		GROUP BY p.city`, dsID)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer rows.Close()
+	type want struct {
+		visits, places int
+		dwell          int64
+		first, last    string
+	}
+	truth := map[string]want{}
+	for rows.Next() {
+		var city string
+		var w want
+		if err := rows.Scan(&city, &w.visits, &w.places, &w.dwell, &w.first, &w.last); err != nil {
+			t.Fatal(err)
+		}
+		truth[city] = w
+	}
+	if err := rows.Err(); err != nil {
+		t.Fatal(err)
+	}
+
+	for _, c := range payload.Cities {
+		w, ok := truth[c.City]
+		if !ok {
+			t.Errorf("城市「%s」不该出现（手写 SQL 里没有）", c.City)
+			continue
+		}
+		if c.Visits != w.visits || c.Places != w.places || c.Dwell != w.dwell {
+			t.Errorf("城市「%s」聚合对不上：到访 %d/%d、地点 %d/%d、停留 %d/%d",
+				c.City, c.Visits, w.visits, c.Places, w.places, c.Dwell, w.dwell)
+		}
+		// 首末到访必须按「可见到访的到达时间」算，不能拿 places 的全量列值
+		if c.First != w.first || c.Last != w.last {
+			t.Errorf("城市「%s」首末到访对不上：%s~%s，应为 %s~%s（按可见到访算）",
+				c.City, c.First, c.Last, w.first, w.last)
+		}
+	}
+	// 保底的不变量：地点数不可能多于到访数（旧写法里这两个数就换位了）
+	for _, c := range payload.Cities {
+		if c.Places > c.Visits {
+			t.Errorf("城市「%s」的地点数 %d 多于到访数 %d，说明又按到访条数重复累加了", c.City, c.Places, c.Visits)
+		}
+	}
+
+	// 把某个地点**最晚的那次到访**标成「已并入」：该城市的最近到访必须跟着退到更早那条。
+	// 这一条专治「偷懒直接取 places.last_visit_at」——那是全量列值，不会跟着退。
+	// （光比对相同口径还不够：被并入的行大多落在父段区间内，两种算法在夹具数据上结果一样，
+	//  不做这一步就是一条假绿的断言。）
+	var placeID int64
+	var latestVisit int
+	if err := pg.QueryRowContext(ctx, `SELECT p.id, v.src_pk
+		FROM visits v JOIN places p ON p.id = v.place_id
+		WHERE v.dataset_id=$1 AND p.city IS NOT NULL AND p.city <> '' AND p.lat IS NOT NULL
+		  AND NOT EXISTS (SELECT 1 FROM visits vh WHERE vh.place_id = p.id AND (vh.is_home OR vh.is_work))
+		  AND (SELECT count(*) FROM visits v2 WHERE v2.place_id = p.id) >= 2
+		ORDER BY v.arrival DESC LIMIT 1`, dsID).Scan(&placeID, &latestVisit); err != nil {
+		t.Skipf("挑不出「同一地点有多条到访」的城市：%v", err)
+	}
+	var cityName string
+	if err := pg.QueryRowContext(ctx, `SELECT city FROM places WHERE id=$1`, placeID).Scan(&cityName); err != nil {
+		t.Fatal(err)
+	}
+	lastBefore := ""
+	lastAfterWant := ""
+	for _, c := range payload.Cities {
+		if c.City == cityName {
+			lastBefore = c.Last
+		}
+	}
+	// 真值（按城市取，标记前后各来一次）：与上面那条对账同一套口径，只是限定到某个城市
+	truthLast := func() string {
+		var s string
+		if err := pg.QueryRowContext(ctx, `SELECT to_char(max(v.arrival),'YYYY-MM-DD')
+			FROM places p JOIN visits v ON v.place_id = p.id AND v.dataset_id = p.dataset_id
+			WHERE p.dataset_id = $1 AND p.city = $2 AND p.city <> '' AND p.lat IS NOT NULL
+			  AND NOT EXISTS (SELECT 1 FROM entity_raw er
+				WHERE er.dataset_id=v.dataset_id AND er.entity='ZVISIT' AND er.src_pk=v.src_pk
+				  AND (er.raw->>'ZMERGEDTO' IS NOT NULL OR er.raw->>'ZPARENT' IS NOT NULL))
+			  AND NOT EXISTS (SELECT 1 FROM visits vh WHERE vh.place_id = p.id
+				AND (vh.is_home OR vh.is_work))`, dsID, cityName).Scan(&s); err != nil {
+			t.Fatal(err)
+		}
+		return s
+	}
+	lastBeforeWant := truthLast()
+	if lastBeforeWant != lastBefore {
+		t.Fatalf("标记前该城市的最近到访就对不上（%s vs %s），用例前提不成立", lastBefore, lastBeforeWant)
+	}
+	if _, err := pg.ExecContext(ctx, `UPDATE entity_raw
+		SET raw = jsonb_set(raw, '{ZMERGEDTO}', to_jsonb($3::int), true)
+		WHERE dataset_id=$1 AND entity='ZVISIT' AND src_pk=$2`, dsID, latestVisit, latestVisit); err != nil {
+		t.Fatal(err)
+	}
+	// 读侧取的是派生列 visits.is_merged，直接改留档之后要按生产路径刷一次
+	if _, err := pg.ExecContext(ctx, stats.RefreshMergedFlagsSQL, dsID); err != nil {
+		t.Fatal(err)
+	}
+	lastAfterWant = truthLast()
+	if lastAfterWant == lastBeforeWant {
+		t.Skipf("城市「%s」里最晚那次不是唯一的最晚记录，换一个再测", cityName)
+	}
+
+	rec2 := httptest.NewRecorder()
+	f.srv.apiCityAgg(rec2, httptest.NewRequest("GET", "/api/cities", nil).WithContext(ctx))
+	if rec2.Code != 200 {
+		t.Fatalf("取城市聚合失败: code=%d", rec2.Code)
+	}
+	var after struct {
+		Cities []struct {
+			City string `json:"city"`
+			Last string `json:"last,omitempty"`
+		} `json:"cities"`
+	}
+	if err := json.Unmarshal(rec2.Body.Bytes(), &after); err != nil {
+		t.Fatalf("解析城市聚合失败: %v", err)
+	}
+	gotLast := ""
+	for _, c := range after.Cities {
+		if c.City == cityName {
+			gotLast = c.Last
+		}
+	}
+	if gotLast == lastBeforeWant {
+		t.Errorf("把 #%d 标成已并入后，城市「%s」的最近到访仍是 %s（应退到 %s）—— 说明取的是 places 的全量列值而不是可见到访",
+			latestVisit, cityName, gotLast, lastAfterWant)
+	}
+	if gotLast != lastAfterWant {
+		t.Errorf("城市「%s」的最近到访应为 %s，实际 %s", cityName, lastAfterWant, gotLast)
+	}
+}

internal/web/client_ip_test.go

@@ -0,0 +1,65 @@
+package web
+
+import (
+	"net/http"
+	"net/http/httptest"
+	"testing"
+)
+
+// S6 回归：X-Forwarded-For 只有**最后一段**可信。
+//
+// 反代（nginx 的 `$proxy_add_x_forwarded_for`）是把客户端发来的值原样接在前面、
+// 再把真实对端补在后面。所以取第一段等于「谁想冒充谁自己填」——访客随手改个请求头
+// 就能换一个投票身份。取最后一段才是反代自己写、客户端改不动的那一个。
+func TestClientIPTrustsOnlyProxyWrittenSegment(t *testing.T) {
+	cases := []struct {
+		name   string
+		remote string
+		xff    []string
+		want   string
+	}{
+		{"没有 XFF 时用 RemoteAddr", "203.0.113.7:51234", nil, "203.0.113.7"},
+		{"RemoteAddr 不带端口", "203.0.113.7", nil, "203.0.113.7"},
+		{"单段 XFF（反代覆盖式写入）", "10.0.0.1:80", []string{"203.0.113.7"}, "203.0.113.7"},
+		{"多段 XFF 取最后一段", "10.0.0.1:80", []string{"198.51.100.9, 203.0.113.7"}, "203.0.113.7"},
+		{"最后一段两边有空格", "10.0.0.1:80", []string{"198.51.100.9 ,  203.0.113.7  "}, "203.0.113.7"},
+		{"多行 XFF 拼接后取最后", "10.0.0.1:80", []string{"198.51.100.9", "203.0.113.7"}, "203.0.113.7"},
+		{"最后一段带端口", "10.0.0.1:80", []string{"198.51.100.9, 203.0.113.7:51234"}, "203.0.113.7"},
+		{"IPv6", "10.0.0.1:80", []string{"198.51.100.9, 2001:db8::1"}, "2001:db8::1"},
+		{"IPv4-mapped IPv6 归一", "10.0.0.1:80", []string{"::ffff:203.0.113.7"}, "203.0.113.7"},
+		// 最后一段不是 IP ⇒ 整个头作废，别把垃圾当身份
+		{"最后一段是垃圾", "203.0.113.7:51234", []string{"198.51.100.9, not-an-ip"}, "203.0.113.7"},
+		{"XFF 只有垃圾", "203.0.113.7:51234", []string{"whatever"}, "203.0.113.7"},
+		{"XFF 为空串", "203.0.113.7:51234", []string{""}, "203.0.113.7"},
+	}
+	for _, c := range cases {
+		t.Run(c.name, func(t *testing.T) {
+			r := httptest.NewRequest("POST", "/api/vote", nil)
+			r.RemoteAddr = c.remote
+			for _, v := range c.xff {
+				r.Header.Add("X-Forwarded-For", v)
+			}
+			if got := clientIP(r); got != c.want {
+				t.Errorf("clientIP = %q，期望 %q", got, c.want)
+			}
+		})
+	}
+}
+
+// 真正要守的性质：只改伪造的前缀，不该改变访客身份。
+// 这条比上面任何单点断言都硬——它直接对应「换个请求头就换一票」这个攻击。
+func TestClientIPIgnoresForgedPrefix(t *testing.T) {
+	mk := func(forged string) *http.Request {
+		r := httptest.NewRequest("POST", "/api/vote", nil)
+		r.RemoteAddr = "10.0.0.1:80"
+		r.Header.Set("X-Forwarded-For", forged+", 203.0.113.7")
+		return r
+	}
+	base := clientIP(mk(""))
+	for _, forged := range []string{"1.2.3.4", "9.9.9.9", "::1", "198.51.100.9"} {
+		got := clientIP(mk(forged))
+		if got != base {
+			t.Errorf("伪造前缀 %q 让身份变成了 %q（基线 %q）——换个头就能换一票", forged, got, base)
+		}
+	}
+}

internal/web/csrf.go

@@ -0,0 +1,70 @@
+package web
+
+import (
+	"log"
+	"net/http"
+	"net/url"
+	"strings"
+)
+
+// csrfOriginGuard 挡「跨站发起的写请求」。
+//
+// 会话 cookie 是 SameSite=Lax，跨站 POST 本来就带不上 cookie；这层是纵深防御，
+// 顺手把「将来有人把 SameSite 放宽」和「同站不同源」这两条路一起堵掉。
+//
+// 判据只认浏览器一定会带的两个头，不需要给每个表单塞 token，因此模板一行都不用改：
+//   - 有 Origin：必须是本站；`Origin: null`（沙箱 iframe / file://）一律拒。
+//   - 没有 Origin 但有 Referer：必须是本站。
+//   - 两个都没有：放行 —— 跨站 POST 浏览器必带 Origin（只有 Referrer-Policy 把它
+//     一起抹掉的情况，而那时 Lax 已经把 cookie 拦在外面了），所以这里只可能是
+//     curl / 脚本这类非浏览器客户端。
+//
+// 注意：反代必须把**原始 Host** 传过来（nginx 的 `proxy_set_header Host $host`），
+// 并且改了 Host 时要带 X-Forwarded-Host；否则本站自己的表单也会被拒。
+func (s *Server) csrfOriginGuard(next http.Handler) http.Handler {
+	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		switch r.Method {
+		case http.MethodPost, http.MethodPut, http.MethodPatch, http.MethodDelete:
+		default:
+			next.ServeHTTP(w, r)
+			return
+		}
+		if !sameOriginRequest(r) {
+			log.Printf("拒绝跨站写请求 %s %s：Origin=%q Referer=%q Host=%q",
+				r.Method, r.URL.Path, r.Header.Get("Origin"), r.Header.Get("Referer"), r.Host)
+			http.Error(w, "跨站请求已被拒绝", http.StatusForbidden)
+			return
+		}
+		next.ServeHTTP(w, r)
+	})
+}
+
+// sameOriginRequest 判断写请求是不是本站自己发起的。
+func sameOriginRequest(r *http.Request) bool {
+	if o := r.Header.Get("Origin"); o != "" {
+		return matchesRequestHost(r, o)
+	}
+	if ref := r.Header.Get("Referer"); ref != "" {
+		return matchesRequestHost(r, ref)
+	}
+	return true
+}
+
+// matchesRequestHost 比较 raw（Origin 或 Referer）的 host 与本请求的 host。
+// X-Forwarded-Host 也在候选里：反代改写 Host 时靠它兜底。
+func matchesRequestHost(r *http.Request, raw string) bool {
+	u, err := url.Parse(raw)
+	if err != nil || u.Host == "" {
+		return false // 含 "null"、相对地址等无法定位来源的形态
+	}
+	if strings.EqualFold(u.Host, r.Host) {
+		return true
+	}
+	if xfh := r.Header.Get("X-Forwarded-Host"); xfh != "" {
+		if i := strings.IndexByte(xfh, ','); i >= 0 {
+			xfh = xfh[:i]
+		}
+		return strings.EqualFold(u.Host, strings.TrimSpace(xfh))
+	}
+	return false
+}

internal/web/csrf_test.go

@@ -0,0 +1,97 @@
+package web
+
+import (
+	"net/http"
+	"net/http/httptest"
+	"testing"
+)
+
+// sameOriginRequest 是 CSRF 纵深防御的核心判据。会话 cookie 已经是 SameSite=Lax，
+// 这层是防「将来有人把 SameSite 放宽」以及同站不同源。
+func TestSameOriginRequest(t *testing.T) {
+	cases := []struct {
+		name   string
+		host   string
+		origin string
+		ref    string
+		xfh    string
+		want   bool
+	}{
+		{name: "无任何来源头（curl/脚本）", host: "site.example", want: true},
+		{name: "本站 Origin", host: "site.example", origin: "http://site.example", want: true},
+		{name: "本站 Origin（带端口）", host: "site.example:8080", origin: "http://site.example:8080", want: true},
+		{name: "本站 Origin（https）", host: "site.example", origin: "https://site.example", want: true},
+		{name: "跨站 Origin", host: "site.example", origin: "http://evil.com", want: false},
+		{name: "跨站 Origin 同后缀", host: "site.example", origin: "http://site.example.evil.com", want: false},
+		{name: "Origin 为 null（沙箱 iframe）", host: "site.example", origin: "null", want: false},
+		{name: "Origin 不可解析", host: "site.example", origin: "://", want: false},
+		{name: "跨站 Referer", host: "site.example", ref: "http://evil.com/admin", want: false},
+		{name: "本站 Referer", host: "site.example", ref: "http://site.example/admin/notes", want: true},
+		{name: "Origin 优先于 Referer", host: "site.example", origin: "http://evil.com", ref: "http://site.example/x", want: false},
+		{name: "反代改写 Host，靠 XFH 兜底", host: "10.0.0.5:8080", origin: "https://site.example",
+			xfh: "site.example", want: true},
+		{name: "反代 XFH 多段取首段", host: "10.0.0.5:8080", origin: "https://site.example",
+			xfh: "site.example, proxy.internal", want: true},
+		{name: "反代 XFH 也不匹配", host: "10.0.0.5:8080", origin: "https://evil.com",
+			xfh: "site.example", want: false},
+	}
+	for _, c := range cases {
+		r := httptest.NewRequest("POST", "/admin/logout", nil)
+		r.Host = c.host
+		if c.origin != "" {
+			r.Header.Set("Origin", c.origin)
+		}
+		if c.ref != "" {
+			r.Header.Set("Referer", c.ref)
+		}
+		if c.xfh != "" {
+			r.Header.Set("X-Forwarded-Host", c.xfh)
+		}
+		if got := sameOriginRequest(r); got != c.want {
+			t.Errorf("%s: sameOriginRequest = %v，期望 %v", c.name, got, c.want)
+		}
+	}
+}
+
+// 走完整中间件链验证接线：写请求跨站被 403，读请求不受影响。
+func TestHandlerRejectsCrossOriginWrite(t *testing.T) {
+	f := newLoginFixture(t)
+	h := f.srv.Handler()
+
+	post := func(method, path, origin, ref string) int {
+		t.Helper()
+		r := httptest.NewRequest(method, path, nil)
+		if origin != "" {
+			r.Header.Set("Origin", origin)
+		}
+		if ref != "" {
+			r.Header.Set("Referer", ref)
+		}
+		w := httptest.NewRecorder()
+		h.ServeHTTP(w, r)
+		return w.Code
+	}
+
+	if code := post("POST", "/admin/logout", "http://evil.com", ""); code != http.StatusForbidden {
+		t.Errorf("跨站 POST 应 403，实际 %d", code)
+	}
+	if code := post("POST", "/admin/logout", "null", ""); code != http.StatusForbidden {
+		t.Errorf("Origin: null 的 POST 应 403，实际 %d", code)
+	}
+	if code := post("POST", "/admin/logout", "", "http://evil.com/x"); code != http.StatusForbidden {
+		t.Errorf("跨站 Referer 的 POST 应 403，实际 %d", code)
+	}
+	// 本站来源与「无来源头」都要放行到业务逻辑（不是 403 即可）
+	for _, c := range []struct{ name, origin, ref string }{
+		{"本站 Origin", "http://example.com", ""},
+		{"无来源头", "", ""},
+	} {
+		if code := post("POST", "/admin/logout", c.origin, c.ref); code == http.StatusForbidden {
+			t.Errorf("%s 的 POST 不该被拦，实际 403", c.name)
+		}
+	}
+	// GET 是读，带跨站 Origin 也不能拦（否则外链图片/预取就废了）
+	if code := post("GET", "/healthz", "http://evil.com", ""); code == http.StatusForbidden {
+		t.Errorf("GET 不该被 CSRF 守卫拦，实际 403")
+	}
+}

internal/web/css_color_test.go

@@ -0,0 +1,52 @@
+package web
+
+import (
+	"bytes"
+	"html/template"
+	"testing"
+)
+
+// TestCSSColorSurvivesTemplateSanitizer 钉住两个方向：
+//
+//  1. `var(--cat-*)` 必须原样渲染进 style。html/template 的 CSS 上下文过滤器**不认识 var()**，
+//     函数返回普通 string 会被替换成 `ZgotmplZ` —— 页面上所有类型色圆点会当场变成透明，
+//     而且不报错、模板测试也照过（实测踩过）。
+//  2. 一旦返回 template.CSS 就等于关掉这道过滤，所以**数据侧来的色值必须先严格校验**：
+//     只有「# + 6 位十六进制」才放行，否则 `#"><img …` 能直接逃出 style 属性。
+func TestCSSColorSurvivesTemplateSanitizer(t *testing.T) {
+	tpl := template.Must(template.New("t").Funcs(templateFuncs()).
+		Parse(`<i style="background:{{csscolor .C}}"></i><b style="background:{{csssoft .C}}"></b>`))
+
+	render := func(v string) string {
+		t.Helper()
+		var buf bytes.Buffer
+		if err := tpl.Execute(&buf, map[string]string{"C": v}); err != nil {
+			t.Fatalf("渲染失败（色值 %q）: %v", v, err)
+		}
+		return buf.String()
+	}
+
+	cases := []struct {
+		name string
+		in   string
+		want string
+	}{
+		{"调色板色名走 CSS 变量", "teal",
+			`<i style="background:var(--cat-teal)"></i><b style="background:var(--cat-teal-soft)"></b>`},
+		{"自定义色值原样用（浅底拼 22 当 alpha）", "#a2845e",
+			`<i style="background:#a2845e"></i><b style="background:#a2845e22"></b>`},
+		{"空值退兜底", "",
+			`<i style="background:var(--cat-none)"></i><b style="background:var(--cat-none-soft)"></b>`},
+		{"想逃出属性的串退兜底", `#"><img src=x>`,
+			`<i style="background:var(--cat-none)"></i><b style="background:var(--cat-none-soft)"></b>`},
+		{"位数不对的 hex 退兜底", "#12345",
+			`<i style="background:var(--cat-none)"></i><b style="background:var(--cat-none-soft)"></b>`},
+		{"套了别的 CSS 声明也退兜底", "red;background:url(javascript:1)",
+			`<i style="background:var(--cat-none)"></i><b style="background:var(--cat-none-soft)"></b>`},
+	}
+	for _, c := range cases {
+		if got := render(c.in); got != c.want {
+			t.Errorf("%s：csscolor/csssoft(%q)\n  得到 %s\n  期望 %s", c.name, c.in, got, c.want)
+		}
+	}
+}

internal/web/dataset_ownership_test.go

@@ -0,0 +1,234 @@
+package web
+
+import (
+	"fmt"
+	"net/http"
+	"net/http/httptest"
+	"os"
+	"path/filepath"
+	"regexp"
+	"strings"
+	"testing"
+
+	"rond-with-you/internal/db"
+)
+
+// ---------- 归属口径：删数据集只许带走「从备份导入」的数据 ----------
+//
+// 事故（2026-09-30）：place_images 与 topics 带 `dataset_id … ON DELETE CASCADE`，
+// 删掉旧数据集时把**站点自建**的记录一起删了——图片行没了、文件却还留在盘上（读取按坐标键、
+// 行按数据集级联，两套口径打架）。这类记录**不在备份里**，删掉就是永久丢失。
+//
+// 这不是靠记性能守住的事，所以做成结构性门禁：
+// 凡是要挂在 datasets 上的外键，表名必须在这份白名单里。新增一张带 dataset_id 的表时，
+// 先问一句「它的记录能不能从备份重新导入」——能，才允许随数据集删除；不能，就只留
+// dataset_id 当出处、不许挂外键（参考 place_images / topics 现在的写法）。
+
+// backupDerivedTables 是从备份导入、删了还能再导回来的那些表。删数据集时它们跟着走是对的。
+var backupDerivedTables = []string{
+	"places", "visits", "movements", "weather", "activities", "tags", "entity_raw",
+}
+
+// userOwnedTables 是站点自建、删数据集**必须留下**的表（只有列、没有外键）。
+var userOwnedTables = []string{"place_images", "place_notes", "place_votes", "topics"}
+
+// TestOnlyBackupDerivedTablesCascadeFromDatasets 运行时判据：查 pg_constraint。
+func TestOnlyBackupDerivedTablesCascadeFromDatasets(t *testing.T) {
+	f := newMovementFixture(t)
+	rows, err := f.pg.QueryContext(f.ctx, `SELECT conrelid::regclass::text, confdeltype
+		FROM pg_constraint WHERE confrelid='datasets'::regclass`)
+	if err != nil {
+		t.Fatalf("查外键失败: %v", err)
+	}
+	defer rows.Close()
+	allowed := map[string]bool{}
+	for _, n := range backupDerivedTables {
+		allowed[n] = true
+	}
+	got := map[string]string{} // 表 -> 删除行为
+	for rows.Next() {
+		var tbl, del string
+		if err := rows.Scan(&tbl, &del); err != nil {
+			t.Fatal(err)
+		}
+		got[tbl] = del
+		if !allowed[tbl] {
+			t.Errorf("%s 挂了 datasets 的外键（删除行为 %s）：它的记录不是从备份导入的，"+
+				"删数据集会连它一起删掉、且无法恢复。只留 dataset_id 当出处，不要挂外键。", tbl, del)
+		}
+	}
+	if err := rows.Err(); err != nil {
+		t.Fatal(err)
+	}
+	// 反向：白名单里的表必须还在。顺手去掉 places/visits 的级联会留下成片孤儿行，
+	// 而删数据集的提示文案是按「这些都随数据集删除」写的。
+	for _, n := range backupDerivedTables {
+		if _, ok := got[n]; !ok {
+			t.Errorf("%s 应当仍随数据集删除（现在没有 datasets 外键了）：删数据集会留下一堆孤儿行，"+
+				"或者外键变成 RESTRICT 之后干脆删不动数据集。", n)
+		}
+	}
+}
+
+// TestMigrationDropsStaleDatasetForeignKeys 「库里残留着旧外键」⇒ 跑一次迁移必须把它摘掉。
+//
+// 这条最要紧：**已经部署出去的库**上就带着那根 CASCADE 外键（本机库现在还是），
+// 光改 CREATE TABLE 救不了它——必须靠 schema.sql 里那句 ALTER TABLE … DROP CONSTRAINT。
+// 这里故意把事故原样的外键加回去，跑一次迁移，断言它们没了：迁移能自愈这件事被钉住。
+//
+// 顺带解释了为什么「运行时判据」单独看不够：测试夹具每次都会跑迁移，
+// 于是运行时那条永远不会在不健康的库上报警——真正的自愈靠这条。
+func TestMigrationDropsStaleDatasetForeignKeys(t *testing.T) {
+	f := newMovementFixture(t)
+	ctx := f.ctx
+	gone := func(table string) bool {
+		var n int
+		if err := f.pg.QueryRowContext(ctx, `SELECT count(*) FROM pg_constraint
+			WHERE conrelid=$1::regclass AND confrelid='datasets'::regclass`, table).Scan(&n); err != nil {
+			t.Fatalf("查 %s 的约束失败: %v", table, err)
+		}
+		return n == 0
+	}
+	// 先把事故原样的外键加回去（NOT VALID 跳过既有行的校验，只关心约束在不在）
+	for _, tbl := range userOwnedTables {
+		if !hasDatasetColumn(t, f, tbl) {
+			continue
+		}
+		if _, err := f.pg.ExecContext(ctx, fmt.Sprintf(
+			`ALTER TABLE %s DROP CONSTRAINT IF EXISTS %s_dataset_id_fkey`, tbl, tbl)); err != nil {
+			t.Fatalf("清理 %s 的旧约束失败: %v", tbl, err)
+		}
+		if _, err := f.pg.ExecContext(ctx, fmt.Sprintf(
+			`ALTER TABLE %s ADD CONSTRAINT %s_dataset_id_fkey
+			 FOREIGN KEY (dataset_id) REFERENCES datasets(id) ON DELETE CASCADE NOT VALID`, tbl, tbl)); err != nil {
+			t.Fatalf("给 %s 补回外键失败: %v", tbl, err)
+		}
+	}
+	// 确认变异生效（否则这条用例本身是假绿的）
+	injected := false
+	for _, tbl := range userOwnedTables {
+		if hasDatasetColumn(t, f, tbl) && !gone(tbl) {
+			injected = true
+		}
+	}
+	if !injected {
+		t.Fatal("变异没生效：没有任何一张自建数据表被挂上外键，这条用例等于没测")
+	}
+
+	if err := db.Migrate(ctx, f.pg); err != nil {
+		t.Fatalf("迁移失败: %v", err)
+	}
+	for _, tbl := range userOwnedTables {
+		if hasDatasetColumn(t, f, tbl) && !gone(tbl) {
+			t.Errorf("跑完迁移后 %s 上还挂着 datasets 的外键：那句 DROP CONSTRAINT 没生效，"+
+				"已经部署出去的库就不会自愈。", tbl)
+		}
+	}
+}
+
+// hasDatasetColumn 判断某表有没有 dataset_id 列（不是所有自建数据表都有）。
+func hasDatasetColumn(t *testing.T, f *movementFixture, table string) bool {
+	t.Helper()
+	var n int
+	if err := f.pg.QueryRowContext(f.ctx, `SELECT count(*) FROM pg_attribute
+		WHERE attrelid=$1::regclass AND attname='dataset_id' AND NOT attisdropped`,
+		table).Scan(&n); err != nil {
+		t.Fatalf("查 %s 的列失败: %v", table, err)
+	}
+	return n > 0
+}
+
+// TestSchemaDeclaresNoDatasetFKForUserData 静态判据：直接扫 schema.sql。
+//
+// 只看运行时约束有个盲点：**新建的库走的是 CREATE TABLE**，而开发库可能压根没跑过那次迁移。
+// 两边都钉住才不会漏——新加一张表时，写 CREATE TABLE 的那一刻就会被这条拦住。
+func TestSchemaDeclaresNoDatasetFKForUserData(t *testing.T) {
+	b, err := os.ReadFile(filepath.Join(moduleRoot(t), "internal", "db", "schema.sql"))
+	if err != nil {
+		t.Fatalf("读 schema.sql 失败: %v", err)
+	}
+	src := string(b)
+	allowed := map[string]bool{}
+	for _, n := range backupDerivedTables {
+		allowed[n] = true
+	}
+	userOwned := map[string]bool{}
+	for _, n := range userOwnedTables {
+		userOwned[n] = true
+	}
+
+	createRe := regexp.MustCompile(`(?i)CREATE\s+TABLE\s+(?:IF\s+NOT\s+EXISTS\s+)?([a-z_]+)`)
+	refRe := regexp.MustCompile(`(?i)REFERENCES\s+datasets\s*\(`)
+	cur := ""
+	for _, line := range strings.Split(src, "\n") {
+		// 必须先跳过注释：这份规矩的说明文字里**就写着** REFERENCES datasets(id) 这几个字，
+		// 不跳过会把自己的文档当成违规（实测就这么误报过一次）。
+		if strings.HasPrefix(strings.TrimSpace(line), "--") {
+			continue
+		}
+		if m := createRe.FindStringSubmatch(line); m != nil {
+			cur = m[1]
+		}
+		if !refRe.MatchString(line) {
+			continue
+		}
+		if cur == "" {
+			t.Errorf("有一条 datasets 的外键没归属到任何 CREATE TABLE：%s", strings.TrimSpace(line))
+			continue
+		}
+		if !allowed[cur] {
+			t.Errorf("schema.sql 里 %s 声明了 datasets 的外键：它的记录不是从备份导入的，"+
+				"删数据集会连它一起删掉（%s）。", cur, strings.TrimSpace(line))
+		}
+	}
+	// 反向：自建数据表必须**真的存在**且带 dataset_id 列（防止有人顺手删表、或漏建列，
+	// 让这条门禁失去意义）
+	for _, n := range userOwnedTables {
+		if !regexp.MustCompile(`(?i)CREATE\s+TABLE\s+(?:IF\s+NOT\s+EXISTS\s+)?` + n + `\b`).MatchString(src) {
+			t.Errorf("schema.sql 里找不到 %s 的建表语句", n)
+		}
+	}
+}
+
+// TestAdminHomeReportsOrphanImages 后台首页要当场报出「有图片文件在库里没有记录」。
+//
+// 这才是真正的预防：那次事故不是「删数据集」本身，而是**行与对象悄悄对不上、没人发现**，
+// 等到照片看不见了才追。让它每次进后台都能看到，同样的漂移下次当场就亮。
+func TestAdminHomeReportsOrphanImages(t *testing.T) {
+	f := newMovementFixture(t)
+	ctx, dsID, srv := f.ctx, f.dsID, f.srv
+	srcPK, _, lat, lon := pickPlaceWithCoords(t, f)
+	isolateImageState(t, f, lat, lon)
+	saveTwoImages(t, f, srcPK)
+
+	// 没漂移时：不该报警
+	rows, objects, orphans := srv.imageHealth(ctx)
+	if rows != 2 || objects != 2 || orphans != 0 {
+		t.Fatalf("刚存完两张应当完全对得上，实际 行%d 对象%d 落单%d", rows, objects, orphans)
+	}
+	// 制造事故形状：行没了、文件还在
+	if _, err := f.pg.ExecContext(ctx, `DELETE FROM place_images WHERE dataset_id=$1`, dsID); err != nil {
+		t.Fatal(err)
+	}
+	rows, objects, orphans = srv.imageHealth(ctx)
+	if rows != 0 || objects != 2 || orphans != 2 {
+		t.Fatalf("行删掉之后应当报 落单 2，实际 行%d 对象%d 落单%d", rows, objects, orphans)
+	}
+
+	rec := httptest.NewRecorder()
+	req := httptest.NewRequest("GET", "/admin", nil).WithContext(ctx)
+	srv.adminHome(rec, req)
+	if rec.Code != http.StatusOK {
+		t.Fatalf("后台首页状态码 %d：%s", rec.Code, rec.Body.String())
+	}
+	body := rec.Body.String()
+	if !strings.Contains(body, "落单 2 个") {
+		t.Error("后台首页没有报出落单数，漂移就还是静默的")
+	}
+	if !strings.Contains(body, "在库里没有记录") {
+		t.Error("后台首页没解释「落单」是什么意思")
+	}
+	if !strings.HasSuffix(strings.TrimSpace(body), "</html>") {
+		t.Error("后台首页没渲染到底")
+	}
+}

internal/web/download_name_test.go

@@ -0,0 +1,127 @@
+package web
+
+import (
+	"net/url"
+	"os"
+	"path/filepath"
+	"regexp"
+	"strings"
+	"testing"
+)
+
+// S9 回归：下载文件名不能从引号里「逃出去」。
+//
+// 导出包名里带着 `datasets.original_name`，也就是上传时的文件名。它原样拼进
+// `filename="…"` 时，一个 `"` 就能提前闭合引号、把后面的内容变成新的头参数
+// （`x"; filename="evil.exe`）。net/http 只把 CR/LF 换成空格，引号它不管。
+func TestDownloadDispositionCannotEscapeTheHeader(t *testing.T) {
+	// 结构：attachment; filename="<纯 ASCII 安全串>"; filename*=UTF-8''<百分号编码>
+	// 集合里必须带上 `-`：attr-char 允许它，而日期段 `-export-20260921` 全是它。
+	shape := regexp.MustCompile(`^attachment; filename="([^"]*)"; filename\*=UTF-8''([-A-Za-z0-9._~%]*)$`)
+
+	cases := []struct {
+		in   string
+		want string // 期望 filename* 解回来的原名；空表示与 in 相同
+	}{
+		{`普通名字-export-20260921.rondbackup`, ""},
+		{`a"b.rondbackup`, ""},
+		{`a"; filename="evil.exe`, ""},
+		{"换\n行\r.rondbackup", ""},
+		{`..%2f..%2fetc%2fpasswd`, ""},
+		{`C:\Windows\system32\x.rondbackup`, ""},
+		{`a;b=c:d*e?f<g>h|i.rondbackup`, ""},
+		{`日本語のバックアップ.rondbackup`, ""},
+		{"", "download"},
+		{"   ", "download"},
+	}
+
+	for _, c := range cases {
+		got := downloadDisposition(c.in)
+
+		if strings.ContainsAny(got, "\r\n") {
+			t.Errorf("%q → 头部里出现了裸的换行: %q", c.in, got)
+		}
+		if n := strings.Count(got, `"`); n != 2 {
+			t.Errorf("%q → 引号有 %d 个（必须恰好一对，多了就能逃逸）: %q", c.in, n, got)
+		}
+		m := shape.FindStringSubmatch(got)
+		if m == nil {
+			t.Errorf("%q → 头部形状不对: %q", c.in, got)
+			continue
+		}
+		if strings.ContainsAny(m[1], `"\\/:;:=*?<>|`) {
+			t.Errorf("%q → filename= 里还有危险字符: %q", c.in, m[1])
+		}
+		// 非 ASCII 名字才需要 filename* 兜底；这里统一验「能解回原名」
+		back, err := url.PathUnescape(m[2])
+		if err != nil {
+			t.Fatalf("%q → filename*= 不是合法的百分号编码: %v", c.in, err)
+		}
+		want := c.want
+		if want == "" {
+			want = c.in
+		}
+		if back != want {
+			t.Errorf("%q → filename*= 解回来是 %q，期望 %q", c.in, back, want)
+		}
+	}
+}
+
+// 纯中文名会把 filename= 整串换成下划线，此时必须保留扩展名，
+// 否则用户下到手里是个没法双击打开的「download」。
+func TestDownloadDispositionKeepsExtensionOnNonASCII(t *testing.T) {
+	got := downloadDisposition("足迹备份.rondbackup")
+	if !strings.Contains(got, `.rondbackup"`) {
+		t.Errorf("非 ASCII 名的 ASCII 兜底丢了扩展名: %q", got)
+	}
+	if !strings.HasPrefix(got, `attachment; filename="download`) {
+		t.Errorf("非 ASCII 名应当退到可读的兜底名: %q", got)
+	}
+}
+
+// S9 静态守卫：所有 Content-Disposition 都必须走 downloadDisposition，
+// 不许再手拼 f-string——手拼就是这次的成因，而且它只在特定文件名下出问题。
+func TestAllContentDispositionGoThroughHelper(t *testing.T) {
+	dir := pkgFile(t, "")
+	entries, err := os.ReadDir(dir)
+	if err != nil {
+		t.Fatalf("读包目录失败: %v", err)
+	}
+	scanned, found := 0, 0
+	for _, e := range entries {
+		if e.IsDir() || !strings.HasSuffix(e.Name(), ".go") || strings.HasSuffix(e.Name(), "_test.go") {
+			continue
+		}
+		scanned++
+		data, err := os.ReadFile(filepath.Join(dir, e.Name()))
+		if err != nil {
+			t.Fatalf("读 %s 失败: %v", e.Name(), err)
+		}
+		src := string(data)
+		for i := 0; ; {
+			j := strings.Index(src[i:], `"Content-Disposition"`)
+			if j < 0 {
+				break
+			}
+			j += i
+			found++
+			// 取一小段窗口看这次 Set 是不是用的助手
+			win := src[j:]
+			if len(win) > 200 {
+				win = win[:200]
+			}
+			if !strings.Contains(win, "downloadDisposition(") {
+				line := 1 + strings.Count(src[:j], "\n")
+				t.Errorf("%s:%d 的 Content-Disposition 没有走 downloadDisposition：%s",
+					e.Name(), line, strings.TrimSpace(strings.SplitN(win, "\n", 2)[0]))
+			}
+			i = j + 1
+		}
+	}
+	if scanned < 5 {
+		t.Fatalf("只扫了 %d 个源文件，守卫形同虚设", scanned)
+	}
+	if found < 3 {
+		t.Fatalf("只找到 %d 处 Content-Disposition（期望至少 3 处），守卫判据需要更新", found)
+	}
+}

internal/web/dup_visits_test.go

@@ -0,0 +1,803 @@
+package web
+
+import (
+	"context"
+	"crypto/rand"
+	"database/sql"
+	"encoding/base64"
+	"fmt"
+	"net/http/httptest"
+	"net/url"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+	"time"
+
+	"rond-with-you/internal/rond"
+)
+
+// 重复到访（站点侧副本）的判定与清理。夹具是「刚导入、还没被改过」的真实数据集，
+// 基线就是它当初那份手机包——判定逻辑必须在这种真数据形状上跑，不能只喂人造的小库。
+
+// dupBlob 是一条到访的 UUID（既要有 hex 用来比，也要有 base64 用来写留档）。
+type dupBlob struct {
+	hex, b64 string
+}
+
+// newDupBlob 造一个基线里绝不会有的 UUID——副本的特征就是「UUID 在基线里找不到」。
+func newDupBlob(t *testing.T) dupBlob {
+	t.Helper()
+	var b [16]byte
+	if _, err := rand.Read(b[:]); err != nil {
+		t.Fatal(err)
+	}
+	return dupBlob{hex: fmt.Sprintf("%x", b), b64: base64.StdEncoding.EncodeToString(b[:])}
+}
+
+// dupSeedBase 是被拿来当「原件」的那条到访。
+type dupSeedBase struct {
+	srcPK   int
+	arrival time.Time
+}
+
+// pickDupBase 挑一条「UUID 在手机包里也有」的到访当原件。skip 里的编号不选
+// （同一份数据里要造两对时，别把上一对的双方再拿去当原件）。
+func pickDupBase(t *testing.T, srv *Server, ctx context.Context, dsID int64, skip ...int) dupSeedBase {
+	t.Helper()
+	base, err := readDupBaseline(ctx, srv.baselinePath(dsID))
+	if err != nil {
+		t.Fatalf("读基线库失败: %v", err)
+	}
+	site, err := srv.loadDupSiteVisits(ctx, dsID)
+	if err != nil {
+		t.Fatalf("读站点到访失败: %v", err)
+	}
+	used := map[int]bool{}
+	for _, s := range skip {
+		used[s] = true
+	}
+	for _, sv := range site {
+		if sv.uuid == "" || !base.uuids[sv.uuid] || used[sv.srcPK] {
+			continue
+		}
+		var placeID int64
+		if err := srv.db.QueryRowContext(ctx, `SELECT COALESCE(place_id,0)
+			FROM visits WHERE dataset_id=$1 AND src_pk=$2`, dsID, sv.srcPK).Scan(&placeID); err != nil {
+			t.Fatal(err)
+		}
+		if placeID > 0 {
+			return dupSeedBase{srcPK: sv.srcPK, arrival: sv.arrival}
+		}
+	}
+	t.Fatal("数据集里挑不出可当原件的到访（UUID 得在基线里）")
+	return dupSeedBase{}
+}
+
+// seedDupVictim 复制一条到访造出「站点副本」，并给它配上位移 / 天气 / 留档。
+// 返回副本的 src_pk 与 UUID。
+func seedDupVictim(t *testing.T, srv *Server, ctx context.Context, dsID int64,
+	base dupSeedBase, keeper int) (int, dupBlob) {
+	t.Helper()
+	pg := srv.db
+	src, err := srv.nextSrcPK(ctx, pg, dsID, visitSeq)
+	if err != nil {
+		t.Fatalf("分配副本编号失败: %v", err)
+	}
+	if err := clearStaleRaw(ctx, pg, dsID, "ZVISIT", src); err != nil {
+		t.Fatal(err)
+	}
+	// 到访行照抄原件：现实里的副本就是合并时多出来的那一份拷贝，字段一模一样
+	// （所以才会「时间 + 地点完全相同」，光看时间是分不出来的）
+	if _, err := pg.ExecContext(ctx, `INSERT INTO visits
+		(dataset_id, src_pk, place_id, activity_id, arrival, departure, duration_min, is_home, is_work,
+		 bookmarked, is_user_added, remark, emoji, weather_symbol)
+		SELECT dataset_id, $3, place_id, activity_id, arrival, departure, duration_min, is_home, is_work,
+		 bookmarked, is_user_added, remark, emoji, weather_symbol
+		FROM visits WHERE dataset_id=$1 AND src_pk=$2`, dsID, base.srcPK, src); err != nil {
+		t.Fatalf("造副本到访失败: %v", err)
+	}
+	blob := newDupBlob(t)
+	// 留档也照抄原件那一行，只改主键与 UUID，合并标记清成 null（副本不该自称已并入别处）。
+	// 这样导出时这一行的列形状和原件一致，往返对比才有意义。
+	if _, err := pg.ExecContext(ctx, `INSERT INTO entity_raw (dataset_id, entity, src_pk, raw)
+		SELECT dataset_id, entity, $3,
+		       jsonb_set(jsonb_set(jsonb_set(jsonb_set(raw,
+		         '{Z_PK}', to_jsonb($3::int), true),
+		         '{ZIDENTIFIER_}', jsonb_build_object('$blob', $4::text), true),
+		         '{ZMERGEDTO}', 'null'::jsonb, true),
+		         '{ZPARENT}', 'null'::jsonb, true)
+		FROM entity_raw WHERE dataset_id=$1 AND entity=$2 AND src_pk=$5`,
+		dsID, "ZVISIT", src, blob.b64, base.srcPK); err != nil {
+		t.Fatalf("造副本留档失败: %v", err)
+	}
+	// 附属记录：两端各挂一条位移 + 一条天气。清理时必须连着一起走，
+	// 否则导出包里会留下指着不存在到访的悬空引用。
+	for _, ends := range [][2]int{{src, keeper}, {keeper, src}} {
+		mv, err := srv.nextSrcPK(ctx, pg, dsID, movementSeq)
+		if err != nil {
+			t.Fatal(err)
+		}
+		if err := clearStaleRaw(ctx, pg, dsID, "ZMOVEMENT", mv); err != nil {
+			t.Fatal(err)
+		}
+		if _, err := pg.ExecContext(ctx, `INSERT INTO movements
+			(dataset_id, src_pk, from_visit_src, to_visit_src) VALUES ($1,$2,$3,$4)`,
+			dsID, mv, ends[0], ends[1]); err != nil {
+			t.Fatalf("造副本位移失败: %v", err)
+		}
+	}
+	w, err := srv.nextSrcPK(ctx, pg, dsID, weatherSeq)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if err := clearStaleRaw(ctx, pg, dsID, "ZHOURLYWEATHER", w); err != nil {
+		t.Fatal(err)
+	}
+	if _, err := pg.ExecContext(ctx, `INSERT INTO weather (dataset_id, src_pk, visit_src, at)
+		VALUES ($1,$2,$3,$4)`, dsID, w, src, base.arrival); err != nil {
+		t.Fatalf("造副本天气失败: %v", err)
+	}
+	return src, blob
+}
+
+// pickReferrers 挑两条跟副本无关、两个合并标记都是空的到访留档。
+// 两条必须不同，否则「只带其中一个键」的两种情形就分不出来了。
+func pickReferrers(t *testing.T, srv *Server, ctx context.Context, dsID int64, exclude ...int64) (int, int) {
+	t.Helper()
+	rows, err := srv.db.QueryContext(ctx, `SELECT src_pk FROM entity_raw
+		WHERE dataset_id=$1 AND entity='ZVISIT' AND NOT (src_pk = ANY($2::bigint[]))
+		  AND raw->>'ZMERGEDTO' IS NULL AND raw->>'ZPARENT' IS NULL
+		ORDER BY src_pk LIMIT 2`, dsID, exclude)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer rows.Close()
+	var out []int
+	for rows.Next() {
+		var pk int
+		if err := rows.Scan(&pk); err != nil {
+			t.Fatal(err)
+		}
+		out = append(out, pk)
+	}
+	if err := rows.Err(); err != nil {
+		t.Fatal(err)
+	}
+	if len(out) < 2 {
+		t.Fatalf("挑不出两条指向副本的引用行（找到 %d 条）", len(out))
+	}
+	return out[0], out[1]
+}
+
+// pointRef 把某条到访留档里的一个合并标记指到 target（另一个保持 null），
+// 模拟「别的到访的留档指着副本」这种要改指的情形。
+func pointRef(t *testing.T, srv *Server, ctx context.Context, dsID int64, referrer int, col string, target int) {
+	t.Helper()
+	other := "ZPARENT"
+	if col == "ZPARENT" {
+		other = "ZMERGEDTO"
+	}
+	if _, err := srv.db.ExecContext(ctx, `UPDATE entity_raw
+		SET raw = jsonb_set(jsonb_set(raw, ARRAY[$4::text], to_jsonb($3::int), true),
+		                    ARRAY[$5::text], 'null'::jsonb, true)
+		WHERE dataset_id=$1 AND entity='ZVISIT' AND src_pk=$2`,
+		dsID, referrer, target, col, other); err != nil {
+		t.Fatalf("设置合并标记失败: %v", err)
+	}
+}
+
+// readRef 读某条到访留档里的一个合并标记。
+func readRef(t *testing.T, srv *Server, ctx context.Context, dsID int64, srcPK int, col string) sql.NullString {
+	t.Helper()
+	var v sql.NullString
+	if err := srv.db.QueryRowContext(ctx, `SELECT raw->>$3 FROM entity_raw
+		WHERE dataset_id=$1 AND entity='ZVISIT' AND src_pk=$2`, dsID, srcPK, col).Scan(&v); err != nil {
+		t.Fatalf("读合并标记失败: %v", err)
+	}
+	return v
+}
+
+// openExport 把导出的字节落到临时文件并打开，返回可直接查询的库。
+// 一份包只开一次：每次打开都要写盘 + 解压，动辄几秒。
+func openExport(t *testing.T, blob []byte) *sql.DB {
+	t.Helper()
+	out := filepath.Join(t.TempDir(), "export.rondbackup")
+	if err := os.WriteFile(out, blob, 0o644); err != nil {
+		t.Fatal(err)
+	}
+	edb, err := rond.Open(out, t.TempDir())
+	if err != nil {
+		t.Fatalf("打开导出包失败: %v", err)
+	}
+	t.Cleanup(func() { edb.Close() })
+	return edb
+}
+
+// countExportTwin 数导出包里「跟某条到访同地点、同到达时间」的到访有几条——
+// 这正是用户看到的那对重复（清理前 2、清理后 1）。
+//
+// 只能按「时间 + 地点」数，不能按 UUID：站点侧的行（副本就是）在导出时会被补上本站
+// 派生的确定性 UUID（coreDataUUID），留档里那个 UUID 本来就不会写进包里。
+func countExportTwin(t *testing.T, edb *sql.DB, keeperHex string, arrival time.Time) int {
+	t.Helper()
+	var n int
+	if err := edb.QueryRow(`SELECT count(*) FROM ZVISIT
+		WHERE ZLOCATION = (SELECT ZLOCATION FROM ZVISIT WHERE hex(ZIDENTIFIER_)=?)
+		  AND abs(ZARRIVALDATE_ - ?) < 0.5`, strings.ToUpper(keeperHex), appleSec(arrival)).Scan(&n); err != nil {
+		t.Fatalf("查导出包失败: %v", err)
+	}
+	return n
+}
+
+// countExportAll 数导出包里的到访总条数。
+func countExportAll(t *testing.T, edb *sql.DB) int {
+	t.Helper()
+	var n int
+	if err := edb.QueryRow(`SELECT count(*) FROM ZVISIT`).Scan(&n); err != nil {
+		t.Fatalf("查导出包失败: %v", err)
+	}
+	return n
+}
+
+// visitUUIDHex 读某条到访留档里的 UUID（小写 hex）。
+func visitUUIDHex(t *testing.T, srv *Server, ctx context.Context, dsID int64, srcPK int) string {
+	t.Helper()
+	var b64 string
+	if err := srv.db.QueryRowContext(ctx, `SELECT COALESCE(raw #>> '{ZIDENTIFIER_,$blob}','')
+		FROM entity_raw WHERE dataset_id=$1 AND entity='ZVISIT' AND src_pk=$2`, dsID, srcPK).Scan(&b64); err != nil {
+		t.Fatal(err)
+	}
+	return blobHex(b64)
+}
+
+// countDangling 数站点里所有悬空引用：留档指向不存在的到访 / 位移指向不存在的到访。
+func countDangling(t *testing.T, srv *Server, ctx context.Context, dsID int64) (int, int) {
+	t.Helper()
+	var raw, mv int
+	if err := srv.db.QueryRowContext(ctx, `SELECT
+		  (SELECT count(*) FROM entity_raw r WHERE r.dataset_id=$1 AND r.entity='ZVISIT' AND NOT r.skipped
+		     AND NOT EXISTS (SELECT 1 FROM visits v WHERE v.dataset_id=r.dataset_id AND v.src_pk=r.src_pk)),
+		  (SELECT count(*) FROM movements m WHERE m.dataset_id=$1
+		     AND ((m.from_visit_src IS NOT NULL AND NOT EXISTS (SELECT 1 FROM visits v WHERE v.dataset_id=m.dataset_id AND v.src_pk=m.from_visit_src))
+		       OR (m.to_visit_src   IS NOT NULL AND NOT EXISTS (SELECT 1 FROM visits v WHERE v.dataset_id=m.dataset_id AND v.src_pk=m.to_visit_src))))`,
+		dsID).Scan(&raw, &mv); err != nil {
+		t.Fatal(err)
+	}
+	return raw, mv
+}
+
+// TestDuplicateVisitsCleanE2E 端到端验证「检出重复到访 → 勾选清理 → 导出不再重复」这条链路。
+//
+// 造两对副本（各带位移 / 天气 / 留档），只提交其中一对，然后逐项核对：
+// 勾掉的那条连附属记录一起没了、没勾的纹丝不动、指向副本的合并标记改指到保留项、
+// 没有任何悬空引用，并且导出包里那一处重复真的从 2 条变回 1 条。
+func TestDuplicateVisitsCleanE2E(t *testing.T) {
+	f := newMovementFixture(t)
+	ctx, pg, dsID := f.ctx, f.pg, f.dsID
+	srv := f.srv
+	if _, err := srv.ensureBaseline(ctx, dsID); err != nil {
+		t.Fatalf("准备基线库失败: %v", err)
+	}
+
+	// 起点：夹具是「刚导入的包」，每条到访的 UUID 都来自这个包，站点侧副本必然是 0 对
+	before, unavailable, err := srv.detectDuplicateVisits(ctx, dsID)
+	if err != nil {
+		t.Fatalf("检测失败: %v", err)
+	}
+	if unavailable != "" {
+		t.Fatalf("夹具的基线判定不了重复（%s），用例前提不成立", unavailable)
+	}
+	if len(before) != 0 {
+		t.Fatalf("刚导入的包不该检出站点副本，实际 %d 对——判定的前提被改坏了", len(before))
+	}
+	base, err := readDupBaseline(ctx, srv.baselinePath(dsID))
+	if err != nil {
+		t.Fatalf("读基线库失败: %v", err)
+	}
+
+	var startVisits int
+	if err := pg.QueryRowContext(ctx, `SELECT count(*) FROM visits WHERE dataset_id=$1`, dsID).Scan(&startVisits); err != nil {
+		t.Fatal(err)
+	}
+	dangRaw0, dangMv0 := countDangling(t, srv, ctx, dsID)
+
+	// 造两对：keeper1/victim1、keeper2/victim2
+	keeper1 := pickDupBase(t, srv, ctx, dsID)
+	victim1, blob1 := seedDupVictim(t, srv, ctx, dsID, keeper1, keeper1.srcPK)
+	keeper2 := pickDupBase(t, srv, ctx, dsID, keeper1.srcPK, victim1)
+	victim2, _ := seedDupVictim(t, srv, ctx, dsID, keeper2, keeper2.srcPK)
+	t.Logf("造副本：原件 #%d → 副本 #%d（UUID %s…）；原件 #%d → 副本 #%d",
+		keeper1.srcPK, victim1, blob1.hex[:8], keeper2.srcPK, victim2)
+
+	// 复制品是「同地点同时间、UUID 不同」，判定必须刚好揪出这两条
+	pairs, unavailable, err := srv.detectDuplicateVisits(ctx, dsID)
+	if err != nil || unavailable != "" {
+		t.Fatalf("检测失败: err=%v unavailable=%s", err, unavailable)
+	}
+	got := map[int]int{}
+	for _, p := range pairs {
+		got[p.Victim] = p.Keep
+	}
+	if len(pairs) != len(before)+2 {
+		t.Fatalf("应检出 %d 对，实际 %d 对", len(before)+2, len(pairs))
+	}
+	if got[victim1] != keeper1.srcPK || got[victim2] != keeper2.srcPK {
+		t.Fatalf("配对不对：%v（应 #%d→#%d、#%d→#%d）",
+			got, victim1, keeper1.srcPK, victim2, keeper2.srcPK)
+	}
+	// 判定的定义性不变量：**副本的 UUID 一定不在基线里，保留项的 UUID 一定在**。
+	// 只按「时间 + 地点」判（漏了 UUID 前提）时，同一处会冒出一大堆「自己配自己」的配对，
+	// 而计数断言是会跟着一起膨胀的——只有这条不变量不随样本量走。
+	for _, p := range pairs {
+		if vh := visitUUIDHex(t, srv, ctx, dsID, p.Victim); vh == "" || base.uuids[vh] {
+			t.Errorf("把 #%d 判成副本，可它的 UUID（%s）在基线里也有——UUID 是判定的前提", p.Victim, vh)
+		}
+		if kh := visitUUIDHex(t, srv, ctx, dsID, p.Keep); kh == "" || !base.uuids[kh] {
+			t.Errorf("#%d 被当成保留项，可它的 UUID（%s）不在基线里", p.Keep, kh)
+		}
+	}
+
+	// 指向副本的合并标记：一条只带 ZMERGEDTO，一条只带 ZPARENT
+	refMerged, refParent := pickReferrers(t, srv, ctx, dsID,
+		int64(keeper1.srcPK), int64(victim1), int64(keeper2.srcPK), int64(victim2))
+	pointRef(t, srv, ctx, dsID, refMerged, "ZMERGEDTO", victim1)
+	pointRef(t, srv, ctx, dsID, refParent, "ZPARENT", victim1)
+
+	// 页面要能渲染出卡片：标题里带对数，每行一个默认勾上的勾选框。
+	//
+	// ⚠️ render 是**流式直写**的：模板执行到一半出错也只记日志、状态码照样 200，body 就此截断。
+	// 所以不能只看 code，必须断言「卡片之后的内容也在」（「全部保留」在 {{.EditLink}} 之后，
+	// 「到访记录」在整张卡片之后），末尾还得是闭合的 </html>。
+	rec := httptest.NewRecorder()
+	srv.editPage(rec, httptest.NewRequest("GET", "/admin/edit", nil).WithContext(ctx))
+	if rec.Code != 200 {
+		t.Fatalf("渲染数据编辑页失败: code=%d", rec.Code)
+	}
+	body := rec.Body.String()
+	for _, want := range []string{
+		fmt.Sprintf("重复到访 %d 对", len(pairs)),
+		fmt.Sprintf(`name="victim" value="%d" checked`, victim1),
+		"全部保留",
+		"到访记录",
+	} {
+		if !strings.Contains(body, want) {
+			t.Errorf("页面里没有 %q（模板可能执行到一半就断了）", want)
+		}
+	}
+	if !strings.HasSuffix(strings.TrimSpace(body), "</html>") {
+		t.Error("页面没有渲染完（body 被截断）")
+	}
+
+	// 清理前导出：那一处就是成对的两条（用户看到的现象）
+	keeperHex1 := visitUUIDHex(t, srv, ctx, dsID, keeper1.srcPK)
+	edbBefore := openExport(t, f.export(t))
+	if n := countExportTwin(t, edbBefore, keeperHex1, keeper1.arrival); n != 2 {
+		t.Fatalf("清理前导出包里同时间同地点应有 2 条，实际 %d", n)
+	}
+	exportVisitsBefore := countExportAll(t, edbBefore)
+
+	// 只提交 victim1：victim2 必须原地不动
+	loc := post(t, srv.editDuplicateVisitsApply, ctx, "/admin/edit/dup/clean",
+		url.Values{"victim": {fmt.Sprint(victim1)}})
+	if !strings.Contains(loc, "ok=") {
+		t.Errorf("清理后没有 ok= 闪信: %s", loc)
+	}
+
+	var n int
+	pg.QueryRowContext(ctx, `SELECT count(*) FROM visits WHERE dataset_id=$1`, dsID).Scan(&n)
+	if n != startVisits+2-1 {
+		t.Errorf("到访数应为 %d，实际 %d", startVisits+2-1, n)
+	}
+	for _, c := range []struct {
+		name string
+		sql  string
+	}{
+		{"副本到访", `SELECT count(*) FROM visits WHERE dataset_id=$1 AND src_pk=$2`},
+		{"副本留档", `SELECT count(*) FROM entity_raw WHERE dataset_id=$1 AND entity='ZVISIT' AND src_pk=$2`},
+		{"副本位移（起点）", `SELECT count(*) FROM movements WHERE dataset_id=$1 AND from_visit_src=$2`},
+		{"副本位移（终点）", `SELECT count(*) FROM movements WHERE dataset_id=$1 AND to_visit_src=$2`},
+		{"副本天气", `SELECT count(*) FROM weather WHERE dataset_id=$1 AND visit_src=$2`},
+	} {
+		pg.QueryRowContext(ctx, c.sql, dsID, victim1).Scan(&n)
+		if n != 0 {
+			t.Errorf("%s 没清掉（还剩 %d 条）", c.name, n)
+		}
+	}
+	// 保留项与未被勾选的那对都在
+	for _, pk := range []int{keeper1.srcPK, victim2, keeper2.srcPK} {
+		pg.QueryRowContext(ctx, `SELECT count(*) FROM visits WHERE dataset_id=$1 AND src_pk=$2`, dsID, pk).Scan(&n)
+		if n != 1 {
+			t.Errorf("到访 #%d 不该被删（实际存在 %d 条）", pk, n)
+		}
+	}
+	pg.QueryRowContext(ctx, `SELECT count(*) FROM movements WHERE dataset_id=$1 AND (from_visit_src=$2 OR to_visit_src=$2)`,
+		dsID, victim2).Scan(&n)
+	if n != 2 {
+		t.Errorf("未勾选的副本 #%d 的位移不该被清（还剩 %d 条）", victim2, n)
+	}
+
+	// 合并标记改指到保留项，且**不凭空补出另一个键**：
+	// 「只有 ZPARENT 指向副本」的那条不许长出 ZMERGEDTO（真机里那是「已并入别处」）
+	if got := readRef(t, srv, ctx, dsID, refMerged, "ZMERGEDTO"); got.String != fmt.Sprint(keeper1.srcPK) {
+		t.Errorf("ZMERGEDTO 应改指到 #%d，实际 %q", keeper1.srcPK, got.String)
+	}
+	if got := readRef(t, srv, ctx, dsID, refMerged, "ZPARENT"); got.Valid {
+		t.Errorf("只带 ZMERGEDTO 的那条不该被补上 ZPARENT，实际 %q", got.String)
+	}
+	if got := readRef(t, srv, ctx, dsID, refParent, "ZPARENT"); got.String != fmt.Sprint(keeper1.srcPK) {
+		t.Errorf("ZPARENT 应改指到 #%d，实际 %q", keeper1.srcPK, got.String)
+	}
+	if got := readRef(t, srv, ctx, dsID, refParent, "ZMERGEDTO"); got.Valid {
+		t.Errorf("只带 ZPARENT 的那条不该被补上 ZMERGEDTO，实际 %q", got.String)
+	}
+
+	// 不得留下任何悬空引用（清理前是多少，清理后还得是多少）
+	if dangRaw, dangMv := countDangling(t, srv, ctx, dsID); dangRaw != dangRaw0 || dangMv != dangMv0 {
+		t.Errorf("清理后出现悬空引用：留档 %d→%d，位移 %d→%d", dangRaw0, dangRaw, dangMv0, dangMv)
+	}
+	// 数据集计数（页脚「数据截至」与后台 flash 用的那份）也要跟着减
+	var dsCount int
+	pg.QueryRowContext(ctx, `SELECT visit_count FROM datasets WHERE id=$1`, dsID).Scan(&dsCount)
+	if dsCount != startVisits+2-1 {
+		t.Errorf("datasets.visit_count 应为 %d，实际 %d", startVisits+2-1, dsCount)
+	}
+
+	// 再检出一次：未勾选的那对还在（留着让用户自己决定）
+	pairs, unavailable, err = srv.detectDuplicateVisits(ctx, dsID)
+	if err != nil || unavailable != "" {
+		t.Fatalf("复核检测失败: err=%v unavailable=%s", err, unavailable)
+	}
+	still := false
+	for _, p := range pairs {
+		if p.Victim == victim2 {
+			still = true
+		}
+		if p.Victim == victim1 {
+			t.Errorf("已清理的副本 #%d 仍被检出", victim1)
+		}
+	}
+	if !still {
+		t.Errorf("未勾选的副本 #%d 不该消失", victim2)
+	}
+
+	// 导出：那一处重复从 2 条变回 1 条，整包到访数只少了被清掉的那一条
+	edbAfter := openExport(t, f.export(t))
+	if n := countExportTwin(t, edbAfter, keeperHex1, keeper1.arrival); n != 1 {
+		t.Errorf("清理后导出包里同时间同地点应只剩 1 条，实际 %d", n)
+	}
+	if n := countExportAll(t, edbAfter); n != exportVisitsBefore-1 {
+		t.Errorf("清理后导出包的到访数应为 %d，实际 %d", exportVisitsBefore-1, n)
+	}
+	// 导出包里那条引用的 ZMERGEDTO 必须正好指向保留项（编号对齐后也要对上）
+	var mergedTo sql.NullInt64
+	if err := edbAfter.QueryRow(`SELECT ZMERGEDTO FROM ZVISIT WHERE Z_PK=?`, refMerged).Scan(&mergedTo); err != nil {
+		t.Fatalf("导出包里找不到引用行 #%d: %v", refMerged, err)
+	}
+	if !mergedTo.Valid || int(mergedTo.Int64) != keeper1.srcPK {
+		t.Errorf("导出包里 ZMERGEDTO 应为 %d，实际 %v", keeper1.srcPK, mergedTo)
+	}
+}
+
+// TestDuplicateVisitsRefusesWrongBaseline 基线不可用 / 跟本站对不上时必须判定不了、且不给按钮。
+//
+// 这是这个功能唯一会造成不可逆损失的地方：照着对不上的参照跑，站内数据会被成片清掉
+// （所有 UUID 都比不上 ⇒ 所有到访都算副本）。所以宁可什么都不做。
+func TestDuplicateVisitsRefusesWrongBaseline(t *testing.T) {
+	f := newMovementFixture(t)
+	ctx, dsID := f.ctx, f.dsID
+	srv := f.srv
+	path, err := srv.ensureBaseline(ctx, dsID)
+	if err != nil {
+		t.Fatalf("准备基线库失败: %v", err)
+	}
+
+	// 缺基线：判定不了，而不是「没有重复」
+	if err := os.Remove(path); err != nil {
+		t.Fatal(err)
+	}
+	if _, unavail, err := srv.detectDuplicateVisits(ctx, dsID); err != nil || unavail == "" {
+		t.Errorf("基线缺失时应当判定不了（err=%v unavail=%q）", err, unavail)
+	}
+	if _, err := srv.ensureBaseline(ctx, dsID); err != nil {
+		t.Fatalf("重建基线库失败: %v", err)
+	}
+
+	// 基线里的 UUID 全换掉 ⇒ 跟本站一条都对不上
+	base, err := readDupBaseline(ctx, path)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(base.uuids) == 0 {
+		t.Fatal("基线里没有 UUID，用例前提不成立")
+	}
+	sdb, err := sql.Open("sqlite", "file:"+filepath.ToSlash(path))
+	if err != nil {
+		t.Fatal(err)
+	}
+	if _, err := sdb.Exec(`UPDATE ZVISIT SET ZIDENTIFIER_ = randomblob(16) WHERE ZIDENTIFIER_ IS NOT NULL`); err != nil {
+		sdb.Close()
+		t.Fatalf("改写基线库失败: %v", err)
+	}
+	if err := sdb.Close(); err != nil {
+		t.Fatal(err)
+	}
+
+	pairs, unavail, err := srv.detectDuplicateVisits(ctx, dsID)
+	if err != nil {
+		t.Fatalf("检测失败: %v", err)
+	}
+	if unavail == "" {
+		t.Fatalf("基线对不上时必须判定不了，却检出 %d 对", len(pairs))
+	}
+	if len(pairs) != 0 {
+		t.Errorf("判定不了时不该给出任何配对，实际 %d 对", len(pairs))
+	}
+	// 页面：只给一行说明，不给「清理」入口
+	rec := httptest.NewRecorder()
+	srv.editPage(rec, httptest.NewRequest("GET", "/admin/edit", nil).WithContext(ctx))
+	if rec.Code != 200 {
+		t.Fatalf("渲染数据编辑页失败: code=%d", rec.Code)
+	}
+	body := rec.Body.String()
+	if !strings.Contains(body, unavail) {
+		t.Error("页面里没有显示判定不了的说明")
+	}
+	if strings.Contains(body, "/admin/edit/dup/clean") {
+		t.Error("判定不了时页面不该出现清理入口")
+	}
+}
+
+// TestDupCleanSkipsStaleSelection 提交「已经不是副本」的编号时必须拒绝，一条都不删。
+//
+// 渲染到点击之间库可能已经变过（另一处清理过、或用户拿着旧页面点），
+// 照着表单里的编号删就是删错行。
+func TestDupCleanSkipsStaleSelection(t *testing.T) {
+	f := newMovementFixture(t)
+	ctx, pg, dsID := f.ctx, f.pg, f.dsID
+	srv := f.srv
+	if _, err := srv.ensureBaseline(ctx, dsID); err != nil {
+		t.Fatalf("准备基线库失败: %v", err)
+	}
+	var startVisits int
+	pg.QueryRowContext(ctx, `SELECT count(*) FROM visits WHERE dataset_id=$1`, dsID).Scan(&startVisits)
+
+	// 挑一条**不是**副本的到访（UUID 就在基线里）提交上去
+	base, err := readDupBaseline(ctx, srv.baselinePath(dsID))
+	if err != nil {
+		t.Fatal(err)
+	}
+	site, err := srv.loadDupSiteVisits(ctx, dsID)
+	if err != nil {
+		t.Fatal(err)
+	}
+	var innocent int
+	for _, sv := range site {
+		if sv.uuid != "" && base.uuids[sv.uuid] {
+			innocent = sv.srcPK
+			break
+		}
+	}
+	if innocent == 0 {
+		t.Skip("夹具里挑不出「UUID 在基线里」的到访")
+	}
+
+	r := httptest.NewRequest("POST", "/admin/edit/dup/clean",
+		strings.NewReader(url.Values{"victim": {fmt.Sprint(innocent)}}.Encode()))
+	r.Header.Set("Content-Type", "application/x-www-form-urlencoded")
+	r = r.WithContext(ctx)
+	w := httptest.NewRecorder()
+	srv.editDuplicateVisitsApply(w, r)
+	if w.Code >= 500 {
+		t.Fatalf("处理失败: code=%d", w.Code)
+	}
+	if !strings.Contains(w.Header().Get("Location"), "err=") {
+		t.Error("提交一条不是副本的到访应当被拒绝")
+	}
+	var n int
+	pg.QueryRowContext(ctx, `SELECT count(*) FROM visits WHERE dataset_id=$1`, dsID).Scan(&n)
+	if n != startVisits {
+		t.Errorf("被拒绝的提交不该删掉任何到访：%d → %d", startVisits, n)
+	}
+	pg.QueryRowContext(ctx, `SELECT count(*) FROM visits WHERE dataset_id=$1 AND src_pk=$2`, dsID, innocent).Scan(&n)
+	if n != 1 {
+		t.Error("那条到访被误删了")
+	}
+}
+
+// seedSiteVisit 造一条「站点补录」的到访：库里有行、但没有 entity_raw 留档（所以没有 UUID）。
+//
+// 时间刻意比模板行晚 7 分钟：真实的补录行只存在于站点，手机包里**没有**同时刻同地点的一条
+// ——否则它会先被「站点侧副本」那条判据认走，测不到「补录行被合并回来」这条路径。
+func seedSiteVisit(t *testing.T, srv *Server, ctx context.Context, dsID int64, base dupSeedBase) int {
+	t.Helper()
+	src, err := srv.nextSrcPK(ctx, srv.db, dsID, visitSeq)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if err := clearStaleRaw(ctx, srv.db, dsID, "ZVISIT", src); err != nil {
+		t.Fatal(err)
+	}
+	if _, err := srv.db.ExecContext(ctx, `INSERT INTO visits
+		(dataset_id, src_pk, place_id, activity_id, arrival, departure, duration_min, is_user_added)
+		SELECT dataset_id, $3, place_id, activity_id, arrival + interval '7 minutes',
+		       departure + interval '7 minutes', duration_min, TRUE
+		FROM visits WHERE dataset_id=$1 AND src_pk=$2`, dsID, base.srcPK, src); err != nil {
+		t.Fatalf("造补录行失败: %v", err)
+	}
+	return src
+}
+
+// seedMergedCopy 造「这条补录行被合并回来」的那一份：一行普通到访 + 留档，
+// 留档里的 ZIDENTIFIER_ 正是导出时补给补录行的派生 UUID（真机上就是这么回来的）。
+// 位移与天气都挂在副本名下，清理时应当改挂到保留项而不是删掉。
+func seedMergedCopy(t *testing.T, srv *Server, ctx context.Context, dsID int64, base dupSeedBase, keeper int) int {
+	t.Helper()
+	src, err := srv.nextSrcPK(ctx, srv.db, dsID, visitSeq)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if err := clearStaleRaw(ctx, srv.db, dsID, "ZVISIT", src); err != nil {
+		t.Fatal(err)
+	}
+	// 与补录行同一时刻同一地点（这就是「同一条的两份」），时间照补录行那份来
+	if _, err := srv.db.ExecContext(ctx, `INSERT INTO visits
+		(dataset_id, src_pk, place_id, activity_id, arrival, departure, duration_min, is_user_added)
+		SELECT dataset_id, $3, place_id, activity_id, arrival + interval '7 minutes',
+		       departure + interval '7 minutes', duration_min, is_user_added
+		FROM visits WHERE dataset_id=$1 AND src_pk=$2`, dsID, base.srcPK, src); err != nil {
+		t.Fatalf("造合并副本失败: %v", err)
+	}
+	blob := base64.StdEncoding.EncodeToString(rond.DerivedUUID("ZVISIT", keeper))
+	if _, err := srv.db.ExecContext(ctx, `INSERT INTO entity_raw (dataset_id, entity, src_pk, raw)
+		VALUES ($1,'ZVISIT',$2, jsonb_build_object('Z_PK',$2::int,
+			'ZIDENTIFIER_', jsonb_build_object('$blob', $3::text)))`, dsID, src, blob); err != nil {
+		t.Fatalf("造副本留档失败: %v", err)
+	}
+	for _, ends := range [][2]int{{src, base.srcPK}, {base.srcPK, src}} {
+		mv, err := srv.nextSrcPK(ctx, srv.db, dsID, movementSeq)
+		if err != nil {
+			t.Fatal(err)
+		}
+		if err := clearStaleRaw(ctx, srv.db, dsID, "ZMOVEMENT", mv); err != nil {
+			t.Fatal(err)
+		}
+		if _, err := srv.db.ExecContext(ctx, `INSERT INTO movements
+			(dataset_id, src_pk, from_visit_src, to_visit_src) VALUES ($1,$2,$3,$4)`,
+			dsID, mv, ends[0], ends[1]); err != nil {
+			t.Fatalf("造副本位移失败: %v", err)
+		}
+	}
+	w, err := srv.nextSrcPK(ctx, srv.db, dsID, weatherSeq)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if err := clearStaleRaw(ctx, srv.db, dsID, "ZHOURLYWEATHER", w); err != nil {
+		t.Fatal(err)
+	}
+	if _, err := srv.db.ExecContext(ctx, `INSERT INTO weather (dataset_id, src_pk, visit_src, at)
+		VALUES ($1,$2,$3,$4)`, dsID, w, src, base.arrival); err != nil {
+		t.Fatalf("造副本天气失败: %v", err)
+	}
+	return src
+}
+
+// TestDupCleanMergedBackSiteRow 站点补录的行在导出后又被合并回来时，会留下一条一模一样的副本。
+//
+// 成因：补录行没有留档 UUID，导出时被补上派生 UUID 写进包里；这份包再合并回站点时，
+// 合并按 UUID 对齐认不出它，就判成「备份新增」又插了一条。卡片要能认出这一对，
+// 且清理时把副本名下的位移 / 天气**改挂**到保留项（那段行程真实发生过，补录行自己没有位移）。
+func TestDupCleanMergedBackSiteRow(t *testing.T) {
+	f := newMovementFixture(t)
+	ctx, pg, dsID := f.ctx, f.pg, f.dsID
+	srv := f.srv
+	if _, err := srv.ensureBaseline(ctx, dsID); err != nil {
+		t.Fatalf("准备基线库失败: %v", err)
+	}
+	before, unavailable, err := srv.detectDuplicateVisits(ctx, dsID)
+	if err != nil || unavailable != "" {
+		t.Fatalf("检测失败: err=%v unavailable=%s", err, unavailable)
+	}
+
+	base := pickDupBase(t, srv, ctx, dsID)
+	keeper := seedSiteVisit(t, srv, ctx, dsID, base)          // 补录行：没有留档
+	copyPK := seedMergedCopy(t, srv, ctx, dsID, base, keeper) // 被合并回来的那一份
+	t.Logf("补录行 #%d + 合并副本 #%d（留档 UUID = v5(ZVISIT/%d)）", keeper, copyPK, keeper)
+
+	pairs, unavailable, err := srv.detectDuplicateVisits(ctx, dsID)
+	if err != nil || unavailable != "" {
+		t.Fatalf("检测失败: err=%v unavailable=%s", err, unavailable)
+	}
+	if len(pairs) != len(before)+1 {
+		t.Fatalf("应检出 %d 对，实际 %d 对", len(before)+1, len(pairs))
+	}
+	var found *EditDupVisit
+	for i := range pairs {
+		if pairs[i].Victim == copyPK {
+			found = &pairs[i]
+		}
+	}
+	if found == nil {
+		t.Fatalf("没认出「补录行被合并回来」这一对（副本 #%d）", copyPK)
+	}
+	if found.Keep != keeper {
+		t.Errorf("保留项应为补录行 #%d，实际 #%d", keeper, found.Keep)
+	}
+	if !found.MoveAssets {
+		t.Error("这一对必须把位移 / 天气改挂到保留项，而不是跟着副本删掉")
+	}
+	if found.Reason != dupHintMergedBack {
+		t.Errorf("成因标注应为 %q，实际 %q", dupHintMergedBack, found.Reason)
+	}
+
+	// 清理这一对
+	post(t, srv.editDuplicateVisitsApply, ctx, "/admin/edit/dup/clean",
+		url.Values{"victim": {fmt.Sprint(copyPK)}})
+
+	var n int
+	pg.QueryRowContext(ctx, `SELECT count(*) FROM visits WHERE dataset_id=$1 AND src_pk=$2`, dsID, copyPK).Scan(&n)
+	if n != 0 {
+		t.Errorf("副本 #%d 没被删掉", copyPK)
+	}
+	pg.QueryRowContext(ctx, `SELECT count(*) FROM visits WHERE dataset_id=$1 AND src_pk=$2`, dsID, keeper).Scan(&n)
+	if n != 1 {
+		t.Errorf("保留的补录行 #%d 不该被删", keeper)
+	}
+	pg.QueryRowContext(ctx, `SELECT count(*) FROM entity_raw WHERE dataset_id=$1 AND entity='ZVISIT' AND src_pk=$2`,
+		dsID, copyPK).Scan(&n)
+	if n != 0 {
+		t.Errorf("副本的留档没被清掉")
+	}
+	// 位移与天气要改挂到保留项（各两条 / 一条），而不是被删
+	pg.QueryRowContext(ctx, `SELECT count(*) FROM movements WHERE dataset_id=$1
+		AND (from_visit_src=$2 OR to_visit_src=$2)`, dsID, copyPK).Scan(&n)
+	if n != 0 {
+		t.Errorf("副本名下还挂着 %d 条位移", n)
+	}
+	pg.QueryRowContext(ctx, `SELECT count(*) FROM movements WHERE dataset_id=$1
+		AND (from_visit_src=$2 OR to_visit_src=$2)`, dsID, keeper).Scan(&n)
+	if n != 2 {
+		t.Errorf("位移应改挂到补录行 #%d（2 条），实际 %d 条", keeper, n)
+	}
+	pg.QueryRowContext(ctx, `SELECT count(*) FROM weather WHERE dataset_id=$1 AND visit_src=$2`, dsID, keeper).Scan(&n)
+	if n != 1 {
+		t.Errorf("天气应改挂到补录行 #%d（1 条），实际 %d 条", keeper, n)
+	}
+	// 清完不该再报这一对
+	pairs, unavailable, err = srv.detectDuplicateVisits(ctx, dsID)
+	if err != nil || unavailable != "" {
+		t.Fatalf("复核检测失败: err=%v unavailable=%s", err, unavailable)
+	}
+	for _, p := range pairs {
+		if p.Victim == copyPK {
+			t.Errorf("已清理的副本 #%d 仍被检出", copyPK)
+		}
+	}
+}
+
+// TestDupCleanKeepsMergeKeysAsIs 静态守卫：改指合并标记必须「只动本来就有的那个键」。
+//
+// tools/dedup_site_visits.py 是把两个键都写成保留项（jsonb_set 的 create_if_missing=true）。
+// 照抄的话，「只有 ZPARENT 指向副本」的行会凭空长出一个 ZMERGEDTO——真机里那是
+// 「这条已并入别处」的意思，会白丢一条记录。实测基线 956 条留档都带着这两个键、
+// 只有 54 / 10 条有值，凭空补键很容易踩到。
+// 另外 raw->> 取出来是 text，必须按字符串比（拿数字比会报「操作符不存在」，整个清理会失败）。
+func TestDupCleanKeepsMergeKeysAsIs(t *testing.T) {
+	src, err := os.ReadFile(pkgFile(t, "edit_duplicates.go"))
+	if err != nil {
+		t.Fatalf("读 edit_duplicates.go 失败: %v", err)
+	}
+	body := sliceFunc(t, string(src), "func (s *Server) cleanDuplicateVisits(")
+	if !strings.Contains(body, "jsonb_set(raw, ARRAY[$4::text], to_jsonb($3::int), false)") {
+		t.Error("改指合并标记必须用 create_if_missing=false，只动本来就存在的那个键")
+	}
+	if strings.Contains(body, "to_jsonb($3::int), true)") {
+		t.Error("不许用 create_if_missing=true：那会凭空补出副本本来没有的合并标记")
+	}
+	if !strings.Contains(body, "raw->>$4 = $2") {
+		t.Error("raw->> 取出来是 text，必须按字符串比")
+	}
+	if !strings.Contains(body, "s.pruneEntityRaw") {
+		t.Error("删完必须 pruneEntityRaw，否则留档里会留下指向已删到访的行")
+	}
+}

internal/web/edit_duplicates.go

@@ -0,0 +1,468 @@
+package web
+
+import (
+	"context"
+	"database/sql"
+	"encoding/base64"
+	"fmt"
+	"log"
+	"math"
+	"net/http"
+	"os"
+	"sort"
+	"strconv"
+	"strings"
+	"time"
+
+	"rond-with-you/internal/rond"
+)
+
+// ---------- 重复到访：站点侧的历史副本 ----------
+//
+// 背景（2026-09-29）：站点库里有一批**到达时间 + 地点与手机包里某条完全相同、但 UUID 不同**
+// 的到访副本。差异页 / 合并都是按 UUID 认人的，于是它们被判成「备份新增」，
+// 导出到 rond 后就是成对的两条重复记录。
+//
+// 判定与 tools/dedup_site_visits.py 是同一套语义（那里已经演练通过，两边不能各写一份）：
+//   - 参照是这份数据集的**基线**（导入时留下的手机包底稿，见 baselinePath）；
+//   - 站点到访的 UUID 在基线里找不到、而基线里有一条「到达时间 + 地点」完全相同的 → 副本。
+//
+// UUID 是前提：只按「时间 + 地点」判，会把手机包自身那些合法的成对条目一起删掉。
+
+// appleEpoch 是 Core Data 的时间原点（2001-01-01 UTC）。基线的 ZARRIVALDATE_ 就是它起算的秒数。
+var appleEpoch = time.Date(2001, 1, 1, 0, 0, 0, 0, time.UTC)
+
+// 两类重复的成因（卡片上打个小标，站长才好判断该不该删）。
+const (
+	// 站点侧副本：手机包里也有「同一时刻同一地点」的一条，但 UUID 不同
+	dupSiteCopy = "站点侧副本"
+	// 补录行被合并回来：站点补录的行没有留档 UUID，导出时会被补一个派生 UUID，
+	// 这份包再合并回站点时对不上，就被当成「备份新增」又插了一条
+	dupHintMergedBack = "你补录的那条被合并回来的一份"
+)
+
+// EditDupVisit 是「重复到访」卡片里的一对：站点侧多出来的那条，与它该保留的那条。
+type EditDupVisit struct {
+	Victim    int // 站点侧多出来的 src_pk —— 勾选后删的就是它
+	Keep      int // 要留下来的 src_pk
+	Arrival   time.Time
+	PlaceName string
+	// Reason 是这一对的成因（卡片上打标用）
+	Reason string
+	// MoveAssets 表示删副本时把它名下的位移 / 天气**改挂**到保留项（而不是删掉）：
+	// 「补录行的副本」属于这种——那段行程是真实发生过的，而补录行自己名下没有位移。
+	MoveAssets bool
+}
+
+// ArrivalStr 是模板里显示的到达时间（本地时区，分钟精度）。
+func (v EditDupVisit) ArrivalStr() string { return v.Arrival.Local().Format("2006-01-02 15:04") }
+
+// dupKey 把「到达时间 + 地点」折成一个比较键。时间取到毫秒：副本与原件的到达时间本来
+// 就是同一个瞬间，而基线与站点两侧都用这一个函数，取整方式一致就不会错配。
+func dupKey(secs float64, who string) string {
+	return strconv.FormatInt(int64(math.Round(secs*1000)), 10) + "|" + who
+}
+
+// dupCoordKey 是地点坐标的比较键（6 位小数，与工具一致）。
+func dupCoordKey(lat, lon float64) string { return fmt.Sprintf("%.6f|%.6f", lat, lon) }
+
+// appleSeconds 把时间换算成 Core Data 的秒数（2001-01-01 UTC 起算），与基线的 ZARRIVALDATE_ 同系。
+func appleSeconds(t time.Time) float64 { return t.UTC().Sub(appleEpoch).Seconds() }
+
+// dupSet 只在键还没被占时写入。Python 那边用的是 dict.setdefault：同一个「时间 + 地点」
+// 在库里有多条时取先到的那条，顺序照抄，两边结果才一致。
+func dupSet[T any](m map[string]T, k string, v T) {
+	if _, ok := m[k]; !ok {
+		m[k] = v
+	}
+}
+
+// dupBaseline 是从基线库读出的判定依据。
+type dupBaseline struct {
+	uuids map[string]bool   // 基线里出现过的到访 UUID（小写 hex）
+	byKey map[string]string // 「到达时间 + 地点」→ 基线里那条的 UUID
+}
+
+// dupPlace 是基线里一个地点的名字与坐标。
+type dupPlace struct {
+	name     string
+	lat, lon float64
+}
+
+// readDupBaseline 只读打开基线库（Core Data 单文件），取出判定要用的两组信息。
+//
+// 驱动只认 _pragma / _time_format 这几个 DSN 参数，没有 mode=ro；基线库是 rollback journal
+// 模式（VACUUM INTO 的产物），只做 SELECT 不会落下任何旁写文件，再加 query_only 兜住
+// 「误写基线库」这条路——基线是导出的底稿，写坏了整个数据集就导不出去了。
+func readDupBaseline(ctx context.Context, path string) (*dupBaseline, error) {
+	sdb, err := openBaselineRO(path)
+	if err != nil {
+		return nil, err
+	}
+	defer sdb.Close()
+
+	places, err := readDupPlaces(ctx, sdb)
+	if err != nil {
+		return nil, err
+	}
+
+	b := &dupBaseline{uuids: map[string]bool{}, byKey: map[string]string{}}
+	rows, err := sdb.QueryContext(ctx, `SELECT hex(ZIDENTIFIER_), ZARRIVALDATE_, ZLOCATION
+		FROM ZVISIT WHERE ZIDENTIFIER_ IS NOT NULL`)
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+	for rows.Next() {
+		var uuid string
+		var arrival sql.NullFloat64
+		var loc sql.NullInt64
+		if err := rows.Scan(&uuid, &arrival, &loc); err != nil {
+			return nil, err
+		}
+		uuid = strings.ToLower(uuid)
+		if uuid == "" {
+			continue
+		}
+		b.uuids[uuid] = true
+		if !arrival.Valid || !loc.Valid {
+			continue
+		}
+		pl, ok := places[loc.Int64]
+		if !ok {
+			continue
+		}
+		dupSet(b.byKey, dupKey(arrival.Float64, pl.name), uuid)
+		if pl.lat != 0 || pl.lon != 0 {
+			dupSet(b.byKey, dupKey(arrival.Float64, dupCoordKey(pl.lat, pl.lon)), uuid)
+		}
+	}
+	return b, rows.Err()
+}
+
+func readDupPlaces(ctx context.Context, sdb *sql.DB) (map[int64]dupPlace, error) {
+	rows, err := sdb.QueryContext(ctx, `SELECT Z_PK, COALESCE(ZNAME_,''),
+		COALESCE(ZLATITUDE,0), COALESCE(ZLONGITUDE,0) FROM ZLOCATION`)
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+	out := map[int64]dupPlace{}
+	for rows.Next() {
+		var pk int64
+		var pl dupPlace
+		if err := rows.Scan(&pk, &pl.name, &pl.lat, &pl.lon); err != nil {
+			return nil, err
+		}
+		out[pk] = pl
+	}
+	return out, rows.Err()
+}
+
+// siteDupVisit 是判定用的站点侧面貌。
+type siteDupVisit struct {
+	srcPK    int
+	uuid     string // 留档里的 ZIDENTIFIER_（小写 hex），站点新建的行没有
+	arrival  time.Time
+	place    string
+	lat, lon float64
+}
+
+// loadDupSiteVisits 读出站点侧的到访（含留档里的 UUID 与所属地点的名称/坐标），按 src_pk 排序。
+func (s *Server) loadDupSiteVisits(ctx context.Context, datasetID int64) ([]siteDupVisit, error) {
+	rows, err := s.db.QueryContext(ctx, `SELECT v.src_pk,
+		COALESCE(er.raw #>> '{ZIDENTIFIER_,$blob}',''),
+		v.arrival, COALESCE(p.name,''), COALESCE(p.lat,0), COALESCE(p.lon,0)
+		FROM visits v
+		LEFT JOIN places p ON p.id = v.place_id
+		LEFT JOIN entity_raw er ON er.dataset_id=v.dataset_id AND er.entity='ZVISIT' AND er.src_pk=v.src_pk
+		WHERE v.dataset_id=$1
+		ORDER BY v.src_pk`, datasetID)
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+	var out []siteDupVisit
+	for rows.Next() {
+		var sv siteDupVisit
+		var b64 string
+		if err := rows.Scan(&sv.srcPK, &b64, &sv.arrival, &sv.place, &sv.lat, &sv.lon); err != nil {
+			return nil, err
+		}
+		sv.uuid = blobHex(b64)
+		out = append(out, sv)
+	}
+	return out, rows.Err()
+}
+
+// blobHex 把留档里的 base64 blob 转成小写 hex。基线侧用的是 hex(ZIDENTIFIER_)，
+// 两边同一个形式才比得上（大小写也要一致，否则一条都认不出来）。
+func blobHex(s string) string {
+	if s == "" {
+		return ""
+	}
+	b, err := base64.StdEncoding.DecodeString(s)
+	if err != nil || len(b) == 0 {
+		return ""
+	}
+	return strings.ToLower(fmt.Sprintf("%x", b))
+}
+
+// detectDuplicateVisits 检出站点侧的重复到访，并给出每条该保留哪一行。
+//
+// 第二个返回值非空表示**第一类判定不了**（基线不可用 / 跟本站到访对不上）——那一类要拿基线
+// 当参照，参照不可靠就宁可不动；但第二类（补录行被合并回来）不依赖基线，照样要报出来。
+func (s *Server) detectDuplicateVisits(ctx context.Context, datasetID int64) ([]EditDupVisit, string, error) {
+	site, err := s.loadDupSiteVisits(ctx, datasetID)
+	if err != nil {
+		return nil, "", err
+	}
+
+	var out []EditDupVisit
+	seen := map[int]bool{}
+	// 第二类：站点补录的行（留档里没有 UUID）导出过一次之后，包里那条带的是站点给它补的
+	// 派生 UUID；这份包合并回站点时对不上（站点这侧本来是空的），于是又插了一条。
+	// 判据全在站点自己这边（不需要基线），所以先判它，基线不可用时也不受影响。
+	// 派生 UUID 命中是很强的证据，排在「站点侧副本」之前。
+	soloByUUID := map[string]siteDupVisit{}
+	for _, sv := range site {
+		if sv.uuid == "" && sv.srcPK > 0 {
+			soloByUUID[rond.DerivedVisitUUID(sv.srcPK)] = sv
+		}
+	}
+	for _, sv := range site {
+		if ssv, ok := soloByUUID[sv.uuid]; sv.uuid != "" && ok && !seen[sv.srcPK] {
+			// 派生 UUID 已经很特异了，这里再对一道时间与地点，免得编号被复用的行配到一起
+			if ssv.place != sv.place || dupKey(appleSeconds(ssv.arrival), ssv.place) != dupKey(appleSeconds(sv.arrival), sv.place) {
+				continue
+			}
+			out = append(out, EditDupVisit{Victim: sv.srcPK, Keep: ssv.srcPK, Arrival: sv.arrival,
+				PlaceName: sv.place, Reason: dupHintMergedBack, MoveAssets: true})
+			seen[sv.srcPK] = true
+		}
+	}
+
+	// 以下第一类需要基线：缺失 / 读不动 / 一条 UUID 都对不上，就只报第二类 + 一行说明。
+	fail := func(msg string) ([]EditDupVisit, string, error) {
+		sort.SliceStable(out, func(i, j int) bool { return out[i].Arrival.After(out[j].Arrival) })
+		return out, msg, nil
+	}
+	path := s.baselinePath(datasetID)
+	if _, err := os.Stat(path); err != nil {
+		return fail("这份数据集还没有可用的基线库（当初上传的原始 .rondbackup 已不在），没法当参照，判定不了「站点侧副本」那一类。")
+	}
+	base, err := readDupBaseline(ctx, path)
+	if err != nil {
+		log.Printf("读取基线库失败（数据集 %d，%s）: %v", datasetID, path, err)
+		return fail("读取基线库失败，判定不了「站点侧副本」那一类。")
+	}
+
+	var withUUID, matched int
+	for _, sv := range site {
+		if sv.uuid == "" {
+			continue
+		}
+		withUUID++
+		if base.uuids[sv.uuid] {
+			matched++
+		}
+	}
+	// 两道闸都防着「拿一份不相干的库当参照」：基线的 UUID 一个都比不上时，
+	// 所有站内到访都会被算成副本，照着删就是把整库搬走。
+	if len(base.uuids) == 0 {
+		return fail("基线里没有带 UUID 的到访，没法当参照，判定不了「站点侧副本」那一类。")
+	}
+	if withUUID > 0 && matched == 0 {
+		return fail("基线跟本站到访一条都对不上，它多半不是这份数据集的手机包，判定不可靠，先不动它。")
+	}
+
+	// 保留项：站点侧 UUID 在基线里能找到的那些（手机包里也有这条），按「时间 + 地点」建索引。
+	keepByKey := map[string]int{}
+	for _, sv := range site {
+		if sv.uuid == "" || !base.uuids[sv.uuid] {
+			continue
+		}
+		secs := appleSeconds(sv.arrival)
+		dupSet(keepByKey, dupKey(secs, sv.place), sv.srcPK)
+		if sv.lat != 0 || sv.lon != 0 {
+			dupSet(keepByKey, dupKey(secs, dupCoordKey(sv.lat, sv.lon)), sv.srcPK)
+		}
+	}
+
+	// 第一类：站点的 UUID 在基线里找不到、而基线里有一条「同时刻同地点」的——站点侧副本
+	for _, sv := range site {
+		if sv.uuid == "" || base.uuids[sv.uuid] || seen[sv.srcPK] {
+			continue
+		}
+		secs := appleSeconds(sv.arrival)
+		byName, byCoord := dupKey(secs, sv.place), ""
+		if sv.lat != 0 || sv.lon != 0 {
+			byCoord = dupKey(secs, dupCoordKey(sv.lat, sv.lon))
+		}
+		// 基线里得有「同一时间同一地点」那条，否则这不是副本，是站点自己新增的到访
+		if base.byKey[byName] == "" && (byCoord == "" || base.byKey[byCoord] == "") {
+			continue
+		}
+		// 站点里也得有那条保留项：没有就无从改指，删了就是净丢一条记录
+		keep, ok := keepByKey[byName]
+		if !ok && byCoord != "" {
+			keep, ok = keepByKey[byCoord]
+		}
+		if !ok {
+			continue
+		}
+		out = append(out, EditDupVisit{Victim: sv.srcPK, Keep: keep, Arrival: sv.arrival,
+			PlaceName: sv.place, Reason: dupSiteCopy})
+		seen[sv.srcPK] = true
+	}
+
+	sort.SliceStable(out, func(i, j int) bool { return out[i].Arrival.After(out[j].Arrival) })
+	return out, "", nil
+}
+
+// editDuplicateVisitsApply 清理勾选的重复到访副本。
+func (s *Server) editDuplicateVisitsApply(w http.ResponseWriter, r *http.Request) {
+	ctx := r.Context()
+	ds, err := s.datasetFor(ctx)
+	if err != nil || ds == nil {
+		redirectEdit(w, r, "err", "还没有可编辑的数据集")
+		return
+	}
+	if err := r.ParseForm(); err != nil {
+		s.serverError(w, r, err)
+		return
+	}
+	want := map[int]bool{}
+	for _, v := range r.PostForm["victim"] {
+		if n, cerr := strconv.Atoi(strings.TrimSpace(v)); cerr == nil && n > 0 {
+			want[n] = true
+		}
+	}
+	if len(want) == 0 {
+		redirectEdit(w, r, "err", "没有勾选要清理的副本")
+		return
+	}
+	// 编号不照着表单删：渲染到点击之间库可能已经变过，这里重算一遍判定，
+	// 只有当下**仍被判为副本**的编号才会动。
+	pairs, unavailable, err := s.detectDuplicateVisits(ctx, ds.ID)
+	if err != nil {
+		s.serverError(w, r, err)
+		return
+	}
+	if unavailable != "" {
+		redirectEdit(w, r, "err", unavailable)
+		return
+	}
+	var picked []EditDupVisit
+	for _, p := range pairs {
+		if want[p.Victim] {
+			picked = append(picked, p)
+		}
+	}
+	if len(picked) == 0 {
+		redirectEdit(w, r, "err", "选中的记录已经不是副本了（库里可能已经变过），请刷新页面重试")
+		return
+	}
+	if err := s.withTx(ctx, func(ex execer) error {
+		return s.cleanDuplicateVisits(ctx, ex, ds.ID, picked)
+	}); err != nil {
+		s.serverError(w, r, err)
+		return
+	}
+	redirectEdit(w, r, "ok", fmt.Sprintf("已清理 %d 条重复到访", len(picked)))
+}
+
+// cleanDuplicateVisits 删掉一批副本，并把指向它们的合并标记改指到保留项。
+//
+// 全程在一个事务里：分开提交会留下「到访没了、留档还指着它」的悬空引用，
+// 导出到 rond 里就是坏数据（到访那条 ZMERGEDTO 指向一个不存在的 Z_PK）。
+func (s *Server) cleanDuplicateVisits(ctx context.Context, ex execer, datasetID int64, pairs []EditDupVisit) error {
+	victims := make([]int64, 0, len(pairs))
+	var repoint []EditDupVisit
+	for _, p := range pairs {
+		victims = append(victims, int64(p.Victim))
+		if p.MoveAssets {
+			repoint = append(repoint, p)
+		}
+	}
+	// 聚合要按地点重算，先把副本所属地点收下来（删完就在 visits 里查不到了）
+	placeIDs, err := s.dupVictimPlaces(ctx, ex, datasetID, victims)
+	if err != nil {
+		return err
+	}
+
+	// 改指合并标记时**只动本来就存在的那一个键**（jsonb_set 的 create_if_missing=false），
+	// 与 tools/dedup_site_visits.py 有一处刻意的不同：工具把两个键都写成保留项，于是
+	// 「只有 ZPARENT 指向副本」的行会凭空长出一个 ZMERGEDTO——那在真机里是「这条已并入
+	// 别处」的意思，会白丢一条记录。实测基线里 956 条留档都带着这两个键，但只有 54 / 10
+	// 条有值，凭空补键是很容易踩到的。
+	//
+	// raw->> 取出来是 text，必须按字符串比（拿数字去比会报「text = integer 操作符不存在」）。
+	for _, p := range pairs {
+		for _, col := range []string{"ZMERGEDTO", "ZPARENT"} {
+			if _, err := ex.ExecContext(ctx, `UPDATE entity_raw
+				SET raw = jsonb_set(raw, ARRAY[$4::text], to_jsonb($3::int), false)
+				WHERE dataset_id=$1 AND entity='ZVISIT' AND raw->>$4 = $2`,
+				datasetID, strconv.Itoa(p.Victim), p.Keep, col); err != nil {
+				return err
+			}
+		}
+	}
+	// 「补录行的副本」先把它名下的位移 / 天气改挂到保留项：那段行程真实发生过，
+	// 而补录行自己名下没有位移，跟着副本一起删就是把里程白丢了。
+	for _, p := range repoint {
+		if _, err := ex.ExecContext(ctx, `UPDATE movements SET from_visit_src=$3
+			WHERE dataset_id=$1 AND from_visit_src=$2`, datasetID, p.Victim, p.Keep); err != nil {
+			return err
+		}
+		if _, err := ex.ExecContext(ctx, `UPDATE movements SET to_visit_src=$3
+			WHERE dataset_id=$1 AND to_visit_src=$2`, datasetID, p.Victim, p.Keep); err != nil {
+			return err
+		}
+		if _, err := ex.ExecContext(ctx, `UPDATE weather SET visit_src=$3
+			WHERE dataset_id=$1 AND visit_src=$2`, datasetID, p.Victim, p.Keep); err != nil {
+			return err
+		}
+	}
+	// 副本的附属记录：位移（两端任一）、天气。到访本身删掉后，它自己的留档与标签关联
+	// 分别由 pruneEntityRaw 与 visit_tags 的外键级联清掉。
+	if _, err := ex.ExecContext(ctx, `DELETE FROM movements WHERE dataset_id=$1
+		AND (from_visit_src = ANY($2::bigint[]) OR to_visit_src = ANY($2::bigint[]))`,
+		datasetID, victims); err != nil {
+		return err
+	}
+	if _, err := ex.ExecContext(ctx, `DELETE FROM weather WHERE dataset_id=$1 AND visit_src = ANY($2::bigint[])`,
+		datasetID, victims); err != nil {
+		return err
+	}
+	if _, err := ex.ExecContext(ctx, `DELETE FROM visits WHERE dataset_id=$1 AND src_pk = ANY($2::bigint[])`,
+		datasetID, victims); err != nil {
+		return err
+	}
+	s.pruneEntityRaw(ctx, ex, datasetID)
+	for _, id := range placeIDs {
+		if err := s.refreshPlaceAgg(ctx, ex, id); err != nil {
+			return err
+		}
+	}
+	return s.refreshDatasetAgg(ctx, ex, datasetID)
+}
+
+// dupVictimPlaces 是这批副本所属的地点 id（不含 place_id 为空的）。
+func (s *Server) dupVictimPlaces(ctx context.Context, ex execer, datasetID int64, victims []int64) ([]int64, error) {
+	rows, err := ex.QueryContext(ctx, `SELECT DISTINCT place_id FROM visits
+		WHERE dataset_id=$1 AND src_pk = ANY($2::bigint[]) AND place_id IS NOT NULL`, datasetID, victims)
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+	var out []int64
+	for rows.Next() {
+		var id int64
+		if err := rows.Scan(&id); err != nil {
+			return nil, err
+		}
+		out = append(out, id)
+	}
+	return out, rows.Err()
+}

internal/web/entity_raw_test.go

@@ -0,0 +1,54 @@
+package web
+
+import (
+	"context"
+	"math"
+	"testing"
+)
+
+// D2 回归：留档序列化失败必须把错误上抛，让整个合并事务回滚。
+// 以前是只 log 后 return nil —— 调用方以为写成功了，合并照常提交，
+// 这一行的原始列就永久缺失（下次跨备份比对认不出 UUID，导出也还原不回去）。
+func TestWriteRawRowFailsLoudlyOnMarshalError(t *testing.T) {
+	f := newLoginFixture(t)
+	ctx := context.Background()
+
+	var ds int64
+	if err := f.pg.QueryRowContext(ctx, `SELECT id FROM datasets ORDER BY id LIMIT 1`).Scan(&ds); err != nil {
+		t.Skipf("库里没有数据集：%v", err)
+	}
+	const pk = 987654321
+	t.Cleanup(func() {
+		ctx := context.Background()
+		for _, e := range []string{"ZVISIT", "ZLOCATION"} {
+			f.pg.ExecContext(ctx, `DELETE FROM entity_raw WHERE dataset_id=$1 AND entity=$2 AND src_pk=$3`, ds, e, pk)
+		}
+	})
+
+	// NaN 是 json.Marshal 明确拒绝的值，拿来触发真实的序列化失败
+	err := writeRawRow(ctx, f.pg, ds, "ZVISIT", pk, map[string]any{"ZBAD": math.NaN()})
+	if err == nil {
+		t.Fatal("序列化失败必须返回错误；返回 nil 等于让留档静默丢失")
+	}
+	var n int
+	if err := f.pg.QueryRowContext(ctx, `SELECT count(*) FROM entity_raw
+		WHERE dataset_id=$1 AND entity='ZVISIT' AND src_pk=$2`, ds, pk).Scan(&n); err != nil {
+		t.Fatal(err)
+	}
+	if n != 0 {
+		t.Errorf("失败时不应留下 entity_raw 行，实际 %d 行", n)
+	}
+
+	// 正常值必须写得进去（否则上面的断言可能只是「这张表根本写不动」）
+	if err := writeRawRow(ctx, f.pg, ds, "ZLOCATION", pk, map[string]any{"ZNAME": "回归测试"}); err != nil {
+		t.Fatalf("正常留档不应失败: %v", err)
+	}
+	var got string
+	if err := f.pg.QueryRowContext(ctx, `SELECT raw->>'ZNAME' FROM entity_raw
+		WHERE dataset_id=$1 AND entity='ZLOCATION' AND src_pk=$2`, ds, pk).Scan(&got); err != nil {
+		t.Fatalf("读取刚写入的留档失败: %v", err)
+	}
+	if got != "回归测试" {
+		t.Errorf("留档内容对不上：%q", got)
+	}
+}

internal/web/export_align_test.go

@@ -0,0 +1,145 @@
+package web
+
+import (
+	"database/sql"
+	"fmt"
+	"os"
+	"path/filepath"
+	"testing"
+
+	"rond-with-you/internal/rond"
+)
+
+// 导出的**编号必须与基线对齐**。
+//
+// 为什么：Core Data 的 store 里地点与活动**没有 UUID**，app 只能靠 Z_PK 解引用
+// （`ZVISIT.ZLOCATION` / `ZVISIT.ZACTIVITY_`）。站点这边的编号是从「导入→导出」循环里滚出来的，
+// 与手机 store 的编号不是一套——2026-09-29 实测：同一批到访里 920/920 的地点引用、903/920 的
+// 活动引用与真机包不同（引用到的地点按名称+坐标完全一致），结果是「导入成功但看不到数据」。
+//
+// 这里把库里的编号整体平移（模拟「数据来自编号完全不同的备份」），再导出，要求导出结果回到基线的编号。
+func TestExportAlignsPKsToBaseline(t *testing.T) {
+	f := newMovementFixture(t)
+	f.shiftSrcPKs(t, 500000) // 库内编号整体平移 ⇒ 与基线完全不同
+
+	out := filepath.Join(t.TempDir(), "export.rondbackup")
+	if err := os.WriteFile(out, f.export(t), 0o644); err != nil {
+		t.Fatal(err)
+	}
+	edb, err := rond.Open(out, t.TempDir())
+	if err != nil {
+		t.Fatalf("打开导出包失败: %v", err)
+	}
+	t.Cleanup(func() { edb.Close() })
+	base := f.openSource(t) // 基线 = 导入用的那份包
+
+	type ref struct {
+		placePK, actPK sql.NullInt64
+	}
+	load := func(db *sql.DB) map[string]ref {
+		rows, err := db.Query(`SELECT hex(ZIDENTIFIER_), ZLOCATION, ZACTIVITY_ FROM ZVISIT
+			WHERE ZIDENTIFIER_ IS NOT NULL`)
+		if err != nil {
+			t.Fatalf("读到访失败: %v", err)
+		}
+		defer rows.Close()
+		m := map[string]ref{}
+		for rows.Next() {
+			var u string
+			var r ref
+			if err := rows.Scan(&u, &r.placePK, &r.actPK); err != nil {
+				t.Fatal(err)
+			}
+			m[u] = r
+		}
+		return m
+	}
+	describe := func(db *sql.DB, placePK, actPK sql.NullInt64) (string, string) {
+		p := "<空>"
+		if placePK.Valid {
+			var n string
+			var la, lo float64
+			if err := db.QueryRow(`SELECT COALESCE(ZNAME_,''), COALESCE(ZLATITUDE,0), COALESCE(ZLONGITUDE,0)
+				FROM ZLOCATION WHERE Z_PK=?`, placePK.Int64).Scan(&n, &la, &lo); err != nil {
+				return "<地点不存在>", ""
+			}
+			p = fmt.Sprintf("%s %.5f,%.5f", n, la, lo)
+		}
+		a := "<空>"
+		if actPK.Valid {
+			var n string
+			if err := db.QueryRow(`SELECT COALESCE(ZNAME_,'') FROM ZACTIVITY WHERE Z_PK=?`, actPK.Int64).Scan(&n); err != nil {
+				return p, "<活动不存在>"
+			}
+			a = n
+		}
+		return p, a
+	}
+
+	baseVisits, expVisits := load(base), load(edb)
+	if len(baseVisits) == 0 || len(expVisits) == 0 {
+		t.Fatalf("包里的到访为空：基线 %d 条 / 导出 %d 条", len(baseVisits), len(expVisits))
+	}
+	common, placeOK, actOK := 0, 0, 0
+	for u, br := range baseVisits {
+		er, ok := expVisits[u]
+		if !ok {
+			continue
+		}
+		common++
+		bp, ba := describe(base, br.placePK, br.actPK)
+		ep, ea := describe(edb, er.placePK, er.actPK)
+		// 关键：**编号本身**要和基线一致（app 就是拿这个编号解引用的）。只看「名称+坐标」
+		// 查不出问题——编号不一致时引用依然自洽，但手机那边解不出来。
+		samePK := br.placePK.Valid == er.placePK.Valid &&
+			(!br.placePK.Valid || br.placePK.Int64 == er.placePK.Int64)
+		if samePK {
+			placeOK++
+		} else if placeOK+3 > common { // 只记前几条，避免刷屏
+			// 少数不一致是正常的：真机自己就有重名的重复行（如同名车站两条），
+			// 地点没有 UUID，1:1 归属只能任选其一。所以例子只记日志，断言看比例。
+			t.Logf("到访 %s 的地点编号不同：基线 #%v(%q) / 导出 #%v(%q)",
+				u[:8], br.placePK.Int64, bp, er.placePK.Int64, ep)
+		}
+		sameAct := br.actPK.Valid == er.actPK.Valid &&
+			(!br.actPK.Valid || br.actPK.Int64 == er.actPK.Int64)
+		if sameAct {
+			actOK++
+		} else if actOK+3 > common {
+			t.Logf("到访 %s 的活动编号不同：基线 #%v(%q) / 导出 #%v(%q)",
+				u[:8], br.actPK.Int64, ba, er.actPK.Int64, ea)
+		}
+	}
+	if common == 0 {
+		t.Fatal("基线与导出没有可对齐的到访")
+	}
+	if placeOK*100 < common*95 {
+		t.Errorf("地点引用与基线一致率过低：%d/%d（应 ≥95%%）", placeOK, common)
+	}
+	if actOK*100 < common*95 {
+		t.Errorf("活动引用与基线一致率过低：%d/%d（应 ≥95%%）", actOK, common)
+	}
+	t.Logf("按 UUID 对齐共同到访 %d 条：地点引用一致 %d、活动引用一致 %d", common, placeOK, actOK)
+
+	// 对齐之后不许出现悬空引用（含自引用 ZMERGEDTO / ZPARENT）
+	for _, q := range []struct{ name, sql string }{
+		{"visit→location", `SELECT count(*) FROM ZVISIT a WHERE a.ZLOCATION IS NOT NULL AND a.ZLOCATION<>0
+			AND NOT EXISTS (SELECT 1 FROM ZLOCATION b WHERE b.Z_PK=a.ZLOCATION)`},
+		{"visit→activity", `SELECT count(*) FROM ZVISIT a WHERE a.ZACTIVITY_ IS NOT NULL AND a.ZACTIVITY_<>0
+			AND NOT EXISTS (SELECT 1 FROM ZACTIVITY b WHERE b.Z_PK=a.ZACTIVITY_)`},
+		{"visit→mergedTo", `SELECT count(*) FROM ZVISIT a WHERE a.ZMERGEDTO IS NOT NULL AND a.ZMERGEDTO<>0
+			AND NOT EXISTS (SELECT 1 FROM ZVISIT b WHERE b.Z_PK=a.ZMERGEDTO)`},
+		{"visit→parent", `SELECT count(*) FROM ZVISIT a WHERE a.ZPARENT IS NOT NULL AND a.ZPARENT<>0
+			AND NOT EXISTS (SELECT 1 FROM ZVISIT b WHERE b.Z_PK=a.ZPARENT)`},
+		{"movement→visit", `SELECT count(*) FROM ZMOVEMENT a WHERE a.ZVISITFROM_ IS NOT NULL AND a.ZVISITFROM_<>0
+			AND NOT EXISTS (SELECT 1 FROM ZVISIT b WHERE b.Z_PK=a.ZVISITFROM_)`},
+		{"movement→transport", `SELECT count(*) FROM ZMOVEMENT a WHERE a.ZTRANSPORT_ IS NOT NULL AND a.ZTRANSPORT_<>0
+			AND NOT EXISTS (SELECT 1 FROM ZTRANSPORT b WHERE b.Z_PK=a.ZTRANSPORT_)`},
+		{"weather→visit", `SELECT count(*) FROM ZHOURLYWEATHER a WHERE a.ZVISIT IS NOT NULL AND a.ZVISIT<>0
+			AND NOT EXISTS (SELECT 1 FROM ZVISIT b WHERE b.Z_PK=a.ZVISIT)`},
+	} {
+		if n := countNull(t, edb, q.sql); n != 0 {
+			t.Errorf("编号对齐后出现 %d 条悬空引用：%s", n, q.name)
+		}
+	}
+}

internal/web/export_download_test.go

@@ -0,0 +1,59 @@
+package web
+
+import (
+	"net/http"
+	"net/http/httptest"
+	"strconv"
+	"testing"
+	"time"
+)
+
+// deadlineRecorder 冒充 http.response：只有实现了 SetWriteDeadline，
+// 才看得出 http.NewResponseController 有没有被中间件挡住。
+type deadlineRecorder struct {
+	*httptest.ResponseRecorder
+	deadline time.Time
+	got      bool
+}
+
+func (d *deadlineRecorder) SetWriteDeadline(t time.Time) error {
+	d.deadline, d.got = t, true
+	return nil
+}
+
+// P4 回归：gzipWriter 必须实现 Unwrap()。少了它，被 gzip 中间件包住的请求调
+// http.NewResponseController(...).SetWriteDeadline/Flush 只会拿到 ErrNotSupported。
+func TestGzipWriterUnwrapsToUnderlyingWriter(t *testing.T) {
+	rec := &deadlineRecorder{ResponseRecorder: httptest.NewRecorder()}
+	gw := &gzipWriter{ResponseWriter: rec}
+
+	if err := http.NewResponseController(gw).SetWriteDeadline(time.Now().Add(time.Minute)); err != nil {
+		t.Fatalf("ResponseController 没能穿过 gzipWriter: %v", err)
+	}
+	if !rec.got {
+		t.Error("SetWriteDeadline 没有落到真正的 ResponseWriter 上")
+	}
+}
+
+// P4 回归：导出是「一次性大响应」，得带上 Content-Length（下载进度条、
+// 也顺带锁住「不再依赖隐式 200」），并把写死线放宽到全站 120s 之外。
+func TestExportSetsContentLengthAndExtendsWriteDeadline(t *testing.T) {
+	f := newMovementFixture(t)
+
+	rec := &deadlineRecorder{ResponseRecorder: httptest.NewRecorder()}
+	req := httptest.NewRequest("GET", "/admin/export/rondbackup", nil).WithContext(f.ctx)
+	f.srv.exportRondbackup(rec, req)
+
+	if rec.Code != http.StatusOK {
+		t.Fatalf("导出返回 %d：%s", rec.Code, firstLine(rec.Body.String()))
+	}
+	if cl := rec.Header().Get("Content-Length"); cl != strconv.Itoa(rec.Body.Len()) {
+		t.Errorf("Content-Length=%q，实际写出 %d 字节", cl, rec.Body.Len())
+	}
+	if ct := rec.Header().Get("Content-Type"); ct != "application/octet-stream" {
+		t.Errorf("Content-Type 不对: %q", ct)
+	}
+	if !rec.got {
+		t.Error("导出没有延长写死线（慢链路下会被全站 120s 截断）")
+	}
+}

internal/web/export_placeholder_test.go

@@ -0,0 +1,202 @@
+package web
+
+import (
+	"database/sql"
+	"fmt"
+	"os"
+	"path/filepath"
+	"testing"
+
+	"rond-with-you/internal/rond"
+)
+
+// TestExportNeverNullsColumnsTheDeviceAlwaysFills 守一条**通用**的导出不变量：
+//
+//	基线里 100% 有值的列，站点新建的行也不许留空。
+//
+// 真机对某些列从来不写 NULL/空串（比如 ZTRANSPORT 的名称/颜色/图标），那些列在它的模型里
+// 很可能就是非可选属性；我们给新行留 NULL，等于塞回去一个它自己从不产生的形状。
+//
+// 2026-09-20 就是这么栽的：站点新建了交通方式「步行」但没选颜色/图标，而站点不单独维护
+// 交通方式表（颜色/图标是从位移上聚合的），导出就把 ZCOLOR_/ZICON_ 写成了 NULL——
+// 逐列比对时它是唯一一处「老行全有值、新行却是空」的列。
+func TestExportNeverNullsColumnsTheDeviceAlwaysFills(t *testing.T) {
+	f := newMovementFixture(t)
+	ctx, pg, dsID := f.ctx, f.pg, f.dsID
+
+	var fromVisit, toVisit int
+	if err := pg.QueryRowContext(ctx, `SELECT vf.src_pk, vt.src_pk
+		FROM visits vf JOIN visits vt ON vt.dataset_id=vf.dataset_id AND vt.arrival > vf.departure + interval '30 min'
+		WHERE vf.dataset_id=$1 AND vf.departure IS NOT NULL
+		ORDER BY vf.arrival DESC LIMIT 1`, dsID).Scan(&fromVisit, &toVisit); err != nil {
+		t.Fatalf("挑不出合法的起止到访: %v", err)
+	}
+	// 故意「只填名字」建成新方式：颜色/图标留空，复现用户那次的操作
+	post(t, f.srv.editMovementCreate, ctx, "/admin/edit/movement", map[string][]string{
+		"from_visit":     {fmt.Sprint(fromVisit)},
+		"to_visit":       {fmt.Sprint(toVisit)},
+		"transport_src":  {transportNewValue},
+		"transport_name": {"测试步行方式"},
+	})
+	_, newTrans := lastMovement(t, ctx, pg, dsID)
+	if newTrans <= 0 {
+		t.Fatal("新建交通方式没有分配编号")
+	}
+
+	// 活动同理：站点「地点补全」新建活动时 color/icon 写的是空串（见 fillup.go 的 INSERT），
+	// 而导出侧的 ns() 把空串也当空——图标那侧早就有 📍 兜底，颜色这侧曾经漏了。
+	var newAct int
+	if err := pg.QueryRowContext(ctx, `INSERT INTO activities (dataset_id, src_pk, name, color, icon)
+		VALUES ($1, 950001, '测试无色活动', '', '') RETURNING src_pk`, dsID).Scan(&newAct); err != nil {
+		t.Fatalf("插入无色活动失败: %v", err)
+	}
+	t.Cleanup(func() {
+		pg.ExecContext(ctx, `DELETE FROM activities WHERE dataset_id=$1 AND src_pk=950001`, dsID)
+	})
+
+	out := filepath.Join(t.TempDir(), "export.rondbackup")
+	if err := os.WriteFile(out, f.export(t), 0o644); err != nil {
+		t.Fatal(err)
+	}
+	edb, err := rond.Open(out, t.TempDir())
+	if err != nil {
+		t.Fatalf("打开导出包失败: %v", err)
+	}
+	t.Cleanup(func() { edb.Close() })
+	srcDB := f.openSource(t)
+
+	// 1) 新建的那条方式必须自带可用的颜色与图标
+	var name, color, icon sql.NullString
+	if err := edb.QueryRow(`SELECT ZNAME_, ZCOLOR_, ZICON_ FROM ZTRANSPORT WHERE Z_PK=?`, newTrans).
+		Scan(&name, &color, &icon); err != nil {
+		t.Fatalf("导出包里找不到新建的交通方式 #%d: %v", newTrans, err)
+	}
+	for _, c := range []struct {
+		col string
+		v   sql.NullString
+	}{{"ZNAME_", name}, {"ZCOLOR_", color}, {"ZICON_", icon}} {
+		if !c.v.Valid || c.v.String == "" {
+			t.Errorf("新建交通方式的 %s 是空的（%q）：真机这列从不留空", c.col, c.v.String)
+		}
+	}
+
+	// 2) 新建的那条「没选颜色」的活动也必须自带可用的颜色与图标
+	var actName, actColor, actIcon sql.NullString
+	if err := edb.QueryRow(`SELECT ZNAME_, ZCOLOR_, ZICON_ FROM ZACTIVITY WHERE Z_PK=?`, newAct).
+		Scan(&actName, &actColor, &actIcon); err != nil {
+		t.Fatalf("导出包里找不到新建的活动 #%d: %v", newAct, err)
+	}
+	for _, c := range []struct {
+		col string
+		v   sql.NullString
+	}{{"ZNAME_", actName}, {"ZCOLOR_", actColor}, {"ZICON_", actIcon}} {
+		if !c.v.Valid || c.v.String == "" {
+			t.Errorf("新建活动的 %s 是空的（%q）：真机这列从不留空，"+
+				"写 NULL 会被当成损坏的数据而拒收整包", c.col, c.v.String)
+		}
+	}
+
+	// 3) 通用判据：基线里一个空值都没有的列，导出里的新行也不许出现空值
+	for _, tbl := range []string{"ZVISIT", "ZLOCATION", "ZACTIVITY", "ZMOVEMENT", "ZTRANSPORT", "ZTAG"} {
+		var baseMax sql.NullInt64
+		if err := srcDB.QueryRow(`SELECT MAX(Z_PK) FROM ` + tbl).Scan(&baseMax); err != nil || !baseMax.Valid {
+			continue
+		}
+		for _, col := range columnNames(t, srcDB, tbl) {
+			if countNull(t, srcDB, fmt.Sprintf(`SELECT COUNT(*) FROM %s WHERE %s IS NULL`, tbl, col)) > 0 {
+				continue // 基线本来就有空值，这一列不算「真机从来不空」
+			}
+			q := fmt.Sprintf(`SELECT COUNT(*) FROM %s WHERE Z_PK > ? AND %s IS NULL`, tbl, col)
+			if n := countNull(t, edb, q, baseMax.Int64); n > 0 {
+				t.Errorf("%s.%s：基线里一个空值都没有，导出却有 %d 个新行是 NULL —— "+
+					"真机从不产生这种形状，它会当成损坏的数据", tbl, col, n)
+			}
+		}
+	}
+}
+
+// columnNames 取一张表的列名（跳过 Core Data 内部列，它们由基线原样带回）。
+func columnNames(t *testing.T, db *sql.DB, tbl string) []string {
+	t.Helper()
+	rows, err := db.Query(`SELECT name FROM pragma_table_info(?)`, tbl)
+	if err != nil {
+		t.Fatalf("读 %s 的列名失败: %v", tbl, err)
+	}
+	defer rows.Close()
+	var out []string
+	for rows.Next() {
+		var n string
+		if err := rows.Scan(&n); err != nil {
+			t.Fatal(err)
+		}
+		out = append(out, n)
+	}
+	return out
+}
+
+func countNull(t *testing.T, db *sql.DB, q string, args ...any) int {
+	t.Helper()
+	var n int
+	if err := db.QueryRow(q, args...).Scan(&n); err != nil {
+		t.Fatalf("查询失败 %s: %v", q, err)
+	}
+	return n
+}
+
+// TestExportDropsOrphanedRawVisits 守「导出包的关系图不许有悬空引用」。
+//
+// ZRAWVISIT（原始 GPS 采样点）是我们**不托管**的实体，导出时原样保留；而站点删掉一条到访时，
+// 指向它的采样点就留成了悬空 —— Core Data 的关系由它自己维护、SQLite 里没有外键约束，
+// 所以 `foreign_key_check` 查不出来，但它是真机自己绝不会产生的形状（真机删到访时采样点级联删）。
+// 留着还有副作用：app 会把「没归并的采样点」重新推成一条到访，删掉的记录又回来了。
+func TestExportDropsOrphanedRawVisits(t *testing.T) {
+	f := newMovementFixture(t)
+	srcDB := f.openSource(t)
+
+	// 挑一条「有原始采样点」的到访：原始采样点的 ZVISIT 就是到访的 Z_PK（= 站点的 src_pk）
+	var visitPK int
+	if err := srcDB.QueryRow(`SELECT ZVISIT FROM ZRAWVISIT
+		WHERE ZVISIT IS NOT NULL GROUP BY ZVISIT ORDER BY ZVISIT LIMIT 1`).Scan(&visitPK); err != nil {
+		t.Skipf("基线里没有带采样点的到访，跳过: %v", err)
+	}
+
+	post(t, f.srv.editVisitDelete, f.ctx, "/admin/edit/visit/delete", map[string][]string{
+		"src_pk": {fmt.Sprint(visitPK)},
+	})
+
+	out := filepath.Join(t.TempDir(), "export.rondbackup")
+	if err := os.WriteFile(out, f.export(t), 0o644); err != nil {
+		t.Fatal(err)
+	}
+	edb, err := rond.Open(out, t.TempDir())
+	if err != nil {
+		t.Fatalf("打开导出包失败: %v", err)
+	}
+	t.Cleanup(func() { edb.Close() })
+
+	if n := countNull(t, edb, `SELECT COUNT(*) FROM ZRAWVISIT WHERE ZVISIT=?`, visitPK); n != 0 {
+		t.Errorf("删掉到访 #%d 后，它的 %d 条原始采样点还留着（悬空引用）", visitPK, n)
+	}
+	// 通用判据：整包不许有任何悬空引用（Core Data 自己维护关系，pragma 查不到）
+	for _, ref := range unmanagedRefs {
+		q := fmt.Sprintf(`SELECT COUNT(*) FROM %s x WHERE x.%s IS NOT NULL AND x.%s<>0
+			AND NOT EXISTS (SELECT 1 FROM %s y WHERE y.Z_PK = x.%s)`,
+			ref[0], ref[1], ref[1], ref[2], ref[1])
+		if n := countNull(t, edb, q); n > 0 {
+			t.Errorf("%s.%s 有 %d 条指向不存在的 %s —— 真机从不产生悬空关系", ref[0], ref[1], n, ref[2])
+		}
+	}
+}
+
+// unmanagedRefs 是「不托管的表指向托管实体」的关系列（库、列、目标表）。
+// 加新表时照这个格式补，通用判据会自动覆盖。
+var unmanagedRefs = [][3]string{
+	{"ZRAWVISIT", "ZVISIT", "ZVISIT"},
+	{"ZRAWVISIT", "ZLOCATION", "ZLOCATION"},
+	{"ZRAWVISIT", "ZACTIVITY", "ZACTIVITY"},
+	{"ZSTAYSEGMENT", "ZLOCATION", "ZLOCATION"},
+	{"ZUSERPHOTO", "ZVISIT_", "ZVISIT"},
+	{"ZVISITPHOTOFAVORITE", "ZVISIT_", "ZVISIT"},
+	{"ZKEYWORD", "ZACTIVITY_", "ZACTIVITY"},
+	{"ZPOICATEGORY", "ZACTIVITY_", "ZACTIVITY"},
+}

internal/web/export_transport_test.go

@@ -0,0 +1,99 @@
+package web
+
+import (
+	"os"
+	"path/filepath"
+	"testing"
+
+	"rond-with-you/internal/rond"
+)
+
+// 交通方式是**全局表、以名称区分**：同名两条会被真机当成损坏数据，整包拒收
+// （2026-09-29 生产导出就是这么被拒的：`ZTRANSPORT` 里两条「公交」）。
+//
+// 站点的 transport_src 是另一套编号空间——把实机备份合并进来时，同一个 src 会带上两种含义
+// （实测 src=4 既是「电🐔」又是「公交」）。导出必须按**名称**归并，并且把每条位移挂回
+// 它自己那个名称对应的方式上；只按 src 取一个名字会让另一种含义的位移挂错方式。
+func TestExportMergesDuplicateTransportNames(t *testing.T) {
+	f := newMovementFixture(t)
+	ctx, pg, dsID := f.ctx, f.pg, f.dsID
+
+	// 造出「同一个 src、两种名称」的形状：正是合并实机备份留下的样子
+	var k1, k2 int
+	if err := pg.QueryRowContext(ctx, `SELECT
+		(SELECT src_pk FROM movements WHERE dataset_id=$1 AND transport_src IS NOT NULL ORDER BY id LIMIT 1),
+		(SELECT src_pk FROM movements WHERE dataset_id=$1 AND transport_src IS NOT NULL ORDER BY id OFFSET 1 LIMIT 1)`,
+		dsID).Scan(&k1, &k2); err != nil {
+		t.Fatalf("挑位移失败: %v", err)
+	}
+	for _, v := range []struct {
+		pk    int
+		name  string
+		color string
+		icon  string
+	}{{k1, "电🐔", "purple", "moped.fill"}, {k2, "公交", "red", "bus.fill"}} {
+		if _, err := pg.ExecContext(ctx, `UPDATE movements SET transport_src=900, transport_name=$3,
+			transport_color=$4, transport_icon=$5 WHERE dataset_id=$1 AND src_pk=$2`,
+			dsID, v.pk, v.name, v.color, v.icon); err != nil {
+			t.Fatalf("预置失败: %v", err)
+		}
+	}
+	t.Cleanup(func() {
+		pg.ExecContext(ctx, `DELETE FROM movements WHERE dataset_id=$1 AND transport_src=900`, dsID)
+	})
+	// 再把站点原本那条「公交」（src=2）改名，于是「公交」这个名字只剩注入的那条：
+	// 归并后基线里 src=2 那行就成了「同名但编号已被归并掉」的旧行，必须被删掉，
+	// 否则 keepMissing 会把它原样留下 → 包里又是两条同名方式
+	if _, err := pg.ExecContext(ctx, `UPDATE movements SET transport_name='巴士'
+		WHERE dataset_id=$1 AND transport_src=2`, dsID); err != nil {
+		t.Fatalf("预置改名失败: %v", err)
+	}
+
+	out := filepath.Join(t.TempDir(), "export.rondbackup")
+	if err := os.WriteFile(out, f.export(t), 0o644); err != nil {
+		t.Fatal(err)
+	}
+	edb, err := rond.Open(out, t.TempDir())
+	if err != nil {
+		t.Fatalf("打开导出包失败: %v", err)
+	}
+	t.Cleanup(func() { edb.Close() })
+
+	// 1) 同名不许出现两条
+	rows, err := edb.Query(`SELECT ZNAME_ FROM ZTRANSPORT WHERE ZNAME_ IS NOT NULL
+		GROUP BY ZNAME_ HAVING count(*) > 1`)
+	if err != nil {
+		t.Fatalf("读 ZTRANSPORT 失败: %v", err)
+	}
+	for rows.Next() {
+		var name string
+		if err := rows.Scan(&name); err != nil {
+			t.Fatal(err)
+		}
+		t.Errorf("导出包里有两条同名交通方式 %q：真机会判成损坏数据、整包拒收", name)
+	}
+	rows.Close()
+	if err := rows.Err(); err != nil {
+		t.Fatal(err)
+	}
+
+	// 2) 每条位移必须挂回自己名称对应的那条方式
+	for _, want := range []struct {
+		pk   int
+		name string
+	}{{k1, "电🐔"}, {k2, "公交"}} {
+		var got string
+		if err := edb.QueryRow(`SELECT t.ZNAME_ FROM ZMOVEMENT m JOIN ZTRANSPORT t ON t.Z_PK = m.ZTRANSPORT_
+			WHERE m.Z_PK = ?`, want.pk).Scan(&got); err != nil {
+			t.Fatalf("位移 #%d 的方式查不到: %v", want.pk, err)
+		}
+		if got != want.name {
+			t.Errorf("位移 #%d 应挂到 %q，实际挂到了 %q（归并后要按位移自己的名称改挂）", want.pk, want.name, got)
+		}
+	}
+	// 3) 归并后不许留下悬空的 ZTRANSPORT_ 引用
+	if n := countNull(t, edb, `SELECT count(*) FROM ZMOVEMENT m WHERE m.ZTRANSPORT_ IS NOT NULL
+		AND m.ZTRANSPORT_ <> 0 AND NOT EXISTS (SELECT 1 FROM ZTRANSPORT t WHERE t.Z_PK = m.ZTRANSPORT_)`); n != 0 {
+		t.Errorf("归并后有 %d 条位移指向不存在的方式", n)
+	}
+}

internal/web/export_zraw_test.go

@@ -0,0 +1,68 @@
+package web
+
+import (
+	"database/sql"
+	"testing"
+)
+
+// TestExportClampsRawSampleCount 守「ZRAW 不能超过包里实际有的采样行数」。
+//
+// ZVISIT.ZRAW 是「这次到访由多少个原始采样点归并而来」的缓存计数，而采样点表 ZRAWVISIT 是
+// **不托管实体**（原样从基线带过来）。合并进来的到访带着源包的计数、源包的采样行却不在本站，
+// 于是计数会超出包里实际有的采样行数——2026-09-30 实测真机会因此**整包拒收**
+// （「备份恢复失败，你的当前数据未被修改」：生产数据里是 #1000 声称 2305 个采样点、包里只有 2246 行），
+// 而把这一列夹回采样行数以内、重新导出就能导入。被真机接受过的包里 ZRAW 为 NULL/0 的行本来就有
+// 39~139 条，所以往下夹是安全的。
+func TestExportClampsRawSampleCount(t *testing.T) {
+	f := newMovementFixture(t)
+	ctx, pg, dsID := f.ctx, f.pg, f.dsID
+	srv := f.srv
+	if _, err := srv.ensureBaseline(ctx, dsID); err != nil {
+		t.Fatalf("准备基线库失败: %v", err)
+	}
+
+	// 造一条「声称有几百万个采样点」的到访：照抄一条正常到访的整行留档，只把 ZRAW 改大
+	base := pickDupBase(t, srv, ctx, dsID)
+	src, err := srv.nextSrcPK(ctx, pg, dsID, visitSeq)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if err := clearStaleRaw(ctx, pg, dsID, "ZVISIT", src); err != nil {
+		t.Fatal(err)
+	}
+	if _, err := pg.ExecContext(ctx, `INSERT INTO visits
+		(dataset_id, src_pk, place_id, activity_id, arrival, departure, duration_min)
+		SELECT dataset_id, $3, place_id, activity_id, arrival, departure, duration_min
+		FROM visits WHERE dataset_id=$1 AND src_pk=$2`, dsID, base.srcPK, src); err != nil {
+		t.Fatal(err)
+	}
+	if _, err := pg.ExecContext(ctx, `INSERT INTO entity_raw (dataset_id, entity, src_pk, raw)
+		SELECT dataset_id, entity, $3, jsonb_set(raw, '{ZRAW}', to_jsonb($4::int), true)
+		FROM entity_raw WHERE dataset_id=$1 AND entity=$2 AND src_pk=$5`,
+		dsID, "ZVISIT", src, 999999, base.srcPK); err != nil {
+		t.Fatal(err)
+	}
+
+	// 导出并核对：任何一行都不许声称比包里的采样行还多
+	edb := openExport(t, f.export(t))
+	var nraw, maxRaw int
+	if err := edb.QueryRow(`SELECT (SELECT count(*) FROM ZRAWVISIT), COALESCE(max(ZRAW),0) FROM ZVISIT`).
+		Scan(&nraw, &maxRaw); err != nil {
+		t.Fatalf("读导出包失败: %v", err)
+	}
+	t.Logf("导出包：采样行 %d，到访的 ZRAW 最大值 %d", nraw, maxRaw)
+	if nraw == 0 {
+		t.Fatal("导出包里没有采样行，用例前提不成立")
+	}
+	if maxRaw > nraw {
+		t.Errorf("有到访声称 %d 个采样点，包里只有 %d 行采样——真机会整包拒收", maxRaw, nraw)
+	}
+	// 被夹的那一行本身还在（只改计数、不丢记录），且计数被夹到了采样行数
+	var got sql.NullInt64
+	if err := edb.QueryRow(`SELECT ZRAW FROM ZVISIT WHERE Z_PK=?`, src).Scan(&got); err != nil {
+		t.Fatalf("导出包里找不到刚造的到访 #%d: %v", src, err)
+	}
+	if !got.Valid || int(got.Int64) != nraw {
+		t.Errorf("被夹的到访 #%d 的 ZRAW 应为 %d，实际 %v", src, nraw, got)
+	}
+}

internal/web/fillup.go

@@ -31,11 +31,29 @@ type fillupHint struct {
 var (
 	fillupMu    sync.Mutex
 	fillupCache = map[int64]fillupHint{}
+	fillupOrder []int64 // 键的插入顺序，超限时据此淘汰最旧的一批
 )
 
+// fillupCacheMax 是内存提示缓存的条目上限。
+//
+// 个人站点的地点数是有限的，这里兜的是「站点长期运行、数据集换了一轮又一轮」时的无界增长：
+// 光写不清的全局 map 会一路涨到把 1C1G 的机器吃干净。超限就丢掉最旧的四分之一，
+// 让缓存自己收敛——比整表清空温和，不会一次性把所有高德建议都丢掉。
+const fillupCacheMax = 2048
+
 func fillupCachePut(placeID int64, h fillupHint) {
 	fillupMu.Lock()
 	defer fillupMu.Unlock()
+	if _, ok := fillupCache[placeID]; !ok {
+		if len(fillupOrder) >= fillupCacheMax {
+			n := fillupCacheMax / 4
+			for _, k := range fillupOrder[:n] {
+				delete(fillupCache, k)
+			}
+			fillupOrder = append(fillupOrder[:0], fillupOrder[n:]...)
+		}
+		fillupOrder = append(fillupOrder, placeID)
+	}
 	fillupCache[placeID] = h
 }
 
@@ -60,6 +78,7 @@ type FillupRow struct {
 	ActHint  string // 建议的活动名（空 = 没建议）
 	ActID    int64  // 建议命中现有活动时的 id；0 表示得新建
 	CatHint  string // 建议的类别
+	CatLabel string // 上面那个类别建议的显示名（站点自定义的优先）
 	Source   string // 建议从哪来
 	AmapType string // 高德给出的类型原文，供人工判断（可能没映射出建议）
 	AmapPoi  string // 高德找到的最近 POI 名字
@@ -112,7 +131,7 @@ type activityOption struct {
 //   - 缺类别 = poi_category 为空。
 //
 // 零到访的地点只要缺类别也会进来——它们没有到访可挂活动，补类别仍然有意义。
-func (s *Server) fillupRows(ctx context.Context, datasetID int64) ([]FillupRow, error) {
+func (s *Server) fillupRows(ctx context.Context, datasetID int64, custom map[string]string) ([]FillupRow, error) {
 	rows, err := s.db.QueryContext(ctx, `
 		SELECT p.id, p.src_pk, COALESCE(p.name,''), COALESCE(p.city,''),
 		       COALESCE(p.lat,0), COALESCE(p.lon,0), COALESCE(p.poi_category,''),
@@ -169,6 +188,7 @@ func (s *Server) fillupRows(ctx context.Context, datasetID int64) ([]FillupRow,
 			}
 			if out[i].NoCat && h.Cat != "" {
 				out[i].CatHint = h.Cat
+				out[i].CatLabel = categoryLabel(h.Cat, custom)
 			}
 			out[i].AmapType, out[i].AmapPoi = h.Type, h.Poi
 		}
@@ -196,7 +216,8 @@ func (s *Server) adminFillupPage(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 	p.SetFlashFromQuery(r)
-	rows, err := s.fillupRows(ctx, ds.ID)
+	catNames := s.categoryLabels(ctx)
+	rows, err := s.fillupRows(ctx, ds.ID, catNames)
 	if err != nil {
 		s.serverError(w, r, err)
 		return
@@ -206,7 +227,7 @@ func (s *Server) adminFillupPage(w http.ResponseWriter, r *http.Request) {
 		s.serverError(w, r, err)
 		return
 	}
-	usedCats, err := s.usedCategories(ctx, ds.ID)
+	usedCats, err := s.usedCategories(ctx, ds.ID, catNames)
 	if err != nil {
 		s.serverError(w, r, err)
 		return
@@ -228,7 +249,7 @@ func (s *Server) adminFillupPage(w http.ResponseWriter, r *http.Request) {
 	rows = rows[from:to]
 
 	s.render(w, "admin/fillup", FillupData{
-		Page: p, Rows: rows, Activities: acts, Categories: fillupCategories(usedCats),
+		Page: p, Rows: rows, Activities: acts, Categories: fillupCategories(usedCats, catNames),
 		Total: total, WithHint: hinted, PageNo: pageNo, PageCount: pageCount,
 	})
 }
@@ -263,7 +284,7 @@ type fillupCategory struct {
 // usedCategories 列出这个数据集里真在用的类别（按地点数从多到少），排在静态表前面。
 // 候选得先跟已有数据对得上——否则用户会在这一页挑一个名字相近的静态枚举，
 // 跟库里已有的值并存成两种，同一个意思分两处统计。
-func (s *Server) usedCategories(ctx context.Context, datasetID int64) ([]fillupCategory, error) {
+func (s *Server) usedCategories(ctx context.Context, datasetID int64, custom map[string]string) ([]fillupCategory, error) {
 	rows, err := s.db.QueryContext(ctx, `SELECT poi_category, count(*) FROM places
 		WHERE dataset_id=$1 AND COALESCE(poi_category,'')<>'' GROUP BY 1 ORDER BY 2 DESC, 1`, datasetID)
 	if err != nil {
@@ -278,14 +299,14 @@ func (s *Server) usedCategories(ctx context.Context, datasetID int64) ([]fillupC
 			return nil, err
 		}
 		// 值可能是 MKPOICategory 枚举，也可能是真机自己写的中文——poiCategoryLabel 两种都认
-		out = append(out, fillupCategory{v, fmt.Sprintf("%s（在用 %d）", poiCategoryLabel(v), n)})
+		out = append(out, fillupCategory{v, fmt.Sprintf("%s（在用 %d）", categoryLabel(v, custom), n)})
 	}
 	return out, rows.Err()
 }
 
 // fillupCategories 是类别下拉的选项：数据集里真在用的排最前面，再跟真机用过的 12 种、
 // 其余常见 MapKit 类别。同一个值只出现一次——在用的那份信息更准，就顶掉静态表里的说明。
-func fillupCategories(inUse []fillupCategory) []fillupCategory {
+func fillupCategories(inUse []fillupCategory, custom map[string]string) []fillupCategory {
 	known := []string{
 		"MKPOICategoryRestaurant", "MKPOICategoryStore", "MKPOICategoryPublicTransport",
 		"MKPOICategoryHotel", "MKPOICategoryLandmark", "MKPOICategoryFoodMarket",
@@ -313,10 +334,10 @@ func fillupCategories(inUse []fillupCategory) []fillupCategory {
 		push(c)
 	}
 	for _, c := range known {
-		push(fillupCategory{c, poiName(c) + "（真机用过）"})
+		push(fillupCategory{c, categoryLabel(c, custom) + "（真机用过）"})
 	}
 	for _, c := range extra {
-		push(fillupCategory{c, poiName(c)})
+		push(fillupCategory{c, categoryLabel(c, custom)})
 	}
 	return out
 }
@@ -378,7 +399,10 @@ func (s *Server) adminFillupApply(w http.ResponseWriter, r *http.Request) {
 					actByName[name] = actID
 					newActs++
 				}
-				isHome, isWork := s.activityFlags(ctx, ex, actID)
+				isHome, isWork, err := s.activityFlags(ctx, ex, actID)
+				if err != nil {
+					return err
+				}
 				res, err := ex.ExecContext(ctx, `UPDATE visits v SET activity_id=$1, is_home=$2, is_work=$3
 					WHERE v.dataset_id=$4 AND v.activity_id IS NULL
 					  AND v.place_id = (SELECT p.id FROM places p WHERE p.dataset_id=$4 AND p.id=$5)`,
@@ -448,8 +472,8 @@ func (s *Server) fillupTargets(ctx context.Context, ex execer, datasetID int64)
 	return out, rows.Err()
 }
 
-func (s *Server) activityFlags(ctx context.Context, ex execer, actID int64) (isHome, isWork bool) {
+func (s *Server) activityFlags(ctx context.Context, ex execer, actID int64) (isHome, isWork bool, err error) {
-	ex.QueryRowContext(ctx, `SELECT is_home, is_work FROM activities WHERE id=$1`, actID).Scan(&isHome, &isWork)
+	err = ex.QueryRowContext(ctx, `SELECT is_home, is_work FROM activities WHERE id=$1`, actID).Scan(&isHome, &isWork)
 	return
 }
 
@@ -489,7 +513,8 @@ func (s *Server) adminFillupAmap(w http.ResponseWriter, r *http.Request) {
 		s.fillupFlash(w, r, "err", "conf/app.ini 里没配 geocode_key，用不了高德")
 		return
 	}
-	rows, err := s.fillupRows(ctx, ds.ID)
+	catNames := s.categoryLabels(ctx)
+	rows, err := s.fillupRows(ctx, ds.ID, catNames)
 	if err != nil {
 		s.serverError(w, r, err)
 		return

internal/web/fillup_cache_test.go

@@ -0,0 +1,51 @@
+package web
+
+import (
+	"strconv"
+	"testing"
+)
+
+// fillupCache 是全局的、只写不清的内存缓存：长期运行必须有上限，
+// 否则站点换了几轮数据集之后 map 会一路涨下去，把 1C1G 的机器吃干净。
+func TestFillupCacheIsBounded(t *testing.T) {
+	fillupMu.Lock()
+	savedCache, savedOrder := fillupCache, fillupOrder
+	fillupCache, fillupOrder = map[int64]fillupHint{}, nil
+	fillupMu.Unlock()
+	t.Cleanup(func() {
+		fillupMu.Lock()
+		fillupCache, fillupOrder = savedCache, savedOrder
+		fillupMu.Unlock()
+	})
+
+	total := fillupCacheMax + fillupCacheMax/2
+	for i := 0; i < total; i++ {
+		fillupCachePut(int64(i), fillupHint{Act: strconv.Itoa(i)})
+	}
+
+	fillupMu.Lock()
+	size, order := len(fillupCache), len(fillupOrder)
+	fillupMu.Unlock()
+	if size > fillupCacheMax {
+		t.Fatalf("缓存条目应被限制在 %d 以内，实际 %d（又变成无界增长了）", fillupCacheMax, size)
+	}
+	if order != size {
+		t.Fatalf("淘汰后 order 应与 cache 等长：order=%d cache=%d", order, size)
+	}
+	if _, ok := fillupHintOf(int64(total - 1)); !ok {
+		t.Error("最后写入的条目不该被淘汰")
+	}
+	if _, ok := fillupHintOf(0); ok {
+		t.Error("最旧的条目应当已被淘汰")
+	}
+
+	// 覆盖写同一个键不该让 order 重复记账（否则 order 会比 cache 长，淘汰时错删）。
+	before := order
+	fillupCachePut(int64(total-1), fillupHint{Act: "again"})
+	fillupMu.Lock()
+	after := len(fillupOrder)
+	fillupMu.Unlock()
+	if after != before {
+		t.Errorf("重复写同一个键不该增加 order 长度：%d -> %d", before, after)
+	}
+}

internal/web/fog.go

@@ -16,6 +16,7 @@ import (
 	"strconv"
 	"strings"
 	"sync"
+	"sync/atomic"
 	"time"
 
 	"rond-with-you/internal/fog"
@@ -26,22 +27,27 @@ const maxFogUploadBytes = 64 << 20 // .fwss 快照一般几 MB，放宽到 64MB
 
 // 迷雾是站点级数据（与公开页读数据不区分归属的约定一致），
 // 内存里只持一份索引，首次访问时从库里加载。
+//
+// 指针用 atomic 而不是普通变量：清空迷雾（fogResetIndex）会在请求 goroutine 里换掉它，
+// 而瓦片/导出/统计同时在读 —— 直接赋值就是一个真的 data race。
 var (
 	fogOnce   sync.Once
-	fogIndexV *fog.Index
+	fogIndexV atomic.Pointer[fog.Index]
 )
 
 func (s *Server) fogIndex() (*fog.Index, error) {
 	fogOnce.Do(func() {
-		fogIndexV = fog.NewIndex()
+		ix := fog.NewIndex()
-		if err := fogIndexV.LoadAll(s.db); err != nil {
+		// 加载完才发布：中途的实例不能被别的 goroutine 看到（这也是Once的意义）
-			fogIndexV = nil
+		if err := ix.LoadAll(s.db); err == nil {
+			fogIndexV.Store(ix)
 		}
 	})
-	if fogIndexV == nil {
+	ix := fogIndexV.Load()
+	if ix == nil {
 		return nil, fmt.Errorf("迷雾数据加载失败")
 	}
-	return fogIndexV, nil
+	return ix, nil
 }
 
 // handleFogTile 渲染迷雾透明瓦片。迷雾网格是 WGS-84；当前激活底图若是
@@ -441,8 +447,11 @@ func (s *Server) fogCoverage(ctx context.Context, datasetID int64, regions []str
 
 // fogResetIndex 丢弃内存里的迷雾索引（清空迷雾后调用），
 // 下次访问时按空库重建。
+//
+// 被清掉的那个索引对象可能还有请求正拿着用（Import/View/All 都走它自己的锁），
+// 这里只换指针、不动旧对象，那些请求会安全地跑完。
 func fogResetIndex() {
-	fogIndexV = fog.NewIndex()
+	fogIndexV.Store(fog.NewIndex())
 }
 
 // adminFogClear 清空全部迷雾数据。迷雾是站点级数据，一次清空影响所有展示。
@@ -483,7 +492,7 @@ func (s *Server) adminFogExport(w http.ResponseWriter, r *http.Request) {
 	_, cells := ix.Stats()
 	w.Header().Set("Content-Type", "application/octet-stream")
 	w.Header().Set("Content-Disposition",
-		fmt.Sprintf(`attachment; filename="fog-export-%s.fwss"`, time.Now().Format("20060102-150405")))
+		downloadDisposition("fog-export-"+time.Now().Format("20060102-150405")+".fwss"))
 	w.Header().Set("X-Fog-Cells", strconv.Itoa(cells))
 	w.Write(out)
 }

internal/web/fog_race_test.go

@@ -0,0 +1,55 @@
+package web
+
+import (
+	"sync"
+	"testing"
+
+	"rond-with-you/internal/fog"
+)
+
+// S1 回归：清空迷雾时换索引指针，而瓦片/导出/统计正在同时读它。
+//
+// ⚠️ 这条用例**必须带 -race 跑才有意义**：
+//
+//	go test -race -count=1 -run TestFogIndexConcurrentResetAndRead ./internal/web/
+//
+// 不带 -race 时它只能证明「并发下不 panic、拿到的不是 nil」。
+func TestFogIndexConcurrentResetAndRead(t *testing.T) {
+	f := newLoginFixture(t)
+
+	// 收尾：把索引恢复成「从库里加载」的状态，别把清空后的空索引留给后面的用例
+	t.Cleanup(func() {
+		if ix := fog.NewIndex(); ix.LoadAll(f.srv.db) == nil {
+			fogIndexV.Store(ix)
+		}
+	})
+
+	// 先触发一次初始加载，让后面的并发都落在「读已发布指针」这条路径上
+	if _, err := f.srv.fogIndex(); err != nil {
+		t.Fatalf("首次加载迷雾索引失败: %v", err)
+	}
+
+	var wg sync.WaitGroup
+	for i := 0; i < 8; i++ {
+		wg.Add(1)
+		go func() {
+			defer wg.Done()
+			for j := 0; j < 200; j++ {
+				ix, err := f.srv.fogIndex()
+				if err != nil || ix == nil {
+					t.Errorf("并发读取拿到了空索引: ix=%v err=%v", ix, err)
+					return
+				}
+				ix.Stats() // 真实读者会做的事（内部有自己的锁）
+			}
+		}()
+	}
+	wg.Add(1)
+	go func() {
+		defer wg.Done()
+		for j := 0; j < 200; j++ {
+			fogResetIndex() // 与 adminFogClear 同一个调用
+		}
+	}()
+	wg.Wait()
+}

internal/web/frontend_fixes_test.go

@@ -0,0 +1,403 @@
+package web
+
+import (
+	"io/fs"
+	"os"
+	"regexp"
+	"strings"
+	"testing"
+)
+
+// ---------- F5：地图脚本里的 localStorage 访问必须走兜底 ----------
+//
+// 隐私模式 / 禁用 Cookie 的浏览器里 localStorage 读写都会抛异常，裸调用会把整段脚本打断
+// （地图白屏、图层不出来，且控制台之外看不出来）。统一走 lsGet/lsSet。
+func TestMapLocalStorageGoesThroughGuard(t *testing.T) {
+	b, err := staticFS.ReadFile("static/js/rond-map.js")
+	if err != nil {
+		t.Fatalf("读取 rond-map.js 失败: %v", err)
+	}
+	src := string(b)
+	if !strings.Contains(src, "function lsGet(k)") || !strings.Contains(src, "function lsSet(k, v)") {
+		t.Fatal("rond-map.js 里找不到 lsGet/lsSet 兜底（写法变了，这条守卫失效）")
+	}
+	if n := strings.Count(src, "window.localStorage."); n != 2 {
+		t.Errorf("裸 localStorage 访问应只剩 lsGet/lsSet 里那 2 处，实际 %d 处"+
+			"（其余一律要走 lsGet/lsSet，否则隐私模式下整段脚本会抛异常）", n)
+	}
+}
+
+// ---------- F6：配置未就绪时的第二次 preview 不能丢点 ----------
+func TestMapPreviewQueuesPendingPoints(t *testing.T) {
+	b, err := staticFS.ReadFile("static/js/rond-map.js")
+	if err != nil {
+		t.Fatalf("读取 rond-map.js 失败: %v", err)
+	}
+	src := string(b)
+	body := funcBody(src, "preview: function (opts)")
+	if body == "" {
+		t.Fatal("在 rond-map.js 里找不到 preview（写法变了，这条守卫失效）")
+	}
+	queue := strings.Index(body, "previewQueue[opts.id] = points;")
+	live := strings.Index(body, "if (live) {")
+	if queue < 0 || live < 0 || queue > live {
+		t.Error("preview：必须在 `if (live)` 之前就把本次的点记进 previewQueue，" +
+			"否则配置未就绪时第二次 preview 的点会被静默丢掉")
+	}
+	if !strings.Contains(body, "if (previewQueue[opts.id]) points = previewQueue[opts.id];") {
+		t.Error("preview：配置回调里没把 previewQueue 排队的点取回来画")
+	}
+	if strings.Contains(src, "previewPending") {
+		t.Error("rond-map.js 里不该再有 previewPending（已由 previewQueue 取代）")
+	}
+}
+
+// ---------- F8：EXIF 全 0 时间不能变成 1899-11-30 ----------
+func TestExifRejectsOutOfRangeDate(t *testing.T) {
+	b, err := staticFS.ReadFile("static/js/photo-exif.js")
+	if err != nil {
+		t.Fatalf("读取 photo-exif.js 失败: %v", err)
+	}
+	src := string(b)
+	guard := strings.Index(src, "Y >= 1900")
+	mk := strings.Index(src, "res.shot = new Date(Y, Mo - 1, D, H, Mi, S);")
+	flag := strings.Index(src, "res.hasTime = true;")
+	if guard < 0 || mk < 0 || flag < 0 || guard > mk || guard > flag {
+		t.Error("photo-exif.js：拍摄时间必须先过范围校验再赋给 res.shot / hasTime" +
+			"（否则「0000:00:00」会被 Date 归一成 1899-11-30，被当成到达时间写进库）")
+	}
+}
+
+// ---------- F9：findExifItemID 读 count 前必须卡住宽度 ----------
+func TestExifItemIDChecksBoundsBeforeRead(t *testing.T) {
+	b, err := staticFS.ReadFile("static/js/photo-exif.js")
+	if err != nil {
+		t.Fatalf("读取 photo-exif.js 失败: %v", err)
+	}
+	body := funcBody(string(b), "function findExifItemID(")
+	if body == "" {
+		t.Fatal("在 photo-exif.js 里找不到 findExifItemID（写法变了，这条守卫失效）")
+	}
+	bounds := strings.Index(body, "p + 2 > u8.length")
+	read := strings.Index(body, "dv.getUint16(p)")
+	if bounds < 0 || read < 0 || bounds > read {
+		t.Error("findExifItemID：读 count 之前必须按 ver 卡住宽度（p+2 / p+4）——" +
+			"末尾恰好相等（start+4 == length）时旧守卫会放行，越界会抛 RangeError")
+	}
+}
+
+// ---------- F16：数据编辑页每个筛选表单都要带上全部筛选条件 ----------
+//
+// 三个表单各自只放自己那几个控件，其余条件靠隐藏域带着；漏一个，用户一提交
+// 就会把别的列表的筛选悄悄清掉（原来「到访」表单只带 vq+back）。
+func TestEditSearchFormsCarryAllFilters(t *testing.T) {
+	b, err := tmplFS.ReadFile("templates/admin/edit.html")
+	if err != nil {
+		t.Fatalf("读取 edit.html 失败: %v", err)
+	}
+	src := string(b)
+	const open = `<form method="get" action="/admin/edit"`
+	params := []string{`name="q"`, `name="src"`, `name="sus"`, `name="vq"`,
+		`name="mt"`, `name="mp"`, `name="mfrom"`, `name="mto"`}
+	n := 0
+	rest := src
+	for {
+		i := strings.Index(rest, open)
+		if i < 0 {
+			break
+		}
+		n++
+		rest = rest[i:]
+		j := strings.Index(rest, "</form>")
+		if j < 0 {
+			t.Fatalf("第 %d 个筛选表单没有收尾", n)
+		}
+		body := rest[:j]
+		for _, p := range params {
+			if !strings.Contains(body, p) {
+				t.Errorf("第 %d 个筛选表单少了 %s：一提交就会把别的列表的筛选清掉", n, p)
+			}
+		}
+		rest = rest[j:]
+	}
+	if n < 3 {
+		t.Fatalf("只找到 %d 个 /admin/edit 筛选表单，预期至少 3 个（写法变了，这条守卫失效）", n)
+	}
+}
+
+// ---------- F17：`safe` 这个现成的转义出口不该留着 ----------
+func TestNoSafeEscapeFunc(t *testing.T) {
+	b, err := os.ReadFile(pkgFile(t, "view.go"))
+	if err != nil {
+		t.Fatalf("读取 view.go 失败: %v", err)
+	}
+	if strings.Contains(string(b), `"safe":`) {
+		t.Error("view.go 里不该再有 `safe` 模板函数（模板一处都没用，却是个现成的 HTML 注入出口）")
+	}
+}
+
+// ---------- F18：纯图标按钮要有 aria-label，图片要有 alt ----------
+func TestPlaceImageControlsAreLabelled(t *testing.T) {
+	b, err := tmplFS.ReadFile("templates/place.html")
+	if err != nil {
+		t.Fatalf("读取 place.html 失败: %v", err)
+	}
+	src := string(b)
+	if !strings.Contains(src, `aria-label="删除这张图片"`) {
+		t.Error("place.html 模板渲染的删除按钮（×）缺 aria-label")
+	}
+	if !strings.Contains(src, `setAttribute('aria-label', '删除这张图片')`) {
+		t.Error("place.html 用 JS 新建的删除按钮（×）缺 aria-label")
+	}
+	if strings.Contains(src, `img.alt = ''`) {
+		t.Error("place.html 新建缩略图时 alt 不能留空")
+	}
+}
+
+// ---------- 窄屏导航：链接行收进菜单（原来是横向滚动，最右边那个字会被切掉） ----------
+//
+// 620px 以下链接行一定放不下（实测：390 溢 63px、320 溢 133px，「统计」被切成半个字紧贴
+// 后面的按钮，而渐隐提示实际上看不出来）。现在整行收进 .nav-menu 这个原生 <details>。
+//
+// 这条守卫钉的是**成对关系**：CSS 的两半（桌面藏菜单 / 窄屏藏链接行）与模板里的两个类
+// 缺任何一个，窄屏就会退回老样子、或者宽屏凭空多出一个菜单按钮。
+func TestNarrowNavCollapsesToMenu(t *testing.T) {
+	css, err := os.ReadFile(pkgFile(t, "static/css/app.css"))
+	if err != nil {
+		t.Fatalf("读取 app.css 失败: %v", err)
+	}
+	src := string(css)
+	for _, want := range []string{
+		".nav-menu { display: none; }",           // 桌面：菜单按钮不出现
+		".nav-links { display: none; }",          // 窄屏：链接行不出现
+		".nav-menu { display: block; flex: 1; }", // 窄屏：菜单按钮取而代之
+	} {
+		if !strings.Contains(src, want) {
+			t.Errorf("app.css 缺少 %q —— 「桌面藏菜单 / 窄屏藏链接行」这两半必须成对，"+
+				"否则窄屏会退回「横向滚动 + 最右边的字被切掉」", want)
+		}
+	}
+
+	b, err := tmplFS.ReadFile("templates/layout.html")
+	if err != nil {
+		t.Fatalf("读取 layout.html 失败: %v", err)
+	}
+	nav := string(b)
+	if !strings.Contains(nav, `class="nav-links"`) || !strings.Contains(nav, `class="nav-menu"`) {
+		t.Error("layout.html 里 .nav-links 与 .nav-menu 必须都在：CSS 的两半分别作用在这两个元素上")
+	}
+	if n := strings.Count(nav, `{{template "navitems" .}}`); n != 2 {
+		t.Errorf("导航链接应当渲染两遍（宽屏平铺 + 窄屏菜单），实际 %d 处", n)
+	}
+}
+
+// ---------- 日期输入必须走统一入口 attachAll ----------
+//
+// 2026-10-09 用户报的 bug：筛选区是原生 <input type=date>，而挂载代码只写了
+// querySelectorAll('input[type=datetime-local]') —— **类型变体没人管**，于是 Chrome 的年段
+// 吞下 6 位数字，敲 20260606 变成 202606/06、el.value 还是空的（筛选条件静默丢掉）。
+//
+// 守卫三件事：
+//
+//	① 模板里不许再出现按 type 挑日期框的选择器 —— 那个选择器只能待在 datetime-input.js 里；
+//	② layout.html 必须**无条件**引入 datetime-input.js（公共页的筛选框也要用，那边不加载 flatpickr）；
+//	③ 统一入口 attachAll 必须存在，且四类页面都调它。
+func TestDateInputsGoThroughAttachAll(t *testing.T) {
+	js, err := staticFS.ReadFile("static/js/datetime-input.js")
+	if err != nil {
+		t.Fatalf("读取 datetime-input.js 失败: %v", err)
+	}
+	if !strings.Contains(string(js), "function attachAll(") {
+		t.Fatal("datetime-input.js 里没有 attachAll —— 统一入口没了，以后新加的输入类型又会被漏掉")
+	}
+
+	layout, err := tmplFS.ReadFile("templates/layout.html")
+	if err != nil {
+		t.Fatalf("读取 layout.html 失败: %v", err)
+	}
+	lay := string(layout)
+	// 日期控件与它的日历弹层必须**无条件**加载：筛选区在公共页上也有日期框，而
+	// 「按页开开关」这种写法漏过一次（2026-10-09 的日期框 bug 就是只挂了 datetime-local）。
+	for _, needle := range []string{
+		"/static/vendor/flatpickr/flatpickr.min.js",
+		"/static/vendor/flatpickr/flatpickr.min.css",
+		"/static/js/datetime-input.js",
+		"rondDatetime.attachAll(",
+	} {
+		if !strings.Contains(lay, needle) {
+			t.Errorf("layout.html 里缺 %s —— 那一页的日期框会退回原生控件（没有日历弹层）", needle)
+		}
+	}
+	if strings.Contains(lay, "{{if .Flatpickr}}") {
+		t.Error("layout.html 里又出现了 {{if .Flatpickr}} 这种按页开关 —— 日期控件已改成无条件加载，" +
+			"开关一旦漏设，那一页的日期框就没有日历弹层（别再引入会漏的东西）")
+	}
+
+	names, err := fs.Glob(tmplFS, "templates/*.html")
+	if err != nil {
+		t.Fatalf("列举模板失败: %v", err)
+	}
+	adminNames, err := fs.Glob(tmplFS, "templates/admin/*.html")
+	if err != nil {
+		t.Fatalf("列举后台模板失败: %v", err)
+	}
+	sels := []string{"input[type=datetime-local]", "input[type=date]"}
+	for _, name := range append(names, adminNames...) {
+		b, err := tmplFS.ReadFile(name)
+		if err != nil {
+			t.Fatalf("读取 %s 失败: %v", name, err)
+		}
+		for _, sel := range sels {
+			if strings.Contains(string(b), sel) {
+				t.Errorf("%s 里又出现手写的日期选择器 %q —— 一律走 rondDatetime.attachAll()，"+
+					"否则新加的输入类型会被漏掉（2026-10-09 的日期框 bug 就是这么来的）", name, sel)
+			}
+		}
+	}
+	for _, name := range []string{"templates/admin/edit.html", "templates/admin/photos.html", "templates/admin/topics.html"} {
+		b, err := tmplFS.ReadFile(name)
+		if err != nil {
+			t.Fatalf("读取 %s 失败: %v", name, err)
+		}
+		if !strings.Contains(string(b), "attachAll(") {
+			t.Errorf("%s 没有调用 attachAll（它自己那批日期框会退回原生控件）", name)
+		}
+	}
+}
+
+// ---------- 专题的迷雾要和「显示区」成对：模板传 fogAreas、地图脚本认 fogAreas ----------
+//
+// 2026-10-10 用户实测发现：专题圈了区域，迷雾却还是全局的。而管理页原本的说明写的是
+// 「区域内的世界迷雾由地图按视野自动呈现，不需要单独圈选」—— **文档与实现不一致**
+// （迷雾一直是全局瓦片，完全不认区域），这种「说明写了、实现没做」最容易蒙混过关。
+//
+// 这条守卫钉住两端与两处顺序：
+//
+//	① topic.html 必须把专题显示区传给地图（且**无条件**传，不限区域时是空数组）；
+//	② rond-map.js 必须实现收口（单独 pane + clip-path，不能裁默认 tilePane——底图在里面）
+//	   且多圆要交给 fog-clip.js 的 pathFor；
+//	③ fog-clip.js 必须在 rond-map.js **之前**加载（否则 window.rondFogClip 还没有）；
+//	④ 裁剪的注册必须排在 applyFit() 之后：视图还没定时 latLngToContainerPoint() 会抛
+//	   「Set map center and zoom first.」，那行异常会把后面的图层添加一起打断
+//	   （实测：pane 建好了、迷雾瓦片一张都没有）。
+func TestTopicFogIsClippedToAreas(t *testing.T) {
+	tpl, err := tmplFS.ReadFile("templates/topic.html")
+	if err != nil {
+		t.Fatalf("读取 topic.html 失败: %v", err)
+	}
+	body := string(tpl)
+	if !strings.Contains(body, "fogAreas:") {
+		t.Error("topic.html 没把专题显示区（fogAreas）传给地图 —— 迷雾不会被收口")
+	}
+	// 无条件传（不要包在 {{if .Topic.HasArea}} 里）：条件分支是「有区域忘了新增分支」
+	// 这类漏传的温床，而空数组对脚本来说就是「不限区域」，没必要分两条路。
+	if !strings.Contains(body, "fogAreas: {{.Topic.AreasJSON}}") {
+		t.Error("fogAreas 应当无条件下发 {{.Topic.AreasJSON}}（不限区域时为空数组），别包在条件里")
+	}
+
+	js, err := staticFS.ReadFile("static/js/rond-map.js")
+	if err != nil {
+		t.Fatalf("读取 rond-map.js 失败: %v", err)
+	}
+	src := string(js)
+	for _, needle := range []string{"opts.fogAreas", "createPane('rondFog')", "clipPath", "rondFogClip.pathFor"} {
+		if !strings.Contains(src, needle) {
+			t.Errorf("rond-map.js 里缺 %q —— 迷雾的收口没实现或被改掉了", needle)
+		}
+	}
+	// 顺序：注册点必须排在 `var applyFit = function` 之后 —— 放早了（比如塞在迷雾图层那段里）
+	// 就是在视图定下来之前算裁剪圆，会抛「Set map center and zoom first.」并打断后续图层添加。
+	reg := strings.Index(src, "map.on('move zoom viewreset resize', applyFogClip)")
+	fitDef := strings.Index(src, "var applyFit = function")
+	if reg < 0 || fitDef < 0 || reg < fitDef {
+		t.Error("applyFogClip 的注册必须排在 applyFit 定义（也就是视图设定）之后 —— " +
+			"视图未定时算裁剪圆会抛错，并把后面的图层添加一起打断")
+	}
+
+	// 多圆路径拼在 fog-clip.js 里，它必须在 rond-map.js 之前加载
+	clip, err := staticFS.ReadFile("static/js/fog-clip.js")
+	if err != nil {
+		t.Fatalf("读取 fog-clip.js 失败: %v", err)
+	}
+	if !strings.Contains(string(clip), "rondFogClip") {
+		t.Error("fog-clip.js 没有暴露 rondFogClip —— rond-map.js 拿不到路径构造函数")
+	}
+	layout, err := tmplFS.ReadFile("templates/layout.html")
+	if err != nil {
+		t.Fatalf("读取 layout.html 失败: %v", err)
+	}
+	lay := string(layout)
+	iClip := strings.Index(lay, "/static/js/fog-clip.js")
+	iMap := strings.Index(lay, "/static/js/rond-map.js")
+	if iClip < 0 {
+		t.Error("layout.html 没引入 fog-clip.js —— 专题的多圆裁剪会静默退化成「不裁剪」")
+	} else if iMap < 0 || iClip > iMap {
+		t.Error("fog-clip.js 必须排在 rond-map.js 之前加载")
+	}
+}
+
+// ---------- 字阶纪律：app.css 与模板内联样式都只走令牌 ----------
+//
+// 改前 app.css 里散着 10 / 10.5 / 11 / 11.5 / 12 / 12.5 / 12.8 / 13 / 13.5 / 14 / 14.5 / 15 /
+// 17 / 18 / 21px 十几档字号，光 12~15px 之间就挤了 4 档 —— 层级挤不出来，只能靠加粗硬顶；
+// 模板里另有 54 处内联字号。现在：文本走 --fs-*，表单控件走 --fs-control（窄屏必须 ≥16px，
+// 否则 iOS 聚焦会放大整页），字形走 --glyph-*（22px 的 ✕ 塞进字阶只会把按钮撑坏）。
+func TestNoBareFontSizePx(t *testing.T) {
+	re := regexp.MustCompile(`font-size:\s*[^;\n]*[0-9]+(\.[0-9]+)?px`)
+	check := func(name string, b []byte) {
+		for _, m := range re.FindAllString(string(b), -1) {
+			t.Errorf("%s 里还有裸字号 %q —— 一律走 --fs-* / --fs-control / --glyph-* 令牌", name, m)
+		}
+	}
+
+	b, err := os.ReadFile(pkgFile(t, "static/css/app.css"))
+	if err != nil {
+		t.Fatalf("读取 app.css 失败: %v", err)
+	}
+	check("app.css", b)
+
+	for _, dir := range []string{"templates/*.html", "templates/admin/*.html"} {
+		names, err := fs.Glob(tmplFS, dir)
+		if err != nil {
+			t.Fatalf("列举 %s 失败: %v", dir, err)
+		}
+		for _, name := range names {
+			body, err := tmplFS.ReadFile(name)
+			if err != nil {
+				t.Fatalf("读取 %s 失败: %v", name, err)
+			}
+			check(name, body)
+		}
+	}
+}
+
+// ---------- F10：补全页的 sessionStorage 读写都要包在 try 里 ----------
+//
+// 隐私模式下 sessionStorage 本身就抛，脏数据又会让 JSON.parse 抛；任何一处漏了 try，
+// 整段脚本就从那一行断掉——下拉候选、草稿恢复全部哑掉，而且控制台之外看不出来。
+func TestFillupSessionStorageIsGuarded(t *testing.T) {
+	b, err := tmplFS.ReadFile("templates/admin/fillup.html")
+	if err != nil {
+		t.Fatalf("读取 fillup.html 失败: %v", err)
+	}
+	src := string(b)
+	needles := []string{"JSON.parse(sessionStorage", "sessionStorage.setItem"}
+	total := 0
+	for _, n := range needles {
+		rest := src
+		for {
+			i := strings.Index(rest, n)
+			if i < 0 {
+				break
+			}
+			total++
+			if open := strings.LastIndex(rest[:i], "try {"); open < 0 || i-open > 160 {
+				t.Errorf("fillup.html：`%s` 前面没有紧挨着的 try {（隐私模式 / 脏数据会中断整段脚本）", n)
+			}
+			rest = rest[i+len(n):]
+		}
+	}
+	if total == 0 {
+		t.Fatal("fillup.html 里找不到 sessionStorage 读写（写法变了，这条守卫失效）")
+	}
+}

internal/web/gpx_owner_test.go

@@ -0,0 +1,177 @@
+package web
+
+import (
+	"fmt"
+	"net/http/httptest"
+	"net/url"
+	"os"
+	"strings"
+	"testing"
+	"time"
+)
+
+// S8 回归：GPX 轨迹必须按属主圈定。
+//
+// gpx_tracks 带 user_id（为将来多用户留位），但两个入口都没用它：
+//   - `GET /api/gpx` 是**公开**接口，却把整张表端出去；
+//   - `POST /admin/gpx/delete` 的 id 来自客户端，只按 id 删就能删别人的。
+//
+// 单用户站点上影响不大，但这是「越权」而不是「影响小」——而且两处都只差一个 user_id 条件。
+func TestGpxOwnershipScoping(t *testing.T) {
+	f := newMovementFixture(t)
+	ctx, pg := f.ctx, f.pg
+
+	var owner int64
+	if err := pg.QueryRowContext(ctx, `SELECT user_id FROM datasets WHERE id=$1`, f.dsID).Scan(&owner); err != nil {
+		t.Fatalf("读数据集属主失败: %v", err)
+	}
+
+	// 外来账号：只为了拥有一条不属于本站主的轨迹
+	foreign := fmt.Sprintf("e2e-gpx-other-%d", time.Now().UnixNano())
+	var foreignID int64
+	if err := pg.QueryRowContext(ctx, `INSERT INTO users (username, password_hash, display_name)
+		VALUES ($1,'x','gpx-other') RETURNING id`, foreign).Scan(&foreignID); err != nil {
+		t.Fatalf("建外来账号失败: %v", err)
+	}
+	mkTrack := func(uid int64, name string) int64 {
+		t.Helper()
+		var id int64
+		if err := pg.QueryRowContext(ctx, `INSERT INTO gpx_tracks
+			(user_id, name, point_count, length_km, points)
+			VALUES ($1,$2,1,1.0,'[[40.0,116.0]]'::jsonb) RETURNING id`, uid, name).Scan(&id); err != nil {
+			t.Fatalf("插入轨迹 %s 失败: %v", name, err)
+		}
+		return id
+	}
+	strayTrack := mkTrack(foreignID, "FOREIGN-"+foreign)
+	ownTrack := mkTrack(owner, "OWNER-"+foreign)
+	t.Cleanup(func() {
+		pg.ExecContext(ctx, `DELETE FROM gpx_tracks WHERE id IN ($1,$2)`, strayTrack, ownTrack)
+		pg.ExecContext(ctx, `DELETE FROM users WHERE id=$1`, foreignID)
+	})
+
+	// 1) 公开接口不许端出别人的轨迹。
+	// 判据不依赖「哪份数据集恰好是活跃的」：只要求返回的每条都属于活跃属主，
+	// 而外来那条必须不在其中——后者才是安全不变量。
+	var activeOwner int64
+	if err := pg.QueryRowContext(ctx, `SELECT user_id FROM datasets
+		WHERE is_active AND status='done' ORDER BY uploaded_at DESC LIMIT 1`).Scan(&activeOwner); err != nil {
+		t.Fatalf("读活跃数据集属主失败: %v", err)
+	}
+	rec := httptest.NewRecorder()
+	f.srv.apiGpx(rec, httptest.NewRequest("GET", "/api/gpx", nil))
+	if rec.Code != 200 {
+		t.Fatalf("apiGpx 返回 %d: %s", rec.Code, rec.Body.String())
+	}
+	body := rec.Body.String()
+	if strings.Contains(body, "FOREIGN-") {
+		t.Errorf("公开接口把别的账号的轨迹也端出来了：%s", truncate(body, 300))
+	}
+	if !strings.Contains(body, "OWNER-") {
+		t.Fatalf("活跃数据集属主（user_id=%d）自己的轨迹没返回，用例失去意义：%s",
+			activeOwner, truncate(body, 300))
+	}
+
+	// 2) 删除别人账号的轨迹必须被拒，而且不能真删掉。
+	victim := httptest.NewRecorder()
+	req := httptest.NewRequest("POST", "/admin/gpx/delete",
+		strings.NewReader(url.Values{"id": {fmt.Sprint(strayTrack)}}.Encode()))
+	req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
+	f.srv.adminGpxDelete(victim, req.WithContext(f.ctx))
+	if msg := flashMsg(t, victim); !strings.Contains(msg, "不存在") {
+		t.Errorf("删别人的轨迹应当回「不存在」，实际 %q", msg)
+	}
+	var still int
+	if err := pg.QueryRowContext(ctx, `SELECT count(*) FROM gpx_tracks WHERE id=$1`, strayTrack).Scan(&still); err != nil {
+		t.Fatal(err)
+	}
+	if still != 1 {
+		t.Errorf("别人的轨迹被删掉了（id=%d）——越权删除", strayTrack)
+	}
+
+	// 3) 删自己的要能删掉（别为堵越权把正常路径也堵死了）。
+	okRec := httptest.NewRecorder()
+	req = httptest.NewRequest("POST", "/admin/gpx/delete",
+		strings.NewReader(url.Values{"id": {fmt.Sprint(ownTrack)}}.Encode()))
+	req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
+	f.srv.adminGpxDelete(okRec, req.WithContext(f.ctx))
+	if msg := flashMsg(t, okRec); !strings.Contains(msg, "已删除") {
+		t.Errorf("删自己的轨迹应当成功，实际 %q", msg)
+	}
+	var gone int
+	if err := pg.QueryRowContext(ctx, `SELECT count(*) FROM gpx_tracks WHERE id=$1`, ownTrack).Scan(&gone); err != nil {
+		t.Fatal(err)
+	}
+	if gone != 0 {
+		t.Errorf("自己的轨迹没被删掉（id=%d）", ownTrack)
+	}
+}
+
+// truncate 只用于把失败信息压短，超长时截断。
+func truncate(s string, n int) string {
+	if len(s) <= n {
+		return s
+	}
+	return s[:n] + "…"
+}
+
+// sqlText 取出函数体里所有反引号包的 SQL 片段。
+//
+// 守卫必须只看 SQL：函数里的**中文注释**也会出现「user_id」这个词，
+// 直接 strings.Contains(body, "user_id") 会被注释顶包——变异掉真条件照样绿。
+func sqlText(body string) string {
+	var b strings.Builder
+	for i := 0; ; {
+		a := strings.IndexByte(body[i:], '`')
+		if a < 0 {
+			break
+		}
+		a += i
+		z := strings.IndexByte(body[a+1:], '`')
+		if z < 0 {
+			break
+		}
+		z += a + 1
+		b.WriteString(body[a+1 : z])
+		b.WriteByte('\n')
+		i = z + 1
+	}
+	return b.String()
+}
+
+// S8 静态守卫：两个入口的 SQL 都必须带 user_id 条件。
+// 行为用例要导一份备份包才能跑（约 6 秒）；这条永远不 skip，防止「改回去」时静默回归。
+func TestGpxQueriesCarryUserID(t *testing.T) {
+	for _, c := range []struct {
+		file string
+		sig  string
+		want []string
+	}{
+		{"handlers_public.go", "func (s *Server) apiGpx(", []string{"user_id"}},
+		{"handlers_admin.go", "func (s *Server) adminGpxDelete(", []string{"user_id"}},
+	} {
+		data, err := os.ReadFile(pkgFile(t, c.file))
+		if err != nil {
+			t.Fatalf("读 %s 失败: %v", c.file, err)
+		}
+		body := sliceFunc(t, string(data), c.sig)
+		q := sqlText(body)
+		if strings.TrimSpace(q) == "" {
+			t.Fatalf("%s 的 %s 里没找到 SQL 字符串，守卫的切片判据需要更新", c.file, c.sig)
+		}
+		for _, w := range c.want {
+			if !strings.Contains(q, w) {
+				t.Errorf("%s 的 %s 的 SQL 里没有 %q：轨迹没按属主圈定", c.file, c.sig, w)
+			}
+		}
+	}
+	// 删不到时的反馈也要有断言：不然「删别人的」会回一句「已删除」。
+	data, err := os.ReadFile(pkgFile(t, "handlers_admin.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	del := sliceFunc(t, string(data), "func (s *Server) adminGpxDelete(")
+	if !strings.Contains(del, "RowsAffected") {
+		t.Error("adminGpxDelete 没看受影响行数：删不到也会回「已删除」")
+	}
+}

internal/web/gzip.go

@@ -88,6 +88,11 @@ func (g *gzipWriter) Flush() {
 	}
 }
 
+// Unwrap 让 http.NewResponseController 能穿过这层包装拿到真正的 ResponseWriter
+// （SetWriteDeadline / Flush / Hijack 都靠它逐层解包）。少了这个方法，
+// 被包装的请求调 SetWriteDeadline 只会拿到 ErrNotSupported。
+func (g *gzipWriter) Unwrap() http.ResponseWriter { return g.ResponseWriter }
+
 func (g *gzipWriter) close() {
 	if g.gz != nil {
 		g.gz.Close()

internal/web/handlers_admin.go

@@ -10,6 +10,7 @@ import (
 	"log"
 	"math"
 	"net/http"
+	"net/url"
 	"os"
 	"path/filepath"
 	"strconv"
@@ -62,6 +63,15 @@ func (s *Server) checkCaptcha(r *http.Request) bool {
 	return s.captcha.Verify(c.Value, r.PostFormValue("captcha"))
 }
 
+// tooManyTries 把等待时长写成一句人话。向上取整，免得显示「请 0 秒后再试」。
+func tooManyTries(wait time.Duration) string {
+	sec := int(wait/time.Second) + 1
+	if sec < 60 {
+		return fmt.Sprintf("登录尝试过于频繁，请 %d 秒后再试", sec)
+	}
+	return fmt.Sprintf("登录尝试过于频繁，请 %d 分钟后再试", (sec+59)/60)
+}
+
 func (s *Server) loginPage(w http.ResponseWriter, r *http.Request) {
 	sets, err := s.sets.Load(r.Context())
 	if err != nil {
@@ -99,20 +109,33 @@ func (s *Server) loginSubmit(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 
+	// 爆破短锁：验证码之后还有一道，连错到阈值就按用户名指数退避
+	if wait := s.loginGuard.RetryAfter(username); wait > 0 {
+		sets, _ := s.sets.Load(ctx)
+		s.renderStatus(w, http.StatusTooManyRequests, "admin/login", LoginData{
+			Settings: sets, Err: tooManyTries(wait), Next: next,
+		})
+		return
+	}
+
 	u, err := s.auth.Authenticate(ctx, username, password)
 	if err != nil {
 		sets, _ := s.sets.Load(ctx)
 		code := http.StatusOK
-		if !errors.Is(err, auth.ErrInvalidCredentials) {
-			code = http.StatusInternalServerError
-		}
 		msg := "用户名或密码错误"
-		if code == http.StatusInternalServerError {
+		if !errors.Is(err, auth.ErrInvalidCredentials) {
-			msg = "登录失败：" + err.Error()
+			// 登录页是公开的，内部错误只进日志，不回显给门外的人
+			log.Printf("登录失败 %s: %v", username, err)
+			code = http.StatusInternalServerError
+			msg = "登录失败，请稍后重试"
+		} else if wait := s.loginGuard.Fail(username); wait > 0 {
+			code = http.StatusTooManyRequests
+			msg = tooManyTries(wait)
 		}
 		s.renderStatus(w, code, "admin/login", LoginData{Settings: sets, Err: msg, Next: next})
 		return
 	}
+	s.loginGuard.Succeed(username)
 	// 已开启两步验证：口令过关只算第一步，签发短时中间令牌进入验证码页
 	if _, enabled, _ := s.auth.TOTPState(ctx, u.ID); enabled {
 		sets, _ := s.sets.Load(ctx)
@@ -121,9 +144,10 @@ func (s *Server) loginSubmit(w http.ResponseWriter, r *http.Request) {
 		})
 		return
 	}
-	s.login(w, u.ID, u.Hash)
+	s.login(w, r, u.ID, u.Hash)
 	target := "/admin"
-	if strings.HasPrefix(next, "/admin") {
+	// 同样先过站内路径判据（挡控制字符/引号），再限定必须落在 /admin 下
+	if next = safeInternalPath(next); strings.HasPrefix(next, "/admin") {
 		target = next
 	}
 	http.Redirect(w, r, target, http.StatusSeeOther)
@@ -150,6 +174,8 @@ func (s *Server) adminHome(w http.ResponseWriter, r *http.Request) {
 		}
 	}
 	d.FogMasks = len(s.masksFor())
+	// 图片挂载体检：行与对象对不上就当场可见（见 imageHealth 的注释）
+	d.ImgRows, d.ImgObjects, d.ImgOrphans = s.imageHealth(r.Context())
 	var fogUpdated sql.NullTime
 	if err := s.db.QueryRowContext(r.Context(),
 		`SELECT max(updated_at) FROM fog_blocks`).Scan(&fogUpdated); err != nil {
@@ -202,6 +228,15 @@ func (s *Server) adminUpload(w http.ResponseWriter, r *http.Request) {
 	}
 
 	stored := filepath.Join(s.cfg.UploadDir, fmt.Sprintf("%d-%s", time.Now().Unix(), sanitize(name)))
+	// 落盘之后每条失败路径都要把半成品删掉：否则反复上传坏包会在 uploads 里堆垃圾。
+	// 只有「新导入成功」那一支会 keepStored = true —— 那份上传件要留给导出当基线源
+	// （findSourceArchive 就是按 datasets.sha256 在 uploads 里找它）。
+	keepStored := false
+	defer func() {
+		if !keepStored {
+			os.Remove(stored)
+		}
+	}()
 	out, err := os.Create(stored)
 	if err != nil {
 		s.serverError(w, r, err)
@@ -265,6 +300,7 @@ func (s *Server) adminUpload(w http.ResponseWriter, r *http.Request) {
 	// 否则 rond 原生的标志位（ZPINSTYLE_/ZRADIUS/ZVISIT.ZRAW…）会被洗成 NULL，越导越失真。
 	// 老数据集缺基线的情况，交给 ensureBaseline 按当初上传的原始包重建。
 	if !st.Identical {
+		keepStored = true
 		if err := rond.WriteBaseline(stored, s.baselinePath(datasetID)); err != nil {
 			log.Printf("写入基线库失败（导出 rondbackup 时需重新上传原始备份）: %v", err)
 		}
@@ -432,6 +468,7 @@ func (s *Server) settingsPage(w http.ResponseWriter, r *http.Request) {
 	d := SettingsData{Page: p, Modules: setting.AllModules, Pages: setting.AllPages,
 		MapInfo: s.mapInfo(), MapLayers: layers, S3Info: s.s3Info()}
 	d.Flash = r.URL.Query().Get("saved")
+	d.Warn = trackWarnMessage(r.URL.Query().Get("warn"))
 	s.render(w, "admin/settings", d)
 }
 
@@ -546,11 +583,105 @@ func (s *Server) settingsSubmit(w http.ResponseWriter, r *http.Request) {
 	if r.PostFormValue("regions_mode") == setting.RegionsBlacklist {
 		next.RegionsMode = setting.RegionsBlacklist
 	}
+	script, trackWarn := cleanTrackScript(r.PostFormValue("track_script"))
+	if trackWarnRejected(trackWarn) {
+		// 判为危险：这次改动整段不采纳，库里原有的脚本与开关都保持不动
+		// （next := cur 已经带上了它们）。把站长手上本来好用的脚本一并清掉，
+		// 比拒绝这次改动更糟。
+	} else {
+		next.TrackScript = script
+		// 开关只在「勾选 + 脚本非空」时才生效：勾了但没填内容等于没开，
+		// 否则 layout 里会挂一个空 <script>，看着像开了其实什么也没统计。
+		next.TrackEnabled = r.PostFormValue("track_enabled") == "on" && next.TrackScript != ""
+	}
 	if err := s.sets.Save(ctx, next); err != nil {
 		s.serverError(w, r, err)
 		return
 	}
-	http.Redirect(w, r, "/admin/settings?saved=1", http.StatusSeeOther)
+	dest := "/admin/settings?saved=1"
+	if trackWarn != "" {
+		dest += "&warn=" + url.QueryEscape(trackWarn)
+	}
+	http.Redirect(w, r, dest, http.StatusSeeOther)
+}
+
+// 统计脚本没被原样采纳时的三类说明码。它们是固定常量、不是用户输入，
+// 所以可以安全地放进跳转查询串，再由 trackWarnMessage 翻成人话。
+const (
+	warnTrackTruncated  = "truncated"
+	warnTrackUnbalanced = "unbalanced"
+	warnTrackBadSrc     = "badsrc"
+)
+
+// trackWarnMessage 把说明码翻成人话；未识别的码不提示（不回显查询串原文）。
+func trackWarnMessage(code string) string {
+	switch code {
+	case warnTrackTruncated:
+		return "统计脚本超过 4096 字符，已截断保存"
+	case warnTrackUnbalanced:
+		return "统计脚本里 <script> 与 </script> 的数量不配对，本次改动已拒绝，库里原有脚本保持不变"
+	case warnTrackBadSrc:
+		return "统计脚本的 src 只接受 http://、https:// 或站内相对路径，本次改动已拒绝，库里原有脚本保持不变"
+	}
+	return ""
+}
+
+// trackWarnRejected 报告这个说明码是否代表「整段没被采纳」。
+func trackWarnRejected(code string) bool {
+	return code == warnTrackUnbalanced || code == warnTrackBadSrc
+}
+
+// cleanTrackScript 收拾管理员粘进来的统计脚本，返回采纳后的内容与一个说明码（空 = 原样通过）。
+//
+// 这段内容会被原样注入**每一个公开页面**，所以要挡住几类会伤到访客的输入。
+// 但**不能**简单地把「出现 </script 就拒」当规则：百度统计、Umami 这类服务
+// 贴进来的就是完整 HTML，一行里必然带 </script>，一拒就把正常用法挡死了。
+//
+// 两条判据：
+//   - 开闭 <script> 标签必须**严格配平**：少一个 </script> 会提前闭合、后面的内容
+//     当正文渲染（页面布局散架），多一个 <script> 则会把页面剩下的收尾整段吞进脚本。
+//   - 开标签上的 src 只放行 http(s):// 与站内相对路径，挡掉 javascript: / data: 伪协议。
+//
+// src 只在**标签内部**找。以前是对整段做 strings.Index(low, "src=")，于是脚本体里
+// 一句 `img.src=u` 就会被命中、整段被判危险而清空——页面却照样提示「设置已保存」，
+// 站长根本看不出脚本没挂上（实测复现过）。
+func cleanTrackScript(v string) (script, warn string) {
+	v = strings.TrimSpace(v)
+	if v == "" {
+		return "", ""
+	}
+	const maxLen = 4096
+	if len(v) > maxLen {
+		v = v[:maxLen]
+		warn = warnTrackTruncated
+	}
+	low := strings.ToLower(v)
+	open := 0
+	for i := 0; ; {
+		j := strings.Index(low[i:], "<script")
+		if j < 0 {
+			break
+		}
+		start := i + j
+		open++
+		end := strings.IndexByte(low[start:], '>')
+		if end < 0 {
+			break // 这个开标签没闭合，交给下面的配平判定处理
+		}
+		tag := low[start : start+end]
+		if k := strings.Index(tag, "src="); k >= 0 {
+			rest := strings.TrimLeft(tag[k+4:], "'\" \t")
+			if rest != "" && !strings.HasPrefix(rest, "http://") &&
+				!strings.HasPrefix(rest, "https://") && !strings.HasPrefix(rest, "/") {
+				return "", warnTrackBadSrc
+			}
+		}
+		i = start + end + 1
+	}
+	if shut := strings.Count(low, "</script"); open != shut {
+		return "", warnTrackUnbalanced
+	}
+	return v, warn
 }
 
 // ---------- 修改口令 ----------
@@ -866,19 +997,15 @@ func (s *Server) adminNotesBulk(w http.ResponseWriter, r *http.Request) {
 	var msg string
 	switch action {
 	case "delete":
-		for _, id := range ids {
+		if err := s.notes.DeleteBulk(r.Context(), u.ID, ds.ID, ids); err != nil {
-			if err := s.notes.Delete(r.Context(), u.ID, ds.ID, int(id)); err != nil {
+			s.serverError(w, r, err)
-				s.serverError(w, r, err)
+			return
-				return
-			}
 		}
 		msg = fmt.Sprintf("已删除 %d 个地点的备注与别名", len(ids))
 	case "clear":
-		for _, id := range ids {
+		if err := s.notes.SetNoteBulk(r.Context(), u.ID, ds.ID, ids); err != nil {
-			if err := s.notes.SetNote(r.Context(), u.ID, ds.ID, int(id), ""); err != nil {
+			s.serverError(w, r, err)
-				s.serverError(w, r, err)
+			return
-				return
-			}
 		}
 		msg = fmt.Sprintf("已清空 %d 个地点的备注（保留别名）", len(ids))
 	case "verdict":
@@ -886,11 +1013,9 @@ func (s *Server) adminNotesBulk(w http.ResponseWriter, r *http.Request) {
 		if verdict != votes.VerdictRecommend && verdict != votes.VerdictAvoid {
 			verdict = 0
 		}
-		for _, id := range ids {
+		if err := s.votes.SaveVerdictBulk(r.Context(), u.ID, ds.ID, ids, verdict); err != nil {
-			if err := s.votes.SaveVerdict(r.Context(), u.ID, ds.ID, int(id), verdict); err != nil {
+			s.serverError(w, r, err)
-				s.serverError(w, r, err)
+			return
-				return
-			}
 		}
 		if verdict == 0 {
 			msg = fmt.Sprintf("已取消 %d 个地点的结论", len(ids))
@@ -941,7 +1066,7 @@ func (s *Server) adminPlaceNote(w http.ResponseWriter, r *http.Request) {
 	}
 	// 备注管理页的行内表单带 next，保存后回到原处（保留筛选）；
 	// 没有 next 时按 Referer 判断，都没有就回后台首页。
-	if next := r.PostFormValue("next"); strings.HasPrefix(next, "/") {
+	if next := safeInternalPath(r.PostFormValue("next")); next != "" {
 		sep := "?"
 		if strings.Contains(next, "?") {
 			sep = "&"
@@ -1000,13 +1125,31 @@ func (s *Server) login2FA(w http.ResponseWriter, r *http.Request) {
 		fail("两步验证状态异常，请重新登录")
 		return
 	}
+	// 两步验证也要限速：中间令牌有 5 分钟有效期，不限速的话 6 位码在窗口内
+	// 足够被打穿。键带前缀，与「口令那一环」分开计数。
+	guardKey := "2fa:" + u.Username
+	if wait := s.loginGuard.RetryAfter(guardKey); wait > 0 {
+		fail(tooManyTries(wait))
+		return
+	}
 	if !auth.VerifyTOTP(secret, code) {
+		if wait := s.loginGuard.Fail(guardKey); wait > 0 {
+			fail(tooManyTries(wait))
+			return
+		}
 		fail("验证码不正确")
 		return
 	}
-	s.login(w, u.ID, u.Hash)
+	// 同一个码在有效窗口内只用一次，否则被偷看的码可以再换一个会话。
+	// 这一条不计入爆破计数：用户手抖重复提交也会撞上，不该因此被越锁越久。
+	if !s.totpReplay.Consume(u.ID, code) {
+		fail("这个验证码刚用过，请等下一个")
+		return
+	}
+	s.loginGuard.Succeed(guardKey)
+	s.login(w, r, u.ID, u.Hash)
 	target := "/admin"
-	if strings.HasPrefix(next, "/admin") {
+	if next = safeInternalPath(next); strings.HasPrefix(next, "/admin") {
 		target = next
 	}
 	http.Redirect(w, r, target, http.StatusSeeOther)
@@ -1174,15 +1317,22 @@ func (s *Server) adminGpxUpload(w http.ResponseWriter, r *http.Request) {
 }
 
 func (s *Server) adminGpxDelete(w http.ResponseWriter, r *http.Request) {
+	u := userFrom(r.Context())
 	id, err := strconv.ParseInt(r.PostFormValue("id"), 10, 64)
 	if err != nil {
 		s.adminFlash(w, r, "err", "轨迹编号无效")
 		return
 	}
-	if _, err := s.db.ExecContext(r.Context(), `DELETE FROM gpx_tracks WHERE id=$1`, id); err != nil {
+	// 带上 user_id：这个 id 是客户端传来的，只按 id 删就能删掉别人的轨迹。
+	res, err := s.db.ExecContext(r.Context(), `DELETE FROM gpx_tracks WHERE id=$1 AND user_id=$2`, id, u.ID)
+	if err != nil {
 		s.serverError(w, r, err)
 		return
 	}
+	if n, _ := res.RowsAffected(); n == 0 {
+		s.adminFlash(w, r, "err", "轨迹不存在")
+		return
+	}
 	s.adminFlash(w, r, "ok", "轨迹已删除")
 }
 

internal/web/handlers_edit.go

@@ -8,11 +8,14 @@ import (
 	"log"
 	"math"
 	"net/http"
+	"sort"
 	"strconv"
 	"strings"
 	"time"
 
 	"rond-with-you/internal/geo"
+	"rond-with-you/internal/rond"
+	"rond-with-you/internal/stats"
 )
 
 // ---------- 数据编辑：手动补录没带手机时的记录点，改完可导出回 rondbackup ----------
@@ -28,7 +31,6 @@ func (s *Server) editPage(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 	p.HasMap = true
-	p.Flatpickr = true
 	q := r.URL.Query()
 	d := EditData{Page: p, Query: strings.TrimSpace(q.Get("q")), SourceCounts: map[string]int{}}
 	d.VisitQuery = strings.TrimSpace(q.Get("vq"))
@@ -66,6 +68,13 @@ func (s *Server) editPage(w http.ResponseWriter, r *http.Request) {
 	} else {
 		d.CanExport = true
 	}
+	// 重复到访（站点侧的历史副本）以基线为参照，见 edit_duplicates.go。
+	// 这里只读基线库与站点数据，不改任何东西；判定不了时 d.DupUnavailable 非空。
+	if pairs, unavailable, err := s.detectDuplicateVisits(ctx, ds.ID); err != nil {
+		log.Printf("检测重复到访失败（数据集 %d）: %v", ds.ID, err)
+	} else {
+		d.DupVisits, d.DupUnavailable = pairs, unavailable
+	}
 
 	// 活动类型与标签
 	if d.Activities, err = s.editOptions(ctx, `SELECT a.id, COALESCE(a.name,'')
@@ -133,6 +142,8 @@ func (s *Server) editPage(w http.ResponseWriter, r *http.Request) {
 	}
 	// 已有类别去重：新建表单、每行编辑的下拉、顶部类别台账都用它（提交值仍是原始标识符）；
 	// 顺手带上地点数，台账要按用量排序、也要知道改一下会影响多少行
+	catNames := s.categoryLabels(ctx)
+	d.KnownCategories = knownCategoryNames()
 	crows, err := s.db.QueryContext(ctx, `SELECT poi_category, count(*) FROM places
 		WHERE dataset_id=$1 AND COALESCE(poi_category,'')<>'' GROUP BY 1 ORDER BY 1`, ds.ID)
 	if err != nil {
@@ -147,8 +158,13 @@ func (s *Server) editPage(w http.ResponseWriter, r *http.Request) {
 			s.serverError(w, r, err)
 			return
 		}
-		d.Categories = append(d.Categories, EditOption{Label: c, Name: poiCategoryLabel(c)})
+		d.Categories = append(d.Categories, EditOption{Label: c, Name: categoryLabel(c, catNames)})
-		d.CategoryRows = append(d.CategoryRows, EditCategory{Value: c, Label: poiCategoryLabel(c), Places: n})
+		// Missing 是「还得你补一个中文名」：自己是枚举、内置表没有**且**你也没填过。
+		// 只看内置表会把已经填好的又标成「还没有中文名」（2026-09-20 用户就这么撞上了）。
+		d.CategoryRows = append(d.CategoryRows, EditCategory{
+			Value: c, Label: categoryLabel(c, catNames), Places: n,
+			Custom: catNames[c] != "", Missing: categoryLabelMissing(c) && catNames[c] == "",
+		})
 	}
 	crows.Close()
 
@@ -176,7 +192,7 @@ func (s *Server) editPage(w http.ResponseWriter, r *http.Request) {
 		COALESCE(p.province,''), COALESCE(p.city,''), COALESCE(p.district,''), COALESCE(p.thoroughfare,''),
 		COALESCE(p.lat,0), COALESCE(p.lon,0), COALESCE(p.visit_count,0),
 		CASE WHEN `+suspectWGS+` THEN TRUE ELSE FALSE END,
-		((r.raw->>'ZLATITUDE'))::float8, ((r.raw->>'ZLONGITUDE'))::float8,
+		`+rond.RawFloat8(`r.raw->>'ZLATITUDE'`)+`, `+rond.RawFloat8(`r.raw->>'ZLONGITUDE'`)+`,
 		COALESCE(p.coord_source,''), COALESCE(p.coord_sys,''), p.src_lat, p.src_lon,
 		COALESCE((SELECT string_agg(x.n || ' ' || x.c, ' · ' ORDER BY x.c DESC, x.n) FROM (
 			SELECT COALESCE(a.name,'（无）') AS n, count(*) AS c FROM visits v
@@ -203,7 +219,7 @@ func (s *Server) editPage(w http.ResponseWriter, r *http.Request) {
 		if e.OrigLat.Valid && e.OrigLon.Valid {
 			e.MovedM = int(geo.Haversine(e.OrigLat.Float64, e.OrigLon.Float64, e.Lat, e.Lon)*1000 + 0.5)
 		}
-		e.CategoryOptions = categoryOptions(d.Categories, e.Category)
+		e.CategoryOptions = categoryOptions(d.Categories, e.Category, catNames)
 		d.Places = append(d.Places, e)
 	}
 	lrows.Close()
@@ -266,8 +282,13 @@ func (s *Server) editPage(w http.ResponseWriter, r *http.Request) {
 	vargs = append(vargs, editPerPage, (d.VisitPageNo-1)*editPerPage)
 	vrows, err := s.db.QueryContext(ctx, `SELECT v.src_pk, COALESCE(p.name,''), COALESCE(p.city,''),
 		COALESCE(a.name,''), COALESCE(a.id,0), v.arrival, v.departure, COALESCE(v.remark,''), COALESCE(v.emoji,''),
-		v.bookmarked, v.is_user_added
+		v.bookmarked, v.is_user_added,
+		-- 真机里「不独立成立」的那两种行（别处已并入 / 只是某个父段的一部分）：访客侧不显示它们，
+		-- 这一页要看得到全部原始行，所以只打标、不过滤（口径见 stats.SoloVisitSQL）
+		CASE WHEN er.raw->>'ZMERGEDTO' IS NOT NULL THEN '已并入 #'||(er.raw->>'ZMERGEDTO')
+		     WHEN er.raw->>'ZPARENT' IS NOT NULL THEN '子段 #'||(er.raw->>'ZPARENT') ELSE '' END
 		FROM visits v LEFT JOIN places p ON p.id=v.place_id LEFT JOIN activities a ON a.id=v.activity_id
+		LEFT JOIN entity_raw er ON er.dataset_id=v.dataset_id AND er.entity='ZVISIT' AND er.src_pk=v.src_pk
 		WHERE `+vwhere+fmt.Sprintf(` ORDER BY v.arrival DESC LIMIT $%d OFFSET $%d`, len(vargs)-1, len(vargs)),
 		vargs...)
 	if err != nil {
@@ -278,7 +299,7 @@ func (s *Server) editPage(w http.ResponseWriter, r *http.Request) {
 		var e EditVisit
 		var dep sql.NullTime
 		if err := vrows.Scan(&e.SrcPK, &e.PlaceName, &e.City, &e.ActivityName, &e.ActivityID,
-			&e.Arrival, &dep, &e.Remark, &e.Emoji, &e.Bookmarked, &e.UserAdded); err != nil {
+			&e.Arrival, &dep, &e.Remark, &e.Emoji, &e.Bookmarked, &e.UserAdded, &e.Hidden); err != nil {
 			vrows.Close()
 			s.serverError(w, r, err)
 			return
@@ -437,7 +458,7 @@ func (s *Server) editPage(w http.ResponseWriter, r *http.Request) {
 
 // categoryOptions 组出某一行的类别下拉：库里的已有类别，当前值不在其中时补进列表，
 // 否则真机里那些非常见类别会被静默改掉或显示为空。
-func categoryOptions(all []EditOption, cur string) []EditOption {
+func categoryOptions(all []EditOption, cur string, custom map[string]string) []EditOption {
 	cur = strings.TrimSpace(cur)
 	out := make([]EditOption, 0, len(all)+1)
 	found := false
@@ -448,7 +469,7 @@ func categoryOptions(all []EditOption, cur string) []EditOption {
 		out = append(out, c)
 	}
 	if cur != "" && !found {
-		out = append(out, EditOption{Label: cur, Name: poiCategoryLabel(cur)})
+		out = append(out, EditOption{Label: cur, Name: categoryLabel(cur, custom)})
 	}
 	return out
 }
@@ -471,42 +492,59 @@ const activityNewValue = "__new__"
 
 // poiCategoryText 把 rond/MapKit 的 POI 分类标识符换成中文。
 // 库里存的原值是 MKPOICategoryXxx（rond 靠它显示图标），表单里给人看中文。
+// poiCategoryText 是类别值 → 中文名 的**内置默认**对照，站点可以用 category_labels 覆盖它。
+// MapKit 只认 MKPOICategory<名字> 这种枚举串，中文名纯粹是站内显示用的。
+//
+// 这里原来是两张表（view.go 的 poiNames 给补全页静态项和 GPX，这张给编辑页），
+// 两边还对不上：FoodMarket 一处「菜市场」一处「食品市场」、Cafe 一处「咖啡馆」一处「咖啡厅」、
+// FitnessCenter 一处「健身房」一处「健身中心」，ATM / Atm 大小写也各写各的。
+// 2026-09-20 合成这一张（冲突处取编辑页那套），并删掉永远匹配不上的 MKPOICategoryMarina2。
 var poiCategoryText = map[string]string{
-	"MKPOICategoryRestaurant":      "餐厅",
+	"MKPOICategoryATM":             "取款机",
-	"MKPOICategoryStore":           "商店",
+	"MKPOICategoryAirport":         "机场",
-	"MKPOICategoryPublicTransport": "公共交通",
+	"MKPOICategoryAmusementPark":   "游乐园",
+	"MKPOICategoryAquarium":        "水族馆",
+	"MKPOICategoryAtm":             "取款机",
+	"MKPOICategoryBakery":          "面包店",
+	"MKPOICategoryBank":            "银行",
+	"MKPOICategoryBar":             "酒吧",
+	"MKPOICategoryBeach":           "海滩",
+	"MKPOICategoryCafe":            "咖啡馆",
+	"MKPOICategoryCampground":      "露营地",
+	"MKPOICategoryCarRental":       "租车",
+	"MKPOICategoryCinema":          "电影院",
+	"MKPOICategoryFireStation":     "消防站",
+	"MKPOICategoryFitnessCenter":   "健身房",
+	"MKPOICategoryFoodMarket":      "菜市场",
+	"MKPOICategoryGasStation":      "加油站",
+	"MKPOICategoryHospital":        "医院",
 	"MKPOICategoryHotel":           "酒店",
 	"MKPOICategoryLandmark":        "地标",
-	"MKPOICategoryFoodMarket":      "菜市场",
-	"MKPOICategoryBeach":           "海滩",
-	"MKPOICategoryCampground":      "露营地",
-	"MKPOICategoryZoo":             "动物园",
-	"MKPOICategoryMuseum":          "博物馆",
-	"MKPOICategoryStadium":         "体育场",
-	"MKPOICategoryPark":            "公园",
-	"MKPOICategoryCafe":            "咖啡馆",
-	"MKPOICategoryBar":             "酒吧",
-	"MKPOICategoryBakery":          "面包店",
-	"MKPOICategorySchool":          "学校",
-	"MKPOICategoryHospital":        "医院",
-	"MKPOICategoryPharmacy":        "药店",
-	"MKPOICategoryBank":            "银行",
-	"MKPOICategoryATM":             "取款机",
-	"MKPOICategoryGasStation":      "加油站",
-	"MKPOICategoryParking":         "停车场",
-	"MKPOICategoryAirport":         "机场",
-	"MKPOICategoryTrainStation":    "火车站",
-	"MKPOICategoryMarina":          "码头",
-	"MKPOICategoryNationalPark":    "国家公园",
-	"MKPOICategoryTheater":         "剧院",
-	"MKPOICategoryCinema":          "电影院",
 	"MKPOICategoryLibrary":         "图书馆",
-	"MKPOICategoryFitnessCenter":   "健身房",
+	"MKPOICategoryMarina":          "码头",
-	"MKPOICategoryAmusementPark":   "游乐园",
+	"MKPOICategoryMovieTheater":    "电影院",
+	"MKPOICategoryMuseum":          "博物馆",
+	"MKPOICategoryNationalPark":    "国家公园",
 	"MKPOICategoryNightlife":       "夜生活",
+	"MKPOICategoryPark":            "公园",
+	"MKPOICategoryParking":         "停车场",
+	"MKPOICategoryPharmacy":        "药店",
+	"MKPOICategoryPolice":          "派出所",
+	"MKPOICategoryPostOffice":      "邮局",
+	"MKPOICategoryPublicTransport": "公共交通",
+	"MKPOICategoryRestaurant":      "餐厅",
 	"MKPOICategoryRestroom":        "洗手间",
+	"MKPOICategorySchool":          "学校",
+	"MKPOICategorySpa":             "水疗",
+	"MKPOICategoryStadium":         "体育场",
+	"MKPOICategoryStore":           "商店",
+	"MKPOICategoryTheater":         "剧院",
+	"MKPOICategoryTrainStation":    "火车站",
+	"MKPOICategoryUniversity":      "大学",
+	"MKPOICategoryZoo":             "动物园",
 }
 
+// poiCategoryLabel 是内置默认名（不含站点覆盖）。
 func poiCategoryLabel(v string) string {
 	if l, ok := poiCategoryText[v]; ok {
 		return l
@@ -514,6 +552,56 @@ func poiCategoryLabel(v string) string {
 	return strings.TrimPrefix(v, "MKPOICategory")
 }
 
+// categoryLabel 取类别的显示名：站点自定义的优先，其次内置默认，都没有就退回去掉前缀的原值。
+// 只影响显示——导出到 rond 用的是 places.poi_category 本身，显示名不会被写回去。
+func categoryLabel(v string, custom map[string]string) string {
+	if l, ok := custom[v]; ok && l != "" {
+		return l
+	}
+	return poiCategoryLabel(v)
+}
+
+// categoryLabelMissing 判断这个值是不是「还没有中文名」：是 MapKit 枚举但内置表里没有，
+// 显示出来只会是 Foo 这种半截英文，该由站长补一个。中文值（站内自己写的）自带名字，不算缺。
+func categoryLabelMissing(v string) bool {
+	if !strings.HasPrefix(v, "MKPOICategory") {
+		return false
+	}
+	_, ok := poiCategoryText[v]
+	return !ok
+}
+
+// knownCategoryNames 列出内置表认得的枚举名（排序后）。页面改「导出值」时拿它提醒：
+// 真机只认它自己那套枚举，拼错的串站内看不出问题，导回手机后那个地点就显示不出类别了。
+func knownCategoryNames() []string {
+	out := make([]string, 0, len(poiCategoryText))
+	for k := range poiCategoryText {
+		out = append(out, k)
+	}
+	sort.Strings(out)
+	return out
+}
+
+// categoryLabels 读站点自定义的类别显示名。读不到就是空 map，各处自动退回内置名。
+func (s *Server) categoryLabels(ctx context.Context) map[string]string {
+	out := map[string]string{}
+	rows, err := s.db.QueryContext(ctx, `SELECT value, label FROM category_labels`)
+	if err != nil {
+		log.Printf("读类别显示名失败: %v", err)
+		return out
+	}
+	defer rows.Close()
+	for rows.Next() {
+		var v, l string
+		if err := rows.Scan(&v, &l); err != nil {
+			log.Printf("读类别显示名失败: %v", err)
+			return out
+		}
+		out[v] = l
+	}
+	return out
+}
+
 // placeDesc 把省市区拼成一段（相邻重复段只留一个，直辖市省名=市名时不会出现
 // 「北京市北京市」这种），街道有值再接上。
 func placeDesc(city, province, area, thoroughfare string) string {
@@ -556,8 +644,10 @@ func (s *Server) editOptions(ctx context.Context, query string, args ...any) ([]
 // 就会复用同一个 src_pk，于是新行继承旧留档的 rond 私有字段（ZRADIUS/ZRAW 等）。
 // skipped=TRUE 的行必须保留——它们本来就是「因缺必填字段没进库、导出时要补回」的行。
 // 清理失败只记日志：留档是保真度增强，不该阻断用户的删除操作。
-func (s *Server) pruneEntityRaw(ctx context.Context, datasetID int64) {
+// 收 ex（*sql.DB 或事务）是为了让调用方把它和「删实体」放进同一个事务——
-	if _, err := s.db.ExecContext(ctx, `DELETE FROM entity_raw r
+// 分两次提交的话，中间失败会留下「实体没了、留档还在」的错位。
+func (s *Server) pruneEntityRaw(ctx context.Context, ex execer, datasetID int64) {
+	if _, err := ex.ExecContext(ctx, `DELETE FROM entity_raw r
 		WHERE r.dataset_id=$1 AND NOT r.skipped AND (
 		     (r.entity='ZLOCATION'      AND NOT EXISTS (SELECT 1 FROM places p     WHERE p.dataset_id=r.dataset_id AND p.src_pk=r.src_pk))
 		  OR (r.entity='ZVISIT'         AND NOT EXISTS (SELECT 1 FROM visits v     WHERE v.dataset_id=r.dataset_id AND v.src_pk=r.src_pk))
@@ -620,23 +710,38 @@ func (s *Server) editActivityDelete(w http.ResponseWriter, r *http.Request) {
 		s.json(w, map[string]any{"error": "请选择要删除的活动"})
 		return
 	}
-	// is_home / is_work 是从活动上抄到到访的冗余标记，活动没了就该一起清掉
+	// 先确认活动存在再动手，整组写进一个事务：清到访标记与删活动分开提交的话，
-	if _, err := s.db.ExecContext(ctx, `UPDATE visits SET activity_id=NULL, is_home=FALSE, is_work=FALSE
+	// 中间失败会留下「到访的活动被摘掉了、活动还在」的半截状态。
-		WHERE dataset_id=$1 AND activity_id=$2`, ds.ID, id); err != nil {
+	notFound := false
+	if err := s.withTx(ctx, func(ex execer) error {
+		var exists bool
+		if err := ex.QueryRowContext(ctx, `SELECT true FROM activities WHERE id=$1 AND dataset_id=$2`,
+			id, ds.ID).Scan(&exists); err != nil {
+			if errors.Is(err, sql.ErrNoRows) {
+				notFound = true
+				return nil
+			}
+			return err
+		}
+		// is_home / is_work 是从活动上抄到到访的冗余标记，活动没了就该一起清掉
+		if _, err := ex.ExecContext(ctx, `UPDATE visits SET activity_id=NULL, is_home=FALSE, is_work=FALSE
+			WHERE dataset_id=$1 AND activity_id=$2`, ds.ID, id); err != nil {
+			return err
+		}
+		if _, err := ex.ExecContext(ctx, `DELETE FROM activities WHERE id=$1 AND dataset_id=$2`, id, ds.ID); err != nil {
+			return err
+		}
+		s.pruneEntityRaw(ctx, ex, ds.ID)
+		return nil
+	}); err != nil {
 		s.serverError(w, r, err)
 		return
 	}
-	res, err := s.db.ExecContext(ctx, `DELETE FROM activities WHERE id=$1 AND dataset_id=$2`, id, ds.ID)
+	if notFound {
-	if err != nil {
-		s.serverError(w, r, err)
-		return
-	}
-	if n, _ := res.RowsAffected(); n == 0 {
 		s.json(w, map[string]any{"error": "活动不存在"})
 		return
 	}
-	s.pruneEntityRaw(ctx, ds.ID)
+	logAggFailure("数据集计数", s.refreshDatasetAgg(ctx, s.db, ds.ID))
-	s.refreshDatasetAgg(ctx, ds.ID)
 	s.json(w, map[string]any{"ok": true})
 }
 
@@ -670,7 +775,7 @@ func (s *Server) editCategoryRename(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 	n, _ := res.RowsAffected()
-	s.json(w, map[string]any{"ok": true, "places": n, "to": to, "label": poiCategoryLabel(to)})
+	s.json(w, map[string]any{"ok": true, "places": n, "to": to, "label": categoryLabel(to, s.categoryLabels(ctx))})
 }
 
 // editCategoryClear 把某个类别从所有地点上摘掉（那些地点退回「未指定」）。
@@ -732,7 +837,10 @@ func (s *Server) editActivityMerge(w http.ResponseWriter, r *http.Request) {
 			return errors.New("活动不存在")
 		}
 		// is_home / is_work 是从活动抄到到访上的冗余标记，跟着目标活动走
-		isHome, isWork := s.activityFlags(ctx, ex, to)
+		isHome, isWork, err := s.activityFlags(ctx, ex, to)
+		if err != nil {
+			return err
+		}
 		res, err := ex.ExecContext(ctx, `UPDATE visits SET activity_id=$3, is_home=$4, is_work=$5
 			WHERE dataset_id=$1 AND activity_id=$2`, ds.ID, from, to, isHome, isWork)
 		if err != nil {
@@ -745,11 +853,42 @@ func (s *Server) editActivityMerge(w http.ResponseWriter, r *http.Request) {
 		s.json(w, map[string]any{"error": err.Error()})
 		return
 	}
-	s.pruneEntityRaw(ctx, ds.ID)
+	s.pruneEntityRaw(ctx, s.db, ds.ID)
-	s.refreshDatasetAgg(ctx, ds.ID)
+	logAggFailure("数据集计数", s.refreshDatasetAgg(ctx, s.db, ds.ID))
 	s.json(w, map[string]any{"ok": true, "visits": moved})
 }
 
+// editCategoryLabel 改类别在站内的**显示名**。跟改名/清空是两回事：
+// 这里只动 category_labels，绝不碰 places.poi_category——显示名不会被导出写回手机。
+// 传空表示恢复内置默认名。
+func (s *Server) editCategoryLabel(w http.ResponseWriter, r *http.Request) {
+	ctx := r.Context()
+	if err := r.ParseForm(); err != nil {
+		s.serverError(w, r, err)
+		return
+	}
+	value := strings.TrimSpace(r.PostFormValue("value"))
+	label := strings.TrimSpace(r.PostFormValue("label"))
+	if value == "" {
+		s.json(w, map[string]any{"error": "请指定要改名的类别值"})
+		return
+	}
+	if label == "" {
+		if _, err := s.db.ExecContext(ctx, `DELETE FROM category_labels WHERE value=$1`, value); err != nil {
+			s.serverError(w, r, err)
+			return
+		}
+		s.json(w, map[string]any{"ok": true, "value": value, "label": poiCategoryLabel(value), "custom": false})
+		return
+	}
+	if _, err := s.db.ExecContext(ctx, `INSERT INTO category_labels (value, label) VALUES ($1,$2)
+		ON CONFLICT (value) DO UPDATE SET label=EXCLUDED.label, updated_at=now()`, value, label); err != nil {
+		s.serverError(w, r, err)
+		return
+	}
+	s.json(w, map[string]any{"ok": true, "value": value, "label": label, "custom": true})
+}
+
 // editPlaceCreate 是最前面那个融合表单（新建地点 / 给已有地点补到访）的处理函数。
 func (s *Server) editPlaceCreate(w http.ResponseWriter, r *http.Request) {
 	ctx := r.Context()
@@ -813,7 +952,7 @@ func (s *Server) editPlaceCreate(w http.ResponseWriter, r *http.Request) {
 			s.serverError(w, r, err)
 			return
 		}
-		s.refreshDatasetAgg(ctx, ds.ID)
+		logAggFailure("数据集计数", s.refreshDatasetAgg(ctx, s.db, ds.ID))
 		redirectEdit(w, r, "ok", "已为所选地点新增到访")
 		return
 	}
@@ -869,7 +1008,7 @@ func (s *Server) editPlaceCreate(w http.ResponseWriter, r *http.Request) {
 		s.serverError(w, r, err)
 		return
 	}
-	s.refreshDatasetAgg(ctx, ds.ID)
+	logAggFailure("数据集计数", s.refreshDatasetAgg(ctx, s.db, ds.ID))
 	if hasVisit {
 		redirectEdit(w, r, "ok", fmt.Sprintf("已新增地点（src_pk=%d）及到访（src_pk=%d）", nextSrc, visitSrc))
 	} else {
@@ -971,7 +1110,7 @@ func (s *Server) editPlaceUpdate(w http.ResponseWriter, r *http.Request) {
 	}
 	// 活动的分面计数、「最近活跃」都跟着到访走，改完刷新一次
 	if actID != nil {
-		s.refreshDatasetAgg(ctx, ds.ID)
+		logAggFailure("数据集计数", s.refreshDatasetAgg(ctx, s.db, ds.ID))
 	}
 
 	msg := "地点已更新"
@@ -1122,27 +1261,31 @@ func (s *Server) editPlaceDelete(w http.ResponseWriter, r *http.Request) {
 		redirectEdit(w, r, "err", "地点标识无效")
 		return
 	}
-	// 该地点名下到访的 src_pk 集合（删地点会级联删掉这些到访）
+	// 三条写语句必须同一个事务：删到一半失败会留下「地点还在、它的行程没了」，
+	// 或者更糟——地点没了但行程还指着已经不存在的到访（rond 里的悬空引用就是这么来的）。
 	const visitSrcs = `SELECT src_pk FROM visits WHERE dataset_id=$1
 		AND place_id=(SELECT id FROM places WHERE dataset_id=$1 AND src_pk=$2)`
-	// 行程以两端到访为锚点：端点没了还留着就是悬空引用，rond 里会指向不存在的到访
+	if err := s.withTx(ctx, func(ex execer) error {
-	if _, err := s.db.ExecContext(ctx, `DELETE FROM movements WHERE dataset_id=$1
+		// 行程以两端到访为锚点：端点没了还留着就是悬空引用，rond 里会指向不存在的到访
-		AND (from_visit_src IN (`+visitSrcs+`) OR to_visit_src IN (`+visitSrcs+`))`, ds.ID, src); err != nil {
+		if _, err := ex.ExecContext(ctx, `DELETE FROM movements WHERE dataset_id=$1
+			AND (from_visit_src IN (`+visitSrcs+`) OR to_visit_src IN (`+visitSrcs+`))`, ds.ID, src); err != nil {
+			return err
+		}
+		// 天气本身有独立价值，只解除关联，不连坐删除
+		if _, err := ex.ExecContext(ctx, `UPDATE weather SET visit_src=NULL
+			WHERE dataset_id=$1 AND visit_src IN (`+visitSrcs+`)`, ds.ID, src); err != nil {
+			return err
+		}
+		if _, err := ex.ExecContext(ctx, `DELETE FROM places WHERE dataset_id=$1 AND src_pk=$2`, ds.ID, src); err != nil {
+			return err
+		}
+		s.pruneEntityRaw(ctx, ex, ds.ID)
+		return nil
+	}); err != nil {
 		s.serverError(w, r, err)
 		return
 	}
-	// 天气本身有独立价值，只解除关联，不连坐删除
+	logAggFailure("数据集计数", s.refreshDatasetAgg(ctx, s.db, ds.ID))
-	if _, err := s.db.ExecContext(ctx, `UPDATE weather SET visit_src=NULL
-		WHERE dataset_id=$1 AND visit_src IN (`+visitSrcs+`)`, ds.ID, src); err != nil {
-		s.serverError(w, r, err)
-		return
-	}
-	if _, err := s.db.ExecContext(ctx, `DELETE FROM places WHERE dataset_id=$1 AND src_pk=$2`, ds.ID, src); err != nil {
-		s.serverError(w, r, err)
-		return
-	}
-	s.pruneEntityRaw(ctx, ds.ID)
-	s.refreshDatasetAgg(ctx, ds.ID)
 	redirectEdit(w, r, "ok", "地点及其到访、关联行程已删除")
 }
 
@@ -1183,7 +1326,7 @@ func (s *Server) editActivityCreate(w http.ResponseWriter, r *http.Request) {
 		s.serverError(w, r, err)
 		return
 	}
-	s.refreshDatasetAgg(ctx, ds.ID)
+	logAggFailure("数据集计数", s.refreshDatasetAgg(ctx, s.db, ds.ID))
 	s.json(w, map[string]any{"id": id, "name": name})
 }
 
@@ -1210,38 +1353,55 @@ func (s *Server) editVisitUpdate(w http.ResponseWriter, r *http.Request) {
 	}
 	actID, isHome, isWork := s.resolveActivity(ctx, ds.ID, r.PostFormValue("activity_id"))
 	var oldPlace int64
-	var curArrival time.Time
+	notFound := false
-	var curDeparture sql.NullTime
+	// 改到访、夹回引用它的行程、重写标签、刷聚合必须同一个事务：夹行程那步失败会留下
-	if err := s.db.QueryRowContext(ctx, `SELECT COALESCE(place_id,0), arrival, departure FROM visits
+	// 「到访时间已越界、行程还挂在旧窗口上」的坏数据，导出到 rond 里就是非法区间。
-		WHERE dataset_id=$1 AND src_pk=$2`, ds.ID, src).Scan(&oldPlace, &curArrival, &curDeparture); err != nil {
+	if err := s.withTx(ctx, func(ex execer) error {
+		var curArrival time.Time
+		var curDeparture sql.NullTime
+		if err := ex.QueryRowContext(ctx, `SELECT COALESCE(place_id,0), arrival, departure FROM visits
+			WHERE dataset_id=$1 AND src_pk=$2`, ds.ID, src).Scan(&oldPlace, &curArrival, &curDeparture); err != nil {
+			if errors.Is(err, sql.ErrNoRows) {
+				notFound = true
+				return nil
+			}
+			return err
+		}
+		// 时间字段是分钟精度：只改类型/备注时不能把真机的小数秒（20:03:21.323）截成整分钟
+		arrival = keepStoredTime(arrival, &curArrival)
+		if departure != nil && curDeparture.Valid {
+			kept := keepStoredTime(*departure, &curDeparture.Time)
+			departure = &kept
+		}
+		if _, err := ex.ExecContext(ctx, `UPDATE visits SET activity_id=$3, arrival=$4, departure=$5, duration_min=$6,
+			is_home=$7, is_work=$8, bookmarked=$9, remark=NULLIF($10,''), emoji=NULLIF($11,'')
+			WHERE dataset_id=$1 AND src_pk=$2`,
+			ds.ID, src, actID, arrival, departure, durationMin(arrival, departure), isHome, isWork,
+			r.PostFormValue("bookmarked") == "on",
+			strings.TrimSpace(r.PostFormValue("remark")), strings.TrimSpace(r.PostFormValue("emoji"))); err != nil {
+			return err
+		}
+		// 时间改动可能让引用这条到访的行程越界，就地夹回去（见 clampVisitMovements）
+		if err := s.clampVisitMovements(ctx, ex, ds.ID, src); err != nil {
+			return err
+		}
+		if err := s.saveVisitTags(ctx, ex, ds.ID, src, r.PostForm["tags"]); err != nil {
+			return err
+		}
+		if oldPlace > 0 {
+			if err := s.refreshPlaceAgg(ctx, ex, oldPlace); err != nil {
+				return err
+			}
+		}
+		return s.refreshDatasetAgg(ctx, ex, ds.ID)
+	}); err != nil {
+		s.serverError(w, r, err)
+		return
+	}
+	if notFound {
 		redirectEdit(w, r, "err", "到访记录不存在")
 		return
 	}
-	// 时间字段是分钟精度：只改类型/备注时不能把真机的小数秒（20:03:21.323）截成整分钟
-	arrival = keepStoredTime(arrival, &curArrival)
-	if departure != nil && curDeparture.Valid {
-		kept := keepStoredTime(*departure, &curDeparture.Time)
-		departure = &kept
-	}
-	if _, err := s.db.ExecContext(ctx, `UPDATE visits SET activity_id=$3, arrival=$4, departure=$5, duration_min=$6,
-		is_home=$7, is_work=$8, bookmarked=$9, remark=NULLIF($10,''), emoji=NULLIF($11,'')
-		WHERE dataset_id=$1 AND src_pk=$2`,
-		ds.ID, src, actID, arrival, departure, durationMin(arrival, departure), isHome, isWork,
-		r.PostFormValue("bookmarked") == "on",
-		strings.TrimSpace(r.PostFormValue("remark")), strings.TrimSpace(r.PostFormValue("emoji"))); err != nil {
-		s.serverError(w, r, err)
-		return
-	}
-	// 时间改动可能让引用这条到访的行程越界，就地夹回去（见 clampVisitMovements）
-	if err := s.clampVisitMovements(ctx, s.db, ds.ID, src); err != nil {
-		s.serverError(w, r, err)
-		return
-	}
-	s.saveVisitTags(ctx, s.db, ds.ID, src, r.PostForm["tags"])
-	if oldPlace > 0 {
-		s.refreshPlaceAgg(ctx, s.db, oldPlace)
-	}
-	s.refreshDatasetAgg(ctx, ds.ID)
 	redirectEdit(w, r, "ok", "到访已更新")
 }
 
@@ -1263,23 +1423,25 @@ func (s *Server) adminVisitBookmark(w http.ResponseWriter, r *http.Request) {
 		redirectEdit(w, r, "err", "到访标识无效")
 		return
 	}
-	res, err := s.db.ExecContext(ctx, `UPDATE visits SET bookmarked = NOT bookmarked
+	// 一条语句搞定「翻转并回读」：以前是 UPDATE 之后再单独 SELECT，那次回读一旦失败
-		WHERE dataset_id=$1 AND src_pk=$2`, ds.ID, src)
+	// 就落进 else 报「已取消收藏」——而它有一半是错的（状态根本不知道）。
-	if err != nil {
+	// 顺带：翻转与回读在同一条语句里，中间也不再有人插进来的窗口。
+	var on bool
+	if err := s.db.QueryRowContext(ctx, `UPDATE visits SET bookmarked = NOT bookmarked
+		WHERE dataset_id=$1 AND src_pk=$2
+		RETURNING bookmarked`, ds.ID, src).Scan(&on); err != nil {
+		if errors.Is(err, sql.ErrNoRows) {
+			redirectEdit(w, r, "err", "到访记录不存在")
+			return
+		}
 		s.serverError(w, r, err)
 		return
 	}
-	if n, _ := res.RowsAffected(); n == 0 {
+	msg := "已取消收藏"
-		redirectEdit(w, r, "err", "到访记录不存在")
+	if on {
-		return
+		msg = "已标记为收藏"
 	}
-	var on bool
+	redirectEdit(w, r, "ok", msg)
-	if err := s.db.QueryRowContext(ctx, `SELECT bookmarked FROM visits WHERE dataset_id=$1 AND src_pk=$2`,
-		ds.ID, src).Scan(&on); err == nil && on {
-		redirectEdit(w, r, "ok", "已标记为收藏")
-		return
-	}
-	redirectEdit(w, r, "ok", "已取消收藏")
 }
 func (s *Server) editVisitDelete(w http.ResponseWriter, r *http.Request) {
 	ctx := r.Context()
@@ -1298,28 +1460,42 @@ func (s *Server) editVisitDelete(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 	var placeID int64
-	if err := s.db.QueryRowContext(ctx, `SELECT COALESCE(place_id,0) FROM visits WHERE dataset_id=$1 AND src_pk=$2`, ds.ID, src).Scan(&placeID); err != nil {
+	notFound := false
+	// 删行程 / 解天气关联 / 删到访必须同一个事务：中间失败会留下指着不存在到访的悬空行程，
+	// 导出到 rond 里就是 8 组悬空引用那种坏数据。
+	if err := s.withTx(ctx, func(ex execer) error {
+		if err := ex.QueryRowContext(ctx, `SELECT COALESCE(place_id,0) FROM visits WHERE dataset_id=$1 AND src_pk=$2`, ds.ID, src).Scan(&placeID); err != nil {
+			if errors.Is(err, sql.ErrNoRows) {
+				notFound = true
+				return nil
+			}
+			return err
+		}
+		if _, err := ex.ExecContext(ctx, `DELETE FROM movements WHERE dataset_id=$1
+			AND (from_visit_src=$2 OR to_visit_src=$2)`, ds.ID, src); err != nil {
+			return err
+		}
+		if _, err := ex.ExecContext(ctx, `UPDATE weather SET visit_src=NULL WHERE dataset_id=$1 AND visit_src=$2`, ds.ID, src); err != nil {
+			return err
+		}
+		if _, err := ex.ExecContext(ctx, `DELETE FROM visits WHERE dataset_id=$1 AND src_pk=$2`, ds.ID, src); err != nil {
+			return err
+		}
+		s.pruneEntityRaw(ctx, ex, ds.ID)
+		if placeID > 0 {
+			if err := s.refreshPlaceAgg(ctx, ex, placeID); err != nil {
+				return err
+			}
+		}
+		return s.refreshDatasetAgg(ctx, ex, ds.ID)
+	}); err != nil {
+		s.serverError(w, r, err)
+		return
+	}
+	if notFound {
 		redirectEdit(w, r, "err", "到访记录不存在")
 		return
 	}
-	if _, err := s.db.ExecContext(ctx, `DELETE FROM movements WHERE dataset_id=$1
-		AND (from_visit_src=$2 OR to_visit_src=$2)`, ds.ID, src); err != nil {
-		s.serverError(w, r, err)
-		return
-	}
-	if _, err := s.db.ExecContext(ctx, `UPDATE weather SET visit_src=NULL WHERE dataset_id=$1 AND visit_src=$2`, ds.ID, src); err != nil {
-		s.serverError(w, r, err)
-		return
-	}
-	if _, err := s.db.ExecContext(ctx, `DELETE FROM visits WHERE dataset_id=$1 AND src_pk=$2`, ds.ID, src); err != nil {
-		s.serverError(w, r, err)
-		return
-	}
-	s.pruneEntityRaw(ctx, ds.ID)
-	if placeID > 0 {
-		s.refreshPlaceAgg(ctx, s.db, placeID)
-	}
-	s.refreshDatasetAgg(ctx, ds.ID)
 	redirectEdit(w, r, "ok", "到访已删除")
 }
 
@@ -1707,40 +1883,54 @@ func (s *Server) editMovementUpdate(w http.ResponseWriter, r *http.Request) {
 		redirectEdit(w, r, "err", "行程标识无效")
 		return
 	}
-	src, ok, msg := s.validateMovementForm(ctx, s.db, ds.ID, r, pk)
+	var tr movementTransport
-	if !ok {
+	var failMsg string
-		redirectEdit(w, r, "err", msg)
+	done := false
-		return
+	// 校验（读起点/终点到访）与两处写入必须同一事务，否则并发改动会让派生列与两端锚点对不上。
-	}
+	if err := s.withTx(ctx, func(ex execer) error {
-	tr, msg := s.resolveMovementTransport(ctx, s.db, ds.ID,
+		src, ok, msg := s.validateMovementForm(ctx, ex, ds.ID, r, pk)
-		r.PostFormValue("transport_src"), r.PostFormValue("transport_name"),
+		if !ok {
-		r.PostFormValue("transport_color"), r.PostFormValue("transport_icon"))
+			failMsg = msg
-	if msg != "" {
+			return nil
-		redirectEdit(w, r, "err", msg)
+		}
-		return
+		var tmsg string
-	}
+		tr, tmsg = s.resolveMovementTransport(ctx, ex, ds.ID,
-	var trSrc, trName, trColor, trIcon any
+			r.PostFormValue("transport_src"), r.PostFormValue("transport_name"),
-	if tr.Src > 0 {
+			r.PostFormValue("transport_color"), r.PostFormValue("transport_icon"))
-		trSrc, trName, trColor, trIcon = tr.Src, nullStr(tr.Name), nullStr(tr.Color), nullStr(tr.Icon)
+		if tmsg != "" {
-	}
+			failMsg = tmsg
-	res, err := s.db.ExecContext(ctx, `UPDATE movements SET
+			return nil
-		transport_src=$3, transport_name=$4, transport_color=$5, transport_icon=$6,
+		}
-		from_visit_src=$7, to_visit_src=$8, from_place_id=$9, to_place_id=$10,
+		var trSrc, trName, trColor, trIcon any
-		started_at=$11, ended_at=$12, duration_min=$13, distance_km=$14
+		if tr.Src > 0 {
-		WHERE dataset_id=$1 AND src_pk=$2`,
+			trSrc, trName, trColor, trIcon = tr.Src, nullStr(tr.Name), nullStr(tr.Color), nullStr(tr.Icon)
-		ds.ID, pk, trSrc, trName, trColor, trIcon,
+		}
-		src.FromVisit, src.ToVisit, nullInt64(src.FromPlace), nullInt64(src.ToPlace),
+		res, err := ex.ExecContext(ctx, `UPDATE movements SET
-		src.Start, src.End, src.DurationMin, src.DistanceKm)
+			transport_src=$3, transport_name=$4, transport_color=$5, transport_icon=$6,
-	if err != nil {
+			from_visit_src=$7, to_visit_src=$8, from_place_id=$9, to_place_id=$10,
+			started_at=$11, ended_at=$12, duration_min=$13, distance_km=$14
+			WHERE dataset_id=$1 AND src_pk=$2`,
+			ds.ID, pk, trSrc, trName, trColor, trIcon,
+			src.FromVisit, src.ToVisit, nullInt64(src.FromPlace), nullInt64(src.ToPlace),
+			src.Start, src.End, src.DurationMin, src.DistanceKm)
+		if err != nil {
+			return err
+		}
+		if n, _ := res.RowsAffected(); n == 0 {
+			failMsg = "行程不存在"
+			return nil
+		}
+		if err := syncTransport(ctx, ex, ds.ID, tr); err != nil {
+			return err
+		}
+		done = true
+		return nil
+	}); err != nil {
 		s.serverError(w, r, err)
 		return
 	}
-	if n, _ := res.RowsAffected(); n == 0 {
+	if !done {
-		redirectEdit(w, r, "err", "行程不存在")
+		redirectEdit(w, r, "err", failMsg)
-		return
-	}
-	if err := syncTransport(ctx, s.db, ds.ID, tr); err != nil {
-		s.serverError(w, r, err)
 		return
 	}
 	redirectEdit(w, r, "ok", "行程已更新")
@@ -1764,16 +1954,28 @@ func (s *Server) editMovementDelete(w http.ResponseWriter, r *http.Request) {
 		redirectEdit(w, r, "err", "行程标识无效")
 		return
 	}
-	res, err := s.db.ExecContext(ctx, `DELETE FROM movements WHERE dataset_id=$1 AND src_pk=$2`, ds.ID, pk)
+	notFound := false
-	if err != nil {
+	// 删行程与清留档必须同一事务：删除成功但清留档失败会留下「号已空、留档还在」的酸数据，
+	// 下一次新建复用该 src_pk 时会继承这条的 rond 私有字段。
+	if err := s.withTx(ctx, func(ex execer) error {
+		res, err := ex.ExecContext(ctx, `DELETE FROM movements WHERE dataset_id=$1 AND src_pk=$2`, ds.ID, pk)
+		if err != nil {
+			return err
+		}
+		if n, _ := res.RowsAffected(); n == 0 {
+			notFound = true
+			return nil
+		}
+		s.pruneEntityRaw(ctx, ex, ds.ID)
+		return nil
+	}); err != nil {
 		s.serverError(w, r, err)
 		return
 	}
-	if n, _ := res.RowsAffected(); n == 0 {
+	if notFound {
 		redirectEdit(w, r, "err", "行程不存在")
 		return
 	}
-	s.pruneEntityRaw(ctx, ds.ID)
 	redirectEdit(w, r, "ok", "行程已删除")
 }
 
@@ -2032,43 +2234,63 @@ func (s *Server) insertVisit(ctx context.Context, ex execer, datasetID, userID,
 		bookmarked, remark, emoji); err != nil {
 		return 0, err
 	}
-	s.saveVisitTags(ctx, ex, datasetID, nextSrc, tags)
+	if err := s.saveVisitTags(ctx, ex, datasetID, nextSrc, tags); err != nil {
-	s.refreshPlaceAgg(ctx, ex, placeID)
+		return 0, err
+	}
+	if err := s.refreshPlaceAgg(ctx, ex, placeID); err != nil {
+		return 0, err
+	}
 	return nextSrc, nil
 }
 
 // saveVisitTags 重写到访的标签关联。
-func (s *Server) saveVisitTags(ctx context.Context, ex execer, datasetID int64, visitSrc int, tagIDs []string) {
+func (s *Server) saveVisitTags(ctx context.Context, ex execer, datasetID int64, visitSrc int, tagIDs []string) error {
 	var visitID int64
 	if err := ex.QueryRowContext(ctx, `SELECT id FROM visits WHERE dataset_id=$1 AND src_pk=$2`, datasetID, visitSrc).Scan(&visitID); err != nil {
-		return
+		return fmt.Errorf("查待标标签的到访（src_pk=%d）失败: %w", visitSrc, err)
+	}
+	if _, err := ex.ExecContext(ctx, `DELETE FROM visit_tags WHERE visit_id=$1`, visitID); err != nil {
+		return fmt.Errorf("清到访标签失败: %w", err)
 	}
-	ex.ExecContext(ctx, `DELETE FROM visit_tags WHERE visit_id=$1`, visitID)
 	for _, t := range tagIDs {
 		id, err := strconv.ParseInt(t, 10, 64)
 		if err != nil || id <= 0 {
 			continue
 		}
-		ex.ExecContext(ctx, `INSERT INTO visit_tags (visit_id, tag_id)
+		if _, err := ex.ExecContext(ctx, `INSERT INTO visit_tags (visit_id, tag_id)
-			SELECT $1, t.id FROM tags t WHERE t.id=$2 AND t.dataset_id=$3 ON CONFLICT DO NOTHING`, visitID, id, datasetID)
+			SELECT $1, t.id FROM tags t WHERE t.id=$2 AND t.dataset_id=$3 ON CONFLICT DO NOTHING`, visitID, id, datasetID); err != nil {
+			return fmt.Errorf("写到访标签失败: %w", err)
+		}
 	}
+	return nil
 }
 
 // refreshPlaceAgg 重算某地点的到访聚合（次数 / 停留 / 首末时间）。
-func (s *Server) refreshPlaceAgg(ctx context.Context, ex execer, placeID int64) {
+//
-	ex.ExecContext(ctx, `UPDATE places p SET
+// 次数与停留按**访客口径**算（不含已并入 / 子段，判据见 stats.SoloVisitSQL）——编辑页删掉一条
+// 普通到访后，「地点库」上那个「到访 N 次」要跟时间线对得上。
+// first_visit_at / last_visit_at 保持全量：last_visit_at 会被导出成 ZLOCATION.ZLASTARRIVALDATE_，
+// 这里改口径就等于动导出包（实测数据集 9 有 7 个地点的「最晚到达」是由被并入的行决定的）。
+func (s *Server) refreshPlaceAgg(ctx context.Context, ex execer, placeID int64) error {
+	if _, err := ex.ExecContext(ctx, `UPDATE places p SET
 		visit_count = COALESCE(v.c,0), dwell_minutes = COALESCE(v.d,0),
 		first_visit_at = v.f, last_visit_at = v.l
 		FROM (SELECT $1::bigint AS pid) x
-		LEFT JOIN (SELECT place_id, count(*) c, COALESCE(sum(LEAST(COALESCE(duration_min,0), 10080)),0) d, min(arrival) f, max(arrival) l
+		LEFT JOIN (SELECT vis.place_id,
-			FROM visits WHERE place_id=$1 GROUP BY place_id) v ON v.place_id = x.pid
+			count(*) FILTER (WHERE `+stats.SoloVisitSQL("vis")+`) c,
-		WHERE p.id = x.pid`, placeID)
+			COALESCE(sum(LEAST(COALESCE(vis.duration_min,0), 10080)) FILTER (WHERE `+stats.SoloVisitSQL("vis")+`),0) d,
+			min(vis.arrival) f, max(vis.arrival) l
+			FROM visits vis WHERE vis.place_id=$1 GROUP BY vis.place_id) v ON v.place_id = x.pid
+		WHERE p.id = x.pid`, placeID); err != nil {
+		return fmt.Errorf("重算地点（id=%d）聚合失败: %w", placeID, err)
+	}
+	return nil
 }
 
 // refreshDatasetAgg 重算数据集的到访数 / 地点数 / 时间跨度（页脚「数据截至」与后台 flash 用）。
 // 编辑页增删记录只动业务表，不刷新的话 datasets 上的缓存计数会越漂越远。
-func (s *Server) refreshDatasetAgg(ctx context.Context, datasetID int64) {
+func (s *Server) refreshDatasetAgg(ctx context.Context, ex execer, datasetID int64) error {
-	s.db.ExecContext(ctx, `UPDATE datasets d SET
+	if _, err := ex.ExecContext(ctx, `UPDATE datasets d SET
 		visit_count = COALESCE(v.c,0), first_visit_at = v.f, last_visit_at = v.l,
 		place_count = COALESCE(p.c,0)
 		FROM (SELECT $1::bigint AS did) x
@@ -2076,7 +2298,20 @@ func (s *Server) refreshDatasetAgg(ctx context.Context, datasetID int64) {
 			FROM visits WHERE dataset_id=$1 GROUP BY dataset_id) v ON v.dataset_id = x.did
 		LEFT JOIN (SELECT dataset_id, count(*) c
 			FROM places WHERE dataset_id=$1 GROUP BY dataset_id) p ON p.dataset_id = x.did
-		WHERE d.id = x.did`, datasetID)
+		WHERE d.id = x.did`, datasetID); err != nil {
+		return fmt.Errorf("重算数据集（id=%d）聚合失败: %w", datasetID, err)
+	}
+	return nil
+}
+
+// logAggFailure 专给「写入已经提交」的那几个刷新点用。
+//
+// 这时不能把请求判成失败：数据其实已经落库了，报错会让用户以为没保存、再点一次就多建一条——
+// 比计数滞后严重得多。但也绝不能静默，否则计数会一路漂下去且日志里查不到。
+func logAggFailure(what string, err error) {
+	if err != nil {
+		log.Printf("刷新%s失败（数据已写入，计数可能滞后）: %v", what, err)
+	}
 }
 
 func parseFloat(v string) (float64, bool) {
@@ -2207,10 +2442,12 @@ func (s *Server) apiCoords(w http.ResponseWriter, r *http.Request) {
 // 导入留档里的原始 GPS 与显示坐标完全相同。真机正常会写 gcj(raw)==显示坐标
 // （305/323），剩下 18 个 raw 与显示坐标一字不差，就是没做偏移的那批。
 // 中国境外的点本来就不该偏移，用外接矩形把它们排除掉，免得误判。
-const suspectWGS = `(r.raw->>'ZRAWLATITUDE') ~ '^-?[0-9.]+$'
+//
-	AND (r.raw->>'ZRAWLONGITUDE') ~ '^-?[0-9.]+$'
+// 两边的取值都走 RawFloat8：留档值不是数字时给 NULL，比较结果也是 NULL = 不命中，
-	AND abs((r.raw->>'ZRAWLATITUDE')::float8 - COALESCE(p.lat,0)) < 1e-9
+// 不会像以前那样因为 `::float8` 把整页 500 掉（旧版那条正则 '^-?[0-9.]+$' 连
-	AND abs((r.raw->>'ZRAWLONGITUDE')::float8 - COALESCE(p.lon,0)) < 1e-9
+// "1.2.3" 都放行，等于没护栏）。
+var suspectWGS = `abs(` + rond.RawFloat8(`r.raw->>'ZRAWLATITUDE'`) + ` - COALESCE(p.lat,0)) < 1e-9
+	AND abs(` + rond.RawFloat8(`r.raw->>'ZRAWLONGITUDE'`) + ` - COALESCE(p.lon,0)) < 1e-9
 	AND p.lat BETWEEN 3.86 AND 53.55 AND p.lon BETWEEN 73.66 AND 135.05`
 
 // 地点列表与 entity_raw 的关联：留档里既有原始 GPS（判断坐标系是否没偏移），

internal/web/handlers_export.go

@@ -4,10 +4,12 @@ import (
 	"bytes"
 	"context"
 	"fmt"
+	"log"
 	"net/http"
 	"os"
 	"path/filepath"
 	"sort"
+	"strconv"
 	"strings"
 	"time"
 
@@ -82,7 +84,7 @@ func (s *Server) exportGeoJSON(w http.ResponseWriter, r *http.Request) {
 	}
 	b.WriteString(`]}`)
 	w.Header().Set("Content-Type", "application/geo+json; charset=utf-8")
-	w.Header().Set("Content-Disposition", `attachment; filename="places.geojson"`)
+	w.Header().Set("Content-Disposition", downloadDisposition("places.geojson"))
 	w.Write([]byte(b.String()))
 }
 
@@ -92,6 +94,7 @@ func (s *Server) exportGPX(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 	var b strings.Builder
+	catNames := s.categoryLabels(r.Context())
 	b.WriteString(`<?xml version="1.0" encoding="UTF-8"?>` + "\n")
 	b.WriteString(`<gpx version="1.1" creator="rond-with-you" xmlns="http://www.topografix.com/GPX/1/1">` + "\n")
 	for _, p := range places {
@@ -100,7 +103,7 @@ func (s *Server) exportGPX(w http.ResponseWriter, r *http.Request) {
 			parts = append(parts, p.Province, p.City)
 		}
 		if p.POICategory != "" {
-			parts = append(parts, poiName(p.POICategory))
+			parts = append(parts, categoryLabel(p.POICategory, catNames))
 		}
 		desc := strings.Join(strings.Fields(strings.Join(parts, " · ")), " ")
 		var last string
@@ -119,10 +122,74 @@ func (s *Server) exportGPX(w http.ResponseWriter, r *http.Request) {
 	b.WriteString("</gpx>\n")
 	w.Header().Set("Content-Type", "application/gpx+xml; charset=utf-8")
 	w.Header().Set("Content-Disposition",
-		fmt.Sprintf(`attachment; filename="places-%s.gpx"`, time.Now().Format("20060102")))
+		downloadDisposition("places-"+time.Now().Format("20060102")+".gpx"))
 	w.Write([]byte(b.String()))
 }
 
+// downloadDisposition 拼 Content-Disposition。
+//
+// 导出包的名字里带着 `datasets.original_name`，那是**上传时的文件名**——含引号、斜杠、
+// 控制字符都正常，甚至可能整段 `"; filename*=…` 之类的内容。原样塞进 `filename="…"`
+// 就能提前闭合引号、往这个头里塞参数（net/http 只把 CR/LF 换成空格，管不了引号）。
+// 所以给两个值：
+//   - `filename=` 只留 ASCII 安全字符，老浏览器兜底；
+//   - `filename*=`（RFC 5987）按 UTF-8 百分号编码带真实名字，现代浏览器优先取它，
+//     中文名不会像以前那样被当成 Latin-1 乱码。
+func downloadDisposition(name string) string {
+	if strings.TrimSpace(name) == "" {
+		name = "download"
+	}
+	ext := filepath.Ext(name)
+	stem := asciiSafe(strings.TrimSuffix(name, ext))
+	// 纯中文名的词干映射完就是一串下划线，给个能读的兜底名；但不能把扩展名一起丢掉，
+	// 否则用户下到手里是个没法双击打开的「download」。
+	if !hasAlnum(stem) {
+		stem = "download"
+	}
+	return fmt.Sprintf("attachment; filename=%q; filename*=UTF-8''%s", stem+asciiSafe(ext), rfc5987Escape(name))
+}
+
+// asciiSafe 把不能安全写进 `filename="…"` 的字符换成下划线：
+// 引号能提前闭合这个参数，斜杠/反斜杠会在落盘时被当成路径，`;` `=` 能伪造后续参数。
+func asciiSafe(s string) string {
+	return strings.Map(func(r rune) rune {
+		if r < 0x20 || r > 0x7e {
+			return '_'
+		}
+		switch r {
+		case '"', '\\', '/', ';', ':', '=', '*', '?', '<', '>', '|':
+			return '_'
+		}
+		return r
+	}, s)
+}
+
+func hasAlnum(s string) bool {
+	return strings.ContainsFunc(s, func(r rune) bool {
+		return (r >= 'a' && r <= 'z') || (r >= 'A' && r <= 'Z') || (r >= '0' && r <= '9')
+	})
+}
+
+// rfc5987Escape 按 RFC 5987 的 attr-char 编码：ASCII 字母数字与 `. _ - ~` 原样，
+// 其余**逐字节**百分号编码（UTF-8 的每个字节各编一次，这正是规范要求的）。
+// 故意只放行这个窄集合：`;` `=` 这类在 attr-char 之外，漏掉就能截断参数。
+func rfc5987Escape(s string) string {
+	const hexDigits = "0123456789ABCDEF"
+	var b strings.Builder
+	for i := 0; i < len(s); i++ {
+		c := s[i]
+		if (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || (c >= '0' && c <= '9') ||
+			c == '.' || c == '_' || c == '-' || c == '~' {
+			b.WriteByte(c)
+			continue
+		}
+		b.WriteByte('%')
+		b.WriteByte(hexDigits[c>>4])
+		b.WriteByte(hexDigits[c&0x0f])
+	}
+	return b.String()
+}
+
 // baselinePath 返回某数据集的基线库路径。基线是导入时从原始备份包留下的单文件副本，
 // 导出时以它为底做覆盖，从而保住 Core Data 的元数据表、索引、持久化历史，
 // 以及我们并不落库的实体（原始 GPS 采样点 ZRAWVISIT、ZKEYWORD、ZTRIP* 等）。
@@ -130,30 +197,51 @@ func (s *Server) baselinePath(datasetID int64) string {
 	return filepath.Join(s.cfg.DataDir, "baselines", fmt.Sprintf("%d.sqlite", datasetID))
 }
 
-// ensureBaseline 确保基线库存在；缺失时从当初上传的原始备份包重建。
+// ensureBaseline 确保基线库存在；缺失时按记档或当初上传的原始备份包重建。
 func (s *Server) ensureBaseline(ctx context.Context, datasetID int64) (string, error) {
 	p := s.baselinePath(datasetID)
 	if _, err := os.Stat(p); err == nil {
 		return p, nil
 	}
-	archive, err := s.findSourceArchive(ctx, datasetID)
+	if err := s.ensureBaselineTo(ctx, datasetID, p); err != nil {
-	if err != nil {
 		return "", err
 	}
-	if err := rond.WriteBaseline(archive, p); err != nil {
-		return "", fmt.Errorf("重建基线库失败：%w", err)
-	}
 	return p, nil
 }
 
-// findSourceArchive 在 uploads 目录里按 datasets.sha256 找回当初上传的备份包。
+// ensureBaselineTo 把底座库写到 dst（不论 dst 是否已存在）。调用方要先想清楚覆盖是否安全：
-func (s *Server) findSourceArchive(ctx context.Context, datasetID int64) (string, error) {
+// 导出路径只会在底座缺失时调它，而「换基线」页要先写临时文件、成功了再改名就位。
-	var sha string
+func (s *Server) ensureBaselineTo(ctx context.Context, datasetID int64, dst string) error {
-	if err := s.db.QueryRowContext(ctx, `SELECT COALESCE(sha256,'') FROM datasets WHERE id=$1`, datasetID).Scan(&sha); err != nil {
+	// 换过底座的数据集必须先看记档：datasets.sha256 指的是**最初**那份包，
-		return "", err
+	// 拿它重建会把底座悄悄退回旧包——站长上一次换基线就白做了，而且没有任何提示。
+	var name, baseSHA string
+	if err := s.db.QueryRowContext(ctx, `SELECT COALESCE(baseline_name,''), COALESCE(baseline_sha256,'')
+		FROM datasets WHERE id=$1`, datasetID).Scan(&name, &baseSHA); err != nil {
+		return err
 	}
+	if baseSHA != "" {
+		archive, err := s.findUploadBySha(baseSHA, 0)
+		if err != nil {
+			return fmt.Errorf("当前底座来自 %s，但 uploads 里已找不到那份包：请到「换基线」页重新上传", name)
+		}
+		if err := rond.WriteBaseline(archive, dst); err != nil {
+			return fmt.Errorf("重建基线库失败：%w", err)
+		}
+		return nil
+	}
+	archive, err := s.findSourceArchive(ctx, datasetID)
+	if err != nil {
+		return err
+	}
+	if err := rond.WriteBaseline(archive, dst); err != nil {
+		return fmt.Errorf("重建基线库失败：%w", err)
+	}
+	return nil
+}
+
+// uploadsNewestFirst 列出 uploads 目录里的候选包，新的在前（命中即止的查找靠这个顺序）。
+func (s *Server) uploadsNewestFirst() []string {
 	files, _ := filepath.Glob(filepath.Join(s.cfg.UploadDir, "*"))
-	// 新的在前，命中即止
 	sort.Slice(files, func(i, j int) bool {
 		fi, ei := os.Stat(files[i])
 		fj, ej := os.Stat(files[j])
@@ -162,19 +250,65 @@ func (s *Server) findSourceArchive(ctx context.Context, datasetID int64) (string
 		}
 		return fi.ModTime().After(fj.ModTime())
 	})
+	return files
+}
+
+func hashUpload(f string) (string, error) {
+	got, _, err := ingest.File(f)
+	return got, err
+}
+
+// findUploadBySha 按内容摘要找一份包（用于「换基线」记档的源包）。
+// size > 0 时先按字节数筛一道再算摘要：uploads 里可能堆着几十份几十 MB 的包，
+// 每份都完整读一遍只为比摘要太亏（sha 相同必然字节数相同）。
+func (s *Server) findUploadBySha(sha string, size int64) (string, error) {
+	f := pickArchiveBySha(s.uploadsNewestFirst(), sha, size, hashUpload)
+	if f == "" {
+		return "", fmt.Errorf("找不到摘要为 %.8s… 的备份包", sha)
+	}
+	return f, nil
+}
+
+// findSourceArchive 在 uploads 目录里按 datasets.sha256 找回当初上传的备份包。
+func (s *Server) findSourceArchive(ctx context.Context, datasetID int64) (string, error) {
+	var sha string
+	var size int64
+	if err := s.db.QueryRowContext(ctx, `SELECT COALESCE(sha256,''), COALESCE(size_bytes,0) FROM datasets WHERE id=$1`, datasetID).Scan(&sha, &size); err != nil {
+		return "", err
+	}
+	// 新的在前，命中即止
+	if f := pickArchiveBySha(s.uploadsNewestFirst(), sha, size, hashUpload); f != "" {
+		return f, nil
+	}
+	return "", fmt.Errorf("找不到当初上传的原始备份包（可能已清理），请到后台重新上传一次该 .rondbackup")
+}
+
+// pickArchiveBySha 从候选文件里挑出摘要匹配的那一份（没有则返回空串）。
+//
+// 先按字节数筛一道再算摘要：uploads 里可能堆着几十份几百 MB 的备份，每份都得完整读一遍
+// 才比得出 sha256，而 sha256 相同就一定字节数相同——大小对不上的根本不必读。
+// 没有 sha 可比时（老库或退化数据）不做筛选，保持「取最新的那份」的旧行为。
+//
+// hash 做成参数是为了让用例能数「到底算了几次摘要」：只看最终返回哪个文件，
+// 带不带这道筛选完全一样，区分不出来。
+func pickArchiveBySha(files []string, sha string, size int64, hash func(string) (string, error)) string {
 	for _, f := range files {
-		if fi, err := os.Stat(f); err != nil || fi.IsDir() {
+		fi, err := os.Stat(f)
+		if err != nil || fi.IsDir() {
 			continue
 		}
-		got, _, err := ingest.File(f)
+		if sha != "" && size > 0 && fi.Size() != size {
+			continue
+		}
+		got, err := hash(f)
 		if err != nil {
 			continue
 		}
 		if sha == "" || got == sha {
-			return f, nil
+			return f
 		}
 	}
-	return "", fmt.Errorf("找不到当初上传的原始备份包（可能已清理），请到后台重新上传一次该 .rondbackup")
+	return ""
 }
 
 // exportRondbackup 以基线库为底，把当前数据集写回为 rond 原始格式的 .rondbackup 并下载。
@@ -203,6 +337,15 @@ func (s *Server) exportRondbackup(w http.ResponseWriter, r *http.Request) {
 	}
 	w.Header().Set("Content-Type", "application/octet-stream")
 	w.Header().Set("Content-Disposition",
-		fmt.Sprintf(`attachment; filename="%s-export-%s.rondbackup"`, stem, time.Now().Format("20060102")))
+		downloadDisposition(stem+"-export-"+time.Now().Format("20060102")+".rondbackup"))
-	w.Write(buf.Bytes())
+	w.Header().Set("Content-Length", strconv.Itoa(buf.Len()))
+	// 整包先落内存是为了绝不写出半截文件，代价是整个下载都得在写死线内完成。
+	// 全站 120s 是按页面响应定的，慢链路下拉几十 MB 不够——只放宽这一条路由。
+	if err := http.NewResponseController(w).SetWriteDeadline(time.Now().Add(10 * time.Minute)); err != nil {
+		log.Printf("导出：无法延长写超时，仍按全站限制走: %v", err)
+	}
+	w.WriteHeader(http.StatusOK)
+	if _, err := buf.WriteTo(w); err != nil {
+		log.Printf("导出：下载写出中断: %v", err)
+	}
 }

internal/web/handlers_images.go

@@ -89,6 +89,9 @@ func (s *Server) adminPlaceImageUpload(w http.ResponseWriter, r *http.Request) {
 		s.json(w, map[string]any{"error": "还没有可编辑的数据集"})
 		return
 	}
+	// 必须先卡请求体：ParseMultipartForm 只限制「内存里留多少」，超出的部分会
+	// 无上限地落到临时文件，光靠后面 LimitReader 拦不住磁盘被写满。
+	r.Body = http.MaxBytesReader(w, r.Body, imageMaxBytes+1<<20)
 	if err := r.ParseMultipartForm(imageUploadMem); err != nil {
 		s.json(w, map[string]any{"error": "上传内容读不出来（可能太大）"})
 		return
@@ -161,6 +164,9 @@ func (s *Server) adminPlaceImageUpload(w http.ResponseWriter, r *http.Request) {
 }
 
 // adminPlaceImageDelete 删掉一张图：先删对象再删行（对象删失败也不留孤儿行）。
+//
+// 按 id 就行，**不按数据集过滤**：图片认地点靠坐标键、与数据集无关，而且数据集可能已经被删
+// （那时行还在、dataset_id 指向一个不存在的编号），带 dataset_id 过滤就永远删不掉了。
 func (s *Server) adminPlaceImageDelete(w http.ResponseWriter, r *http.Request) {
 	ctx := r.Context()
 	ds, err := s.datasetFor(ctx)
@@ -178,7 +184,7 @@ func (s *Server) adminPlaceImageDelete(w http.ResponseWriter, r *http.Request) {
 	}
 	var backend, key string
 	if err := s.db.QueryRowContext(ctx, `SELECT storage, object_key FROM place_images
-		WHERE id=$1 AND dataset_id=$2`, id, ds.ID).Scan(&backend, &key); err != nil {
+		WHERE id=$1`, id).Scan(&backend, &key); err != nil {
 		s.json(w, map[string]any{"error": "图片不存在"})
 		return
 	}
@@ -188,8 +194,7 @@ func (s *Server) adminPlaceImageDelete(w http.ResponseWriter, r *http.Request) {
 		s.json(w, map[string]any{"error": "删除文件失败：" + err.Error()})
 		return
 	}
-	if _, err := s.db.ExecContext(ctx, `DELETE FROM place_images WHERE id=$1 AND dataset_id=$2`,
+	if _, err := s.db.ExecContext(ctx, `DELETE FROM place_images WHERE id=$1`, id); err != nil {
-		id, ds.ID); err != nil {
 		s.serverError(w, r, err)
 		return
 	}

internal/web/handlers_photos.go

@@ -48,9 +48,9 @@ func (s *Server) adminPhotosPage(w http.ResponseWriter, r *http.Request) {
 		s.serverError(w, r, err)
 		return
 	}
-	p.Flatpickr = true
 	p.HasMap = true
 	d := PhotoData{Page: p, GeocodeReady: s.cfg.GeocodeKey != ""}
+	catNames := s.categoryLabels(r.Context())
 	ds, err := s.datasetFor(r.Context())
 	if err != nil {
 		s.serverError(w, r, err)
@@ -81,7 +81,7 @@ func (s *Server) adminPhotosPage(w http.ResponseWriter, r *http.Request) {
 				s.serverError(w, r, err)
 				return
 			}
-			d.Categories = append(d.Categories, EditOption{Label: c, Name: poiCategoryLabel(c)})
+			d.Categories = append(d.Categories, EditOption{Label: c, Name: categoryLabel(c, catNames)})
 		}
 		crows.Close()
 	}
@@ -232,7 +232,7 @@ func (s *Server) adminPhotosImport(w http.ResponseWriter, r *http.Request) {
 		imported++
 	}
 
-	s.refreshDatasetAgg(ctx, ds.ID)
+	logAggFailure("数据集计数", s.refreshDatasetAgg(ctx, s.db, ds.ID))
 	msg := fmt.Sprintf("已导入 %d 个地点（照片）", imported)
 	if withImage > 0 {
 		msg += fmt.Sprintf("，配了 %d 张图", withImage)

internal/web/handlers_public.go

@@ -29,13 +29,22 @@ const (
 
 func (s *Server) pageBase(r *http.Request, nav, title string) (Page, error) {
 	ctx := r.Context()
-	p := Page{Nav: nav, Title: title, User: userFrom(ctx), PageNo: 1, AssetV: assetVersion,
+	p := Page{Nav: nav, Title: title, User: userFrom(ctx), PageNo: 1, AssetV: assetVersion}
-		TrackScript: trackTag(s.cfg.TrackScript)}
 	sets, err := s.sets.Load(ctx)
 	if err != nil {
 		return p, err
 	}
 	p.Settings = sets
+	// 统计脚本：后台「站点设置」里勾了开关才注入（默认关闭）。
+	// conf/app.ini 的 track_script 只在这一个开关打开时充当默认内容，
+	// 这样既保留了原来「改 ini 就能挂上」的用法，也让开关成为唯一的总闸。
+	track := sets.TrackScript
+	if track == "" {
+		track = s.cfg.TrackScript
+	}
+	if sets.TrackEnabled {
+		p.TrackScript = trackTag(track)
+	}
 	ds, err := s.datasetFor(ctx)
 	if err != nil {
 		return p, err
@@ -44,9 +53,10 @@ func (s *Server) pageBase(r *http.Request, nav, title string) (Page, error) {
 	if ds == nil {
 		return p, nil
 	}
-	// 有专题才在导航里露出入口（含未对外展示的：站长要能从导航进管理页）
+	// 有专题才在导航里露出入口（含未对外展示的：站长要能从导航进管理页）。
+	// 专题归**人**（换了数据集也还是同一批），所以按属主判，不是按数据集。
 	if err := s.db.QueryRowContext(ctx,
-		`SELECT EXISTS(SELECT 1 FROM topics WHERE dataset_id=$1)`, ds.ID).Scan(&p.HasTopics); err != nil {
+		`SELECT EXISTS(SELECT 1 FROM topics WHERE user_id=$1)`, ds.UserID).Scan(&p.HasTopics); err != nil {
 		return p, err
 	}
 
@@ -97,8 +107,9 @@ func (s *Server) pageBase(r *http.Request, nav, title string) (Page, error) {
 	p.FilterBase = r.URL.Path
 	p.Presets = buildPresets(p.From, p.To)
 	// 「回到哪」的两个参数：Back 是别人挂给我们的（详情页/编辑页的返回按钮用），
-	// BackQS 是把自己挂给别人的（列表页生成详情链接用）。
+	// BackQS 是把自己挂给别人的（列表页生成详情链接用），SelfPath 是它的未编码原文。
 	p.Back = backFromRequest(r)
+	p.SelfPath = selfPath(r)
 	p.BackQS = backQS(r)
 	return p, nil
 }
@@ -358,6 +369,7 @@ func (s *Server) home(w http.ResponseWriter, r *http.Request) {
 	d.MaxCity = maxOf(d.CityStats, func(c stats.CityStat) int { return c.Count })
 	d.MaxTransport = maxOf(d.Transports, func(t stats.TransportStat) int { return t.Count })
 	d.MaxTag = maxOf(d.Tags, func(t stats.TagStat) int { return t.Count })
+	d.MaxMonthly = maxOf(d.Monthly, func(m MonthBar) int { return m.Count })
 	s.render(w, "home", d)
 }
 
@@ -527,6 +539,7 @@ func (s *Server) placePage(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 	d := PlaceData{Page: p, Place: place, Visits: visits, Points: []MapPoint{toPoint(place)}}
+	d.CategoryLabel = categoryLabel(place.POICategory, s.categoryLabels(r.Context()))
 	d.Title = place.Name
 	// 备注保存后跳回本页并带上 ok，只有站长能看到这句提示
 	if p.IsAdmin() {
@@ -701,6 +714,18 @@ func (s *Server) statsPage(w http.ResponseWriter, r *http.Request) {
 			d.Avoided, err = s.verdictPlaces(ctx, p.Dataset.ID, votes.VerdictAvoid, 8)
 			return err
 		}},
+		// 访客点赞榜另起一个任务：与站长结论互不依赖，串在同一个任务里只会白等
+		pageJob{"visitorvotes", func(ctx context.Context) error {
+			if !p.IsAdmin() && !p.Settings.MarksPublic {
+				return nil
+			}
+			var err error
+			if d.VisitorUp, err = s.votes.TopVisitorVoted(ctx, p.Dataset.ID, 1, 8); err != nil {
+				return err
+			}
+			d.VisitorDown, err = s.votes.TopVisitorVoted(ctx, p.Dataset.ID, -1, 8)
+			return err
+		}},
 	); err != nil {
 		s.serverError(w, r, err)
 		return
@@ -714,10 +739,6 @@ func (s *Server) statsPage(w http.ResponseWriter, r *http.Request) {
 			}
 		}
 	}
-	if d.Weekday, err = s.q.Weekday(ctx, f); err != nil {
-		s.serverError(w, r, err)
-		return
-	}
 	for _, m := range d.Monthly {
 		if m.Count > d.MaxMonthly {
 			d.MaxMonthly = m.Count
@@ -869,7 +890,7 @@ func (s *Server) firstArrivalCities(ctx context.Context, datasetID int64, from,
 	regSQL := regionSQL("p", regions, exclude, &args)
 	q := `SELECT COALESCE(p.city,''), COALESCE(p.province,''), min(v.arrival)::date
 		FROM visits v JOIN places p ON p.id = v.place_id
-		WHERE v.dataset_id = $1 AND p.city IS NOT NULL AND p.city <> ''` + regSQL + `
+		WHERE v.dataset_id = $1 AND p.city IS NOT NULL AND p.city <> '' AND ` + stats.SoloVisitSQL("v") + regSQL + `
 		GROUP BY p.city, p.province
 		HAVING min(v.arrival) >= $2 AND min(v.arrival) < $3
 		ORDER BY min(v.arrival) ASC`
@@ -901,7 +922,8 @@ func (s *Server) extremePlace(ctx context.Context, datasetID int64, from, to tim
 	args := []any{datasetID, from, to}
 	q := `SELECT ` + stats.PlaceCols + ` FROM places p
 		WHERE p.dataset_id=$1 AND p.lat IS NOT NULL
-		AND EXISTS (SELECT 1 FROM visits v WHERE v.place_id=p.id AND v.arrival >= $2 AND v.arrival < $3)` +
+		AND EXISTS (SELECT 1 FROM visits v WHERE v.place_id=p.id AND v.arrival >= $2 AND v.arrival < $3
+			AND ` + stats.SoloVisitSQL("v") + `)` +
 		regionSQL("p", regions, exclude, &args) + `
 		ORDER BY p.lat ` + dir + ` LIMIT 1`
 	if err := stats.ScanPlace(s.db.QueryRowContext(ctx, q, args...), &p); err != nil {
@@ -949,16 +971,29 @@ func (s *Server) apiCityAgg(w http.ResponseWriter, r *http.Request) {
 	if !p.IsAdmin() {
 		regSQL = regionSQL("p", p.Settings.Regions, p.Settings.RegionBlacklist(), &args)
 	}
-	rows, err := s.db.QueryContext(r.Context(), `SELECT COALESCE(p.city,''), COALESCE(p.province,''),
+	// 先按**地点**聚合、再按城市汇总。直接在 places ⋈ visits 上 sum(places.visit_count) 是错的：
-		AVG(p.lat)::float8, AVG(p.lon)::float8,
+	// 一个地点有 N 条到访，它的 visit_count 就会被累加 N 次（实测「到访 72661 次」，真值 568），
-		COALESCE(sum(p.visit_count),0), count(*), COALESCE(sum(p.dwell_minutes),0),
+	// dwell 同理；count(*) 数出来的是到访条数，却被当成「地点数」显示。
-		min(p.first_visit_at), max(p.last_visit_at)
+	rows, err := s.db.QueryContext(r.Context(), `SELECT COALESCE(pa.city,''), COALESCE(pa.province,''),
-		FROM places p
+		AVG(pa.lat)::float8, AVG(pa.lon)::float8,
-		JOIN visits v ON v.place_id = p.id AND v.dataset_id = p.dataset_id
+		COALESCE(sum(pa.visits),0), count(*), COALESCE(sum(pa.dwell),0),
-		WHERE p.dataset_id = $1 AND p.city IS NOT NULL AND p.city <> '' AND p.lat IS NOT NULL`+regSQL+`
+		min(pa.first_at), max(pa.last_at)
-			AND NOT EXISTS (SELECT 1 FROM visits vh WHERE vh.place_id = p.id
+		FROM (
-				AND (vh.is_home OR vh.is_work))
+			SELECT p.id, p.city, p.province, p.lat, p.lon,
-		GROUP BY p.city, p.province
+				-- 首末到访按**可见到访**的到达时间算，不取 places 列值（那两列是全量，
+				-- 会被已并入 / 子段的行推早推晚），与 visit_count 之类的口径保持一致
+				min(v.arrival) AS first_at, max(v.arrival) AS last_at,
+				count(*) AS visits,
+				COALESCE(sum(LEAST(COALESCE(v.duration_min,0),10080)),0) AS dwell
+			FROM places p
+			JOIN visits v ON v.place_id = p.id AND v.dataset_id = p.dataset_id
+			WHERE p.dataset_id = $1 AND p.city IS NOT NULL AND p.city <> '' AND p.lat IS NOT NULL`+regSQL+`
+				AND `+stats.SoloVisitSQL("v")+`
+				AND NOT EXISTS (SELECT 1 FROM visits vh WHERE vh.place_id = p.id
+					AND (vh.is_home OR vh.is_work))
+			GROUP BY p.id
+		) pa
+		GROUP BY pa.city, pa.province
 		ORDER BY 5 DESC`, args...)
 	if err != nil {
 		s.json(w, map[string]string{"error": err.Error()})
@@ -1100,10 +1135,31 @@ type GPXTrack struct {
 
 // apiGpx 返回已导入的 GPX 轨迹。库里存的是 WGS-84（GPX 标准），
 // 底图是 GCJ-02 时按点转成火星坐标，保证和足迹点对齐。
+//
+// 轨迹按**当前生效数据集的属主**圈定，不是把整张表端出去：gpx_tracks 带 user_id，
+// 这是公开接口、不带登录态，不按属主过滤就等于把别人的轨迹一起露给访客。
+// 没有生效数据集时返回空集——和页面其余部分「没数据就没有」的口径一致。
 func (s *Server) apiGpx(w http.ResponseWriter, r *http.Request) {
+	ctx := r.Context()
+	empty := func() {
+		s.json(w, struct {
+			Tracks []GPXTrack `json:"tracks"`
+		}{Tracks: []GPXTrack{}})
+	}
+	var owner int64
+	err := s.db.QueryRowContext(ctx, `SELECT user_id FROM datasets
+		WHERE is_active AND status='done' ORDER BY uploaded_at DESC LIMIT 1`).Scan(&owner)
+	if errors.Is(err, sql.ErrNoRows) {
+		empty()
+		return
+	}
+	if err != nil {
+		s.json(w, map[string]string{"error": err.Error()})
+		return
+	}
 	crs := r.URL.Query().Get("crs")
-	rows, err := s.db.QueryContext(r.Context(), `SELECT id, name, points, length_km, started_at
+	rows, err := s.db.QueryContext(ctx, `SELECT id, name, points, length_km, started_at
-		FROM gpx_tracks ORDER BY started_at DESC NULLS LAST, id DESC`)
+		FROM gpx_tracks WHERE user_id=$1 ORDER BY started_at DESC NULLS LAST, id DESC`, owner)
 	if err != nil {
 		s.json(w, map[string]string{"error": err.Error()})
 		return