Add Almanac accuracy seed inputs

data/historical/DJI_daily.csv

@@ -0,0 +1,67 @@
+"Date","Open","High","Low","Close"
+"12/29/2025","48,636.63","48,704.83","48,390.91","48,461.93"
+"12/30/2025","48,434.88","48,471.70","48,297.26","48,367.06"
+"12/31/2025","48,371.52","48,394.51","48,050.88","48,063.29"
+"01/02/2026","48,105.98","48,404.06","47,853.04","48,382.39"
+"01/05/2026","48,475.81","49,209.95","48,449.62","48,977.18"
+"01/06/2026","48,987.36","49,509.92","48,923.83","49,462.08"
+"01/07/2026","49,512.72","49,621.43","48,951.99","48,996.08"
+"01/08/2026","48,850.17","49,357.74","48,792.34","49,266.11"
+"01/09/2026","49,234.81","49,571.41","49,197.06","49,504.07"
+"01/12/2026","49,499.67","49,633.35","49,011.31","49,590.20"
+"01/13/2026","49,616.95","49,616.95","49,056.31","49,191.99"
+"01/14/2026","49,088.25","49,195.10","48,851.98","49,149.63"
+"01/15/2026","49,201.10","49,581.18","49,201.10","49,442.44"
+"01/16/2026","49,466.70","49,616.70","49,246.24","49,359.33"
+"01/20/2026","49,005.01","49,005.01","48,428.13","48,488.59"
+"01/21/2026","48,546.03","49,295.03","48,546.03","49,077.23"
+"01/22/2026","49,201.81","49,607.29","49,201.81","49,384.01"
+"01/23/2026","49,264.54","49,265.46","48,963.05","49,098.71"
+"01/26/2026","49,137.65","49,488.81","49,137.65","49,412.40"
+"01/27/2026","49,103.58","49,157.80","48,862.52","49,003.41"
+"01/28/2026","49,024.68","49,150.34","48,901.49","49,015.60"
+"01/29/2026","48,938.27","49,292.81","48,597.22","49,071.56"
+"01/30/2026","48,991.62","49,047.68","48,459.88","48,892.47"
+"02/02/2026","48,777.77","49,484.95","48,673.58","49,407.66"
+"02/03/2026","49,358.59","49,653.13","48,832.78","49,240.99"
+"02/04/2026","49,323.59","49,649.86","49,112.43","49,501.30"
+"02/05/2026","49,313.04","49,340.90","48,829.10","48,908.72"
+"02/06/2026","49,032.19","50,169.65","49,032.19","50,115.67"
+"02/09/2026","50,047.79","50,219.40","49,837.45","50,135.87"
+"02/10/2026","50,193.49","50,512.79","50,115.03","50,188.14"
+"02/11/2026","50,243.15","50,499.04","49,901.61","50,121.40"
+"02/12/2026","50,170.27","50,447.01","49,420.28","49,451.98"
+"02/13/2026","49,439.58","49,743.98","49,084.35","49,500.93"
+"02/17/2026","49,525.37","49,732.37","49,169.84","49,533.19"
+"02/18/2026","49,571.92","49,897.31","49,469.06","49,662.66"
+"02/19/2026","49,576.22","49,606.17","49,197.53","49,395.16"
+"02/20/2026","49,323.00","49,712.56","49,158.28","49,625.97"
+"02/23/2026","49,536.54","49,695.61","48,731.46","48,804.06"
+"02/24/2026","48,827.80","49,295.21","48,752.74","49,174.50"
+"02/25/2026","49,357.63","49,517.36","49,206.87","49,482.15"
+"02/26/2026","49,544.58","49,815.22","49,237.38","49,499.20"
+"02/27/2026","49,253.57","49,253.57","48,678.78","48,977.92"
+"03/02/2026","48,794.42","49,064.67","48,377.96","48,904.78"
+"03/03/2026","48,493.11","48,695.36","47,626.85","48,501.27"
+"03/04/2026","48,589.77","48,854.05","48,354.37","48,739.41"
+"03/05/2026","48,526.73","48,526.73","47,577.11","47,954.74"
+"03/06/2026","47,634.55","47,634.55","47,009.01","47,501.55"
+"03/09/2026","47,371.28","47,876.06","46,615.52","47,740.80"
+"03/10/2026","47,771.43","48,220.54","47,444.23","47,706.51"
+"03/11/2026","47,690.76","47,711.26","47,185.89","47,417.27"
+"03/12/2026","47,242.52","47,242.52","46,662.23","46,677.85"
+"03/13/2026","46,689.24","47,123.99","46,494.63","46,558.47"
+"03/16/2026","46,707.40","47,176.14","46,707.40","46,946.41"
+"03/17/2026","47,085.53","47,428.12","46,975.52","46,993.26"
+"03/18/2026","46,913.93","46,913.93","46,193.06","46,225.15"
+"03/19/2026","46,134.87","46,247.22","45,733.70","46,021.43"
+"03/20/2026","45,975.65","46,068.31","45,369.39","45,577.47"
+"03/23/2026","45,803.82","46,712.33","45,803.82","46,208.47"
+"03/24/2026","46,099.86","46,400.82","45,769.69","46,124.06"
+"03/25/2026","46,314.24","46,718.42","46,196.91","46,429.49"
+"03/26/2026","46,344.64","46,547.59","45,910.75","45,960.11"
+"03/27/2026","45,904.25","45,904.25","45,063.33","45,166.64"
+"03/30/2026","45,283.06","45,625.76","45,057.28","45,216.14"
+"03/31/2026","45,541.76","46,383.40","45,480.30","46,341.51"
+"04/01/2026","46,396.12","46,803.36","46,396.12","46,565.74"
+"04/02/2026","46,469.36","46,754.72","45,897.24","46,504.67"

