@openfinclaw/openfinclaw-strategy 2026.3.26 → 2026.3.27

package/index.ts

@@ -4,12 +4,16 @@ import type { Command } from "commander";
  * Features:
  * - Strategy tools: publish, validate, fork, leaderboard
  * - Market data tools: price, K-line, crypto data, compare, search
+ * - SQLite persistence: all tool executions logged; domain tables for strategies and backtests
+ * - 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";
 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 { startHttpServer } from "./src/http/server.js";
 import { registerStrategyTools } from "./src/strategy/tools.js";
 
 const openfinclawPlugin = {
@@ -22,11 +26,14 @@ const openfinclawPlugin = {
   register(api: OpenClawPluginApi) {
     const config = resolvePluginConfig(api);
 
+    // Initialise SQLite database (creates tables on first run)
+    const db = getDb();
+
     // Register DataHub market data tools (fin_price, fin_kline, fin_crypto, fin_compare, fin_slim_search)
-    registerDatahubTools(api, config);
+    registerDatahubTools(api, config, db);
 
     // Register strategy tools (skill_publish, skill_validate, skill_fork, skill_leaderboard, etc.)
-    registerStrategyTools(api, config);
+    registerStrategyTools(api, config, db);
 
     // Register CLI commands
     api.registerCli(
@@ -38,6 +45,9 @@ const openfinclawPlugin = {
         }),
       { commands: ["strategy"] },
     );
+
+    // Start embedded dashboard HTTP server (loopback only, configurable port)
+    startHttpServer(db, config.httpPort, api.logger);
   },
 };
 

package/openclaw.plugin.json

@@ -30,6 +30,13 @@
         "minimum": 5000,
         "maximum": 300000,
         "description": "HTTP request timeout in milliseconds"
+      },
+      "httpPort": {
+        "type": "number",
+        "default": 18792,
+        "minimum": 1024,
+        "maximum": 65535,
+        "description": "Dashboard HTTP server port (loopback only)"
       }
     }
   },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openfinclaw/openfinclaw-strategy",
-  "version": "2026.3.26",
+  "version": "2026.3.27",
   "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",
@@ -34,7 +34,7 @@
     "registry": "https://registry.npmjs.org"
   },
   "dependencies": {
-    "@sinclair/typebox": "^0.34.0",
+    "@sinclair/typebox": "0.34.48",
     "adm-zip": "^0.5.16"
   },
   "devDependencies": {

package/src/config.ts

@@ -48,10 +48,18 @@ export function resolvePluginConfig(api: OpenClawPluginApi): UnifiedPluginConfig
       ? Math.floor(Number(timeoutRaw))
       : DEFAULT_TIMEOUT_MS;
 
+  const httpPortRaw = raw?.httpPort ?? readEnv(["OPENFINCLAW_HTTP_PORT"]);
+  const httpPortNum = Number(httpPortRaw);
+  const httpPort =
+    Number.isFinite(httpPortNum) && httpPortNum >= 1024 && httpPortNum <= 65535
+      ? Math.floor(httpPortNum)
+      : 18792;
+
   return {
     apiKey: apiKey && apiKey.length > 0 ? apiKey : undefined,
     hubApiUrl: hubApiUrl.replace(/\/$/, ""),
     datahubGatewayUrl: datahubGatewayUrl.replace(/\/+$/, ""),
     requestTimeoutMs,
+    httpPort,
   };
 }

package/src/datahub/tools.ts

@@ -1,9 +1,11 @@
+import type { DatabaseSync } from "node:sqlite";
 /**
  * DataHub market data tools registration.
  * Tools: fin_price, fin_kline, fin_crypto, fin_compare, fin_slim_search
  */
 import { Type } from "@sinclair/typebox";
-import type { OpenClawPluginApi } from "openfinclaw/plugin-sdk";
+import type { OpenClawPluginApi } from "openclaw/plugin-sdk";
+import { withLogging } from "../middleware/with-logging.js";
 import type { UnifiedPluginConfig, MarketType } from "../types.js";
 import { DataHubClient, guessMarket } from "./client.js";
 
@@ -29,8 +31,13 @@ const NO_KEY =
 
 /**
  * Register DataHub market data tools.
+ * @param db - SQLite database for activity logging.
  */
-export function registerDatahubTools(api: OpenClawPluginApi, config: UnifiedPluginConfig): void {
+export function registerDatahubTools(
+  api: OpenClawPluginApi,
+  config: UnifiedPluginConfig,
+  db: DatabaseSync,
+): void {
   const datahubClient = config.apiKey
     ? new DataHubClient(config.datahubGatewayUrl, config.apiKey, config.requestTimeoutMs)
     : null;
@@ -84,7 +91,7 @@ export function registerDatahubTools(api: OpenClawPluginApi, config: UnifiedPlug
           }),
         ),
       }),
-      async execute(_id: string, params: Record<string, unknown>) {
+      execute: withLogging(db, "fin_price", "market-data", async (_id, params) => {
         try {
           if (!datahubClient) return json({ error: NO_KEY });
           const symbol = String(params.symbol);
@@ -100,7 +107,7 @@ export function registerDatahubTools(api: OpenClawPluginApi, config: UnifiedPlug
         } catch (err) {
           return json({ error: err instanceof Error ? err.message : String(err) });
         }
-      },
+      }),
     },
     { names: ["fin_price"] },
   );
@@ -128,7 +135,7 @@ export function registerDatahubTools(api: OpenClawPluginApi, config: UnifiedPlug
           Type.Number({ description: "Number of bars to return (default: 30)" }),
         ),
       }),
-      async execute(_id: string, params: Record<string, unknown>) {
+      execute: withLogging(db, "fin_kline", "market-data", async (_id, params) => {
         try {
           if (!datahubClient) return json({ error: NO_KEY });
           const symbol = String(params.symbol);
@@ -151,7 +158,7 @@ export function registerDatahubTools(api: OpenClawPluginApi, config: UnifiedPlug
         } catch (err) {
           return json({ error: err instanceof Error ? err.message : String(err) });
         }
-      },
+      }),
     },
     { names: ["fin_kline"] },
   );
