@zhin.js/plugin-lottery 1.0.0

package/src/index.ts

@@ -0,0 +1,216 @@
+/**
+ * @zhin.js/plugin-lottery — scheduled pipeline: sync → review → recommend → push
+ */
+import { formatCompact, MessageCommand, Schema, usePlugin } from 'zhin.js';
+import type { GameId } from './types.js';
+import { parseGameId, resolveEnabledGames } from './games/registry.js';
+import {
+  defineLotteryTables,
+  loadDraws,
+  type LotteryDb,
+} from './db.js';
+import {
+  formatDailyReportText,
+  loadTodayReport,
+} from './recommend/report.js';
+import { recommendGame, formatPickLine, formatPickStats } from './recommend/game-pick.js';
+import {
+  loadAccuracySnapshot,
+  loadGameWeights,
+} from './evaluate/tracker.js';
+import { setLotteryAgentDeps } from './lottery-agent-deps.js';
+import { formatPipelineReply, runLotteryPipeline } from './pipeline.js';
+import { formatBacktestSection, formatTrainReport, runBacktestForGames, trainAllGameWeights } from './evaluate/backtest.js';
+import { resolveKl8Config, type Kl8ConfigInput } from './games/kl8-groups.js';
+
+const plugin = usePlugin();
+const { logger, addCommand, useContext, onDispose, declareConfig } = plugin;
+
+const config = declareConfig(
+  'lottery',
+  Schema.object({
+    pickCount: Schema.number().default(5).min(1).max(10).description('KL8 pick count'),
+    scheduleCron: Schema.string().default('0 0 18 * * *').description('Daily pipeline cron (sync→review→recommend→push)'),
+    historyLimit: Schema.number().default(500).min(50).max(2000).description('Max draws kept per game'),
+    scheduleEnabled: Schema.boolean().default(true).description('Enable scheduled pipeline'),
+    agentEnabled: Schema.boolean().default(true).description('AI narrative on daily report (optional)'),
+    backtestEnabled: Schema.boolean().default(true).description('Walk-forward backtest vs random baseline in report'),
+    backtestWindow: Schema.number().default(50).min(10).max(300).description('Backtest periods per game'),
+    backtestRandomTrials: Schema.number().default(64).min(10).max(500).description('Monte Carlo random trials per period'),
+    backtestMinHistory: Schema.number().default(30).min(10).max(150).description('Min history before walk-forward'),
+    backtestAdaptive: Schema.boolean().default(true).description('Per-period weight tuning in backtest simulation'),
+    weightPersistEnabled: Schema.boolean().default(true).description('Persist simulated F/O/T weights to lottery_model_weights'),
+    weightHoldoutFallback: Schema.boolean().default(true).description('Use DEFAULT weights when holdout adaptive loses to random'),
+    kl8: Schema.object({
+      pickCount: Schema.number().default(5).min(1).max(10).description('Numbers per KL8 group (选N)'),
+      recommendGroups: Schema.number().default(3).min(1).max(10).description('KL8 recommendation rows per day'),
+      groupStrategies: Schema.list(Schema.string()).default(['balanced', 'hot', 'cold']),
+    }).description('KL8 multi-strategy groups'),
+    games: Schema.list(Schema.string()).default(['kl8', 'ssq', 'dlt', 'fc3d', 'pl3', 'pl5']),
+  }),
+);
+
+let _db: LotteryDb | null = null;
+
+function getDb(): LotteryDb | null {
+  return _db;
+}
+
+function enabledGames(): GameId[] {
+  return resolveEnabledGames(config.games as string[]);
+}
+
+function pipelineDeps() {
+  const kl8 = resolveKl8Config(config.pickCount, config.kl8 as Kl8ConfigInput | undefined);
+  return {
+    getDb,
+    plugin,
+    enabledGames,
+    historyLimit: config.historyLimit,
+    pickCount: config.pickCount,
+    kl8,
+    agentEnabled: config.agentEnabled,
+    backtest: {
+      enabled: config.backtestEnabled,
+      window: config.backtestWindow,
+      randomTrials: config.backtestRandomTrials,
+      minHistory: config.backtestMinHistory,
+      adaptive: config.backtestAdaptive,
+    },
+    weightPersist: config.weightPersistEnabled,
+    weightHoldoutFallback: config.weightHoldoutFallback,
+  };
+}
+
+function refreshLotteryAgentDeps(): void {
+  setLotteryAgentDeps({
+    getDb: () => _db,
+    getConfig: () => ({
+      pickCount: config.pickCount,
+      historyLimit: config.historyLimit,
+      kl8: resolveKl8Config(config.pickCount, config.kl8 as Kl8ConfigInput | undefined),
+    }),
+    plugin,
+    enabledGames,
+    scheduleCron: () => config.scheduleCron,
+    scheduleEnabled: () => config.scheduleEnabled,
+    pipelinePush: true,
+  });
+}
+
+refreshLotteryAgentDeps();
+
+useContext('database', (db: unknown) => {
+  const d = db as { define: (n: string, s: Record<string, unknown>) => void };
+  defineLotteryTables(d);
+  _db = db as LotteryDb;
+  refreshLotteryAgentDeps();
+  logger.debug(formatCompact({ op: 'lottery-ready', schedule: config.scheduleEnabled }));
+});
+
+onDispose(() => {});
+
+// ─── Commands ───────────────────────────────────────────────────────────────
+
+addCommand(
+  new MessageCommand('lottery [game:word]')
+    .desc('Run full pipeline: sync → review → recommend (manual, no push)')
+    .action(async (_msg, result) => {
+      const gid = parseGameId(result.params.game ?? '');
+      const out = await runLotteryPipeline(pipelineDeps(), { gameId: gid ?? undefined, push: false });
+      return formatPipelineReply(out);
+    }),
+);
+
+addCommand(
+  new MessageCommand('lottery-train [game:word]')
+    .desc('Full-history weight training: predict→compare→tune from DEFAULT, persist to DB')
+    .action(async (_msg, result) => {
+      const db = getDb();
+      if (!db) return '数据库未就绪';
+      const gid = parseGameId(result.params.game ?? '');
+      const gameIds = gid ? [gid] : enabledGames();
+      const results = await trainAllGameWeights(db, gameIds, {
+        pickCount: config.pickCount,
+        minHistory: config.backtestMinHistory,
+        historyLimit: config.historyLimit,
+        randomTrials: config.backtestRandomTrials,
+        holdoutWindow: config.backtestWindow,
+        holdoutFallback: config.weightHoldoutFallback,
+        persist: true,
+      });
+      return formatTrainReport(results);
+    }),
+);
+
+addCommand(
+  new MessageCommand('lottery-backtest [game:word]')
+    .desc('Walk-forward backtest: strategy vs random baseline (no betting)')
+    .action(async (_msg, result) => {
+      const db = getDb();
+      if (!db) return '数据库未就绪';
+      const gid = parseGameId(result.params.game ?? '');
+      const gameIds = gid ? [gid] : enabledGames();
+      const summaries = await runBacktestForGames(db, gameIds, {
+        pickCount: config.pickCount,
+        window: config.backtestWindow,
+        randomTrials: config.backtestRandomTrials,
+        minHistory: config.backtestMinHistory,
+        historyLimit: config.historyLimit,
+        adaptive: config.backtestAdaptive,
+      });
+      const text = formatBacktestSection(summaries);
+      return text || '历史数据不足，请先执行 lottery 同步开奖';
+    }),
+);
+
+addCommand(
+  new MessageCommand('lottery-today')
+    .desc('Show today published recommendation report')
+    .action(async () => {
+      const db = getDb();
+      if (!db) return '数据库未就绪';
+      const report = await loadTodayReport(db);
+      if (!report) return '今日尚无推荐，可执行 lottery 或等待定时任务';
+      return formatDailyReportText(report, '');
+    }),
+);
+
+addCommand(
+  new MessageCommand('lottery-stats <game:word>')
+    .desc('Single-game stats snapshot (code engine)')
+    .action(async (_msg, result) => {
+      const gid = parseGameId(result.params.game ?? '');
+      if (!gid) return '请指定玩法';
+      const db = getDb();
+      if (!db) return '数据库未就绪';
+      const draws = await loadDraws(db, gid, config.historyLimit);
+      if (!draws.length) return '暂无数据，请先 lottery';
+      const kl8 = resolveKl8Config(config.pickCount, config.kl8 as Kl8ConfigInput | undefined);
+      const pick = recommendGame(gid, draws, {
+        pickCount: gid === 'kl8' ? kl8.pickCount : config.pickCount,
+        tieSeed: 'stats',
+        weights: await loadGameWeights(db, gid),
+        accuracy: await loadAccuracySnapshot(db, gid),
+        kl8: gid === 'kl8' ? kl8 : undefined,
+      });
+      return [formatPickLine(pick), formatPickStats(pick), `样本 ${draws.length} 期`].join('\n');
+    }),
+);
+
+addCommand(
+  new MessageCommand('lottery-history <game:word> [count:number=10]')
+    .desc('List historical draw results')
+    .action(async (_msg, result) => {
+      const gid = parseGameId(result.params.game ?? '');
+      if (!gid) return '请指定玩法';
+      const db = getDb();
+      if (!db) return '数据库未就绪';
+      const count = Math.min(50, Math.max(1, Number(result.params.count) || 10));
+      const draws = await loadDraws(db, gid, count);
+      if (!draws.length) return '暂无数据';
+      return draws.map((d) => `${d.issue} ${d.drawTime} ${JSON.stringify(d.numbers)}`).join('\n');
+    }),
+);
+
+export default plugin;

