@zhin.js/plugin-lottery 1.1.8 → 1.1.10

package/src/i18n.ts

@@ -0,0 +1,222 @@
+import { createMessages } from 'zhin.js/i18n';
+
+export const messages = createMessages({
+  dbNotReady: { 'zh-CN': '数据库未就绪', en: 'Database is not ready.' },
+  syncResult: { 'zh-CN': '同步 {result}', en: 'Sync {result}' },
+  reviewTitle: { 'zh-CN': '【彩票推荐复盘】', en: '[Lottery recommendation review]' },
+  reviewModel: { 'zh-CN': '■ {game} 模型 {weights}', en: '■ {game} model {weights}' },
+  reviewRate: { 'zh-CN': '  累计 {count} 期 平均命中 {rate}%', en: '  {count} draws reviewed; average hit rate {rate}%' },
+  reviewEmpty: { 'zh-CN': '  尚无复盘数据', en: '  No reviews yet.' },
+  reviewDraw: { 'zh-CN': '  第{issue}期 {detail} ({rate}%)', en: '  Draw {issue}: {detail} ({rate}%)' },
+  agentMemory: { 'zh-CN': '【Agent 记忆】', en: '[Agent memory]' },
+  pickLine: { 'zh-CN': '■ {label}：{numbers}', en: '■ {label}: {numbers}' },
+  noPicks: { 'zh-CN': '暂无推荐号码，请确认已同步开奖数据。', en: 'No picks available. Make sure draw results have been synchronized.' },
+  noReport: { 'zh-CN': '今日尚无推荐，请等待定时任务。', en: 'No report for today yet. Wait for the scheduled run.' },
+  noReportCommand: { 'zh-CN': '今日尚无推荐，可执行 {command} 或等待定时任务。', en: 'No report for today yet. Run {command} or wait for the scheduled run.' },
+  gameRequired: { 'zh-CN': '请指定玩法', en: 'Specify a lottery game.' },
+  invalidGame: { 'zh-CN': '无效的玩法', en: 'Invalid lottery game.' },
+  noData: { 'zh-CN': '暂无数据', en: 'No data available.' },
+  syncRequired: { 'zh-CN': '历史数据不足，请先同步开奖。', en: 'Not enough history. Synchronize draw results first.' },
+  syncCommand: { 'zh-CN': '历史数据不足，请先执行 {command} 同步开奖。', en: 'Not enough history. Run {command} to synchronize draw results first.' },
+  sample: { 'zh-CN': '样本 {count} 期', en: 'Sample: {count} draws' },
+  "zones": {
+    "zh-CN": "三区 {zones}",
+    "en": "Zones {zones}"
+  },
+  "oddEven": {
+    "zh-CN": "奇偶 {odd}:{even}",
+    "en": "Odd/even {odd}:{even}"
+  },
+  "bigSmall": {
+    "zh-CN": "大小 {big}:{small}",
+    "en": "High/low {big}:{small}"
+  },
+  "recentHot": {
+    "zh-CN": "近10期热号 {numbers}",
+    "en": "Hot numbers in last 10 draws: {numbers}"
+  },
+  "weights": {
+    "zh-CN": "权重 {weights}",
+    "en": "Weights {weights}"
+  },
+  "digitPos": {
+    "zh-CN": "第{position}位[{numbers}]",
+    "en": "Position {position} [{numbers}]"
+  },
+  "strategy.balanced": {
+    "zh-CN": "均衡",
+    "en": "Balanced"
+  },
+  "strategy.hot": {
+    "zh-CN": "热号",
+    "en": "Hot"
+  },
+  "strategy.cold": {
+    "zh-CN": "冷号",
+    "en": "Cold"
+  },
+  "strategy.trend": {
+    "zh-CN": "趋势",
+    "en": "Trend"
+  },
+  "pickLabel": {
+    "zh-CN": "{name}（选{count}）",
+    "en": "{name} (pick {count})"
+  },
+  "pickGroupsLabel": {
+    "zh-CN": "{name}（选{count}·{groups}组）",
+    "en": "{name} (pick {count} · {groups} groups)"
+  },
+  "basicDetail": {
+    "zh-CN": "频率+遗漏+趋势 | 和值{sum} 跨度{span}",
+    "en": "Frequency + omission + trend | Sum {sum}, span {span}"
+  },
+  "multiDetail": {
+    "zh-CN": "多策略 {strategies} | 和值{sum} 跨度{span}",
+    "en": "Strategies {strategies} | Sum {sum}, span {span}"
+  },
+  "redDetail": {
+    "zh-CN": "红球 {oddEven} {bigSmall} | 蓝 {blue}",
+    "en": "Red {oddEven} {bigSmall} | Blue {blue}"
+  },
+  "frontDetail": {
+    "zh-CN": "前区 {oddEven} {zones}",
+    "en": "Front {oddEven} {zones}"
+  },
+  "digitDetail": {
+    "zh-CN": "直选 {positions} | 和值{sum}",
+    "en": "Straight {positions} | Sum {sum}"
+  },
+  "groupLine": {
+    "zh-CN": "  组{index}·{label}：{numbers}",
+    "en": "  Group {index} · {label}: {numbers}"
+  },
+  "redLine": {
+    "zh-CN": "■ {label}：红 {red} + 蓝 {blue}",
+    "en": "■ {label}: Red {red} + Blue {blue}"
+  },
+  "frontLine": {
+    "zh-CN": "■ {label}：前 {front} + 后 {back}",
+    "en": "■ {label}: Front {front} + Back {back}"
+  },
+  "hot": {
+    "zh-CN": "热号 {numbers}",
+    "en": "Hot {numbers}"
+  },
+  "cold": {
+    "zh-CN": "冷号 {numbers}",
+    "en": "Cold {numbers}"
+  },
+  "accuracy": {
+    "zh-CN": "历史命中 {rate}% ({count}期) 近5期 {recent}",
+    "en": "Historical hit rate {rate}% ({count} draws), last 5: {recent}"
+  },
+  "game.kl8": {
+    "zh-CN": "快乐8",
+    "en": "Happy 8"
+  },
+  "game.ssq": {
+    "zh-CN": "双色球",
+    "en": "Double Color Ball"
+  },
+  "game.dlt": {
+    "zh-CN": "超级大乐透",
+    "en": "Super Lotto"
+  },
+  "game.fc3d": {
+    "zh-CN": "福彩3D",
+    "en": "Fucai 3D"
+  },
+  "game.pl3": {
+    "zh-CN": "排列3",
+    "en": "Pick 3"
+  },
+  "game.pl5": {
+    "zh-CN": "排列5",
+    "en": "Pick 5"
+  },
+  "dailyTitle": {
+    "zh-CN": "【彩票每日推荐】{date}",
+    "en": "[Daily lottery report] {date}"
+  },
+  "weightFallback": {
+    "zh-CN": "【权重保护】近端 holdout 调优未跑赢随机，已回退默认 F40/O35/T25：{games}",
+    "en": "[Weight safeguard] Recent holdout tuning did not beat random; reverted to F40/O35/T25: {games}"
+  },
+  "accuracyOverview": {
+    "zh-CN": "【模型复盘】累计平均命中 {overview}",
+    "en": "[Model review] Cumulative average hit rate: {overview}"
+  },
+  "statsExplanation": {
+    "zh-CN": "【统计说明】号码由频率+遗漏+近期趋势综合打分，并根据历史命中自动调权。",
+    "en": "[Method] Numbers are scored by frequency, omission and recent trends; weights adapt to historical hits."
+  },
+  "disclaimer": {
+    "zh-CN": "免责声明：本推荐由历史数据统计生成，仅供参考，不构成投注建议，不保证中奖。请理性购彩。",
+    "en": "Disclaimer: These picks are generated from historical statistics for reference only, not betting advice or a guarantee of winning. Play responsibly."
+  },
+  "backtestAdaptive": {
+    "zh-CN": "{game}: 调优 {rate}%",
+    "en": "{game}: adaptive {rate}%"
+  },
+  "backtestFixed": {
+    "zh-CN": "固定 {rate}%",
+    "en": "fixed {rate}%"
+  },
+  "backtestRandom": {
+    "zh-CN": "随机 {rate}%",
+    "en": "random {rate}%"
+  },
+  "backtestDelta": {
+    "zh-CN": "(Δ调优-随机 {delta}%, n={count}, 热身{warmup}期)",
+    "en": "(Δ adaptive-random {delta}%, n={count}, warmup {warmup} draws)"
+  },
+  "finalWeights": {
+    "zh-CN": "终权重 {weights}",
+    "en": "final weights {weights}"
+  },
+  "backtestTitle": {
+    "zh-CN": "【回测可信度】近 N 期 walk-forward 抽样",
+    "en": "[Backtest confidence] Walk-forward sampling of the latest N draws"
+  },
+  "backtestNote": {
+    "zh-CN": "说明：Δ 接近 0 为正常；终权重见 lottery_model_weights。",
+    "en": "Note: Δ near zero is normal; final weights are stored in lottery_model_weights."
+  },
+  "backtestFallback": {
+    "zh-CN": "推荐时若近端调优输给随机，将自动回退默认 F40/O35/T25（见【权重保护】）。",
+    "en": "If recent tuning underperforms random, recommendations revert to F40/O35/T25 (see Weight safeguard)."
+  },
+  "trainFallback": {
+    "zh-CN": " [holdout→默认]",
+    "en": " [holdout→default]"
+  },
+  "trainGame": {
+    "zh-CN": "{game}: 训练{steps}期 ({first}→{last}){fallback}",
+    "en": "{game}: trained on {steps} draws ({first}→{last}){fallback}"
+  },
+  "trainHit": {
+    "zh-CN": "命中 调优{adaptive}% / 固定{fixed}% / 随机{random}%",
+    "en": "Hit rate: adaptive {adaptive}% / fixed {fixed}% / random {random}%"
+  },
+  "trainDelta": {
+    "zh-CN": "Δ调优-随机 {delta}%",
+    "en": "Δ adaptive-random {delta}%"
+  },
+  "trainWeights": {
+    "zh-CN": "权重 {initial} → {final}",
+    "en": "Weights {initial} → {final}"
+  },
+  "trainEmpty": {
+    "zh-CN": "训练失败：历史数据不足，请先同步开奖。",
+    "en": "Training failed: not enough history. Synchronize draw results first."
+  },
+  "trainTitle": {
+    "zh-CN": "【权重训练】全历史 walk-forward：预测→比对→调权，已写入 lottery_model_weights",
+    "en": "[Weight training] Full-history walk-forward: predict → compare → tune; saved to lottery_model_weights"
+  },
+  "trainNote": {
+    "zh-CN": "说明：训练≠保证未来更准；终权重供后续推荐使用。",
+    "en": "Note: training does not guarantee better future results. Final weights are used for later recommendations."
+  }
+});