@@ -202,7 +209,7 @@ export function registerDatahubTools(api: OpenClawPluginApi, config: UnifiedPlug
         end_date: Type.Optional(Type.String({ description: "End date (YYYY-MM-DD)" })),
         limit: Type.Optional(Type.Number({ description: "Max results (default: 20)" })),
       }),
-      async execute(_id: string, params: Record<string, unknown>) {
+      execute: withLogging(db, "fin_crypto", "market-data", async (_id, params) => {
         try {
           if (!datahubClient) return json({ error: NO_KEY });
           const endpoint = String(params.endpoint ?? "coin/market");
@@ -231,7 +238,7 @@ export function registerDatahubTools(api: OpenClawPluginApi, config: UnifiedPlug
         } catch (err) {
           return json({ error: err instanceof Error ? err.message : String(err) });
         }
-      },
+      }),
     },
     { names: ["fin_crypto"] },
   );
@@ -249,7 +256,7 @@ export function registerDatahubTools(api: OpenClawPluginApi, config: UnifiedPlug
           description: "Comma-separated symbols (2-5). Example: BTC/USDT,ETH/USDT,600519.SH",
         }),
       }),
-      async execute(_id: string, params: Record<string, unknown>) {
+      execute: withLogging(db, "fin_compare", "market-data", async (_id, params) => {
         try {
           if (!datahubClient) return json({ error: NO_KEY });
           const raw = String(params.symbols);
@@ -287,7 +294,7 @@ export function registerDatahubTools(api: OpenClawPluginApi, config: UnifiedPlug
         } catch (err) {
           return json({ error: err instanceof Error ? err.message : String(err) });
         }
-      },
+      }),
     },
     { names: ["fin_compare"] },
   );
@@ -310,7 +317,7 @@ export function registerDatahubTools(api: OpenClawPluginApi, config: UnifiedPlug
           }),
         ),
       }),
-      async execute(_id: string, params: Record<string, unknown>) {
+      execute: withLogging(db, "fin_slim_search", "market-data", async (_id, params) => {
         try {
           if (!datahubClient) return json({ error: NO_KEY });
           const q = String(params.query);
@@ -340,7 +347,7 @@ export function registerDatahubTools(api: OpenClawPluginApi, config: UnifiedPlug
         } catch (err) {
           return json({ error: err instanceof Error ? err.message : String(err) });
         }
-      },
+      }),
     },
     { names: ["fin_slim_search"] },
   );

package/src/db/db.ts

@@ -0,0 +1,44 @@
+import { mkdirSync } from "node:fs";
+/**
+ * SQLite database singleton for OpenFinClaw plugin.
+ * Database path: ~/.openfinclaw/workspace/openfinclaw-plugin.db
+ */
+import { createRequire } from "node:module";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import type { DatabaseSync } from "node:sqlite";
+import { ensureSchema } from "./schema.js";
+
+// Use createRequire to load the built-in node:sqlite in an ESM context.
+const _require = createRequire(import.meta.url);
+
+let _db: DatabaseSync | null = null;
+
+/** Resolve the database file path under ~/.openfinclaw/workspace/. */
+function resolveDbPath(): string {
+  const base = join(homedir(), ".openfinclaw", "workspace");
+  mkdirSync(base, { recursive: true });
+  return join(base, "openfinclaw-plugin.db");
+}
+
+/**
+ * Get (or lazily initialise) the SQLite database singleton.
+ * Calls ensureSchema on first access to create missing tables.
+ */
+export function getDb(): DatabaseSync {
+  if (_db) return _db;
+  // node:sqlite is available in Node 22+
+  const { DatabaseSync } = _require("node:sqlite") as typeof import("node:sqlite");
+  const dbPath = resolveDbPath();
+  _db = new DatabaseSync(dbPath);
+  ensureSchema(_db);
+  return _db;
+}
+
+/** Close the database (used in tests / graceful shutdown). */
+export function closeDb(): void {
+  if (_db) {
+    _db.close();
+    _db = null;
+  }
+}

package/src/db/repositories.ts