package/src/lottery-agent-deps.ts

@@ -0,0 +1,29 @@
+/**
+ * Shared runtime deps for lottery agent/ authoring tools.
+ * Set once from plugin index during init — never call getPlugin() from tool execute.
+ */
+import type { Plugin } from 'zhin.js';
+import type { GameId } from './types.js';
+import type { LotteryDb } from './db.js';
+import type { Kl8Config } from './games/kl8-groups.js';
+
+export interface LotteryAgentDeps {
+  getDb: () => LotteryDb | null;
+  getConfig: () => { pickCount: number; historyLimit: number; kl8: Kl8Config };
+  plugin: Plugin;
+  enabledGames: () => GameId[];
+  scheduleCron: () => string;
+  scheduleEnabled: () => boolean;
+  pipelinePush: boolean;
+}
+
+let _deps: LotteryAgentDeps | null = null;
+
+export function setLotteryAgentDeps(deps: LotteryAgentDeps): void {
+  _deps = deps;
+}
+
+export function getLotteryAgentDeps(): LotteryAgentDeps {
+  if (!_deps) throw new Error('lottery agent deps not initialized');
+  return _deps;
+}

package/src/lottery-tool-handlers.ts

@@ -0,0 +1,166 @@
+import { DISCLAIMER, type GameId } from './types.js';
+
+import { parseGameId } from './games/registry.js';
+import { loadDraws } from './db.js';
+import { recommendGame } from './recommend/game-pick.js';
+import {
+  loadGameWeights,
+  saveGameWeights,
+  loadAccuracySnapshot,
+  savePrediction,
+  listPendingPredictions,
+  submitAgentReview,
+  saveAgentMemory,
+  loadAgentMemory,
+} from './evaluate/tracker.js';
+import { saveDailyReport } from './recommend/report.js';
+import { pushTextToMasters } from './push.js';
+import { normalizeWeights } from './stats/weights.js';
+import { getLotteryAgentDeps } from './lottery-agent-deps.js';
+
+export async function handleGetModelState(game?: string): Promise<string> {
+  const deps = getLotteryAgentDeps();
+  const db = deps.getDb();
+  if (!db) return 'db not ready';
+  const gid = parseGameId(game ?? '');
+  const ids: GameId[] = gid ? [gid] : deps.enabledGames();
+  const out = [];
+  for (const id of ids) {
+    const w = await loadGameWeights(db, id);
+    const acc = await loadAccuracySnapshot(db, id);
+    out.push({ gameId: id, weights: w, accuracy: acc ?? null });
+  }
+  return JSON.stringify(out);
+}
+
+export async function handleComputeRecommend(game: string): Promise<string> {
+  const deps = getLotteryAgentDeps();
+  const gid = parseGameId(game);
+  if (!gid) return 'invalid game';
+  const db = deps.getDb();
+  if (!db) return 'db not ready';
+  const cfg = deps.getConfig();
+  const draws = await loadDraws(db, gid, cfg.historyLimit);
+  if (!draws.length) return 'no data, run lottery_sync first';
+  const pick = recommendGame(gid, draws, {
+    pickCount: gid === 'kl8' ? cfg.kl8.pickCount : cfg.pickCount,
+    tieSeed: new Date().toISOString().slice(0, 10),
+    weights: await loadGameWeights(db, gid),
+    accuracy: await loadAccuracySnapshot(db, gid),
+    kl8: gid === 'kl8' ? cfg.kl8 : undefined,
+  });
+  return JSON.stringify(pick);
+}
+
+export async function handleSavePrediction(game: string, numbersJson: string): Promise<string> {
+  const deps = getLotteryAgentDeps();
+  const gid = parseGameId(game);
+  if (!gid) return 'invalid game';
+  const db = deps.getDb();
+  if (!db) return 'db not ready';
+  const numbers = JSON.parse(numbersJson);
+  const weights = await loadGameWeights(db, gid);
+  await savePrediction(db, {
+    gameId: gid,
+    label: gid,
+    numbers,
+    weights,
+    stats: { gameId: gid, sampleSize: 0, hot: [], cold: [], detail: '' },
+  });
+  return JSON.stringify({ ok: true, gameId: gid });
+}
+
+export async function handleListPending(game?: string): Promise<string> {
+  const deps = getLotteryAgentDeps();
+  const db = deps.getDb();
+  if (!db) return 'db not ready';
+  const gid = parseGameId(game ?? '');
+  return JSON.stringify(await listPendingPredictions(db, gid ?? undefined));
+}
+
+export async function handleSubmitReview(input: {
+  game: string;
+  predict_at: string;
+  actual_issue: string;
+  actual_numbers_json: string;
+  analysis: string;
+}): Promise<string> {
+  const deps = getLotteryAgentDeps();
+  const gid = parseGameId(input.game);
+  if (!gid) return 'invalid game';
+  const db = deps.getDb();
+  if (!db) return 'db not ready';
+  const hit = await submitAgentReview(
+    db,
+    {
+      gameId: gid,
+      predictAt: input.predict_at,
+      actualIssue: input.actual_issue,
+      actualNumbers: JSON.parse(input.actual_numbers_json),
+      analysis: input.analysis ?? '',
+    },
+    deps.getConfig().historyLimit,
+  );
+  return hit ? JSON.stringify(hit) : 'pending not found';
+}
+
+export async function handleSetWeights(game: string, freq: number, omit: number, trend: number): Promise<string> {
+  const deps = getLotteryAgentDeps();
+  const gid = parseGameId(game);
+  if (!gid) return 'invalid game';
+  const db = deps.getDb();
+  if (!db) return 'db not ready';
+  const w = normalizeWeights({ freq, omit, trend });
+  const snap = await loadAccuracySnapshot(db, gid);
+  await saveGameWeights(db, gid, w, snap?.evalCount ?? 0, snap?.avgHitRate ?? 0);
+  return JSON.stringify({ ok: true, weights: w });
+}
+
+export async function handleSaveMemory(content: string, memoryType?: string, game?: string): Promise<string> {
+  const deps = getLotteryAgentDeps();
+  const db = deps.getDb();
+  if (!db) return 'db not ready';
+  const gid = parseGameId(game ?? '');
+  await saveAgentMemory(db, content, memoryType || 'insight', gid ?? '');
+  return JSON.stringify({ ok: true });
+}
+
+export async function handleGetMemory(game?: string, limit?: number): Promise<string> {
+  const deps = getLotteryAgentDeps();
+  const db = deps.getDb();
+  if (!db) return 'db not ready';
+  const gid = parseGameId(game ?? '');
+  const lim = Math.min(50, limit || 20);
+  return JSON.stringify(await loadAgentMemory(db, gid ?? undefined, lim));
+}
+
+export async function handlePublishReport(content: string, push?: boolean): Promise<string> {
+  const deps = getLotteryAgentDeps();
+  const db = deps.getDb();
+  if (!db) return 'db not ready';
+  const text = content.trim();
+  if (!text.includes(DISCLAIMER)) return 'content must include disclaimer';
+  const date = new Date().toISOString().slice(0, 10);
+  await saveDailyReport(db, { date, picks: [] as never[], disclaimer: DISCLAIMER, body: text }, text);
+  const doPush = push === true;
+  if (doPush) await pushTextToMasters(deps.plugin, text);
+  return JSON.stringify({ ok: true, date, pushed: doPush });
+}
+
+export async function handleStatsSnapshot(game: string): Promise<string> {
+  const deps = getLotteryAgentDeps();
+  const gid = parseGameId(game);
+  if (!gid) return 'invalid game';
+  const db = deps.getDb();
+  if (!db) return 'db not ready';
+  const cfg = deps.getConfig();
+  const draws = await loadDraws(db, gid, Math.min(30, cfg.historyLimit));
+  const pick = recommendGame(gid, draws, {
+    pickCount: gid === 'kl8' ? cfg.kl8.pickCount : cfg.pickCount,
+    tieSeed: 'snapshot',
+    weights: await loadGameWeights(db, gid),
+    accuracy: await loadAccuracySnapshot(db, gid),
+    kl8: gid === 'kl8' ? cfg.kl8 : undefined,
+  });
+  return JSON.stringify({ sample: draws.length, pick, recentDraws: draws.slice(0, 5) });
+}