data/historical/GSPC_daily.csv

@@ -0,0 +1,67 @@
+"Date","Open","High","Low","Close"
+"12/29/2025","6,903.60","6,920.21","6,888.76","6,905.74"
+"12/30/2025","6,900.44","6,913.25","6,893.47","6,896.24"
+"12/31/2025","6,898.82","6,901.42","6,844.55","6,845.50"
+"01/02/2026","6,878.11","6,894.87","6,824.31","6,858.47"
+"01/05/2026","6,892.19","6,920.38","6,891.56","6,902.05"
+"01/06/2026","6,908.03","6,948.69","6,904.02","6,944.82"
+"01/07/2026","6,945.07","6,965.69","6,919.19","6,920.93"
+"01/08/2026","6,914.11","6,931.28","6,899.33","6,921.46"
+"01/09/2026","6,927.83","6,978.36","6,917.64","6,966.28"
+"01/12/2026","6,944.12","6,986.33","6,934.07","6,977.27"
+"01/13/2026","6,977.41","6,985.83","6,938.77","6,963.74"
+"01/14/2026","6,937.41","6,941.30","6,885.74","6,926.60"
+"01/15/2026","6,969.46","6,979.34","6,937.93","6,944.47"
+"01/16/2026","6,960.54","6,967.30","6,925.09","6,940.01"
+"01/20/2026","6,865.24","6,871.17","6,789.05","6,796.86"
+"01/21/2026","6,810.71","6,910.39","6,804.96","6,875.62"
+"01/22/2026","6,914.44","6,934.75","6,893.62","6,913.35"
+"01/23/2026","6,907.85","6,932.96","6,895.50","6,915.61"
+"01/26/2026","6,923.23","6,964.66","6,921.60","6,950.23"
+"01/27/2026","6,965.96","6,988.82","6,958.83","6,978.60"
+"01/28/2026","7,002.00","7,002.28","6,963.46","6,978.03"
+"01/29/2026","6,977.74","6,992.84","6,870.80","6,969.01"
+"01/30/2026","6,947.27","6,964.09","6,893.48","6,939.03"
+"02/02/2026","6,916.64","6,991.92","6,914.34","6,976.44"
+"02/03/2026","6,985.45","6,993.08","6,862.05","6,917.81"
+"02/04/2026","6,924.50","6,936.09","6,838.80","6,882.72"
+"02/05/2026","6,837.39","6,857.85","6,780.13","6,798.40"
+"02/06/2026","6,816.74","6,944.89","6,816.74","6,932.30"
+"02/09/2026","6,917.26","6,980.10","6,905.87","6,964.82"
+"02/10/2026","6,974.49","6,986.83","6,937.53","6,941.81"
+"02/11/2026","6,976.48","6,993.48","6,911.97","6,941.47"
+"02/12/2026","6,957.54","6,973.22","6,824.04","6,832.76"
+"02/13/2026","6,834.27","6,881.96","6,794.55","6,836.17"
+"02/17/2026","6,819.86","6,866.99","6,775.50","6,843.22"
+"02/18/2026","6,855.48","6,909.12","6,849.66","6,881.31"
+"02/19/2026","6,861.34","6,879.12","6,833.06","6,861.89"
+"02/20/2026","6,843.26","6,915.86","6,836.33","6,909.51"
+"02/23/2026","6,901.25","6,916.96","6,819.82","6,837.75"
+"02/24/2026","6,837.37","6,899.17","6,815.43","6,890.07"
+"02/25/2026","6,915.15","6,952.51","6,915.15","6,946.13"
+"02/26/2026","6,944.74","6,947.25","6,859.73","6,908.86"
+"02/27/2026","6,856.54","6,882.96","6,831.74","6,878.88"
+"03/02/2026","6,824.36","6,901.01","6,796.85","6,881.62"
+"03/03/2026","6,800.26","6,840.05","6,710.42","6,816.63"
+"03/04/2026","6,831.69","6,885.94","6,811.64","6,869.50"
+"03/05/2026","6,851.08","6,870.43","6,770.78","6,830.71"
+"03/06/2026","6,769.03","6,773.42","6,711.56","6,740.02"
+"03/09/2026","6,699.80","6,810.44","6,636.04","6,795.99"
+"03/10/2026","6,796.56","6,845.08","6,759.74","6,781.48"
+"03/11/2026","6,790.09","6,811.15","6,745.59","6,775.80"
+"03/12/2026","6,740.88","6,740.88","6,670.40","6,672.62"
+"03/13/2026","6,673.49","6,733.30","6,623.92","6,632.19"
+"03/16/2026","6,674.37","6,729.79","6,674.37","6,699.38"
+"03/17/2026","6,722.35","6,754.30","6,710.80","6,716.09"
+"03/18/2026","6,697.16","6,705.18","6,621.66","6,624.70"
+"03/19/2026","6,583.12","6,636.74","6,557.82","6,606.49"
+"03/20/2026","6,594.66","6,594.66","6,473.52","6,506.48"
+"03/23/2026","6,574.96","6,651.62","6,565.55","6,581.00"
+"03/24/2026","6,552.09","6,595.75","6,525.11","6,556.37"
+"03/25/2026","6,598.35","6,633.94","6,568.41","6,591.90"
+"03/26/2026","6,555.86","6,573.22","6,473.79","6,477.16"
+"03/27/2026","6,453.89","6,453.89","6,356.08","6,368.85"
+"03/30/2026","6,403.37","6,427.31","6,316.91","6,343.72"
+"03/31/2026","6,395.88","6,539.05","6,395.88","6,528.52"
+"04/01/2026","6,556.56","6,609.67","6,554.29","6,575.32"
+"04/02/2026","6,512.61","6,601.91","6,474.94","6,582.69"

