perf(db): 统计金额落到列上、会话刷新节流、补齐保留与内存治理

背景：生产 32 天内 >500ms 慢查询从 2.4k/天涨到 1.3 万/天（09-26 尖峰 14.3 万），
pg_stat_statements 显示后台工单列表族占 57%、打手端 visible_orders 占 27%；
同时 backend 容器十天从 194MB 涨到 754MB(768MB 限额的 98%)，贴顶后整体变慢。

1. 新增迁移 083：work_orders 增加派生列 source_order_amount_fen，并从
   material_json.source.orderAmountFen 回填（只认 15 位以内整数，与 JS/SQL 口径一致）。
   统计查询原来每行要解析 1.2KB JSON（全表约 132MB）且同一表达式求值两次，
   生产实测 3.5~4.4 秒；改走派生列后 COALESCE 短路，未命中列的行才回退 JSON/orders.total_amount，
   口径与改造前完全一致。写入点：createWorkOrder / updateWorkOrder 各一处，并加静态守卫。
2. worker_sessions.last_seen_at 从"每个请求都写"改为"5 分钟才写一次"：
   32 天被写了 3300 万次（占 DB 总时间 2.8%，并堆出 14% 死元组）。仍用一条语句返回鉴权有效性
   （EXISTS target AS valid），不能因为不写就让上层 401。
3. 保留策略补上 work_order_events（71.7 万行 / 269MB，此前完全没纳入清理，只增不减），
   新增配置 retention.workOrderEventDays（默认 180 天）与 WORK_ORDER_EVENT_RETENTION_DAYS 出口。
4. 内存治理：compose 后端限额 768m→1g 并显式设置 V8 老生代上限（--max-old-space-size=768），
   避免贴 cgroup 上限后 GC 抖动；新增每 10 分钟的进程内存快照日志（rss/heapUsed/heapLimit），
   用于区分"正常 GC 曲线"与"真泄漏"。
5. 限流桶加 5 万条硬上限：key 里含请求体字段（collect 的 orderNo）时可被构造成高基数，
   只按过期清理挡不住内存增长。

验证：后端 530 项单测全绿（新增 11 项，含派生列/会话/保留的静态守卫与解析函数单测）。

apps/backend/src/repositories/worker-platform/shared.test.ts

@@ -0,0 +1,69 @@
+import assert from 'node:assert/strict'
+import test from 'node:test'
+
+import { resolveSourceOrderAmountFen } from './shared.js'
+
+test('resolveSourceOrderAmountFen：正常取值（字符串/数字都认）', () => {
+  assert.equal(resolveSourceOrderAmountFen({ source: { orderAmountFen: 12345 } }), 12345)
+  assert.equal(resolveSourceOrderAmountFen({ source: { orderAmountFen: '12345' } }), 12345)
+  // JSON 字符串形态（createWorkOrder 收到的就是字符串）
+  assert.equal(
+    resolveSourceOrderAmountFen(JSON.stringify({ source: { orderAmountFen: '8800' } })),
+    8800,
+  )
+})
+
+test('resolveSourceOrderAmountFen：0 是合法金额，必须与"没有值"区分开', () => {
+  // 统计口径是 COALESCE(列, ...)：0 会直接命中列，NULL 才会回退 orders.total_amount，
+  // 所以这里必须返回 0 而不是 null
+  assert.equal(resolveSourceOrderAmountFen({ source: { orderAmountFen: 0 } }), 0)
+  assert.equal(resolveSourceOrderAmountFen({ source: { orderAmountFen: '0' } }), 0)
+})
+
+test('resolveSourceOrderAmountFen：没有合法整数时返回 null（交给 SQL 回退）', () => {
+  const invalidCases: unknown[] = [
+    undefined,
+    null,
+    {},
+    { source: {} },
+    { source: { orderAmountFen: null } },
+    { source: { orderAmountFen: '' } },
+    { source: { orderAmountFen: '   ' } },
+    { source: { orderAmountFen: '12.5' } },
+    { source: { orderAmountFen: '12a' } },
+    { source: { orderAmountFen: '￥120' } },
+    { source: { orderAmountFen: {} } },
+    { source: { orderAmountFen: [] } },
+    'not-json',
+  ]
+  for (const value of invalidCases) {
+    assert.equal(
+      resolveSourceOrderAmountFen(value),
+      null,
+      `${JSON.stringify(value)} 应判为"来源没给合法值"`,
+    )
+  }
+})
+
+test('resolveSourceOrderAmountFen：位数上限与迁移 083 / 统计 SQL 保持一致（1~15 位）', () => {
+  // 15 位是安全上限：Number 能精确表示，::bigint 也不会溢出
+  assert.equal(
+    resolveSourceOrderAmountFen({ source: { orderAmountFen: '999999999999999' } }),
+    999999999999999,
+  )
+  // 16 位起一律判为非法（不写列 → SQL 回退 orders.total_amount），避免与 SQL 口径分叉
+  assert.equal(
+    resolveSourceOrderAmountFen({ source: { orderAmountFen: '1000000000000000' } }),
+    null,
+  )
+  assert.equal(
+    resolveSourceOrderAmountFen({ source: { orderAmountFen: '12345678901234567890' } }),
+    null,
+  )
+})
+
+test('resolveSourceOrderAmountFen：material 结构异常不抛错', () => {
+  for (const weird of [0, false, '', '[]', [], '{}']) {
+    assert.doesNotThrow(() => resolveSourceOrderAmountFen(weird))
+  }
+})