@@ -0,0 +1,315 @@
+/**
+ * Data access helpers for OpenFinClaw plugin SQLite tables.
+ */
+import type { DatabaseSync } from "node:sqlite";
+
+// ── Row types ─────────────────────────────────────────────────────────────
+
+export interface ActivityLogEntry {
+  id: string;
+  timestamp: string;
+  category: string;
+  action: string;
+  strategy_id?: string | null;
+  detail?: string | null;
+  metadata_json?: string | null;
+}
+
+export interface AgentEventEntry {
+  id: string;
+  type: string;
+  title: string;
+  detail?: string | null;
+  timestamp: string;
+  status?: string | null;
+  action_params_json?: string | null;
+  narration?: string | null;
+  feed_type?: string | null;
+  chips_json?: string | null;
+  sparkline_json?: string | null;
+  category?: string | null;
+  severity?: string | null;
+  strategy_id?: string | null;
+  reasoning?: string | null;
+}
+
+/**
+ * Strategy lifecycle levels:
+ * - L0: 创建 / Fork（尚未回测）
+ * - L1: 回测中 / 回测完成
+ * - L2: 模拟盘运行中（预留）
+ * - L3: 实盘运行中（预留）
+ */
+export type StrategyLevel = "L0" | "L1" | "L2" | "L3";
+
+export interface StrategyRow {
+  id: string;
+  name: string;
+  template_id?: string | null;
+  /** 策略生命周期阶段：L0 创建 → L1 回测 → L2 模拟盘 → L3 实盘 */
+  level?: StrategyLevel | null;
+  status: string;
+  symbols?: string | null;
+  timeframes?: string | null;
+  markets?: string | null;
+  exchange_id?: string | null;
+  parameters?: string | null;
+  definition?: string | null;
+  version: number;
+  created_at: string;
+  updated_at: string;
+  promoted_at?: string | null;
+  last_backtest_id?: string | null;
+  last_paper_session_id?: string | null;
+  tags?: string | null;
+}
+
+export interface BacktestRow {
+  id: string;
+  strategy_id: string;
+  remote_task_id?: string | null;
+  status: string;
+  total_return?: number | null;
+  sharpe?: number | null;
+  sortino?: number | null;
+  max_drawdown?: number | null;
+  win_rate?: number | null;
+  profit_factor?: number | null;
+  total_trades?: number | null;
+  final_equity?: number | null;
+  initial_capital?: number | null;
+  equity_curve?: string | null;
+  trade_journal?: string | null;
+  monthly_returns?: string | null;
+  tearsheet_html?: string | null;
+  submitted_at?: string | null;
+  completed_at?: string | null;
+  created_at: string;
+}
+
+// ── Writes ────────────────────────────────────────────────────────────────
+
+/** Insert one row into agent_activity_log. Silently swallows errors to never interrupt tools. */
+export function insertActivityLog(db: DatabaseSync, entry: ActivityLogEntry): void {
+  try {
+    db.prepare(`
+      INSERT INTO agent_activity_log
+        (id, timestamp, category, action, strategy_id, detail, metadata_json)
+      VALUES (?, ?, ?, ?, ?, ?, ?)
+    `).run(
+      entry.id,
+      entry.timestamp,
+      entry.category,
+      entry.action,
+      entry.strategy_id ?? null,
+      entry.detail ?? null,
+      entry.metadata_json ?? null,
+    );
+  } catch {
+    // Logging must never crash the calling tool
+  }
+}
+
+/** Insert one row into agent_events. Silently swallows errors. */
+export function insertAgentEvent(db: DatabaseSync, event: AgentEventEntry): void {
+  try {
+    db.prepare(`
+      INSERT INTO agent_events
+        (id, type, title, detail, timestamp, status, action_params_json,
+         narration, feed_type, chips_json, sparkline_json, category, severity,
+         strategy_id, reasoning)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `).run(
+      event.id,
+      event.type,
+      event.title,
+      event.detail ?? null,
+      event.timestamp,
+      event.status ?? null,
+      event.action_params_json ?? null,
+      event.narration ?? null,
+      event.feed_type ?? null,
+      event.chips_json ?? null,
+      event.sparkline_json ?? null,
+      event.category ?? null,
+      event.severity ?? null,
+      event.strategy_id ?? null,
+      event.reasoning ?? null,
+    );
+  } catch {
+    // Logging must never crash the calling tool
+  }
+}
+
+/** Insert or replace a strategy row. */
+export function upsertStrategy(db: DatabaseSync, row: StrategyRow): void {
+  try {
+    db.prepare(`
+      INSERT INTO strategies
+        (id, name, template_id, level, status, symbols, timeframes, markets,
+         exchange_id, parameters, definition, version, created_at, updated_at,
+         promoted_at, last_backtest_id, last_paper_session_id, tags)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+      ON CONFLICT(id) DO UPDATE SET
+        name                  = excluded.name,
+        template_id           = excluded.template_id,
+        level                 = excluded.level,
+        status                = excluded.status,
+        symbols               = excluded.symbols,
+        timeframes            = excluded.timeframes,
+        markets               = excluded.markets,
+        exchange_id           = excluded.exchange_id,
+        parameters            = excluded.parameters,
+        definition            = excluded.definition,
+        version               = excluded.version,
+        updated_at            = excluded.updated_at,
+        promoted_at           = excluded.promoted_at,
+        last_backtest_id      = excluded.last_backtest_id,
+        last_paper_session_id = excluded.last_paper_session_id,
+        tags                  = excluded.tags
+    `).run(
+      row.id,
+      row.name,
+      row.template_id ?? null,
+      row.level ?? null,
+      row.status,
+      row.symbols ?? null,
+      row.timeframes ?? null,
+      row.markets ?? null,
+      row.exchange_id ?? null,
+      row.parameters ?? null,
+      row.definition ?? null,
+      row.version,
+      row.created_at,
+      row.updated_at,
+      row.promoted_at ?? null,
+      row.last_backtest_id ?? null,
+      row.last_paper_session_id ?? null,
+      row.tags ?? null,
+    );
+  } catch {
+    // Logging must never crash the calling tool
+  }
+}
+
+/** Insert a backtest result row. */
+export function insertBacktestResult(db: DatabaseSync, row: BacktestRow): void {
+  try {
+    db.prepare(`
+      INSERT INTO backtest_results
+        (id, strategy_id, remote_task_id, status, total_return, sharpe, sortino,
+         max_drawdown, win_rate, profit_factor, total_trades, final_equity,
+         initial_capital, equity_curve, trade_journal, monthly_returns,
+         tearsheet_html, submitted_at, completed_at, created_at)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `).run(
+      row.id,
+      row.strategy_id,
+      row.remote_task_id ?? null,
+      row.status,
+      row.total_return ?? null,
+      row.sharpe ?? null,
+      row.sortino ?? null,
+      row.max_drawdown ?? null,
+      row.win_rate ?? null,
+      row.profit_factor ?? null,
+      row.total_trades ?? null,
+      row.final_equity ?? null,
+      row.initial_capital ?? null,
+      row.equity_curve ?? null,
+      row.trade_journal ?? null,
+      row.monthly_returns ?? null,
+      row.tearsheet_html ?? null,
+      row.submitted_at ?? null,
+      row.completed_at ?? null,
+      row.created_at,
+    );
+  } catch {
+    // Logging must never crash the calling tool
+  }
+}
+
+/** Update backtest_results metrics after publish_verify completes. */
+export function updateBacktestResult(
+  db: DatabaseSync,
+  id: string,
+  patch: Partial<
+    Pick<
+      BacktestRow,
+      | "status"
+      | "total_return"
+      | "sharpe"
+      | "sortino"
+      | "max_drawdown"
+      | "win_rate"
+      | "profit_factor"
+      | "total_trades"
+      | "final_equity"
+      | "equity_curve"
+      | "trade_journal"
+      | "monthly_returns"
+      | "tearsheet_html"
+      | "completed_at"
+    >
+  >,
+): void {
+  try {
+    const sets: string[] = [];
+    const values: unknown[] = [];
+    for (const [k, v] of Object.entries(patch)) {
+      sets.push(`${k} = ?`);
+      values.push(v ?? null);
+    }
+    if (sets.length === 0) return;
+    values.push(id);
+    db.prepare(`UPDATE backtest_results SET ${sets.join(", ")} WHERE id = ?`).run(...values);
+  } catch {
+    // Logging must never crash the calling tool
+  }
+}
+
+/** Update strategy level by id. */
+export function updateStrategyLevel(db: DatabaseSync, id: string, level: StrategyLevel): void {
+  try {
+    db.prepare(`UPDATE strategies SET level = ?, updated_at = ? WHERE id = ?`).run(
+      level,
+      new Date().toISOString(),
+      id,
+    );
+  } catch {
+    // Logging must never crash the calling tool
+  }
+}
+
+// ── Reads ─────────────────────────────────────────────────────────────────
+
+/** Query agent_activity_log, newest first. */
+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[];
+}
+
+/** 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[];
+}
+
+/** 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[];
+}
+
+/** Query backtest results, optionally filtered by strategy_id. */
+export function queryBacktestResults(db: DatabaseSync, strategyId?: string): BacktestRow[] {
+  if (strategyId) {
+    return db
+      .prepare(`SELECT * FROM backtest_results WHERE strategy_id = ? ORDER BY created_at DESC`)
+      .all(strategyId) as BacktestRow[];
+  }
+  return db
+    .prepare(`SELECT * FROM backtest_results ORDER BY created_at DESC`)
+    .all() as BacktestRow[];
+}