data/historical/IXIC_daily.csv

@@ -0,0 +1,67 @@
+"Date","Open","High","Low","Close"
+"12/29/2025","23,414.68","23,531.02","23,397.52","23,474.35"
+"12/30/2025","23,465.67","23,521.05","23,414.83","23,419.08"
+"12/31/2025","23,420.85","23,445.26","23,237.78","23,241.99"
+"01/02/2026","23,481.49","23,585.96","23,119.49","23,235.63"
+"01/05/2026","23,449.67","23,476.51","23,332.23","23,395.82"
+"01/06/2026","23,446.96","23,559.15","23,389.57","23,547.17"
+"01/07/2026","23,544.90","23,723.37","23,504.22","23,584.27"
+"01/08/2026","23,548.89","23,558.17","23,353.46","23,480.02"
+"01/09/2026","23,496.21","23,721.15","23,426.48","23,671.35"
+"01/12/2026","23,576.88","23,804.05","23,562.97","23,733.90"
+"01/13/2026","23,735.12","23,813.30","23,607.59","23,709.87"
+"01/14/2026","23,563.92","23,590.20","23,306.66","23,471.75"
+"01/15/2026","23,693.97","23,721.11","23,502.18","23,530.02"
+"01/16/2026","23,639.69","23,664.26","23,446.81","23,515.39"
+"01/20/2026","23,142.69","23,236.05","22,916.83","22,954.32"
+"01/21/2026","23,017.68","23,383.24","22,927.88","23,224.82"
+"01/22/2026","23,440.71","23,503.16","23,335.15","23,436.02"
+"01/23/2026","23,440.92","23,610.74","23,374.26","23,501.24"
+"01/26/2026","23,529.28","23,688.94","23,486.08","23,601.36"
+"01/27/2026","23,734.75","23,865.26","23,694.38","23,817.10"
+"01/28/2026","23,965.11","23,988.27","23,775.49","23,857.45"
+"01/29/2026","23,830.92","23,840.55","23,232.78","23,685.12"
+"01/30/2026","23,578.96","23,662.25","23,351.55","23,461.82"
+"02/02/2026","23,370.55","23,686.83","23,356.40","23,592.11"
+"02/03/2026","23,667.44","23,691.60","23,027.22","23,255.19"
+"02/04/2026","23,217.02","23,270.07","22,684.51","22,904.58"
+"02/05/2026","22,604.02","22,841.28","22,461.14","22,540.59"
+"02/06/2026","22,625.30","23,088.46","22,586.40","23,031.21"
+"02/09/2026","22,952.24","23,314.67","22,878.37","23,238.67"
+"02/10/2026","23,271.23","23,310.73","23,089.10","23,102.47"
+"02/11/2026","23,278.29","23,320.62","22,902.01","23,066.47"
+"02/12/2026","23,142.87","23,161.60","22,548.02","22,597.15"
+"02/13/2026","22,561.46","22,742.06","22,402.38","22,546.67"
+"02/17/2026","22,394.76","22,690.83","22,256.76","22,578.38"
+"02/18/2026","22,629.85","22,895.96","22,597.77","22,753.63"
+"02/19/2026","22,639.88","22,768.83","22,583.61","22,682.73"
+"02/20/2026","22,542.28","22,948.87","22,539.05","22,886.07"
+"02/23/2026","22,840.97","22,893.22","22,547.12","22,627.27"
+"02/24/2026","22,641.60","22,895.48","22,528.26","22,863.68"
+"02/25/2026","23,005.01","23,169.68","23,004.69","23,152.08"
+"02/26/2026","23,100.58","23,109.47","22,670.80","22,878.38"
+"02/27/2026","22,615.43","22,735.78","22,538.30","22,668.21"
+"03/02/2026","22,322.12","22,802.80","22,306.08","22,748.86"
+"03/03/2026","22,292.37","22,601.59","22,124.78","22,516.69"
+"03/04/2026","22,620.89","22,891.88","22,570.67","22,807.48"
+"03/05/2026","22,707.47","22,877.02","22,500.29","22,748.99"
+"03/06/2026","22,421.17","22,614.41","22,328.14","22,387.68"
+"03/09/2026","22,184.05","22,741.03","22,061.97","22,695.95"
+"03/10/2026","22,722.94","22,906.72","22,608.23","22,697.10"
+"03/11/2026","22,771.27","22,877.71","22,602.33","22,716.13"
+"03/12/2026","22,526.59","22,550.75","22,290.48","22,311.98"
+"03/13/2026","22,425.70","22,521.38","22,069.24","22,105.36"
+"03/16/2026","22,340.39","22,521.59","22,316.63","22,374.18"
+"03/17/2026","22,458.03","22,569.64","22,409.07","22,479.53"
+"03/18/2026","22,421.96","22,461.76","22,144.76","22,152.42"
+"03/19/2026","21,871.04","22,187.06","21,851.05","22,090.69"
+"03/20/2026","21,989.33","21,997.09","21,522.75","21,647.61"
+"03/23/2026","21,995.78","22,189.34","21,865.80","21,946.76"
+"03/24/2026","21,807.60","21,916.16","21,712.04","21,761.89"
+"03/25/2026","22,006.43","22,093.18","21,865.46","21,929.83"
+"03/26/2026","21,693.18","21,823.58","21,395.77","21,408.08"
+"03/27/2026","21,287.19","21,293.50","20,909.93","20,948.36"
+"03/30/2026","21,096.24","21,139.72","20,690.25","20,794.64"
+"03/31/2026","21,064.33","21,642.62","21,063.38","21,590.63"
+"04/01/2026","21,742.80","21,983.07","21,723.72","21,840.95"
+"04/02/2026","21,472.52","21,906.48","21,371.32","21,879.18"

