horizon-code 0.5.0 → 0.6.0

package/src/strategy/tools.ts

@@ -13,6 +13,13 @@ import { saveStrategy, loadStrategy, listSavedStrategies } from "./persistence.t
 import { hyperlink } from "../util/hyperlink.ts";
 import { writeWorkspaceFile, readWorkspaceFile, listWorkspaceFiles } from "./workspace.ts";
 import type { StrategyDraft } from "../state/types.ts";
+import { saveVersion, listVersions, getVersion, diffVersions } from "./versioning.ts";
+import { logEntry, getHistory, generateReport, compareVersions, codeHash } from "./ledger.ts";
+import { computeHealthScore } from "./health.ts";
+import { createAlert, removeAlert, listAlerts, formatCondition, formatAction } from "./alerts.ts";
+import { exportStrategy, importStrategy } from "./export.ts";
+import { startReplay, stopReplay, recordMetrics, loadReplay, listReplays, summarizeReplay } from "./replay.ts";
+import { learnFromStrategy, recordBacktest } from "../platform/profile.ts";
 
 const t = tool as any;
 
@@ -332,6 +339,7 @@ export const strategyTools: Record<string, any> = {
 
       // Auto-save
       await saveStrategy(draft.name, fixedCode).catch(() => {});
+      saveVersion(draft.name, fixedCode, `edit: ${args.find}`);
 
       return {
         strategy_name: draft.name,
@@ -746,7 +754,40 @@ except Exception as e:
         }
 
         const result = JSON.parse(jsonMatch[1]!.trim());
-        return { ...result, ascii_dashboard: dashMatch ? dashMatch[1]!.trim() : null, data_source: args.use_real_data && _lastFetchedData ? `real (${_lastFetchedData.slug}, ${_lastFetchedData.points} points)` : `synthetic (${dataPoints} ticks)` };
+        recordBacktest();
+        // Parse metrics from backtest result for ledger + Kelly sizing
+        const m = result.metrics ?? result;
+        const backtestMetrics = {
+          pnl: m.total_return ?? m.pnl ?? 0,
+          rpnl: m.realized_pnl ?? 0,
+          upnl: m.unrealized_pnl ?? 0,
+          sharpe: m.sharpe_ratio ?? m.sharpe ?? 0,
+          max_dd: m.max_drawdown ?? m.max_dd ?? 0,
+          win_rate: m.win_rate ?? 0,
+          trades: m.trade_count ?? m.trades ?? 0,
+          exposure: m.exposure ?? 0,
+        };
+        logEntry({ strategy_name: draft.name, code_hash: codeHash(draft.code), type: "backtest", timestamp: new Date().toISOString(), duration_secs: 0, params: draft.params ?? {}, metrics: backtestMetrics });
+
+        // Auto Kelly sizing — estimate edge and suggest position size
+        let kelly_sizing: any = null;
+        if (backtestMetrics.win_rate > 0 && backtestMetrics.trades >= 5) {
+          const winRate = backtestMetrics.win_rate;
+          const avgWin = backtestMetrics.pnl > 0 ? backtestMetrics.pnl / (backtestMetrics.trades * winRate || 1) : 0;
+          const avgLoss = backtestMetrics.pnl < 0 ? Math.abs(backtestMetrics.pnl) / (backtestMetrics.trades * (1 - winRate) || 1) : avgWin * 0.5;
+          const payoffRatio = avgLoss > 0 ? avgWin / avgLoss : 2;
+          const kellyFraction = Math.max(0, winRate - (1 - winRate) / payoffRatio);
+          const bankroll = args.initial_capital ?? 1000;
+          kelly_sizing = {
+            edge_pct: ((winRate - 0.5) * 200).toFixed(1) + "%",
+            kelly_fraction: kellyFraction.toFixed(3),
+            full_kelly: "$" + (bankroll * kellyFraction).toFixed(2),
+            half_kelly: "$" + (bankroll * kellyFraction * 0.5).toFixed(2) + " (recommended)",
+            quarter_kelly: "$" + (bankroll * kellyFraction * 0.25).toFixed(2) + " (conservative)",
+          };
+        }
+
+        return { ...result, kelly_sizing, ascii_dashboard: dashMatch ? dashMatch[1]!.trim() : null, data_source: args.use_real_data && _lastFetchedData ? `real (${_lastFetchedData.slug}, ${_lastFetchedData.points} points)` : `synthetic (${dataPoints} ticks)` };
       } catch (err) {
         return { error: `Backtest execution failed: ${err instanceof Error ? err.message : String(err)}`, hint: "Ensure Horizon SDK is installed: pip install horizon" };
       }
