fix(forecast): accuracy = 100 − WAPE, and days without daylight sample coverage (logger outage) are neither scored nor used to learn the sky model

- mean per-day % error let one partial day (2.1 kWh actual vs 25 forecast) zero a month
- evaluatedForecastRows joins 06:00–17:59 BKK sample counts; < 115 of 144 → actual=null, incomplete=true
- feeds both /api/forecast/accuracy and the learned sky factors

Author: botnick

src/lib/__tests__/skylearn.test.ts

@@ -25,10 +25,15 @@ describe("learnSky — site sky factors shrunk toward the regional prior", () =>
 });
 
 describe("accuracySummary", () => {
-  it("score = 100 − mean absolute % error; bias signed", () => {
+  it("score = 100 − WAPE (Σ|err| ÷ Σactual); bias signed", () => {
     const a = accuracySummary([{ day: "a", predicted: 45, actual: 50 }, { day: "b", predicted: 55, actual: 50 }]);
     expect(a.n).toBe(2); expect(a.score).toBe(90); expect(a.bias).toBeCloseTo(0); expect(a.mae).toBeCloseTo(5);
   });
+  it("one near-empty day can't zero a month of good days (WAPE, not mean APE)", () => {
+    const good = Array.from({ length: 10 }, (_, i) => ({ day: `d${i}`, predicted: 30, actual: 30 }));
+    const a = accuracySummary([...good, { day: "x", predicted: 25, actual: 2.1 }]);
+    expect(a.score).toBeGreaterThan(90); // mean APE would have scored 0
+  });
   it("ignores days with no real production; empty → nulls", () => {
     expect(accuracySummary([{ day: "a", predicted: 10, actual: 0 }]).score).toBeNull();
   });

src/lib/skylearn.ts

@@ -42,7 +42,10 @@ export interface Accuracy { n: number; score: number | null; bias: number | null
 export function accuracySummary(rows: AccRow[]): Accuracy {
   const r = rows.filter((x) => Number.isFinite(x.predicted) && Number.isFinite(x.actual) && x.actual > 0.5);
   if (!r.length) return { n: 0, score: null, bias: null, mae: null };
-  let ape = 0, err = 0, abs = 0;
-  for (const x of r) { const e = x.predicted - x.actual; ape += Math.abs(e) / x.actual; err += e; abs += Math.abs(e); }
-  return { n: r.length, score: Math.round(Math.max(0, 1 - ape / r.length) * 100), bias: err / r.length, mae: abs / r.length };
+  // Score is 100 − WAPE (Σ|error| ÷ Σactual): errors weighted by the energy at stake. A plain mean
+  // of per-day % errors lets one near-empty day (2 kWh actual vs 25 forecast = 1,100 %) wipe out a
+  // month of good days; WAPE is the standard production-forecast metric and has no such cliff.
+  let err = 0, abs = 0, act = 0;
+  for (const x of r) { const e = x.predicted - x.actual; err += e; abs += Math.abs(e); act += x.actual; }
+  return { n: r.length, score: Math.round(Math.max(0, 1 - abs / act) * 100), bias: err / r.length, mae: abs / r.length };
 }

src/worker/index.ts

@@ -703,13 +703,29 @@ app.get("/api/export", async (c) => {
 // One place both the app (/api/totals) and the cron's day-ahead log read from, so
 // what gets evaluated is exactly what was shown. Memoised per isolate 30 min.
 let memModel: { at: number; m: { capKw: number; calibDays: number; sky: Record<number, number>; skyDays: number } } | null = null;
+// 06:00–17:59 = 144 five-minute samples; require 80 % of them
+const DAYLIGHT_COVER_MIN = 115;
 async function evaluatedForecastRows(env: Env, days: number) {
   const today = bkkDayOf(Date.now());
   const cutoff = bkkDayOf(Date.now() - days * 86400000);
+  // A day only counts as "actual" when our own 5-min samples cover most of its daylight: a
+  // logger outage leaves Deye's day total partial (e.g. 2.1 kWh for a ~30 kWh day), and judging
+  // the forecast — or teaching the sky model — on that would be wrong. Such days come back with
+  // actual = null and incomplete = true.
+  const since = Math.floor(Date.parse(cutoff + "T00:00:00+07:00") / 1000);
   const { results } = await env.DB.prepare(
-    `SELECT f.day, f.predicted, f.cond, f.psh, f.cap_kw, d.gen AS actual FROM forecast_log f LEFT JOIN daily d ON d.day = f.day
-     WHERE f.day >= ? AND f.day < ? ORDER BY f.day`).bind(cutoff, today).all();
-  return (results || []) as { day: string; predicted: number; cond: number; psh: number; cap_kw: number; actual: number | null }[];
+    `SELECT f.day, f.predicted, f.cond, f.psh, f.cap_kw, d.gen AS actual, COALESCE(c.n, 0) AS cover
+       FROM forecast_log f
+       LEFT JOIN daily d ON d.day = f.day
+       LEFT JOIN (SELECT date(ts + 25200, 'unixepoch') AS day, COUNT(*) AS n FROM samples
+                   WHERE ts >= ? AND CAST(strftime('%H', ts + 25200, 'unixepoch') AS INTEGER) BETWEEN 6 AND 17
+                   GROUP BY 1) c ON c.day = f.day
+      WHERE f.day >= ? AND f.day < ? ORDER BY f.day`).bind(since, cutoff, today).all();
+  return ((results || []) as any[]).map((r) => {
+    const complete = Number(r.cover) >= DAYLIGHT_COVER_MIN;
+    return { day: String(r.day), predicted: Number(r.predicted), cond: Number(r.cond), psh: Number(r.psh), cap_kw: Number(r.cap_kw),
+      actual: complete && r.actual != null ? Number(r.actual) : null, incomplete: !complete && r.actual != null };
+  });
 }
 async function forecastModel(env: Env) {
   if (memModel && Date.now() - memModel.at < 30 * 60 * 1000) return memModel.m;
@@ -802,7 +818,7 @@ app.get("/api/forecast/accuracy", async (c) => {
   const days = Math.min(365, Math.max(7, Number(c.req.query("days")) || 30));
   const rows = await evaluatedForecastRows(c.env, days);
   const s = accuracySummary(rows.filter((r) => r.actual != null).map((r) => ({ day: r.day, predicted: Number(r.predicted), actual: Number(r.actual) })));
-  return c.json({ days, ...s, rows: rows.map((r) => ({ day: r.day, predicted: Number(r.predicted), actual: r.actual == null ? null : Number(r.actual), cond: Number(r.cond) })) });
+  return c.json({ days, ...s, rows: rows.map((r) => ({ day: r.day, predicted: Number(r.predicted), actual: r.actual == null ? null : Number(r.actual), cond: Number(r.cond), incomplete: r.incomplete })) });
 });
 
 app.get("/api/weather", async (c) => c.json(await getWeather(c.env)));