apps/backend/src/repositories/worker-platform/shared.ts

@@ -1,7 +1,38 @@
 import type { PoolClient } from 'pg'
 
+import { parseJsonObject } from '../../utils/json.js'
+import type { JsonObject } from '../../types/json.js'
 import type { WorkerWalletRow } from './types.js'
 
+/**
+ * 解析工单 `material.source.orderAmountFen`（来源订单的用户付款金额，分），用于派生列
+ * `work_orders.source_order_amount_fen`。
+ *
+ * 统计口径要求：来源给了合法整数就用它，否则回退 `orders.total_amount`。
+ * 所以**没有合法值时必须返回 null 而不是 0**——0 是"确实付了 0 元"，NULL 才是"来源没给"。
+ *
+ * 位数上限与迁移 083 的回填、统计 SQL 里的正则保持一致（1~15 位）：
+ * 15 位以内一定能被 Number 精确表示且不会撑爆 bigint。
+ */
+export function resolveSourceOrderAmountFen(materialJson: unknown): number | null {
+  const material =
+    typeof materialJson === 'string'
+      ? parseJsonObject(materialJson)
+      : (materialJson as JsonObject | null | undefined)
+  if (!material || typeof material !== 'object') return null
+
+  const source = (material as JsonObject).source
+  if (!source || typeof source !== 'object' || Array.isArray(source)) return null
+
+  const raw = (source as JsonObject).orderAmountFen
+  if (raw === null || raw === undefined) return null
+
+  const text = String(raw).trim()
+  if (!/^-?[0-9]{1,15}$/.test(text)) return null
+
+  return Number(text)
+}
+
 export async function ensureWorkerWalletWithClient(
   client: PoolClient,
   workerId: number,

apps/backend/src/repositories/worker-platform/work-order-management-repo.ts

@@ -1,5 +1,5 @@
 import { query, withTransaction } from '../../db/client.js'
-import { toJsonString, toPositiveInteger } from './shared.js'
+import { resolveSourceOrderAmountFen, toJsonString, toPositiveInteger } from './shared.js'
 import { getWorkOrderById, getWorkOrderByIdWithClient } from './work-order-query-repo.js'
 import { createWorkOrderEventWithClient } from './work-order-event-repo.js'
 import {
@@ -22,12 +22,12 @@ export async function createWorkOrder(input: CreateWorkOrderInput): Promise<Work
         deposit_threshold_amount, sharing_enabled, sharing_total_quantity,
         sharing_unit_reward, timeout_minutes, timeout_policy,
         acceptance_mode, gift_phase, gift_cooldown_hours, gift_cooldown_minutes,
-        material_json, requirement_json, created_at, updated_at
+        material_json, requirement_json, source_order_amount_fen, created_at, updated_at
       ) VALUES (
         $1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11,
         $12, $13, $14, $15, $16, $17,
         $18, $19, $20, $21,
-        $22::jsonb, $23::jsonb, $24, $25
+        $22::jsonb, $23::jsonb, $24, $25, $26
       )
       RETURNING id
     `,
@@ -55,6 +55,8 @@ export async function createWorkOrder(input: CreateWorkOrderInput): Promise<Work
       normalizeWorkOrderGiftCooldownMinutes(input.giftCooldownMinutes),
       input.materialJson,
       input.requirementJson,
+      // 与 material_json 同源：统计要用的付款金额落到列上，避免每次刷新解析全表 JSON
+      resolveSourceOrderAmountFen(input.materialJson),
       input.now,
       input.now,
     ],
@@ -99,8 +101,8 @@ export async function updateWorkOrder(
         problem_note = $6, reward_amount = $7, sharing_enabled = $8,
         sharing_total_quantity = $9, sharing_unit_reward = $10, published_at = $11,
         hall_queued_at = $12, pinned_at = $13, assigned_at = $14, submitted_at = $15,
-        accepted_at = $16, updated_at = $17
-      WHERE id = $18
+        accepted_at = $16, source_order_amount_fen = $17, updated_at = $18
+      WHERE id = $19
     `,
     [
       next.status,
@@ -119,6 +121,8 @@ export async function updateWorkOrder(
       next.assigned_at || null,
       next.submitted_at || null,
       next.accepted_at || null,
+      // material_json 可能被这次 patch 改写（如补资料 / 快手发码回填），派生列跟着重算
+      resolveSourceOrderAmountFen(next.material_json),
       next.updated_at,
       Number(workOrderId),
     ],

apps/backend/src/repositories/worker-platform/work-order-query-repo.ts

@@ -332,6 +332,30 @@ async function countWorkOrdersWithWhere(
 }
 
 /** 按筛选条件汇总工单，统计范围不受当前分页影响。 */
+/**
+ * 统计用的「用户付款金额」表达式。
+ *
+ * 优先读 083 迁移落下来的派生列 `source_order_amount_fen`（写入点：createWorkOrder /
+ * updateWorkOrder，口径见 shared.ts 的 resolveSourceOrderAmountFen）。
+ * **COALESCE 是短路求值**：列非空时后面两个分支根本不会被计算，所以命中列的行完全不碰
+ * material_json——这正是把 2.8 秒的统计查询拉回毫秒级的关键（改造前每行要解析 1.2KB JSON，
+ * 全表约 132MB，而且这个表达式在总付款与退款两处各求值一次）。
+ *
+ * 第二、三个分支是兜底，只为覆盖"写入点漏了"或迁移前的老行，保证口径永远正确：
+ *   1) 派生列为 NULL 且 JSON 里有 15 位以内的合法整数 → 用 JSON 值；
+ *   2) 否则回退 orders.total_amount（与改造前完全一致）。
+ */
+const WORK_ORDER_PAYMENT_AMOUNT_SQL = `
+  COALESCE(
+    wo.source_order_amount_fen,
+    CASE
+      WHEN COALESCE(wo.material_json->'source'->>'orderAmountFen', '') ~ '^-?[0-9]{1,15}$'
+        THEN (wo.material_json->'source'->>'orderAmountFen')::bigint
+    END,
+    COALESCE(o.total_amount, 0)
+  )
+`
+
 export async function getWorkOrderStatistics(input: ListInput = {}): Promise<WorkOrderStatistics> {
   const { joins, whereClause, params } = buildWorkOrderWhere(input)
   const vipEvidencePendingWhere = `
@@ -346,13 +370,7 @@ export async function getWorkOrderStatistics(input: ListInput = {}): Promise<Wor
   const statusExpression = input.vipEvidencePending
     ? `CASE WHEN ${vipEvidencePendingWhere} THEN 'vip_evidence_pending' ELSE ${operationalStatus} END`
     : operationalStatus
-  const paymentExpression = `
-    CASE
-      WHEN COALESCE(wo.material_json->'source'->>'orderAmountFen', '') ~ '^-?[0-9]+$'
-        THEN (wo.material_json->'source'->>'orderAmountFen')::bigint
-      ELSE COALESCE(o.total_amount, 0)
-    END
-  `
+  const paymentExpression = WORK_ORDER_PAYMENT_AMOUNT_SQL
   const result = await query<WorkOrderStatisticsRow>(
     `
       SELECT

apps/backend/src/repositories/worker-platform/worker-session-repo.ts

@@ -83,14 +83,41 @@ export async function getWorkerSessionBySessionId(
   return result.rows[0] || null
 }
 
+/**
+ * 校验会话仍然有效，并顺带刷新 last_seen_at。
+ *
+ * 这里必须同时满足两个约束，所以不能用"直接跳过"的写法：
+ *   1. 返回值是**鉴权有效性**——上层 `!(await touchWorkerSession(...))` 为真就直接 401
+ *      「登录设备已被删除」，跳过查询会把所有正常请求打成未登录；
+ *   2. 也不能像以前那样每个请求都真写一次：32 天里 last_seen_at 被写了 3300 万次，
+ *      占数据库总执行时间的 2.8%，还在 worker_sessions 上堆出 14% 的死元组。
+ *
+ * 因此改成「一条语句拿到有效性 + 只在超过 5 分钟没刷新时才写」。
+ * 副作用只有 last_seen_at 精度变粗（用于设备列表排序与展示），
+ * 不影响会话有效期：expires_at 在建会话时确定，不做滑动续期。
+ */
+const WORKER_SESSION_TOUCH_MIN_INTERVAL = '5 minutes'
+
 export async function touchWorkerSession(sessionId: string, now: string): Promise<boolean> {
-  const result = await query(
-    `UPDATE worker_sessions
-     SET last_seen_at = $2, updated_at = $2
-     WHERE session_id = $1 AND status = 'active' AND expires_at > $2`,
+  const result = await query<{ valid: boolean }>(
+    `
+      WITH target AS (
+        SELECT session_id
+        FROM worker_sessions
+        WHERE session_id = $1 AND status = 'active' AND expires_at > $2
+      ), touched AS (
+        UPDATE worker_sessions ws
+        SET last_seen_at = $2, updated_at = $2
+        FROM target
+        WHERE ws.session_id = target.session_id
+          AND ws.last_seen_at < ($2::timestamptz - INTERVAL '${WORKER_SESSION_TOUCH_MIN_INTERVAL}')
+        RETURNING ws.session_id
+      )
+      SELECT EXISTS (SELECT 1 FROM target) AS valid
+    `,
     [String(sessionId || '').trim(), now],
   )
-  return (result.rowCount || 0) > 0
+  return Boolean(result.rows[0]?.valid)
 }
 
 export async function revokeWorkerSession(