workout_app: deload after a training gap at load

The old break rule ran at finish after the session was saved, so
daysSince was always 0 and it never fired. Now the gap deload cuts
by tier (7-13d 1 step, 14-20d 2, +1/week, 40% cap) when the workout
loads, stamps last_deloaded_at (shared with manual deload, synced),
logs progression_events, and shows the old target struck through.
One-time backfill with pre-cut export + restore script.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
Krzysztof Rudnicki 2026-11-20 23:53:33 +01:00
parent 27e4ff5064
commit bc4e590822
32 changed files with 1507 additions and 54 deletions

View File

@ -0,0 +1,33 @@
"""Restore of the pre-gap-deload export (scripts/restore_exercise_state.py)."""
from __future__ import annotations
import datetime as dt
import pytest
from scripts import restore_exercise_state as res
_NOW = dt.datetime(2026, 11, 21, 12, 0, tzinfo=dt.UTC)
def test_every_row_gets_a_newer_stamp_and_a_deload_stamp() -> None:
export = {
"format": "workout_app-export",
"version": 3,
"exercise_state": [
{"name": "Dumbbell Lunge", "weight": 20.0, "updated_at": 5},
{"name": "Situp", "weight": 10.0, "updated_at": 0},
],
}
doc = res.prepare_restore(export, _NOW)
stamp = int(_NOW.timestamp() * 1000)
assert [r["updated_at"] for r in doc["exercise_state"]] == [stamp, stamp]
assert all(r["last_deloaded_at"].startswith("2026-11-21T12:00") for r in doc["exercise_state"])
assert doc["exercise_state"][0]["weight"] == 20.0
assert doc["version"] == 3
def test_an_empty_export_is_refused() -> None:
with pytest.raises(ValueError, match="nothing to restore"):
res.prepare_restore({"exercise_state": []}, _NOW)

View File

@ -101,6 +101,24 @@ desktop() {
ok "restarted ${UNITS[*]}"
}
# The app's one-time gap deload backfill saves the pre-cut exercise_state on
# its first start after install; keep a PC copy so restore works without the
# phone's dir. The app needs a few seconds after launch, hence the retries;
# a miss only warns, `restore_exercise_state.py pull` fetches it later.
deload_export() {
local tries
[[ -f "$HOME/.local/state/screen-locker/exercise_state_pre_gap_deload.json" ]] && return 0
for tries in 1 2 3 4 5 6 7 8 9 10; do
if python3 "$LIVE/scripts/restore_exercise_state.py" pull >/dev/null 2>&1; then
ok "pre-gap-deload export copied to ~/.local/state/screen-locker/"
return 0
fi
sleep 2
done
echo "deploy: WARN: no pre-gap-deload export pulled after $tries tries;" \
"run: python3 $LIVE/scripts/restore_exercise_state.py pull" >&2
}
phone() {
local rc=0 tree
tree="$(git -C "$LIVE" rev-parse "HEAD:$APP_DIR")" || die "no $APP_DIR tree at $LIVE HEAD"
@ -114,6 +132,7 @@ phone() {
mkdir -p "$(dirname "$PHONE_APP_MARKER")"
printf '%s\n' "$tree" > "$PHONE_APP_MARKER"
ok "workout app release build installed on the phone (tree ${tree:0:10})"
deload_export
;;
46) die "phone_deploy protect guard (exit 46) refused com.kuhy.workout_app;" \
"kuhy runs: PHONE_PROTECT_ALLOW=com.kuhy.workout_app bash $LIVE/scripts/deploy.sh" \

View File

@ -0,0 +1,113 @@
#!/usr/bin/env python3
"""Pull or restore the workout app's pre-gap-deload ``exercise_state`` export.
The phone's one-time gap deload backfill saves the pre-cut weights as
``exercise_state_pre_gap_deload.json`` in the app's external files dir
before it cuts anything.
restore_exercise_state.py pull # copy it to ~/.local/state/screen-locker/
restore_exercise_state.py restore # put those weights back on the phone
``restore`` stamps every row with a newer ``updated_at`` (so the app's import
lets it win) and a fresh ``last_deloaded_at`` (so the gap deload does not cut
the restored weights again before the next session), pushes it as
``restore_exercise_state.json``, restarts the app, and checks that the app
consumed the file. The app then pushes the restored state to Firebase.
Restore goes through the phone, not Firebase: after its first reconcile the
phone never pulls progression, so a Firebase-side write would never land.
"""
from __future__ import annotations
import argparse
import datetime as dt
import json
import os
import subprocess
import sys
import tempfile
import time
from pathlib import Path
from typing import Any
APP_ID = "com.kuhy.workout_app"
REMOTE_DIR = f"/sdcard/Android/data/{APP_ID}/files"
EXPORT_NAME = "exercise_state_pre_gap_deload.json"
RESTORE_NAME = "restore_exercise_state.json"
STATE_DIR = Path.home() / ".local/state/screen-locker"
LOCAL_EXPORT = STATE_DIR / EXPORT_NAME
CONSUME_WAIT_S = 20
def prepare_restore(export: dict[str, Any], now: dt.datetime) -> dict[str, Any]:
"""Return an import document that makes every exported row win."""
rows = export.get("exercise_state")
if not isinstance(rows, list) or not rows:
msg = "export has no exercise_state rows; nothing to restore"
raise ValueError(msg)
stamp_ms = int(now.timestamp() * 1000)
stamp_iso = now.replace(tzinfo=None).isoformat(timespec="microseconds")
return {
"format": export.get("format", "workout_app-export"),
"version": export.get("version", 3),
"exported_at": stamp_iso,
"exercise_state": [
{**row, "updated_at": stamp_ms, "last_deloaded_at": stamp_iso} for row in rows
],
}
def _adb(*args: str) -> subprocess.CompletedProcess[str]:
serial = os.environ.get("ADB_SERIAL", "23181JEGR08034")
return subprocess.run(
["adb", "-s", serial, *args], check=True, capture_output=True, text=True, timeout=30
)
def pull() -> Path:
"""Copy the phone's pre-cut export to ``LOCAL_EXPORT``."""
STATE_DIR.mkdir(parents=True, exist_ok=True)
_adb("pull", f"{REMOTE_DIR}/{EXPORT_NAME}", str(LOCAL_EXPORT))
print(f"[OK] pre-deload export saved: {LOCAL_EXPORT}")
return LOCAL_EXPORT
def restore(source: Path) -> None:
"""Push ``source`` back to the phone and confirm the app imported it."""
export = json.loads(source.read_text(encoding="utf-8"))
doc = prepare_restore(export, dt.datetime.now().astimezone())
with tempfile.TemporaryDirectory() as tmp:
path = Path(tmp) / RESTORE_NAME
path.write_text(json.dumps(doc), encoding="utf-8")
_adb("push", str(path), f"{REMOTE_DIR}/{RESTORE_NAME}")
# Force-stop keeps the app's data; the next start imports the file.
_adb("shell", "am", "force-stop", APP_ID)
_adb("shell", "monkey", "-p", APP_ID, "-c", "android.intent.category.LAUNCHER", "1")
deadline = time.monotonic() + CONSUME_WAIT_S
while time.monotonic() < deadline:
listing = _adb("shell", "ls", REMOTE_DIR).stdout.split()
if RESTORE_NAME not in listing:
names = ", ".join(r["name"] for r in doc["exercise_state"])
print(f"[OK] restored {len(doc['exercise_state'])} exercise(s): {names}")
return
time.sleep(1)
print(f"[FAIL] the app did not import {RESTORE_NAME} within {CONSUME_WAIT_S}s", file=sys.stderr)
sys.exit(1)
def main(argv: list[str] | None = None) -> None:
"""Parse the command line and run ``pull`` or ``restore``."""
parser = argparse.ArgumentParser(description=__doc__.splitlines()[0])
sub = parser.add_subparsers(dest="cmd", required=True)
sub.add_parser("pull", help="copy the phone's pre-deload export to the PC")
rest = sub.add_parser("restore", help="write the exported weights back")
rest.add_argument("--file", type=Path, default=LOCAL_EXPORT)
args = parser.parse_args(argv)
if args.cmd == "pull":
pull()
else:
restore(args.file)
if __name__ == "__main__":
main()

View File

@ -1,4 +1,5 @@
import 'dart:async';
import 'dart:developer' show log;
import 'dart:io' show HttpOverrides, Platform;
// Framework material, for its MaterialLocalizations delegate only: material_ui
@ -16,6 +17,7 @@ import 'package:workout_app/sandbox/sandbox_log.dart';
import 'package:workout_app/screens/home_screen.dart';
import 'package:workout_app/services/backup_service.dart';
import 'package:workout_app/services/break_service_controller.dart';
import 'package:workout_app/services/exercise_state_files.dart';
import 'package:workout_app/services/foreground_break_client_flutter.dart';
import 'package:workout_app/services/foreground_run_client_flutter.dart';
import 'package:workout_app/services/http_server_service.dart';
@ -138,6 +140,8 @@ void main(List<String> args) async {
),
);
debugPrint('WorkoutApp: ${restored.reason}');
// The real app only: the sandbox gets backdated test data instead.
if (!Sandbox.enabled) await _repairProgression();
// Android-only transport: it exists so the PC can pull today's workout off
// the phone over LAN. On the PC itself it would bind the very port the PC
// scans, so it is skipped rather than serving the machine to itself.
@ -248,3 +252,28 @@ class _WorkoutAppState extends State<WorkoutApp> with WidgetsBindingObserver {
);
}
}
// coverage:ignore-start
// Launch-path glue, like main() above; both halves are tested on their own
// (exercise_state_files_test, storage_service_gap_deload_test).
/// Imports a pushed restore file, then runs the one-time gap deload
/// backfill (stamped, so later launches skip it), and pushes what changed.
Future<void> _repairProgression() async {
final files = ExerciseStateFiles();
final restore = await files.importRestoreFile();
debugPrint('WorkoutApp: ${restore.reason}');
final backfill = await StorageService.instance.runGapDeloadBackfill(
writeExport: files.writeDeloadExport,
);
debugPrint('WorkoutApp: ${backfill.reason}');
if (restore.rows > 0 || backfill.deloads.isNotEmpty) {
unawaited(
ProgressionSyncService().pushProgression().then((r) {
if (!r.changed) {
log('Repaired progression not synced: ${r.reason}', level: 1000);
}
}),
);
}
}
// coverage:ignore-end