package/src/db/schema.ts

@@ -0,0 +1,110 @@
+/**
+ * SQLite schema for OpenFinClaw plugin (MVP 4 tables).
+ * Based on ER diagram v0.3 — openfinclaw-opc-fund-plugin.
+ */
+import type { DatabaseSync } from "node:sqlite";
+
+/**
+ * Create (or migrate) all MVP tables.
+ * Safe to call multiple times — uses CREATE TABLE IF NOT EXISTS.
+ */
+export function ensureSchema(db: DatabaseSync): void {
+  // ── strategies ────────────────────────────────────────────────────────────
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS strategies (
+      id                   TEXT PRIMARY KEY,
+      name                 TEXT NOT NULL,
+      template_id          TEXT,
+      level                TEXT DEFAULT 'L0',
+      status               TEXT NOT NULL DEFAULT 'draft',
+      symbols              TEXT,
+      timeframes           TEXT,
+      markets              TEXT,
+      exchange_id          TEXT,
+      parameters           TEXT,
+      definition           TEXT,
+      version              INTEGER NOT NULL DEFAULT 1,
+      created_at           TEXT NOT NULL,
+      updated_at           TEXT NOT NULL,
+      promoted_at          TEXT,
+      last_backtest_id     TEXT,
+      last_paper_session_id TEXT,
+      tags                 TEXT
+    );
+  `);
+
+  // ── backtest_results ──────────────────────────────────────────────────────
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS backtest_results (
+      id               TEXT PRIMARY KEY,
+      strategy_id      TEXT NOT NULL,
+      remote_task_id   TEXT,
+      status           TEXT NOT NULL DEFAULT 'pending',
+      total_return     REAL,
+      sharpe           REAL,
+      sortino          REAL,
+      max_drawdown     REAL,
+      win_rate         REAL,
+      profit_factor    REAL,
+      total_trades     INTEGER,
+      final_equity     REAL,
+      initial_capital  REAL,
+      equity_curve     TEXT,
+      trade_journal    TEXT,
+      monthly_returns  TEXT,
+      tearsheet_html   TEXT,
+      submitted_at     TEXT,
+      completed_at     TEXT,
+      created_at       TEXT NOT NULL,
+      FOREIGN KEY (strategy_id) REFERENCES strategies(id)
+    );
+  `);
+  db.exec(`CREATE INDEX IF NOT EXISTS idx_br_strategy_id ON backtest_results(strategy_id);`);
+
+  // ── agent_activity_log ────────────────────────────────────────────────────
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS agent_activity_log (
+      id            TEXT PRIMARY KEY,
+      timestamp     TEXT NOT NULL,
+      category      TEXT NOT NULL,
+      action        TEXT NOT NULL,
+      strategy_id   TEXT,
+      detail        TEXT,
+      metadata_json TEXT
+    );
+  `);
+  db.exec(`CREATE INDEX IF NOT EXISTS idx_aal_timestamp ON agent_activity_log(timestamp);`);
+  db.exec(`CREATE INDEX IF NOT EXISTS idx_aal_category ON agent_activity_log(category);`);
+
+  // ── agent_events ──────────────────────────────────────────────────────────
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS agent_events (
+      id                TEXT PRIMARY KEY,
+      type              TEXT NOT NULL,
+      title             TEXT NOT NULL,
+      detail            TEXT,
+      timestamp         TEXT NOT NULL,
+      status            TEXT,
+      action_params_json TEXT,
+      narration         TEXT,
+      feed_type         TEXT,
+      chips_json        TEXT,
+      sparkline_json    TEXT,
+      category          TEXT,
+      severity          TEXT,
+      strategy_id       TEXT,
+      reasoning         TEXT
+    );
+  `);
+  db.exec(`CREATE INDEX IF NOT EXISTS idx_ae_timestamp ON agent_events(timestamp);`);
+  db.exec(`CREATE INDEX IF NOT EXISTS idx_ae_strategy_id ON agent_events(strategy_id);`);
+
+  // ── migrations (add columns to existing databases) ──────────────────────
+}
+
+/** 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 }>;
+  if (rows.some((r) => r.name === column)) return;
+  db.exec(`ALTER TABLE ${table} ADD COLUMN ${column} ${definition}`);
+}

package/src/http/routes.ts

@@ -0,0 +1,107 @@
+/**
+ * REST route handlers for the OpenFinClaw dashboard HTTP server.
+ */
+import { readFileSync } from "node:fs";
+import type { IncomingMessage, ServerResponse } from "node:http";
+import { join } from "node:path";
+import type { DatabaseSync } from "node:sqlite";
+import { fileURLToPath } from "node:url";
+import {
+  queryActivityLog,
+  queryAgentEvents,
+  queryStrategies,
+  queryBacktestResults,
+} from "../db/repositories.js";
+
+// Resolve path to web/index.html relative to this file's location
+const WEB_DIR = join(fileURLToPath(import.meta.url), "..", "..", "..", "web");
+
+function getIndexHtml(): string {
+  return readFileSync(join(WEB_DIR, "index.html"), "utf8");
+}
+
+function parseQueryParam(url: string, name: string, fallback: number): number {
+  try {
+    const u = new URL(url, "http://localhost");
+    const v = u.searchParams.get(name);
+    const n = v != null ? parseInt(v, 10) : NaN;
+    return Number.isFinite(n) && n >= 0 ? n : fallback;
+  } catch {
+    return fallback;
+  }
+}
+
+function parseStringParam(url: string, name: string): string | undefined {
+  try {
+    const u = new URL(url, "http://localhost");
+    return u.searchParams.get(name) ?? undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+function sendJson(res: ServerResponse, data: unknown): void {
+  const body = JSON.stringify(data);
+  res.writeHead(200, {
+    "Content-Type": "application/json",
+    "Content-Length": Buffer.byteLength(body),
+    "Access-Control-Allow-Origin": "*",
+  });
+  res.end(body);
+}
+
+function sendHtml(res: ServerResponse, html: string): void {
+  res.writeHead(200, { "Content-Type": "text/html; charset=utf-8" });
+  res.end(html);
+}
+
+function send404(res: ServerResponse): void {
+  res.writeHead(404, { "Content-Type": "text/plain" });
+  res.end("Not found");
+}
+
+/**
+ * Dispatch an incoming HTTP request to the appropriate handler.
+ */
+export function handleRoute(db: DatabaseSync, req: IncomingMessage, res: ServerResponse): void {
+  const url = req.url ?? "/";
+  const pathname = url.split("?")[0];
+
+  // Dashboard HTML
+  if (pathname === "/" || pathname === "/index.html") {
+    try {
+      sendHtml(res, getIndexHtml());
+    } catch {
+      res.writeHead(500);
+      res.end("Failed to load dashboard HTML");
+    }
+    return;
+  }
+
+  if (pathname === "/api/activity-log") {
+    const limit = parseQueryParam(url, "limit", 50);
+    const offset = parseQueryParam(url, "offset", 0);
+    sendJson(res, queryActivityLog(db, limit, offset));
+    return;
+  }
+
+  if (pathname === "/api/agent-events") {
+    const limit = parseQueryParam(url, "limit", 50);
+    const offset = parseQueryParam(url, "offset", 0);
+    sendJson(res, queryAgentEvents(db, limit, offset));
+    return;
+  }
+
+  if (pathname === "/api/strategies") {
+    sendJson(res, queryStrategies(db));
+    return;
+  }
+
+  if (pathname === "/api/backtest-results") {
+    const strategyId = parseStringParam(url, "strategy_id");
+    sendJson(res, queryBacktestResults(db, strategyId));
+    return;
+  }
+
+  send404(res);
+}

package/src/http/server.ts

@@ -0,0 +1,36 @@
+/**
+ * Embedded HTTP server for the OpenFinClaw dashboard.
+ * Binds to 127.0.0.1 only (loopback) for local access.
+ */
+import { createServer } from "node:http";
+import type { DatabaseSync } from "node:sqlite";
+import { handleRoute } from "./routes.js";
+
+export interface DashboardLogger {
+  info(msg: string): void;
+}
+
+/**
+ * Start the dashboard HTTP server.
+ * Errors during individual requests are caught and returned as 500s.
+ */
+export function startHttpServer(db: DatabaseSync, port: number, logger: DashboardLogger): void {
+  const server = createServer((req, res) => {
+    try {
+      handleRoute(db, req, res);
+    } catch (err) {
+      if (!res.headersSent) {
+        res.writeHead(500, { "Content-Type": "text/plain" });
+      }
+      res.end(`Internal Server Error: ${String(err)}`);
+    }
+  });
+
+  server.on("error", (err) => {
+    logger.info(`[OpenFinClaw] Dashboard server error: ${String(err)}`);
+  });
+
+  server.listen(port, "127.0.0.1", () => {
+    logger.info(`[OpenFinClaw] Dashboard available at http://127.0.0.1:${port}`);
+  });
+}

package/src/middleware/with-logging.ts

@@ -0,0 +1,72 @@
+/**
+ * Higher-order function that wraps a tool execute() to automatically log
+ * every invocation (success or failure) into agent_activity_log.
+ */
+import { randomUUID } from "node:crypto";
+import type { DatabaseSync } from "node:sqlite";
+import { insertActivityLog } from "../db/repositories.js";
+
+/**
+ * Generic tool execute function signature.
+ * Uses `(...args: never[])` rest params so the wrapper is assignable to any
+ * concrete execute overload the SDK defines (extra optional params like
+ * `signal` and `onUpdate` are passed through transparently).
+ */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+type AnyExecuteFn = (
+  toolCallId: string,
+  params: Record<string, unknown>,
+  ...rest: any[]
+) => Promise<any>;
+
+/**
+ * Wrap a tool execute function with automatic activity logging.
+ *
+ * @param db        - The SQLite database instance.
+ * @param toolName  - Name used as the `action` column value.
+ * @param category  - Broad category, e.g. "market-data" or "strategy".
+ * @param fn        - The original execute function to wrap.
+ * @param opts      - Optional: extract strategy_id from params for context.
+ */
+export function withLogging<T extends AnyExecuteFn>(
+  db: DatabaseSync,
+  toolName: string,
+  category: string,
+  fn: T,
+  opts?: { strategyIdParam?: string },
+): T {
+  const wrapped: AnyExecuteFn = async (toolCallId, params, ...rest) => {
+    const logId = randomUUID();
+    const startMs = Date.now();
+    const strategyId =
+      opts?.strategyIdParam != null
+        ? ((params[opts.strategyIdParam] as string | undefined) ?? null)
+        : null;
+
+    try {
+      const result = await fn(toolCallId, params, ...rest);
+      insertActivityLog(db, {
+        id: logId,
+        timestamp: new Date().toISOString(),
+        category,
+        action: toolName,
+        strategy_id: strategyId,
+        detail: `OK (${Date.now() - startMs}ms)`,
+        metadata_json: JSON.stringify({ toolCallId, params }),
+      });
+      return result;
+    } catch (err) {
+      insertActivityLog(db, {
+        id: logId,
+        timestamp: new Date().toISOString(),
+        category,
+        action: toolName,
+        strategy_id: strategyId,
+        detail: `ERROR (${Date.now() - startMs}ms): ${String(err)}`,
+        metadata_json: JSON.stringify({ toolCallId, params }),
+      });
+      throw err;
+    }
+  };
+  return wrapped as T;
+}

package/src/strategy/tools.ts

@@ -1,10 +1,20 @@
+import { randomUUID } from "node:crypto";
 /**
  * Strategy tools registration.
  * Tools: skill_publish, skill_publish_verify, skill_validate, skill_leaderboard, skill_fork, skill_list_local, skill_get_info
  */
 import { readFile } from "node:fs/promises";
+import type { DatabaseSync } from "node:sqlite";
 import { Type } from "@sinclair/typebox";
 import type { OpenClawPluginApi } from "openfinclaw/plugin-sdk";
+import {
+  insertAgentEvent,
+  insertBacktestResult,
+  updateBacktestResult,
+  updateStrategyLevel,
+  upsertStrategy,
+} from "../db/repositories.js";
+import { withLogging } from "../middleware/with-logging.js";
 import type { UnifiedPluginConfig, BoardType, LeaderboardResponse } from "../types.js";
 import { hubApiRequest } from "./client.js";
 import { forkStrategy, fetchStrategyInfo } from "./fork.js";
@@ -24,8 +34,13 @@ const NO_API_KEY =
 
 /**
  * Register strategy tools.
+ * @param db - SQLite database for activity logging and domain table writes.
  */
-export function registerStrategyTools(api: OpenClawPluginApi, config: UnifiedPluginConfig): void {
+export function registerStrategyTools(
+  api: OpenClawPluginApi,
+  config: UnifiedPluginConfig,
+  db: DatabaseSync,
+): void {
   // ── skill_publish ──
   api.registerTool(
     {
@@ -45,7 +60,7 @@ export function registerStrategyTools(api: OpenClawPluginApi, config: UnifiedPlu
           }),
         ),
       }),
-      async execute(_toolCallId: string, params: Record<string, unknown>) {
+      execute: withLogging(db, "skill_publish", "strategy", async (_toolCallId, params) => {
         try {
           const filePath = String(params.filePath ?? "").trim();
           if (!filePath) return json({ success: false, error: "filePath is required" });
@@ -87,6 +102,57 @@ export function registerStrategyTools(api: OpenClawPluginApi, config: UnifiedPlu
               creditsEarned?: { action?: string; amount?: number; message?: string };
             };
 
+            // Persist strategy + pending backtest result
+            const now = new Date().toISOString();
+            const strategyId = resp.entryId ?? resp.slug ?? randomUUID();
+            const hubVersion = Number(resp.version) || 1;
+            upsertStrategy(db, {
+              id: strategyId,
+              name: resp.slug ?? filePath,
+              status: "published",
+              level: resp.backtestTaskId ? "L1" : "L0",
+              version: hubVersion,
+              created_at: now,
+              updated_at: now,
+              promoted_at: now,
+            });
+
+            if (resp.backtestTaskId) {
+              const backtestId = randomUUID();
+              insertBacktestResult(db, {
+                id: backtestId,
+                strategy_id: strategyId,
+                remote_task_id: resp.backtestTaskId,
+                status: "pending",
+                submitted_at: now,
+                created_at: now,
+              });
+              upsertStrategy(db, {
+                id: strategyId,
+                name: resp.slug ?? filePath,
+                status: "published",
+                level: "L1",
+                version: hubVersion,
+                created_at: now,
+                updated_at: now,
+                promoted_at: now,
+                last_backtest_id: backtestId,
+              });
+            }
+
+            insertAgentEvent(db, {
+              id: randomUUID(),
+              type: "publish",
+              title: `策略发布: ${resp.slug ?? "(未知)"}`,
+              detail: `Entry ID: ${resp.entryId ?? "—"} | Backtest: ${resp.backtestTaskId ?? "—"}`,
+              timestamp: now,
+              status: "info",
+              category: "strategy",
+              severity: "low",
+              strategy_id: strategyId,
+              narration: `策略 ${resp.slug ?? filePath} 已成功发布到 Hub`,
+            });
+
             const lines: string[] = [];
             lines.push("Skill 发布成功！");
             lines.push("");
@@ -118,7 +184,7 @@ export function registerStrategyTools(api: OpenClawPluginApi, config: UnifiedPlu
             error: err instanceof Error ? err.message : String(err),
           });
         }
-      },
+      }),
     },
     { names: ["skill_publish"] },
   );
