@openfinclaw/openfinclaw-strategy 2026.3.276 → 2026.3.310

package/index.test.ts

@@ -77,7 +77,7 @@ describe("openfinclaw plugin", () => {
       expect.objectContaining({
         path: "/plugins/openfinclaw",
         match: "prefix",
-        auth: "gateway",
+        auth: "plugin",
       }),
     );
   });
@@ -86,10 +86,12 @@ describe("openfinclaw plugin", () => {
     const { api, tools } = createFakeApi({});
     plugin.register(api);
 
-    expect(tools.size).toBeGreaterThanOrEqual(7);
+    expect(tools.size).toBeGreaterThanOrEqual(9);
     expect(tools.has("skill_publish")).toBe(true);
     expect(tools.has("skill_publish_verify")).toBe(true);
     expect(tools.has("skill_validate")).toBe(true);
+    expect(tools.has("strategy_price_monitor")).toBe(true);
+    expect(tools.has("strategy_periodic_report")).toBe(true);
   });
 
   it("skill_publish_verify returns success when API returns 200 with submissionId", async () => {

package/index.ts

@@ -8,7 +8,7 @@ import type { Command } from "commander";
  * - Dashboard: embedded HTTP server at http://127.0.0.1:<httpPort> (default 18792)
  * Supports FEP v2.0 protocol for strategy packages.
  */
-import type { OpenClawPluginApi } from "openclaw/plugin-sdk/core";
+import { definePluginEntry } from "openclaw/plugin-sdk/plugin-entry";
 import { registerStrategyCli } from "./src/cli.js";
 import { resolvePluginConfig } from "./src/config.js";
 import { registerDatahubTools } from "./src/datahub/tools.js";
@@ -20,15 +20,18 @@ import { setupOpenfinclawCronJobs } from "./src/scheduler/cron-setup.js";
 import { AggregatedNewsProvider, createNewsProviders } from "./src/scheduler/news-provider.js";
 import { registerSchedulerTools } from "./src/scheduler/tools.js";
 import { registerStrategyTools } from "./src/strategy/tools.js";
+import { setupTournamentCronJob } from "./src/tournament/cron-setup.js";
+import { TournamentDb } from "./src/tournament/db.js";
+import { buildOrchestratorPrompt } from "./src/tournament/prompts.js";
+import { registerTournamentTools } from "./src/tournament/tools.js";
 
-const openfinclawPlugin = {
+export default definePluginEntry({
   id: "openfinclaw-strategy",
   name: "OpenFinClaw",
   description:
     "Unified financial tools: strategy publishing/fork/validation, market data (price/K-line/crypto/compare/search). Single API key for Hub and DataHub.",
-  kind: "financial" as const,
 
-  register(api: OpenClawPluginApi) {
+  register(api) {
     const config = resolvePluginConfig(api);
 
     // Register DataHub market data tools (fin_price, fin_kline, fin_crypto, fin_compare, fin_slim_search)
@@ -38,7 +41,7 @@ const openfinclawPlugin = {
     // Register strategy tools (skill_publish, skill_validate, skill_fork, skill_leaderboard, etc.)
     registerStrategyTools(api, config, getDb);
 
-    // Register scheduler tools (strategy_daily_scan, strategy_scan_history)
+    // Register scheduler tools (strategy_daily_scan, strategy_price_monitor, strategy_scan_history, strategy_periodic_report)
     const newsProviders = createNewsProviders(config);
     const newsProvider = new AggregatedNewsProvider(newsProviders);
     registerSchedulerTools(api, config, getDb, newsProvider);
@@ -69,9 +72,14 @@ const openfinclawPlugin = {
       handler: createOpenFinclawGatewayProxy({ port: config.httpPort, logger: api.logger }),
     });
 
+    // Register tournament tools (tournament_pick, tournament_leaderboard, tournament_result)
+    const getTournamentDb = () => new TournamentDb(getDb());
+    registerTournamentTools(api.registerTool.bind(api), getTournamentDb);
+
     // Inject agent system prompt: prioritise tool calls so data lands in SQLite
+    const tournamentPrompt = buildOrchestratorPrompt();
     api.on("before_prompt_build", async () => ({
-      prependSystemContext: OPENFINCLAW_AGENT_GUIDANCE,
+      prependSystemContext: `${OPENFINCLAW_AGENT_GUIDANCE}\n\n${tournamentPrompt}`,
     }));
 
     // ── Gateway Cron registration ──
@@ -93,8 +101,19 @@ const openfinclawPlugin = {
             `[OpenFinClaw] Cron setup failed: ${err instanceof Error ? err.message : String(err)}`,
           );
         });
+
+      // Register tournament cron job
+      setupTournamentCronJob()
+        .then((result) => {
+          if (result.created) {
+            api.logger.info("[OpenFinClaw] Tournament cron job registered");
+          }
+        })
+        .catch((err) => {
+          api.logger.info(
+            `[OpenFinClaw] Tournament cron setup failed: ${err instanceof Error ? err.message : String(err)}`,
+          );
+        });
     }
   },
-};
-
-export default openfinclawPlugin;
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openfinclaw/openfinclaw-strategy",
-  "version": "2026.3.276",
+  "version": "2026.3.310",
   "description": "OpenFinClaw - Unified financial tools: market data (price/K-line/crypto/compare/search), strategy publishing, fork, and validation. Single API key for Hub and DataHub.",
   "keywords": [
     "backtest",

package/src/db/repositories.ts

@@ -353,22 +353,51 @@ export function updateScanHistory(
   }
 }
 
-/** Query scan history, newest first. Optionally filter by scan_type. */
+/** Query scan history, newest first. Optionally filter by scan_type and started_at lower bound (ISO 8601). */
 export function queryScanHistory(
   db: DatabaseSync,
-  opts: { scanType?: string; limit?: number; offset?: number } = {},
+  opts: {
+    scanType?: string;
+    startedAfter?: string;
+    limit?: number;
+    offset?: number;
+  } = {},
 ): ScanHistoryEntry[] {
-  const { limit = 20, offset = 0, scanType } = opts;
+  const { limit = 20, offset = 0, scanType, startedAfter } = opts;
+  const conditions: string[] = [];
+  const params: unknown[] = [];
   if (scanType) {
-    return db
-      .prepare(
-        `SELECT * FROM scan_history WHERE scan_type = ? ORDER BY started_at DESC LIMIT ? OFFSET ?`,
-      )
-      .all(scanType, limit, offset) as ScanHistoryEntry[];
+    conditions.push("scan_type = ?");
+    params.push(scanType);
+  }
+  if (startedAfter) {
+    conditions.push("started_at >= ?");
+    params.push(startedAfter);
   }
+  const where = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
+  params.push(limit, offset);
   return db
-    .prepare(`SELECT * FROM scan_history ORDER BY started_at DESC LIMIT ? OFFSET ?`)
-    .all(limit, offset) as ScanHistoryEntry[];
+    .prepare(`SELECT * FROM scan_history ${where} ORDER BY started_at DESC LIMIT ? OFFSET ?`)
+    .all(...params) as ScanHistoryEntry[];
+}
+
+/**
+ * Count scan_history rows grouped by scan_type since an inclusive time bound (ISO 8601 started_at).
+ */
+export function countScanHistoryByTypeSince(
+  db: DatabaseSync,
+  startedAfter: string,
+): Map<string, number> {
+  const rows = db
+    .prepare(
+      `SELECT scan_type, COUNT(*) AS cnt FROM scan_history WHERE started_at >= ? GROUP BY scan_type`,
+    )
+    .all(startedAfter) as Array<{ scan_type: string; cnt: number }>;
+  const map = new Map<string, number>();
+  for (const r of rows) {
+    map.set(r.scan_type, Number(r.cnt));
+  }
+  return map;
 }
 
 // ── Price Alerts ──────────────────────────────────────────────────────────
@@ -408,22 +437,40 @@ export function insertPriceAlert(db: DatabaseSync, alert: PriceAlertEntry): void
   }
 }
 
