Improve parser runtime config and check-in state

.env.example

@@ -0,0 +1,20 @@
+# Local development defaults.
+HISTORY_STORE=local_json
+LOCAL_HISTORY_PATH=data/completed_sessions.json
+
+PARSER_BACKEND=ollama
+OLLAMA_MODEL=qwen3:8b
+
+# Hugging Face Space parser runtime.
+# PARSER_BACKEND=transformers
+# PARSER_MODEL_ID=Qwen/Qwen3-1.7B
+# PARSER_MAX_NEW_TOKENS=384
+# ZEROGPU_DURATION_SECONDS=120
+
+# Optional Hugging Face Dataset storage.
+# Keep real tokens in your local .env or Hugging Face Space secrets.
+# HISTORY_STORE=hf_dataset
+# HF_HISTORY_DATASET_REPO=your-username/training-coach-history
+# HF_HISTORY_FILE=completed_sessions.json
+# HF_HISTORY_PRIVATE=1
+# HF_TOKEN=hf_...

DECISIONS.md

@@ -87,9 +87,9 @@ with a one-line note on why.
   because it is much faster on the Mac than local Transformers CPU/disk-offload.
   `qwen3:4b` is the current local parser candidate for tiny/local badge fit.
 - **Space parser runtime:** Hugging Face Spaces use the Transformers parser backend,
-  configured with `PARSER_BACKEND=transformers` and `PARSER_MODEL_ID=Qwen/Qwen3-4B`.
-  Local development remains Ollama by default so the app still runs locally without a
-  cloud AI API.
+  configured with `PARSER_BACKEND=transformers`, `PARSER_MODEL_ID=Qwen/Qwen3-1.7B`,
+  and `PARSER_MAX_NEW_TOKENS=384`. Local development remains Ollama by default so the
+  app still runs locally without a cloud AI API.
 - **MVP training template:** use the supplied fixed 4-day exercise template for the
   first engine slice. Preserve exercise grouping, execution order, set counts, rep
   targets, and notes. For MVP simplicity, all exercise rests are normalized to 1 minute.

README.md

@@ -10,6 +10,8 @@ app_file: app.py
 pinned: false
 license: apache-2.0
 short_description: Small Models Big Adventures Hackaton - Weightlifting Trainer
+preload_from_hub:
+  - Qwen/Qwen3-1.7B
 ---
 
 # Strength Training Coach
@@ -107,6 +109,9 @@ cloud model inference or training logic.
 
 ## Parser Runtime Modes
 
+Copy `.env.example` to `.env` for local settings. `.env` is ignored by git and is
+loaded automatically by `app.py` before storage or parser backends are configured.
+
 Local development defaults to Ollama:
 
 ```txt
@@ -118,7 +123,8 @@ Hugging Face Spaces should use the Transformers runtime:
 
 ```txt
 PARSER_BACKEND=transformers