@@ -138,7 +204,7 @@ export function registerStrategyTools(api: OpenClawPluginApi, config: UnifiedPlu
           Type.String({ description: "Backtest task ID from skill_publish response" }),
         ),
       }),
-      async execute(_toolCallId: string, params: Record<string, unknown>) {
+      execute: withLogging(db, "skill_publish_verify", "strategy", async (_toolCallId, params) => {
         try {
           const submissionId = String(params.submissionId ?? "").trim() || undefined;
           const backtestTaskId = String(params.backtestTaskId ?? "").trim() || undefined;
@@ -167,6 +233,31 @@ export function registerStrategyTools(api: OpenClawPluginApi, config: UnifiedPlu
 
           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 perf = (resp.backtestReport as Record<string, unknown> | undefined)
+                ?.performance as Record<string, unknown> | undefined;
+              updateBacktestResult(db, backtestTaskId, {
+                status: "completed",
+                total_return: typeof perf?.totalReturn === "number" ? perf.totalReturn : undefined,
+                sharpe: typeof perf?.sharpe === "number" ? perf.sharpe : undefined,
+                max_drawdown: typeof perf?.maxDrawdown === "number" ? perf.maxDrawdown : undefined,
+                win_rate: typeof perf?.winRate === "number" ? perf.winRate : undefined,
+                completed_at: new Date().toISOString(),
+              });
+              // Backtest completed → strategy stays at L1
+              if (verifyStrategyId) updateStrategyLevel(db, verifyStrategyId, "L1");
+            } else if (resp.backtestStatus === "failed" && backtestTaskId) {
+              updateBacktestResult(db, backtestTaskId, {
+                status: "failed",
+                completed_at: new Date().toISOString(),
+              });
+              // Backtest failed → revert to L0
+              if (verifyStrategyId) updateStrategyLevel(db, verifyStrategyId, "L0");
+            }
+
             const lines: string[] = [];
             lines.push("发布验证结果：");
             lines.push(`- Slug: ${resp.slug ?? "(未知)"}`);
@@ -211,7 +302,7 @@ export function registerStrategyTools(api: OpenClawPluginApi, config: UnifiedPlu
             error: err instanceof Error ? err.message : String(err),
           });
         }
-      },
+      }),
     },
     { names: ["skill_publish_verify"] },
   );