@@ -833,6 +874,9 @@ except Exception as e:
           watchForCrash();
         }
 
+        startReplay(pid, draft.name);
+        learnFromStrategy(draft.code);
+
         return {
           success: true, pid, status: "running", timeout_secs: timeout,
           auto_restart: autoRestart,
@@ -1000,6 +1044,7 @@ except Exception as e:
         phase: "generated",
       };
       store.setStrategyDraft(draft);
+      saveVersion(draft.name, fixedCode);
 
       return {
         strategy_name: args.name,
@@ -1206,4 +1251,453 @@ Your HTML can fetch("/api/local/metrics").then(r => r.json()) to get live data.
       }
     },
   }),
+
+  // ── Versioning ──
+
+  strategy_versions: t({
+    description: "List all saved versions of a strategy. Shows version number, timestamp, and change description for each.",
+    parameters: z.object({
+      name: z.string().describe("Strategy name"),
+    }),
+    execute: async (args: any) => {
+      try {
+        const versions = await listVersions(args.name);
+        return { strategy_name: args.name, versions, count: versions.length };
+      } catch (err) {
+        return { error: `Failed to list versions: ${err instanceof Error ? err.message : String(err)}` };
+      }
+    },
+  }),
+
+  revert_strategy: t({
+    description: "Revert a strategy to a previous version. Loads the code from that version and sets it as the active draft.",
+    parameters: z.object({
+      name: z.string().describe("Strategy name"),
+      version: z.number().describe("Version number to revert to"),
+    }),
+    execute: async (args: any) => {
+      try {
+        const versionData = await getVersion(args.name, args.version);
+        if (!versionData) return { error: `Version ${args.version} not found for "${args.name}"` };
+
+        const code = versionData.code;
+        const fixedCode = autoFixStrategyCode(code);
+        const errors = validateStrategyCode(fixedCode);
+        const warnings = getStrategyWarnings(fixedCode);
+
+        const draft: StrategyDraft = {
+          name: args.name,
+          code: fixedCode,
+          params: {},
+          explanation: "",
+          riskConfig: null,
+          validationStatus: errors.length === 0 ? "valid" : "invalid",
+          validationErrors: errors,
+          validationWarnings: warnings,
+          phase: "generated",
+        };
+        store.setStrategyDraft(draft);
+
+        return {
+          strategy_name: args.name,
+          version: args.version,
+          code: fixedCode,
+          validation: { valid: errors.length === 0, errors },
+          message: `Reverted to version ${args.version}`,
+        };
+      } catch (err) {
+        return { error: `Failed to revert: ${err instanceof Error ? err.message : String(err)}` };
+      }
+    },
+  }),
+
+  diff_versions: t({
+    description: "Show a diff between two versions of a strategy. Useful for reviewing what changed between iterations.",
+    parameters: z.object({
+      name: z.string().describe("Strategy name"),
+      v1: z.number().describe("First version number"),
+      v2: z.number().describe("Second version number"),
+    }),
+    execute: async (args: any) => {
+      try {
+        const diff = await diffVersions(args.name, args.v1, args.v2);
+        return { strategy_name: args.name, v1: args.v1, v2: args.v2, diff };
+      } catch (err) {
+        return { error: `Failed to diff: ${err instanceof Error ? err.message : String(err)}` };
+      }
+    },
+  }),
+
+  // ── Ledger & Reports ──
+
+  strategy_report: t({
+    description: "Show performance history from the strategy ledger. Includes backtest/run history and version-over-version comparison.",
+    parameters: z.object({
+      name: z.string().describe("Strategy name"),
+    }),
+    execute: async (args: any) => {
+      try {
+        const report = generateReport(args.name);
+        const comparison = compareVersions(args.name);
+        return { strategy_name: args.name, report, comparison };
+      } catch (err) {
+        return { error: `Failed to generate report: ${err instanceof Error ? err.message : String(err)}` };
+      }
+    },
+  }),
+
+  // ── Health Score ──
+
+  health_score: t({
+    description: "Compute a health score for the current strategy code. Analyzes code quality, risk management, and best practices.",
+    parameters: z.object({}),
+    execute: async () => {
+      const draft = store.getActiveSession()?.strategyDraft;
+      if (!draft) return { error: "No strategy loaded." };
+      try {
+        const score = computeHealthScore(draft.code);
+        return { strategy_name: draft.name, ...score };
+      } catch (err) {
+        return { error: `Failed to compute health score: ${err instanceof Error ? err.message : String(err)}` };
+      }
+    },
+  }),
+
+  // ── Alerts ──
+
+  set_alert: t({
+    description: "Create an alert that triggers when a condition is met (e.g. max drawdown exceeds threshold). Supports log, stop_process, and webhook actions.",
+    parameters: z.object({
+      condition_type: z.enum(["max_dd_exceeds", "pnl_below", "exposure_above", "win_rate_below", "loss_streak"]).describe("Type of condition to monitor"),
+      threshold: z.number().describe("Threshold value for the condition"),
+      action_type: z.enum(["log", "stop_process", "webhook"]).describe("Action to take when triggered"),
+      webhook_url: z.string().optional().describe("Webhook URL (required if action_type is 'webhook')"),
+      cooldown_secs: z.number().optional().describe("Cooldown between triggers in seconds (default: none)"),
+    }),
+    execute: async (args: any) => {
+      try {
+        const draft = store.getActiveSession()?.strategyDraft;
+        const condition = { type: args.condition_type, threshold: args.threshold } as any;
+        const action = args.action_type === "webhook"
+          ? { type: "webhook" as const, url: args.webhook_url ?? "" }
+          : { type: args.action_type as "log" | "stop_process" };
+        const alert = createAlert(
+          draft?.name ?? "local",
+          condition,
+          action,
+          (args.cooldown_secs ?? 60) * 1000,
+        );
+        return {
+          success: true,
+          alert,
+          message: `Alert created: ${formatCondition(alert.condition)} → ${formatAction(alert.action)}`,
+        };
+      } catch (err) {
+        return { error: `Failed to create alert: ${err instanceof Error ? err.message : String(err)}` };
+      }
+    },
+  }),
+
+  list_alerts: t({
+    description: "List all active alerts. Optionally filter by strategy name.",
+    parameters: z.object({
+      strategy_name: z.string().optional().describe("Filter by strategy name"),
+    }),
+    execute: async (args: any) => {
+      try {
+        const alerts = listAlerts(args.strategy_name);
+        return {
+          count: alerts.length,
+          alerts: alerts.map((a: any) => ({
+            id: a.id,
+            condition: formatCondition(a.condition),
+            action: formatAction(a.action),
+            cooldown_secs: a.cooldown_secs,
+            last_triggered: a.last_triggered,
+          })),
+        };
+      } catch (err) {
+        return { error: `Failed to list alerts: ${err instanceof Error ? err.message : String(err)}` };
+      }
+    },
+  }),
+
+  remove_alert: t({
+    description: "Remove an alert by its ID.",
+    parameters: z.object({
+      id: z.string().describe("Alert ID to remove"),
+    }),
+    execute: async (args: any) => {
+      try {
+        removeAlert(args.id);
+        return { success: true, message: `Alert ${args.id} removed.` };
+      } catch (err) {
+        return { error: `Failed to remove alert: ${err instanceof Error ? err.message : String(err)}` };
+      }
+    },
+  }),
+
+  // ── Export / Import ──
+
+  export_strategy: t({
+    description: "Export the current strategy to a .hz file. Bundles code, params, risk config, and metadata.",
+    parameters: z.object({
+      name: z.string().optional().describe("Strategy name override. Defaults to current draft name."),
+    }),
+    execute: async (args: any) => {
+      const draft = store.getActiveSession()?.strategyDraft;
+      if (!draft) return { error: "No strategy loaded." };
+      try {
+        const result = await exportStrategy(args.name ?? draft.name, draft.code, draft.params ?? {}, null);
+        return { success: true, ...result };
+      } catch (err) {
+        return { error: `Export failed: ${err instanceof Error ? err.message : String(err)}` };
+      }
+    },
+  }),
+
+  import_strategy: t({
+    description: "Import a strategy from a .hz file. Loads the code, params, and config into the active draft.",
+    parameters: z.object({
+      path: z.string().describe("Path to the .hz file"),
+    }),
+    execute: async (args: any) => {
+      try {
+        const imported = await importStrategy(args.path);
+        const fixedCode = autoFixStrategyCode(imported.code);
+        const errors = validateStrategyCode(fixedCode);
+        const warnings = getStrategyWarnings(fixedCode);
+
+        const draft: StrategyDraft = {
+          name: imported.name,
+          code: fixedCode,
+          params: imported.params ?? {},
+          explanation: "",
+          riskConfig: null,
+          validationStatus: errors.length === 0 ? "valid" : "invalid",
+          validationErrors: errors,
+          validationWarnings: warnings,
+          phase: "generated",
+        };
+        store.setStrategyDraft(draft);
+
+        return {
+          strategy_name: imported.name,
+          code: fixedCode,
+          validation: { valid: errors.length === 0, errors },
+          message: `Imported strategy "${imported.name}" from ${args.path}`,
+        };
+      } catch (err) {
+        return { error: `Import failed: ${err instanceof Error ? err.message : String(err)}` };
+      }
+    },
+  }),
+
+  // ── Replay ──
+
+  replay_session: t({
+    description: "View execution replay data. Without a file_name, lists available replays. With a file_name, loads and summarizes that replay session.",
+    parameters: z.object({
+      file_name: z.string().optional().describe("Replay file name to load. Omit to list available replays."),
+    }),
+    execute: async (args: any) => {
+      try {
+        if (!args.file_name) {
+          const replays = listReplays();
+          return { count: replays.length, replays };
+        }
+        const replay = loadReplay(args.file_name);
+        if (!replay) return { error: `Replay file not found: ${args.file_name}` };
+        const summary = summarizeReplay(replay);
+        return { file_name: args.file_name, summary, event_count: replay.events.length };
+      } catch (err) {
+        return { error: `Replay failed: ${err instanceof Error ? err.message : String(err)}` };
+      }
+    },
+  }),
+
+  // ── Portfolio ──
+
+  portfolio_summary: t({
+    description: "Aggregate metrics across all running strategy processes. Shows combined PnL, exposure, trades, and per-process breakdown.",
+    parameters: z.object({}),
+    execute: async () => {
+      const processes = [...runningProcesses.entries()].filter(([_, m]) => m.proc.exitCode === null);
+      if (processes.length === 0) return { error: "No running processes." };
+
+      let totalPnl = 0, totalRpnl = 0, totalUpnl = 0, totalTrades = 0, totalExposure = 0;
+      const breakdown: any[] = [];
+
+      for (const [pid, managed] of processes) {
+        const metrics = parseLocalMetrics(managed);
+        if (metrics) {
+          totalPnl += metrics.pnl;
+          totalRpnl += metrics.rpnl;
+          totalUpnl += metrics.upnl;
+          totalTrades += metrics.trades;
+          totalExposure += metrics.exposure;
+          breakdown.push({
+            pid,
+            uptime_secs: Math.round((Date.now() - managed.startedAt) / 1000),
+            pnl: metrics.pnl,
+            rpnl: metrics.rpnl,
+            upnl: metrics.upnl,
+            trades: metrics.trades,
+            win_rate: metrics.win_rate,
+            max_dd: metrics.max_dd,
+            sharpe: metrics.sharpe,
+            exposure: metrics.exposure,
+          });
+        } else {
+          breakdown.push({ pid, uptime_secs: Math.round((Date.now() - managed.startedAt) / 1000), metrics: "unavailable" });
+        }
+      }
+
+      return {
+        running_processes: processes.length,
+        aggregate: { pnl: totalPnl, rpnl: totalRpnl, upnl: totalUpnl, trades: totalTrades, exposure: totalExposure },
+        breakdown,
+      };
+    },
+  }),
+
+  // ── Parameter Sweep ──
+
+  parameter_sweep: t({
+    description: "Run multiple backtests with different parameter values. Modifies the strategy params dict for each value, runs backtest, and returns a comparison table.",
+    parameters: z.object({
+      param_name: z.string().describe("Name of the parameter to sweep (must exist in params={...})"),
+      values: z.array(z.number()).describe("Array of values to test"),
+      data_points: z.number().optional().describe("Synthetic data points per backtest (default 500)"),
+    }),
+    execute: async (args: any) => {
+      const draft = store.getActiveSession()?.strategyDraft;
+      if (!draft) return { error: "No strategy loaded yet." };
+      if (draft.validationStatus === "invalid") {
+        return { error: "Strategy has validation errors. Fix them first.", errors: draft.validationErrors };
+      }
+
+      const dataPoints = args.data_points ?? 500;
+      const results: any[] = [];
+
+      for (const value of args.values) {
+        // Modify params dict in the code
+        const paramPattern = new RegExp(`(["']${args.param_name}["']\\s*:\\s*)([\\d.]+)`);
+        let modifiedCode = draft.code;
+        if (paramPattern.test(modifiedCode)) {
+          modifiedCode = modifiedCode.replace(paramPattern, `$1${value}`);
+        } else {
+          // Try bare key format: param_name: value
+          const barePattern = new RegExp(`(${args.param_name}\\s*[:=]\\s*)([\\d.]+)`);
+          if (barePattern.test(modifiedCode)) {
+            modifiedCode = modifiedCode.replace(barePattern, `$1${value}`);
+          } else {
+            return { error: `Parameter "${args.param_name}" not found in strategy code params.` };
+          }
+        }
+
+        const hzRunIdx = modifiedCode.search(/hz\.run\s*\(/);
+        const pipelineCode = hzRunIdx !== -1 ? modifiedCode.slice(0, hzRunIdx).trimEnd() : modifiedCode;
+        const { pipelineFns, riskArgs, paramsStr, marketNames } = extractRunKwargs(modifiedCode);
+
+        const backtestConfig = {
+          name: draft.name.replace(/[^a-zA-Z0-9_-]/g, "_"),
+          markets: marketNames,
+          data_points: dataPoints,
+          base_price: 0.50,
+          initial_capital: 1000,
+          fill_model: "deterministic",
+          risk_args: riskArgs,
+          params_str: paramsStr,
+          pipeline_fns: pipelineFns,
+        };
+
+        const script = `
+import horizon as hz
+from horizon.context import FeedData
+import json, sys
+
+${pipelineCode}
+
+with open("backtest_config.json") as f:
+    _cfg = json.load(f)
+
+data = []
+price = _cfg["base_price"]
+for i in range(_cfg["data_points"]):
+    noise = (((i * 7 + 13) % 100) / 100 - 0.5) * 0.05
+    revert = (_cfg["base_price"] - price) * 0.05
+    price = max(0.01, min(0.99, price + noise + revert))
+    data.append({"timestamp": float(i), "price": round(price, 4)})
+
+try:
+    result = hz.backtest(
+        name=_cfg["name"],
+        markets=_cfg["markets"],
+        data=data,
+        pipeline=[${pipelineFns.join(", ")}],
+        risk=hz.Risk(${riskArgs}),
+        params=${paramsStr},
+        initial_capital=_cfg["initial_capital"],
+        fill_model=_cfg["fill_model"],
+    )
+    m = result.metrics
+    out = {
+        "total_return": round(getattr(m, 'total_return', 0), 4),
+        "max_drawdown": round(getattr(m, 'max_drawdown', 0), 4),
+        "sharpe_ratio": round(getattr(m, 'sharpe_ratio', 0), 2),
+        "win_rate": round(getattr(m, 'win_rate', 0), 4),
+        "profit_factor": round(getattr(m, 'profit_factor', 0), 2),
+        "trade_count": getattr(m, 'trade_count', 0),
+    }
+    print("---SWEEP_JSON---")
+    print(json.dumps(out))
+    print("---END_SWEEP_JSON---")
+except Exception as e:
+    print("---SWEEP_ERROR---")
+    print(str(e))
+    print("---END_SWEEP_ERROR---")
+    sys.exit(1)
+`;
+
+        try {
+          const { mkdtemp } = await import("fs/promises");
+          const { join } = await import("path");
+          const { tmpdir } = await import("os");
+          const sandboxDir = await mkdtemp(join(tmpdir(), "horizon-sweep-"));
+          await Bun.write(join(sandboxDir, "backtest_config.json"), JSON.stringify(backtestConfig));
+
+          const { stdout, stderr, exitCode, timedOut } = await runInSandbox({ code: script, timeout: 60000, cwd: sandboxDir });
+
+          if (timedOut) {
+            results.push({ param_value: value, error: "timed out" });
+            continue;
+          }
+
+          if (stdout.includes("---SWEEP_ERROR---")) {
+            const errMsg = stdout.split("---SWEEP_ERROR---")[1]?.split("---END_SWEEP_ERROR---")[0]?.trim();
+            results.push({ param_value: value, error: errMsg });
+            continue;
+          }
+
+          const jsonMatch = stdout.match(/---SWEEP_JSON---([\s\S]*?)---END_SWEEP_JSON---/);
+          if (jsonMatch) {
+            const metrics = JSON.parse(jsonMatch[1]!.trim());
+            results.push({ param_value: value, ...metrics });
+          } else {
+            results.push({ param_value: value, error: "no output" });
+          }
+        } catch (err) {
+          results.push({ param_value: value, error: err instanceof Error ? err.message : String(err) });
+        }
+      }
+
+      return {
+        strategy_name: draft.name,
+        param_name: args.param_name,
+        sweep_count: args.values.length,
+        results,
+      };
+    },
+  }),
 };