-/** Query price alerts, newest first. */
+/** Query price alerts, newest first. Optionally filter by strategy and created_at lower bound (ISO 8601). */
 export function queryPriceAlerts(
   db: DatabaseSync,
-  opts: { strategyId?: string; limit?: number; offset?: number } = {},
+  opts: {
+    strategyId?: string;
+    createdAfter?: string;
+    limit?: number;
+    offset?: number;
+  } = {},
 ): PriceAlertEntry[] {
-  const { limit = 50, offset = 0, strategyId } = opts;
+  const { limit = 50, offset = 0, strategyId, createdAfter } = opts;
+  const conditions: string[] = [];
+  const params: unknown[] = [];
   if (strategyId) {
-    return db
-      .prepare(
-        `SELECT * FROM price_alerts WHERE strategy_id = ? ORDER BY created_at DESC LIMIT ? OFFSET ?`,
-      )
-      .all(strategyId, limit, offset) as PriceAlertEntry[];
+    conditions.push("strategy_id = ?");
+    params.push(strategyId);
   }
+  if (createdAfter) {
+    conditions.push("created_at >= ?");
+    params.push(createdAfter);
+  }
+  const where = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
+  params.push(limit, offset);
   return db
-    .prepare(`SELECT * FROM price_alerts ORDER BY created_at DESC LIMIT ? OFFSET ?`)
-    .all(limit, offset) as PriceAlertEntry[];
+    .prepare(`SELECT * FROM price_alerts ${where} ORDER BY created_at DESC LIMIT ? OFFSET ?`)
+    .all(...params) as PriceAlertEntry[];
+}
+
+/** Count price_alerts rows since an inclusive time bound (ISO 8601 created_at). */
+export function countPriceAlertsSince(db: DatabaseSync, createdAfter: string): number {
+  const row = db
+    .prepare(`SELECT COUNT(*) AS cnt FROM price_alerts WHERE created_at >= ?`)
+    .get(createdAfter) as { cnt: number } | undefined;
+  return Number(row?.cnt ?? 0);
 }
 
 /** Mark a price alert as acknowledged. */