@@ -228,7 +319,7 @@ export function registerStrategyTools(api: OpenClawPluginApi, config: UnifiedPlu
           description: "Path to strategy package directory (must contain fep.yaml)",
         }),
       }),
-      async execute(_toolCallId: string, params: Record<string, unknown>) {
+      execute: withLogging(db, "skill_validate", "strategy", async (_toolCallId, params) => {
         try {
           const dirPath = String(params.dirPath ?? "").trim();
           if (!dirPath)
@@ -248,7 +339,7 @@ export function registerStrategyTools(api: OpenClawPluginApi, config: UnifiedPlu
             errors: [err instanceof Error ? err.message : String(err)],
           });
         }
-      },
+      }),
     },
     { names: ["skill_validate"] },
   );
@@ -272,7 +363,7 @@ export function registerStrategyTools(api: OpenClawPluginApi, config: UnifiedPlu
         ),
         offset: Type.Optional(Type.Number({ description: "Offset for pagination" })),
       }),
-      async execute(_toolCallId: string, params: Record<string, unknown>) {
+      execute: withLogging(db, "skill_leaderboard", "strategy", async (_toolCallId, params) => {
         try {
           const boardType = (params.boardType as BoardType) || "composite";
           const limit = Math.min(Math.max(Number(params.limit) || 20, 1), 100);
@@ -352,7 +443,7 @@ export function registerStrategyTools(api: OpenClawPluginApi, config: UnifiedPlu
             error: err instanceof Error ? err.message : String(err),
           });
         }
-      },
+      }),
     },
     { names: ["skill_leaderboard"] },
   );