scripts/seed_accuracy.py

@@ -0,0 +1,412 @@
+#!/usr/bin/env python3
+"""Seed Almanac historic accuracy data from local index CSV files.
+
+Run this script from the project root so relative paths resolve against the repo:
+    python scripts/seed_accuracy.py
+"""
+
+from __future__ import annotations
+
+import argparse
+import csv
+import json
+import sys
+from collections import defaultdict
+from datetime import datetime, timezone
+from pathlib import Path
+
+
+PRIMARY_ALMANAC_PATH = Path("data") / "almanac_2026" / "almanac_2026.json"
+FALLBACK_ALMANAC_PATH = Path("data") / "almanac_2026" / "almanac_2026_db_dump.json"
+OUTPUT_PATH = Path("data") / "almanac_2026" / "accuracy_results.json"
+
+INDEX_CONFIG = {
+    "d": {
+        "csv_key": "dji",
+        "summary_key": "dow",
+        "label": "Dow",
+        "arg": "dji",
+        "default": Path("data") / "historical" / "DJI_daily.csv",
+    },
+    "s": {
+        "csv_key": "sp500",
+        "summary_key": "sp500",
+        "label": "S&P 500",
+        "arg": "sp500",
+        "default": Path("data") / "historical" / "GSPC_daily.csv",
+    },
+    "n": {
+        "csv_key": "nasdaq",
+        "summary_key": "nasdaq",
+        "label": "NASDAQ",
+        "arg": "nasdaq",
+        "default": Path("data") / "historical" / "IXIC_daily.csv",
+    },
+}
+
+
+def iso_utc_now() -> str:
+    return datetime.now(timezone.utc).isoformat().replace("+00:00", "Z")
+
+
+def read_json(path: Path) -> dict:
+    with path.open("r", encoding="utf-8") as handle:
+        payload = json.load(handle)
+    if not isinstance(payload, dict):
+        raise ValueError(f"{path} must contain a top-level JSON object")
+    return payload
+
+
+def load_almanac_predictions(project_root: Path) -> dict[str, dict[str, object]]:
+    primary_path = project_root / PRIMARY_ALMANAC_PATH
+    fallback_path = project_root / FALLBACK_ALMANAC_PATH
+
+    if primary_path.exists():
+        payload = read_json(primary_path)
+        daily = payload.get("daily", {})
+        if isinstance(daily, dict):
+            normalized = {}
+            for date_key, day in daily.items():
+                if not isinstance(day, dict):
+                    continue
+                normalized[str(date_key)] = {
+                    "d": float(day.get("d", 0.0)),
+                    "s": float(day.get("s", 0.0)),
+                    "n": float(day.get("n", 0.0)),
+                    "context": str(day.get("notes", "") or "").strip(),
+                }
+            if normalized:
+                return normalized
+
+    if fallback_path.exists():
+        payload = read_json(fallback_path)
+        table = payload.get("daily_probabilities", {})
+        rows = table.get("rows", []) if isinstance(table, dict) else []
+        if isinstance(rows, list):
+            normalized = {}
+            for row in rows:
+                if not isinstance(row, dict):
+                    continue
+                date_key = str(row.get("date", "")).strip()
+                if not date_key:
+                    continue
+                normalized[date_key] = {
+                    "d": float(row.get("dow_prob", 0.0)),
+                    "s": float(row.get("sp500_prob", 0.0)),
+                    "n": float(row.get("nasdaq_prob", 0.0)),
+                    "context": str(row.get("notes", "") or "").strip(),
+                }
+            if normalized:
+                return normalized
+
+    raise FileNotFoundError(
+        "No supported almanac source found. Expected "
+        f"{primary_path} or {fallback_path}."
+    )
+
+
+def parse_close(value: str) -> float:
+    return float(str(value or "").replace(",", "").strip())
+
+
+def load_history_csv(path: Path) -> dict[str, dict[str, float | None]]:
+    if not path.exists():
+        raise FileNotFoundError(f"Missing historical CSV: {path}")
+
+    rows: list[tuple[datetime, float]] = []
+    with path.open("r", encoding="utf-8-sig", newline="") as handle:
+        reader = csv.DictReader(handle)
+        required = {"Date", "Close"}
+        if not required.issubset(set(reader.fieldnames or [])):
+            raise ValueError(f"{path} must contain Date and Close columns")
+        for row in reader:
+            date_text = str(row.get("Date", "")).strip()
+            if not date_text:
+                continue
+            try:
+                parsed_date = datetime.strptime(date_text, "%m/%d/%Y")
+                close_value = parse_close(str(row.get("Close", "")))
+            except ValueError as exc:
+                raise ValueError(f"Unable to parse row in {path}: {row}") from exc
+            rows.append((parsed_date, close_value))
+
+    if not rows:
+        raise ValueError(f"{path} did not contain any historical rows")
+
+    rows.sort(key=lambda item: item[0])
+    lookup: dict[str, dict[str, float | None]] = {}
+    previous_close: float | None = None
+    for trade_date, close_value in rows:
+        iso_date = trade_date.strftime("%Y-%m-%d")
+        lookup[iso_date] = {"close": close_value, "prev_close": previous_close}
+        previous_close = close_value
+    return lookup
+
+
+def actual_direction(pct_change: float) -> str:
+    if pct_change > 0:
+        return "UP"
+    if pct_change < 0:
+        return "DOWN"
+    return "FLAT"
+
+
+def predicted_direction(probability: float) -> str | None:
+    if probability > 50:
+        return "UP"
+    if probability < 50:
+        return "DOWN"
+    return None
+
+
+def score_prediction(probability: float, pct_change: float) -> dict[str, str | None]:
+    predicted = predicted_direction(probability)
+    actual = actual_direction(pct_change)
+    verdict = None
+
+    if predicted == "UP":
+        verdict = "HIT" if pct_change > 0 else "MISS"
+    elif predicted == "DOWN":
+        verdict = "HIT" if pct_change < 0 else "MISS"
+
+    return {"verdict": verdict, "predicted": predicted, "actual": actual}
+
+
+def pct(value: int, total: int) -> float:
+    if total <= 0:
+        return 0.0
+    return round((value / total) * 100, 1)
+
+
+def build_daily_results(
+    almanac_daily: dict[str, dict[str, object]],
+    history_by_index: dict[str, dict[str, dict[str, float | None]]],
+) -> dict[str, dict[str, object]]:
+    daily_results: dict[str, dict[str, object]] = {}
+
+    for date_key in sorted(almanac_daily.keys()):
+        current_records = {}
+        for config in INDEX_CONFIG.values():
+            history = history_by_index[config["csv_key"]]
+            current_records[config["csv_key"]] = history.get(date_key)
+
+        if any(record is None or record.get("prev_close") is None for record in current_records.values()):
+            continue
+
+        day_predictions = almanac_daily[date_key]
+        actuals = {}
+        prev_closes = {}
+        pct_changes = {}
+        results = {}
+        hits = 0
+        total_calls = 0
+
+        for signal_key, config in INDEX_CONFIG.items():
+            csv_key = config["csv_key"]
+            record = current_records[csv_key] or {}
+            close_value = float(record["close"])
+            prev_close = float(record["prev_close"])
+            pct_change = (close_value - prev_close) / prev_close
+            probability = float(day_predictions.get(signal_key, 0.0))
+
+            actuals[csv_key] = round(close_value, 6)
+            prev_closes[csv_key] = round(prev_close, 6)
+            pct_changes[csv_key] = round(pct_change, 6)
+            results[signal_key] = score_prediction(probability, pct_change)
+
+            if results[signal_key]["verdict"] is not None:
+                total_calls += 1
+                if results[signal_key]["verdict"] == "HIT":
+                    hits += 1
+
+        daily_results[date_key] = {
+            "actual": actuals,
+            "prev_close": prev_closes,
+            "pct_change": pct_changes,
+            "almanac_scores": {
+                "d": float(day_predictions.get("d", 0.0)),
+                "s": float(day_predictions.get("s", 0.0)),
+                "n": float(day_predictions.get("n", 0.0)),
+            },
+            "results": results,
+            "hits": hits,
+            "total_calls": total_calls,
+            "context": str(day_predictions.get("context", "") or "").strip(),
+        }
+
+    return daily_results
+
+
+def aggregate_periods(
+    daily_results: dict[str, dict[str, object]],
+    key_builder,
+    include_dates: bool = False,
+    include_trading_days: bool = False,
+) -> dict[str, dict[str, object]]:
+    grouped: dict[str, dict[str, object]] = defaultdict(
+        lambda: {
+            "dates": [],
+            "hits": 0,
+            "total_calls": 0,
+            "dow": {"hits": 0, "total": 0},
+            "sp500": {"hits": 0, "total": 0},
+            "nasdaq": {"hits": 0, "total": 0},
+        }
+    )
+
+    for date_key, day in sorted(daily_results.items()):
+        group_key = key_builder(date_key)
+        bucket = grouped[group_key]
+        bucket["dates"].append(date_key)
+        bucket["hits"] += int(day.get("hits", 0))
+        bucket["total_calls"] += int(day.get("total_calls", 0))
+
+        for signal_key, config in INDEX_CONFIG.items():
+            result = (day.get("results", {}) or {}).get(signal_key, {})
+            verdict = result.get("verdict")
+            if verdict is None:
+                continue
+            summary_bucket = bucket[config["summary_key"]]
+            summary_bucket["total"] += 1
+            if verdict == "HIT":
+                summary_bucket["hits"] += 1
+
+    summarized: dict[str, dict[str, object]] = {}
+    for group_key, bucket in sorted(grouped.items()):
+        record: dict[str, object] = {
+            "hits": bucket["hits"],
+            "total_calls": bucket["total_calls"],
+            "accuracy": pct(bucket["hits"], bucket["total_calls"]),
+        }
+        if include_dates:
+            record["dates"] = bucket["dates"]
+        for index_key in ("dow", "sp500", "nasdaq"):
+            index_bucket = bucket[index_key]
+            record[index_key] = {
+                "hits": index_bucket["hits"],
+                "total": index_bucket["total"],
+                "pct": pct(index_bucket["hits"], index_bucket["total"]),
+            }
+        if include_trading_days:
+            record["trading_days"] = len(bucket["dates"])
+        summarized[group_key] = record
+
+    return summarized
+
+
+def build_output(daily_results: dict[str, dict[str, object]]) -> dict[str, object]:
+    weekly = aggregate_periods(
+        daily_results,
+        key_builder=lambda date_key: datetime.strptime(date_key, "%Y-%m-%d").strftime("%Y-W%W"),
+        include_dates=True,
+    )
+    monthly = aggregate_periods(
+        daily_results,
+        key_builder=lambda date_key: date_key[:7],
+        include_trading_days=True,
+    )
+
+    sorted_dates = sorted(daily_results.keys())
+    return {
+        "meta": {
+            "last_updated": iso_utc_now(),
+            "total_days_scored": len(sorted_dates),
+            "data_range": {
+                "from": sorted_dates[0] if sorted_dates else None,
+                "to": sorted_dates[-1] if sorted_dates else None,
+            },
+            "source": "Historic CSV backtest via scripts/seed_accuracy.py",
+        },
+        "daily": daily_results,
+        "weekly": weekly,
+        "monthly": monthly,
+    }
+
+
+def format_score(hits: int, total: int) -> str:
+    if total <= 0:
+        return "0/0 (--%)"
+    return f"{hits}/{total} ({round((hits / total) * 100):.0f}%)"
+
+
+def print_summary(output: dict[str, object]) -> None:
+    monthly = output.get("monthly", {})
+    if not isinstance(monthly, dict):
+        return
+
+    print("=== 2026 Almanac Accuracy Backtest ===")
+    print(f"{'Month':<10} {'Dow':<15} {'S&P 500':<15} {'NASDAQ':<15} {'All':<15}")
+
+    total_hits = 0
+    total_calls = 0
+    per_index_totals = {
+        "dow": {"hits": 0, "total": 0},
+        "sp500": {"hits": 0, "total": 0},
+        "nasdaq": {"hits": 0, "total": 0},
+    }
+
+    for month_key in sorted(monthly.keys()):
+        month_data = monthly[month_key]
+        month_name = datetime.strptime(month_key + "-01", "%Y-%m-%d").strftime("%B")
+        total_hits += int(month_data.get("hits", 0))
+        total_calls += int(month_data.get("total_calls", 0))
+        for index_key in per_index_totals:
+            per_index_totals[index_key]["hits"] += int(month_data.get(index_key, {}).get("hits", 0))
+            per_index_totals[index_key]["total"] += int(month_data.get(index_key, {}).get("total", 0))
+
+        print(
+            f"{month_name:<10} "
+            f"{format_score(month_data['dow']['hits'], month_data['dow']['total']):<15} "
+            f"{format_score(month_data['sp500']['hits'], month_data['sp500']['total']):<15} "
+            f"{format_score(month_data['nasdaq']['hits'], month_data['nasdaq']['total']):<15} "
+            f"{format_score(month_data['hits'], month_data['total_calls']):<15}"
+        )
+
+    total_label = "Q1 Total" if set(monthly.keys()).issubset({"2026-01", "2026-02", "2026-03"}) else "YTD Total"
+    print(
+        f"{total_label:<10} "
+        f"{format_score(per_index_totals['dow']['hits'], per_index_totals['dow']['total']):<15} "
+        f"{format_score(per_index_totals['sp500']['hits'], per_index_totals['sp500']['total']):<15} "
+        f"{format_score(per_index_totals['nasdaq']['hits'], per_index_totals['nasdaq']['total']):<15} "
+        f"{format_score(total_hits, total_calls):<15}"
+    )
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(description="Seed Almanac historic accuracy results from local CSV data.")
+    parser.add_argument("--dji", type=Path, default=INDEX_CONFIG["d"]["default"])
+    parser.add_argument("--sp500", type=Path, default=INDEX_CONFIG["s"]["default"])
+    parser.add_argument("--nasdaq", type=Path, default=INDEX_CONFIG["n"]["default"])
+    return parser.parse_args()
+
+
+def main() -> int:
+    args = parse_args()
+    project_root = Path.cwd()
+
+    try:
+        almanac_daily = load_almanac_predictions(project_root)
+        history_by_index = {
+            "dji": load_history_csv(project_root / Path(args.dji)),
+            "sp500": load_history_csv(project_root / Path(args.sp500)),
+            "nasdaq": load_history_csv(project_root / Path(args.nasdaq)),
+        }
+        daily_results = build_daily_results(almanac_daily, history_by_index)
+        output = build_output(daily_results)
+
+        output_path = project_root / OUTPUT_PATH
+        output_path.parent.mkdir(parents=True, exist_ok=True)
+        with output_path.open("w", encoding="utf-8") as handle:
+            json.dump(output, handle, indent=2)
+            handle.write("\n")
+
+        print_summary(output)
+        print(f"Wrote {output_path}")
+        return 0
+    except Exception as exc:
+        print(f"[seed_accuracy] {exc}", file=sys.stderr)
+        return 1
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