package/src/db/schema.ts

@@ -1,8 +1,9 @@
 /**
  * SQLite schema for OpenFinClaw plugin (MVP 4 tables).
- * Based on ER diagram v0.3 — openfinclaw-opc-fund-plugin.
+ * Based on ER diagram v0.3.
  */
 import type { DatabaseSync } from "node:sqlite";
+import { ensureTournamentSchema } from "../tournament/db.js";
 
 /**
  * Create (or migrate) all MVP tables.
@@ -134,6 +135,9 @@ export function ensureSchema(db: DatabaseSync): void {
   db.exec(`CREATE INDEX IF NOT EXISTS idx_price_alerts_created ON price_alerts(created_at);`);
   db.exec(`CREATE INDEX IF NOT EXISTS idx_price_alerts_strategy ON price_alerts(strategy_id);`);
 
+  // ── tournament tables ──────────────────────────────────────────────────
+  ensureTournamentSchema(db);
+
   // ── migrations (add columns to existing databases) ──────────────────────
 }
 

package/src/scheduler/periodic-report-builder.ts

@@ -0,0 +1,71 @@
+/**
+ * Markdown builder for `strategy_periodic_report` (weekly / monthly rolling windows).
+ */
+
+/** One row for the performance ranking table. */
+export interface StrategyRankRow {
+  strategyId: string;
+  strategyName: string;
+  totalReturn: number | null;
+  sharpe: number | null;
+  maxDrawdown: number | null;
+}
+
+/** Inputs collected by the tool before formatting. */
+export interface PeriodicReportPayload {
+  period: "weekly" | "monthly";
+  windowStartIso: string;
+  windowEndIso: string;
+  scanCountsByType: Map<string, number>;
+  priceAlertCount: number;
+  rankRows: StrategyRankRow[];
+}
+
+/**
+ * Format a periodic performance report as Markdown for the agent.
+ *
+ * @param payload - Aggregated stats and ranking rows for the reporting window.
+ * @returns Markdown string (zh headings, decimal returns as percent like daily scan).
+ */
+export function formatPeriodicReportMarkdown(payload: PeriodicReportPayload): string {
+  const periodLabel = payload.period === "weekly" ? "周报" : "月报";
+  const start = payload.windowStartIso.slice(0, 10);
+  const end = payload.windowEndIso.slice(0, 10);
+  const lines: string[] = [];
+
+  lines.push(`## 策略绩效${periodLabel} — ${start} ~ ${end}`);
+  lines.push("");
+
+  lines.push("### 绩效排名");
+  lines.push("");
+  lines.push("| 排名 | 策略 | 总收益 | 夏普 | 最大回撤 |");
+  lines.push("|------|------|--------|------|----------|");
+
+  const sorted = [...payload.rankRows].sort((a, b) => {
+    const ar = a.totalReturn ?? Number.NEGATIVE_INFINITY;
+    const br = b.totalReturn ?? Number.NEGATIVE_INFINITY;
+    return br - ar;
+  });
+
+  sorted.forEach((row, i) => {
+    const ret = row.totalReturn == null ? "—" : `${(row.totalReturn * 100).toFixed(2)}%`;
+    const sharpe = row.sharpe == null ? "—" : row.sharpe.toFixed(2);
+    const dd = row.maxDrawdown == null ? "—" : `${(row.maxDrawdown * 100).toFixed(2)}%`;
+    lines.push(`| ${i + 1} | ${row.strategyName} | ${ret} | ${sharpe} | ${dd} |`);
+  });
+
+  lines.push("");
+  lines.push("### 活动统计");
+  const keys = [...payload.scanCountsByType.keys()].sort();
+  if (keys.length === 0) {
+    lines.push("- （窗口内无扫描记录）");
+  } else {
+    for (const k of keys) {
+      lines.push(`- ${k}: ${payload.scanCountsByType.get(k)} 次`);
+    }
+  }
+  lines.push(`- 价格告警: ${payload.priceAlertCount} 条`);
+  lines.push("");
+
+  return lines.join("\n");
+}