@@ -371,46 +462,79 @@ export function registerStrategyTools(api: OpenClawPluginApi, config: UnifiedPlu
         name: Type.Optional(Type.String({ description: "Name for the forked strategy" })),
         targetDir: Type.Optional(Type.String({ description: "Custom target directory" })),
       }),
-      async execute(_toolCallId: string, params: Record<string, unknown>) {
-        try {
-          const strategyId = String(params.strategyId ?? "").trim();
-          if (!strategyId) return json({ success: false, error: "strategyId is required" });
+      execute: withLogging(
+        db,
+        "skill_fork",
+        "strategy",
+        async (_toolCallId, params) => {
+          try {
+            const strategyId = String(params.strategyId ?? "").trim();
+            if (!strategyId) return json({ success: false, error: "strategyId is required" });
+
+            if (!config.apiKey) {
+              return json({
+                success: false,
+                error: "API key is required for fork operation.",
+              });
+            }
 
-          if (!config.apiKey) {
-            return json({
-              success: false,
-              error: "API key is required for fork operation.",
+            const result = await forkStrategy(config, strategyId, {
+              name: params.name ? String(params.name) : undefined,
+              targetDir: params.targetDir ? String(params.targetDir) : undefined,
             });
-          }
 
-          const result = await forkStrategy(config, strategyId, {
-            name: params.name ? String(params.name) : undefined,
-            targetDir: params.targetDir ? String(params.targetDir) : undefined,
-          });
+            if (result.success) {
+              // Persist forked strategy to DB
+              const now = new Date().toISOString();
+              const localId = result.forkEntryId ?? strategyId;
+              upsertStrategy(db, {
+                id: localId,
+                name: result.sourceName ?? (params.name ? String(params.name) : strategyId),
+                template_id: result.sourceId,
+                status: "forked",
+                level: "L0",
+                version: Number(result.sourceVersion) || 1,
+                created_at: now,
+                updated_at: now,
+              });
+
+              insertAgentEvent(db, {
+                id: randomUUID(),
+                type: "fork",
+                title: `Fork 策略: ${result.sourceName ?? strategyId}`,
+                detail: `本地路径: ${result.localPath}`,
+                timestamp: now,
+                status: "info",
+                category: "strategy",
+                severity: "low",
+                strategy_id: localId,
+                narration: `已将策略 ${result.sourceName ?? strategyId} Fork 到本地`,
+              });
+
+              const lines: string[] = [];
+              lines.push("策略 Fork 成功！");
+              lines.push(`- 原策略: ${result.sourceName} (${result.sourceId})`);
+              lines.push(`- 本地路径: ${result.localPath}`);
+              lines.push("");
+              lines.push("下一步:");
+              lines.push(`- 编辑策略: code ${result.localPath}/scripts/strategy.py`);
 
-          if (result.success) {
-            const lines: string[] = [];
-            lines.push("策略 Fork 成功！");
-            lines.push(`- 原策略: ${result.sourceName} (${result.sourceId})`);
-            lines.push(`- 本地路径: ${result.localPath}`);
-            lines.push("");
-            lines.push("下一步:");
-            lines.push(`- 编辑策略: code ${result.localPath}/scripts/strategy.py`);
+              return {
+                content: [{ type: "text" as const, text: lines.join("\n") }],
+                details: result,
+              };
+            }
 
-            return {
-              content: [{ type: "text" as const, text: lines.join("\n") }],
-              details: result,
-            };
+            return json({ success: false, error: result.error ?? "Failed to fork strategy" });
+          } catch (err) {
+            return json({
+              success: false,
+              error: err instanceof Error ? err.message : String(err),
+            });
           }
-
-          return json({ success: false, error: result.error ?? "Failed to fork strategy" });
-        } catch (err) {
-          return json({
-            success: false,
-            error: err instanceof Error ? err.message : String(err),
-          });
-        }
-      },
+        },
+        { strategyIdParam: "strategyId" },
+      ),
     },
     { names: ["skill_fork"] },
   );
@@ -422,7 +546,7 @@ export function registerStrategyTools(api: OpenClawPluginApi, config: UnifiedPlu
       label: "List local strategies",
       description: "List all strategies downloaded or created locally, organized by date.",
       parameters: Type.Object({}),
-      async execute() {
+      execute: withLogging(db, "skill_list_local", "strategy", async () => {
         try {
           const strategies = await listLocalStrategies();
 
@@ -461,7 +585,7 @@ export function registerStrategyTools(api: OpenClawPluginApi, config: UnifiedPlu
             error: err instanceof Error ? err.message : String(err),
           });
         }
-      },
+      }),
     },
     { names: ["skill_list_local"] },
   );