View File

@ -49,6 +49,7 @@ class ExerciseState implements ProgressionInputs {
required this.restSuccessSecs,
required this.restFailSecs,
required this.restWarmupSecs,
this.lastDeloadedAt,
});
/// The state a never-trained [ex] starts from.
@ -128,6 +129,13 @@ class ExerciseState implements ProgressionInputs {
/// Rest after the warmup set, in seconds.
final int restWarmupSecs;
/// When the target was last cut by a deload -- manual, gap or backfill --
/// or null if never. One shared stamp: the gap deload skips an exercise
/// deloaded after its last session, so nothing is cut twice. Optional
/// (unlike the rest) because only deloads write it; every other rebuild
/// carries it through [copyWith].
final DateTime? lastDeloadedAt;
/// Whether the exercise is paused at [now].
bool isPausedAt(DateTime now) {
final until = pausedUntil;
@ -150,6 +158,7 @@ class ExerciseState implements ProgressionInputs {
int? restSuccessSecs,
int? restFailSecs,
int? restWarmupSecs,
DateTime? lastDeloadedAt,
bool resume = false,
}) => ExerciseState(
name: name,
@ -169,6 +178,7 @@ class ExerciseState implements ProgressionInputs {
restSuccessSecs: restSuccessSecs ?? this.restSuccessSecs,
restFailSecs: restFailSecs ?? this.restFailSecs,
restWarmupSecs: restWarmupSecs ?? this.restWarmupSecs,
lastDeloadedAt: lastDeloadedAt ?? this.lastDeloadedAt,
);
}

View File

@ -0,0 +1,134 @@
/// The gap deload: how far a training break cuts an exercise's target.
///
/// Applied when the workout loads, not when it finishes. The old rule lived
/// in `applyProgression` and could never fire: finishing saves the session
/// first, so "days since the last workout" was always 0. It also only ever
/// took one step, so a two-week break started from the pre-gap max.
///
/// Pure on purpose: the storage layer decides *whether* an exercise is due
/// (stamp, history) and these functions decide *how much*.
library;
import 'package:workout_app/models/progression.dart';
/// Shortest break, in calendar days, that costs a step.
const int kGapDeloadMinDays = 7;
/// Every further week of break costs one more step.
const int kGapDeloadDaysPerStep = 7;
/// The most a gap deload may take off the pre-gap weight (or reps, in reps
/// mode): a hard cap, however long the break.
const double kGapDeloadMaxLoss = 0.4;
/// `progression_events.kind` of a deload a training gap caused at load.
const String kGapDeloadKind = 'gap_deload';
/// `progression_events.kind` of the one-time repair of existing data.
const String kBackfillDeloadKind = 'backfill_deload';
/// Calendar days from [from] to [to]: 23:00 to 01:00 next day is one day.
///
/// Built from UTC dates so a DST change inside the gap cannot shave an hour
/// off and turn 7 days into 6.
int gapCalendarDays(DateTime from, DateTime to) => DateTime.utc(
to.year,
to.month,
to.day,
).difference(DateTime.utc(from.year, from.month, from.day)).inDays;
/// Regression steps a break of [gapDays] calendar days costs: under 7 none,
/// 7-13 one, 14-20 two, then one more per extra week.
int gapDeloadSteps(int gapDays) => gapDays < kGapDeloadMinDays
? 0
: 1 + (gapDays - kGapDeloadMinDays) ~/ kGapDeloadDaysPerStep;
/// [s]'s target after [steps] regression steps, each one
/// [targetAfterFailure], stopping before any step that would take more than
/// [kGapDeloadMaxLoss] off [s]'s weight (or, in reps mode, its reps).
///
/// A step that alone breaks the cap is not taken: 5 kg -> 2.5 kg is a 50%
/// loss, so a 5 kg exercise keeps 5 kg. Double progression caps on weight
/// only; its rep drops within one weight are the small steps of the ladder.
ProgressionTarget gapDeloadTarget(ProgressionInputs s, int steps) {
final weightFloor = s.weight * (1 - kGapDeloadMaxLoss);
final repsFloor = (s.reps * (1 - kGapDeloadMaxLoss)).ceil();
var cur = s;
for (var i = 0; i < steps; i++) {
final t = targetAfterFailure(cur);
if (t.weight == cur.weight && t.reps == cur.reps) break;
// A tiny epsilon: 0.6 * 12.5 is 7.499999... in binary.
if (t.weight < weightFloor - 1e-9) break;
if (s.mode == ProgressionMode.reps && t.reps < repsFloor) break;
cur = _Step(s, t);
}
return ProgressionTarget(cur.weight, cur.reps);
}
/// One finished session of one exercise: when it ended and its target.
class SessionMark {
/// Creates a [SessionMark].
const SessionMark({
required this.endedAt,
required this.weight,
required this.reps,
});
/// When the session ended (local time).
final DateTime endedAt;
/// The target weight the session was done at, in kg.
final double weight;
/// The target reps the session was done at.
final int reps;
}
/// Steps the history still owes: the replay (part c) of the backfill.
///
/// Replays [marks] (oldest first) with the new rule. Each gap of a week or
/// more between two sessions should have cut the next one's target; when the
/// next session ran at the SAME target, that cut never happened and its
/// steps are owed. Any target change afterwards (a fail-streak deload, a
/// success step, a hand edit) re-anchors the replay on what was really
/// lifted, so the debt clears. That is kuhy's case: failed after a 7-day
/// break at the pre-gap weight, then a second break on top.
int missedGapSteps(List<SessionMark> marks) {
var owed = 0;
for (var i = 1; i < marks.length; i++) {
final prev = marks[i - 1];
final cur = marks[i];
if (cur.weight != prev.weight || cur.reps != prev.reps) {
owed = 0;
continue;
}
owed += gapDeloadSteps(gapCalendarDays(prev.endedAt, cur.endedAt));
}
return owed;
}
/// [ProgressionInputs] of [base] with [t]'s weight and reps: one step down.
class _Step implements ProgressionInputs {
_Step(this._base, this._t);
final ProgressionInputs _base;
final ProgressionTarget _t;
@override
double get weight => _t.weight;
@override
int get reps => _t.reps;
@override
double get maxWeight => _base.maxWeight;
@override
ProgressionMode get mode => _base.mode;
@override
int get repsHigh => _base.repsHigh;
@override
int get repsLow => _base.repsLow;
}

View File

@ -13,6 +13,7 @@ import 'package:workout_app/screens/settings_screen.dart';
import 'package:workout_app/screens/workout_screen.dart';
import 'package:workout_app/services/done_today.dart';
import 'package:workout_app/services/lock_mode.dart';
import 'package:workout_app/services/progression_sync_service.dart';
import 'package:workout_app/services/storage_service.dart';
import 'package:workout_app/services/sync_status.dart';
import 'package:workout_app/services/workout_sync_service.dart';
@ -90,8 +91,12 @@ class _HomeScreenState extends State<HomeScreen> {
Future<void> _load() async {
final storage = StorageService.instance;
final nextType = await storage.getNextWorkoutType();
final exercises = await storage.getCurrentExercises(nextType);
final saved = await storage.loadActiveSession();
// The gap deload runs before the targets are read, so the workout opens
// at the cut weight. Never under a saved session: that workout already
// started at its own targets. Stamped per exercise, so a reload is a no-op.
if (saved == null) await _applyGapDeloads(storage);
final exercises = await storage.getCurrentExercises(nextType);
final lastDate = await storage.getLastWorkoutDate();
final today = DateTime.now();
final doneLocally =

View File

@ -81,4 +81,23 @@ extension _HomeScreenLaunch on _HomeScreenState {
return false;
}
}
/// Cuts every exercise a training break made due, then pushes the cut to
/// Firebase so other devices see it. The phone is the only place this
/// runs; the PC only reads workouts and never cuts.
Future<void> _applyGapDeloads(StorageService storage) async {
final done = await storage.applyGapDeloads();
if (done.isEmpty) return;
SandboxLog.event('gap deload', {
for (final d in done) d.name: '${d.from.weight}x${d.from.reps}'
'->${d.to.weight}x${d.to.reps}',
});
unawaited(
ProgressionSyncService().pushProgression().then((r) {
if (!r.changed) {
log('Gap deload not synced: ${r.reason}', level: 1000);
}
}),
);
}
}

View File

@ -50,6 +50,11 @@ class _SandboxSectionState extends State<_SandboxSection> {
);
}
Future<void> _seedGaps() async {
await StorageService.instance.seedGapScenarios();
_report('Seeded backdated sessions; open the workout to see the cuts.');
}
Future<void> _saveRest() async {
final secs = int.tryParse(_rest.text.trim());
if (secs == null || secs < 1) {
@ -98,6 +103,13 @@ class _SandboxSectionState extends State<_SandboxSection> {
semanticLabel: 'Mark today not done',
),
),
ElevatedButton(
onPressed: () => unawaited(_seedGaps()),
child: const Icon(
Icons.history,
semanticLabel: 'Seed gap deload cases',
),
),
],
),
const SizedBox(height: 12),

