trainerroad-cli 0.1.0 → 0.2.0

package/src/commands/workout-recommend.mjs

@@ -0,0 +1,175 @@
+import { queryWorkoutLibrary } from "./workout-library.mjs";
+
+async function requirePrivateMember(flags, deps) {
+  const { withClient } = deps;
+  const client = await withClient(flags);
+  try {
+    const memberInfo = await client.getMemberInfo();
+    return { client, memberInfo };
+  } catch {
+    throw new Error(
+      "workout-recommend requires private authenticated mode. Login first with trainerroad-cli login.",
+    );
+  }
+}
+
+function numericOrNull(value, deps) {
+  if (value == null) return null;
+  return deps.requireNumber(value, null);
+}
+
+function deriveTarget(explicit, min, max) {
+  if (explicit != null) return explicit;
+  if (min != null && max != null) return (min + max) / 2;
+  return null;
+}
+
+function compareValues(left, right) {
+  if (left === right) return 0;
+  if (left == null) return 1;
+  if (right == null) return -1;
+  if (typeof left === "string" || typeof right === "string") {
+    return String(left).localeCompare(String(right));
+  }
+  return Number(left) - Number(right);
+}
+
+function scoreWorkout(item, targets) {
+  let score = 0;
+  const reasons = [];
+
+  if (targets.level != null && item.progressionLevel != null) {
+    const delta = Math.abs(item.progressionLevel - targets.level);
+    score += delta * 10;
+    reasons.push({ metric: "level", target: targets.level, actual: item.progressionLevel, delta });
+  }
+
+  if (targets.duration != null && item.durationMinutes != null) {
+    const delta = Math.abs(item.durationMinutes - targets.duration);
+    score += delta / 5;
+    reasons.push({ metric: "duration", target: targets.duration, actual: item.durationMinutes, delta });
+  }
+
+  if (targets.tss != null && item.tss != null) {
+    const delta = Math.abs(item.tss - targets.tss);
+    score += delta / 10;
+    reasons.push({ metric: "tss", target: targets.tss, actual: item.tss, delta });
+  }
+
+  if (targets.searchText) {
+    const text = String(item.workoutName ?? "").toLowerCase();
+    const query = String(targets.searchText).toLowerCase();
+    if (text === query) score -= 2;
+    else if (text.includes(query)) score -= 1;
+  }
+
+  if (item.hasInstructions) score -= 0.15;
+  if (item.isOutside === false) score -= 0.05;
+
+  return { score, reasons };
+}
+
+export async function commandWorkoutRecommend(flags, deps) {
+  const { isJsonMode, requirePositiveInteger, requireNumber, toBoolean, writeOutput } = deps;
+  const { client, memberInfo } = await requirePrivateMember(flags, deps);
+
+  const count = requirePositiveInteger(flags.count, 5);
+  const candidateLimit = requirePositiveInteger(flags["candidate-limit"], 100);
+  const minDuration = numericOrNull(flags["min-duration"], deps);
+  const maxDuration = numericOrNull(flags["max-duration"], deps);
+  const minTss = numericOrNull(flags["min-tss"], deps);
+  const maxTss = numericOrNull(flags["max-tss"], deps);
+  const minLevel = numericOrNull(flags["min-level"], deps);
+  const maxLevel = numericOrNull(flags["max-level"], deps);
+  const targetDuration = deriveTarget(numericOrNull(flags["target-duration"], deps), minDuration, maxDuration);
+  const targetTss = deriveTarget(numericOrNull(flags["target-tss"], deps), minTss, maxTss);
+  const targetLevel = deriveTarget(numericOrNull(flags["target-level"], deps), minLevel, maxLevel);
+  const searchText = String(flags.search ?? "").trim();
+
+  const library = await queryWorkoutLibrary(client, memberInfo, {
+    searchText,
+    zone: flags.zone,
+    zoneId: flags["zone-id"],
+    profile: flags.profile,
+    profileId: flags["profile-id"],
+    outside: flags.outside == null ? null : toBoolean(flags.outside, false),
+    hasInstructions:
+      flags["has-instructions"] == null ? null : toBoolean(flags["has-instructions"], false),
+    minDuration,
+    maxDuration,
+    minTss,
+    maxTss,
+    minLevel,
+    maxLevel,
+    sort: String(flags.sort ?? "level"),
+    limit: candidateLimit,
+    pageSize: requirePositiveInteger(flags["page-size"], 50),
+  });
+
+  const targets = {
+    duration: targetDuration,
+    tss: targetTss,
+    level: targetLevel,
+    searchText,
+  };
+
+  const recommendations = library.records
+    .map((item) => {
+      const ranking = scoreWorkout(item, targets);
+      return { ...item, recommendationScore: ranking.score, rationale: ranking.reasons };
+    })
+    .sort(
+      (a, b) =>
+        compareValues(a.recommendationScore, b.recommendationScore) ||
+        compareValues(a.progressionLevel, b.progressionLevel) ||
+        compareValues(a.durationMinutes, b.durationMinutes) ||
+        compareValues(a.workoutName, b.workoutName),
+    )
+    .slice(0, count);
+
+  const payload = {
+    generatedAt: new Date().toISOString(),
+    command: "workout-recommend",
+    member: { memberId: memberInfo.memberId, username: memberInfo.username },
+    query: {
+      searchText,
+      zone: flags.zone ?? null,
+      zoneId: flags["zone-id"] ?? null,
+      profile: flags.profile ?? null,
+      profileId: flags["profile-id"] ?? null,
+      outside: flags.outside ?? null,
+      hasInstructions: flags["has-instructions"] ?? null,
+      minDuration,
+      maxDuration,
+      minTss,
+      maxTss,
+      minLevel,
+      maxLevel,
+      targetDuration,
+      targetTss,
+      targetLevel,
+      count,
+      candidateLimit,
+    },
+    fetch: library.fetch,
+    recommendationCount: recommendations.length,
+    records: recommendations,
+  };
+
+  if (!isJsonMode(flags)) {
+    await writeOutput(payload, flags, (value) => {
+      const lines = [
+        `Workout recommendations (${value.recommendationCount}) candidates=${value.fetch.fetchedCount}/${value.fetch.serverTotalCount ?? "?"}`,
+      ];
+      for (const item of value.records) {
+        lines.push(
+          `- ${item.workoutName ?? "(untitled)"} | workoutId=${item.workoutId} | score=${item.recommendationScore.toFixed(2)} | level=${item.progressionLevel ?? "?"} | duration=${item.durationMinutes ?? "?"}m | tss=${item.tss ?? "?"}`,
+        );
+      }
+      return lines.join("\n");
+    });
+    return;
+  }
+
+  await writeOutput(payload, { ...flags, json: !flags.jsonl });
+}