package/src/pipeline.ts

@@ -0,0 +1,206 @@
+import type { Plugin } from 'zhin.js';
+import type { GameId } from './types.js';
+import { syncGame, type LotteryDb } from './db.js';
+
+import {
+  buildDailyReport,
+  explainReportWithAi,
+  formatDailyReportText,
+  hydrateReportPickWeights,
+  resolveTodayReport,
+  saveDailyReport,
+} from './recommend/report.js';
+import { evaluatePendingPredictions, gamesNeedingPrediction } from './evaluate/review-pending.js';
+import { formatBacktestSection, refreshWeightsForGames, runBacktestForGames } from './evaluate/backtest.js';
+import {
+  planRecommendWeights,
+  gamesToPredict,
+  runHoldoutBacktest,
+} from './evaluate/weight-guard.js';
+import { cancelTodayPendingPredictions } from './evaluate/tracker.js';
+import { pushTextToMasters } from './push.js';
+import type { Kl8Config } from './games/kl8-groups.js';
+
+export interface PipelineDeps {
+  getDb: () => LotteryDb | null;
+  plugin: Plugin;
+  enabledGames: () => GameId[];
+  historyLimit: number;
+  pickCount: number;
+  kl8: Kl8Config;
+  agentEnabled: boolean;
+  backtest: {
+    enabled: boolean;
+    window: number;
+    randomTrials: number;
+    minHistory: number;
+    adaptive: boolean;
+  };
+  weightPersist: boolean;
+  weightHoldoutFallback: boolean;
+}
+
+function backtestOpts(deps: PipelineDeps) {
+  return {
+    pickCount: deps.pickCount,
+    window: deps.backtest.window,
+    randomTrials: deps.backtest.randomTrials,
+    minHistory: deps.backtest.minHistory,
+    historyLimit: deps.historyLimit,
+    adaptive: deps.backtest.adaptive,
+  };
+}
+
+async function attachBacktestOverview(
+  db: LotteryDb,
+  gameIds: GameId[],
+  deps: PipelineDeps,
+  holdoutSummaries: import('./evaluate/adaptive-sim.js').SimulationResult[] = [],
+): Promise<string> {
+  if (!deps.backtest.enabled || deps.backtest.window <= 0) return '';
+  const summaries = holdoutSummaries.length
+    ? holdoutSummaries
+    : await runBacktestForGames(db, gameIds, backtestOpts(deps));
+  return formatBacktestSection(summaries);
+}
+
+export interface PipelineOptions {
+  gameId?: GameId;
+  push?: boolean;
+}
+
+export interface PipelineStepResult {
+  sync: string;
+  review: string;
+  recommend: string;
+  pushed: boolean;
+  reportText: string;
+}
+
+export async function runLotteryPipeline(
+  deps: PipelineDeps,
+  options: PipelineOptions = {},
+): Promise<PipelineStepResult> {
+  const db = deps.getDb();
+  if (!db) {
+    return {
+      sync: 'db not ready',
+      review: 'skipped',
+      recommend: 'skipped',
+      pushed: false,
+      reportText: '数据库未就绪',
+    };
+  }
+
+  const gameIds = options.gameId ? [options.gameId] : deps.enabledGames();
+  const syncParts: string[] = [];
+  const insertedAll = [];
+
+  for (const id of gameIds) {
+    try {
+      const { count, inserted } = await syncGame(db, id, deps.historyLimit);
+      syncParts.push(`${id}:+${count}`);
+      insertedAll.push(...inserted);
+    } catch {
+      syncParts.push(`${id}:err`);
+    }
+  }
+
+  const reviewResult = await evaluatePendingPredictions(
+    db,
+    gameIds,
+    deps.historyLimit,
+    insertedAll,
+  );
+  const reviewText = reviewResult.skipped
+    ? 'skipped (no pending)'
+    : reviewResult.lines.length
+      ? reviewResult.lines.join('; ')
+      : 'no match';
+
+  await refreshWeightsForGames(db, gameIds, {
+    ...backtestOpts(deps),
+    persist: deps.weightPersist,
+    reviewEvaluated: reviewResult.evaluated,
+    holdoutWindow: deps.backtest.window,
+    holdoutFallback: deps.weightHoldoutFallback,
+  });
+
+  const holdoutSummaries = deps.backtest.enabled && deps.backtest.window > 0
+    ? await runHoldoutBacktest(db, gameIds, backtestOpts(deps))
+    : [];
+
+  const missingToday = await gamesNeedingPrediction(db, gameIds);
+  const weightPlan = planRecommendWeights(gameIds, holdoutSummaries, deps.weightHoldoutFallback);
+  for (const gid of weightPlan.fallbacks) {
+    if (!missingToday.includes(gid)) await cancelTodayPendingPredictions(db, gid);
+  }
+  const needPredict = gamesToPredict(gameIds, missingToday, weightPlan);
+
+  let reportText = '';
+  let recommendText: string;
+
+  if (!needPredict.length) {
+    const existing = await resolveTodayReport(db, gameIds);
+    if (existing) {
+      recommendText = 'reused today picks';
+      existing.weightFallbackGames = weightPlan.fallbacks.length ? weightPlan.fallbacks : undefined;
+      existing.backtestOverview = await attachBacktestOverview(db, gameIds, deps, holdoutSummaries);
+      reportText = formatDailyReportText(existing, '');
+    } else {
+      recommendText = 'skipped (no picks available)';
+    }
+  } else {
+    const report = await buildDailyReport(
+      db,
+      needPredict,
+      { pickCount: deps.pickCount, historyLimit: deps.historyLimit, kl8: deps.kl8 },
+      new Date(),
+      true,
+      weightPlan.overrides,
+    );
+    report.weightFallbackGames = weightPlan.fallbacks.length ? weightPlan.fallbacks : undefined;
+    report.backtestOverview = await attachBacktestOverview(db, gameIds, deps, holdoutSummaries);
+
+    if (needPredict.length < gameIds.length) {
+      const existing = await resolveTodayReport(db, gameIds);
+      if (existing?.picks?.length) {
+        const regen = new Set(needPredict);
+        report.picks = [
+          ...existing.picks.filter((p) => !regen.has(p.gameId)),
+          ...report.picks,
+        ];
+      }
+    }
+    report.picks = await hydrateReportPickWeights(db, report.picks);
+
+    let aiNote = '';
+    if (deps.agentEnabled) {
+      aiNote = await explainReportWithAi(deps.plugin, report);
+    }
+    reportText = formatDailyReportText(report, aiNote);
+    await saveDailyReport(db, report, aiNote);
+    recommendText = weightPlan.fallbacks.some((g) => needPredict.includes(g))
+      ? `saved ${needPredict.join(', ')} (holdout fallback regen)`
+      : `saved ${needPredict.join(', ')}`;
+  }
+
+  let pushed = false;
+  if (options.push && reportText) {
+    await pushTextToMasters(deps.plugin, reportText);
+    pushed = true;
+  }
+
+  return {
+    sync: syncParts.join(', ') || 'none',
+    review: reviewText,
+    recommend: recommendText,
+    pushed,
+    reportText,
+  };
+}
+
+export function formatPipelineReply(result: PipelineStepResult): string {
+  if (result.reportText.trim()) return result.reportText.trim();
+  return '暂无推荐号码，请确认已同步开奖数据。';
+}