View File

@ -85,6 +85,9 @@ class _WorkoutScreenState extends State<WorkoutScreen> {
late final List<Exercise> _exercises = List.of(widget.exercises);
Map<String, ExerciseState> _exerciseStates = {};
/// Gap deloads this workout opened with, shown struck through on tiles.
Map<String, ProgressionEvent> _gapDeloads = {};
// Break state. The deadline is the source of truth: `_breakClock` is what
// survives the app being backgrounded, and everything else is derived from
// it. See services/break_clock.dart for why a tick counter could not be.
@ -153,11 +156,13 @@ class _WorkoutScreenState extends State<WorkoutScreen> {
Future<void> _loadExerciseStates() async {
final states = await StorageService.instance.getAllExerciseStates();
final gapDeloads = await StorageService.instance.activeGapDeloads();
// After, not beside, the read above: the push below carries both.
await _cues.load();
if (mounted) {
setState(() {
_exerciseStates = {for (final s in states) s.name: s};
_gapDeloads = gapDeloads;
});
// The first snapshot can go out before this load lands, and it would
// count a paused exercise's sets until the next tap. A no-op if the
@ -226,6 +231,7 @@ class _WorkoutScreenState extends State<WorkoutScreen> {
child: _WorkoutBody(
exercises: _exercises,
exerciseStates: _exerciseStates,
gapDeloads: _gapDeloads,
tapped: _tapped,
doneReps: _doneReps,
warmupTapped: _warmupTapped,

View File

@ -33,8 +33,12 @@ class _WorkoutBody extends StatelessWidget {
required this.onTapWarmup,
required this.onSettingsChanged,
required this.onDeload,
this.gapDeloads = const {},
});
/// Gap deloads no session has followed yet, by exercise name.
final Map<String, ProgressionEvent> gapDeloads;
/// The exercises in this session, in display order.
final List<Exercise> exercises;
@ -145,6 +149,10 @@ class _WorkoutBody extends StatelessWidget {
onTapWarmup: () => onTapWarmup(i),
onSettingsChanged: onSettingsChanged,
onDeload: () => onDeload(i),
deloadedFrom: switch (gapDeloads[ex.name]) {
null => null,
final e => ProgressionTarget(e.fromWeight, e.fromReps),
},
);
}
}

View File

@ -85,13 +85,11 @@ extension _WorkoutScreenFinish on _WorkoutScreenState {
json: session.toJsonString(),
);
final lastDate = await storage.getLastWorkoutDate() ?? _startTime;
await storage.applyProgression(
succeededExercises: {
for (int i = 0; i < _exercises.length; i++)
_exercises[i].name: results[i].succeeded,
},
lastWorkoutDate: lastDate,
);
await storage.setLastWorkoutType(widget.workoutType);
await storage.clearActiveSession();

View File

@ -0,0 +1,127 @@
/// The files around the one-time gap deload backfill: its pre-cut export
/// and the restore file `scripts/restore_exercise_state.py` pushes back.
///
/// Both live in the app's external files dir
/// (`/sdcard/Android/data/<package>/files`), the one place `adb` can reach on
/// a release build without storage permission. The export is also written
/// to the internal support dir, a second copy that survives a cleared
/// external dir.
///
/// The restore goes through the phone's own stamped import, not Firebase:
/// after its first reconcile the phone never pulls progression again (local
/// wins), so a PC-side Firebase write would never land and be overwritten
/// by the next push.
library;
import 'dart:convert';
import 'dart:developer';
import 'dart:io';
import 'package:path/path.dart' as p;
import 'package:path_provider/path_provider.dart';
import 'package:workout_app/services/storage_service.dart';
/// File name of the pre-cut `exercise_state` export.
const String kDeloadExportFileName = 'exercise_state_pre_gap_deload.json';
/// File name the restore script pushes.
const String kRestoreFileName = 'restore_exercise_state.json';
/// What [ExerciseStateFiles.importRestoreFile] did.
class RestoreOutcome {
/// Creates an outcome.
const RestoreOutcome({required this.rows, required this.reason});
/// Rows the import wrote; 0 when no file was there or it was unusable.
final int rows;
/// Why, as a sentence.
final String reason;
}
// coverage:ignore-start
// Android-only plugin calls; the suite injects directories instead.
Future<List<Directory>> _defaultExportDirs() async => [
await getApplicationSupportDirectory(),
if (Platform.isAndroid) ?await getExternalStorageDirectory(),
];
Future<Directory?> _defaultRestoreDir() async =>
Platform.isAndroid ? await getExternalStorageDirectory() : null;
// coverage:ignore-end
/// Writes the backfill export and imports a pushed restore file.
class ExerciseStateFiles {
/// Creates the helper; the arguments are test seams.
ExerciseStateFiles({
Future<List<Directory>> Function()? exportDirs,
Future<Directory?> Function()? restoreDir,
}) : _exportDirs = exportDirs ?? _defaultExportDirs,
_restoreDir = restoreDir ?? _defaultRestoreDir;
final Future<List<Directory>> Function() _exportDirs;
final Future<Directory?> Function() _restoreDir;
/// Writes [json] to every export dir. Throws when none could be written,
/// which stops the backfill before it cuts anything.
Future<void> writeDeloadExport(String json) async {
var written = 0;
final failures = <String>[];
for (final dir in await _exportDirs()) {
try {
await dir.create(recursive: true);
await File(p.join(dir.path, kDeloadExportFileName)).writeAsString(json);
written++;
log('ExerciseStateFiles: pre-deload export saved in ${dir.path}');
} on FileSystemException catch (error) {
failures.add('${dir.path}: $error');
log(
'ExerciseStateFiles: pre-deload export NOT saved in ${dir.path} '
'($error).',
level: 900,
);
}
}
if (written == 0) {
throw FileSystemException(
'no copy of the pre-deload export could be written: '
'${failures.isEmpty ? 'no export directory' : failures.join('; ')}',
);
}
}
/// Imports [kRestoreFileName] if the restore script pushed one, then
/// renames it so the next launch does not import it again.
Future<RestoreOutcome> importRestoreFile() async {
final dir = await _restoreDir();
if (dir == null) {
return const RestoreOutcome(
rows: 0,
reason: 'no external files dir on this platform',
);
}
final file = File(p.join(dir.path, kRestoreFileName));
if (!file.existsSync()) {
return const RestoreOutcome(rows: 0, reason: 'no restore file pushed');
}
final ImportReport report;
try {
final data = jsonDecode(await file.readAsString());
report = await StorageService.instance.importDataReport(
data as Map<String, dynamic>,
);
} on Object catch (error) {
final reason =
'restore file ${file.path} is not a workout_app export ($error); '
'left in place, nothing restored';
log('ExerciseStateFiles: $reason', level: 1000);
return RestoreOutcome(rows: 0, reason: reason);
}
final done = '${file.path}.done-${DateTime.now().millisecondsSinceEpoch}';
await file.rename(done);
final reason =
'restore file imported ${report.rows} row(s); kept as $done';
log('ExerciseStateFiles: $reason', level: 900);
return RestoreOutcome(rows: report.rows, reason: reason);
}
}

View File

@ -111,6 +111,7 @@ class ProgressionSyncService {
'rest_success_secs': s.restSuccessSecs,
'rest_fail_secs': s.restFailSecs,
'rest_warmup_secs': s.restWarmupSecs,
'last_deloaded_at': s.lastDeloadedAt?.toIso8601String(),
};
// Every field after fail_threshold is lenient: records pushed before it
@ -135,6 +136,10 @@ class ProgressionSyncService {
(j['rest_fail_secs'] as num?)?.toInt() ?? kDefaultRestFailSecs,
restWarmupSecs:
(j['rest_warmup_secs'] as num?)?.toInt() ?? kDefaultRestWarmupSecs,
lastDeloadedAt: switch (j['last_deloaded_at']) {
final String raw => DateTime.tryParse(raw),
_ => null,
},
);
/// The remote path holding [name]'s progression record.

View File

@ -13,6 +13,7 @@ import 'package:path_provider/path_provider.dart';
import 'package:sqflite/sqflite.dart';
import 'package:workout_app/models/exercise.dart';
import 'package:workout_app/models/exercise_state.dart';
import 'package:workout_app/models/gap_deload.dart';
import 'package:workout_app/models/manual_deload.dart';
import 'package:workout_app/models/progression.dart';
import 'package:workout_app/models/run_record.dart';
@ -33,6 +34,7 @@ part 'storage_service_backup.dart';
part 'storage_service_deload.dart';
part 'storage_service_exercises.dart';
part 'storage_service_export.dart';
part 'storage_service_gap_deload.dart';
part 'storage_service_import.dart';
part 'storage_service_pc_link.dart';
part 'storage_service_runs.dart';
@ -100,7 +102,7 @@ class StorageService {
// coverage:ignore-end
_db = await openDatabase(
dbPath,
version: 9,
version: 10,
onCreate: _createSchema,
onUpgrade: _migrateSchema,
// In tests resetForTesting() reopens a ':memory:' DB per test; sqflite's

View File

@ -42,6 +42,9 @@ extension StorageServiceDeload on StorageService {
);
}
// One stamp for manual and gap deloads: the gap deload skips an
// exercise deloaded since its last session.
final at = DateTime.now();
final changed = await _db.transaction((txn) async {
final rows = await txn.update(
'exercise_state',
@ -50,6 +53,7 @@ extension StorageServiceDeload on StorageService {
'reps': t.reps,
'success_streak': 0,
'fail_streak': 0,
'last_deloaded_at': at.toIso8601String(),
'updated_at': _nowMs(),
},
where: 'name = ?',
@ -59,7 +63,7 @@ extension StorageServiceDeload on StorageService {
// must not leave an event describing a deload nobody received.
if (rows != 1) return false;
await txn.insert('progression_events', {
'at': DateTime.now().toIso8601String(),
'at': at.toIso8601String(),
'exercise': name,
'kind': kManualDeloadKind,
'source': source.storageKey,
@ -86,6 +90,7 @@ extension StorageServiceDeload on StorageService {
reps: t.reps,
successStreak: 0,
failStreak: 0,
lastDeloadedAt: at,
),
reason: reason,
);

View File

@ -35,6 +35,7 @@ extension StorageServiceExercises on StorageService {
restSuccessSecs: r['rest_success_secs']! as int,
restFailSecs: r['rest_fail_secs']! as int,
restWarmupSecs: r['rest_warmup_secs']! as int,
lastDeloadedAt: _parseDeloadStamp(r['last_deloaded_at']),
);
}
@ -153,6 +154,7 @@ extension StorageServiceExercises on StorageService {
'has_warmup': state.hasWarmup ? 1 : 0,
'paused_until': _pauseColumn(state),
..._restColumnValues(state),
'last_deloaded_at': state.lastDeloadedAt?.toIso8601String(),
'updated_at': _nowMs(),
}, conflictAlgorithm: ConflictAlgorithm.replace);
}

View File

@ -0,0 +1,307 @@
// The gap deload: cut a target after a training break, once, at load.
//
// Its own part next to storage_service_deload.dart: both write a target
// change plus its `progression_events` row in one transaction and share the
// `last_deloaded_at` stamp. See storage_service_backup.dart for why these are
// `part` extensions.
part of 'storage_service.dart';
/// Settings key stamped once the one-time backfill has run.
const String kGapDeloadBackfillKey = 'gap_deload_backfill_v1';
/// `progression_events.source` of a cut the app made by itself.
const String kAutoDeloadSource = 'auto';
/// One exercise's gap deload, as written.
class GapDeload {
/// Creates a [GapDeload].
const GapDeload({
required this.name,
required this.from,
required this.to,
required this.steps,
});
/// Exercise name.
final String name;
/// The target before the cut.
final ProgressionTarget from;
/// The target after it.
final ProgressionTarget to;
/// Regression steps the gap asked for (the 40% cap may have taken fewer).
final int steps;
}
/// What [StorageServiceGapDeload.runGapDeloadBackfill] did.
class BackfillReport {
/// Creates a report.
const BackfillReport({
required this.ran,
required this.reason,
this.deloads = const [],
});
/// Whether the backfill ran (and is now stamped).
final bool ran;
/// Why it did or did not, as a sentence.
final String reason;
/// Every exercise it cut.
final List<GapDeload> deloads;
}
/// Gap deload at workout load, plus its one-time backfill.
extension StorageServiceGapDeload on StorageService {
/// Every exercise's finished sessions, oldest first.
///
/// Read from `workout_history`, which also holds sessions synced from other
/// devices. Manual logs (table tennis, "other") name no exercise, so they
/// cannot move a per-exercise gap.
Future<Map<String, List<SessionMark>>> sessionMarks() async {
final rows = await _db.query('workout_history', columns: ['date', 'json']);
final marks = <String, List<SessionMark>>{};
for (final row in rows) {
final payload = StorageServiceSessions._decodeJson(row['json']);
if (payload == null) continue;
final ended = _sessionEnd(payload, row['date']);
if (ended == null) {
log(
'StorageService: a session row has no readable end_time, '
'start_time or date — it does not count toward any training gap.',
level: 900,
);
continue;
}
final exercises = payload['exercises'];
if (exercises is! List) continue;
for (final ex in exercises) {
if (ex is! Map || ex['name'] is! String) continue;
marks
.putIfAbsent(ex['name']! as String, () => [])
.add(
SessionMark(
endedAt: ended,
// -1: an old row with no target breaks every replay chain
// instead of matching another unknown one.
weight: (ex['targetWeight'] as num?)?.toDouble() ?? -1,
reps: (ex['targetReps'] as num?)?.toInt() ?? -1,
),
);
}
}
for (final list in marks.values) {
list.sort((a, b) => a.endedAt.compareTo(b.endedAt));
}
return marks;
}
/// Cuts every exercise whose last session is a week or more before [now].
///
/// Skips an exercise deloaded (manually or by an earlier run of this)
/// after its last session, so reopening the workout never cuts twice.
/// With [includeOwed] (the backfill) the history's unpaid gaps are added
/// on top -- see [missedGapSteps] -- and the lower of the two results wins.
/// Every cut zeroes both streaks, stamps `last_deloaded_at` and logs a
/// `progression_events` row of [kind], in one transaction.
Future<List<GapDeload>> applyGapDeloads({
DateTime? now,
String kind = kGapDeloadKind,
bool includeOwed = false,
}) async {
final at = now ?? DateTime.now();
final marks = await sessionMarks();
final done = <GapDeload>[];
for (final state in await getAllExerciseStates()) {
final history = marks[state.name];
if (history == null || history.isEmpty) continue;
final last = history.last.endedAt;
final stamp = state.lastDeloadedAt;
if (stamp != null && stamp.isAfter(last)) continue;
final steps = gapDeloadSteps(gapCalendarDays(last, at));
if (steps == 0) continue;
var t = gapDeloadTarget(state, steps);
var total = steps;
if (includeOwed) {
final owed = missedGapSteps(history);
final replay = gapDeloadTarget(state, steps + owed);
if (_lower(replay, t)) {
t = replay;
total = steps + owed;
}
}
if (t.weight == state.weight && t.reps == state.reps) {
log(
'StorageService: ${state.name} is due $steps gap step(s) but '
'already sits where the 40% cap stops them; left as is.',
);
continue;
}
if (await _writeGapDeload(state, t, at, kind)) {
done.add(
GapDeload(
name: state.name,
from: ProgressionTarget(state.weight, state.reps),
to: t,
steps: total,
),
);
log(
'StorageService: $kind ${state.name} after '
'${gapCalendarDays(last, at)} days: '
'${_deloadKg(state.weight)} kg × ${state.reps} → '
'${_deloadKg(t.weight)} kg × ${t.reps}',
);
}
}
if (done.isNotEmpty) unawaited(_backupNow());
return done;
}
/// The newest gap or backfill deload per exercise that no session has
/// followed yet: what the tile shows struck through.
Future<Map<String, ProgressionEvent>> activeGapDeloads() async {
final marks = await sessionMarks();
final shown = <String, ProgressionEvent>{};
for (final e in await getProgressionEvents()) {
if (e.kind != kGapDeloadKind && e.kind != kBackfillDeloadKind) continue;
if (shown.containsKey(e.exercise)) continue; // newest first
final history = marks[e.exercise];
if (history != null &&
history.isNotEmpty &&
!history.last.endedAt.isBefore(e.at)) {
continue;
}
shown[e.exercise] = e;
}
return shown;
}
/// The one-time repair of the data the broken rule left behind.
///
/// [writeExport] receives a JSON export of `exercise_state` BEFORE any cut;
/// if it throws, nothing is cut and the stamp stays unset, so the next
/// launch retries. Then every exercise last trained a week or more ago is
/// cut by its current gap plus whatever the history still owes. Exercises
/// trained since are left alone. Runs once: [kGapDeloadBackfillKey].
Future<BackfillReport> runGapDeloadBackfill({
required Future<void> Function(String json) writeExport,
DateTime? now,
}) async {
final stamp = await _getSetting(kGapDeloadBackfillKey);
if (stamp != null) {
return BackfillReport(
ran: false,
reason: 'gap deload backfill already ran at $stamp',
);
}
final export = jsonEncode({
'format': kExportFormat,
'version': kExportVersion,
'exported_at': DateTime.now().toIso8601String(),
'exercise_state': await _db.query('exercise_state', orderBy: 'name'),
});
try {
await writeExport(export);
} on Object catch (error, stackTrace) {
final reason =
'gap deload backfill NOT run: the pre-cut export of exercise_state '
'could not be saved ($error), so nothing was cut; the next launch '
'retries';
log(
'StorageService: $reason',
level: 1000,
error: error,
stackTrace: stackTrace,
);
return BackfillReport(ran: false, reason: reason);
}
final deloads = await applyGapDeloads(
now: now,
kind: kBackfillDeloadKind,
includeOwed: true,
);
await _setSetting(
kGapDeloadBackfillKey,
(now ?? DateTime.now()).toIso8601String(),
);
final reason = 'gap deload backfill cut ${deloads.length} exercise(s)';
log('StorageService: $reason');
return BackfillReport(ran: true, reason: reason, deloads: deloads);
}
Future<bool> _writeGapDeload(
ExerciseState state,
ProgressionTarget t,
DateTime at,
String kind,
) => _db.transaction((txn) async {
final rows = await txn.update(
'exercise_state',
{
'weight': t.weight,
'reps': t.reps,
'success_streak': 0,
'fail_streak': 0,
'last_deloaded_at': at.toIso8601String(),
'updated_at': _nowMs(),
},
where: 'name = ?',
whereArgs: [state.name],
);
if (rows != 1) {
log(
'StorageService: ${state.name} vanished from exercise_state during '
'its gap deload; nothing was cut or logged.',
level: 900,
);
return false;
}
await txn.insert('progression_events', {
'at': at.toIso8601String(),
'exercise': state.name,
'kind': kind,
'source': kAutoDeloadSource,
'from_weight': state.weight,
'from_reps': state.reps,
'to_weight': t.weight,
'to_reps': t.reps,
});
return true;
});
}
/// Whether [a] is a lighter target than [b]: weight first, then reps.
bool _lower(ProgressionTarget a, ProgressionTarget b) =>
a.weight < b.weight || (a.weight == b.weight && a.reps < b.reps);
/// When a session payload ended: `end_time`, else `start_time`, else the
/// row's `date`.
DateTime? _sessionEnd(Map<String, dynamic> payload, Object? rowDate) {
for (final raw in [payload['end_time'], payload['start_time'], rowDate]) {
if (raw is String) {
final parsed = DateTime.tryParse(raw);
if (parsed != null) return parsed;
}
}
return null;
}
/// Reads a stored `last_deloaded_at`; anything unreadable is reported and
/// treated as "never", which lets the gap rule decide.
DateTime? _parseDeloadStamp(Object? raw) {
if (raw == null) return null;
final parsed = raw is String ? DateTime.tryParse(raw) : null;
if (parsed == null) {
log(
'StorageService: unreadable last_deloaded_at "$raw" — treating the '
'exercise as never deloaded.',
level: 900,
);
}
return parsed;
}

View File

@ -67,4 +67,71 @@ extension StorageServiceSandbox on StorageService {
/// Persists the speed-up the sandbox replays its GPS run at.
Future<void> setSandboxReplayFactor(int factor) =>
_setSetting(kSandboxReplayFactorKey, '$factor');
/// Wipes, then backdates finished sessions so the next workout load runs
/// every gap-deload case at once (sandbox only, never the real app):
/// Lunge 8 days (one step), Bench 15 days (two), Row 5 days (none), Curl
/// 40 days (stops at the 40% cap); in workout B, Romanian Deadlift in reps
/// mode and Overhead Press in double progression, both 14 days.
Future<void> seedGapScenarios([DateTime? now]) async {
final at = now ?? DateTime.now();
await wipeAll();
Future<void> seed(
String name,
int daysAgo, {
required double weight,
required int reps,
ProgressionMode mode = ProgressionMode.weight,
}) async {
await _db.update(
'exercise_state',
{'weight': weight, 'reps': reps, 'progression_mode': mode.storageKey},
where: 'name = ?',
whereArgs: [name],
);
final end = at.subtract(Duration(days: daysAgo));
final start = end.subtract(const Duration(hours: 1));
final day = start.toIso8601String().substring(0, 10);
await _db.insert('workout_history', {
'date': day,
'workout_type': 'A',
'duration_seconds': 3600,
'succeeded': 1,
'json': jsonEncode({
'date': day,
'start_time': start.toIso8601String(),
'end_time': end.toIso8601String(),
'exercises': [
{
'name': name,
'targetWeight': weight,
'targetReps': reps,
'succeeded': true,
},
],
}),
});
}
await seed('Dumbbell Lunge', 8, weight: 20, reps: 12);
await seed('Dumbbell Bench Press', 15, weight: 22.5, reps: 12);
await seed('Dumbbell Row', 5, weight: 22.5, reps: 6);
await seed('Dumbbell Curl', 40, weight: 12.5, reps: 12);
await seed(
'Dumbbell Romanian Deadlift',
14,
weight: 27.5,
reps: 10,
mode: ProgressionMode.reps,
);
await seed(
'Dumbbell Overhead Press',
14,
weight: 7.5,
reps: 8,
mode: ProgressionMode.doubleProgression,
);
// Last was B, so the home screen offers A with the four A cases.
await _setSetting('last_workout_type', 'B');
}
}

View File

@ -34,6 +34,9 @@ const _progressionEventsTable = '''
/// stamped import row beats it.
const _updatedAtColumn = 'updated_at INTEGER NOT NULL DEFAULT 0';
/// The v10 shared deload stamp (local ISO-8601), NULL = never deloaded.
const _lastDeloadedColumn = 'last_deloaded_at TEXT';
/// Milliseconds since the epoch, UTC: the value every user write stamps.
int _nowMs() => DateTime.now().toUtc().millisecondsSinceEpoch;
@ -56,7 +59,8 @@ extension StorageServiceSchema on StorageService {
has_warmup INTEGER,
paused_until TEXT,
$_restColumns,
$_updatedAtColumn
$_updatedAtColumn,
$_lastDeloadedColumn
)
''');
await db.execute('''
@ -155,6 +159,13 @@ extension StorageServiceSchema on StorageService {
await db.execute(ddl);
}
}
if (oldVersion < 10) {
// NULL for every existing row: no deload before v10 stamped anything,
// and the gap deload reads NULL as "due if the gap says so".
await db.execute(
'ALTER TABLE exercise_state ADD COLUMN $_lastDeloadedColumn',
);
}
}
Future<void> _seedDefaultsIfNeeded() async {

View File

@ -12,29 +12,20 @@ extension StorageServiceSessions on StorageService {
///
/// The step itself comes from [targetAfterSuccess] / [targetAfterFailure],
/// the same functions the workout screen previews with, so what the tile
/// promises is what finishing does.
/// promises is what finishing does. A training break is NOT handled here:
/// the gap deload already cut the target when the workout loaded
/// (`applyGapDeloads`), so finishing never cuts a second time. The old
/// break branch here could not fire anyway: the session is saved before
/// this runs, so "days since the last workout" was always 0.
Future<void> applyProgression({
required Map<String, bool> succeededExercises,
required DateTime lastWorkoutDate,
}) async {
final daysSince = DateTime.now().difference(lastWorkoutDate).inDays;
final hadBreak = daysSince > 7;
for (final entry in succeededExercises.entries) {
final state = await getExerciseState(entry.key);
if (state == null) continue;
final Map<String, Object> update;
if (hadBreak) {
// A week off is one regression step, in whatever mode is active.
final t = targetAfterFailure(state);
update = {
'weight': t.weight,
'reps': t.reps,
'success_streak': 0,
'fail_streak': 0,
};
} else if (entry.value) {
if (entry.value) {
final newStreak = state.successStreak + 1;
final step = newStreak >= state.successThreshold;
final t = step

View File

@ -31,8 +31,13 @@ class ExerciseTile extends StatelessWidget {
required this.onSettingsChanged,
required this.onDeload,
super.key,
this.deloadedFrom,
});
/// The target a gap deload cut this exercise from, until the next
/// session: shown struck through beside the new one, with a down arrow.
final ProgressionTarget? deloadedFrom;
/// The exercise definition to display (this session's targets).
final Exercise exercise;
@ -126,6 +131,14 @@ class ExerciseTile extends StatelessWidget {
onTap: () => showExerciseSettings(context),
),
const SizedBox(width: 8),
if (deloadedFrom case final from?
when from.weight != exercise.weight ||
from.reps != exercise.reps)
_DeloadedFrom(
from: from,
exercise: exercise,
color: onHeaderMuted,
),
Text(
'${exercise.sets}×${exercise.reps}×${exercise.weight}kg',
style: TextStyle(

View File

@ -234,3 +234,47 @@ class _PausedRow extends StatelessWidget {
);
}
}
/// The pre-deload target, struck through, and a small down arrow: what a
/// gap deload took off. Numerals only (textgate); only the part that
/// changed is shown, `25kg` or `×12`.
class _DeloadedFrom extends StatelessWidget {
const _DeloadedFrom({
required this.from,
required this.exercise,
required this.color,
});
final ProgressionTarget from;
final Exercise exercise;
final Color color;
@override
Widget build(BuildContext context) {
final parts = [
if (from.reps != exercise.reps) '×${from.reps}',
if (from.weight != exercise.weight) '${from.weight}kg',
];
return Row(
mainAxisSize: MainAxisSize.min,
children: [
Icon(
Icons.arrow_downward,
size: 14,
color: color,
semanticLabel: '${exercise.name} deloaded after a break',
),
const SizedBox(width: 2),
Text(
parts.join(' '),
style: TextStyle(
color: color,
fontSize: AppTextSize.label,
decoration: TextDecoration.lineThrough,
),
),
const SizedBox(width: 6),
],
);
}
}

View File

@ -0,0 +1,99 @@
import 'package:flutter_test/flutter_test.dart';
import 'package:workout_app/models/gap_deload.dart';
import 'package:workout_app/models/progression.dart';
import '../services/_deload_test_fixtures.dart';
DateTime _d(int day) => DateTime(2026, 11, day, 18);
void main() {
group('gapCalendarDays', () {
test('counts calendar days, not 24 h blocks', () {
expect(gapCalendarDays(DateTime(2026, 11, 1, 23), DateTime(2026, 11, 8, 1)), 7);
expect(gapCalendarDays(_d(8), _d(8)), 0);
});
});
group('gapDeloadSteps', () {
test('tiers: <7 none, 7-13 one, 14-20 two, +1 per week', () {
expect(gapDeloadSteps(0), 0);
expect(gapDeloadSteps(6), 0);
expect(gapDeloadSteps(7), 1);
expect(gapDeloadSteps(13), 1);
expect(gapDeloadSteps(14), 2);
expect(gapDeloadSteps(20), 2);
expect(gapDeloadSteps(21), 3);
expect(gapDeloadSteps(60), 8);
});
});
group('gapDeloadTarget', () {
test('weight mode: one step per tier', () {
final t = gapDeloadTarget(deloadState(weight: 100), 2);
expect(t.weight, 95);
expect(t.reps, 5);
});
test('weight mode: stops at a hard 40% loss', () {
// 10 kg: 7.5 is 25% off, 5 would be 50% -> stop at 7.5.
expect(gapDeloadTarget(deloadState(weight: 10), 8).weight, 7.5);
// 100 kg with 20 steps would be 50 kg; the floor is 60.
expect(gapDeloadTarget(deloadState(weight: 100), 20).weight, 60);
});
test('one step that alone exceeds the cap means no cut', () {
final t = gapDeloadTarget(deloadState(weight: 5), 1);
expect(t.weight, 5);
});
test('reps mode: same steps, same 40% cap on reps', () {
final s = deloadState(weight: 0, reps: 10, mode: ProgressionMode.reps);
expect(gapDeloadTarget(s, 2).reps, 8);
expect(gapDeloadTarget(s, 10).reps, 6);
});
test('double progression: reps first, weight capped at 40%', () {
final s = deloadState(
weight: 20,
reps: 8,
mode: ProgressionMode.doubleProgression,
);
final two = gapDeloadTarget(s, 2);
expect((two.weight, two.reps), (20.0, 6));
final three = gapDeloadTarget(s, 3);
expect((three.weight, three.reps), (17.5, 12));
expect(gapDeloadTarget(s, 99).weight, greaterThanOrEqualTo(12));
});
test('zero steps is the saved target', () {
final t = gapDeloadTarget(deloadState(weight: 50), 0);
expect((t.weight, t.reps), (50.0, 5));
});
});
group('missedGapSteps', () {
SessionMark m(int day, double w, {int reps = 5}) =>
SessionMark(endedAt: _d(day), weight: w, reps: reps);
test('a gap followed by an unchanged target is owed', () {
// 7-day gap (1 step), trained again at the same weight.
expect(missedGapSteps([m(1, 50), m(8, 50)]), 1);
});
test('debts add up while the target never moved', () {
expect(missedGapSteps([m(1, 50), m(8, 50), m(10, 50)]), 1);
expect(missedGapSteps([m(1, 50), m(8, 50), m(22, 50)]), 3);
});
test('any target change after the gap clears the debt', () {
expect(missedGapSteps([m(1, 50), m(8, 50), m(10, 52.5)]), 0);
expect(missedGapSteps([m(1, 50), m(8, 47.5)]), 0);
});
test('no history, one session or short gaps owe nothing', () {
expect(missedGapSteps([]), 0);
expect(missedGapSteps([m(1, 50)]), 0);
expect(missedGapSteps([m(1, 50), m(4, 50)]), 0);
});
});
}

View File

@ -0,0 +1,104 @@
import 'dart:convert';
import 'dart:io';
import 'package:flutter_test/flutter_test.dart';
import 'package:path/path.dart' as p;
import 'package:sqflite_common_ffi/sqflite_ffi.dart';
import 'package:workout_app/models/workout_plan.dart';
import 'package:workout_app/services/exercise_state_files.dart';
import 'package:workout_app/services/storage_service.dart';
void main() {
late Directory tmp;
setUpAll(() {
sqfliteFfiInit();
databaseFactory = databaseFactoryFfi;
});
setUp(() async {
StorageService.resetForTesting();
await StorageService.init();
tmp = Directory.systemTemp.createTempSync('esf_');
});
tearDown(() => tmp.deleteSync(recursive: true));
group('writeDeloadExport', () {
test('writes every dir it can', () async {
final a = Directory(p.join(tmp.path, 'a'));
final b = Directory(p.join(tmp.path, 'b'));
await ExerciseStateFiles(
exportDirs: () async => [a, b],
).writeDeloadExport('{"x":1}');
for (final d in [a, b]) {
expect(
File(p.join(d.path, kDeloadExportFileName)).readAsStringSync(),
'{"x":1}',
);
}
});
test('one unwritable dir is tolerated, none is fatal', () async {
final blocker = File(p.join(tmp.path, 'file'))..writeAsStringSync('');
final bad = Directory(p.join(blocker.path, 'sub'));
final good = Directory(p.join(tmp.path, 'good'));
await ExerciseStateFiles(
exportDirs: () async => [bad, good],
).writeDeloadExport('{}');
await expectLater(
ExerciseStateFiles(
exportDirs: () async => [bad],
).writeDeloadExport('{}'),
throwsA(isA<FileSystemException>()),
);
await expectLater(
ExerciseStateFiles(exportDirs: () async => []).writeDeloadExport('{}'),
throwsA(isA<FileSystemException>()),
);
});
});
group('importRestoreFile', () {
final lift = workoutA.first.name;
test('imports a pushed file once and keeps it renamed', () async {
final row = Map<String, Object?>.of(
(await StorageService.instance.exportData())['exercise_state']
.cast<Map<String, Object?>>()
.firstWhere((Map<String, Object?> r) => r['name'] == lift),
);
row['weight'] = 12.5;
row['updated_at'] = DateTime.now().millisecondsSinceEpoch + 1000;
File(p.join(tmp.path, kRestoreFileName)).writeAsStringSync(
jsonEncode({
'version': 3,
'exercise_state': [row],
}),
);
final files = ExerciseStateFiles(restoreDir: () async => tmp);
final r = await files.importRestoreFile();
expect(r.rows, 1);
expect((await StorageService.instance.getExerciseState(lift))!.weight, 12.5);
expect(File(p.join(tmp.path, kRestoreFileName)).existsSync(), isFalse);
expect((await files.importRestoreFile()).rows, 0);
});
test('a broken file is left in place', () async {
final f = File(p.join(tmp.path, kRestoreFileName))
..writeAsStringSync('not json');
final r = await ExerciseStateFiles(
restoreDir: () async => tmp,
).importRestoreFile();
expect(r.rows, 0);
expect(f.existsSync(), isTrue);
});
test('no dir on this platform', () async {
final r = await ExerciseStateFiles(
restoreDir: () async => null,
).importRestoreFile();
expect(r.rows, 0);
});
});
}

View File

@ -6,6 +6,7 @@ import 'dart:convert';
import 'package:crdt_sync/crdt_sync.dart';
import 'package:flutter_test/flutter_test.dart';
import 'package:sqflite_common_ffi/sqflite_ffi.dart';
import 'package:workout_app/models/manual_deload.dart';
import 'package:workout_app/services/progression_sync_service.dart';
import 'package:workout_app/services/storage_service.dart';
@ -110,4 +111,26 @@ void main() {
);
},
);
test('the shared deload stamp syncs and pulls back (C8)', () async {
final storage = StorageService.instance;
await storage.manualDeload('Situp', source: DeloadSource.settings);
final stamp = (await storage.getExerciseState('Situp'))!.lastDeloadedAt!;
await markSynced();
await sync.pushProgression();
expect(_payload(store, 'Situp')['last_deloaded_at'], stamp.toIso8601String());
StorageService.resetForTesting();
await StorageService.init();
await sync.pullProgression();
final pulled = (await storage.getExerciseState('Situp'))!;
expect(pulled.lastDeloadedAt, stamp);
});
test('a record without the stamp pulls as never deloaded', () async {
seedRemote(store, 'Situp', weight: 5, reps: 31, maxWeight: 10);
await sync.pullProgression();
final s = (await StorageService.instance.getExerciseState('Situp'))!;
expect(s.lastDeloadedAt, isNull);
});
}

View File

@ -32,11 +32,9 @@ void main() {
// Default success threshold is 3 — three straight successes trigger a
// progression, which at the cap increments reps instead of weight.
final today = DateTime.now();
for (var i = 0; i < 3; i++) {
await _svc.applyProgression(
succeededExercises: {name: true},
lastWorkoutDate: today,
);
}

View File

@ -0,0 +1,245 @@
import 'dart:convert';
import 'package:flutter_test/flutter_test.dart';
import 'package:sqflite_common_ffi/sqflite_ffi.dart';
import 'package:workout_app/models/gap_deload.dart';
import 'package:workout_app/models/manual_deload.dart';
import 'package:workout_app/models/progression.dart';
import 'package:workout_app/models/workout_plan.dart';
import 'package:workout_app/services/storage_service.dart';
StorageService get _svc => StorageService.instance;
final _now = DateTime(2026, 11, 20, 18);
/// Saves a finished session of [names] that ended [daysAgo] days before
/// [_now], at the given target.
Future<void> _session(
List<String> names, {
required int daysAgo,
double weight = 25,
int reps = 5,
bool succeeded = true,
}) async {
final end = _now.subtract(Duration(days: daysAgo));
final start = end.subtract(const Duration(hours: 1));
await _svc.saveSession(
date: start.toIso8601String().substring(0, 10),
workoutType: 'A',
durationSeconds: 3600,
succeeded: succeeded,
json: jsonEncode({
'date': start.toIso8601String().substring(0, 10),
'start_time': start.toIso8601String(),
'end_time': end.toIso8601String(),
'exercises': [
for (final n in names)
{
'name': n,
'targetWeight': weight,
'targetReps': reps,
'succeeded': succeeded,
},
],
}),
);
}
void main() {
setUpAll(() {
sqfliteFfiInit();
databaseFactory = databaseFactoryFfi;
});
setUp(() async {
StorageService.resetForTesting();
await StorageService.init();
});
final lift = workoutA.first.name;
Future<void> at(double w) => _svc.setExerciseWeight(lift, w);
group('applyGapDeloads', () {
test('8-day gap: one step down, streaks zeroed, stamped, logged', () async {
await at(25);
await _session([lift], daysAgo: 8);
final done = await _svc.applyGapDeloads(now: _now);
expect(done.map((d) => d.name), [lift]);
final s = (await _svc.getExerciseState(lift))!;
expect(s.weight, 22.5);
expect((s.successStreak, s.failStreak), (0, 0));
expect(s.lastDeloadedAt, _now);
final events = await _svc.getProgressionEvents(exercise: lift);
expect(events.single.kind, kGapDeloadKind);
expect((events.single.fromWeight, events.single.toWeight), (25.0, 22.5));
});
test('15-day gap: two steps', () async {
await at(25);
await _session([lift], daysAgo: 15);
await _svc.applyGapDeloads(now: _now);
expect((await _svc.getExerciseState(lift))!.weight, 20);
});
test('5-day gap: untouched', () async {
await at(25);
await _session([lift], daysAgo: 5);
expect(await _svc.applyGapDeloads(now: _now), isEmpty);
expect((await _svc.getExerciseState(lift))!.weight, 25);
});
test('never trained: no gap, no cut', () async {
expect(await _svc.applyGapDeloads(now: _now), isEmpty);
});
test('reopening never cuts twice', () async {
await at(25);
await _session([lift], daysAgo: 8);
await _svc.applyGapDeloads(now: _now);
final later = _now.add(const Duration(minutes: 5));
expect(await _svc.applyGapDeloads(now: later), isEmpty);
// Not even a week later with no session in between.
expect(
await _svc.applyGapDeloads(now: _now.add(const Duration(days: 7))),
isEmpty,
);
expect((await _svc.getExerciseState(lift))!.weight, 22.5);
});
test('a manual deload since the last session skips the auto cut', () async {
await at(25);
await _session([lift], daysAgo: 8);
final m = await _svc.manualDeload(lift, source: DeloadSource.settings);
expect(m.state!.lastDeloadedAt, isNotNull);
expect(await _svc.applyGapDeloads(now: _now), isEmpty);
expect((await _svc.getExerciseState(lift))!.weight, 22.5);
});
test('a session after a deload makes the next gap due again', () async {
await at(25);
await _session([lift], daysAgo: 30);
await _svc.applyGapDeloads(now: _now.subtract(const Duration(days: 20)));
await _session([lift], daysAgo: 9, weight: 20);
final done = await _svc.applyGapDeloads(now: _now);
expect(done, hasLength(1));
});
test('reps mode: two steps on reps', () async {
final s = (await _svc.getExerciseState(lift))!;
await _svc.setExerciseSettings(s.copyWith(mode: ProgressionMode.reps));
await _svc.setExerciseReps(lift, 10);
await _session([lift], daysAgo: 14);
await _svc.applyGapDeloads(now: _now);
expect((await _svc.getExerciseState(lift))!.reps, 8);
});
test('activeGapDeloads: shown until the next session', () async {
await at(25);
await _session([lift], daysAgo: 8);
await _svc.applyGapDeloads(now: _now);
final shown = await _svc.activeGapDeloads();
expect(shown[lift]!.fromWeight, 25);
await _session([lift], daysAgo: 0, weight: 22.5);
expect(await _svc.activeGapDeloads(), isEmpty);
});
});
group('runGapDeloadBackfill', () {
test('exports before cutting, cuts stale lifts, never twice', () async {
final fresh = workoutA[1].name;
await at(25);
await _svc.setExerciseWeight(fresh, 40);
// kuhy's case: 7-day break, failed at the same weight, then 15 days.
await _session([lift], daysAgo: 30);
await _session([lift], daysAgo: 22, succeeded: false);
await _session([lift], daysAgo: 16, succeeded: false);
await _session([fresh], daysAgo: 2, weight: 40);
final exports = <String>[];
final r = await _svc.runGapDeloadBackfill(
now: _now,
writeExport: (json) async {
// The export must hold the PRE-cut weights.
final rows = (jsonDecode(json) as Map)['exercise_state'] as List;
expect(
rows.firstWhere((r) => r['name'] == lift)['weight'],
25,
);
exports.add(json);
},
);
expect(r.ran, isTrue);
expect(exports, hasLength(1));
// Gap now: 16 days = 2 steps; owed from the 8-day gap = 1 step.
expect((await _svc.getExerciseState(lift))!.weight, 17.5);
expect((await _svc.getExerciseState(fresh))!.weight, 40);
final ev = await _svc.getProgressionEvents(exercise: lift);
expect(ev.single.kind, kBackfillDeloadKind);
final again = await _svc.runGapDeloadBackfill(
now: _now,
writeExport: (json) async => exports.add(json),
);
expect(again.ran, isFalse);
expect(exports, hasLength(1));
expect((await _svc.getExerciseState(lift))!.weight, 17.5);
});
test('a failed export cuts nothing and leaves the stamp unset', () async {
await at(25);
await _session([lift], daysAgo: 15);
final r = await _svc.runGapDeloadBackfill(
now: _now,
writeExport: (_) async => throw const FileSystemExceptionLike(),
);
expect(r.ran, isFalse);
expect((await _svc.getExerciseState(lift))!.weight, 25);
final retry = await _svc.runGapDeloadBackfill(
now: _now,
writeExport: (_) async {},
);
expect(retry.ran, isTrue);
});
test('never raises a weight', () async {
await at(5);
await _session([lift], daysAgo: 40, weight: 5);
await _svc.runGapDeloadBackfill(now: _now, writeExport: (_) async {});
expect((await _svc.getExerciseState(lift))!.weight, 5);
});
});
group('sandbox seed', () {
test('seeds every gap case for the next workout load', () async {
await _svc.seedGapScenarios(_now);
expect(await _svc.getNextWorkoutType(), 'A');
final done = {
for (final d in await _svc.applyGapDeloads(now: _now)) d.name: d.to,
};
expect(done['Dumbbell Lunge']!.weight, 17.5);
expect(done['Dumbbell Bench Press']!.weight, 17.5);
expect(done.containsKey('Dumbbell Row'), isFalse);
expect(done['Dumbbell Curl']!.weight, 7.5);
expect(done['Dumbbell Romanian Deadlift']!.reps, 8);
expect(done['Dumbbell Overhead Press']!.reps, 6);
});
});
group('finish no longer deloads', () {
test('a session after a long break progresses normally', () async {
await at(22.5);
await _session([lift], daysAgo: 0, weight: 22.5);
await _svc.applyProgression(succeededExercises: {lift: true});
expect((await _svc.getExerciseState(lift))!.weight, 22.5);
expect((await _svc.getExerciseState(lift))!.successStreak, 1);
});
});
}
/// A stand-in I/O failure for the export writer.
class FileSystemExceptionLike implements Exception {
/// Creates one.
const FileSystemExceptionLike();
}

View File

@ -34,7 +34,6 @@ void main() {
final before = await _svc.getExerciseState(name);
await _svc.applyProgression(
succeededExercises: {name: true},
lastWorkoutDate: DateTime.now().subtract(const Duration(days: 1)),
);
final after = await _svc.getExerciseState(name);
expect(after!.successStreak, (before!.successStreak + 1));
@ -50,7 +49,6 @@ void main() {
final before = await _svc.getExerciseState(name);
await _svc.applyProgression(
succeededExercises: {name: true},
lastWorkoutDate: DateTime.now().subtract(const Duration(days: 1)),
);
final after = await _svc.getExerciseState(name);
// Weight should increase (if below maxWeight) or reps increase
@ -71,7 +69,6 @@ void main() {
final before = await _svc.getExerciseState(name);
await _svc.applyProgression(
succeededExercises: {name: false},
lastWorkoutDate: DateTime.now().subtract(const Duration(days: 1)),
);
final after = await _svc.getExerciseState(name);
expect(after!.failStreak, (before!.failStreak + 1));
@ -87,28 +84,14 @@ void main() {
final before = await _svc.getExerciseState(name);
await _svc.applyProgression(
succeededExercises: {name: false},
lastWorkoutDate: DateTime.now().subtract(const Duration(days: 1)),
);
final after = await _svc.getExerciseState(name);
expect(after!.weight, lessThanOrEqualTo(before!.weight));
});
test('reduces weight after long break (> 7 days)', () async {
final name = workoutA.first.name;
await _svc.setExerciseWeight(name, 20.0);
final before = await _svc.getExerciseState(name);
await _svc.applyProgression(
succeededExercises: {name: true},
lastWorkoutDate: DateTime.now().subtract(const Duration(days: 10)),
);
final after = await _svc.getExerciseState(name);
expect(after!.weight, lessThan(before!.weight));
});
test('skips unknown exercise gracefully', () async {
await _svc.applyProgression(
succeededExercises: {'Ghost Exercise': true},
lastWorkoutDate: DateTime.now().subtract(const Duration(days: 1)),
);
// No exception thrown — that's the test.
});

View File

@ -7,7 +7,6 @@ import 'package:workout_app/services/storage_service.dart';
StorageService get _svc => StorageService.instance;
final _yesterday = DateTime.now().subtract(const Duration(days: 1));
void main() {
setUpAll(() {
@ -71,7 +70,6 @@ void main() {
ProgressionMode mode, {
required bool success,
required int reps,
DateTime? last,
}) async {
final name = workoutA.first.name;
final s = (await _svc.getExerciseState(name))!;
@ -82,7 +80,6 @@ void main() {
await _svc.setExerciseWeight(name, 10);
await _svc.applyProgression(
succeededExercises: {name: success},
lastWorkoutDate: last ?? _yesterday,
);
return (await _svc.getExerciseState(name))!;
}
@ -114,15 +111,5 @@ void main() {
);
expect((s.weight, s.reps), (7.5, 12));
});
test('a week off is one regression step in the active mode', () async {
final s = await run(
ProgressionMode.reps,
success: true,
reps: 10,
last: DateTime.now().subtract(const Duration(days: 9)),
);
expect((s.weight, s.reps, s.successStreak, s.failStreak), (10, 9, 0, 0));
});
});
}

View File

@ -162,7 +162,6 @@ void main() {
() => expectStamped(
() => _svc.applyProgression(
succeededExercises: {name: true},
lastWorkoutDate: DateTime.now(),
),
),
);

View File

@ -0,0 +1,55 @@
import 'package:flutter_test/flutter_test.dart';
import 'package:material_ui/material_ui.dart';
import 'package:workout_app/models/exercise.dart';
import 'package:workout_app/models/exercise_state.dart';
import 'package:workout_app/models/progression.dart';
import 'package:workout_app/ui/theme.dart';
import 'package:workout_app/widgets/exercise_tile.dart';
const _exercise = Exercise(name: 'Squat', sets: 3, reps: 5, weight: 17.5);
Widget _tile(ProgressionTarget? from) => MaterialApp(
theme: buildAppTheme(),
home: Scaffold(
body: ExerciseTile(
exercise: _exercise,
state: ExerciseState.initial(_exercise),
tapped: const [false, false, false],
doneReps: const [5, 5, 5],
warmupTapped: false,
onTapCircle: (_) {},
onLongPressCircle: (_) {},
onTapWarmup: () {},
onSettingsChanged: (_) {},
onDeload: () async => null,
deloadedFrom: from,
),
),
);
TextDecoration? _decoration(WidgetTester tester, String text) =>
tester.widget<Text>(find.text(text)).style?.decoration;
void main() {
testWidgets('a gap deload shows the old weight struck through + arrow', (
tester,
) async {
await tester.pumpWidget(_tile(const ProgressionTarget(20, 5)));
expect(find.byIcon(Icons.arrow_downward), findsOneWidget);
expect(_decoration(tester, '20.0kg'), TextDecoration.lineThrough);
expect(find.textContaining('3×5×17.5kg'), findsOneWidget);
expect(find.bySemanticsLabel('Squat deloaded after a break'), findsOne);
});
testWidgets('a reps-only cut strikes the old reps', (tester) async {
await tester.pumpWidget(_tile(const ProgressionTarget(17.5, 7)));
expect(_decoration(tester, '×7'), TextDecoration.lineThrough);
});
testWidgets('no deload, or one already undone: no arrow', (tester) async {
await tester.pumpWidget(_tile(null));
expect(find.byIcon(Icons.arrow_downward), findsNothing);
await tester.pumpWidget(_tile(const ProgressionTarget(17.5, 5)));
expect(find.byIcon(Icons.arrow_downward), findsNothing);
});
}