@openfinclaw/openfinclaw-strategy 2026.3.276 → 2026.4.2

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";
@@ -21,14 +21,13 @@ import { AggregatedNewsProvider, createNewsProviders } from "./src/scheduler/new
 import { registerSchedulerTools } from "./src/scheduler/tools.js";
 import { registerStrategyTools } from "./src/strategy/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 +37,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);
@@ -82,9 +81,9 @@ const openfinclawPlugin = {
     if (config.schedulerEnabled) {
       setupOpenfinclawCronJobs(config)
         .then((result) => {
-          if (result.created > 0) {
+          if (result.created > 0 || result.migrated > 0) {
             api.logger.info(
-              `[OpenFinClaw] Cron jobs registered: ${result.created} created, ${result.existing} existing`,
+              `[OpenFinClaw] Cron jobs: ${result.created} created, ${result.migrated} migrated, ${result.existing} existing`,
             );
           }
         })
@@ -95,6 +94,4 @@ const openfinclawPlugin = {
         });
     }
   },
-};
-
-export default openfinclawPlugin;
+});

package/openclaw.plugin.json

@@ -23,7 +23,7 @@
       "datahubGatewayUrl": {
         "type": "string",
         "description": "DataHub Gateway URL for market data",
-        "default": "http://43.134.61.136:9080"
+        "default": "https://datahub.openfinclaw.ai"
       },
       "requestTimeoutMs": {
         "type": "number",
@@ -69,6 +69,16 @@
         "default": "Asia/Shanghai",
         "description": "Timezone for scheduled tasks"
       },
+      "cronSessionTarget": {
+        "type": "string",
+        "default": "isolated",
+        "description": "Cron job session mode: 'isolated' (own session, won't block main chat) or 'main' (legacy, runs in main conversation)"
+      },
+      "cronDeliveryMode": {
+        "type": "string",
+        "default": "announce",
+        "description": "Cron result delivery: 'announce' (push to user's last active channel) or 'none' (silent)"
+      },
       "newsApiKey": {
         "type": "string",
         "description": "Optional API key for Finnhub or NewsAPI news provider",
@@ -101,7 +111,7 @@
     },
     "datahubGatewayUrl": {
       "label": "DataHub Gateway URL",
-      "placeholder": "http://43.134.61.136:9080"
+      "placeholder": "https://datahub.openfinclaw.ai"
     }
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openfinclaw/openfinclaw-strategy",
-  "version": "2026.3.276",
+  "version": "2026.4.2",
   "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/config.ts

@@ -6,7 +6,7 @@ import type { OpenClawPluginApi } from "openclaw/plugin-sdk/core";
 import type { NewsProviderType, UnifiedPluginConfig } from "./types.js";
 
 const DEFAULT_HUB_API_URL = "https://hub.openfinclaw.ai";
-const DEFAULT_DATAHUB_GATEWAY_URL = "http://43.134.61.136:9080";
+const DEFAULT_DATAHUB_GATEWAY_URL = "https://datahub.openfinclaw.ai";
 const DEFAULT_TIMEOUT_MS = 60_000;
 
 const DEFAULT_SCAN_CRON = "0 8 * * *";
@@ -92,6 +92,29 @@ export function resolvePluginConfig(api: OpenClawPluginApi): UnifiedPluginConfig
     readEnv(["OPENFINCLAW_SCAN_TZ"]) ??
     DEFAULT_SCAN_TZ;
 
+  const cronAgentIdRaw =
+    (typeof raw?.cronAgentId === "string" ? raw.cronAgentId : undefined) ??
+    readEnv(["OPENFINCLAW_CRON_AGENT_ID"]);
+  const cronAgentId = cronAgentIdRaw?.trim() || undefined;
+
+  const VALID_SESSION_TARGETS = new Set(["isolated", "main"]);
+  const cronSessionTargetRaw =
+    (typeof raw?.cronSessionTarget === "string" ? raw.cronSessionTarget : undefined) ??
+    readEnv(["OPENFINCLAW_CRON_SESSION_TARGET"]) ??
+    "isolated";
+  const cronSessionTarget = VALID_SESSION_TARGETS.has(cronSessionTargetRaw)
+    ? cronSessionTargetRaw
+    : "isolated";
+
+  const VALID_DELIVERY_MODES = new Set(["announce", "none"]);
+  const cronDeliveryModeRaw =
+    (typeof raw?.cronDeliveryMode === "string" ? raw.cronDeliveryMode : undefined) ??
+    readEnv(["OPENFINCLAW_CRON_DELIVERY_MODE"]) ??
+    "announce";
+  const cronDeliveryMode = VALID_DELIVERY_MODES.has(cronDeliveryModeRaw)
+    ? cronDeliveryModeRaw
+    : "announce";
+
   // ── News config ──
   const newsApiKey =
     (typeof raw?.newsApiKey === "string" ? raw.newsApiKey : undefined) ??