package/src/lottery-tool-handlers.ts

@@ -1,3 +1,5 @@
+import { resolveLocale, type Locale } from 'zhin.js/i18n';
+import { messages as t } from './i18n.js';
 import type { GameId } from './types.js';
 
 import { parseGameId } from './games/registry.js';
@@ -25,14 +27,15 @@ export async function handleGetModelState(runtime: LotteryRuntime, game?: string
   return JSON.stringify(out);
 }
 
-export async function handleComputeRecommend(runtime: LotteryRuntime, game: string): Promise<string> {
+export async function handleComputeRecommend(runtime: LotteryRuntime, game: string, locale: Locale = resolveLocale(runtime.locale)): Promise<string> {
   const gid = parseGameId(game);
-  if (!gid) return 'invalid game';
+  if (!gid) return t(locale, 'invalidGame');
   const { db, config: cfg } = runtime;
   const kl8 = lotteryKl8(cfg);
   const draws = await loadDraws(db, gid, cfg.historyLimit);
-  if (!draws.length) return 'no data; run the lottery draw synchronization tool first';
+  if (!draws.length) return t(locale, 'syncRequired');
   const pick = recommendGame(gid, draws, {
+    locale,
     pickCount: gid === 'kl8' ? kl8.pickCount : cfg.pickCount,
     tieSeed: new Date().toISOString().slice(0, 10),
     weights: await loadGameWeights(db, gid),
@@ -42,13 +45,14 @@ export async function handleComputeRecommend(runtime: LotteryRuntime, game: stri
   return JSON.stringify(pick);
 }
 
-export async function handleSavePrediction(runtime: LotteryRuntime, game: string, numbersJson: string): Promise<string> {
+export async function handleSavePrediction(runtime: LotteryRuntime, game: string, numbersJson: string, locale: Locale = resolveLocale(runtime.locale)): Promise<string> {
   const gid = parseGameId(game);
-  if (!gid) return 'invalid game';
+  if (!gid) return t(locale, 'invalidGame');
   const { db } = runtime;
   const numbers = JSON.parse(numbersJson);
   const weights = await loadGameWeights(db, gid);
   await savePrediction(db, {
+    locale,
     gameId: gid,
     label: gid,
     numbers,
@@ -64,13 +68,14 @@ export async function handleListPending(runtime: LotteryRuntime, game?: string):
   return JSON.stringify(await listPendingPredictions(db, gid ?? undefined));
 }
 
-export async function handleStatsSnapshot(runtime: LotteryRuntime, game: string): Promise<string> {
+export async function handleStatsSnapshot(runtime: LotteryRuntime, game: string, locale: Locale = resolveLocale(runtime.locale)): Promise<string> {
   const gid = parseGameId(game);
-  if (!gid) return 'invalid game';
+  if (!gid) return t(locale, 'invalidGame');
   const { db, config: cfg } = runtime;
   const kl8 = lotteryKl8(cfg);
   const draws = await loadDraws(db, gid, Math.min(30, cfg.historyLimit));
   const pick = recommendGame(gid, draws, {
+    locale,
     pickCount: gid === 'kl8' ? kl8.pickCount : cfg.pickCount,
     tieSeed: 'snapshot',
     weights: await loadGameWeights(db, gid),

package/src/pipeline.ts

@@ -1,3 +1,5 @@
+import { resolveLocale, type Locale } from 'zhin.js/i18n';
+import { messages as t } from './i18n.js';
 import type { GameId } from './types.js';
 import { syncGame, type LotteryDb } from './db.js';
 
@@ -19,6 +21,7 @@ import { cancelTodayPendingPredictions } from './evaluate/tracker.js';
 import type { Kl8Config } from './games/kl8-groups.js';
 
 export interface PipelineDeps {
+  locale?: Locale;
   db: LotteryDb;
   enabledGames: () => GameId[];
   historyLimit: number;
@@ -57,7 +60,7 @@ async function attachBacktestOverview(
   const summaries = holdoutSummaries.length
     ? holdoutSummaries
     : await runBacktestForGames(db, gameIds, backtestOpts(deps));
-  return formatBacktestSection(summaries);
+  return formatBacktestSection(summaries, deps.locale);
 }
 
 export interface PipelineOptions {
@@ -128,11 +131,11 @@ export async function runLotteryPipeline(
   let recommendText: string;
 
   if (!needPredict.length) {
-    const existing = await resolveTodayReport(db, gameIds);
+    const existing = await resolveTodayReport(db, gameIds, new Date(), deps.locale);
     if (existing) {
       recommendText = 'reused today picks';
       existing.weightFallbackGames = weightPlan.fallbacks.length ? weightPlan.fallbacks : undefined;
-      existing.backtestOverview = await attachBacktestOverview(db, gameIds, deps, holdoutSummaries);
+      existing.backtestOverview = await attachBacktestOverview(db, gameIds, { ...deps, locale: resolveLocale(existing.locale) }, holdoutSummaries);
       reportText = formatDailyReportText(existing, '');
     } else {
       recommendText = 'skipped (no picks available)';
@@ -141,7 +144,7 @@ export async function runLotteryPipeline(
     const report = await buildDailyReport(
       db,
       needPredict,
-      { pickCount: deps.pickCount, historyLimit: deps.historyLimit, kl8: deps.kl8 },
+      { pickCount: deps.pickCount, historyLimit: deps.historyLimit, kl8: deps.kl8, locale: deps.locale },
       new Date(),
       true,
       weightPlan.overrides,
@@ -150,7 +153,7 @@ export async function runLotteryPipeline(
     report.backtestOverview = await attachBacktestOverview(db, gameIds, deps, holdoutSummaries);
 
     if (needPredict.length < gameIds.length) {
-      const existing = await resolveTodayReport(db, gameIds);
+      const existing = await resolveTodayReport(db, gameIds, new Date(), deps.locale);
       if (existing?.picks?.length) {
         const regen = new Set(needPredict);
         report.picks = [
@@ -184,7 +187,7 @@ export async function runLotteryPipeline(
   };
 }
 
-export function formatPipelineReply(result: PipelineStepResult): string {
+export function formatPipelineReply(result: PipelineStepResult, locale?: Locale): string {
   if (result.reportText.trim()) return result.reportText.trim();
-  return '暂无推荐号码，请确认已同步开奖数据。';
+  return t(locale, 'noPicks');
 }

package/src/recommend/game-pick.ts

@@ -1,3 +1,5 @@
+import { resolveLocale, type Locale } from 'zhin.js/i18n';
+import { messages as t } from '../i18n.js';
 import { type DrawNumbers, type GameId, type GamePick, type NormalizedDraw, type ScoreWeights, type StatsSnapshot, type AccuracySnapshot } from '../types.js';
 import { getGameMeta } from '../games/registry.js';
 import { recommendKl8Groups, resolveKl8Config, type Kl8Config } from '../games/kl8-groups.js';
@@ -30,6 +32,7 @@ function poolDraws(draws: NormalizedDraw[], extract: (n: DrawNumbers) => number[
 }
 
 export interface RecommendOptions {
+  locale?: Locale;
   pickCount: number;
   tieSeed: string;
   weights?: ScoreWeights;
@@ -42,7 +45,9 @@ export function recommendGame(
   draws: NormalizedDraw[],
   options: RecommendOptions,
 ): GamePick {
+  const locale = resolveLocale(options.locale);
   const meta = getGameMeta(gameId);
+  const name = locale === 'en' ? t(locale, `game.${gameId}`) : meta.name;
   const tieSeed = `${options.tieSeed}:${gameId}`;
   const weights = options.weights ?? { freq: 0.4, omit: 0.35, trend: 0.25 };
 
@@ -55,10 +60,11 @@ export function recommendGame(
         const pick = pickTopUnique(scores, kl8.pickCount);
         const hot = scores.slice(0, 5).map((s) => s.value);
         const cold = [...scores].reverse().slice(0, 5).map((s) => s.value);
-        const pro = computeProMetrics(gameId, pick, draws, weights, 1, 80, 40);
+        const pro = computeProMetrics(gameId, pick, draws, weights, 1, 80, 40, locale);
         return {
           gameId,
-          label: `${meta.name}（选${pick.length}）`,
+          locale,
+          label: t(locale, 'pickLabel', { name, count: pick.length }),
           numbers: { main: pick },
           weights,
           stats: buildSnapshot(
@@ -66,7 +72,7 @@ export function recommendGame(
             draws,
             hot,
             cold,
-            `频率+遗漏+趋势 | 和值${pro.sum} 跨度${pro.span}`,
+            t(locale, 'basicDetail', { sum: pro.sum, span: pro.span }),
             pro,
             options.accuracy,
             weights,
@@ -79,15 +85,17 @@ export function recommendGame(
         strategies: kl8.groupStrategies,
         tieSeed,
         baseWeights: weights,
+        locale,
       });
       const primary = multi.groups[0]?.numbers ?? [];
       const hot = multi.scores.slice(0, 5).map((s) => s.value);
       const cold = [...multi.scores].reverse().slice(0, 5).map((s) => s.value);
-      const pro = computeProMetrics(gameId, primary, draws, weights, 1, 80, 40);
+      const pro = computeProMetrics(gameId, primary, draws, weights, 1, 80, 40, locale);
       const strategyNote = multi.groups.map((g) => g.label).join('/');
       return {
         gameId,
-        label: `${meta.name}（选${kl8.pickCount}·${multi.groups.length}组）`,
+          locale,
+        label: t(locale, 'pickGroupsLabel', { name, count: kl8.pickCount, groups: multi.groups.length }),
         numbers: { main: primary },
         weights,
         kl8Groups: multi.groups,
@@ -96,7 +104,7 @@ export function recommendGame(
           draws,
           hot,
           cold,
-          `多策略 ${strategyNote} | 和值${pro.sum} 跨度${pro.span}`,
+          t(locale, 'multiDetail', { strategies: strategyNote, sum: pro.sum, span: pro.span }),
           pro,
           options.accuracy,
           weights,
@@ -110,10 +118,11 @@ export function recommendGame(
       const blueScores = scorePool(blueRows, 1, 16, `${tieSeed}:blue`, weights);
       const red = pickTopUnique(redScores, 6);
       const blue = pickTopUnique(blueScores, 1);
-      const pro = computeProMetrics(gameId, red, draws, weights, 1, 33, 17);
+      const pro = computeProMetrics(gameId, red, draws, weights, 1, 33, 17, locale);
       return {
         gameId,
-        label: meta.name,
+          locale,
+        label: name,
         numbers: { red, blue },
         weights,
         stats: buildSnapshot(
@@ -121,7 +130,7 @@ export function recommendGame(
           draws,
           redScores.slice(0, 5).map((s) => s.value),
           redScores.slice(-5).map((s) => s.value),
-          `红球 ${pro.oddEven} ${pro.bigSmall} | 蓝 ${blue.map(pad2).join(' ')}`,
+          t(locale, 'redDetail', { oddEven: pro.oddEven, bigSmall: pro.bigSmall, blue: blue.map(pad2).join(' ') }),
           pro,
           options.accuracy,
           weights,
@@ -135,10 +144,11 @@ export function recommendGame(
       const backScores = scorePool(backRows, 1, 12, `${tieSeed}:back`, weights);
       const front = pickTopUnique(frontScores, 5);
       const back = pickTopUnique(backScores, 2);
-      const pro = computeProMetrics(gameId, front, draws, weights, 1, 35, 18);
+      const pro = computeProMetrics(gameId, front, draws, weights, 1, 35, 18, locale);
       return {
         gameId,
-        label: meta.name,
+          locale,
+        label: name,
         numbers: { front, back },
         weights,
         stats: buildSnapshot(
@@ -146,7 +156,7 @@ export function recommendGame(
           draws,
           frontScores.slice(0, 5).map((s) => s.value),
           frontScores.slice(-5).map((s) => s.value),
-          `前区 ${pro.oddEven} ${pro.zones ?? ''}`.trim(),
+          t(locale, 'frontDetail', { oddEven: pro.oddEven, zones: pro.zones ?? '' }).trim(),
           pro,
           options.accuracy,
           weights,
@@ -157,10 +167,11 @@ export function recommendGame(
     case 'pl3': {
       const rows = poolDraws(draws, (n) => n.digits ?? []);
       const digits = scoreDigits(rows, 3, tieSeed, weights);
-      const pro = computeDigitProMetrics(digits, draws, weights);
+      const pro = computeDigitProMetrics(digits, draws, weights, locale);
       return {
         gameId,
-        label: meta.name,
+          locale,
+        label: name,
         numbers: { digits },
         weights,
         stats: buildSnapshot(
@@ -168,7 +179,7 @@ export function recommendGame(
           draws,
           digits,
           [],
-          `直选 ${pro.digitPos} | 和值${pro.sum}`,
+          t(locale, 'digitDetail', { positions: pro.digitPos ?? '', sum: pro.sum }),
           pro,
           options.accuracy,
           weights,
@@ -178,10 +189,11 @@ export function recommendGame(
     case 'pl5': {
       const rows = poolDraws(draws, (n) => n.digits ?? []);
       const digits = scoreDigits(rows, 5, tieSeed, weights);
-      const pro = computeDigitProMetrics(digits, draws, weights);
+      const pro = computeDigitProMetrics(digits, draws, weights, locale);
       return {
         gameId,
-        label: meta.name,
+          locale,
+        label: name,
         numbers: { digits },
         weights,
         stats: buildSnapshot(
@@ -189,7 +201,7 @@ export function recommendGame(
           draws,
           digits,
           [],
-          `直选 ${pro.digitPos} | 和值${pro.sum}`,
+          t(locale, 'digitDetail', { positions: pro.digitPos ?? '', sum: pro.sum }),
           pro,
           options.accuracy,
           weights,
@@ -201,36 +213,36 @@ export function recommendGame(
   }
 }
 
-export function formatPickLine(pick: GamePick): string {
+export function formatPickLine(pick: GamePick, locale: Locale = resolveLocale(pick.locale)): string {
   const n = pick.numbers;
   switch (pick.gameId) {
     case 'kl8': {
       if (pick.kl8Groups?.length) {
         const header = `■ ${pick.label}`;
         const rows = pick.kl8Groups.map(
-          (g) => `  组${g.index}·${g.label}：${g.numbers.map(pad2).join(' ')}`,
+          (g) => t(locale, 'groupLine', { index: g.index, label: g.label, numbers: g.numbers.map(pad2).join(' ') }),
         );
         return [header, ...rows].join('\n');
       }
-      return `■ ${pick.label}：${(n.main ?? []).map(pad2).join(' ')}`;
+      return t(locale, 'pickLine', { label: pick.label, numbers: (n.main ?? []).map(pad2).join(' ') });
     }
     case 'ssq':
-      return `■ ${pick.label}：红 ${(n.red ?? []).map(pad2).join(' ')} + 蓝 ${(n.blue ?? []).map(pad2).join(' ')}`;
+      return t(locale, 'redLine', { label: pick.label, red: (n.red ?? []).map(pad2).join(' '), blue: (n.blue ?? []).map(pad2).join(' ') });
     case 'dlt':
-      return `■ ${pick.label}：前 ${(n.front ?? []).map(pad2).join(' ')} + 后 ${(n.back ?? []).map(pad2).join(' ')}`;
+      return t(locale, 'frontLine', { label: pick.label, front: (n.front ?? []).map(pad2).join(' '), back: (n.back ?? []).map(pad2).join(' ') });
     case 'fc3d':
     case 'pl3':
     case 'pl5':
-      return `■ ${pick.label}：${(n.digits ?? []).join(' ')}`;
+      return t(locale, 'pickLine', { label: pick.label, numbers: (n.digits ?? []).join(' ') });
     default:
       return `■ ${pick.label}`;
   }
 }
 
-export function formatPickStats(pick: GamePick): string {
+export function formatPickStats(pick: GamePick, locale: Locale = resolveLocale(pick.locale)): string {
   const parts: string[] = [];
-  const hot = pick.stats.hot.length ? `热号 ${pick.stats.hot.join(',')}` : '';
-  const cold = pick.stats.cold.length ? `冷号 ${pick.stats.cold.join(',')}` : '';
+  const hot = pick.stats.hot.length ? t(locale, 'hot', { numbers: pick.stats.hot.join(',') }) : '';
+  const cold = pick.stats.cold.length ? t(locale, 'cold', { numbers: pick.stats.cold.join(',') }) : '';
   if (hot) parts.push(hot);
   if (cold) parts.push(cold);
   if (pick.stats.pro) {
@@ -241,7 +253,7 @@ export function formatPickStats(pick: GamePick): string {
   }
   if (pick.stats.accuracy) {
     const a = pick.stats.accuracy;
-    parts.push(`历史命中 ${(a.avgHitRate * 100).toFixed(1)}% (${a.evalCount}期) 近5期 ${a.recent5}`);
+    parts.push(t(locale, 'accuracy', { rate: (a.avgHitRate * 100).toFixed(1), count: a.evalCount, recent: a.recent5 }));
   }
   parts.push(pick.stats.detail);
   return `  ${parts.filter(Boolean).join('\n  ')}`;

package/src/recommend/report.ts

@@ -1,4 +1,6 @@
-import { DEFAULT_WEIGHTS, DISCLAIMER, type DailyReport, type DrawNumbers, type GameId, type GamePick, type ScoreWeights } from '../types.js';
+import { resolveLocale, type Locale } from 'zhin.js/i18n';
+import { messages as t } from '../i18n.js';
+import { DEFAULT_WEIGHTS, type DailyReport, type DrawNumbers, type GameId, type GamePick, type ScoreWeights } from '../types.js';
 
 import { recommendGame, formatPickLine, formatPickStats } from './game-pick.js';
 import { resolveKl8Config, type Kl8Config } from '../games/kl8-groups.js';
@@ -8,6 +10,7 @@ import { loadDraws, REPORTS_TABLE, parseStoredJson, type LotteryDb } from '../db
 import { listPendingPredictions, loadAccuracySnapshot, loadGameWeights, savePrediction } from '../evaluate/tracker.js';
 
 export interface LotteryConfigSlice {
+  locale?: Locale;
   pickCount: number;
   historyLimit: number;
   kl8?: Kl8Config;
@@ -31,6 +34,7 @@ export async function buildDailyReport(
     const accuracy = await loadAccuracySnapshot(db, gameId);
     const kl8 = config.kl8 ?? resolveKl8Config(config.pickCount);
     const pick = recommendGame(gameId, draws, {
+      locale: config.locale,
       pickCount: gameId === 'kl8' ? kl8.pickCount : config.pickCount,
       tieSeed,
       weights,
@@ -46,28 +50,30 @@ export async function buildDailyReport(
     .join(' | ');
   return {
     date: dateStr,
+    locale: resolveLocale(config.locale),
     picks,
-    disclaimer: DISCLAIMER,
+    disclaimer: t(config.locale, 'disclaimer'),
     accuracyOverview: accuracyOverview || undefined,
   };
 }
 
 export function formatDailyReportText(report: DailyReport, aiExplanation?: string): string {
+  const locale = resolveLocale(report.locale);
   if (report.body?.trim()) {
     const extra = aiExplanation?.trim();
     return extra ? `${report.body.trim()}\n\n${extra}` : report.body.trim();
   }
-  const lines = [`【彩票每日推荐】${report.date}`, ''];
+  const lines = [t(locale, 'dailyTitle', { date: report.date }), ''];
   if (report.backtestOverview?.trim()) {
     lines.push(report.backtestOverview.trim());
     lines.push('');
   }
   if (report.weightFallbackGames?.length) {
-    lines.push(`【权重保护】近端 holdout 调优未跑赢随机，已回退默认 F40/O35/T25：${report.weightFallbackGames.join(', ')}`);
+    lines.push(t(locale, 'weightFallback', { games: report.weightFallbackGames.join(', ') }));
     lines.push('');
   }
   if (report.accuracyOverview) {
-    lines.push(`【模型复盘】累计平均命中 ${report.accuracyOverview}`);
+    lines.push(t(locale, 'accuracyOverview', { overview: report.accuracyOverview }));
     lines.push('');
   }
   for (const pick of report.picks) {
@@ -79,7 +85,7 @@ export function formatDailyReportText(report: DailyReport, aiExplanation?: strin
     lines.push(aiExplanation.trim());
     lines.push('');
   } else {
-    lines.push('【统计说明】号码由频率+遗漏+近期趋势综合打分，并根据历史命中自动调权。');
+    lines.push(t(locale, 'statsExplanation'));
     lines.push('');
   }
   lines.push(report.disclaimer);
@@ -128,6 +134,7 @@ export async function loadTodayPendingPicks(
   db: LotteryDb,
   gameIds: GameId[],
   date = new Date(),
+  locale?: Locale,
 ): Promise<GamePick[]> {
   const today = date.toISOString().slice(0, 10);
   const picks: GamePick[] = [];
@@ -139,6 +146,7 @@ export async function loadTodayPendingPicks(
     }>;
     for (const row of pending.filter((p) => p.predict_date === today)) {
       picks.push({
+        locale: resolveLocale(locale),
         gameId,
         label: gameId,
         numbers: parseStoredJson<DrawNumbers>(row.numbers, {}),
@@ -155,15 +163,17 @@ export async function resolveTodayReport(
   db: LotteryDb,
   gameIds: GameId[],
   date = new Date(),
+  locale?: Locale,
 ): Promise<DailyReport | null> {
   const saved = await loadTodayReport(db, date);
   if (saved) return saved;
-  const picks = await loadTodayPendingPicks(db, gameIds, date);
+  const picks = await loadTodayPendingPicks(db, gameIds, date, locale);
   if (!picks.length) return null;
   return {
     date: date.toISOString().slice(0, 10),
+    locale: resolveLocale(locale),
     picks,
-    disclaimer: DISCLAIMER,
+    disclaimer: t(locale, 'disclaimer'),
   };
 }