@openfinclaw/openfinclaw-strategy 2026.3.275 → 2026.3.310

package/src/strategy/tools.ts

@@ -204,122 +204,131 @@ export function registerStrategyTools(
           Type.String({ description: "Backtest task ID from skill_publish response" }),
         ),
       }),
-      execute: withLogging(getDb, "skill_publish_verify", "strategy", async (_toolCallId, params) => {
-        try {
-          const submissionId = String(params.submissionId ?? "").trim() || undefined;
-          const backtestTaskId = String(params.backtestTaskId ?? "").trim() || undefined;
+      execute: withLogging(
+        getDb,
+        "skill_publish_verify",
+        "strategy",
+        async (_toolCallId, params) => {
+          try {
+            const submissionId = String(params.submissionId ?? "").trim() || undefined;
+            const backtestTaskId = String(params.backtestTaskId ?? "").trim() || undefined;
 
-          if (!submissionId && !backtestTaskId) {
-            return json({
-              success: false,
-              error: "Either submissionId or backtestTaskId is required",
-            });
-          }
+            if (!submissionId && !backtestTaskId) {
+              return json({
+                success: false,
+                error: "Either submissionId or backtestTaskId is required",
+              });
+            }
 
-          if (!config.apiKey) {
-            return json({
-              success: false,
-              error: NO_API_KEY,
-            });
-          }
+            if (!config.apiKey) {
+              return json({
+                success: false,
+                error: NO_API_KEY,
+              });
+            }
 
-          const searchParams: Record<string, string> = {};
-          if (submissionId) searchParams.submissionId = submissionId;
-          if (backtestTaskId) searchParams.backtestTaskId = backtestTaskId;
+            const searchParams: Record<string, string> = {};
+            if (submissionId) searchParams.submissionId = submissionId;
+            if (backtestTaskId) searchParams.backtestTaskId = backtestTaskId;
 
-          const { status, data } = await hubApiRequest(config, "GET", "/skill/publish/verify", {
-            searchParams,
-          });
+            const { status, data } = await hubApiRequest(config, "GET", "/skill/publish/verify", {
+              searchParams,
+            });
 
-          if (status >= 200 && status < 300) {
-            const resp = data as Record<string, unknown>;
-
-            // Update backtest result metrics and strategy level
-            const verifyStrategyId = resp.entryId as string | undefined;
-            if (resp.backtestStatus === "completed" && backtestTaskId) {
-              const report = resp.backtestReport as Record<string, unknown> | undefined;
-              const perf = report?.performance as Record<string, unknown> | undefined;
-              updateBacktestResult(getDb(), backtestTaskId, {
-                status: "completed",
-                total_return: typeof perf?.totalReturn === "number" ? perf.totalReturn : undefined,
-                sharpe: typeof perf?.sharpe === "number" ? perf.sharpe : undefined,
-                sortino: typeof perf?.sortino === "number" ? perf.sortino : undefined,
-                max_drawdown: typeof perf?.maxDrawdown === "number" ? perf.maxDrawdown : undefined,
-                win_rate: typeof perf?.winRate === "number" ? perf.winRate : undefined,
-                profit_factor:
-                  typeof perf?.profitFactor === "number" ? perf.profitFactor : undefined,
-                total_trades: typeof perf?.totalTrades === "number" ? perf.totalTrades : undefined,
-                final_equity: typeof perf?.finalEquity === "number" ? perf.finalEquity : undefined,
-                equity_curve: Array.isArray(report?.equity_curve)
-                  ? JSON.stringify(report.equity_curve)
-                  : undefined,
-                trade_journal: Array.isArray(report?.trade_journal)
-                  ? JSON.stringify(report.trade_journal)
-                  : undefined,
-                monthly_returns:
-                  report?.monthly_returns && typeof report.monthly_returns === "object"
-                    ? JSON.stringify(report.monthly_returns)
+            if (status >= 200 && status < 300) {
+              const resp = data as Record<string, unknown>;
+
+              // Update backtest result metrics and strategy level
+              const verifyStrategyId = resp.entryId as string | undefined;
+              if (resp.backtestStatus === "completed" && backtestTaskId) {
+                const report = resp.backtestReport as Record<string, unknown> | undefined;
+                const perf = report?.performance as Record<string, unknown> | undefined;
+                updateBacktestResult(getDb(), backtestTaskId, {
+                  status: "completed",
+                  total_return:
+                    typeof perf?.totalReturn === "number" ? perf.totalReturn : undefined,
+                  sharpe: typeof perf?.sharpe === "number" ? perf.sharpe : undefined,
+                  sortino: typeof perf?.sortino === "number" ? perf.sortino : undefined,
+                  max_drawdown:
+                    typeof perf?.maxDrawdown === "number" ? perf.maxDrawdown : undefined,
+                  win_rate: typeof perf?.winRate === "number" ? perf.winRate : undefined,
+                  profit_factor:
+                    typeof perf?.profitFactor === "number" ? perf.profitFactor : undefined,
+                  total_trades:
+                    typeof perf?.totalTrades === "number" ? perf.totalTrades : undefined,
+                  final_equity:
+                    typeof perf?.finalEquity === "number" ? perf.finalEquity : undefined,
+                  equity_curve: Array.isArray(report?.equity_curve)
+                    ? JSON.stringify(report.equity_curve)
                     : undefined,
-                tearsheet_html:
-                  typeof report?.tearsheet_html === "string" ? report.tearsheet_html : undefined,
-                completed_at: new Date().toISOString(),
-              });
-              // Backtest completed → strategy stays at L1
-              if (verifyStrategyId) updateStrategyLevel(getDb(), verifyStrategyId, "L1");
-            } else if (resp.backtestStatus === "failed" && backtestTaskId) {
-              updateBacktestResult(getDb(), backtestTaskId, {
-                status: "failed",
-                completed_at: new Date().toISOString(),
-              });
-              // Backtest failed → revert to L0
-              if (verifyStrategyId) updateStrategyLevel(getDb(), verifyStrategyId, "L0");
-            }
-
-            const lines: string[] = [];
-            lines.push("发布验证结果：");
-            lines.push(`- Slug: ${resp.slug ?? "(未知)"}`);
-            lines.push(`- Version: ${resp.version ?? "(未知)"}`);
-            lines.push(`- Backtest Status: ${resp.backtestStatus ?? "(未知)"}`);
+                  trade_journal: Array.isArray(report?.trade_journal)
+                    ? JSON.stringify(report.trade_journal)
+                    : undefined,
+                  monthly_returns:
+                    report?.monthly_returns && typeof report.monthly_returns === "object"
+                      ? JSON.stringify(report.monthly_returns)
+                      : undefined,
+                  tearsheet_html:
+                    typeof report?.tearsheet_html === "string" ? report.tearsheet_html : undefined,
+                  completed_at: new Date().toISOString(),
+                });
+                // Backtest completed → strategy stays at L1
+                if (verifyStrategyId) updateStrategyLevel(getDb(), verifyStrategyId, "L1");
+              } else if (resp.backtestStatus === "failed" && backtestTaskId) {
+                updateBacktestResult(getDb(), backtestTaskId, {
+                  status: "failed",
+                  completed_at: new Date().toISOString(),
+                });
+                // Backtest failed → revert to L0
+                if (verifyStrategyId) updateStrategyLevel(getDb(), verifyStrategyId, "L0");
+              }
 
-            if (resp.backtestStatus === "completed" && resp.backtestReport) {
-              const perf = (resp.backtestReport as Record<string, unknown>).performance as
-                | Record<string, unknown>
-                | undefined;
-              if (perf) {
-                lines.push("");
-                lines.push("回测报告摘要：");
-                if (typeof perf.totalReturn === "number")
-                  lines.push(`- 总收益率: ${(perf.totalReturn * 100).toFixed(2)}%`);
-                if (typeof perf.sharpe === "number")
-                  lines.push(`- 夏普比率: ${perf.sharpe.toFixed(3)}`);
-                if (typeof perf.maxDrawdown === "number")
-                  lines.push(`- 最大回撤: ${(perf.maxDrawdown * 100).toFixed(2)}%`);
-                if (typeof perf.winRate === "number")
-                  lines.push(`- 胜率: ${(perf.winRate * 100).toFixed(1)}%`);
+              const lines: string[] = [];
+              lines.push("发布验证结果：");
+              lines.push(`- Slug: ${resp.slug ?? "(未知)"}`);
+              lines.push(`- Version: ${resp.version ?? "(未知)"}`);
+              lines.push(`- Backtest Status: ${resp.backtestStatus ?? "(未知)"}`);
+
+              if (resp.backtestStatus === "completed" && resp.backtestReport) {
+                const perf = (resp.backtestReport as Record<string, unknown>).performance as
+                  | Record<string, unknown>
+                  | undefined;
+                if (perf) {
+                  lines.push("");
+                  lines.push("回测报告摘要：");
+                  if (typeof perf.totalReturn === "number")
+                    lines.push(`- 总收益率: ${(perf.totalReturn * 100).toFixed(2)}%`);
+                  if (typeof perf.sharpe === "number")
+                    lines.push(`- 夏普比率: ${perf.sharpe.toFixed(3)}`);
+                  if (typeof perf.maxDrawdown === "number")
+                    lines.push(`- 最大回撤: ${(perf.maxDrawdown * 100).toFixed(2)}%`);
+                  if (typeof perf.winRate === "number")
+                    lines.push(`- 胜率: ${(perf.winRate * 100).toFixed(1)}%`);
+                }
               }
+
+              return {
+                content: [{ type: "text" as const, text: lines.join("\n") }],
+                details: { success: true, ...resp },
+              };
             }
 
-            return {
-              content: [{ type: "text" as const, text: lines.join("\n") }],
-              details: { success: true, ...resp },
-            };
+            return json({
+              success: false,
+              status,
+              error:
+                (data as { code?: string; message?: string })?.message ??
+                (data as { detail?: string })?.detail ??
+                data,
+            });
+          } catch (err) {
+            return json({
+              success: false,
+              error: err instanceof Error ? err.message : String(err),
+            });
           }
-
-          return json({
-            success: false,
-            status,
-            error:
-              (data as { code?: string; message?: string })?.message ??
-              (data as { detail?: string })?.detail ??
-              data,
-          });
-        } catch (err) {
-          return json({
-            success: false,
-            error: err instanceof Error ? err.message : String(err),
-          });
-        }
-      }),
+        },
+      ),
     },
     { names: ["skill_publish_verify"] },
   );

package/src/tournament/cron-setup.ts

@@ -0,0 +1,102 @@
+/**
+ * Tournament cron job registration.
+ * Follows the same file-based pattern as scheduler/cron-setup.ts.
+ * @module openfinclaw/tournament/cron-setup
+ */
+import { randomUUID } from "node:crypto";
+import fs from "node:fs";
+import path from "node:path";
+
+const DEFAULT_TOURNAMENT_CRON = "0 9 * * 1-5"; // 9 AM weekdays
+const DEFAULT_TOURNAMENT_TZ = "Asia/Shanghai";
+
+interface StoredCronJob {
+  id: string;
+  name: string;
+  enabled: boolean;
+  schedule: { kind: "cron"; expr: string; tz?: string };
+  payload: { kind: "systemEvent"; text: string };
+  sessionTarget: string;
+  wakeMode: string;
+  delivery: { mode: string };
+  createdAtMs: number;
+  updatedAtMs: number;
+  state: Record<string, unknown>;
+}
+
+interface CronStoreFile {
+  version: 1;
+  jobs: StoredCronJob[];
+}
+
+function defaultStorePath(): string {
+  const home = process.env.HOME ?? process.env.USERPROFILE ?? "";
+  return path.join(home, ".openclaw", "cron", "jobs.json");
+}
+
+async function loadStore(storePath: string): Promise<CronStoreFile> {
+  try {
+    const raw = await fs.promises.readFile(storePath, "utf-8");
+    const parsed = JSON.parse(raw) as Record<string, unknown>;
+    const jobs = Array.isArray(parsed.jobs) ? (parsed.jobs as StoredCronJob[]) : [];
+    return { version: 1, jobs };
+  } catch (err) {
+    if ((err as { code?: string }).code === "ENOENT") {
+      return { version: 1, jobs: [] };
+    }
+    throw err;
+  }
+}
+
+async function saveStore(storePath: string, store: CronStoreFile): Promise<void> {
+  const dir = path.dirname(storePath);
+  await fs.promises.mkdir(dir, { recursive: true });
+  const json = JSON.stringify(store, null, 2);
+  const tmp = `${storePath}.${process.pid}.${Date.now()}.tmp`;
+  await fs.promises.writeFile(tmp, json, "utf-8");
+  await fs.promises.rename(tmp, storePath);
+}
+
+const TOURNAMENT_JOB_NAME = "openfinclaw:tournament";
+
+/**
+ * Register the daily tournament cron job.
+ * Idempotent: skips if job already exists by name.
+ */
+export async function setupTournamentCronJob(config?: {
+  cronExpr?: string;
+  timezone?: string;
+}): Promise<{ ok: boolean; created: boolean }> {
+  const storePath = defaultStorePath();
+  const store = await loadStore(storePath);
+
+  const existingNames = new Set(store.jobs.map((j) => j.name));
+  if (existingNames.has(TOURNAMENT_JOB_NAME)) {
+    return { ok: true, created: false };
+  }
+
+  const cronExpr =
+    config?.cronExpr ?? process.env.OPENFINCLAW_TOURNAMENT_CRON ?? DEFAULT_TOURNAMENT_CRON;
+  const timezone = config?.timezone ?? DEFAULT_TOURNAMENT_TZ;
+
+  const now = Date.now();
+  store.jobs.push({
+    id: randomUUID(),
+    name: TOURNAMENT_JOB_NAME,
+    enabled: true,
+    schedule: { kind: "cron", expr: cronExpr, tz: timezone },
+    payload: {
+      kind: "systemEvent",
+      text: "[openfinclaw:tournament] 每日策略锦标赛触发。请执行今日锦标赛流程。",
+    },
+    sessionTarget: "main",
+    wakeMode: "now",
+    delivery: { mode: "none" },
+    createdAtMs: now,
+    updatedAtMs: now,
+    state: {},
+  });
+
+  await saveStore(storePath, store);
+  return { ok: true, created: true };
+}

package/src/tournament/db.test.ts

@@ -0,0 +1,222 @@
+/**
+ * Unit tests for tournament DB operations.
+ * @module openfinclaw/tournament/db.test
+ */
+import { DatabaseSync } from "node:sqlite";
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import { TournamentDb, ensureTournamentSchema } from "./db.js";
+
+describe("TournamentDb", () => {
+  let db: DatabaseSync;
+  let tdb: TournamentDb;
+
+  beforeEach(() => {
+    db = new DatabaseSync(":memory:");
+    db.exec("PRAGMA journal_mode = WAL");
+    ensureTournamentSchema(db);
+    tdb = new TournamentDb(db);
+  });
+
+  afterEach(() => {
+    db.close();
+  });
+
+  describe("schema", () => {
+    it("creates tables idempotently", () => {
+      ensureTournamentSchema(db);
+      ensureTournamentSchema(db);
+      const tables = db
+        .prepare("SELECT name FROM sqlite_master WHERE type='table' AND name LIKE 'tournament_%'")
+        .all() as Array<{ name: string }>;
+      const names = tables.map((t) => t.name).sort();
+      expect(names).toEqual([
+        "tournament_agents",
+        "tournament_picks",
+        "tournament_rounds",
+        "tournament_strategies",
+      ]);
+    });
+  });
+
+  describe("rounds", () => {
+    it("creates a round", () => {
+      const created = tdb.createRound({ id: "round-20260331", date: "2026-03-31", ticker: "AAPL" });
+      expect(created).toBe(true);
+      const round = tdb.getRound("round-20260331");
+      expect(round).toBeDefined();
+      expect(round!.ticker).toBe("AAPL");
+      expect(round!.status).toBe("running");
+    });
+
+    it("returns false for duplicate round", () => {
+      tdb.createRound({ id: "round-20260331", date: "2026-03-31", ticker: "AAPL" });
+      const dup = tdb.createRound({ id: "round-20260331", date: "2026-03-31", ticker: "TSLA" });
+      expect(dup).toBe(false);
+    });
+
+    it("updates round status to completed", () => {
+      tdb.createRound({ id: "round-20260331", date: "2026-03-31", ticker: "AAPL" });
+      tdb.updateRoundStatus("round-20260331", "completed");
+      const round = tdb.getRound("round-20260331")!;
+      expect(round.status).toBe("completed");
+      expect(round.completed_at).toBeTruthy();
+    });
+
+    it("updates round status to skipped with reason", () => {
+      tdb.createRound({ id: "round-20260331", date: "2026-03-31", ticker: "AAPL" });
+      tdb.updateRoundStatus("round-20260331", "skipped", "Less than 2 agents succeeded");
+      const round = tdb.getRound("round-20260331")!;
+      expect(round.status).toBe("skipped");
+      expect(round.skip_reason).toBe("Less than 2 agents succeeded");
+    });
+
+    it("counts consecutive skips", () => {
+      tdb.createRound({ id: "round-20260331", date: "2026-03-31", ticker: "A" });
+      tdb.updateRoundStatus("round-20260331", "skipped");
+      tdb.createRound({ id: "round-20260330", date: "2026-03-30", ticker: "B" });
+      tdb.updateRoundStatus("round-20260330", "skipped");
+      tdb.createRound({ id: "round-20260329", date: "2026-03-29", ticker: "C" });
+      tdb.updateRoundStatus("round-20260329", "completed");
+      expect(tdb.countConsecutiveSkips()).toBe(2);
+    });
+  });
+
+  describe("strategies", () => {
+    it("saves and retrieves strategies", () => {
+      tdb.createRound({ id: "round-20260331", date: "2026-03-31", ticker: "AAPL" });
+      tdb.saveStrategy({
+        round_id: "round-20260331",
+        agent_name: "bull",
+        thesis: "EMA crossover bullish",
+        entry_price: 150.0,
+        exit_price: 165.0,
+        stop_loss: 145.0,
+        position_pct: 0.25,
+        confidence: 85,
+        sharpe: 1.5,
+        max_drawdown: -0.08,
+        total_return: 0.12,
+        raw_result: '{"detail":"full analysis"}',
+      });
+
+      const strategies = tdb.getStrategies("round-20260331");
+      expect(strategies).toHaveLength(1);
+      expect(strategies[0].agent_name).toBe("bull");
+      expect(strategies[0].confidence).toBe(85);
+      expect(strategies[0].sharpe).toBe(1.5);
+    });
+
+    it("upserts strategy on conflict", () => {
+      tdb.createRound({ id: "round-20260331", date: "2026-03-31", ticker: "AAPL" });
+      tdb.saveStrategy({
+        round_id: "round-20260331",
+        agent_name: "bull",
+        thesis: "First",
+        confidence: 50,
+        entry_price: null,
+        exit_price: null,
+        stop_loss: null,
+        position_pct: null,
+        sharpe: null,
+        max_drawdown: null,
+        total_return: null,
+        raw_result: null,
+      });
+      tdb.saveStrategy({
+        round_id: "round-20260331",
+        agent_name: "bull",
+        thesis: "Updated",
+        confidence: 90,
+        entry_price: 100,
+        exit_price: 110,
+        stop_loss: 95,
+        position_pct: 0.3,
+        sharpe: 2.0,
+        max_drawdown: -0.05,
+        total_return: 0.2,
+        raw_result: null,
+      });
+
+      const strategies = tdb.getStrategies("round-20260331");
+      expect(strategies).toHaveLength(1);
+      expect(strategies[0].thesis).toBe("Updated");
+      expect(strategies[0].confidence).toBe(90);
+    });
+  });
+
+  describe("agents", () => {
+    it("records win and updates avg sharpe", () => {
+      tdb.recordWin("bull", 1.5);
+      tdb.recordWin("bull", 2.5);
+      const agent = tdb.getAgent("bull")!;
+      expect(agent.wins).toBe(2);
+      expect(agent.rounds_played).toBe(2);
+      expect(agent.avg_sharpe).toBe(2.0);
+    });
+
+    it("records loss", () => {
+      tdb.recordLoss("bear", 0.5);
+      const agent = tdb.getAgent("bear")!;
+      expect(agent.losses).toBe(1);
+      expect(agent.rounds_played).toBe(1);
+    });
+
+    it("returns leaderboard sorted by avg_sharpe", () => {
+      tdb.recordWin("bull", 2.0);
+      tdb.recordWin("bear", 1.0);
+      tdb.recordWin("contrarian", 3.0);
+      const lb = tdb.getLeaderboard();
+      expect(lb[0].name).toBe("contrarian");
+      expect(lb[1].name).toBe("bull");
+      expect(lb[2].name).toBe("bear");
+    });
+  });
+
+  describe("picks", () => {
+    it("records a pick", () => {
+      tdb.createRound({ id: "round-20260331", date: "2026-03-31", ticker: "AAPL" });
+      const recorded = tdb.recordPick({
+        round_id: "round-20260331",
+        user_id: "telegram:12345",
+        session_key: "agent:main:telegram",
+        agent_name: "bull",
+      });
+      expect(recorded).toBe(true);
+    });
+
+    it("returns false for duplicate pick by same user", () => {
+      tdb.createRound({ id: "round-20260331", date: "2026-03-31", ticker: "AAPL" });
+      tdb.recordPick({
+        round_id: "round-20260331",
+        user_id: "telegram:12345",
+        session_key: "agent:main:telegram",
+        agent_name: "bull",
+      });
+      const dup = tdb.recordPick({
+        round_id: "round-20260331",
+        user_id: "telegram:12345",
+        session_key: "agent:main:telegram",
+        agent_name: "bear",
+      });
+      expect(dup).toBe(false);
+    });
+
+    it("allows different users to pick same round", () => {
+      tdb.createRound({ id: "round-20260331", date: "2026-03-31", ticker: "AAPL" });
+      const pick1 = tdb.recordPick({
+        round_id: "round-20260331",
+        user_id: "telegram:12345",
+        session_key: "agent:main:telegram",
+        agent_name: "bull",
+      });
+      const pick2 = tdb.recordPick({
+        round_id: "round-20260331",
+        user_id: "telegram:67890",
+        session_key: "agent:main:telegram",
+        agent_name: "bear",
+      });
+      expect(pick1).toBe(true);
+      expect(pick2).toBe(true);
+    });
+  });
+});