@openfinclaw/openfinclaw-strategy 2026.4.2 → 2026.4.9

package/index.ts

@@ -12,7 +12,7 @@ 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";
-import { getDb } from "./src/db/db.js";
+import { closeDb, getDb } from "./src/db/db.js";
 import { createOpenFinclawGatewayProxy } from "./src/http/gateway-proxy.js";
 import { startHttpServer } from "./src/http/server.js";
 import { OPENFINCLAW_AGENT_GUIDANCE } from "./src/prompt-guidance.js";
@@ -20,6 +20,10 @@ 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";
 
 export default definePluginEntry({
   id: "openfinclaw-strategy",
@@ -68,11 +72,21 @@ export default definePluginEntry({
       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}`,
     }));
 
+    // Graceful shutdown: close SQLite connection
+    process.once("beforeExit", () => {
+      closeDb();
+    });
+
     // ── Gateway Cron registration ──
     // Write cron jobs directly to ~/.openclaw/cron/jobs.json during register().
     // This ensures jobs are available immediately on both gateway startup AND
@@ -92,6 +106,19 @@ export default definePluginEntry({
             `[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)}`,
+          );
+        });
     }
   },
 });

package/package.json

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

@@ -12,7 +12,7 @@ import { mkdirSync, unlinkSync } from "node:fs";
 import { homedir } from "node:os";
 import { join } from "node:path";
 import { DatabaseSync } from "node:sqlite";
-import { ensureSchema } from "./schema.js";
+import { cleanupOldRows, ensureSchema } from "./schema.js";
 
 /** globalThis key — survives module hot-reloads within the same process. */
 const GLOBAL_DB_KEY = "__openfinclaw_db__" as const;
@@ -52,6 +52,8 @@ export function getDb(): DatabaseSync {
     ensureSchema(db);
   }
   (globalThis as Record<string, unknown>)[GLOBAL_DB_KEY] = db;
+  // Best-effort cleanup of old rows on first access each process lifecycle
+  cleanupOldRows(db);
   return db;
 }
 

package/src/db/repositories.ts

@@ -1,7 +1,12 @@
 /**
  * Data access helpers for OpenFinClaw plugin SQLite tables.
  */
-import type { DatabaseSync } from "node:sqlite";
+import type { DatabaseSync, SQLInputValue } from "node:sqlite";
+
+/** Cast unknown[] to SQLInputValue[] for db.prepare().run() spread. */
+function sqlParams(values: unknown[]): SQLInputValue[] {
+  return values as SQLInputValue[];
+}
 
 // ── Row types ─────────────────────────────────────────────────────────────
 
@@ -262,7 +267,7 @@ export function updateBacktestResult(
     }
     if (sets.length === 0) return;
     values.push(id);
-    db.prepare(`UPDATE backtest_results SET ${sets.join(", ")} WHERE id = ?`).run(...values);
+    db.prepare(`UPDATE backtest_results SET ${sets.join(", ")} WHERE id = ?`).run(...sqlParams(values));
   } catch {
     // Logging must never crash the calling tool
   }
@@ -347,7 +352,7 @@ export function updateScanHistory(
     }
     if (sets.length === 0) return;
     values.push(id);
-    db.prepare(`UPDATE scan_history SET ${sets.join(", ")} WHERE id = ?`).run(...values);
+    db.prepare(`UPDATE scan_history SET ${sets.join(", ")} WHERE id = ?`).run(...sqlParams(values));
   } catch {
     // Logging must never crash the calling tool
   }
@@ -378,7 +383,7 @@ export function queryScanHistory(
   params.push(limit, offset);
   return db
     .prepare(`SELECT * FROM scan_history ${where} ORDER BY started_at DESC LIMIT ? OFFSET ?`)
-    .all(...params) as ScanHistoryEntry[];
+    .all(...sqlParams(params)) as unknown as ScanHistoryEntry[];
 }
 
 /**
@@ -462,7 +467,7 @@ export function queryPriceAlerts(
   params.push(limit, offset);
   return db
     .prepare(`SELECT * FROM price_alerts ${where} ORDER BY created_at DESC LIMIT ? OFFSET ?`)
-    .all(...params) as PriceAlertEntry[];
+    .all(...sqlParams(params)) as unknown as PriceAlertEntry[];
 }
 
 /** Count price_alerts rows since an inclusive time bound (ISO 8601 created_at). */
@@ -488,19 +493,19 @@ export function acknowledgePriceAlert(db: DatabaseSync, id: string): void {
 export function queryActivityLog(db: DatabaseSync, limit = 50, offset = 0): ActivityLogEntry[] {
   return db
     .prepare(`SELECT * FROM agent_activity_log ORDER BY timestamp DESC LIMIT ? OFFSET ?`)
-    .all(limit, offset) as ActivityLogEntry[];
+    .all(limit, offset) as unknown as ActivityLogEntry[];
 }
 
 /** Query agent_events, newest first. */
 export function queryAgentEvents(db: DatabaseSync, limit = 50, offset = 0): AgentEventEntry[] {
   return db
     .prepare(`SELECT * FROM agent_events ORDER BY timestamp DESC LIMIT ? OFFSET ?`)
-    .all(limit, offset) as AgentEventEntry[];
+    .all(limit, offset) as unknown as AgentEventEntry[];
 }
 
 /** Query all strategies, newest first. */
 export function queryStrategies(db: DatabaseSync): StrategyRow[] {
-  return db.prepare(`SELECT * FROM strategies ORDER BY updated_at DESC`).all() as StrategyRow[];
+  return db.prepare(`SELECT * FROM strategies ORDER BY updated_at DESC`).all() as unknown as StrategyRow[];
 }
 
 /** Query backtest results, optionally filtered by strategy_id. */
@@ -508,9 +513,9 @@ export function queryBacktestResults(db: DatabaseSync, strategyId?: string): Bac
   if (strategyId) {
     return db
       .prepare(`SELECT * FROM backtest_results WHERE strategy_id = ? ORDER BY created_at DESC`)
-      .all(strategyId) as BacktestRow[];
+      .all(strategyId) as unknown as BacktestRow[];
   }
   return db
     .prepare(`SELECT * FROM backtest_results ORDER BY created_at DESC`)
-    .all() as BacktestRow[];
+    .all() as unknown as BacktestRow[];
 }

package/src/db/schema.ts

@@ -3,6 +3,7 @@
  * 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,9 +135,29 @@ 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) ──────────────────────
 }
 
+/**
+ * Purge old rows from accumulating tables.
+ * Safe to call periodically (e.g. on plugin register or via cron).
+ * Keeps 90 days of activity logs, scan history, and acknowledged price alerts.
+ */
+export function cleanupOldRows(db: DatabaseSync): void {
+  const cutoff = new Date(Date.now() - 90 * 24 * 60 * 60 * 1000).toISOString();
+  try {
+    db.exec(`DELETE FROM agent_activity_log WHERE timestamp < '${cutoff}'`);
+    db.exec(`DELETE FROM scan_history WHERE started_at < '${cutoff}'`);
+    db.exec(`DELETE FROM price_alerts WHERE acknowledged = 1 AND created_at < '${cutoff}'`);
+    db.exec(`DELETE FROM agent_events WHERE timestamp < '${cutoff}'`);
+  } catch {
+    // Cleanup is best-effort — never crash the plugin
+  }
+}
+
 /** Add a column if it doesn't already exist (safe for repeated calls). */
 function ensureColumn(db: DatabaseSync, table: string, column: string, definition: string): void {
   const rows = db.prepare(`PRAGMA table_info(${table})`).all() as Array<{ name: string }>;

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