-PARSER_MODEL_ID=Qwen/Qwen3-4B
+PARSER_MODEL_ID=Qwen/Qwen3-1.7B
+PARSER_MAX_NEW_TOKENS=384
 ZEROGPU_DURATION_SECONDS=120
 ```
 

app.py

@@ -1,13 +1,22 @@
 from datetime import date
+import logging
+import os
 
 import gradio as gr
 
+from training_coach.env import load_local_env
 from training_coach.engine import build_session_for_day, suggest_next_training_day
 from training_coach.models import CheckIn, CompletedSession, CompletedSet, PainIssue
 from training_coach.parser_service import parse_check_in_with_configured_backend
 from training_coach.storage import create_history_store
 
 
+load_local_env()
+logging.basicConfig(
+    level=os.getenv("LOG_LEVEL", "INFO").upper(),
+    format="%(asctime)s level=%(levelname)s logger=%(name)s %(message)s",
+)
+logger = logging.getLogger(__name__)
 history_store = create_history_store()
 LOG_HEADERS = [
     "exercise_id",
@@ -76,18 +85,47 @@ def _format_parser_panel(parsed):
     return "\n\n".join(sections) or "No extra parser notes."
 
 
-def _parse_check_in_details(check_in):
+def _pain_issue_key(issue):
+    if issue.affected_muscle is not None:
+        return str(issue.affected_muscle)
+    return issue.notes.strip().lower()
+
+
+def _merge_pain_issues(previous_issues_state, parsed_issues):
+    merged = {}
+    for issue_data in previous_issues_state or []:
+        issue = PainIssue.model_validate(issue_data)
+        merged[_pain_issue_key(issue)] = issue
+    for issue in parsed_issues:
+        merged[_pain_issue_key(issue)] = issue
+    return list(merged.values())
+
+
+def _parse_check_in_details(check_in, previous_pain_issues_state=None):
     if not check_in.strip():
+        logger.info("event=parse_skipped reason=empty_check_in")
         default_result = _default_parse_result("Write a check-in first.")
         return default_result, default_result[-1]
 
+    logger.info(
+        "event=parse_request text_chars=%s previous_pain_issues=%s",
+        len(check_in),
+        len(previous_pain_issues_state or []),
+    )
     try:
         parsed = parse_check_in_with_configured_backend(check_in)
     except Exception as error:
+        logger.exception("event=parse_failed error_type=%s", type(error).__name__)
         default_result = _default_parse_result(f"Parser failed: {error}")
         return default_result, default_result[-1]
 
     parsed_check_in = parsed.check_in
+    parsed_check_in.pain_issues = _merge_pain_issues(
+        previous_pain_issues_state,
+        parsed_check_in.pain_issues,
+    )
+    if parsed_check_in.pain_issues:
+        parsed_check_in.pain_or_injury = "yes"
     parse_result = (
         _first_or_default(parsed_check_in.time_available_minutes, 60),
         _first_or_default(parsed_check_in.energy_level, "medium"),
@@ -102,6 +140,14 @@ def _parse_check_in_details(check_in):
         ],
         _format_parser_panel(parsed),
     )
+    logger.info(
+        "event=parse_complete missing_fields=%s follow_up_questions=%s "
+        "pain_issues=%s context_signals=%s",
+        len(parsed.missing_fields),
+        len(parsed.follow_up_questions),
+        len(parsed_check_in.pain_issues),
+        len(parsed.context_signals),
+    )
     return parse_result, _format_follow_up_reply(parsed)
 
 
@@ -123,9 +169,12 @@ def _assistant_reply_from_summary(parser_summary):
     return parser_summary
 
 
-def send_check_in_message(message, chat_history, transcript):
+def send_check_in_message(message, chat_history, transcript, pain_issues_state=None):
     if not message.strip():
-        parsed_result, assistant_reply = _parse_check_in_details(transcript or "")
+        parsed_result, assistant_reply = _parse_check_in_details(
+            transcript or "",
+            pain_issues_state,
+        )
         return (
             "",
             chat_history or [],
@@ -134,7 +183,10 @@ def send_check_in_message(message, chat_history, transcript):
         )
 
     updated_transcript = _append_user_message(transcript or "", message)
-    parsed_result, assistant_reply = _parse_check_in_details(updated_transcript)
+    parsed_result, assistant_reply = _parse_check_in_details(
+        updated_transcript,
+        pain_issues_state,
+    )
     updated_chat_history = [
         *(chat_history or []),
         {"role": "user", "content": message.strip()},
@@ -153,6 +205,7 @@ def send_check_in_message(message, chat_history, transcript):
 
 
 def reset_check_in_conversation():
+    logger.info("event=check_in_reset")
     return (
         "",
         [],
@@ -196,6 +249,17 @@ def build_preview(
     mood,
     pain_issues_state=None,
 ):
+    logger.info(
+        "event=session_build_start time_minutes=%s energy=%s sleep=%s "
+        "sleep_hours_present=%s pain_or_injury=%s mood=%s pain_issues=%s",
+        time_minutes,
+        energy,
+        sleep,
+        sleep_hours is not None,
+        pain_or_injury,
+        mood,
+        len(pain_issues_state or []),
+    )
     structured_check_in = CheckIn(
         raw_text=check_in,
         time_available_minutes=time_minutes,
@@ -215,6 +279,18 @@ def build_preview(
         check_in=structured_check_in,
         completed_sessions=completed_sessions,
     )
+    exercise_count = len(session_plan.planned_exercises)
+    set_count = sum(
+        len(exercise.prescribed_sets)
+        for exercise in session_plan.planned_exercises
+    )
+    logger.info(
+        "event=session_build_complete day_number=%s history_sessions=%s exercises=%s sets=%s",
+        day_number,
+        len(completed_sessions),
+        exercise_count,
+        set_count,
+    )
 
     check_in_text = structured_check_in.raw_text.strip() or "No check-in text yet."
     soreness_text = structured_check_in.soreness.strip() or "None noted."
@@ -417,8 +493,15 @@ def _log_inputs_to_completed_sets(log_rows, reps_values, load_values, rpe_values
 
 def save_completed_session(day_number, log_rows, *log_input_values):
     if day_number is None:
+        logger.info("event=session_save_skipped reason=missing_day")
         return "Build today's session before saving."
 
+    logger.info(
+        "event=session_save_start day_number=%s log_rows=%s ui_input_values=%s",
+        day_number,
+        len(log_rows or []),
+        len(log_input_values),
+    )
     try:
         if log_input_values:
             reps_values = log_input_values[:MAX_LOG_ROWS]
@@ -435,6 +518,7 @@ def save_completed_session(day_number, log_rows, *log_input_values):
         else:
             completed_sets = _log_rows_to_completed_sets(log_rows)
         if not completed_sets:
+            logger.info("event=session_save_skipped reason=no_completed_sets")
             return "Add at least one completed set with reps and load before saving."
 
         completed_session = CompletedSession(
@@ -444,8 +528,14 @@ def save_completed_session(day_number, log_rows, *log_input_values):
         )
         history_store.append_completed_session(completed_session)
     except Exception as error:
+        logger.exception("event=session_save_failed error_type=%s", type(error).__name__)
         return f"Could not save completed session: {error}"
 
+    logger.info(
+        "event=session_save_complete day_number=%s completed_sets=%s",
+        day_number,
+        len(completed_sets),
+    )
     return (
         f"Saved Day {day_number} with {len(completed_sets)} completed sets. "
         "The next build will suggest the following training day."
@@ -539,7 +629,7 @@ with gr.Blocks(title="Strength Training Coach") as demo:
 
         parse_button.click(
             fn=send_check_in_message,
-            inputs=[check_in, check_in_chat, check_in_state],
+            inputs=[check_in, check_in_chat, check_in_state, pain_issues_state],
             outputs=[
                 check_in,
                 check_in_chat,
@@ -557,7 +647,7 @@ with gr.Blocks(title="Strength Training Coach") as demo:
         )
         check_in.submit(
             fn=send_check_in_message,
-            inputs=[check_in, check_in_chat, check_in_state],
+            inputs=[check_in, check_in_chat, check_in_state, pain_issues_state],
             outputs=[
                 check_in,
                 check_in_chat,
@@ -632,4 +722,5 @@ with gr.Blocks(title="Strength Training Coach") as demo:
 
 
 if __name__ == "__main__":
+    logger.info("event=app_start")
     demo.launch()

tests/test_app.py

@@ -116,6 +116,44 @@ class AppTest(unittest.TestCase):
         self.assertNotIn("How many minutes", result[-1])
         self.assertEqual(result[-1], "No extra parser notes.")
 
+    def test_send_check_in_message_preserves_previous_pain_issues(self):
+        previous_pain_issues = [
+            PainIssue(
+                affected_muscle="biceps_brachii",
+                severity="mild",
+                notes="Bicep is hurting.",
+            ).model_dump(mode="json")
+        ]
+        parsed = ParsedCheckIn(
+            check_in=CheckIn(
+                raw_text="bicep hurts\nand my left leg also\nhamstring, mild but sharp",
+                pain_or_injury="yes",
+                pain_issues=[
+                    PainIssue(
+                        affected_muscle="hamstrings",
+                        severity="mild",
+                        notes="Left hamstring pain, mild but sharp.",
+                    )
+                ],
+            )
+        )
+
+        with patch("app.parse_check_in_with_configured_backend", return_value=parsed):
+            result = send_check_in_message(
+                "hamstring, mild but sharp",
+                [],
+                "bicep hurts\nand my left leg also",
+                previous_pain_issues,
+            )
+
+        pain_issues = result[10]
+        self.assertEqual(
+            [issue["affected_muscle"] for issue in pain_issues],
+            ["biceps_brachii", "hamstrings"],
+        )
+        self.assertIn("biceps_brachii", result[-1])
+        self.assertIn("hamstrings", result[-1])
+
     def test_parse_check_in_omits_unsure_pain_severity_from_panel(self):
         parsed = ParsedCheckIn(
             check_in=CheckIn(

tests/test_env.py

@@ -0,0 +1,34 @@
+import os
+import tempfile
+import unittest
+from pathlib import Path
+from unittest.mock import patch
+
+from training_coach.env import load_local_env
+
+
+class EnvTests(unittest.TestCase):
+    def test_load_local_env_sets_missing_values_without_overriding_existing(self):
+        with tempfile.TemporaryDirectory() as temp_dir:
+            env_path = Path(temp_dir) / ".env"
+            env_path.write_text(
+                "\n".join(
+                    [
+                        "# comment",
+                        "PARSER_BACKEND=transformers",
+                        "OLLAMA_MODEL='qwen3:8b'",
+                        "EXISTING=value-from-file",
+                    ]
+                )
+            )
+
+            with patch.dict(os.environ, {"EXISTING": "value-from-env"}, clear=True):
+                load_local_env(env_path)
+
+                self.assertEqual(os.environ["PARSER_BACKEND"], "transformers")
+                self.assertEqual(os.environ["OLLAMA_MODEL"], "qwen3:8b")
+                self.assertEqual(os.environ["EXISTING"], "value-from-env")
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/test_parser_runtime.py

@@ -1,23 +1,74 @@
 import unittest
+from unittest.mock import patch
 
 from training_coach.parser_runtime import (
     DEFAULT_TRANSFORMERS_MODEL,
     PARSER_MODEL,
-    MODEL_CACHE_DIR,
+    MODEL_CACHE_ENV_VAR,
     ParserRuntimeUnavailableError,
     _load_transformers,
     generate_parser_response,
+    load_parser_model,
     parse_check_in_with_model,
 )
 
 
 class ParserRuntimeTest(unittest.TestCase):
+    def tearDown(self):
+        load_parser_model.cache_clear()
+
     def test_runtime_exports_model_name(self):
         self.assertEqual(PARSER_MODEL, "Qwen/Qwen2.5-1.5B-Instruct")
-        self.assertEqual(DEFAULT_TRANSFORMERS_MODEL, "Qwen/Qwen3-4B")
+        self.assertEqual(DEFAULT_TRANSFORMERS_MODEL, "Qwen/Qwen3-1.7B")
+
+    def test_runtime_uses_default_huggingface_cache_by_default(self):
+        self.assertEqual(MODEL_CACHE_ENV_VAR, "PARSER_MODEL_CACHE_DIR")
+
+    def test_load_parser_model_uses_default_hf_cache_without_override(self):
+        class FakeTokenizer:
+            @classmethod
+            def from_pretrained(cls, model_name, cache_dir=None):
+                return {"model_name": model_name, "cache_dir": cache_dir}
+
+        class FakeModel:
+            @classmethod
+            def from_pretrained(cls, model_name, **kwargs):
+                return {"model_name": model_name, **kwargs}
+
+        load_parser_model.cache_clear()
+        with patch.dict("os.environ", {}, clear=True), patch(
+            "training_coach.parser_runtime._load_transformers",
+            return_value=(FakeModel, FakeTokenizer),
+        ):
+            tokenizer, model = load_parser_model("test/model")
+
+        self.assertIsNone(tokenizer["cache_dir"])
+        self.assertIsNone(model["cache_dir"])
+
+    def test_load_parser_model_allows_explicit_cache_override(self):
+        class FakeTokenizer:
+            @classmethod
+            def from_pretrained(cls, model_name, cache_dir=None):
+                return {"model_name": model_name, "cache_dir": cache_dir}
+
+        class FakeModel:
+            @classmethod
+            def from_pretrained(cls, model_name, **kwargs):
+                return {"model_name": model_name, **kwargs}
+
+        load_parser_model.cache_clear()
+        with patch.dict(
+            "os.environ",
+            {MODEL_CACHE_ENV_VAR: "/tmp/parser-cache"},
+            clear=True,
+        ), patch(
+            "training_coach.parser_runtime._load_transformers",
+            return_value=(FakeModel, FakeTokenizer),
+        ):
+            tokenizer, model = load_parser_model("test/model")
 
-    def test_runtime_uses_project_local_model_cache(self):
-        self.assertEqual(str(MODEL_CACHE_DIR), ".cache/huggingface")
+        self.assertEqual(tokenizer["cache_dir"], "/tmp/parser-cache")
+        self.assertEqual(model["cache_dir"], "/tmp/parser-cache")
 
     def test_runtime_can_import_transformers_or_reports_clear_error(self):
         try:

training_coach/engine.py

@@ -1,4 +1,5 @@
 from datetime import date
+import logging
 from math import ceil
 import re
 from collections.abc import Sequence
@@ -17,6 +18,7 @@ from training_coach.models import (
 MVP_LOAD_INCREMENT_KG = 1.0
 MVP_BASE_TARGET_RIR = 2
 MVP_REP_STEP = 2
+logger = logging.getLogger(__name__)
 
 INJURY_KEYWORDS = (
     "ache",
@@ -309,6 +311,15 @@ def build_session_for_day(
     if day_number not in MVP_4_DAY_TEMPLATE:
         raise ValueError("day_number must be between 1 and 4")
 
+    logger.info(
+        "event=engine_build_start day_number=%s history_sessions=%s "
+        "time_minutes=%s pain_or_injury=%s pain_issues=%s",
+        day_number,
+        len(completed_sessions or []),
+        check_in.time_available_minutes,
+        check_in.pain_or_injury,
+        len(check_in.pain_issues),
+    )
     planned_exercises = []
     for order, item in enumerate(MVP_4_DAY_TEMPLATE[day_number], start=1):
         reps_low, reps_high, target_reps = _template_reps(item)
@@ -322,16 +333,39 @@ def build_session_for_day(
             )
         )
 
+    template_set_count = sum(
+        len(exercise.prescribed_sets)
+        for exercise in planned_exercises
+    )
+    logger.info(
+        "event=engine_template_loaded day_number=%s exercises=%s sets=%s",
+        day_number,
+        len(planned_exercises),
+        template_set_count,
+    )
+
     if completed_sessions:
         planned_exercises = [
             apply_double_progression(exercise, completed_sessions)
             for exercise in planned_exercises
         ]
+        logger.info(
+            "event=engine_progression_applied day_number=%s exercises=%s",
+            day_number,
+            len(planned_exercises),
+        )
 
+    before_pain_count = len(planned_exercises)
     planned_exercises, pain_filter_notes = apply_pain_filter(
         planned_exercises,
         check_in,
     )
+    if pain_filter_notes:
+        logger.info(
+            "event=engine_pain_filter_applied before_exercises=%s after_exercises=%s",
+            before_pain_count,
+            len(planned_exercises),
+        )
 
     session_notes = [
         f"MVP fixed day {day_number} template.",
@@ -340,19 +374,58 @@ def build_session_for_day(
     if pain_filter_notes:
         session_notes.extend(pain_filter_notes)
 
+    before_time_sets = sum(
+        len(exercise.prescribed_sets)
+        for exercise in planned_exercises
+    )
     planned_exercises, time_compression_notes = apply_time_compression(
         planned_exercises,
         check_in,
     )
     if time_compression_notes:
         session_notes.extend(time_compression_notes)
+        after_time_sets = sum(
+            len(exercise.prescribed_sets)
+            for exercise in planned_exercises
+        )
+        logger.info(
+            "event=engine_time_compression_applied before_sets=%s after_sets=%s time_minutes=%s",
+            before_time_sets,
+            after_time_sets,
+            check_in.time_available_minutes,
+        )
 
+    before_readiness_sets = sum(
+        len(exercise.prescribed_sets)
+        for exercise in planned_exercises
+    )
     planned_exercises, readiness_notes = apply_readiness_modifier(
         planned_exercises,
         check_in,
     )
     if readiness_notes:
         session_notes.extend(readiness_notes)
+        after_readiness_sets = sum(
+            len(exercise.prescribed_sets)
+            for exercise in planned_exercises
+        )
+        logger.info(
+            "event=engine_readiness_applied before_sets=%s after_sets=%s",
+            before_readiness_sets,
+            after_readiness_sets,
+        )
+
+    final_set_count = sum(
+        len(exercise.prescribed_sets)
+        for exercise in planned_exercises
+    )
+    logger.info(
+        "event=engine_build_complete day_number=%s exercises=%s sets=%s notes=%s",
+        day_number,
+        len(planned_exercises),
+        final_set_count,
+        len(session_notes),
+    )
 
     return SessionPlan(
         date=session_date,

training_coach/env.py

@@ -0,0 +1,19 @@
+from pathlib import Path
+import os
+
+
+def load_local_env(path: str | Path = ".env") -> None:
+    env_path = Path(path)
+    if not env_path.exists():
+        return
+
+    for line in env_path.read_text().splitlines():
+        stripped = line.strip()
+        if not stripped or stripped.startswith("#") or "=" not in stripped:
+            continue
+
+        key, value = stripped.split("=", 1)
+        key = key.strip()
+        value = value.strip().strip('"').strip("'")
+        if key and key not in os.environ:
+            os.environ[key] = value

training_coach/parser_runtime.py

@@ -1,14 +1,17 @@
 from functools import lru_cache
+import logging
 import os
-from pathlib import Path
+from time import perf_counter
 
-from training_coach.parser import PARSER_FALLBACK_MODEL, PARSER_MODEL, build_parser_messages, parse_model_response
+from training_coach.parser import PARSER_MODEL, build_parser_messages, parse_model_response
 from training_coach.models import ParsedCheckIn
 
 
-MODEL_CACHE_DIR = Path(".cache/huggingface")
-DEFAULT_TRANSFORMERS_MODEL = PARSER_FALLBACK_MODEL
+MODEL_CACHE_ENV_VAR = "PARSER_MODEL_CACHE_DIR"
+DEFAULT_TRANSFORMERS_MODEL = "Qwen/Qwen3-1.7B"
+DEFAULT_MAX_NEW_TOKENS = 384
 DEFAULT_ZEROGPU_DURATION_SECONDS = 120
+logger = logging.getLogger(__name__)
 
 
 class ParserRuntimeUnavailableError(RuntimeError):
@@ -39,15 +42,23 @@ def _load_transformers():
 
 @lru_cache(maxsize=1)
 def load_parser_model(model_name: str = DEFAULT_TRANSFORMERS_MODEL):
+    start_time = perf_counter()
+    logger.info("event=parser_model_load_start model=%s", model_name)
     AutoModelForCausalLM, AutoTokenizer = _load_transformers()
-    MODEL_CACHE_DIR.mkdir(parents=True, exist_ok=True)
-    tokenizer = AutoTokenizer.from_pretrained(model_name, cache_dir=MODEL_CACHE_DIR)
+    cache_dir = os.getenv(MODEL_CACHE_ENV_VAR) or None
+    tokenizer = AutoTokenizer.from_pretrained(model_name, cache_dir=cache_dir)
     model = AutoModelForCausalLM.from_pretrained(
         model_name,
-        cache_dir=MODEL_CACHE_DIR,
+        cache_dir=cache_dir,
         device_map="auto",
         torch_dtype="auto",
     )
+    logger.info(
+        "event=parser_model_load_complete model=%s cache_dir_configured=%s elapsed_ms=%s",
+        model_name,
+        cache_dir is not None,
+        round((perf_counter() - start_time) * 1000),
+    )
     return tokenizer, model
 
 
@@ -56,22 +67,40 @@ def generate_parser_response(
     raw_text: str,
     model_name: str = DEFAULT_TRANSFORMERS_MODEL,
 ) -> str:
+    start_time = perf_counter()
+    logger.info(
+        "event=parser_generate_start model=%s text_chars=%s",
+        model_name,
+        len(raw_text),
+    )
     tokenizer, model = load_parser_model(model_name)
     messages = build_parser_messages(raw_text)
-    prompt = tokenizer.apply_chat_template(
-        messages,
-        tokenize=False,
-        add_generation_prompt=True,
-    )
+    chat_template_kwargs = {
+        "tokenize": False,
+        "add_generation_prompt": True,
+        "enable_thinking": False,
+    }
+    try:
+        prompt = tokenizer.apply_chat_template(messages, **chat_template_kwargs)
+    except TypeError:
+        chat_template_kwargs.pop("enable_thinking")
+        prompt = tokenizer.apply_chat_template(messages, **chat_template_kwargs)
     inputs = tokenizer([prompt], return_tensors="pt").to(model.device)
     output_ids = model.generate(
         **inputs,
-        max_new_tokens=800,
+        max_new_tokens=int(os.getenv("PARSER_MAX_NEW_TOKENS", str(DEFAULT_MAX_NEW_TOKENS))),
         do_sample=False,
         pad_token_id=tokenizer.eos_token_id,
     )
     generated_ids = output_ids[:, inputs.input_ids.shape[-1] :]
-    return tokenizer.batch_decode(generated_ids, skip_special_tokens=True)[0].strip()
+    response_text = tokenizer.batch_decode(generated_ids, skip_special_tokens=True)[0].strip()
+    logger.info(
+        "event=parser_generate_complete model=%s response_chars=%s elapsed_ms=%s",
+        model_name,
+        len(response_text),
+        round((perf_counter() - start_time) * 1000),
+    )
+    return response_text
 
 
 def parse_check_in_with_model(
@@ -79,5 +108,13 @@ def parse_check_in_with_model(
     model_name: str | None = None,
 ) -> ParsedCheckIn:
     model_name = model_name or os.getenv("PARSER_MODEL_ID", DEFAULT_TRANSFORMERS_MODEL)
+    logger.info("event=parser_model_parse_start model=%s", model_name)
     response_text = generate_parser_response(raw_text, model_name=model_name)
-    return parse_model_response(response_text)
+    parsed = parse_model_response(response_text)
+    logger.info(
+        "event=parser_model_parse_complete model=%s missing_fields=%s follow_up_questions=%s",
+        model_name,
+        len(parsed.missing_fields),
+        len(parsed.follow_up_questions),
+    )
+    return parsed

training_coach/parser_service.py

@@ -1,3 +1,4 @@
+import logging
 import os
 
 from training_coach.models import ParsedCheckIn
@@ -7,6 +8,7 @@ from training_coach.parser_runtime import parse_check_in_with_model
 
 DEFAULT_LOCAL_BACKEND = "ollama"
 DEFAULT_SPACE_BACKEND = "transformers"
+logger = logging.getLogger(__name__)
 
 
 def parser_backend() -> str:
@@ -20,13 +22,33 @@ def parser_backend() -> str:
 
 def parse_check_in_with_configured_backend(raw_text: str) -> ParsedCheckIn:
     backend = parser_backend()
+    logger.info(
+        "event=parser_start backend=%s text_chars=%s",
+        backend,
+        len(raw_text),
+    )
     if backend == "ollama":
-        return parse_check_in_with_ollama(
+        parsed = parse_check_in_with_ollama(
             raw_text,
             model_name=os.getenv("OLLAMA_MODEL", "qwen3:8b"),
         )
+        logger.info(
+            "event=parser_complete backend=%s missing_fields=%s follow_up_questions=%s",
+            backend,
+            len(parsed.missing_fields),
+            len(parsed.follow_up_questions),
+        )
+        return parsed
     if backend == "transformers":
-        return parse_check_in_with_model(raw_text)
+        parsed = parse_check_in_with_model(raw_text)
+        logger.info(
+            "event=parser_complete backend=%s missing_fields=%s follow_up_questions=%s",
+            backend,
+            len(parsed.missing_fields),
+            len(parsed.follow_up_questions),
+        )
+        return parsed
+    logger.error("event=parser_unsupported_backend backend=%s", backend)
     raise ValueError(
         "Unsupported PARSER_BACKEND. Use 'ollama' for local Ollama or "
         "'transformers' for Hugging Face Spaces."

training_coach/storage.py

@@ -1,4 +1,5 @@
 import json
+import logging
 import os
 from pathlib import Path
 from tempfile import TemporaryDirectory
@@ -9,6 +10,7 @@ from training_coach.models import CompletedSession
 
 DEFAULT_HISTORY_PATH = Path("data/completed_sessions.json")
 DEFAULT_HF_HISTORY_FILE = "completed_sessions.json"
+logger = logging.getLogger(__name__)
 
 
 class HistoryStore(Protocol):
@@ -50,23 +52,53 @@ class JsonHistoryStore:
 
     def load_completed_sessions(self) -> list[CompletedSession]:
         if not self.path.exists():
+            logger.info(
+                "event=history_load_complete backend=json path=%s sessions=0 missing_file=true",
+                self.path,
+            )
             return []
 
+        logger.info("event=history_load_start backend=json path=%s", self.path)
         data = json.loads(self.path.read_text(encoding="utf-8"))
-        return _sessions_from_payload(data)
+        sessions = _sessions_from_payload(data)
+        logger.info(
+            "event=history_load_complete backend=json path=%s sessions=%s",
+            self.path,
+            len(sessions),
+        )
+        return sessions
 
     def save_completed_sessions(self, sessions: list[CompletedSession]) -> None:
+        logger.info(
+            "event=history_save_start backend=json path=%s sessions=%s",
+            self.path,
+            len(sessions),
+        )
         self.path.parent.mkdir(parents=True, exist_ok=True)
         data = _history_payload(sessions)
         self.path.write_text(
             json.dumps(data, indent=2) + "\n",
             encoding="utf-8",
         )
+        logger.info(
+            "event=history_save_complete backend=json path=%s sessions=%s",
+            self.path,
+            len(sessions),
+        )
 
     def append_completed_session(self, session: CompletedSession) -> None:
+        logger.info(
+            "event=history_append_start backend=json day_number=%s sets=%s",
+            session.day_number,
+            len(session.completed_sets),
+        )
         sessions = self.load_completed_sessions()
         sessions.append(session)
         self.save_completed_sessions(sessions)
+        logger.info(
+            "event=history_append_complete backend=json sessions=%s",
+            len(sessions),
+        )
 
 
 class HuggingFaceDatasetHistoryStore:
@@ -120,17 +152,47 @@ class HuggingFaceDatasetHistoryStore:
         )
 
     def load_completed_sessions(self) -> list[CompletedSession]:
+        logger.info(
+            "event=history_load_start backend=hf_dataset repo_id=%s path_in_repo=%s",
+            self.repo_id,
+            self.path_in_repo,
+        )
         try:
             downloaded_path = self._download()
         except Exception as error:
             if _is_missing_hf_history_error(error):
+                logger.info(
+                    "event=history_load_complete backend=hf_dataset repo_id=%s "
+                    "path_in_repo=%s sessions=0 missing_file=true",
+                    self.repo_id,
+                    self.path_in_repo,
+                )
                 return []
+            logger.exception(
+                "event=history_load_failed backend=hf_dataset repo_id=%s error_type=%s",
+                self.repo_id,
+                type(error).__name__,
+            )
             raise
 
         data = json.loads(Path(downloaded_path).read_text(encoding="utf-8"))
-        return _sessions_from_payload(data)
+        sessions = _sessions_from_payload(data)
+        logger.info(
+            "event=history_load_complete backend=hf_dataset repo_id=%s "
+            "path_in_repo=%s sessions=%s",
+            self.repo_id,
+            self.path_in_repo,
+            len(sessions),
+        )
+        return sessions
 
     def save_completed_sessions(self, sessions: list[CompletedSession]) -> None:
+        logger.info(
+            "event=history_save_start backend=hf_dataset repo_id=%s path_in_repo=%s sessions=%s",
+            self.repo_id,
+            self.path_in_repo,
+            len(sessions),
+        )
         api = self._api()
         api.create_repo(
             repo_id=self.repo_id,
@@ -153,11 +215,29 @@ class HuggingFaceDatasetHistoryStore:
                 token=self.token,
                 commit_message="Update completed training sessions",
             )
+        logger.info(
+            "event=history_save_complete backend=hf_dataset repo_id=%s "
+            "path_in_repo=%s sessions=%s",
+            self.repo_id,
+            self.path_in_repo,
+            len(sessions),
+        )
 
     def append_completed_session(self, session: CompletedSession) -> None:
+        logger.info(
+            "event=history_append_start backend=hf_dataset repo_id=%s day_number=%s sets=%s",
+            self.repo_id,
+            session.day_number,
+            len(session.completed_sets),
+        )
         sessions = self.load_completed_sessions()
         sessions.append(session)
         self.save_completed_sessions(sessions)
+        logger.info(
+            "event=history_append_complete backend=hf_dataset repo_id=%s sessions=%s",
+            self.repo_id,
+            len(sessions),
+        )
 
 
 def create_history_store() -> HistoryStore:
@@ -165,13 +245,24 @@ def create_history_store() -> HistoryStore:
     repo_id = os.getenv("HF_HISTORY_DATASET_REPO", "").strip()
     if backend == "hf_dataset" or repo_id:
         if not repo_id:
+            logger.error(
+                "event=history_store_config_failed backend=hf_dataset "
+                "reason=missing_repo_id"
+            )
             raise RuntimeError(
                 "Set HF_HISTORY_DATASET_REPO when HISTORY_STORE=hf_dataset."
             )
+        logger.info(
+            "event=history_store_created backend=hf_dataset repo_id=%s path_in_repo=%s",
+            repo_id,
+            os.getenv("HF_HISTORY_FILE", DEFAULT_HF_HISTORY_FILE),
+        )
         return HuggingFaceDatasetHistoryStore(
             repo_id=repo_id,
             token=os.getenv("HF_TOKEN"),
             path_in_repo=os.getenv("HF_HISTORY_FILE", DEFAULT_HF_HISTORY_FILE),
             private=os.getenv("HF_HISTORY_PRIVATE", "1") not in {"0", "false", "False"},
         )
-    return JsonHistoryStore(os.getenv("LOCAL_HISTORY_PATH", DEFAULT_HISTORY_PATH))
+    path = os.getenv("LOCAL_HISTORY_PATH", DEFAULT_HISTORY_PATH)
+    logger.info("event=history_store_created backend=json path=%s", path)
+    return JsonHistoryStore(path)