package/src/push.ts

@@ -0,0 +1,34 @@
+import type { Plugin } from 'zhin.js';
+
+export async function pushTextToMasters(plugin: Plugin, text: string): Promise<void> {
+  const root = plugin.root as {
+    adapters?: string[];
+    inject?: (key: string) => unknown;
+  };
+  const inject = root.inject?.bind(root);
+  if (!inject) return;
+  const adapterNames = root.adapters ?? [];
+  for (const adapterName of adapterNames) {
+    const adapter = inject(adapterName) as {
+      endpoints?: Map<string, { $config?: { master?: unknown; name?: string }; $id?: string }>;
+      sendMessage?: (opts: Record<string, unknown>) => Promise<unknown>;
+    } | null;
+    if (!adapter?.endpoints || !adapter.sendMessage) continue;
+    for (const [, endpoint] of adapter.endpoints) {
+      const master = endpoint.$config?.master;
+      if (master == null || master === '') continue;
+      const endpointId = endpoint.$id ?? endpoint.$config?.name ?? '';
+      try {
+        await adapter.sendMessage({
+          context: adapterName,
+          endpoint: endpointId,
+          type: 'private',
+          id: String(master),
+          content: text,
+        });
+      } catch (e) {
+        plugin.logger.warn(`lottery push failed: ${e instanceof Error ? e.message : String(e)}`);
+      }
+    }
+  }
+}