@@ -476,45 +600,54 @@ export function registerStrategyTools(api: OpenClawPluginApi, config: UnifiedPlu
       parameters: Type.Object({
         strategyId: Type.String({ description: "Strategy ID from Hub (UUID or Hub URL)" }),
       }),
-      async execute(_toolCallId: string, params: Record<string, unknown>) {
-        try {
-          const strategyId = String(params.strategyId ?? "").trim();
-          if (!strategyId) return json({ success: false, error: "strategyId is required" });
-
-          const result = await fetchStrategyInfo(config, strategyId);
-
-          if (result.success && result.data) {
-            const info = result.data;
-            const lines: string[] = [];
-            lines.push("策略信息:");
-            lines.push(`- ID: ${info.id}`);
-            lines.push(`- 名称: ${info.name}`);
-            if (info.author?.displayName) lines.push(`- 作者: ${info.author.displayName}`);
-            if (info.backtestResult) {
+      execute: withLogging(
+        db,
+        "skill_get_info",
+        "strategy",
+        async (_toolCallId, params) => {
+          try {
+            const strategyId = String(params.strategyId ?? "").trim();
+            if (!strategyId) return json({ success: false, error: "strategyId is required" });
+
+            const result = await fetchStrategyInfo(config, strategyId);
+
+            if (result.success && result.data) {
+              const info = result.data;
+              const lines: string[] = [];
+              lines.push("策略信息:");
+              lines.push(`- ID: ${info.id}`);
+              lines.push(`- 名称: ${info.name}`);
+              if (info.author?.displayName) lines.push(`- 作者: ${info.author.displayName}`);
+              if (info.backtestResult) {
+                lines.push("");
+                lines.push("绩效指标:");
+                if (typeof info.backtestResult.totalReturn === "number")
+                  lines.push(`- 总收益率: ${(info.backtestResult.totalReturn * 100).toFixed(2)}%`);
+                if (typeof info.backtestResult.sharpe === "number")
+                  lines.push(`- 夏普比率: ${info.backtestResult.sharpe.toFixed(3)}`);
+              }
               lines.push("");
-              lines.push("绩效指标:");
-              if (typeof info.backtestResult.totalReturn === "number")
-                lines.push(`- 总收益率: ${(info.backtestResult.totalReturn * 100).toFixed(2)}%`);
-              if (typeof info.backtestResult.sharpe === "number")
-                lines.push(`- 夏普比率: ${info.backtestResult.sharpe.toFixed(3)}`);
+              lines.push(`Hub URL: https://hub.openfinclaw.ai/strategy/${info.id}`);
+
+              return {
+                content: [{ type: "text" as const, text: lines.join("\n") }],
+                details: { success: true, ...info },
+              };
             }
-            lines.push("");
-            lines.push(`Hub URL: https://hub.openfinclaw.ai/strategy/${info.id}`);
 
-            return {
-              content: [{ type: "text" as const, text: lines.join("\n") }],
-              details: { success: true, ...info },
-            };
+            return json({
+              success: false,
+              error: result.error ?? "Failed to fetch strategy info",
+            });
+          } catch (err) {
+            return json({
+              success: false,
+              error: err instanceof Error ? err.message : String(err),
+            });
           }
-
-          return json({ success: false, error: result.error ?? "Failed to fetch strategy info" });
-        } catch (err) {
-          return json({
-            success: false,
-            error: err instanceof Error ? err.message : String(err),
-          });
-        }
-      },
+        },
+        { strategyIdParam: "strategyId" },
+      ),
     },
     { names: ["skill_get_info"] },
   );

package/src/types.ts

@@ -533,4 +533,6 @@ export interface UnifiedPluginConfig {
   datahubGatewayUrl: string;
   /** 请求超时（毫秒） */
   requestTimeoutMs: number;
+  /** Dashboard HTTP server port (default: 18791) */
+  httpPort: number;
 }