@@ -124,6 +147,9 @@ export function resolvePluginConfig(api: OpenClawPluginApi): UnifiedPluginConfig
     weeklyReportCronExpr,
     monthlyReportCronExpr,
     scanTimezone,
+    cronAgentId,
+    cronSessionTarget,
+    cronDeliveryMode,
     newsApiKey: newsApiKey && newsApiKey.length > 0 ? newsApiKey : undefined,
     newsProvider,
     priceAlertThreshold,

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,6 +1,6 @@
 /**
  * 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";
 

package/src/scheduler/cron-setup.ts

@@ -8,7 +8,9 @@
  * The running CronService watches the store file and picks up new jobs
  * on its next tick.
  *
- * Idempotent: safe to call multiple times (skips existing jobs by name).
+ * Idempotent: creates missing jobs and migrates legacy "main" session jobs
+ * to "isolated" so cron tasks run in their own session without blocking the
+ * user's active conversation.
  *
  * Jobs:
  * - openfinclaw:daily-scan      (0 8 * * *)       每日策略扫描
@@ -23,16 +25,21 @@ import type { UnifiedPluginConfig } from "../types.js";
 
 // ── Cron store types (mirrors src/cron/types.ts subset) ──────────────────
 
+type CronPayload =
+  | { kind: "systemEvent"; text: string }
+  | { kind: "agentTurn"; message: string };
+
 /** Minimal stored cron job shape. */
 interface StoredCronJob {
   id: string;
   name: string;
+  agentId?: string;
   enabled: boolean;
   schedule: { kind: "cron"; expr: string; tz?: string };
-  payload: { kind: "systemEvent"; text: string };
+  payload: CronPayload;
   sessionTarget: string;
   wakeMode: string;
-  delivery: { mode: string };
+  delivery: { mode: string; channel?: string; to?: string };
   createdAtMs: number;
   updatedAtMs: number;
   state: Record<string, unknown>;
@@ -43,6 +50,14 @@ interface CronStoreFile {
   jobs: StoredCronJob[];
 }
 
+/** Names managed by this plugin — used for migration detection. */
+const OPENFINCLAW_JOB_NAMES = new Set([
+  "openfinclaw:daily-scan",
+  "openfinclaw:price-monitor",
+  "openfinclaw:weekly-report",
+  "openfinclaw:monthly-report",
+]);
+
 // ── File I/O ──────────────────────────────────────────────────────────────
 
 /** Resolve default cron store path: ~/.openclaw/cron/jobs.json */
@@ -82,15 +97,26 @@ async function saveStore(storePath: string, store: CronStoreFile): Promise<void>
 function buildCronJobDefs(config: UnifiedPluginConfig): Array<{
   name: string;
   schedule: { kind: "cron"; expr: string; tz?: string };
-  payload: { kind: "systemEvent"; text: string };
+  payload: CronPayload;
+  sessionTarget: string;
+  delivery: { mode: string };
 }> {
+  const sessionTarget = config.cronSessionTarget;
+  const delivery = { mode: config.cronDeliveryMode };
+  const useAgentTurn = sessionTarget !== "main";
+
+  function makePayload(text: string): CronPayload {
+    return useAgentTurn ? { kind: "agentTurn", message: text } : { kind: "systemEvent", text };
+  }
+
   return [
     {
       name: "openfinclaw:daily-scan",
       schedule: { kind: "cron", expr: config.scanCronExpr, tz: config.scanTimezone },
-      payload: {
-        kind: "systemEvent",
-        text: [
+      sessionTarget,
+      delivery,
+      payload: makePayload(
+        [
           "[openfinclaw-strategy 每日扫描]",
           "1. 调用 strategy_daily_scan 获取策略扫描报告",
           "2. 分析每条新闻对策略的影响（利好/利空/中性）",
@@ -98,56 +124,94 @@ function buildCronJobDefs(config: UnifiedPluginConfig): Array<{
           "4. 用 skill_publish_verify 确认回测完成",
           "5. 将分析报告和建议操作发送给用户",
         ].join("\n"),
-      },
+      ),
     },
     {
       name: "openfinclaw:price-monitor",
       schedule: { kind: "cron", expr: config.monitorCronExpr, tz: config.scanTimezone },
-      payload: {
-        kind: "systemEvent",
-        text: [
+      sessionTarget,
+      delivery,
+      payload: makePayload(
+        [
           "[openfinclaw-strategy 价格监控]",
           "调用 strategy_price_monitor 检查所有策略标的的价格异动。",
           "如有告警（涨跌幅超阈值），分析可能的原因并通知用户。",
         ].join("\n"),
-      },
+      ),
     },
     {
       name: "openfinclaw:weekly-report",
       schedule: { kind: "cron", expr: config.weeklyReportCronExpr, tz: config.scanTimezone },
-      payload: {
-        kind: "systemEvent",
-        text: [
+      sessionTarget,
+      delivery,
+      payload: makePayload(
+        [
           "[openfinclaw-strategy 周报]",
           '调用 strategy_periodic_report(period="weekly") 生成策略绩效周报。',
           "汇总本周回测结果、价格告警和扫描记录，发送给用户。",
         ].join("\n"),
-      },
+      ),
     },
     {
       name: "openfinclaw:monthly-report",
       schedule: { kind: "cron", expr: config.monthlyReportCronExpr, tz: config.scanTimezone },
-      payload: {
-        kind: "systemEvent",
-        text: [
+      sessionTarget,
+      delivery,
+      payload: makePayload(
+        [
           "[openfinclaw-strategy 月报]",
           '调用 strategy_periodic_report(period="monthly") 生成策略绩效月报。',
           "汇总本月回测结果、价格告警和扫描记录，发送给用户。",
         ].join("\n"),
-      },
+      ),
     },
   ];
 }
 
+// ── Migration ─────────────────────────────────────────────────────────────
+
+/**
+ * Migrate legacy openfinclaw jobs that still use sessionTarget "main" +
+ * systemEvent payload to the new isolated agentTurn pattern.
+ * Returns the number of jobs migrated.
+ */
+function migrateLegacyJobs(
+  store: CronStoreFile,
+  defs: ReturnType<typeof buildCronJobDefs>,
+): number {
+  const defsByName = new Map(defs.map((d) => [d.name, d]));
+  let migrated = 0;
+
+  for (const job of store.jobs) {
+    if (!OPENFINCLAW_JOB_NAMES.has(job.name)) continue;
+    if (job.sessionTarget !== "main") continue;
+
+    const def = defsByName.get(job.name);
+    if (!def) continue;
+
+    job.payload = def.payload;
+    job.sessionTarget = def.sessionTarget;
+    job.delivery = def.delivery;
+    job.updatedAtMs = Date.now();
+    migrated++;
+  }
+
+  return migrated;
+}
+
 // ── Public API ────────────────────────────────────────────────────────────
 
 /**
- * Idempotently register openfinclaw cron jobs by writing to the
+ * Register and migrate openfinclaw cron jobs by writing to the
  * Gateway cron store file. Safe to call at plugin startup.
+ *
+ * - Creates missing jobs with the current config (isolated session by default).
+ * - Migrates existing legacy "main" session jobs to "isolated" + "agentTurn"
+ *   so cron tasks no longer block the user's active conversation.
  */
 export async function setupOpenfinclawCronJobs(
   config: UnifiedPluginConfig,
-): Promise<{ ok: boolean; created: number; existing: number }> {
+): Promise<{ ok: boolean; created: number; existing: number; migrated: number }> {
   const storePath = defaultStorePath();
   const store = await loadStore(storePath);
   const existingNames = new Set(store.jobs.map((j) => j.name));
@@ -160,12 +224,13 @@ export async function setupOpenfinclawCronJobs(
     store.jobs.push({
       id: randomUUID(),
       name: def.name,
+      agentId: config.cronAgentId,
       enabled: true,
       schedule: def.schedule,
       payload: def.payload,
-      sessionTarget: "main",
+      sessionTarget: def.sessionTarget,
       wakeMode: "now",
-      delivery: { mode: "none" },
+      delivery: def.delivery,
       createdAtMs: now,
       updatedAtMs: now,
       state: {},
@@ -173,9 +238,11 @@ export async function setupOpenfinclawCronJobs(
     created++;
   }
 
-  if (created > 0) {
+  const migrated = migrateLegacyJobs(store, defs);
+
+  if (created > 0 || migrated > 0) {
     await saveStore(storePath, store);
   }
 
-  return { ok: true, created, existing: existingNames.size };
+  return { ok: true, created, existing: existingNames.size, migrated };
 }

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"] },
+  );
 }

package/src/types.ts

@@ -552,6 +552,12 @@ export interface UnifiedPluginConfig {
   monthlyReportCronExpr: string;
   /** 调度时区 */
   scanTimezone: string;
+  /** 定时任务绑定的专用 agent id；未设置时沿用默认 agent */
+  cronAgentId: string | undefined;
+  /** Cron session 模式："isolated"（独立 session，不阻塞主对话）或 "main"（旧行为） */
+  cronSessionTarget: string;
+  /** Cron 投递模式："announce"（推送到用户最近活跃频道）或 "none" */
+  cronDeliveryMode: string;
 
   // ── 新闻源配置 ────────────────────────────────────────────
   /** 外部新闻 API Key（Finnhub 或 NewsAPI） */