package/src/scheduler/tools.ts

@@ -1,13 +1,16 @@
 /**
  * Scheduler tools registration.
- * Tools: strategy_daily_scan, strategy_scan_history
+ * Tools: strategy_daily_scan, strategy_price_monitor, strategy_scan_history, strategy_periodic_report
  */
 import { randomUUID } from "node:crypto";
 import type { DatabaseSync } from "node:sqlite";
 import { Type } from "@sinclair/typebox";
 import type { OpenClawPluginApi } from "openclaw/plugin-sdk/core";
-import { DataHubClient } from "../datahub/client.js";
+import { DataHubClient, guessMarket } from "../datahub/client.js";
 import {
+  countPriceAlertsSince,
+  countScanHistoryByTypeSince,
+  insertPriceAlert,
   insertScanHistory,
   queryBacktestResults,
   queryScanHistory,
@@ -17,6 +20,7 @@ import {
 import { withLogging } from "../middleware/with-logging.js";
 import type { UnifiedPluginConfig } from "../types.js";
 import type { AggregatedNewsProvider } from "./news-provider.js";
+import { formatPeriodicReportMarkdown } from "./periodic-report-builder.js";
 import { buildScanReport, formatScanReportMarkdown } from "./scan-report-builder.js";
 
 /** JSON tool result helper. */
@@ -191,6 +195,213 @@ export function registerSchedulerTools(
     { names: ["strategy_daily_scan"] },
   );
 
+  // ── strategy_price_monitor ──
+  api.registerTool(
+    {
+      name: "strategy_price_monitor",
+      label: "Strategy price monitor",
+      description:
+        "Check price moves for all symbols referenced by local strategies against a threshold. " +
+        "Persists alerts to SQLite. Intended for cron or manual runs.",
+      parameters: Type.Object({
+        threshold: Type.Optional(
+          Type.Number({ description: "Alert threshold in percent (default: plugin config)" }),
+        ),
+        strategyId: Type.Optional(
+          Type.String({ description: "Monitor symbols for one strategy only (default: all)" }),
+        ),
+      }),
+      execute: withLogging(
+        getDb,
+        "strategy_price_monitor",
+        "scheduler",
+        async (_toolCallId, params) => {
+          const scanId = randomUUID();
+          const now = new Date().toISOString();
+
+          insertScanHistory(getDb(), {
+            id: scanId,
+            scan_type: "price_monitor",
+            started_at: now,
+            status: "running",
+            strategies_scanned: 0,
+            news_found: 0,
+            actions_taken: 0,
+          });
+
+          try {
+            const db = getDb();
+            let strategies = queryStrategies(db);
+            if (params.strategyId) {
+              strategies = strategies.filter((s) => s.id === params.strategyId);
+            }
+            strategies = strategies.filter((s) => {
+              try {
+                const syms = JSON.parse(s.symbols ?? "[]");
+                return Array.isArray(syms) && syms.length > 0;
+              } catch {
+                return false;
+              }
+            });
+
+            if (!config.apiKey) {
+              updateScanHistory(getDb(), scanId, {
+                status: "failed",
+                completed_at: new Date().toISOString(),
+                summary: "API key not configured.",
+              });
+              return json({
+                success: false,
+                error: "API key not configured; price monitoring requires DataHub access.",
+              });
+            }
+
+            if (strategies.length === 0) {
+              updateScanHistory(getDb(), scanId, {
+                status: "completed",
+                completed_at: new Date().toISOString(),
+                strategies_scanned: 0,
+                summary: "No strategies with symbols.",
+              });
+              return {
+                content: [
+                  {
+                    type: "text" as const,
+                    text: "暂无包含标的的策略。请先配置策略 symbols 后再运行价格监控。",
+                  },
+                ],
+                details: { success: true, strategiesScanned: 0, alertCount: 0 },
+              };
+            }
+
+            const threshold =
+              params.threshold != null && Number.isFinite(Number(params.threshold))
+                ? Number(params.threshold)
+                : config.priceAlertThreshold;
+
+            type StratRef = { id: string; name: string };
+            const symbolToStrategies = new Map<string, StratRef[]>();
+            for (const s of strategies) {
+              try {
+                const syms = JSON.parse(s.symbols ?? "[]") as string[];
+                for (const sym of syms) {
+                  if (typeof sym !== "string" || !sym) continue;
+                  const list = symbolToStrategies.get(sym) ?? [];
+                  list.push({ id: s.id, name: s.name });
+                  symbolToStrategies.set(sym, list);
+                }
+              } catch {
+                /* skip */
+              }
+            }
+
+            const client = new DataHubClient(
+              config.datahubGatewayUrl,
+              config.apiKey,
+              config.requestTimeoutMs,
+            );
+
+            const alertLines: string[] = [];
+            const okLines: string[] = [];
+            let alertCount = 0;
+
+            for (const [symbol, strats] of symbolToStrategies) {
+              const market = guessMarket(symbol);
+              let pct: number | null = null;
+              let lastPrice = 0;
+              let prevPrice = 0;
+              try {
+                const ohlcv = await client.getOHLCV({ symbol, market, limit: 2 });
+                if (ohlcv.length >= 2) {
+                  prevPrice = ohlcv[ohlcv.length - 2]!.close;
+                  lastPrice = ohlcv[ohlcv.length - 1]!.close;
+                  if (prevPrice > 0) pct = ((lastPrice - prevPrice) / prevPrice) * 100;
+                }
+              } catch {
+                pct = null;
+              }
+
+              if (pct === null) {
+                okLines.push(`- ${symbol}: 无法获取 K 线（DataHub 或标的异常）`);
+                continue;
+              }
+
+              if (Math.abs(pct) >= threshold) {
+                for (const st of strats) {
+                  const alertId = randomUUID();
+                  const pctStr = `${pct >= 0 ? "+" : ""}${pct.toFixed(2)}%`;
+                  insertPriceAlert(getDb(), {
+                    id: alertId,
+                    strategy_id: st.id,
+                    symbol,
+                    alert_type: "threshold_breached",
+                    trigger_value: pct,
+                    threshold,
+                    message: `涨跌幅 ${pctStr} 超过阈值 ${threshold}%（策略: ${st.name}）`,
+                    created_at: new Date().toISOString(),
+                    acknowledged: 0,
+                  });
+                  alertCount += 1;
+                  alertLines.push(
+                    `- **${symbol}**: ${pctStr} (阈值 ${threshold}%) — 策略: ${st.name}\n  - 当前收盘: ${lastPrice.toFixed(6)}，上一根收盘: ${prevPrice.toFixed(6)}`,
+                  );
+                }
+              } else {
+                okLines.push(`- ${symbol}: ${pct >= 0 ? "+" : ""}${pct.toFixed(2)}%`);
+              }
+            }
+
+            const title = `## 价格监控报告 — ${now.slice(0, 16).replace("T", " ")}`;
+            const body: string[] = [title, ""];
+            if (alertLines.length > 0) {
+              body.push("### 告警");
+              body.push(...alertLines);
+              body.push("");
+            } else {
+              body.push("### 告警");
+              body.push("（本窗口无触及阈值的标的）");
+              body.push("");
+            }
+            body.push("### 正常 / 其他");
+            body.push(...okLines);
+
+            const markdown = body.join("\n");
+
+            updateScanHistory(getDb(), scanId, {
+              status: "completed",
+              completed_at: new Date().toISOString(),
+              strategies_scanned: strategies.length,
+              actions_taken: alertCount,
+              summary: `Price monitor: ${alertCount} alert(s), ${symbolToStrategies.size} symbol(s).`,
+            });
+
+            return {
+              content: [{ type: "text" as const, text: markdown }],
+              details: {
+                success: true,
+                alertCount,
+                symbolsChecked: symbolToStrategies.size,
+                strategiesScanned: strategies.length,
+                threshold,
+              },
+            };
+          } catch (err) {
+            updateScanHistory(getDb(), scanId, {
+              status: "failed",
+              completed_at: new Date().toISOString(),
+              summary: `Price monitor failed: ${err instanceof Error ? err.message : String(err)}`,
+            });
+            return json({
+              success: false,
+              error: err instanceof Error ? err.message : String(err),
+            });
+          }
+        },
+      ),
+    },
+    { names: ["strategy_price_monitor"] },
+  );
+
   // ── strategy_scan_history ──
   api.registerTool(
     {
@@ -258,4 +469,108 @@ export function registerSchedulerTools(
     },
     { names: ["strategy_scan_history"] },
   );
+
+  // ── strategy_periodic_report ──
+  api.registerTool(
+    {
+      name: "strategy_periodic_report",
+      label: "Strategy periodic report",
+      description:
+        "Build a weekly (7-day rolling) or monthly (30-day rolling) Markdown report: " +
+        "backtest ranking snapshot, scan_history counts by type, and price alert count.",
+      parameters: Type.Object({
+        period: Type.String({
+          enum: ["weekly", "monthly"],
+          description: "weekly = past 7×24h from now; monthly = past 30×24h from now (rolling)",
+        }),
+      }),
+      execute: withLogging(
+        getDb,
+        "strategy_periodic_report",
+        "scheduler",
+        async (_toolCallId, params) => {
+          const period = params.period === "monthly" ? "monthly" : "weekly";
+          const scanId = randomUUID();
+          const now = new Date();
+          const start = new Date(now.getTime());
+          const days = period === "weekly" ? 7 : 30;
+          start.setTime(now.getTime() - days * 24 * 60 * 60 * 1000);
+          const startIso = start.toISOString();
+          const endIso = now.toISOString();
+          const scanType = period === "weekly" ? "weekly_report" : "monthly_report";
+
+          try {
+            const db = getDb();
+            // Stats before persisting this run's scan_history row so the report does not count itself.
+            const scanCounts = countScanHistoryByTypeSince(db, startIso);
+            const priceAlertCount = countPriceAlertsSince(db, startIso);
+            const strategies = queryStrategies(db);
+
+            const rankRows = strategies.map((s) => {
+              const bts = queryBacktestResults(db, s.id);
+              const latest = bts[0];
+              return {
+                strategyId: s.id,
+                strategyName: s.name,
+                totalReturn: latest?.total_return ?? null,
+                sharpe: latest?.sharpe ?? null,
+                maxDrawdown: latest?.max_drawdown ?? null,
+              };
+            });
+
+            const markdown = formatPeriodicReportMarkdown({
+              period,
+              windowStartIso: startIso,
+              windowEndIso: endIso,
+              scanCountsByType: scanCounts,
+              priceAlertCount,
+              rankRows,
+            });
+
+            const completedAt = new Date().toISOString();
+            insertScanHistory(getDb(), {
+              id: scanId,
+              scan_type: scanType,
+              started_at: endIso,
+              completed_at: completedAt,
+              status: "completed",
+              strategies_scanned: strategies.length,
+              news_found: 0,
+              actions_taken: 0,
+              summary: `${period} report: ${strategies.length} strategies, ${priceAlertCount} alerts in window.`,
+            });
+
+            return {
+              content: [{ type: "text" as const, text: markdown }],
+              details: {
+                success: true,
+                period,
+                windowStartIso: startIso,
+                windowEndIso: endIso,
+                strategyCount: strategies.length,
+                priceAlertCount,
+              },
+            };
+          } catch (err) {
+            insertScanHistory(getDb(), {
+              id: scanId,
+              scan_type: scanType,
+              started_at: endIso,
+              completed_at: new Date().toISOString(),
+              status: "failed",
+              strategies_scanned: 0,
+              news_found: 0,
+              actions_taken: 0,
+              summary: `Periodic report failed: ${err instanceof Error ? err.message : String(err)}`,
+            });
+            return json({
+              success: false,
+              error: err instanceof Error ? err.message : String(err),
+            });
+          }
+        },
+      ),
+    },
+    { names: ["strategy_periodic_report"] },
+  );
 }