package/src/strategy/versioning.ts

@@ -0,0 +1,168 @@
+// Strategy version control — tracks every code change with diffs
+// Storage: ~/.horizon/versions/<strategy-slug>/v<N>.json
+
+import { homedir } from "os";
+import { resolve, join } from "path";
+import { existsSync, mkdirSync, readdirSync, statSync } from "fs";
+import { createHash } from "crypto";
+
+const VERSIONS_ROOT = resolve(homedir(), ".horizon", "versions");
+
+interface StrategyVersion {
+  version: number;
+  code: string;
+  hash: string;
+  label: string;
+  timestamp: string;
+  diff: string | null; // unified diff from previous version
+}
+
+function ensureDir(dir: string): void {
+  if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+}
+
+function slugify(name: string): string {
+  return name.toLowerCase().replace(/[^a-z0-9]+/g, "_").replace(/^_|_$/g, "");
+}
+
+function codeHash(code: string): string {
+  return createHash("sha256").update(code).digest("hex").slice(0, 12);
+}
+
+/** Compute a simple unified diff between two code strings */
+function computeDiff(oldCode: string, newCode: string): string {
+  const oldLines = oldCode.split("\n");
+  const newLines = newCode.split("\n");
+  const lines: string[] = [];
+  const maxLen = Math.max(oldLines.length, newLines.length);
+
+  let added = 0, removed = 0, unchanged = 0;
+
+  for (let i = 0; i < maxLen; i++) {
+    const oldLine = oldLines[i];
+    const newLine = newLines[i];
+
+    if (oldLine === newLine) {
+      unchanged++;
+    } else {
+      if (oldLine !== undefined && (newLine === undefined || oldLine !== newLine)) {
+        lines.push(`- ${oldLine}`);
+        removed++;
+      }
+      if (newLine !== undefined && (oldLine === undefined || oldLine !== newLine)) {
+        lines.push(`+ ${newLine}`);
+        added++;
+      }
+    }
+  }
+
+  if (added === 0 && removed === 0) return "(no changes)";
+  return `+${added} -${removed} (~${unchanged} unchanged)\n${lines.slice(0, 100).join("\n")}${lines.length > 100 ? `\n... (${lines.length - 100} more lines)` : ""}`;
+}
+
+/** Save a new version of a strategy. Returns version number. */
+export async function saveVersion(name: string, code: string, label?: string): Promise<{ version: number; hash: string }> {
+  const slug = slugify(name);
+  const dir = join(VERSIONS_ROOT, slug);
+  ensureDir(dir);
+
+  const existing = getVersionList(slug);
+  const nextVersion = existing.length + 1;
+  const hash = codeHash(code);
+
+  // Skip if code is identical to latest version
+  if (existing.length > 0) {
+    const latestPath = join(dir, `v${existing.length}.json`);
+    try {
+      const latest: StrategyVersion = JSON.parse(await Bun.file(latestPath).text());
+      if (latest.hash === hash) {
+        return { version: existing.length, hash };
+      }
+    } catch {}
+  }
+
+  // Compute diff from previous version
+  let diff: string | null = null;
+  if (existing.length > 0) {
+    try {
+      const prevPath = join(dir, `v${existing.length}.json`);
+      const prev: StrategyVersion = JSON.parse(await Bun.file(prevPath).text());
+      diff = computeDiff(prev.code, code);
+    } catch {}
+  }
+
+  const version: StrategyVersion = {
+    version: nextVersion,
+    code,
+    hash,
+    label: label ?? `v${nextVersion}`,
+    timestamp: new Date().toISOString(),
+    diff,
+  };
+
+  await Bun.write(join(dir, `v${nextVersion}.json`), JSON.stringify(version, null, 2));
+  return { version: nextVersion, hash };
+}
+
+function getVersionList(slug: string): string[] {
+  const dir = join(VERSIONS_ROOT, slug);
+  if (!existsSync(dir)) return [];
+  return readdirSync(dir)
+    .filter(f => f.startsWith("v") && f.endsWith(".json"))
+    .sort((a, b) => {
+      const numA = parseInt(a.slice(1));
+      const numB = parseInt(b.slice(1));
+      return numA - numB;
+    });
+}
+
+/** List all versions of a strategy */
+export async function listVersions(name: string): Promise<{ version: number; hash: string; label: string; timestamp: string }[]> {
+  const slug = slugify(name);
+  const dir = join(VERSIONS_ROOT, slug);
+  const files = getVersionList(slug);
+
+  const versions: { version: number; hash: string; label: string; timestamp: string }[] = [];
+  for (const file of files) {
+    try {
+      const v: StrategyVersion = JSON.parse(await Bun.file(join(dir, file)).text());
+      versions.push({ version: v.version, hash: v.hash, label: v.label, timestamp: v.timestamp });
+    } catch {}
+  }
+  return versions;
+}
+
+/** Get a specific version's full data */
+export async function getVersion(name: string, version: number): Promise<StrategyVersion | null> {
+  const slug = slugify(name);
+  const path = join(VERSIONS_ROOT, slug, `v${version}.json`);
+  if (!existsSync(path)) return null;
+  try {
+    return JSON.parse(await Bun.file(path).text());
+  } catch { return null; }
+}
+
+/** Get diff between two versions */
+export async function diffVersions(name: string, v1: number, v2: number): Promise<string | null> {
+  const ver1 = await getVersion(name, v1);
+  const ver2 = await getVersion(name, v2);
+  if (!ver1 || !ver2) return null;
+  return computeDiff(ver1.code, ver2.code);
+}
+
+/** Get the latest version's code */
+export async function getLatestCode(name: string): Promise<string | null> {
+  const slug = slugify(name);
+  const files = getVersionList(slug);
+  if (files.length === 0) return null;
+  const v = await getVersion(name, files.length);
+  return v?.code ?? null;
+}
+
+/** List all strategy names that have version history */
+export function listVersionedStrategies(): string[] {
+  ensureDir(VERSIONS_ROOT);
+  return readdirSync(VERSIONS_ROOT, { withFileTypes: true })
+    .filter(d => d.isDirectory())
+    .map(d => d.name);
+}