tests/test_seed_accuracy.py

@@ -0,0 +1,165 @@
+"""CLI tests for scripts/seed_accuracy.py."""
+
+from __future__ import annotations
+
+import csv
+import json
+import shutil
+import subprocess
+import sys
+import tempfile
+import unittest
+from pathlib import Path
+
+
+REPO_ROOT = Path(__file__).resolve().parent.parent
+SCRIPT_PATH = REPO_ROOT / "scripts" / "seed_accuracy.py"
+
+
+def write_csv(path: Path, rows: list[dict[str, str]]) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    with path.open("w", encoding="utf-8", newline="") as handle:
+        writer = csv.DictWriter(handle, fieldnames=["Date", "Open", "High", "Low", "Close"])
+        writer.writeheader()
+        writer.writerows(rows)
+
+
+def write_primary_almanac(path: Path) -> None:
+    payload = {
+        "meta": {"source": "fixture", "year": 2026, "generated_at": "2026-04-05T00:00:00Z"},
+        "months": {},
+        "daily": {
+            "2026-01-02": {"d": 60.0, "s": 40.0, "n": 50.0, "notes": "Opening session"},
+            "2026-01-05": {"d": 45.0, "s": 55.0, "n": 70.0, "notes": ""},
+            "2026-01-06": {"d": 80.0, "s": 20.0, "n": 60.0, "notes": "Momentum test"},
+        },
+        "seasonal_signals": [],
+        "seasonal_heatmap": {},
+    }
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(json.dumps(payload, indent=2), encoding="utf-8")
+
+
+def write_fallback_almanac(path: Path) -> None:
+    payload = {
+        "daily_probabilities": {
+            "rows": [
+                {"date": "2026-01-02", "dow_prob": 60.0, "sp500_prob": 40.0, "nasdaq_prob": 50.0, "notes": "Opening session"},
+                {"date": "2026-01-05", "dow_prob": 45.0, "sp500_prob": 55.0, "nasdaq_prob": 70.0, "notes": ""},
+                {"date": "2026-01-06", "dow_prob": 80.0, "sp500_prob": 20.0, "nasdaq_prob": 60.0, "notes": "Momentum test"},
+            ]
+        }
+    }
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(json.dumps(payload, indent=2), encoding="utf-8")
+
+
+def seed_fixture_history(root: Path) -> None:
+    historical_dir = root / "data" / "historical"
+    write_csv(
+        historical_dir / "DJI_daily.csv",
+        [
+            {"Date": "12/31/2025", "Open": "0", "High": "0", "Low": "0", "Close": "100"},
+            {"Date": "01/02/2026", "Open": "0", "High": "0", "Low": "0", "Close": "101"},
+            {"Date": "01/05/2026", "Open": "0", "High": "0", "Low": "0", "Close": "100"},
+            {"Date": "01/06/2026", "Open": "0", "High": "0", "Low": "0", "Close": "102"},
+        ],
+    )
+    write_csv(
+        historical_dir / "GSPC_daily.csv",
+        [
+            {"Date": "12/31/2025", "Open": "0", "High": "0", "Low": "0", "Close": "200"},
+            {"Date": "01/02/2026", "Open": "0", "High": "0", "Low": "0", "Close": "199"},
+            {"Date": "01/05/2026", "Open": "0", "High": "0", "Low": "0", "Close": "200"},
+            {"Date": "01/06/2026", "Open": "0", "High": "0", "Low": "0", "Close": "198"},
+        ],
+    )
+    write_csv(
+        historical_dir / "IXIC_daily.csv",
+        [
+            {"Date": "12/31/2025", "Open": "0", "High": "0", "Low": "0", "Close": "300"},
+            {"Date": "01/02/2026", "Open": "0", "High": "0", "Low": "0", "Close": "300"},
+            {"Date": "01/05/2026", "Open": "0", "High": "0", "Low": "0", "Close": "303"},
+            {"Date": "01/06/2026", "Open": "0", "High": "0", "Low": "0", "Close": "300"},
+        ],
+    )
+
+
+class TestSeedAccuracyScript(unittest.TestCase):
+    def make_project_root(self, name: str) -> Path:
+        root = REPO_ROOT / "tmp_feedback_test_main" / name
+        shutil.rmtree(root, ignore_errors=True)
+        root.mkdir(parents=True, exist_ok=True)
+        return root
+
+    def run_script(self, project_root: Path) -> subprocess.CompletedProcess[str]:
+        return subprocess.run(
+            [sys.executable, str(SCRIPT_PATH)],
+            cwd=project_root,
+            capture_output=True,
+            text=True,
+            check=False,
+        )
+
+    def test_seed_accuracy_generates_output_from_primary_almanac_json(self):
+        project_root = self.make_project_root("seed_accuracy_primary")
+        try:
+            write_primary_almanac(project_root / "data" / "almanac_2026" / "almanac_2026.json")
+            seed_fixture_history(project_root)
+
+            result = self.run_script(project_root)
+
+            self.assertEqual(result.returncode, 0, msg=result.stderr)
+            self.assertIn("January", result.stdout)
+            self.assertIn("Q1 Total", result.stdout)
+
+            output_path = project_root / "data" / "almanac_2026" / "accuracy_results.json"
+            payload = json.loads(output_path.read_text(encoding="utf-8"))
+
+            self.assertEqual(payload["meta"]["total_days_scored"], 3)
+            self.assertEqual(payload["meta"]["data_range"]["from"], "2026-01-02")
+            self.assertEqual(payload["meta"]["data_range"]["to"], "2026-01-06")
+            self.assertEqual(payload["daily"]["2026-01-02"]["hits"], 2)
+            self.assertEqual(payload["daily"]["2026-01-02"]["total_calls"], 2)
+            self.assertEqual(payload["daily"]["2026-01-02"]["results"]["n"]["verdict"], None)
+            self.assertEqual(payload["daily"]["2026-01-06"]["results"]["n"]["verdict"], "MISS")
+            self.assertEqual(payload["weekly"]["2026-W00"]["hits"], 2)
+            self.assertEqual(payload["weekly"]["2026-W01"]["nasdaq"]["pct"], 50.0)
+            self.assertEqual(payload["monthly"]["2026-01"]["hits"], 7)
+            self.assertEqual(payload["monthly"]["2026-01"]["total_calls"], 8)
+            self.assertEqual(payload["monthly"]["2026-01"]["accuracy"], 87.5)
+            self.assertEqual(payload["monthly"]["2026-01"]["trading_days"], 3)
+        finally:
+            shutil.rmtree(project_root, ignore_errors=True)
+
+    def test_seed_accuracy_falls_back_to_structured_dump(self):
+        project_root = self.make_project_root("seed_accuracy_fallback")
+        try:
+            write_fallback_almanac(project_root / "data" / "almanac_2026" / "almanac_2026_db_dump.json")
+            seed_fixture_history(project_root)
+
+            result = self.run_script(project_root)
+
+            self.assertEqual(result.returncode, 0, msg=result.stderr)
+            output_path = project_root / "data" / "almanac_2026" / "accuracy_results.json"
+            payload = json.loads(output_path.read_text(encoding="utf-8"))
+            self.assertEqual(payload["daily"]["2026-01-05"]["hits"], 3)
+            self.assertEqual(payload["daily"]["2026-01-06"]["context"], "Momentum test")
+        finally:
+            shutil.rmtree(project_root, ignore_errors=True)
+
+    def test_seed_accuracy_returns_error_when_history_is_missing(self):
+        project_root = self.make_project_root("seed_accuracy_missing_history")
+        try:
+            write_primary_almanac(project_root / "data" / "almanac_2026" / "almanac_2026.json")
+
+            result = self.run_script(project_root)
+
+            self.assertEqual(result.returncode, 1)
+            self.assertIn("Missing historical CSV", result.stderr)
+        finally:
+            shutil.rmtree(project_root, ignore_errors=True)
+
+
+if __name__ == "__main__":
+    unittest.main()