package/src/commands/workout-tools.mjs

@@ -0,0 +1,326 @@
+function stripHtml(value) {
+  return String(value ?? "")
+    .replace(/<[^>]+>/g, " ")
+    .replace(/&nbsp;/gi, " ")
+    .replace(/&amp;/gi, "&")
+    .replace(/&quot;/gi, '"')
+    .replace(/&#39;/gi, "'")
+    .replace(/\s+/g, " ")
+    .trim();
+}
+
+function summarizeWorkout(workout) {
+  if (!workout || typeof workout !== "object") return null;
+  return {
+    workoutId: workout.id ?? null,
+    workoutName: workout.workoutName ?? workout.name ?? null,
+    zoneId: workout.progressionId ?? workout.progression?.id ?? null,
+    zoneName: workout.progression?.text ?? null,
+    profileId: workout.profileId ?? null,
+    profileName: workout.profileName ?? null,
+    durationMinutes: workout.duration ?? null,
+    tss: workout.tss ?? null,
+    intensityFactor: workout.intensityFactor ?? null,
+    averageFtpPercent: workout.averageFtpPercent ?? null,
+    progressionLevel: workout.progressionLevel ?? null,
+    workoutDifficultyRating: workout.workoutDifficultyRating ?? null,
+    workoutTypeId: workout.workoutTypeId ?? null,
+    workoutLabelId: workout.workoutLabelId ?? null,
+    isOutside: workout.isOutside ?? null,
+    hasInstructions: workout.hasInstructions ?? null,
+    firstPublishDate: workout.firstPublishDate ?? null,
+    indoorAlternativeId: workout.indoorAlternativeId ?? null,
+    energyKj: workout.kj ?? null,
+    goal: stripHtml(workout.goalDescription),
+    description: stripHtml(workout.workoutDescription),
+  };
+}
+
+function summarizePlannedActivity(activity) {
+  if (!activity || typeof activity !== "object") return null;
+  const workout = activity.workout ?? null;
+  const date = activity.date
+    ? `${String(activity.date.year).padStart(4, "0")}-${String(activity.date.month).padStart(2, "0")}-${String(activity.date.day).padStart(2, "0")}`
+    : null;
+  return {
+    plannedActivityId: activity.id ?? null,
+    date,
+    timeOfDay: activity.timeOfDay ?? null,
+    workoutId: workout?.id ?? null,
+    workoutName: workout?.name ?? activity.name ?? null,
+    isOutside: workout?.isOutside ?? null,
+    durationMinutes:
+      workout?.duration ??
+      (Number.isFinite(Number(activity.durationInSeconds))
+        ? Math.round(Number(activity.durationInSeconds) / 60)
+        : null),
+    tss: activity.tss ?? workout?.tss ?? null,
+    recommendationReason: activity.recommendationReason ?? null,
+    modified: activity.modified ?? null,
+  };
+}
+
+function summarizeLevels(levelsPayload) {
+  return {
+    workoutLevels: Array.isArray(levelsPayload?.workoutLevels) ? levelsPayload.workoutLevels : [],
+    athleteLevels:
+      levelsPayload && typeof levelsPayload.athleteLevels === "object" ? levelsPayload.athleteLevels : {},
+  };
+}
+
+function summarizeChart(chartData, pointLimit = 200) {
+  const rawPoints = Array.isArray(chartData?.courseData) ? chartData.courseData : [];
+  const pointsUseMilliseconds =
+    rawPoints.length > 1 && Number(rawPoints[1]?.seconds) >= 1000 && Number(rawPoints[1]?.seconds) % 1000 === 0;
+  const points = rawPoints.map((point) => ({
+    ...point,
+    seconds:
+      pointsUseMilliseconds && Number.isFinite(Number(point?.seconds))
+        ? Number(point.seconds) / 1000
+        : point?.seconds ?? null,
+  }));
+  let minPercent = null;
+  let maxPercent = null;
+  let durationSeconds = 0;
+  for (const point of points) {
+    const ftpPercent = Number(point?.ftpPercent);
+    if (Number.isFinite(ftpPercent)) {
+      minPercent = minPercent == null ? ftpPercent : Math.min(minPercent, ftpPercent);
+      maxPercent = maxPercent == null ? ftpPercent : Math.max(maxPercent, ftpPercent);
+    }
+    const seconds = Number(point?.seconds);
+    if (Number.isFinite(seconds)) durationSeconds = Math.max(durationSeconds, seconds);
+  }
+  return {
+    pointCount: points.length,
+    durationSeconds,
+    minFtpPercent: minPercent,
+    maxFtpPercent: maxPercent,
+    points: points.slice(0, pointLimit),
+  };
+}
+
+function requireFlag(flags, name) {
+  const value = flags[name];
+  if (value === undefined || value === null || value === "") {
+    throw new Error(`Missing required flag --${name}.`);
+  }
+  return value;
+}
+
+async function requirePrivateMember(flags, deps) {
+  const { withClient } = deps;
+  const client = await withClient(flags);
+  try {
+    const memberInfo = await client.getMemberInfo();
+    return { client, memberInfo };
+  } catch {
+    throw new Error(
+      "This command requires private authenticated mode. Login first with trainerroad-cli login.",
+    );
+  }
+}
+
+async function sleep(ms) {
+  await new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+async function findPlannedWorkoutOnDate(client, memberInfo, dateIso, workoutId) {
+  const timeline = await client.getTimeline(memberInfo.memberId, memberInfo.username);
+  const candidateIds = (Array.isArray(timeline?.plannedActivities) ? timeline.plannedActivities : [])
+    .filter((item) => {
+      const date = item?.date;
+      const asIso = date
+        ? `${String(date.year).padStart(4, "0")}-${String(date.month).padStart(2, "0")}-${String(date.day).padStart(2, "0")}`
+        : null;
+      return asIso === dateIso;
+    })
+    .map((item) => item.id)
+    .filter(Boolean);
+
+  if (candidateIds.length === 0) return null;
+  const details = await client.getPlannedActivitiesByIds(
+    memberInfo.memberId,
+    memberInfo.username,
+    candidateIds,
+  );
+  const matches = details.filter((item) => Number(item?.workout?.id) === Number(workoutId));
+  if (matches.length === 0) return null;
+  return matches.sort((a, b) => String(b.modified ?? "").localeCompare(String(a.modified ?? "")))[0];
+}
+
+async function listPlannedWorkoutsOnDate(client, memberInfo, dateIso) {
+  const timeline = await client.getTimeline(memberInfo.memberId, memberInfo.username);
+  const candidateIds = (Array.isArray(timeline?.plannedActivities) ? timeline.plannedActivities : [])
+    .filter((item) => {
+      const date = item?.date;
+      const asIso = date
+        ? `${String(date.year).padStart(4, "0")}-${String(date.month).padStart(2, "0")}-${String(date.day).padStart(2, "0")}`
+        : null;
+      return asIso === dateIso;
+    })
+    .map((item) => item.id)
+    .filter(Boolean);
+
+  if (candidateIds.length === 0) return [];
+  return client.getPlannedActivitiesByIds(memberInfo.memberId, memberInfo.username, candidateIds);
+}
+
+export async function commandWorkoutDetails(flags, deps) {
+  const { isJsonMode, requirePositiveInteger, toBoolean, writeOutput } = deps;
+  const workoutId = Number(requireFlag(flags, "id"));
+  if (!Number.isFinite(workoutId)) {
+    throw new Error(`Invalid --id "${flags.id}". Expected a numeric workout ID.`);
+  }
+
+  const includeChart = toBoolean(flags["include-chart"], false);
+  const chartPointLimit = requirePositiveInteger(flags["chart-point-limit"], 200);
+  const { client, memberInfo } = await requirePrivateMember(flags, deps);
+
+  const [byIdRows, summaryPayload, levelsPayload, chartData] = await Promise.all([
+    client.getWorkoutsByIds([workoutId], memberInfo.username),
+    client.getWorkoutSummary(workoutId, memberInfo.username),
+    client.getWorkoutLevels(workoutId, memberInfo.username),
+    includeChart ? client.getWorkoutChartData(workoutId, memberInfo.username) : Promise.resolve(null),
+  ]);
+
+  const byIdWorkout = Array.isArray(byIdRows) && byIdRows.length > 0 ? byIdRows[0] : null;
+  const summaryWorkout = summaryPayload?.summary ?? null;
+  const workout = summarizeWorkout(summaryWorkout ?? byIdWorkout);
+  const payload = {
+    generatedAt: new Date().toISOString(),
+    command: "workout-details",
+    member: { memberId: memberInfo.memberId, username: memberInfo.username },
+    query: { workoutId, includeChart, chartPointLimit },
+    workout,
+    levels: summarizeLevels(levelsPayload),
+    chart: includeChart ? summarizeChart(chartData, chartPointLimit) : undefined,
+  };
+
+  if (!isJsonMode(flags)) {
+    await writeOutput(payload, flags, (value) => {
+      const lines = [
+        `${value.workout?.workoutName ?? "Workout"} | workoutId=${value.query.workoutId} | zone=${value.workout?.zoneName ?? value.workout?.zoneId ?? "?"} | profile=${value.workout?.profileName ?? value.workout?.profileId ?? "?"}`,
+        `duration=${value.workout?.durationMinutes ?? "?"}m | tss=${value.workout?.tss ?? "?"} | if=${value.workout?.intensityFactor ?? "?"} | level=${value.workout?.progressionLevel ?? "?"} | outside=${value.workout?.isOutside}`,
+      ];
+      if (value.chart) {
+        lines.push(
+          `chart: points=${value.chart.pointCount} duration=${value.chart.durationSeconds}s ftp%=${value.chart.minFtpPercent ?? "?"}-${value.chart.maxFtpPercent ?? "?"}`,
+        );
+      }
+      return lines.join("\n");
+    });
+    return;
+  }
+
+  await writeOutput(payload, { ...flags, json: !flags.jsonl });
+}
+
+export async function commandAddWorkout(flags, deps) {
+  const { isJsonMode, toBoolean, writeOutput } = deps;
+  const workoutId = Number(requireFlag(flags, "workout-id"));
+  const dateIso = String(requireFlag(flags, "date"));
+  if (!Number.isFinite(workoutId)) {
+    throw new Error(`Invalid --workout-id "${flags["workout-id"]}". Expected a numeric workout ID.`);
+  }
+
+  const outside = toBoolean(flags.outside, false);
+  const { client, memberInfo } = await requirePrivateMember(flags, deps);
+  const workoutRows = await client.getWorkoutsByIds([workoutId], memberInfo.username);
+  const workout = summarizeWorkout(Array.isArray(workoutRows) ? workoutRows[0] : null);
+  if (!workout) {
+    throw new Error(`Workout ${workoutId} was not found in the library.`);
+  }
+
+  const attempts = await client.tryAddWorkoutToCalendar(workoutId, dateIso, {
+    outside,
+    usernameForReferer: memberInfo.username,
+  });
+
+  let created = null;
+  for (let attempt = 0; attempt < 4; attempt += 1) {
+    created = await findPlannedWorkoutOnDate(client, memberInfo, dateIso, workoutId);
+    if (created) break;
+    await sleep(750);
+  }
+
+  if (!created) {
+    throw new Error(
+      `TrainerRoad did not expose a confirmed added workout for ${dateIso}. Attempts: ${JSON.stringify(attempts)}`,
+    );
+  }
+
+  const payload = {
+    generatedAt: new Date().toISOString(),
+    command: "add-workout",
+    member: { memberId: memberInfo.memberId, username: memberInfo.username },
+    query: { workoutId, date: dateIso, outside },
+    workout,
+    created: summarizePlannedActivity(created),
+    attempts,
+    warnings: attempts.some((item) => !item.ok)
+      ? [
+          "TrainerRoad returned one or more non-2xx responses during add-workout, but the workout was observed on the calendar after reconciliation.",
+        ]
+      : [],
+  };
+
+  if (!isJsonMode(flags)) {
+    await writeOutput(payload, flags, (value) => {
+      const warning = value.warnings.length > 0 ? " | warning=server-status-mismatch" : "";
+      return `Added ${value.workout?.workoutName ?? "workout"} to ${value.query.date} | plannedActivityId=${value.created?.plannedActivityId}${warning}`;
+    });
+    return;
+  }
+
+  await writeOutput(payload, { ...flags, json: !flags.jsonl });
+}
+
+export async function commandCopyWorkout(flags, deps) {
+  const { isJsonMode, writeOutput } = deps;
+  const sourcePlannedActivityId = String(requireFlag(flags, "id"));
+  const targetDate = String(requireFlag(flags, "date"));
+  const { client, memberInfo } = await requirePrivateMember(flags, deps);
+  const source = await client.getPlannedActivity(sourcePlannedActivityId, memberInfo.username);
+  const beforeTarget = await listPlannedWorkoutsOnDate(client, memberInfo, targetDate);
+  const beforeIds = new Set(beforeTarget.map((item) => item.id));
+
+  const mutation = await client.copyPlannedActivity(sourcePlannedActivityId, targetDate, memberInfo.username);
+
+  let created = null;
+  for (let attempt = 0; attempt < 5; attempt += 1) {
+    const afterTarget = await listPlannedWorkoutsOnDate(client, memberInfo, targetDate);
+    created = afterTarget.find(
+      (item) =>
+        !beforeIds.has(item.id) &&
+        Number(item?.workout?.id) === Number(source?.workout?.id),
+    );
+    if (created) break;
+    await sleep(500);
+  }
+
+  if (!created) {
+    throw new Error(
+      `Copy completed but no new planned workout was found on ${targetDate} for source ${sourcePlannedActivityId}.`,
+    );
+  }
+
+  const payload = {
+    generatedAt: new Date().toISOString(),
+    command: "copy-workout",
+    member: { memberId: memberInfo.memberId, username: memberInfo.username },
+    query: { sourcePlannedActivityId, date: targetDate },
+    source: summarizePlannedActivity(source),
+    created: summarizePlannedActivity(created),
+    mutation,
+  };
+
+  if (!isJsonMode(flags)) {
+    await writeOutput(payload, flags, (value) => {
+      return `Copied ${value.source?.workoutName ?? "workout"} to ${value.query.date} | plannedActivityId=${value.created?.plannedActivityId}`;
+    });
+    return;
+  }
+
+  await writeOutput(payload, { ...flags, json: !flags.jsonl });
+}

package/src/commands/workouts.mjs

@@ -1,3 +1,17 @@
+function addLocalTimeSummary(record, summarizeActivityTime) {
+  if (!record || typeof record !== "object" || typeof summarizeActivityTime !== "function") {
+    return record;
+  }
+  const summary = summarizeActivityTime(record.started, record.durationInSeconds);
+  if (!summary) return record;
+  return { ...record, ...summary };
+}
+
+function addLocalTimeSummaryList(records, summarizeActivityTime) {
+  const rows = Array.isArray(records) ? records : [];
+  return rows.map((record) => addLocalTimeSummary(record, summarizeActivityTime));
+}
+
 export async function commandFuture(flags, deps) {
   const {
     requireNumber,
@@ -130,6 +144,7 @@ export async function commandPast(flags, deps) {
     writeOutput,
     hasAgentRecordTransforms,
     sortByDateDesc,
+    summarizeActivityTime,
   } = deps;
 
   const days = requireNumber(flags.days, 60);
@@ -144,7 +159,8 @@ export async function commandPast(flags, deps) {
   if (context.mode === "private") {
     const filtered = filterPastActivities(context.timeline.activities, fromDate, toDate).slice(0, limit);
     if (!flags.details) {
-      const { records: filteredRecords, filterSummary } = applyAgentRecordFilters(filtered, flags);
+      const recordsWithLocalTime = addLocalTimeSummaryList(filtered, summarizeActivityTime);
+      const { records: filteredRecords, filterSummary } = applyAgentRecordFilters(recordsWithLocalTime, flags);
       const payload = {
         mode: "private",
         generatedAt: new Date().toISOString(),
@@ -165,7 +181,10 @@ export async function commandPast(flags, deps) {
             return lines.join("\n");
           }
           for (const item of value.records) {
-            lines.push(`- ${item.started} id=${item.id} type=${item.type} tss=${item.tss}`);
+            const overnightLabel = item.crossesMidnightLocal ? " | overnight=true" : "";
+            lines.push(
+              `- ${item.startedAtLocal ?? item.started} id=${item.id} type=${item.type} tss=${item.tss}${overnightLabel}`,
+            );
           }
           return lines.join("\n");
         });
@@ -190,7 +209,11 @@ export async function commandPast(flags, deps) {
       ...item,
       personalRecordCount: Array.isArray(personalRecords[item.id]) ? personalRecords[item.id].length : 0,
     }));
-    const { records: filteredRecords, filterSummary } = applyAgentRecordFilters(detailRecords, flags);
+    const detailRecordsWithLocalTime = addLocalTimeSummaryList(detailRecords, summarizeActivityTime);
+    const { records: filteredRecords, filterSummary } = applyAgentRecordFilters(
+      detailRecordsWithLocalTime,
+      flags,
+    );
     const payload = {
       mode: "private",
       generatedAt: new Date().toISOString(),
@@ -215,8 +238,9 @@ export async function commandPast(flags, deps) {
           return lines.join("\n");
         }
         for (const item of value.records) {
+          const overnightLabel = item.crossesMidnightLocal ? " | overnight=true" : "";
           lines.push(
-            `- ${new Date(item.started).toISOString()} ${item.name} | id=${item.id} | tss=${item.tss} | duration=${item.durationInSeconds}s | prs=${item.personalRecordCount}`,
+            `- ${item.startedAtLocal ?? item.started} ${item.name} | id=${item.id} | tss=${item.tss} | duration=${item.durationInSeconds}s | prs=${item.personalRecordCount}${overnightLabel}`,
           );
         }
         return lines.join("\n");
@@ -286,6 +310,7 @@ export async function commandToday(flags, deps) {
     writeOutput,
     hasAgentRecordTransforms,
     toIsoDateFromPlanned,
+    summarizeActivityTime,
   } = deps;
 
   const today = normalizeDateOnlyInput(flags.date, isoDateShift(0));
@@ -316,9 +341,10 @@ export async function commandToday(flags, deps) {
       );
     }
 
+    const completedWithLocalTime = addLocalTimeSummaryList(activityRecords, summarizeActivityTime);
     const records = [
       ...plannedRecords.map((item) => ({ recordType: "planned", ...item })),
-      ...activityRecords.map((item) => ({
+      ...completedWithLocalTime.map((item) => ({
         recordType: "completed",
         ...item,
         personalRecordCount: Array.isArray(personalRecords[item.id]) ? personalRecords[item.id].length : 0,
@@ -333,9 +359,9 @@ export async function commandToday(flags, deps) {
       query: { date: today, details: Boolean(flags.details) },
       filters: filterSummary,
       member: { memberId: context.memberInfo.memberId, username: context.memberInfo.username },
-      counts: { planned: plannedRecords.length, completed: activityRecords.length },
+      counts: { planned: plannedRecords.length, completed: completedWithLocalTime.length },
       planned: plannedRecords,
-      completed: activityRecords,
+      completed: completedWithLocalTime,
       personalRecords,
       count: filteredRecords.length,
       records: filteredRecords,
@@ -372,9 +398,15 @@ export async function commandToday(flags, deps) {
         for (const item of value.completed) {
           if (flags.details) {
             const prs = Array.isArray(value.personalRecords[item.id]) ? value.personalRecords[item.id].length : 0;
-            lines.push(`- completed ${new Date(item.started).toISOString()} ${item.name} | tss=${item.tss} | prs=${prs}`);
+            const overnightLabel = item.crossesMidnightLocal ? " | overnight=true" : "";
+            lines.push(
+              `- completed ${item.startedAtLocal ?? item.started} ${item.name} | tss=${item.tss} | prs=${prs}${overnightLabel}`,
+            );
           } else {
-            lines.push(`- completed ${item.started} id=${item.id} type=${item.type} tss=${item.tss}`);
+            const overnightLabel = item.crossesMidnightLocal ? " | overnight=true" : "";
+            lines.push(
+              `- completed ${item.startedAtLocal ?? item.started} id=${item.id} type=${item.type} tss=${item.tss}${overnightLabel}`,
+            );
           }
         }
         return lines.join("\n");

package/src/lib/agent-filters.mjs

@@ -1,6 +1,13 @@
+import { normalizeTimeZone, toDateOnlyInTimeZone } from "./timezone.mjs";
+
 function toIsoDate(value) {
-  if (typeof value === "string" && value.length >= 10) return value.slice(0, 10);
-  return new Date(value).toISOString().slice(0, 10);
+  if (typeof value === "string" && value.length >= 10 && /^\d{4}-\d{2}-\d{2}/.test(value)) {
+    return value.slice(0, 10);
+  }
+  return (
+    toDateOnlyInTimeZone(value, normalizeTimeZone(), { assumeUtcForOffsetlessDateTime: true }) ??
+    new Date(value).toISOString().slice(0, 10)
+  );
 }
 
 function toIsoDateFromPlannedRecord(record) {