@richhaase/c2 0.3.2 → 0.4.0

package/src/notes.ts

@@ -0,0 +1,270 @@
+import { mkdir, readdir, readFile, rm, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { isValidYMD } from "./models.ts";
+import type { DataPaths } from "./paths.ts";
+
+export const NOTE_TYPES = ["subjective", "observation", "lesson"] as const;
+export type NoteType = (typeof NOTE_TYPES)[number];
+
+export const NOTE_AUTHORS = ["athlete", "coach"] as const;
+export type NoteAuthor = (typeof NOTE_AUTHORS)[number];
+
+export interface NoteRecord {
+  id: string;
+  date: string;
+  type: NoteType;
+  workout_id?: number;
+  tags?: string[];
+  body: string;
+  author: NoteAuthor;
+}
+
+const CROCKFORD = "0123456789ABCDEFGHJKMNPQRSTVWXYZ";
+
+export function ulid(now: Date): string {
+  let ms = now.getTime();
+  let time = "";
+  for (let i = 0; i < 10; i++) {
+    time = CROCKFORD[ms % 32] + time;
+    ms = Math.floor(ms / 32);
+  }
+  const bytes = new Uint8Array(16);
+  crypto.getRandomValues(bytes);
+  let rand = "";
+  for (const b of bytes) {
+    rand += CROCKFORD[b % 32];
+  }
+  return time + rand;
+}
+
+export function localISO(d: Date): string {
+  const pad = (n: number, width = 2) => String(Math.abs(n)).padStart(width, "0");
+  const offsetMinutes = -d.getTimezoneOffset();
+  const sign = offsetMinutes >= 0 ? "+" : "-";
+  const offset = `${sign}${pad(Math.floor(Math.abs(offsetMinutes) / 60))}:${pad(Math.abs(offsetMinutes) % 60)}`;
+  return `${d.getFullYear()}-${pad(d.getMonth() + 1)}-${pad(d.getDate())}T${pad(d.getHours())}:${pad(d.getMinutes())}:${pad(d.getSeconds())}${offset}`;
+}
+
+export function serializeNote(note: NoteRecord): string {
+  const ordered: Record<string, unknown> = { id: note.id, date: note.date, type: note.type };
+  if (note.workout_id != null) ordered.workout_id = note.workout_id;
+  if (note.tags != null && note.tags.length > 0) ordered.tags = note.tags;
+  ordered.body = note.body;
+  ordered.author = note.author;
+  return JSON.stringify(ordered);
+}
+
+export function isNoteShaped(parsed: unknown): parsed is NoteRecord {
+  const note = parsed as NoteRecord;
+  return (
+    typeof note?.id === "string" &&
+    typeof note?.date === "string" &&
+    typeof note?.body === "string" &&
+    (NOTE_TYPES as readonly string[]).includes(note?.type) &&
+    (NOTE_AUTHORS as readonly string[]).includes(note?.author) &&
+    /^\d{4}-\d{2}-\d{2}T.*(?:Z|[+-]\d{2}:\d{2})$/.test(note.date) &&
+    isValidYMD(note.date.slice(0, 10)) &&
+    !Number.isNaN(new Date(note.date).getTime()) &&
+    (note.workout_id === undefined ||
+      (typeof note.workout_id === "number" && Number.isFinite(note.workout_id))) &&
+    (note.tags === undefined ||
+      (Array.isArray(note.tags) && note.tags.every((t) => typeof t === "string")))
+  );
+}
+
+function parseNote(raw: string): NoteRecord | null {
+  try {
+    const parsed = JSON.parse(raw) as unknown;
+    return isNoteShaped(parsed) ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+
+function compareNotes(a: NoteRecord, b: NoteRecord): number {
+  const aMs = new Date(a.date).getTime();
+  const bMs = new Date(b.date).getTime();
+  if (aMs !== bMs) return aMs < bMs ? -1 : 1;
+  if (a.id !== b.id) return a.id < b.id ? -1 : 1;
+  return 0;
+}
+
+export async function writeNote(paths: DataPaths, note: NoteRecord): Promise<void> {
+  await mkdir(paths.notesDir, { recursive: true });
+  await writeFile(join(paths.notesDir, `${note.id}.json`), `${serializeNote(note)}\n`, "utf-8");
+}
+
+interface LooseEntry {
+  note: NoteRecord;
+  file: string;
+}
+
+async function readLooseEntries(paths: DataPaths): Promise<LooseEntry[]> {
+  const entries: LooseEntry[] = [];
+  let files: string[];
+  try {
+    files = await readdir(paths.notesDir);
+  } catch {
+    return entries;
+  }
+  for (const f of files.sort()) {
+    if (!f.endsWith(".json")) continue;
+    try {
+      const note = parseNote(await readFile(join(paths.notesDir, f), "utf-8"));
+      if (note != null) entries.push({ note, file: f });
+    } catch {}
+  }
+  return entries;
+}
+
+async function readLooseNotes(paths: DataPaths): Promise<Map<string, NoteRecord>> {
+  const notes = new Map<string, NoteRecord>();
+  for (const entry of await readLooseEntries(paths)) {
+    notes.set(entry.note.id, entry.note);
+  }
+  return notes;
+}
+
+async function readArchivedNotes(paths: DataPaths): Promise<Map<string, NoteRecord>> {
+  const notes = new Map<string, NoteRecord>();
+  let files: string[];
+  try {
+    files = await readdir(paths.archiveDir);
+  } catch {
+    return notes;
+  }
+  for (const f of files) {
+    if (!f.endsWith(".jsonl")) continue;
+    let text: string;
+    try {
+      text = await readFile(join(paths.archiveDir, f), "utf-8");
+    } catch {
+      continue;
+    }
+    for (const line of text.split("\n")) {
+      if (line.trim() === "") continue;
+      const note = parseNote(line);
+      if (note != null && !notes.has(note.id)) notes.set(note.id, note);
+    }
+  }
+  return notes;
+}
+
+export async function readAllNotes(paths: DataPaths): Promise<NoteRecord[]> {
+  const archived = await readArchivedNotes(paths);
+  const loose = await readLooseNotes(paths);
+  for (const [id, note] of loose) {
+    archived.set(id, note);
+  }
+  return [...archived.values()].sort(compareNotes);
+}
+
+export interface NoteFilter {
+  type?: string;
+  since?: string;
+  workoutId?: number;
+}
+
+export function filterNotes(notes: NoteRecord[], filter: NoteFilter): NoteRecord[] {
+  return notes.filter((n) => {
+    if (filter.type && n.type !== filter.type) return false;
+    if (filter.since && n.date.slice(0, 10) < filter.since) return false;
+    if (filter.workoutId != null && n.workout_id !== filter.workoutId) return false;
+    return true;
+  });
+}
+
+const COMPACT_AGE_DAYS = 7;
+
+async function readArchiveYear(
+  paths: DataPaths,
+  year: number,
+): Promise<{ notes: NoteRecord[]; safeToRewrite: boolean }> {
+  const notes: NoteRecord[] = [];
+  let text: string;
+  try {
+    text = await readFile(paths.archiveFile(year), "utf-8");
+  } catch (err: unknown) {
+    const code = (err as NodeJS.ErrnoException).code;
+    return { notes, safeToRewrite: code === "ENOENT" };
+  }
+  const seen = new Set<string>();
+  for (const line of text.split("\n")) {
+    if (line.trim() === "") continue;
+    const note = parseNote(line);
+    if (note == null) return { notes, safeToRewrite: false };
+    if (seen.has(note.id)) return { notes, safeToRewrite: false };
+    seen.add(note.id);
+    notes.push(note);
+  }
+  return { notes, safeToRewrite: true };
+}
+
+export interface CompactResult {
+  archived: number;
+  years: number[];
+  skippedYears: number[];
+}
+
+export async function compactNotes(paths: DataPaths, now: Date): Promise<CompactResult> {
+  const cutoff = new Date(now);
+  cutoff.setDate(cutoff.getDate() - COMPACT_AGE_DAYS);
+  const cutoffMs = cutoff.getTime();
+
+  const entries = await readLooseEntries(paths);
+  const deduped = new Map<string, NoteRecord>();
+  const contentById = new Map<string, string>();
+  const divergent = new Set<string>();
+  for (const e of entries) {
+    const content = serializeNote(e.note);
+    const prior = contentById.get(e.note.id);
+    if (prior != null && prior !== content) divergent.add(e.note.id);
+    contentById.set(e.note.id, content);
+    deduped.set(e.note.id, e.note);
+  }
+  const eligible = [...deduped.values()].filter(
+    (n) => !divergent.has(n.id) && new Date(n.date).getTime() < cutoffMs,
+  );
+  if (eligible.length === 0) return { archived: 0, years: [], skippedYears: [] };
+
+  const byYear = new Map<number, NoteRecord[]>();
+  for (const note of eligible) {
+    const year = Number(note.date.slice(0, 4));
+    if (!byYear.has(year)) byYear.set(year, []);
+    byYear.get(year)!.push(note);
+  }
+
+  await mkdir(paths.archiveDir, { recursive: true });
+  let archivedCount = 0;
+  const years: number[] = [];
+  const skippedYears: number[] = [];
+  for (const [year, notes] of byYear) {
+    const existing = await readArchiveYear(paths, year);
+    if (!existing.safeToRewrite) {
+      skippedYears.push(year);
+      continue;
+    }
+    const merged = new Map<string, NoteRecord>();
+    for (const n of existing.notes) merged.set(n.id, n);
+    for (const n of notes) merged.set(n.id, n);
+    const lines = [...merged.values()].sort(compareNotes).map(serializeNote);
+    try {
+      await writeFile(paths.archiveFile(year), `${lines.join("\n")}\n`, "utf-8");
+    } catch {
+      skippedYears.push(year);
+      continue;
+    }
+    const archivedIds = new Set(notes.map((n) => n.id));
+    for (const e of entries) {
+      if (archivedIds.has(e.note.id)) {
+        try {
+          await rm(join(paths.notesDir, e.file), { force: true });
+        } catch {}
+      }
+    }
+    archivedCount += notes.length;
+    years.push(year);
+  }
+
+  return { archived: archivedCount, years: years.sort(), skippedYears: skippedYears.sort() };
+}

package/src/paths.test.ts

@@ -0,0 +1,47 @@
+import { expect, test } from "bun:test";
+import { chmod, mkdir, mkdtemp } from "node:fs/promises";
+import { homedir, tmpdir } from "node:os";
+import { join } from "node:path";
+import { canonicalRoot, expandTilde, pathsFor } from "./paths.ts";
+
+test("expandTilde resolves home shorthand", () => {
+  expect(expandTilde("~")).toBe(homedir());
+  expect(expandTilde("~/Documents/kb")).toBe(join(homedir(), "Documents", "kb"));
+  expect(expandTilde("/absolute/path")).toBe("/absolute/path");
+});
+
+test("pathsFor derives every path from the root", () => {
+  const p = pathsFor("/tmp/c2-store");
+  expect(p.root).toBe("/tmp/c2-store");
+  expect(p.meta).toBe("/tmp/c2-store/meta.json");
+  expect(p.workouts).toBe("/tmp/c2-store/workouts.jsonl");
+  expect(p.strokeFile(42)).toBe("/tmp/c2-store/strokes/42.jsonl");
+  expect(p.archiveFile(2026)).toBe("/tmp/c2-store/notes/archive/2026.jsonl");
+  expect(p.narrativeFile("2026-07-05")).toBe("/tmp/c2-store/reports/2026-07-05.md");
+});
+
+test("pathsFor expands tilde roots", () => {
+  const p = pathsFor("~/kb/c2");
+  expect(p.root).toBe(join(homedir(), "kb", "c2"));
+});
+
+test("canonicalRoot keeps missing tail components", async () => {
+  const base = await mkdtemp(join(tmpdir(), "c2-canon-"));
+  const target = join(base, "a", "b", "c");
+  const out = await canonicalRoot(target);
+  expect(out.endsWith(join("a", "b", "c"))).toBe(true);
+});
+
+test("canonicalRoot preserves the full path when an ancestor is unreadable", async () => {
+  const base = await mkdtemp(join(tmpdir(), "c2-canon-eacces-"));
+  const locked = join(base, "locked");
+  await mkdir(locked);
+  await chmod(locked, 0o000);
+  try {
+    const target = join(locked, "x", "y");
+    const out = await canonicalRoot(target);
+    expect(out.endsWith(join("locked", "x", "y"))).toBe(true);
+  } finally {
+    await chmod(locked, 0o755);
+  }
+});

package/src/paths.ts

@@ -0,0 +1,66 @@
+import { realpath } from "node:fs/promises";
+import { homedir } from "node:os";
+import { basename, dirname, join, resolve } from "node:path";
+import type { Config } from "./config.ts";
+
+export interface DataPaths {
+  root: string;
+  meta: string;
+  workouts: string;
+  strokesDir: string;
+  strokeFile(id: number): string;
+  notesDir: string;
+  archiveDir: string;
+  archiveFile(year: number): string;
+  plan: string;
+  playbook: string;
+  reportsDir: string;
+  narrativeFile(date: string): string;
+}
+
+export function expandTilde(p: string): string {
+  if (p === "~") return homedir();
+  if (p.startsWith("~/")) return join(homedir(), p.slice(2));
+  return p;
+}
+
+export function pathsFor(root: string): DataPaths {
+  const abs = resolve(expandTilde(root));
+  return {
+    root: abs,
+    meta: join(abs, "meta.json"),
+    workouts: join(abs, "workouts.jsonl"),
+    strokesDir: join(abs, "strokes"),
+    strokeFile: (id: number) => join(abs, "strokes", `${id}.jsonl`),
+    notesDir: join(abs, "notes"),
+    archiveDir: join(abs, "notes", "archive"),
+    archiveFile: (year: number) => join(abs, "notes", "archive", `${year}.jsonl`),
+    plan: join(abs, "plan.md"),
+    playbook: join(abs, "playbook.md"),
+    reportsDir: join(abs, "reports"),
+    narrativeFile: (date: string) => join(abs, "reports", `${date}.md`),
+  };
+}
+
+export function dataPaths(cfg: Config): DataPaths {
+  return pathsFor(cfg.data_dir);
+}
+
+export async function canonicalRoot(p: string): Promise<string> {
+  let base = resolve(expandTilde(p));
+  const rest: string[] = [];
+  for (;;) {
+    try {
+      const real = await realpath(base);
+      return rest.length > 0 ? join(real, ...rest) : real;
+    } catch (err: unknown) {
+      if ((err as NodeJS.ErrnoException).code !== "ENOENT") {
+        return rest.length > 0 ? join(base, ...rest) : base;
+      }
+      rest.unshift(basename(base));
+      const parent = dirname(base);
+      if (parent === base) return resolve(expandTilde(p));
+      base = parent;
+    }
+  }
+}

package/src/sessions.ts

@@ -2,10 +2,10 @@ import type { Workout } from "./models.ts";
 import { calendarDay } from "./models.ts";
 
 export interface Session {
-  date: string; // "2026-03-07"
+  date: string;
   workouts: Workout[];
   totalDistance: number;
-  totalTime: number; // tenths of seconds
+  totalTime: number;
 }
 
 export function groupIntoSessions(workouts: Workout[]): Session[] {
@@ -31,7 +31,6 @@ export function groupIntoSessions(workouts: Workout[]): Session[] {
     .sort((a, b) => a.date.localeCompare(b.date));
 }
 
-/** Count unique calendar days (sessions) in a list of workouts. */
 export function sessionCount(workouts: Workout[]): number {
   const days = new Set(workouts.map(calendarDay));
   return days.size;

package/src/stats.test.ts

@@ -30,28 +30,28 @@ function makeGoalConfig(overrides: Partial<Config["goal"]> = {}): Config {
 
 describe("mondayOf", () => {
   test("monday returns same date", () => {
-    const d = new Date(2026, 2, 2); // Mon Mar 2
+    const d = new Date(2026, 2, 2);
     const m = mondayOf(d);
-    expect(m.getDay()).toBe(1); // Monday
+    expect(m.getDay()).toBe(1);
     expect(m.getDate()).toBe(2);
   });
 
   test("wednesday returns previous monday", () => {
-    const d = new Date(2026, 2, 4); // Wed Mar 4
+    const d = new Date(2026, 2, 4);
     const m = mondayOf(d);
     expect(m.getDay()).toBe(1);
     expect(m.getDate()).toBe(2);
   });
 
   test("sunday returns previous monday", () => {
-    const d = new Date(2026, 2, 8); // Sun Mar 8
+    const d = new Date(2026, 2, 8);
     const m = mondayOf(d);
     expect(m.getDay()).toBe(1);
     expect(m.getDate()).toBe(2);
   });
 
   test("handles month boundary", () => {
-    const d = new Date(2026, 2, 1); // Mar 1
+    const d = new Date(2026, 2, 1);
     const m = mondayOf(d);
     expect(m.getDay()).toBe(1);
     expect(m.getTime()).toBeLessThanOrEqual(d.getTime());
@@ -65,8 +65,8 @@ describe("workoutsInRange", () => {
       makeWorkout(2, "2026-02-15 10:00:00", 5000),
       makeWorkout(3, "2026-03-15 10:00:00", 5000),
     ];
-    const from = new Date(2026, 1, 1); // Feb 1
-    const to = new Date(2026, 2, 1); // Mar 1
+    const from = new Date(2026, 1, 1);
+    const to = new Date(2026, 2, 1);
     const result = workoutsInRange(workouts, from, to);
     expect(result).toHaveLength(1);
     expect(result[0]!.id).toBe(2);
@@ -82,10 +82,10 @@ describe("workoutsInRange", () => {
 
 describe("buildWeekSummaries", () => {
   test("buckets workouts into correct weeks", () => {
-    const now = new Date(2026, 2, 7); // Sat Mar 7
+    const now = new Date(2026, 2, 7);
     const workouts = [
-      makeWorkout(1, "2026-03-02 10:00:00", 5000), // Mon of current week
-      makeWorkout(2, "2026-02-23 10:00:00", 6000), // Previous week
+      makeWorkout(1, "2026-03-02 10:00:00", 5000),
+      makeWorkout(2, "2026-02-23 10:00:00", 6000),
     ];
     const summaries = buildWeekSummaries(workouts, now, 2);
     expect(summaries).toHaveLength(2);
@@ -97,12 +97,12 @@ describe("buildWeekSummaries", () => {
     const now = new Date(2026, 2, 7);
     const workouts = [
       makeWorkout(1, "2026-03-02 09:00:00", 1000),
-      makeWorkout(2, "2026-03-02 10:00:00", 2000), // same day
-      makeWorkout(3, "2026-03-04 10:00:00", 3000), // different day
+      makeWorkout(2, "2026-03-02 10:00:00", 2000),
+      makeWorkout(3, "2026-03-04 10:00:00", 3000),
     ];
     const summaries = buildWeekSummaries(workouts, now, 1);
     expect(summaries[0]!.meters).toBe(6000);
-    expect(summaries[0]!.sessions).toBe(2); // 2 unique days
+    expect(summaries[0]!.sessions).toBe(2);
   });
 
   test("returns empty summaries for no workouts", () => {
@@ -120,7 +120,7 @@ describe("computeGoalProgress", () => {
       makeWorkout(1, "2026-03-01 10:00:00", 100_000),
       makeWorkout(2, "2026-02-01 10:00:00", 100_000),
     ];
-    const now = new Date(2026, 2, 7); // Mar 7
+    const now = new Date(2026, 2, 7);
     const goal = computeGoalProgress(workouts, cfg, now);
     expect(goal.totalMeters).toBe(200_000);
     expect(goal.target).toBe(1_000_000);
@@ -141,9 +141,9 @@ describe("computeGoalProgress", () => {
   test("excludes workouts outside goal date range", () => {
     const cfg = makeGoalConfig();
     const workouts = [
-      makeWorkout(1, "2025-12-01 10:00:00", 50_000), // before start
-      makeWorkout(2, "2026-03-01 10:00:00", 100_000), // in range
-      makeWorkout(3, "2027-02-01 10:00:00", 50_000), // after end
+      makeWorkout(1, "2025-12-01 10:00:00", 50_000),
+      makeWorkout(2, "2026-03-01 10:00:00", 100_000),
+      makeWorkout(3, "2027-02-01 10:00:00", 50_000),
     ];
     const now = new Date(2026, 2, 7);
     const goal = computeGoalProgress(workouts, cfg, now);
@@ -153,7 +153,7 @@ describe("computeGoalProgress", () => {
   test("before start date: weeksElapsed is 0", () => {
     const cfg = makeGoalConfig({ start_date: "2026-06-01" });
     const workouts: Workout[] = [];
-    const now = new Date(2026, 2, 7); // before start
+    const now = new Date(2026, 2, 7);
     const goal = computeGoalProgress(workouts, cfg, now);
     expect(goal.weeksElapsed).toBe(0);
     expect(goal.currentAvgPace).toBe(0);
@@ -170,7 +170,7 @@ describe("computeGoalProgress", () => {
       makeWorkout(6, "2026-03-23 10:00:00", 20_000),
       makeWorkout(7, "2026-03-30 10:00:00", 20_000),
     ];
-    const now = new Date(2026, 2, 30, 18);
+    const now = new Date(2026, 3, 6, 18);
     const goal = computeGoalProgress(workouts, cfg, now);
     expect(goal.currentAvgPace).toBe(20_000);
   });
@@ -182,8 +182,19 @@ describe("computeGoalProgress", () => {
       makeWorkout(2, "2026-03-23 10:00:00", 15_000),
       makeWorkout(3, "2026-03-30 10:00:00", 15_000),
     ];
-    const now = new Date(2026, 2, 30, 18);
+    const now = new Date(2026, 3, 6, 18);
     const goal = computeGoalProgress(workouts, cfg, now);
     expect(goal.currentAvgPace).toBe(7_500);
   });
+
+  test("currentAvgPace excludes the current in-progress week", () => {
+    const cfg = makeGoalConfig();
+    const workouts = [
+      makeWorkout(1, "2026-04-06 10:00:00", 20_000),
+      makeWorkout(2, "2026-04-13 06:55:00", 5_500),
+    ];
+    const now = new Date(2026, 3, 13, 18);
+    const goal = computeGoalProgress(workouts, cfg, now);
+    expect(goal.currentAvgPace).toBe(5_000);
+  });
 });

package/src/stats.ts

@@ -1,7 +1,7 @@
 import type { Config } from "./config.ts";
 import { parseGoalDate } from "./config.ts";
 import type { Workout } from "./models.ts";
-import { calendarDay, pace500mSeconds, parsedDate } from "./models.ts";
+import { calendarDay, formatSeconds, pace500mSeconds, parsedDate } from "./models.ts";
 
 export interface WeekSummary {
   weekStart: Date;
@@ -18,13 +18,13 @@ export interface WeekSummary {
 export interface GoalProgress {
   target: number;
   totalMeters: number;
-  progress: number; // ratio 0–1
+  progress: number;
   weeksElapsed: number;
   totalWeeks: number;
   remainingMeters: number;
   remainingWeeks: number;
-  requiredPace: number; // meters/week needed going forward
-  currentAvgPace: number; // meters/week over the recent window
+  requiredPace: number;
+  currentAvgPace: number;
   onPace: boolean;
 }
 
@@ -105,6 +105,58 @@ export function buildWeekSummaries(workouts: Workout[], now: Date, weeks: number
   return summaries;
 }
 
+export interface RecentWeek {
+  weekStart: Date;
+  meters: number;
+  sessions: number;
+}
+
+export function recentWeeks(workouts: Workout[], now: Date, count: number): RecentWeek[] {
+  const out: RecentWeek[] = [];
+  for (let i = 0; i < count; i++) {
+    const weekStart = mondayOf(now);
+    weekStart.setDate(weekStart.getDate() - i * 7);
+    const weekEnd = new Date(weekStart);
+    weekEnd.setDate(weekEnd.getDate() + 7);
+    const weekWorkouts = workoutsInRange(workouts, weekStart, weekEnd);
+    out.push({
+      weekStart,
+      meters: weekWorkouts.reduce((sum, w) => sum + w.distance, 0),
+      sessions: new Set(weekWorkouts.map(calendarDay)).size,
+    });
+  }
+  return out;
+}
+
+export interface WeekSummaryData {
+  week_start: string;
+  meters: number;
+  sessions: number;
+  avg_pace_500m_seconds: number | null;
+  avg_pace_500m: string | null;
+  avg_spm: number | null;
+  avg_hr: number | null;
+}
+
+export function localYMD(d: Date): string {
+  const mm = String(d.getMonth() + 1).padStart(2, "0");
+  const dd = String(d.getDate()).padStart(2, "0");
+  return `${d.getFullYear()}-${mm}-${dd}`;
+}
+
+export function weekSummaryData(ws: WeekSummary): WeekSummaryData {
+  const avgPace = ws.paceCount > 0 ? ws.paceSum / ws.paceCount : null;
+  return {
+    week_start: localYMD(ws.weekStart),
+    meters: ws.meters,
+    sessions: ws.sessions,
+    avg_pace_500m_seconds: avgPace != null ? Math.round(avgPace * 10) / 10 : null,
+    avg_pace_500m: avgPace != null ? formatSeconds(avgPace) : null,
+    avg_spm: ws.spmCount > 0 ? Math.round((ws.spmSum / ws.spmCount) * 10) / 10 : null,
+    avg_hr: ws.hrCount > 0 ? Math.round(ws.hrSum / ws.hrCount) : null,
+  };
+}
+
 export function computeGoalProgress(workouts: Workout[], cfg: Config, now?: Date): GoalProgress {
   const target = cfg.goal.target_meters;
   const start = parseGoalDate(cfg.goal.start_date);
@@ -138,16 +190,17 @@ export function computeGoalProgress(workouts: Workout[], cfg: Config, now?: Date
   if (weeksElapsed > 0) {
     const thisMonday = mondayOf(today);
     const recentStart = new Date(thisMonday);
-    recentStart.setDate(recentStart.getDate() - (RECENT_WEEKS - 1) * 7);
+    recentStart.setDate(recentStart.getDate() - RECENT_WEEKS * 7);
     const windowStart = recentStart < start ? start : recentStart;
+    const windowMs = thisMonday.getTime() - windowStart.getTime();
+    const weeksInWindow = Math.max(1, Math.round(windowMs / (1000 * 60 * 60 * 24 * 7)));
     let recentMeters = 0;
     for (const w of workouts) {
       const t = parsedDate(w);
-      if (t >= windowStart && t <= today) {
+      if (t >= windowStart && t < thisMonday) {
         recentMeters += w.distance;
       }
     }
-    const weeksInWindow = Math.min(RECENT_WEEKS, Math.max(1, weeksElapsed));
     currentAvgPace = Math.floor(recentMeters / weeksInWindow);
   }
   const targetWeekly = target / totalWeeks;