diff --git a/.github/workflows/deploy-docs.yml b/.github/workflows/deploy-docs.yml
index a9fd57c1..db4d8ed5 100644
--- a/.github/workflows/deploy-docs.yml
+++ b/.github/workflows/deploy-docs.yml
@@ -55,7 +55,7 @@ jobs:
       run: cd frontend && npm ci
 
     - name: Build Storybook
-      run: cd frontend && npm run build-storybook -- --base=/ProgressRPG/storybook/
+      run: cd frontend && npm run build-storybook
 
     - name: Combine sites
       run: |
diff --git a/Makefile b/Makefile
index 47affdfb..28341cf8 100755
--- a/Makefile
+++ b/Makefile
@@ -26,6 +26,8 @@ ds:
 
 t:
 	docker compose exec web python manage.py test $(t) --keepdb --buffer
+tnk:
+	docker compose exec web python manage.py test $(t) --buffer
 
 vt:
 	cd ./frontend
diff --git a/api/tests.py b/api/tests.py
index 6a4d5fe8..8c0bac4a 100644
--- a/api/tests.py
+++ b/api/tests.py
@@ -32,7 +32,7 @@ def player_for(user) -> Player:
 
 class TestMeViewSet(APITestCase):
     def setUp(self):
-        self.character = Character.objects.create(given_name="Hero", can_link=True)
+        self.character = Character.objects.create(given_name="Hero")
         self.user = create_test_user(
             email="duncan@example.com",
             password="pass12345",
@@ -194,32 +194,78 @@ def test_complete_onboarding_sets_flag(self):
         self.assertTrue(player_for(self.user).onboarding_completed)
         self.assertEqual(res.data, {"onboarding_completed": True})
 
-    def test_today_points_null_when_no_active_link(self):
+    def test_daily_goals_null_when_no_active_link(self):
         self.authenticate()
         player = player_for(self.user)
         self.assertIsNone(player.active_link)
 
-        res = self.client.get(reverse("me-today-points"))
+        res = self.client.get(reverse("me-daily-goals"))
 
         self.assertEqual(res.status_code, status.HTTP_200_OK)
-        self.assertIsNone(res.data["points_today"])
+        self.assertIsNone(res.data["goals"])
 
-    def test_today_points_reflects_todays_completed_activities(self):
+    def test_daily_goals_all_false_when_linked_but_no_activity_or_login(self):
         self.authenticate()
         player = player_for(self.user)
         PlayerCharacterLink.objects.create(player=player, character=self.character)
 
+        res = self.client.get(reverse("me-daily-goals"))
+
+        self.assertEqual(res.status_code, status.HTTP_200_OK)
+        goals = res.data["goals"]
+        self.assertFalse(goals["logged_in_today"])
+        self.assertFalse(goals["completed_activity_today"])
+        self.assertEqual(goals["activity_minutes_today"], 0)
+        self.assertFalse(goals["minutes_goal_met"])
+        self.assertFalse(goals["all_goals_met"])
+        self.assertFalse(goals["bonus_awarded_today"])
+        self.assertEqual(goals["bonus_ap"], 0)
+
+    def test_daily_goals_reflects_todays_completed_activities(self):
+        self.authenticate()
+        player = player_for(self.user)
+        PlayerCharacterLink.objects.create(player=player, character=self.character)
+
+        PlayerActivity.objects.create(
+            player=player,
+            is_complete=True,
+            duration=1200,  # 20 minutes
+            completed_at=datetime.now(timezone.utc),
+        )
+
+        res = self.client.get(reverse("me-daily-goals"))
+
+        self.assertEqual(res.status_code, status.HTTP_200_OK)
+        goals = res.data["goals"]
+        self.assertTrue(goals["completed_activity_today"])
+        self.assertEqual(goals["activity_minutes_today"], 20)
+        self.assertTrue(goals["minutes_goal_met"])
+
+    def test_daily_goals_all_met_awards_bonus_once(self):
+        from users.models import UserLogin
+
+        self.authenticate()
+        player = player_for(self.user)
+        PlayerCharacterLink.objects.create(player=player, character=self.character)
+        UserLogin.objects.create(user=self.user)
+
         PlayerActivity.objects.create(
             player=player,
             is_complete=True,
-            duration=1200,  # 20 minutes -> 2 points
+            duration=1200,
             completed_at=datetime.now(timezone.utc),
         )
 
-        res = self.client.get(reverse("me-today-points"))
+        res = self.client.get(reverse("me-daily-goals"))
 
         self.assertEqual(res.status_code, status.HTTP_200_OK)
-        self.assertEqual(res.data["points_today"], 2)
+        goals = res.data["goals"]
+        self.assertTrue(goals["all_goals_met"])
+        # Reads never award the bonus themselves - only activity completion
+        # does (via check_and_award_daily_goals), so a plain GET here
+        # shouldn't have paid it out.
+        self.assertFalse(goals["bonus_awarded_today"])
+        self.assertEqual(goals["bonus_ap"], 0)
 
 
 class CustomTokenObtainPairViewTests(APITestCase):
diff --git a/api/views.py b/api/views.py
index 65505a45..4d67fa11 100644
--- a/api/views.py
+++ b/api/views.py
@@ -363,24 +363,61 @@ def character(self, request):
 
     @extend_schema(
         responses=inline_serializer(
-            name="TodayPointsResponse",
+            name="DailyGoalsResponse",
             fields={
-                "points_today": drf_serializers.IntegerField(allow_null=True),
+                "goals": inline_serializer(
+                    name="DailyGoalsStateResponse",
+                    fields={
+                        "logged_in_today": drf_serializers.BooleanField(),
+                        "completed_activity_today": drf_serializers.BooleanField(),
+                        "activity_minutes_today": drf_serializers.IntegerField(),
+                        "minutes_goal_threshold": drf_serializers.IntegerField(),
+                        "minutes_goal_met": drf_serializers.BooleanField(),
+                        "all_goals_met": drf_serializers.BooleanField(),
+                        "bonus_awarded_today": drf_serializers.BooleanField(),
+                        "bonus_ap": drf_serializers.IntegerField(),
+                    },
+                    allow_null=True,
+                ),
             },
         )
     )
     @action(detail=False, methods=["get"])
-    def today_points(self, request):
+    def daily_goals(self, request):
         """
-        Personal "points earned today" for the map view's badge (issue #673).
-        `points_today` is null - not zero - when the player has no active
+        Daily goals for the map view's badge (issue #751, replacing the old
+        `today_points`/`points_today` mechanic from issue #673). `goals` is
+        null - not a set of all-false goals - when the player has no active
         PlayerCharacterLink, so the frontend can tell "no link" apart from
-        "linked but nothing earned yet today" and hide the badge entirely.
+        "linked but no goals cleared yet today" and hide the badge entirely.
         """
+        from progression.daily_goals import (
+            MINUTES_GOAL_THRESHOLD,
+            get_daily_goals_state,
+        )
+
         player = request.user.player
         link = player.active_link
 
-        return Response({"points_today": link.points_today if link else None})
+        if not link:
+            return Response({"goals": None})
+
+        state = get_daily_goals_state(player)
+
+        return Response(
+            {
+                "goals": {
+                    "logged_in_today": state.logged_in_today,
+                    "completed_activity_today": state.completed_activity_today,
+                    "activity_minutes_today": state.activity_minutes_today,
+                    "minutes_goal_threshold": MINUTES_GOAL_THRESHOLD,
+                    "minutes_goal_met": state.minutes_goal_met,
+                    "all_goals_met": state.all_goals_met,
+                    "bonus_awarded_today": state.bonus_awarded_today,
+                    "bonus_ap": state.bonus_ap,
+                }
+            }
+        )
 
     @extend_schema(
         responses=inline_serializer(
diff --git a/character/admin.py b/character/admin.py
index d9c5a8bf..f8015d5b 100644
--- a/character/admin.py
+++ b/character/admin.py
@@ -60,6 +60,27 @@ def get_other_members(self, obj):
         return ", ".join(str(c) for c in others)
 
 
+class CanLinkListFilter(admin.SimpleListFilter):
+    """
+    can_link is a derived property, not a DB column, so it can't be listed
+    in list_filter directly - filter via Character.objects.linkable()
+    (the queryset-level equivalent) instead.
+    """
+
+    title = "can link"
+    parameter_name = "can_link"
+
+    def lookups(self, request, model_admin):
+        return (("yes", "Yes"), ("no", "No"))
+
+    def queryset(self, request, queryset):
+        if self.value() == "yes":
+            return queryset.filter(pk__in=Character.objects.linkable())
+        if self.value() == "no":
+            return queryset.exclude(pk__in=Character.objects.linkable())
+        return queryset
+
+
 @admin.action(description="Mark selected characters as NPCs and unlink from players")
 def mark_as_npc(modeladmin, request, queryset):
     for character in queryset:
@@ -73,17 +94,6 @@ def mark_as_npc(modeladmin, request, queryset):
     )
 
 
-@admin.action(description="Mark selected characters as available to link")
-def mark_as_canlink(modeladmin, request, queryset):
-    for character in queryset:
-        character.can_link = True
-        character.save(update_fields=["can_link"])
-
-    messages.success(
-        request, f"{queryset.count()} character(s) marked as available to link."
-    )
-
-
 @admin.register(Character)
 class CharacterAdmin(admin.ModelAdmin):
     fieldsets = (
@@ -93,6 +103,7 @@ class CharacterAdmin(admin.ModelAdmin):
                 "fields": (
                     "given_name",
                     "can_link",
+                    "is_reserved",
                     "sex",
                 )
             },
@@ -145,7 +156,8 @@ class CharacterAdmin(admin.ModelAdmin):
         "birth_date",
     ]
     list_filter = [
-        "can_link",
+        CanLinkListFilter,
+        "is_reserved",
         "birth_date",
         "death_date",
         "sex",
@@ -156,6 +168,7 @@ class CharacterAdmin(admin.ModelAdmin):
         "links__player__name",
     ]
     readonly_fields = [
+        "can_link",
         "get_player",
         "get_age",
         "created_at",
@@ -168,7 +181,7 @@ class CharacterAdmin(admin.ModelAdmin):
         CharacterRelationshipMembershipInline,
         CharacterCurrencyInline,
     ]
-    actions = [mark_as_npc, mark_as_canlink]
+    actions = [mark_as_npc]
 
     @admin.display(description="Player")
     def get_player(self, obj):
diff --git a/character/filters.py b/character/filters.py
index c8a3b864..59d7127f 100644
--- a/character/filters.py
+++ b/character/filters.py
@@ -7,7 +7,7 @@ class CharacterFilter(django_filters.FilterSet):
     level = django_filters.RangeFilter(field_name="level")
     xp = django_filters.RangeFilter(field_name="xp")
     is_npc = django_filters.BooleanFilter(method="filter_is_npc")
-    can_link = django_filters.BooleanFilter(field_name="can_link")
+    can_link = django_filters.BooleanFilter(method="filter_can_link")
 
     class Meta:
         model = Character
@@ -21,3 +21,15 @@ def filter_is_npc(self, queryset, name, value):
         else:
             # is_npc=False means HAS active player link
             return queryset.filter(links__is_active=True)
+
+    def filter_can_link(self, queryset, name, value):
+        """
+        can_link is derived, not a DB column - defer to
+        Character.objects.linkable(), the queryset-level equivalent of
+        Character.can_link, instead of duplicating its logic here.
+        """
+        linkable = Character.objects.linkable()
+        if value:
+            return queryset.filter(pk__in=linkable)
+        else:
+            return queryset.exclude(pk__in=linkable)
diff --git a/character/migrations/0021_remove_character_can_link_character_is_reserved.py b/character/migrations/0021_remove_character_can_link_character_is_reserved.py
new file mode 100644
index 00000000..c74dd925
--- /dev/null
+++ b/character/migrations/0021_remove_character_can_link_character_is_reserved.py
@@ -0,0 +1,26 @@
+# Generated by Django 5.2.17 on 2026-08-13 16:31
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ("character", "0020_remove_character_building"),
+    ]
+
+    operations = [
+        migrations.RemoveField(
+            model_name="character",
+            name="can_link",
+        ),
+        migrations.AddField(
+            model_name="character",
+            name="is_reserved",
+            field=models.BooleanField(
+                default=False,
+                help_text="Manually held back from linking (e.g. reserved for a future storyline), independent of age or link status.",
+                verbose_name="Reserved",
+            ),
+        ),
+    ]
diff --git a/character/models/character.py b/character/models/character.py
index fab8ffc6..c5ef0ad1 100644
--- a/character/models/character.py
+++ b/character/models/character.py
@@ -1,4 +1,5 @@
 # from datetime import datetime
+from datetime import timedelta
 from celery import current_app
 from decimal import Decimal
 from django.contrib.gis.geos import Point
@@ -309,6 +310,33 @@ def get_miscarriage_change(self):
 ########################################################################
 
 
+class CharacterQuerySet(models.QuerySet):
+    def linkable(self):
+        """
+        Characters currently eligible to be linked to a player - the
+        queryset-level equivalent of `Character.can_link`, for call sites
+        that need to filter/exist-check in SQL rather than load instances.
+        Keep this in sync with `Character.can_link` by hand; there's no
+        way to share the logic verbatim since one runs in the DB and the
+        other in Python.
+        """
+        cutoff_date = timezone.now().date() - timedelta(
+            days=Character.MIN_LINK_AGE_DAYS
+        )
+        return (
+            self.filter(is_reserved=False)
+            .filter(
+                models.Q(birth_date__isnull=True)
+                | models.Q(birth_date__lte=cutoff_date)
+            )
+            .exclude(links__is_active=True)
+        )
+
+
+class CharacterManager(models.Manager.from_queryset(CharacterQuerySet)):
+    pass
+
+
 class Character(LevelProgressionMixin, LifeCycleMixin, Movable):
     class SexChoices(models.TextChoices):
         MALE = "Male", "Male"
@@ -335,11 +363,21 @@ class SexChoices(models.TextChoices):
         max_length=20, choices=SexChoices.choices, null=True, blank=True
     )
     reputation = models.IntegerField(default=0)
-    can_link = models.BooleanField(default=False)
+    is_reserved = models.BooleanField(
+        default=False,
+        verbose_name="Reserved",
+        help_text="Manually held back from linking (e.g. reserved for a future storyline), independent of age or link status.",
+    )
     link_points_multiplier = models.DecimalField(
         max_digits=5, decimal_places=2, default="1.00"
     )
 
+    objects = CharacterManager()
+
+    # Minimum age (in days) for a character to be linkable. ~18 years,
+    # matching spawn-time character generation.
+    MIN_LINK_AGE_DAYS = int(18 * 365.25)
+
     @property
     def is_npc(self):
         """
@@ -347,6 +385,33 @@ def is_npc(self):
         """
         return not self.links.filter(is_active=True).exists()
 
+    @property
+    def is_underage(self):
+        # An unknown birth_date isn't evidence of being underage - it just
+        # means age isn't gating linkability for this character.
+        if self.birth_date is None:
+            return False
+        return self.get_age() < self.MIN_LINK_AGE_DAYS
+
+    @property
+    def can_link(self) -> bool:
+        """
+        Whether this character is currently eligible to be linked to a
+        player, derived from independent reasons - manual reservation,
+        age, active link, and (once population centres can gate linking -
+        see #681) population_centre.characters_can_link - rather than a
+        flag several call sites could clobber. Keep in sync by hand with
+        `CharacterQuerySet.linkable`, the SQL-level equivalent used where
+        a Python loop over instances isn't practical.
+        """
+        if self.is_reserved:
+            return False
+        if self.is_underage:
+            return False
+        if self.links.filter(is_active=True).exists():
+            return False
+        return True
+
     def __str__(self):
         return self.name
 
@@ -520,34 +585,6 @@ def link_points(self):
         )
         return int(base_points * multiplier)
 
-    @property
-    def player_time_today(self):
-        """
-        Completed activity time for this link so far today (in minutes) -
-        a date-filtered variant of player_time, bounded to the current UTC
-        day instead of the whole link lifetime.
-        """
-        start_of_day = timezone.now().replace(hour=0, minute=0, second=0, microsecond=0)
-        start = max(start_of_day, self.linked_at)
-
-        qs = self.player.activities.filter(is_complete=True, completed_at__gte=start)
-        if self.unlinked_at:
-            qs = qs.filter(completed_at__lte=self.unlinked_at)
-
-        total_seconds = qs.aggregate(total=Sum("duration"))["total"] or 0
-        return int(total_seconds // 60)
-
-    @property
-    def points_today(self):
-        """
-        Points earned today (issue #673's map-view "today" badge) - only the
-        activity-time component of link_points, date-filtered to today.
-        link_points' other terms (days_linked * 20, login_points) aren't
-        "earned today" in the same sense, so they're deliberately left out
-        here rather than prorated.
-        """
-        return self.player_time_today // 10
-
     @classmethod
     def get_character(cls, player: Player) -> Character:
         return link_services.player_link_get_character(cls, player)
diff --git a/character/services/character_services.py b/character/services/character_services.py
index c2cd135b..6711fb12 100644
--- a/character/services/character_services.py
+++ b/character/services/character_services.py
@@ -40,6 +40,4 @@ def character_assign_work(character, building) -> None:
 
 
 def character_has_available(model_cls) -> bool:
-    return (
-        model_cls.objects.filter(can_link=True).exclude(links__is_active=True).exists()
-    )
+    return model_cls.objects.linkable().exists()
diff --git a/character/services/link_services.py b/character/services/link_services.py
index f0ff0816..3af344ba 100644
--- a/character/services/link_services.py
+++ b/character/services/link_services.py
@@ -37,8 +37,6 @@ def player_link_unlink(link) -> None:
     link.unlinked_at = timezone.now()
     link.is_active = False
     link.save()
-    link.character.can_link = True
-    link.character.save(update_fields=["can_link"])
 
 
 def player_link_deactivate_active_links(model_cls, player) -> None:
@@ -59,6 +57,4 @@ def player_link_assign_character(model_cls, player, character):
         character=character,
         is_active=True,
     )
-    character.can_link = False
-    character.save(update_fields=["can_link"])
     return link
diff --git a/character/signals.py b/character/signals.py
index 020e38e2..ec499903 100644
--- a/character/signals.py
+++ b/character/signals.py
@@ -1,7 +1,6 @@
 # character.signals
 from datetime import timedelta, datetime, time
-from django.db import transaction
-from django.db.models.signals import pre_save, post_save, pre_delete, post_delete
+from django.db.models.signals import post_save, pre_delete, post_delete
 from django.dispatch import receiver
 from django.utils import timezone
 
@@ -41,59 +40,6 @@ def unlink_before_deletion(sender, instance, **kwargs):
     instance.unlink()
 
 
-def recompute_character_flags(character_id: int) -> None:
-    """
-    Recompute denormalised flags for a Character based on current links.
-    A character can_link if they have no active player links.
-    """
-    if not character_id:
-        return
-
-    # Character can link if they don't have any active player links
-    has_active_link = PlayerCharacterLink.objects.filter(
-        character_id=character_id, is_active=True
-    ).exists()
-
-    can_link = not has_active_link
-
-    Character.objects.filter(id=character_id).update(
-        can_link=can_link,
-    )
-
-
-@receiver(pre_save, sender=PlayerCharacterLink)
-def link_presave_track_old_character(sender, instance, **kwargs):
-    """
-    If someone edits a link and changes its character, we need to update BOTH:
-    the old character and the new character.
-    """
-    instance._old_character_id = None
-    if instance.pk:
-        try:
-            old = PlayerCharacterLink.objects.only("character_id").get(pk=instance.pk)
-            instance._old_character_id = old.character_id
-        except PlayerCharacterLink.DoesNotExist:
-            pass
-
-
-@receiver(post_save, sender=PlayerCharacterLink)
-def link_postsave_recompute(sender, instance, **kwargs):
-    def _do():
-        # update new/current character
-        recompute_character_flags(instance.character_id)
-        # update old character if link moved
-        old_id = getattr(instance, "_old_character_id", None)
-        if old_id and old_id != instance.character_id:
-            recompute_character_flags(old_id)
-
-    transaction.on_commit(_do)
-
-
-@receiver(post_delete, sender=PlayerCharacterLink)
-def link_postdelete_recompute(sender, instance, **kwargs):
-    transaction.on_commit(lambda: recompute_character_flags(instance.character_id))
-
-
 @receiver(post_delete, sender=CharacterRelationshipMembership)
 def delete_relationship_with_no_members(sender, instance, **kwargs):
     """
diff --git a/character/tests/test_filters.py b/character/tests/test_filters.py
index de73f859..c90af8e1 100644
--- a/character/tests/test_filters.py
+++ b/character/tests/test_filters.py
@@ -17,7 +17,6 @@ def setUp(self):
             given_name="NPC1",
             birth_date=date(2000, 1, 1),
             sex="Male",
-            can_link=True,
             level=5,
             xp=100,
         )
@@ -25,7 +24,6 @@ def setUp(self):
             given_name="NPC2",
             birth_date=date(2000, 1, 1),
             sex="Female",
-            can_link=True,
             level=10,
             xp=500,
         )
@@ -45,7 +43,6 @@ def setUp(self):
             given_name="Player1",
             birth_date=date(2000, 1, 1),
             sex="Male",
-            can_link=False,
             level=3,
             xp=75,
         )
@@ -66,7 +63,6 @@ def setUp(self):
             given_name="Player2",
             birth_date=date(2000, 1, 1),
             sex="Female",
-            can_link=False,
             level=7,
             xp=200,
         )
diff --git a/character/tests/test_models.py b/character/tests/test_models.py
index 45704cff..552717c4 100644
--- a/character/tests/test_models.py
+++ b/character/tests/test_models.py
@@ -413,13 +413,11 @@ def setUp(self):
             given_name="NPC1",
             birth_date=date(2000, 1, 1),
             sex="Male",
-            can_link=True,
         )
         self.npc2 = Character.objects.create(
             given_name="NPC2",
             birth_date=date(2000, 1, 1),
             sex="Female",
-            can_link=True,
         )
 
         # Create a player-linked character
@@ -440,14 +438,10 @@ def setUp(self):
             given_name="Player",
             birth_date=date(2000, 1, 1),
             sex="Male",
-            can_link=False,
         )
         PlayerCharacterLink.objects.create(
             player=self.player, character=self.player_character, is_active=True
         )
-        # Update can_link to match real behavior
-        self.player_character.can_link = False
-        self.player_character.save()
 
     def test_is_npc_property_for_npc(self):
         """Test that a character without an active player link is an NPC"""
@@ -483,8 +477,8 @@ def test_has_available_classmethod(self):
 
     def test_has_available_no_linkable_characters(self):
         """Test has_available returns False when no linkable characters exist"""
-        # Mark all NPCs as not linkable
-        Character.objects.filter(can_link=True).update(can_link=False)
+        # Mark all currently-linkable NPCs as reserved, so none remain linkable
+        Character.objects.linkable().update(is_reserved=True)
         self.assertFalse(Character.has_available())
 
     def test_has_available_all_linked(self):
@@ -506,65 +500,6 @@ def test_has_available_all_linked(self):
         self.assertFalse(Character.has_available())
 
 
-class PlayerCharacterLinkPointsTodayTests(TestCase):
-    """Tests for PlayerCharacterLink.player_time_today/points_today (issue #673)."""
-
-    def setUp(self):
-        from progression.models import PlayerActivity
-
-        self.PlayerActivity = PlayerActivity
-        self.user = user_factory(with_player=True)
-        self.player = self.user.player
-        character = Character.objects.create(given_name="Hero")
-        self.link = PlayerCharacterLink.objects.create(
-            player=self.player, character=character
-        )
-        # Backdated well before "today" so player_time_today's max(start_of_day,
-        # linked_at) resolves to start_of_day in these tests, rather than to
-        # whatever moment setUp happened to run at.
-        self.link.linked_at = now() - timedelta(days=30)
-        self.link.save(update_fields=["linked_at"])
-
-    def _complete_activity(self, *, duration_seconds, completed_at):
-        return self.PlayerActivity.objects.create(
-            player=self.player,
-            is_complete=True,
-            duration=duration_seconds,
-            completed_at=completed_at,
-        )
-
-    def test_points_today_counts_only_activities_completed_today(self):
-        today_start = now().replace(hour=0, minute=0, second=0, microsecond=0)
-        self._complete_activity(
-            duration_seconds=1800, completed_at=today_start + timedelta(hours=2)
-        )  # 30 min today
-        self._complete_activity(
-            duration_seconds=3600, completed_at=today_start - timedelta(hours=1)
-        )  # 60 min yesterday - excluded
-
-        self.assertEqual(self.link.player_time_today, 30)
-        self.assertEqual(self.link.points_today, 3)
-
-    def test_points_today_excludes_activity_before_link_started(self):
-        today_start = now().replace(hour=0, minute=0, second=0, microsecond=0)
-        self.link.linked_at = today_start + timedelta(hours=5)
-        self.link.save(update_fields=["linked_at"])
-
-        self._complete_activity(
-            duration_seconds=1800, completed_at=today_start + timedelta(hours=1)
-        )  # today, but before the link started - excluded
-        self._complete_activity(
-            duration_seconds=600, completed_at=today_start + timedelta(hours=6)
-        )  # 10 min, after linked_at
-
-        self.assertEqual(self.link.player_time_today, 10)
-        self.assertEqual(self.link.points_today, 1)
-
-    def test_points_today_zero_with_no_activities(self):
-        self.assertEqual(self.link.player_time_today, 0)
-        self.assertEqual(self.link.points_today, 0)
-
-
 class CharacterTotalLinkPointsTests(TestCase):
     """Tests for Character.total_link_points (the character-side counterpart
     to Player.total_link_points)."""
diff --git a/core/migrations/0016_gamesettings_daily_goals_completion_bonus_ap.py b/core/migrations/0016_gamesettings_daily_goals_completion_bonus_ap.py
new file mode 100644
index 00000000..b30f306a
--- /dev/null
+++ b/core/migrations/0016_gamesettings_daily_goals_completion_bonus_ap.py
@@ -0,0 +1,21 @@
+# Generated by Django 5.2.16 on 2026-08-10 00:00
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ("core", "0015_featureflag"),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name="gamesettings",
+            name="daily_goals_completion_bonus_ap",
+            field=models.IntegerField(
+                default=50,
+                help_text="Lump-sum AP awarded once per day when a player clears all three daily goals (see progression.daily_goals).",
+            ),
+        ),
+    ]
diff --git a/core/models.py b/core/models.py
index 07e9204c..da57cd33 100644
--- a/core/models.py
+++ b/core/models.py
@@ -90,6 +90,13 @@ class GameSettings(models.Model):
         max_digits=5, decimal_places=2, default="1.25"
     )
     task_completion_xp = models.IntegerField(default=100)
+    daily_goals_completion_bonus_ap = models.IntegerField(
+        default=50,
+        help_text=(
+            "Lump-sum AP awarded once per day when a player clears all "
+            "three daily goals (see progression.daily_goals)."
+        ),
+    )
     xp_mastery_scale = models.DecimalField(
         max_digits=10,
         decimal_places=2,
@@ -162,6 +169,8 @@ def clean(self):
             errors["task_activity_xp_multiplier"] = "Must be > 0."
         if self.task_completion_xp < 0:
             errors["task_completion_xp"] = "Must be non-negative."
+        if self.daily_goals_completion_bonus_ap < 0:
+            errors["daily_goals_completion_bonus_ap"] = "Must be non-negative."
         if self.xp_mastery_scale <= 0:
             errors["xp_mastery_scale"] = "Must be > 0."
         if self.xp_mastery_multiplier_cap < 1:
diff --git a/frontend/src/api/activities.ts b/frontend/src/api/activities.ts
index bbb97450..2d8a8019 100644
--- a/frontend/src/api/activities.ts
+++ b/frontend/src/api/activities.ts
@@ -1,7 +1,18 @@
 // src/api/activities.ts
 import type { PlayerActivity } from "../types";
+import type { OfflineActivityLogResponse } from "../types/api";
 import { apiFetch } from "../utils/api";
 
+export interface OfflineActivityLogPayload {
+  /** Name for a newly-created task; ignored (and optional) when `task` is set. */
+  name?: string;
+  description?: string;
+  skill?: number;
+  task?: number;
+  started_at: string;
+  completed_at: string;
+}
+
 export function fetchActivities(): Promise<PlayerActivity[]> {
   return (async () => {
     const allResults: PlayerActivity[] = [];
@@ -45,3 +56,12 @@ export function deleteActivity(id: number): Promise<void> {
     method: "DELETE",
   });
 }
+
+export function logOfflineActivity(
+  data: OfflineActivityLogPayload
+): Promise<OfflineActivityLogResponse> {
+  return apiFetch<OfflineActivityLogResponse>("/player-activities/log_offline/", {
+    method: "POST",
+    body: JSON.stringify(data),
+  });
+}
diff --git a/frontend/src/api/player.ts b/frontend/src/api/player.ts
index b4263b44..ba23d15b 100644
--- a/frontend/src/api/player.ts
+++ b/frontend/src/api/player.ts
@@ -41,13 +41,25 @@ export const deleteAccount = async (): Promise<unknown> => {
   return response;
 };
 
-export interface TodayPointsResponse {
-  // null (not 0) when the player has no active PlayerCharacterLink - see
-  // MeViewSet.today_points in api/views.py. Callers use this to hide the
-  // map view's "today" badge entirely rather than showing a zero (issue #673).
-  points_today: number | null;
+export interface DailyGoalsState {
+  logged_in_today: boolean;
+  completed_activity_today: boolean;
+  activity_minutes_today: number;
+  minutes_goal_threshold: number;
+  minutes_goal_met: boolean;
+  all_goals_met: boolean;
+  bonus_awarded_today: boolean;
+  bonus_ap: number;
 }
 
-export const fetchTodayPoints = async (): Promise<TodayPointsResponse> => {
-  return apiFetch<TodayPointsResponse>("/me/today_points/");
+export interface DailyGoalsResponse {
+  // null (not a set of all-false goals) when the player has no active
+  // PlayerCharacterLink - see MeViewSet.daily_goals in api/views.py.
+  // Callers use this to hide the map view's badge entirely rather than
+  // showing an unearned "0 of 3" (issue #673, redesigned in #751).
+  goals: DailyGoalsState | null;
+}
+
+export const fetchDailyGoals = async (): Promise<DailyGoalsResponse> => {
+  return apiFetch<DailyGoalsResponse>("/me/daily_goals/");
 };
diff --git a/frontend/src/components/ActivitiesPanel/ActivitiesPanel.module.scss b/frontend/src/components/ActivitiesPanel/ActivitiesPanel.module.scss
index a1f3229b..520b000d 100644
--- a/frontend/src/components/ActivitiesPanel/ActivitiesPanel.module.scss
+++ b/frontend/src/components/ActivitiesPanel/ActivitiesPanel.module.scss
@@ -14,13 +14,37 @@
   flex-direction: column;
 }
 
-.dateTabs {
+.toolbar {
   display: flex;
+  align-items: center;
   gap: sp.$spacing-sm;
   margin-bottom: sp.$spacing-md;
+  width: 100%;
+}
+
+.dateTabs {
+  display: flex;
+  gap: sp.$spacing-sm;
   flex-wrap: wrap;
   justify-content: center;
-  width: 100%;
+  flex: 1;
+}
+
+.addOfflineButton {
+  @include c.apply-button-variant(primary);
+  flex-shrink: 0;
+  border: none;
+  border-radius: 50%;
+  width: 2.25rem;
+  height: 2.25rem;
+  min-width: 2.25rem;
+  padding: 0;
+  font-size: 1.25rem;
+  line-height: 1;
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  cursor: pointer;
 }
 
 .dateButton {
diff --git a/frontend/src/components/ActivitiesPanel/ActivitiesPanel.test.tsx b/frontend/src/components/ActivitiesPanel/ActivitiesPanel.test.tsx
index 1eea100b..99bfd72f 100644
--- a/frontend/src/components/ActivitiesPanel/ActivitiesPanel.test.tsx
+++ b/frontend/src/components/ActivitiesPanel/ActivitiesPanel.test.tsx
@@ -2,8 +2,17 @@ import { render, screen, waitFor, within } from "@testing-library/react";
 import userEvent from "@testing-library/user-event";
 import { beforeEach, describe, expect, it, vi } from "vitest";
 
+import { TooltipProvider } from "../Tooltip/Tooltip";
 import ActivitiesPanel from "./ActivitiesPanel";
 
+function renderActivitiesPanel() {
+  return render(
+    <TooltipProvider>
+      <ActivitiesPanel />
+    </TooltipProvider>
+  );
+}
+
 const mockUseActivities = vi.fn();
 const mockUseDeleteActivity = vi.fn();
 const mockUseUpdateActivity = vi.fn();
@@ -39,7 +48,7 @@ describe("ActivitiesPanel", () => {
 
   it("renders activities and delegates edit through PlayerItemList", async () => {
     const user = userEvent.setup();
-    render(<ActivitiesPanel />);
+    renderActivitiesPanel();
 
     expect(screen.getByText("Write docs")).toBeInTheDocument();
 
@@ -47,19 +56,19 @@ describe("ActivitiesPanel", () => {
     const input = screen.getByLabelText("activity name");
     await user.clear(input);
     await user.type(input, "Write tests");
-    await user.click(screen.getByRole("button", { name: "Save" }));
+    await user.tab();
 
     await waitFor(() => {
-      expect(updateMutate).toHaveBeenCalledWith({
-        activityId: 1,
-        data: { name: "Write tests" },
-      });
+      expect(updateMutate).toHaveBeenCalledWith(
+        { activityId: 1, data: { name: "Write tests" } },
+        expect.objectContaining({ onSuccess: expect.any(Function), onError: expect.any(Function) }),
+      );
     });
   });
 
   it("delegates delete confirmation through PlayerItemList", async () => {
     const user = userEvent.setup();
-    render(<ActivitiesPanel />);
+    renderActivitiesPanel();
 
     await user.click(screen.getByRole("button", { name: "Open activity Write docs" }));
     await user.click(within(screen.getByRole("dialog")).getByRole("button", { name: "Delete" }));
diff --git a/frontend/src/components/ActivitiesPanel/ActivitiesPanel.tsx b/frontend/src/components/ActivitiesPanel/ActivitiesPanel.tsx
index 614ce3ec..72e3c820 100644
--- a/frontend/src/components/ActivitiesPanel/ActivitiesPanel.tsx
+++ b/frontend/src/components/ActivitiesPanel/ActivitiesPanel.tsx
@@ -6,6 +6,8 @@ import { formatDurationShort, pluralize } from "../../utils/formatUtils";
 
 import Button from "../Button/Button";
 import PlayerItemList from "../PlayerItemList/PlayerItemList";
+import Tooltip from "../Tooltip/Tooltip";
+import LogOfflineActivityModal from "../LogOfflineActivityModal/LogOfflineActivityModal";
 import styles from "./ActivitiesPanel.module.scss";
 
 type DateCategory = "today" | "yesterday" | "older";
@@ -68,6 +70,7 @@ export default function ActivitiesPanel(): React.ReactElement | null {
   const deleteActivity = useDeleteActivity();
   const updateActivity = useUpdateActivity();
   const [activeTab, setActiveTab] = useState<DateCategory>("today");
+  const [isLogModalOpen, setIsLogModalOpen] = useState(false);
 
   const bucketed = useMemo(() => bucketActivities(activities ?? []), [activities]);
 
@@ -103,11 +106,14 @@ export default function ActivitiesPanel(): React.ReactElement | null {
   const hasTabActivities = groupedByCategory[activeTab].length > 0;
 
   const handleEdit = useCallback(
-    (activity: PlayerActivity, name: string) => {
-      updateActivity.mutate({
-        activityId: activity.id,
-        data: { name },
-      });
+    (activity: PlayerActivity, name: string, callbacks?: { onSuccess?: () => void; onError?: () => void }) => {
+      updateActivity.mutate(
+        {
+          activityId: activity.id,
+          data: { name },
+        },
+        callbacks,
+      );
     },
     [updateActivity],
   );
@@ -124,8 +130,8 @@ export default function ActivitiesPanel(): React.ReactElement | null {
   return (
     <div className={styles.page}>
       <div className={styles.content}>
-      {hasActivities && (
-        <>
+      <div className={styles.toolbar}>
+        {hasActivities && (
           <div className={styles.dateTabs}>
             {dateTabs.map(({ key, label }) => (
               <Button
@@ -138,7 +144,25 @@ export default function ActivitiesPanel(): React.ReactElement | null {
               </Button>
             ))}
           </div>
+        )}
+        <Tooltip content="Add offline activity">
+          <button
+            type="button"
+            className={styles.addOfflineButton}
+            aria-label="Add offline activity"
+            onClick={() => setIsLogModalOpen(true)}
+          >
+            +
+          </button>
+        </Tooltip>
+      </div>
 
+      {isLogModalOpen && (
+        <LogOfflineActivityModal onClose={() => setIsLogModalOpen(false)} />
+      )}
+
+      {hasActivities && (
+        <>
           {hasTabActivities ? (
             <div className={styles.activitiesList}>
               {Object.entries(activitiesByDay).map(([dateKey, dayActivities]) => {
diff --git a/frontend/src/components/ActivityInput/ActivityInput.module.scss b/frontend/src/components/ActivityInput/ActivityInput.module.scss
index 6a5a3d63..f4725474 100644
--- a/frontend/src/components/ActivityInput/ActivityInput.module.scss
+++ b/frontend/src/components/ActivityInput/ActivityInput.module.scss
@@ -4,7 +4,7 @@
 @use '../../styles/semantic/spacing' as sp;
 @use 'sass:map';
 
-$row-control-height: 44px;
+$row-control-height: sp.$form-control-height;
 .control {
   height: $row-control-height;
   display: flex;
@@ -216,14 +216,6 @@ $row-control-height: 44px;
 }
 
 @include m.respond-to(md, down) {
-  .control {
-    height: 40px;
-  }
-
-  .grow {
-    min-height: 40px;
-  }
-
   .inputText {
     font-size: 1rem;
     line-height: 1.1;
@@ -242,14 +234,6 @@ $row-control-height: 44px;
 }
 
 @include m.respond-to(sm, down) {
-  .control {
-    height: 38px;
-  }
-
-  .grow {
-    min-height: 38px;
-  }
-
   .inputText {
     font-size: 0.9rem;
     line-height: 1.05;
diff --git a/frontend/src/components/ActivityInput/ActivityInput.tsx b/frontend/src/components/ActivityInput/ActivityInput.tsx
index 89e77ae7..afb1eb4b 100644
--- a/frontend/src/components/ActivityInput/ActivityInput.tsx
+++ b/frontend/src/components/ActivityInput/ActivityInput.tsx
@@ -7,6 +7,7 @@ import EntitySearchInput from "../EntitySearchInput/EntitySearchInput";
 import styles from "./ActivityInput.module.scss";
 import { useActivityInput } from "./useActivityInput";
 import SupportFlowModal from "../SupportFlow/SupportFlowModal";
+import { formatDuration } from "../../utils/formatUtils";
 
 export default function ActivityInput() {
   const {
@@ -14,8 +15,7 @@ export default function ActivityInput() {
     setName,
     isActive,
     inputValue,
-    minutes,
-    seconds,
+    elapsed,
     formattedLimit,
     showAutoStopWarning,
     flowState,
@@ -63,7 +63,7 @@ export default function ActivityInput() {
             </div>
 
             <div className={classNames(styles.timerPill, styles.control)}>
-              {minutes}:{seconds.toString().padStart(2, "0")}
+              {formatDuration(elapsed)}
             </div>
 
             <Button
diff --git a/frontend/src/components/ActivityInput/useActivityInput.test.ts b/frontend/src/components/ActivityInput/useActivityInput.test.ts
index cbf94b1f..137e83e1 100644
--- a/frontend/src/components/ActivityInput/useActivityInput.test.ts
+++ b/frontend/src/components/ActivityInput/useActivityInput.test.ts
@@ -344,7 +344,7 @@ describe('useActivityInput unified handlers', () => {
     });
   });
 
-  it('invalidates the today-points query after completing an activity, so the map badge updates immediately (#673)', async () => {
+  it('invalidates the daily-goals query after completing an activity, so the map badge updates immediately (#673, #751)', async () => {
     mockGame({ status: 'active', currentActivity: { name: 'Deep work' } });
     stop.mockResolvedValue({ xp_gained: 10 });
 
@@ -355,7 +355,7 @@ describe('useActivityInput unified handlers', () => {
     });
 
     expect(invalidateQueries).toHaveBeenCalledWith({
-      queryKey: ['me', 'today-points'],
+      queryKey: ['me', 'daily-goals'],
     });
   });
 });
diff --git a/frontend/src/components/ActivityInput/useActivityInput.ts b/frontend/src/components/ActivityInput/useActivityInput.ts
index c130ef24..3b1488c1 100644
--- a/frontend/src/components/ActivityInput/useActivityInput.ts
+++ b/frontend/src/components/ActivityInput/useActivityInput.ts
@@ -5,9 +5,10 @@ import { useGame } from "../../hooks/useGame";
 import { useEntitySearchCache } from "../../hooks/useEntitySearchCache";
 import { useSupportFlow } from "../../hooks/useSupportFlow";
 import { useFeatureFlag } from "../../hooks/useFeatureFlag";
-import { TODAY_POINTS_QUERY_KEY } from "../../hooks/usePlayer";
+import { DAILY_GOALS_QUERY_KEY } from "../../hooks/usePlayer";
 import type { PlayerActivity } from "../../types";
 import { playLimitReachedSound, primeAudio } from "../../utils/sounds";
+import { formatDuration } from "../../utils/formatUtils";
 
 /** Populated on stop when `results_mode` is on, instead of opening the SupportFlow modal. */
 export interface ResultsData {
@@ -295,7 +296,7 @@ export function useActivityInput() {
           fetchPlayerAndCharacter(),
           fetchCharacterCurrent(),
           fetchActivities(),
-          queryClient.invalidateQueries({ queryKey: TODAY_POINTS_QUERY_KEY }),
+          queryClient.invalidateQueries({ queryKey: DAILY_GOALS_QUERY_KEY }),
           completedTaskId ? queryClient.invalidateQueries({ queryKey: ["tasks"] }) : Promise.resolve(),
         ]);
       } catch (err) {
@@ -536,8 +537,8 @@ export function useActivityInput() {
     stop,
   ]);
 
-  const minutes = Math.floor(elapsed / 60);
-  const seconds = elapsed % 60;
+  const formattedElapsed =
+  formatDuration(elapsed)
 
   const formattedLimit = useMemo(() => {
     if (typeof limitSeconds !== "number" || limitSeconds <= 0) {
@@ -563,8 +564,8 @@ export function useActivityInput() {
     inputValue,
     taskId: currentActivity?.taskId ?? null,
     activityCatalogId: currentActivity?.activity ?? null,
-    minutes,
-    seconds,
+    elapsed,
+    formattedElapsed,
     formattedLimit,
     showAutoStopWarning,
     flowState,
diff --git a/frontend/src/components/BuildingDetail/BuildingDetail.test.tsx b/frontend/src/components/BuildingDetail/BuildingDetail.test.tsx
index 85593148..6d986ec6 100644
--- a/frontend/src/components/BuildingDetail/BuildingDetail.test.tsx
+++ b/frontend/src/components/BuildingDetail/BuildingDetail.test.tsx
@@ -56,7 +56,7 @@ describe('BuildingDetail', () => {
     expect(screen.queryByText(/Wheat/)).not.toBeInTheDocument();
   });
 
-  it('shows each resident, with "walking" overriding their scheduled activity', () => {
+  it('shows each resident by name only', () => {
     render(
       <BuildingDetail
         buildingType="residential"
@@ -67,8 +67,8 @@ describe('BuildingDetail', () => {
       />
     );
 
-    expect(screen.getByText('Alice — idle')).toBeInTheDocument();
-    expect(screen.getByText('Bob — walking')).toBeInTheDocument();
+    expect(screen.getByText('Alice')).toBeInTheDocument();
+    expect(screen.getByText('Bob')).toBeInTheDocument();
   });
 
   it('calls onSelectResident when a resident row is clicked', async () => {
diff --git a/frontend/src/components/BuildingDetail/BuildingDetail.tsx b/frontend/src/components/BuildingDetail/BuildingDetail.tsx
index c14c6aef..f114f6b7 100644
--- a/frontend/src/components/BuildingDetail/BuildingDetail.tsx
+++ b/frontend/src/components/BuildingDetail/BuildingDetail.tsx
@@ -35,8 +35,7 @@ function capitalize(word: string): string {
 function residentLine(resident: BuildingDetailResident): string {
   // "walking" overrides the scheduled activity while moving, same rule as
   // a character's own map tooltip (CharacterTooltipContent).
-  const activity = resident.isMoving ? "walking" : resident.currentActivity;
-  return activity ? `${resident.name} — ${activity}` : resident.name;
+  return resident.name;
 }
 
 export default function BuildingDetail({
diff --git a/frontend/src/components/CategoriesPanel/CategoriesPanel.test.tsx b/frontend/src/components/CategoriesPanel/CategoriesPanel.test.tsx
index da84cce2..bad828fe 100644
--- a/frontend/src/components/CategoriesPanel/CategoriesPanel.test.tsx
+++ b/frontend/src/components/CategoriesPanel/CategoriesPanel.test.tsx
@@ -44,16 +44,16 @@ describe("CategoriesPanel", () => {
     const input = screen.getByLabelText("category name");
     await user.clear(input);
     await user.type(input, "Admin");
-    await user.click(screen.getByRole("button", { name: "Save" }));
+    await user.tab();
 
     await waitFor(() => {
-      expect(updateMutate).toHaveBeenCalledWith({
-        id: 1,
-        data: { name: "Admin" },
-      });
+      expect(updateMutate).toHaveBeenCalledWith(
+        { id: 1, data: { name: "Admin" } },
+        expect.objectContaining({ onSuccess: expect.any(Function), onError: expect.any(Function) }),
+      );
     });
 
-    await user.click(screen.getByRole("button", { name: "Open category Deep Work" }));
+    // The modal stays open after an autosave — no explicit Save click to close it.
     await user.click(within(screen.getByRole("dialog")).getByRole("button", { name: "Delete" }));
     await user.click(within(screen.getByRole("dialog")).getByRole("button", { name: "Delete" }));
 
diff --git a/frontend/src/components/DailyGoalsBadge/DailyGoalsBadge.module.scss b/frontend/src/components/DailyGoalsBadge/DailyGoalsBadge.module.scss
new file mode 100644
index 00000000..3bdf9ece
--- /dev/null
+++ b/frontend/src/components/DailyGoalsBadge/DailyGoalsBadge.module.scss
@@ -0,0 +1,60 @@
+@use '../../styles/semantic/colors' as c;
+@use '../../styles/semantic/typography' as t;
+@use '../../styles/semantic/spacing' as sp;
+
+.badge {
+  background: c.$color-bg;
+  border: 1px solid c.$color-border-primary;
+  border-radius: sp.$border-radius;
+  padding: sp.$spacing-xs sp.$spacing-sm;
+  min-width: 11rem;
+  @include t.apply-text-style(t.$text-body);
+}
+
+.title {
+  margin: 0 0 sp.$spacing-xs;
+  @include t.apply-text-style(t.$text-caption);
+  color: c.$color-text-muted;
+}
+
+.goalList {
+  list-style: none;
+  margin: 0;
+  padding: 0;
+  display: flex;
+  flex-direction: column;
+  gap: 2px;
+}
+
+.goal,
+.goalMet {
+  display: flex;
+  align-items: center;
+  gap: sp.$spacing-xs;
+  @include t.apply-text-style(t.$text-list);
+}
+
+.goal {
+  color: c.$color-text-muted;
+}
+
+.goalMet {
+  color: c.$color-text-body;
+}
+
+.goalMark {
+  color: c.$color-status-success;
+  width: 1em;
+  text-align: center;
+}
+
+.goal .goalMark {
+  color: c.$color-text-disabled;
+}
+
+.bonus {
+  margin: sp.$spacing-xs 0 0;
+  color: c.$color-status-success;
+  font-weight: bold;
+  @include t.apply-text-style(t.$text-list);
+}
diff --git a/frontend/src/components/DailyGoalsBadge/DailyGoalsBadge.test.tsx b/frontend/src/components/DailyGoalsBadge/DailyGoalsBadge.test.tsx
new file mode 100644
index 00000000..3313ca75
--- /dev/null
+++ b/frontend/src/components/DailyGoalsBadge/DailyGoalsBadge.test.tsx
@@ -0,0 +1,96 @@
+import { render, screen } from '@testing-library/react';
+import { describe, expect, it, vi } from 'vitest';
+
+import DailyGoalsBadge from './DailyGoalsBadge';
+import type { DailyGoalsResponse } from '../../api/player';
+
+const mockUseDailyGoals = vi.fn<() => { data: DailyGoalsResponse | undefined }>(
+  () => ({ data: { goals: null } })
+);
+
+vi.mock('../../hooks/usePlayer', () => ({
+  useDailyGoals: () => mockUseDailyGoals(),
+}));
+
+const baseGoals = {
+  logged_in_today: false,
+  completed_activity_today: false,
+  activity_minutes_today: 0,
+  minutes_goal_threshold: 3,
+  minutes_goal_met: false,
+  all_goals_met: false,
+  bonus_awarded_today: false,
+  bonus_ap: 0,
+};
+
+describe('DailyGoalsBadge', () => {
+  it('renders nothing when the player has no active character link', () => {
+    mockUseDailyGoals.mockReturnValue({ data: { goals: null } });
+
+    const { container } = render(<DailyGoalsBadge />);
+
+    expect(container).toBeEmptyDOMElement();
+  });
+
+  it('renders nothing while the query has no data yet', () => {
+    mockUseDailyGoals.mockReturnValue({ data: undefined });
+
+    const { container } = render(<DailyGoalsBadge />);
+
+    expect(container).toBeEmptyDOMElement();
+  });
+
+  it('shows all three goals as unmet', () => {
+    mockUseDailyGoals.mockReturnValue({ data: { goals: baseGoals } });
+
+    render(<DailyGoalsBadge />);
+
+    expect(screen.getByText('Logged in today')).toBeInTheDocument();
+    expect(screen.getByText('Completed an activity')).toBeInTheDocument();
+    expect(screen.getByText('3+ minutes recorded')).toBeInTheDocument();
+    expect(screen.queryByText(/AP bonus earned/)).not.toBeInTheDocument();
+    expect(screen.queryByText('All goals cleared!')).not.toBeInTheDocument();
+  });
+
+  it('shows the awarded bonus once all goals are cleared and the bonus has paid out', () => {
+    mockUseDailyGoals.mockReturnValue({
+      data: {
+        goals: {
+          ...baseGoals,
+          logged_in_today: true,
+          completed_activity_today: true,
+          activity_minutes_today: 5,
+          minutes_goal_met: true,
+          all_goals_met: true,
+          bonus_awarded_today: true,
+          bonus_ap: 50,
+        },
+      },
+    });
+
+    render(<DailyGoalsBadge />);
+
+    expect(screen.getByText('+50 AP bonus earned!')).toBeInTheDocument();
+  });
+
+  it('shows a generic "cleared" message if goals are met but the bonus has not landed yet', () => {
+    mockUseDailyGoals.mockReturnValue({
+      data: {
+        goals: {
+          ...baseGoals,
+          logged_in_today: true,
+          completed_activity_today: true,
+          activity_minutes_today: 5,
+          minutes_goal_met: true,
+          all_goals_met: true,
+          bonus_awarded_today: false,
+          bonus_ap: 0,
+        },
+      },
+    });
+
+    render(<DailyGoalsBadge />);
+
+    expect(screen.getByText('All goals cleared!')).toBeInTheDocument();
+  });
+});
diff --git a/frontend/src/components/DailyGoalsBadge/DailyGoalsBadge.tsx b/frontend/src/components/DailyGoalsBadge/DailyGoalsBadge.tsx
new file mode 100644
index 00000000..ed841a59
--- /dev/null
+++ b/frontend/src/components/DailyGoalsBadge/DailyGoalsBadge.tsx
@@ -0,0 +1,65 @@
+import React from "react";
+import { useDailyGoals } from "../../hooks/usePlayer";
+import styles from "./DailyGoalsBadge.module.scss";
+
+interface GoalItem {
+  key: string;
+  label: string;
+  met: boolean;
+}
+
+// Personal "daily goals" badge for the map view (issue #751, replacing the
+// old single-number "today" points badge from issue #673) - deliberately
+// not attached to any village marker, and deliberately silent about the
+// player/character link: framed as the player's own goals rather than
+// naming a character, since players don't yet know about the link.
+// Renders nothing (not an empty/all-unmet state) when the player has no
+// active PlayerCharacterLink - see MeViewSet.daily_goals in api/views.py.
+export default function DailyGoalsBadge(): React.ReactElement | null {
+  const { data } = useDailyGoals();
+  const goals = data?.goals;
+
+  if (goals == null) {
+    return null;
+  }
+
+  const items: GoalItem[] = [
+    { key: "login", label: "Logged in today", met: goals.logged_in_today },
+    {
+      key: "activity",
+      label: "Completed an activity",
+      met: goals.completed_activity_today,
+    },
+    {
+      key: "minutes",
+      label: `${goals.minutes_goal_threshold}+ minutes recorded`,
+      met: goals.minutes_goal_met,
+    },
+  ];
+
+  return (
+    <div className={styles.badge} aria-live="polite" role="status">
+      <p className={styles.title}>Today&apos;s goals</p>
+      <ul className={styles.goalList}>
+        {items.map((item) => (
+          <li
+            key={item.key}
+            className={item.met ? styles.goalMet : styles.goal}
+          >
+            <span className={styles.goalMark} aria-hidden="true">
+              {item.met ? "✓" : "○"}
+            </span>
+            {item.label}
+          </li>
+        ))}
+      </ul>
+      {goals.all_goals_met && (
+        <p className={styles.bonus}>
+          {goals.bonus_awarded_today
+            ? `+${goals.bonus_ap} AP bonus earned!`
+            : "All goals cleared!"}
+        </p>
+      )}
+    </div>
+  );
+}
diff --git a/frontend/src/components/EntitySearchInput/EntitySearchInput.module.scss b/frontend/src/components/EntitySearchInput/EntitySearchInput.module.scss
index 2a60608e..48c964ef 100644
--- a/frontend/src/components/EntitySearchInput/EntitySearchInput.module.scss
+++ b/frontend/src/components/EntitySearchInput/EntitySearchInput.module.scss
@@ -13,9 +13,10 @@
 .input {
   width: 100%;
   min-width: 0;
+  height: sp.$form-control-height;
   padding: sp.$padding-base;
   box-sizing: border-box;
-  border-radius: sp.$border-radius;
+  border-radius: sp.$form-control-radius;
   @include t.apply-text-style(t.$text-body);
   @include m.border-interactive(
     rgba(c.$color-border-primary, 0.4),
diff --git a/frontend/src/components/Input/Input.module.scss b/frontend/src/components/Input/Input.module.scss
index a991bf0a..6441da5e 100644
--- a/frontend/src/components/Input/Input.module.scss
+++ b/frontend/src/components/Input/Input.module.scss
@@ -27,6 +27,7 @@
 
 .inputField {
   padding: sp.$padding-base;
+  height: sp.$form-control-height;
   box-sizing: border-box;
   max-width: 30rem;
   @include m.border-interactive(
@@ -34,7 +35,7 @@
     c.$color-border-primary,
     c.$color-border-accent
   );
-  border-radius: sp.$border-radius;
+  border-radius: sp.$form-control-radius;
   transition: border 0.2s, background 0.2s;
   @include t.apply-text-style(t.$text-body);
 
diff --git a/frontend/src/components/Input/Input.tsx b/frontend/src/components/Input/Input.tsx
index b95a9176..c0b9343b 100644
--- a/frontend/src/components/Input/Input.tsx
+++ b/frontend/src/components/Input/Input.tsx
@@ -23,6 +23,7 @@ function EyeOffIcon() {
 interface InputProps {
   id: string;
   label?: string;
+  ariaLabel?: string;
   type?: string;
   value?: string;
   onChange?: (value: string | boolean) => void;
@@ -34,6 +35,8 @@ interface InputProps {
   checked?: boolean;
   minLength?: number;
   maxLength?: number;
+  min?: string | number;
+  max?: string | number;
   className?: string;
   inputClassName?: string;
   disabled?: boolean;
@@ -44,6 +47,7 @@ interface InputProps {
 export default function Input({
   id,
   label,
+  ariaLabel,
   type = 'text',
   value,
   onChange,
@@ -55,6 +59,8 @@ export default function Input({
   checked,
   minLength,
   maxLength,
+  min,
+  max,
   className,
   inputClassName,
   disabled = false,
@@ -91,13 +97,15 @@ export default function Input({
       onBlur={onBlur}
       onKeyDown={onKeyDown}
       placeholder={placeholder}
+      aria-label={!label ? ariaLabel : undefined}
       aria-invalid={!!error}
       aria-describedby={describedBy}
       aria-required={required}
       autoComplete={autoComplete}
-      required={required}
       minLength={minLength}
       maxLength={maxLength}
+      min={min}
+      max={max}
       disabled={disabled}
     />
   );
diff --git a/frontend/src/components/List/List.module.scss b/frontend/src/components/List/List.module.scss
index 09ae1119..836525a9 100644
--- a/frontend/src/components/List/List.module.scss
+++ b/frontend/src/components/List/List.module.scss
@@ -61,7 +61,6 @@
 
 .canHover .listItem:hover {
   background: rgba(c.$color-border-primary, 0.18);
-  border-color: rgba(c.$color-border-primary, 0.7);
   @include m.box-shadow(md);
   z-index: 1;
   cursor: default;
diff --git a/frontend/src/components/LogOfflineActivityModal/LogOfflineActivityModal.module.scss b/frontend/src/components/LogOfflineActivityModal/LogOfflineActivityModal.module.scss
new file mode 100644
index 00000000..8c7e4788
--- /dev/null
+++ b/frontend/src/components/LogOfflineActivityModal/LogOfflineActivityModal.module.scss
@@ -0,0 +1,126 @@
+@use '../../styles/semantic/spacing' as sp;
+@use '../../styles/semantic/typography' as t;
+@use '../../styles/semantic/colors' as c;
+@use '../../styles/utilities/mixins' as m;
+
+.form {
+  display: flex;
+  flex-direction: column;
+  gap: sp.$spacing-md;
+  width: 100%;
+}
+
+.field {
+  display: flex;
+  flex-direction: column;
+  gap: sp.$spacing-xs;
+}
+
+.label {
+  @include t.apply-text-style(t.$text-body);
+  font-weight: 600;
+}
+
+.required {
+  color: c.$color-error;
+}
+
+.row {
+  display: flex;
+  gap: sp.$spacing-sm;
+  width: 100%;
+
+  > * {
+    flex: 1;
+    min-width: 0;
+  }
+}
+
+.durationPartField {
+  flex: 0 0 auto;
+  width: 4.5rem;
+  max-width: 4.5rem;
+
+  input[type='number'] {
+    appearance: textfield;
+    -moz-appearance: textfield;
+
+    &::-webkit-outer-spin-button,
+    &::-webkit-inner-spin-button {
+      appearance: none;
+      -webkit-appearance: none;
+      margin: 0;
+    }
+  }
+}
+
+.taskInput {
+  width: 100%;
+}
+
+.durationPreview {
+  @include t.apply-text-style(t.$text-body);
+  opacity: 0.75;
+  margin: 0;
+}
+
+.errorText {
+  @include t.apply-text-style(t.$text-body);
+  color: c.$color-error;
+  margin: 0;
+}
+
+.eligibilityBanner {
+  @include t.apply-text-style(t.$text-body);
+  margin: 0;
+  padding: sp.$spacing-sm sp.$spacing-md;
+  border-radius: sp.$border-radius;
+  border: 1px solid transparent;
+
+  &.info {
+    background: rgba(c.$color-status-info, 0.1);
+    border-color: rgba(c.$color-status-info, 0.4);
+  }
+
+  &.success {
+    background: rgba(c.$color-status-success, 0.1);
+    border-color: rgba(c.$color-status-success, 0.4);
+  }
+
+  &.warning {
+    background: rgba(c.$color-warning, 0.12);
+    border-color: rgba(c.$color-warning, 0.4);
+  }
+}
+
+.actions {
+  display: flex;
+  justify-content: flex-end;
+  gap: sp.$spacing-sm;
+  margin-top: sp.$spacing-sm;
+}
+
+.confirmation {
+  display: flex;
+  flex-direction: column;
+  gap: sp.$spacing-md;
+  width: 100%;
+  text-align: center;
+}
+
+.confirmationHeadline {
+  @include t.apply-text-style(t.$text-body);
+  margin: 0;
+}
+
+.confirmationActions {
+  display: flex;
+  justify-content: center;
+  gap: sp.$spacing-sm;
+}
+
+@include m.respond-to(sm, down) {
+  .row {
+    flex-direction: column;
+  }
+}
diff --git a/frontend/src/components/LogOfflineActivityModal/LogOfflineActivityModal.test.tsx b/frontend/src/components/LogOfflineActivityModal/LogOfflineActivityModal.test.tsx
new file mode 100644
index 00000000..b8e3763b
--- /dev/null
+++ b/frontend/src/components/LogOfflineActivityModal/LogOfflineActivityModal.test.tsx
@@ -0,0 +1,122 @@
+import { render, screen, waitFor } from "@testing-library/react";
+import userEvent from "@testing-library/user-event";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+
+import { TooltipProvider } from "../Tooltip/Tooltip";
+import LogOfflineActivityModal from "./LogOfflineActivityModal";
+
+const logMutate = vi.fn();
+const fetchPlayerAndCharacter = vi.fn();
+let gameValue: Record<string, unknown>;
+
+vi.mock("../../hooks/useActivities", () => ({
+  useLogOfflineActivity: () => ({ mutate: logMutate, isPending: false }),
+}));
+
+vi.mock("../../hooks/useGame", () => ({
+  useGame: () => gameValue,
+}));
+
+// Stub the autocomplete input so these tests don't depend on the search cache.
+vi.mock("../EntitySearchInput/EntitySearchInput", () => ({
+  default: ({
+    value,
+    onChange,
+    placeholder,
+  }: {
+    value: string;
+    onChange?: (v: string) => void;
+    placeholder?: string;
+  }) => (
+    <input
+      aria-label="Task"
+      placeholder={placeholder}
+      value={value}
+      onChange={(event) => onChange?.(event.target.value)}
+    />
+  ),
+}));
+
+function renderModal(onClose = vi.fn()) {
+  return render(
+    <TooltipProvider>
+      <LogOfflineActivityModal onClose={onClose} />
+    </TooltipProvider>
+  );
+}
+
+describe("LogOfflineActivityModal", () => {
+  beforeEach(() => {
+    logMutate.mockReset();
+    fetchPlayerAndCharacter.mockReset();
+    gameValue = { player: { is_premium: true }, fetchPlayerAndCharacter };
+  });
+
+  it("blocks submission and shows errors when required fields are missing", async () => {
+    const user = userEvent.setup();
+    renderModal();
+
+    await user.click(screen.getByRole("button", { name: "Log activity" }));
+
+    expect(await screen.findByText("Enter or select a task.")).toBeInTheDocument();
+    expect(screen.getByText("Enter a duration greater than zero.")).toBeInTheDocument();
+    expect(logMutate).not.toHaveBeenCalled();
+  });
+
+  it("submits a valid entry and shows the XP confirmation", async () => {
+    const user = userEvent.setup();
+    renderModal();
+
+    await user.type(screen.getByLabelText("Task"), "Write docs");
+    await user.type(screen.getByLabelText("Minutes"), "30");
+
+    await user.click(screen.getByRole("button", { name: "Log activity" }));
+
+    await waitFor(() => expect(logMutate).toHaveBeenCalledTimes(1));
+    const [payload, callbacks] = logMutate.mock.calls[0];
+    expect(payload.name).toBe("Write docs");
+    expect(payload.started_at < payload.completed_at).toBe(true);
+
+    callbacks.onSuccess({
+      success: true,
+      message: "Activity logged",
+      activity: { name: "Write docs" },
+      xp_gained: 42,
+      xp_eligible_seconds: 1800,
+      level_ups: [],
+    });
+
+    expect(await screen.findByText("+42 XP awarded")).toBeInTheDocument();
+    expect(fetchPlayerAndCharacter).toHaveBeenCalled();
+  });
+
+  it("surfaces the backend error message on failure", async () => {
+    const user = userEvent.setup();
+    renderModal();
+
+    await user.type(screen.getByLabelText("Task"), "Write docs");
+    await user.type(screen.getByLabelText("Minutes"), "30");
+    await user.click(screen.getByRole("button", { name: "Log activity" }));
+
+    await waitFor(() => expect(logMutate).toHaveBeenCalledTimes(1));
+    const [, callbacks] = logMutate.mock.calls[0];
+
+    callbacks.onError(new Error(JSON.stringify({ success: false, message: "Daily limit reached." })));
+
+    expect(await screen.findByText("Daily limit reached.")).toBeInTheDocument();
+  });
+
+  it("warns free-tier users that XP won't be awarded", async () => {
+    gameValue = { player: { is_premium: false }, fetchPlayerAndCharacter };
+    const user = userEvent.setup();
+    renderModal();
+
+    await user.type(screen.getByLabelText("Minutes"), "10");
+
+    expect(
+      await screen.findByText(
+        "This will be recorded, but offline activities only earn XP for Premium accounts."
+      )
+    ).toBeInTheDocument();
+  });
+});
diff --git a/frontend/src/components/LogOfflineActivityModal/LogOfflineActivityModal.tsx b/frontend/src/components/LogOfflineActivityModal/LogOfflineActivityModal.tsx
new file mode 100644
index 00000000..bd3f6c83
--- /dev/null
+++ b/frontend/src/components/LogOfflineActivityModal/LogOfflineActivityModal.tsx
@@ -0,0 +1,171 @@
+import classNames from "classnames";
+
+import Modal from "../Modal/Modal";
+import Button from "../Button/Button";
+import Input from "../Input/Input";
+import EntitySearchInput from "../EntitySearchInput/EntitySearchInput";
+import { formatDurationShort } from "../../utils/formatUtils";
+import { useLogOfflineActivityForm } from "./useLogOfflineActivityForm";
+import styles from "./LogOfflineActivityModal.module.scss";
+
+interface LogOfflineActivityModalProps {
+  onClose: () => void;
+}
+
+export default function LogOfflineActivityModal({ onClose }: LogOfflineActivityModalProps) {
+  const {
+    taskName,
+    handleTaskNameChange,
+    handleTaskSelect,
+    durationHours,
+    setDurationHours,
+    durationMinutes,
+    setDurationMinutes,
+    totalDurationMinutes,
+    completionDate,
+    handleCompletionDateChange,
+    completionTime,
+    handleCompletionTimeChange,
+    maxCompletionDate,
+    fieldErrors,
+    submitError,
+    result,
+    eligibility,
+    isSubmitting,
+    handleSubmit,
+    reset,
+  } = useLogOfflineActivityForm();
+
+  if (result) {
+    return (
+      <Modal title="Activity logged" onClose={onClose} size="sm">
+        <div className={styles.confirmation}>
+          <p className={styles.confirmationHeadline}>
+            &ldquo;{result.activity.name}&rdquo; has been recorded.
+          </p>
+          {result.xp_gained > 0 ? (
+            <p className={classNames(styles.eligibilityBanner, styles.success)}>
+              +{result.xp_gained} XP awarded
+            </p>
+          ) : (
+            <p className={classNames(styles.eligibilityBanner, styles.info)}>
+              No XP was awarded for this activity.
+            </p>
+          )}
+          <div className={styles.confirmationActions}>
+            <Button variant="secondary" onClick={reset}>
+              Log another
+            </Button>
+            <Button onClick={onClose}>Done</Button>
+          </div>
+        </div>
+      </Modal>
+    );
+  }
+
+  return (
+    <Modal title="Log offline activity" onClose={onClose} size="sm">
+      <form className={styles.form} onSubmit={handleSubmit}>
+        <div className={styles.field}>
+          <span className={styles.label}>
+            Task <span className={styles.required} aria-label="required">*</span>
+          </span>
+          <EntitySearchInput
+            type="task"
+            value={taskName}
+            onChange={handleTaskNameChange}
+            onSelect={handleTaskSelect}
+            placeholder="Search or enter a task name"
+            ariaLabel="Task"
+            inputClassName={styles.taskInput}
+          />
+          {fieldErrors.task && (
+            <p className={styles.errorText} role="alert">{fieldErrors.task}</p>
+          )}
+        </div>
+
+        <div className={styles.field}>
+          <span className={styles.label}>
+            Duration <span className={styles.required} aria-label="required">*</span>
+          </span>
+          <div className={styles.row}>
+            <Input
+              id="offline-activity-duration-hours"
+              ariaLabel="Hours"
+              type="number"
+              placeholder="hh"
+              value={durationHours}
+              onChange={(value) => setDurationHours(value as string)}
+              className={styles.durationPartField}
+            />
+            <Input
+              id="offline-activity-duration-minutes"
+              ariaLabel="Minutes"
+              type="number"
+              placeholder="mm"
+              value={durationMinutes}
+              onChange={(value) => setDurationMinutes((value as string).slice(0, 2))}
+              maxLength={2}
+              className={styles.durationPartField}
+            />
+          </div>
+          {fieldErrors.duration && (
+            <p className={styles.errorText} role="alert">{fieldErrors.duration}</p>
+          )}
+        </div>
+
+        <div className={styles.field}>
+          <span className={styles.label}>Completed</span>
+          <div className={styles.row}>
+            <Input
+              id="offline-activity-date"
+              ariaLabel="Completion date"
+              type="date"
+              value={completionDate}
+              onChange={(value) => handleCompletionDateChange(value as string)}
+              max={maxCompletionDate}
+            />
+            <Input
+              id="offline-activity-time"
+              ariaLabel="Completion time"
+              type="time"
+              value={completionTime}
+              onChange={(value) => handleCompletionTimeChange(value as string)}
+            />
+          </div>
+          {fieldErrors.completedAt && (
+            <p className={styles.errorText} role="alert">{fieldErrors.completedAt}</p>
+          )}
+        </div>
+
+        {!Number.isNaN(totalDurationMinutes) && totalDurationMinutes > 0 && (
+          <p className={styles.durationPreview}>
+            Logging {formatDurationShort(Math.round(totalDurationMinutes * 60))}
+          </p>
+        )}
+
+        {eligibility && (
+          <p
+            className={classNames(styles.eligibilityBanner, styles[eligibility.tone])}
+            role="status"
+          >
+            {eligibility.message}
+          </p>
+        )}
+
+        {submitError && (
+          <p className={styles.errorText} role="alert">{submitError}</p>
+        )}
+
+        <div className={styles.actions}>
+          <Button type="button" variant="secondary" onClick={onClose} disabled={isSubmitting}>
+            Cancel
+          </Button>
+          <Button type="submit" disabled={isSubmitting}>
+            {isSubmitting ? "Logging…" : "Log activity"}
+          </Button>
+        </div>
+      </form>
+    </Modal>
+  );
+}
diff --git a/frontend/src/components/LogOfflineActivityModal/useLogOfflineActivityForm.ts b/frontend/src/components/LogOfflineActivityModal/useLogOfflineActivityForm.ts
new file mode 100644
index 00000000..03d24d1d
--- /dev/null
+++ b/frontend/src/components/LogOfflineActivityModal/useLogOfflineActivityForm.ts
@@ -0,0 +1,242 @@
+import { useCallback, useMemo, useState } from "react";
+
+import { useLogOfflineActivity } from "../../hooks/useActivities";
+import { useGame } from "../../hooks/useGame";
+import type { SearchEntity } from "../EntitySearchInput/useEntitySearchInput";
+import type { OfflineActivityLogResponse } from "../../types";
+
+// Must match OFFLINE_XP_ELIGIBLE_BACKDATE_WINDOW in progression/services.py —
+// duplicated here only for the client-side "will this earn XP" hint; the
+// backend remains the authority on whether XP is actually awarded.
+const XP_ELIGIBLE_BACKDATE_DAYS = 7;
+
+function pad(n: number): string {
+  return String(n).padStart(2, "0");
+}
+
+function todayDateValue(): string {
+  const now = new Date();
+  return `${now.getFullYear()}-${pad(now.getMonth() + 1)}-${pad(now.getDate())}`;
+}
+
+function nowTimeValue(): string {
+  const now = new Date();
+  return `${pad(now.getHours())}:${pad(now.getMinutes())}`;
+}
+
+function extractErrorMessage(error: unknown): string {
+  if (error instanceof Error && error.message) {
+    try {
+      const parsed = JSON.parse(error.message) as Record<string, unknown>;
+      if (typeof parsed.message === "string") return parsed.message;
+
+      const firstFieldError = Object.values(parsed).find(
+        (value): value is string[] =>
+          Array.isArray(value) && typeof value[0] === "string"
+      );
+      if (firstFieldError) return firstFieldError[0];
+    } catch {
+      // Not a JSON error body — fall back to the raw message below.
+    }
+    return error.message;
+  }
+  return "Something went wrong logging this activity. Please try again.";
+}
+
+export interface FieldErrors {
+  task?: string;
+  duration?: string;
+  completedAt?: string;
+}
+
+export function useLogOfflineActivityForm(onLogged?: () => void) {
+  const { player, fetchPlayerAndCharacter } = useGame();
+  const isPremium = Boolean(player?.is_premium);
+  const logOfflineActivity = useLogOfflineActivity();
+
+  const [taskName, setTaskName] = useState("");
+  const [selectedTaskId, setSelectedTaskId] = useState<number | null>(null);
+  const [durationHours, setDurationHours] = useState("");
+  const [durationMinutes, setDurationMinutes] = useState("");
+  const [completionDate, setCompletionDate] = useState(todayDateValue);
+  const [completionTime, setCompletionTime] = useState(nowTimeValue);
+  // Fixed at mount: caps the native date picker so future dates can't be
+  // selected at all, rather than allowing them and erroring afterwards.
+  const [maxCompletionDate] = useState(todayDateValue);
+  const [fieldErrors, setFieldErrors] = useState<FieldErrors>({});
+  const [submitError, setSubmitError] = useState<string | null>(null);
+  const [result, setResult] = useState<OfflineActivityLogResponse | null>(null);
+  // Read once at mount (a lazy initializer, not a render-phase call) and
+  // refreshed by the date/time change handlers below — those are event
+  // handlers, where reading the clock is fine.
+  const [nowMs, setNowMs] = useState(() => Date.now());
+
+  const handleCompletionDateChange = useCallback((value: string) => {
+    setCompletionDate(value);
+    setNowMs(Date.now());
+  }, []);
+
+  const handleCompletionTimeChange = useCallback((value: string) => {
+    setCompletionTime(value);
+    setNowMs(Date.now());
+  }, []);
+
+  const handleTaskNameChange = useCallback((value: string) => {
+    setTaskName(value);
+    setSelectedTaskId(null);
+  }, []);
+
+  const handleTaskSelect = useCallback((entity: SearchEntity) => {
+    setTaskName(entity.name);
+    setSelectedTaskId(typeof entity.id === "number" ? entity.id : Number(entity.id));
+  }, []);
+
+  const totalDurationMinutes = useMemo(() => {
+    const hours = Number(durationHours || 0);
+    const minutes = Number(durationMinutes || 0);
+    if (Number.isNaN(hours) || Number.isNaN(minutes)) return NaN;
+    return hours * 60 + minutes;
+  }, [durationHours, durationMinutes]);
+
+  const completedAt = useMemo(() => {
+    if (!completionDate || !completionTime) return null;
+    const date = new Date(`${completionDate}T${completionTime}`);
+    return Number.isNaN(date.getTime()) ? null : date;
+  }, [completionDate, completionTime]);
+
+  const eligibility = useMemo(() => {
+    if (!completedAt) return null;
+
+    if (!isPremium) {
+      return {
+        tone: "info" as const,
+        message: "This will be recorded, but offline activities only earn XP for Premium accounts.",
+      };
+    }
+
+    const ageDays = (nowMs - completedAt.getTime()) / (24 * 60 * 60 * 1000);
+    if (ageDays > XP_ELIGIBLE_BACKDATE_DAYS) {
+      return {
+        tone: "warning" as const,
+        message: `This is more than ${XP_ELIGIBLE_BACKDATE_DAYS} days old, so it will be recorded but won't earn XP.`,
+      };
+    }
+
+    return {
+      tone: "success" as const,
+      message: "This activity is eligible for XP, subject to your daily logging limits.",
+    };
+  }, [completedAt, isPremium, nowMs]);
+
+  const validate = useCallback((): FieldErrors => {
+    const errors: FieldErrors = {};
+
+    if (!taskName.trim()) {
+      errors.task = "Enter or select a task.";
+    }
+
+    const hours = durationHours ? Number(durationHours) : 0;
+    const minutes = durationMinutes ? Number(durationMinutes) : 0;
+    if (Number.isNaN(hours) || hours < 0) {
+      errors.duration = "Hours must be a positive number.";
+    } else if (Number.isNaN(minutes) || minutes < 0 || minutes > 59) {
+      errors.duration = "Minutes must be between 0 and 59.";
+    } else if (totalDurationMinutes <= 0) {
+      errors.duration = "Enter a duration greater than zero.";
+    }
+
+    if (!completionDate || !completionTime) {
+      errors.completedAt = "Enter a completion date and time.";
+    } else if (!completedAt) {
+      errors.completedAt = "Enter a valid completion date and time.";
+    } else if (completedAt.getTime() > Date.now()) {
+      errors.completedAt = "Completion date/time can't be in the future.";
+    }
+
+    return errors;
+  }, [
+    completedAt,
+    completionDate,
+    completionTime,
+    durationHours,
+    durationMinutes,
+    taskName,
+    totalDurationMinutes,
+  ]);
+
+  const reset = useCallback(() => {
+    setTaskName("");
+    setSelectedTaskId(null);
+    setDurationHours("");
+    setDurationMinutes("");
+    setCompletionDate(todayDateValue());
+    setCompletionTime(nowTimeValue());
+    setNowMs(Date.now());
+    setFieldErrors({});
+    setSubmitError(null);
+    setResult(null);
+  }, []);
+
+  const handleSubmit = useCallback(
+    (event: React.FormEvent<HTMLFormElement>) => {
+      event.preventDefault();
+      setSubmitError(null);
+
+      const errors = validate();
+      setFieldErrors(errors);
+      if (Object.keys(errors).length > 0 || !completedAt) return;
+
+      const durationSeconds = Math.round(totalDurationMinutes * 60);
+      const startedAt = new Date(completedAt.getTime() - durationSeconds * 1000);
+
+      logOfflineActivity.mutate(
+        {
+          ...(selectedTaskId ? { task: selectedTaskId } : { name: taskName.trim() }),
+          started_at: startedAt.toISOString(),
+          completed_at: completedAt.toISOString(),
+        },
+        {
+          onSuccess: (data) => {
+            setResult(data);
+            if (data.xp_gained > 0) fetchPlayerAndCharacter();
+            onLogged?.();
+          },
+          onError: (error) => setSubmitError(extractErrorMessage(error)),
+        }
+      );
+    },
+    [
+      completedAt,
+      fetchPlayerAndCharacter,
+      logOfflineActivity,
+      onLogged,
+      selectedTaskId,
+      taskName,
+      totalDurationMinutes,
+      validate,
+    ]
+  );
+
+  return {
+    taskName,
+    handleTaskNameChange,
+    handleTaskSelect,
+    durationHours,
+    setDurationHours,
+    durationMinutes,
+    setDurationMinutes,
+    totalDurationMinutes,
+    completionDate,
+    handleCompletionDateChange,
+    completionTime,
+    handleCompletionTimeChange,
+    maxCompletionDate,
+    fieldErrors,
+    submitError,
+    result,
+    eligibility,
+    isSubmitting: logOfflineActivity.isPending,
+    handleSubmit,
+    reset,
+  };
+}
diff --git a/frontend/src/components/Map/Map.test.tsx b/frontend/src/components/Map/Map.test.tsx
index 33f39f40..c17e6d9c 100644
--- a/frontend/src/components/Map/Map.test.tsx
+++ b/frontend/src/components/Map/Map.test.tsx
@@ -1165,7 +1165,6 @@ describe('PopulationCentreMap entity detail card', () => {
     const dialog = await screen.findByRole('dialog', { name: 'House 2' });
     expect(dialog).toHaveTextContent('1 / 4');
     expect(dialog).toHaveTextContent('Alice');
-    expect(dialog).toHaveTextContent('idle');
   });
 
   it('switches to a resident\'s own detail card when clicked inside the building detail card', async () => {
diff --git a/frontend/src/components/Modal/Modal.module.scss b/frontend/src/components/Modal/Modal.module.scss
index 0ca97f77..6022ecb9 100644
--- a/frontend/src/components/Modal/Modal.module.scss
+++ b/frontend/src/components/Modal/Modal.module.scss
@@ -53,8 +53,7 @@
   overflow-y: auto;
   overflow-x: hidden;
   min-height: 0;
-  padding-top: sp.$spacing-md;
-  padding-bottom: sp.$spacing-md;
+  padding: sp.$spacing-md sp.$spacing-sm;
   @include tc.two-column-layout;
 
   justify-content: flex-start;
diff --git a/frontend/src/components/PlayerItemList/PlayerItemList.module.scss b/frontend/src/components/PlayerItemList/PlayerItemList.module.scss
index 87e9fd30..d577afcd 100644
--- a/frontend/src/components/PlayerItemList/PlayerItemList.module.scss
+++ b/frontend/src/components/PlayerItemList/PlayerItemList.module.scss
@@ -156,19 +156,12 @@
   }
 }
 
-.childList {
-  list-style: none;
-  margin: sp.$spacing-xs 0 0;
-  padding: 0 0 0 sp.$spacing-lg;
-  display: flex;
-  flex-direction: column;
-  gap: sp.$spacing-xs;
-}
-
 .childItem {
-  background: transparent;
-  border-color: rgba(c.$color-border-primary, 0.12);
-  opacity: 0.9;
+  // Shrink width by the indent instead of just shifting it, so the right
+  // edge still lines up with the parent's — .listItem's width: 100% would
+  // otherwise push the box that far past the parent's right edge.
+  width: calc(100% - #{sp.$spacing-lg});
+  margin-left: sp.$spacing-lg;
 }
 
 .itemCompleted {
@@ -235,9 +228,10 @@
 .editInput {
   flex: 1;
   min-width: 0;
+  height: sp.$form-control-height;
   padding: sp.$spacing-xs sp.$spacing-sm;
   border: 2px solid rgba(c.$color-status-success, 0.45);
-  border-radius: sp.$border-radius;
+  border-radius: sp.$form-control-radius;
   font-size: 1em;
   font-family: inherit;
   transition: border-color 0.2s ease;
@@ -259,6 +253,7 @@
 }
 
 .editConfirmActions {
+  position: relative;
   display: flex;
   justify-content: flex-start;
   align-items: center;
@@ -290,3 +285,45 @@
   color: rgba(0, 0, 0, 0.65);
   @include t.apply-text-style(t.$text-caption);
 }
+
+.saveStatus {
+  position: absolute;
+  right: 0;
+  top: 50%;
+  transform: translateY(-50%);
+  padding: sp.$spacing-xs sp.$spacing-sm;
+  border-radius: sp.$border-radius;
+  border: 1px solid rgba(c.$color-border-primary, 0.4);
+  background: rgba(c.$color-bg, 0.95);
+  box-shadow: 0 2px 8px rgba(0, 0, 0, 0.25);
+  pointer-events: none;
+  z-index: 1;
+  font-weight: 600;
+  @include t.apply-text-style(t.$text-caption);
+  animation: saveStatusFadeIn 0.15s ease;
+}
+
+.saveStatus-saving {
+  color: rgba(0, 0, 0, 0.6);
+}
+
+.saveStatus-saved {
+  color: c.$color-status-success;
+  animation: saveStatusFadeInOut #{2500ms} ease forwards;
+}
+
+.saveStatus-error {
+  color: c.$color-status-danger;
+}
+
+@keyframes saveStatusFadeIn {
+  from { opacity: 0; }
+  to { opacity: 1; }
+}
+
+@keyframes saveStatusFadeInOut {
+  0% { opacity: 0; }
+  10% { opacity: 1; }
+  80% { opacity: 1; }
+  100% { opacity: 0; }
+}
diff --git a/frontend/src/components/PlayerItemList/PlayerItemList.test.tsx b/frontend/src/components/PlayerItemList/PlayerItemList.test.tsx
index 682abdd2..6142c2df 100644
--- a/frontend/src/components/PlayerItemList/PlayerItemList.test.tsx
+++ b/frontend/src/components/PlayerItemList/PlayerItemList.test.tsx
@@ -26,7 +26,7 @@ describe("PlayerItemList", () => {
     expect(screen.getByText("Duration: 15m • 15 XP gained")).toBeInTheDocument();
   });
 
-  it("opens the edit modal and saves a trimmed name", async () => {
+  it("autosaves a trimmed name on blur", async () => {
     const user = userEvent.setup();
     const onEdit = vi.fn();
 
@@ -43,10 +43,57 @@ describe("PlayerItemList", () => {
     const input = screen.getByLabelText("activity name");
     await user.clear(input);
     await user.type(input, "  Deep work  ");
-    await user.click(screen.getByRole("button", { name: "Save" }));
+    await user.tab();
 
-    expect(onEdit).toHaveBeenCalledWith(items[0], "Deep work");
-    expect(screen.queryByRole("dialog")).not.toBeInTheDocument();
+    expect(onEdit).toHaveBeenCalledWith(
+      items[0],
+      "Deep work",
+      expect.objectContaining({ onSuccess: expect.any(Function), onError: expect.any(Function) }),
+    );
+    // Autosave doesn't close the modal — there's no explicit Save action anymore.
+    expect(screen.getByRole("dialog")).toBeInTheDocument();
+  });
+
+  it("does not re-fire the save when blurring without changing the name", async () => {
+    const user = userEvent.setup();
+    const onEdit = vi.fn();
+
+    render(
+      <PlayerItemList items={items} itemLabel="activity" onEdit={onEdit} />,
+    );
+
+    await user.click(screen.getByRole("button", { name: "Open activity Write docs" }));
+    const input = screen.getByLabelText("activity name");
+    await user.click(input);
+    await user.tab();
+
+    expect(onEdit).not.toHaveBeenCalled();
+  });
+
+  it("shows a Saved indicator once the autosave succeeds, then shows a warning on failure", async () => {
+    const user = userEvent.setup();
+    const onEdit = vi.fn((_item, _name, callbacks) => callbacks?.onSuccess?.());
+
+    const { rerender } = render(
+      <PlayerItemList items={items} itemLabel="activity" onEdit={onEdit} />,
+    );
+
+    await user.click(screen.getByRole("button", { name: "Open activity Write docs" }));
+    const input = screen.getByLabelText("activity name");
+    await user.clear(input);
+    await user.type(input, "Deep work");
+    await user.tab();
+
+    expect(await screen.findByText("Saved")).toBeInTheDocument();
+
+    const failingOnEdit = vi.fn((_item, _name, callbacks) => callbacks?.onError?.());
+    rerender(<PlayerItemList items={items} itemLabel="activity" onEdit={failingOnEdit} />);
+
+    await user.clear(input);
+    await user.type(input, "Deeper work");
+    await user.tab();
+
+    expect(await screen.findByText("Couldn't save — try again")).toBeInTheDocument();
   });
 
   it("opens the delete modal and confirms deletion", async () => {
@@ -154,7 +201,7 @@ describe("PlayerItemList", () => {
     const child = { id: 11, name: "Child task" };
     const flatItems = [parent, child];
 
-    it("renders children nested under their parent without a top-level row", () => {
+    it("renders children as independent rows, indented, directly after their parent", () => {
       render(
         <PlayerItemList
           items={flatItems}
@@ -165,8 +212,15 @@ describe("PlayerItemList", () => {
 
       expect(screen.getByRole("button", { name: "Open task Parent task" })).toBeInTheDocument();
       expect(screen.getByRole("button", { name: "Open task Child task" })).toBeInTheDocument();
-      // The child is not rendered as its own top-level list item.
+      // The child is not duplicated as a second top-level entry sourced from `items`.
       expect(screen.getAllByRole("button", { name: /^Open task / })).toHaveLength(2);
+
+      // Both render as siblings within the list, not one nested inside the other.
+      const rows = screen.getAllByRole("listitem");
+      expect(rows).toHaveLength(2);
+      expect(rows[0]).toHaveTextContent("Parent task");
+      expect(rows[1]).toHaveTextContent("Child task");
+      expect(within(rows[0]).queryByText("Child task")).not.toBeInTheDocument();
     });
 
     it("is unaffected when getChildren is not passed (ProjectsPanel-style usage)", () => {
diff --git a/frontend/src/components/PlayerItemList/PlayerItemList.tsx b/frontend/src/components/PlayerItemList/PlayerItemList.tsx
index 53356cc3..9d0f2e9c 100644
--- a/frontend/src/components/PlayerItemList/PlayerItemList.tsx
+++ b/frontend/src/components/PlayerItemList/PlayerItemList.tsx
@@ -3,10 +3,12 @@ import classNames from "classnames";
 
 import Button from "../Button/Button";
 import List from "../List/List";
-import Li from "../List/Li";
 import Modal from "../Modal/Modal";
+import SaveStatusIndicator from "./SaveStatusIndicator";
 import { usePlayerItemListControls } from "./usePlayerItemListControls";
 import { usePlayerItemModal } from "./usePlayerItemModal";
+import type { SaveCallbacks } from "./usePlayerItemModal";
+import type { SaveStatusHelpers } from "./useSaveStatus";
 import styles from "./PlayerItemList.module.scss";
 
 export interface SortOption<T> {
@@ -30,8 +32,8 @@ interface PlayerItemListProps<T extends { id?: string | number; name?: string }>
   onToggleComplete?: (item: T) => void;
   getItemKey?: (item: T, index: number) => string | number;
   renderItemMeta?: (item: T) => React.ReactNode;
-  renderEditSummary?: (item: T) => React.ReactNode;
-  onEdit?: (item: T, name: string) => void;
+  renderEditSummary?: (item: T, saveHelpers: SaveStatusHelpers) => React.ReactNode;
+  onEdit?: (item: T, name: string, callbacks?: SaveCallbacks) => void;
   onDelete?: (item: T) => void;
   hoverEdit?: boolean;
   renderRowActions?: (item: T) => React.ReactNode;
@@ -92,6 +94,7 @@ export default function PlayerItemList<T extends { id?: string | number; name?:
     liveActiveItem,
     editingName,
     confirmingDelete,
+    saveStatus,
     activeItemName,
     modalSummary,
     setEditingName,
@@ -137,11 +140,15 @@ export default function PlayerItemList<T extends { id?: string | number; name?:
     return ids;
   }, [items, getChildren]);
 
-  const topLevelDisplayItems = useMemo(() => {
+  // Sort/filter controls only apply to top-level items; a child keeps its
+  // place directly after its parent (in `getChildren`'s order) rather than
+  // being reordered independently.
+  const flatDisplayItems = useMemo(() => {
     if (!getChildren) return displayItems;
-    return displayItems.filter(
+    const topLevel = displayItems.filter(
       (item) => item.id === undefined || !childIds.has(item.id)
     );
+    return topLevel.flatMap((item) => [item, ...(getChildren(item) ?? [])]);
   }, [displayItems, getChildren, childIds]);
 
   const renderRow = (item: T): React.ReactNode => (
@@ -252,7 +259,7 @@ export default function PlayerItemList<T extends { id?: string | number; name?:
       ) : null}
       <div className={styles.listScroll}>
       <List
-        items={topLevelDisplayItems}
+        items={flatDisplayItems}
         ariaLabel={ariaLabel}
         canHover
         className={classNames(styles.list, listClassName)}
@@ -260,31 +267,11 @@ export default function PlayerItemList<T extends { id?: string | number; name?:
         getKey={getItemKey}
         getItemClassName={(item) =>
           classNames(styles.item, {
+            [styles.childItem]: item.id !== undefined && childIds.has(item.id),
             [styles.itemCompleted]: isItemComplete?.(item),
           })
         }
-        renderItem={(item) => {
-          const children = getChildren?.(item);
-          return (
-            <>
-              {renderRow(item)}
-              {children?.length ? (
-                <ul className={styles.childList}>
-                  {children.map((child, index) => (
-                    <Li
-                      key={(child.id as string | number | undefined) ?? index}
-                      className={classNames(styles.item, styles.childItem, {
-                        [styles.itemCompleted]: isItemComplete?.(child),
-                      })}
-                    >
-                      {renderRow(child)}
-                    </Li>
-                  ))}
-                </ul>
-              ) : null}
-            </>
-          );
-        }}
+        renderItem={(item) => renderRow(item)}
       />
       </div>
 
@@ -337,6 +324,7 @@ export default function PlayerItemList<T extends { id?: string | number; name?:
                       aria-label={`${itemLabel} name`}
                       value={editingName}
                       onChange={(event) => setEditingName(event.target.value)}
+                      onBlur={handleEditSave}
                       autoFocus
                       onKeyDown={(event) => {
                         if (event.key === "Enter") handleEditSave();
@@ -350,19 +338,15 @@ export default function PlayerItemList<T extends { id?: string | number; name?:
                 <div className={styles.editConfirmMeta}>{modalSummary}</div>
               ) : null}
               <div className={styles.editConfirmActions}>
-                {canEdit ? (
-                  <Button variant="primary" onClick={handleEditSave}>
-                    Save
-                  </Button>
-                ) : null}
                 <Button variant="secondary" onClick={handleModalClose}>
-                  {canEdit ? "Cancel" : "Close"}
+                  Close
                 </Button>
                 {canDelete ? (
                   <Button variant="secondaryDanger" onClick={handleDeleteRequest}>
                     Delete
                   </Button>
                 ) : null}
+                <SaveStatusIndicator status={saveStatus} />
               </div>
             </div>
           )}
diff --git a/frontend/src/components/PlayerItemList/SaveStatusIndicator.tsx b/frontend/src/components/PlayerItemList/SaveStatusIndicator.tsx
new file mode 100644
index 00000000..abe08832
--- /dev/null
+++ b/frontend/src/components/PlayerItemList/SaveStatusIndicator.tsx
@@ -0,0 +1,27 @@
+import classNames from "classnames";
+import type { SaveStatus } from "./useSaveStatus";
+import styles from "./PlayerItemList.module.scss";
+
+interface SaveStatusIndicatorProps {
+  status: SaveStatus;
+}
+
+const STATUS_TEXT: Record<Exclude<SaveStatus, "idle">, string> = {
+  saving: "Saving…",
+  saved: "Saved",
+  error: "Couldn't save — try again",
+};
+
+export default function SaveStatusIndicator({ status }: SaveStatusIndicatorProps) {
+  if (status === "idle") return null;
+
+  return (
+    <div
+      className={classNames(styles.saveStatus, styles[`saveStatus-${status}`])}
+      role={status === "error" ? "alert" : "status"}
+      aria-live="polite"
+    >
+      {STATUS_TEXT[status]}
+    </div>
+  );
+}
diff --git a/frontend/src/components/PlayerItemList/usePlayerItemModal.ts b/frontend/src/components/PlayerItemList/usePlayerItemModal.ts
index 8884a21f..4e552cda 100644
--- a/frontend/src/components/PlayerItemList/usePlayerItemModal.ts
+++ b/frontend/src/components/PlayerItemList/usePlayerItemModal.ts
@@ -1,11 +1,18 @@
-import { useCallback, useMemo, useState } from "react";
+import { useCallback, useMemo, useRef, useState } from "react";
+
+import { useSaveStatus, type SaveStatusHelpers } from "./useSaveStatus";
+
+export interface SaveCallbacks {
+  onSuccess?: () => void;
+  onError?: () => void;
+}
 
 interface UsePlayerItemModalProps<T extends { id?: string | number; name?: string }> {
   items: T[];
   getItemName: (item: T) => string;
   renderItemMeta?: (item: T) => React.ReactNode;
-  renderEditSummary?: (item: T) => React.ReactNode;
-  onEdit?: (item: T, name: string) => void;
+  renderEditSummary?: (item: T, saveHelpers: SaveStatusHelpers) => React.ReactNode;
+  onEdit?: (item: T, name: string, callbacks?: SaveCallbacks) => void;
   onDelete?: (item: T) => void;
 }
 
@@ -20,34 +27,55 @@ export function usePlayerItemModal<T extends { id?: string | number; name?: stri
   const [activeItem, setActiveItem] = useState<T | null>(null);
   const [editingName, setEditingName] = useState("");
   const [confirmingDelete, setConfirmingDelete] = useState(false);
+  // Tracks the last name we've committed (or started committing) a save
+  // for, so blur/Enter only fire a request when the name actually changed.
+  const lastSavedNameRef = useRef("");
+
+  const { saveStatus, reportSaving, reportSaved, reportError, resetSaveStatus } = useSaveStatus();
 
   const handleOpenItem = useCallback(
     (item: T) => {
       setActiveItem(item);
-      setEditingName(getItemName(item));
+      const name = getItemName(item);
+      setEditingName(name);
+      lastSavedNameRef.current = name;
+      resetSaveStatus();
     },
-    [getItemName],
+    [getItemName, resetSaveStatus],
   );
 
   const handleModalClose = useCallback(() => {
     setActiveItem(null);
     setEditingName("");
     setConfirmingDelete(false);
-  }, []);
+    resetSaveStatus();
+  }, [resetSaveStatus]);
 
-  const handleEditSave = useCallback(() => {
+  // Autosaves the name field. Fires on blur (and Enter) rather than on
+  // every keystroke, mirroring the due-date field's commit-on-blur pattern.
+  const commitNameEdit = useCallback(() => {
     if (!activeItem || !onEdit) {
       return;
     }
 
     const trimmedName = editingName.trim();
-    if (!trimmedName) {
+    if (!trimmedName || trimmedName === lastSavedNameRef.current) {
       return;
     }
 
-    onEdit(activeItem, trimmedName);
-    handleModalClose();
-  }, [activeItem, editingName, onEdit, handleModalClose]);
+    lastSavedNameRef.current = trimmedName;
+    reportSaving();
+    onEdit(activeItem, trimmedName, {
+      onSuccess: reportSaved,
+      onError: reportError,
+    });
+  }, [activeItem, editingName, onEdit, reportSaving, reportSaved, reportError]);
+
+  // handleEditSave is kept as the exported name for the commit action
+  // (bound to the name input's blur/Enter handlers) since it's still the
+  // thing that saves the edit — there's just no explicit "Save" button
+  // triggering it anymore.
+  const handleEditSave = commitNameEdit;
 
   const handleDeleteRequest = useCallback(() => {
     setConfirmingDelete(true);
@@ -82,23 +110,29 @@ export function usePlayerItemModal<T extends { id?: string | number; name?: stri
     [liveActiveItem, getItemName],
   );
 
+  const saveHelpers = useMemo<SaveStatusHelpers>(
+    () => ({ reportSaving, reportSaved, reportError }),
+    [reportSaving, reportSaved, reportError],
+  );
+
   const modalSummary = useMemo(() => {
     if (!liveActiveItem) {
       return null;
     }
 
     return (
-      renderEditSummary?.(liveActiveItem) ??
+      renderEditSummary?.(liveActiveItem, saveHelpers) ??
       renderItemMeta?.(liveActiveItem) ??
       null
     );
-  }, [liveActiveItem, renderEditSummary, renderItemMeta]);
+  }, [liveActiveItem, renderEditSummary, renderItemMeta, saveHelpers]);
 
   return {
     activeItem,
     liveActiveItem,
     editingName,
     confirmingDelete,
+    saveStatus,
 
     activeItemName,
     modalSummary,
diff --git a/frontend/src/components/PlayerItemList/useSaveStatus.ts b/frontend/src/components/PlayerItemList/useSaveStatus.ts
new file mode 100644
index 00000000..077f03da
--- /dev/null
+++ b/frontend/src/components/PlayerItemList/useSaveStatus.ts
@@ -0,0 +1,77 @@
+import { useCallback, useEffect, useRef, useState } from "react";
+
+export type SaveStatus = "idle" | "saving" | "saved" | "error";
+
+export interface SaveStatusHelpers {
+  reportSaving: () => void;
+  reportSaved: () => void;
+  reportError: () => void;
+}
+
+const SAVED_DISPLAY_MS = 2500;
+// Saves usually resolve fast enough that "Saving…" would just flash on
+// screen; only show it once a save has been pending this long.
+const SAVING_DISPLAY_DELAY_MS = 150;
+
+/**
+ * Tracks a single in-flight autosave's status so a modal can show a brief
+ * "Saved"/"Couldn't save" indicator. "saved" auto-clears after a few
+ * seconds; "error" persists until the next save attempt or a manual reset,
+ * since a missed save is worse than a lingering banner.
+ */
+export function useSaveStatus() {
+  const [saveStatus, setSaveStatus] = useState<SaveStatus>("idle");
+  const hideTimerRef = useRef<ReturnType<typeof setTimeout> | null>(null);
+  const savingTimerRef = useRef<ReturnType<typeof setTimeout> | null>(null);
+
+  const clearHideTimer = useCallback(() => {
+    if (hideTimerRef.current) {
+      clearTimeout(hideTimerRef.current);
+      hideTimerRef.current = null;
+    }
+  }, []);
+
+  const clearSavingTimer = useCallback(() => {
+    if (savingTimerRef.current) {
+      clearTimeout(savingTimerRef.current);
+      savingTimerRef.current = null;
+    }
+  }, []);
+
+  const reportSaving = useCallback(() => {
+    clearHideTimer();
+    clearSavingTimer();
+    savingTimerRef.current = setTimeout(() => {
+      savingTimerRef.current = null;
+      setSaveStatus("saving");
+    }, SAVING_DISPLAY_DELAY_MS);
+  }, [clearHideTimer, clearSavingTimer]);
+
+  const reportSaved = useCallback(() => {
+    clearHideTimer();
+    clearSavingTimer();
+    setSaveStatus("saved");
+    hideTimerRef.current = setTimeout(() => setSaveStatus("idle"), SAVED_DISPLAY_MS);
+  }, [clearHideTimer, clearSavingTimer]);
+
+  const reportError = useCallback(() => {
+    clearHideTimer();
+    clearSavingTimer();
+    setSaveStatus("error");
+  }, [clearHideTimer, clearSavingTimer]);
+
+  const resetSaveStatus = useCallback(() => {
+    clearHideTimer();
+    clearSavingTimer();
+    setSaveStatus("idle");
+  }, [clearHideTimer, clearSavingTimer]);
+
+  useEffect(() => {
+    return () => {
+      clearHideTimer();
+      clearSavingTimer();
+    };
+  }, [clearHideTimer, clearSavingTimer]);
+
+  return { saveStatus, reportSaving, reportSaved, reportError, resetSaveStatus };
+}
diff --git a/frontend/src/components/ProjectsPanel/ProjectsPanel.test.tsx b/frontend/src/components/ProjectsPanel/ProjectsPanel.test.tsx
index 2adb9039..be0a916f 100644
--- a/frontend/src/components/ProjectsPanel/ProjectsPanel.test.tsx
+++ b/frontend/src/components/ProjectsPanel/ProjectsPanel.test.tsx
@@ -77,16 +77,16 @@ describe("ProjectsPanel", () => {
     const input = screen.getByLabelText("project name");
     await user.clear(input);
     await user.type(input, "Platform refresh");
-    await user.click(screen.getByRole("button", { name: "Save" }));
+    await user.tab();
 
     await waitFor(() => {
-      expect(updateMutate).toHaveBeenCalledWith({
-        id: 1,
-        data: { name: "Platform refresh" },
-      });
+      expect(updateMutate).toHaveBeenCalledWith(
+        { id: 1, data: { name: "Platform refresh" } },
+        expect.objectContaining({ onSuccess: expect.any(Function), onError: expect.any(Function) }),
+      );
     });
 
-    await user.click(screen.getByRole("button", { name: "Open project Website overhaul" }));
+    // The modal stays open after an autosave — no explicit Save click to close it.
     await user.click(within(screen.getByRole("dialog")).getByRole("button", { name: "Delete" }));
     await user.click(within(screen.getByRole("dialog")).getByRole("button", { name: "Delete" }));
 
diff --git a/frontend/src/components/SkillsPanel/SkillsPanel.test.tsx b/frontend/src/components/SkillsPanel/SkillsPanel.test.tsx
index 50d3b3ec..a927c541 100644
--- a/frontend/src/components/SkillsPanel/SkillsPanel.test.tsx
+++ b/frontend/src/components/SkillsPanel/SkillsPanel.test.tsx
@@ -44,13 +44,13 @@ describe("SkillsPanel", () => {
     const input = screen.getByLabelText("skill name");
     await user.clear(input);
     await user.type(input, "Research");
-    await user.click(screen.getByRole("button", { name: "Save" }));
+    await user.tab();
 
     await waitFor(() => {
-      expect(updateMutate).toHaveBeenCalledWith({
-        id: 1,
-        data: { name: "Research" },
-      });
+      expect(updateMutate).toHaveBeenCalledWith(
+        { id: 1, data: { name: "Research" } },
+        expect.objectContaining({ onSuccess: expect.any(Function), onError: expect.any(Function) }),
+      );
     });
   });
 
diff --git a/frontend/src/components/TasksPanel/TasksPanel.test.tsx b/frontend/src/components/TasksPanel/TasksPanel.test.tsx
index 5671697c..6ddb5e8f 100644
--- a/frontend/src/components/TasksPanel/TasksPanel.test.tsx
+++ b/frontend/src/components/TasksPanel/TasksPanel.test.tsx
@@ -284,13 +284,13 @@ describe("TasksPanel", () => {
     const input = screen.getByLabelText("task name");
     await user.clear(input);
     await user.type(input, "Evening routine");
-    await user.click(within(screen.getByRole("dialog")).getByRole("button", { name: "Save" }));
+    await user.tab();
 
     await waitFor(() => {
-      expect(updateMutate).toHaveBeenCalledWith({
-        id: 1,
-        data: { name: "Evening routine" },
-      });
+      expect(updateMutate).toHaveBeenCalledWith(
+        { id: 1, data: { name: "Evening routine" } },
+        expect.objectContaining({ onSuccess: expect.any(Function), onError: expect.any(Function) }),
+      );
     });
   });
 
@@ -325,7 +325,7 @@ describe("TasksPanel", () => {
       total_records: 0,
     };
 
-    it("renders a subtask nested under its parent", () => {
+    it("renders a subtask as an independent, indented row directly after its parent", () => {
       mockUseTasks.mockReturnValue({
         isLoading: false,
         data: [parentTask, childTask],
@@ -336,9 +336,14 @@ describe("TasksPanel", () => {
       const childButton = screen.getAllByRole("button", { name: "Edit task Child subtask" })[0];
       expect(parentButton).toBeInTheDocument();
       expect(childButton).toBeInTheDocument();
-      // The subtask is nested inside the parent's <li>, not a sibling top-level row.
+      // The subtask is its own sibling row, not nested inside the parent's <li>.
       const parentListItem = parentButton.closest("li");
-      expect(parentListItem).toContainElement(childButton);
+      const childListItem = childButton.closest("li");
+      expect(parentListItem).not.toBe(childListItem);
+      expect(parentListItem).not.toContainElement(childButton);
+
+      const rows = screen.getAllByRole("listitem");
+      expect(rows.indexOf(childListItem!)).toBe(rows.indexOf(parentListItem!) + 1);
     });
 
     it("hides a completed parent and its subtasks together", () => {
@@ -405,10 +410,10 @@ describe("TasksPanel", () => {
       await user.tab();
 
       await waitFor(() => {
-        expect(updateMutate).toHaveBeenCalledWith({
-          id: 1,
-          data: { due_at: expect.any(String) },
-        });
+        expect(updateMutate).toHaveBeenCalledWith(
+          { id: 1, data: { due_at: expect.any(String) } },
+          expect.objectContaining({ onSuccess: expect.any(Function), onError: expect.any(Function) }),
+        );
       });
     });
   });
diff --git a/frontend/src/components/TasksPanel/TasksPanel.tsx b/frontend/src/components/TasksPanel/TasksPanel.tsx
index e8d64ca0..3da46e7a 100644
--- a/frontend/src/components/TasksPanel/TasksPanel.tsx
+++ b/frontend/src/components/TasksPanel/TasksPanel.tsx
@@ -107,7 +107,7 @@ export default function TasksPanel({
               </>
             );
           }}
-          renderEditSummary={(taskItem) => {
+          renderEditSummary={(taskItem, saveHelpers) => {
             const summary = getTaskEditSummary(taskItem);
             const hasSubtasks = (taskItem.subtask_count ?? 0) > 0;
             const parentOptions = topLevelTasks.filter((t) => t.id !== taskItem.id);
@@ -162,58 +162,68 @@ export default function TasksPanel({
                     type="datetime-local"
                     className={styles.dueDateInput}
                     defaultValue={toDatetimeLocalValue(taskItem.due_at)}
-                    onBlur={(event) =>
-                      updateTask.mutate({
-                        id: taskItem.id,
-                        data: { due_at: fromDatetimeLocalValue(event.target.value) },
-                      })
-                    }
+                    onBlur={(event) => {
+                      saveHelpers.reportSaving();
+                      updateTask.mutate(
+                        {
+                          id: taskItem.id,
+                          data: { due_at: fromDatetimeLocalValue(event.target.value) },
+                        },
+                        { onSuccess: saveHelpers.reportSaved, onError: saveHelpers.reportError },
+                      );
+                    }}
                   />
                   {taskItem.due_at && (
                     <Button
                       variant="secondary"
-                      onClick={() =>
-                        updateTask.mutate({ id: taskItem.id, data: { due_at: null } })
-                      }
+                      onClick={() => {
+                        saveHelpers.reportSaving();
+                        updateTask.mutate(
+                          { id: taskItem.id, data: { due_at: null } },
+                          { onSuccess: saveHelpers.reportSaved, onError: saveHelpers.reportError },
+                        );
+                      }}
                     >
                       Clear
                     </Button>
                   )}
                 </div>
-                {taskItem.parent == null && (
-                  <div className={styles.parentRow}>
-                    <label className={styles.timestampLabel} htmlFor="task-parent">
-                      Parent task
-                    </label>
-                    <Tooltip
-                      content={
-                        hasSubtasks
-                          ? "This task already has subtasks and can't be nested under another task."
-                          : undefined
-                      }
-                    >
-                      <select
-                        id="task-parent"
-                        className={styles.parentSelect}
-                        disabled={hasSubtasks}
-                        defaultValue={taskItem.parent ?? ""}
-                        onChange={(event) =>
-                          updateTask.mutate({
+                <div className={styles.parentRow}>
+                  <label className={styles.timestampLabel} htmlFor="task-parent">
+                    Parent task
+                  </label>
+                  <Tooltip
+                    content={
+                      hasSubtasks
+                        ? "This task already has subtasks and can't be nested under another task."
+                        : undefined
+                    }
+                  >
+                    <select
+                      id="task-parent"
+                      className={styles.parentSelect}
+                      disabled={hasSubtasks}
+                      defaultValue={taskItem.parent ?? ""}
+                      onChange={(event) => {
+                        saveHelpers.reportSaving();
+                        updateTask.mutate(
+                          {
                             id: taskItem.id,
                             data: { parent: event.target.value ? Number(event.target.value) : null },
-                          })
-                        }
-                      >
-                        <option value="">No parent</option>
-                        {parentOptions.map((option) => (
-                          <option key={option.id} value={option.id}>
-                            {option.name}
-                          </option>
-                        ))}
-                      </select>
-                    </Tooltip>
-                  </div>
-                )}
+                          },
+                          { onSuccess: saveHelpers.reportSaved, onError: saveHelpers.reportError },
+                        );
+                      }}
+                    >
+                      <option value="">No parent</option>
+                      {parentOptions.map((option) => (
+                        <option key={option.id} value={option.id}>
+                          {option.name}
+                        </option>
+                      ))}
+                    </select>
+                  </Tooltip>
+                </div>
               </>
             );
           }}
diff --git a/frontend/src/components/TasksPanel/useTasksPanel.tsx b/frontend/src/components/TasksPanel/useTasksPanel.tsx
index 9da699f5..af963a66 100644
--- a/frontend/src/components/TasksPanel/useTasksPanel.tsx
+++ b/frontend/src/components/TasksPanel/useTasksPanel.tsx
@@ -245,15 +245,8 @@ export function useTasksPanel(openTaskId?: number | null, onOpenNote?: (noteId:
   }, []);
 
   const handleEdit = useCallback(
-    (task: ItemRecord, name: string, options?: { parent?: number | null; due_at?: string | null }) => {
-      updateTask.mutate({
-        id: task.id,
-        data: {
-          name,
-          ...(options?.parent !== undefined ? { parent: options.parent } : {}),
-          ...(options?.due_at !== undefined ? { due_at: options.due_at } : {}),
-        },
-      });
+    (task: ItemRecord, name: string, callbacks?: { onSuccess?: () => void; onError?: () => void }) => {
+      updateTask.mutate({ id: task.id, data: { name } }, callbacks);
     },
     [updateTask]
   );
diff --git a/frontend/src/components/TodayPointsBadge/TodayPointsBadge.module.scss b/frontend/src/components/TodayPointsBadge/TodayPointsBadge.module.scss
deleted file mode 100644
index 905ae3fe..00000000
--- a/frontend/src/components/TodayPointsBadge/TodayPointsBadge.module.scss
+++ /dev/null
@@ -1,12 +0,0 @@
-@use '../../styles/semantic/colors' as c;
-@use '../../styles/semantic/typography' as t;
-@use '../../styles/semantic/spacing' as sp;
-
-.badge {
-  background: c.$color-bg;
-  border: 1px solid c.$color-border-primary;
-  border-radius: sp.$border-radius;
-  padding: 0.25rem 0.6rem;
-  white-space: nowrap;
-  @include t.apply-text-style(t.$text-body);
-}
diff --git a/frontend/src/components/TodayPointsBadge/TodayPointsBadge.test.tsx b/frontend/src/components/TodayPointsBadge/TodayPointsBadge.test.tsx
deleted file mode 100644
index c2c50430..00000000
--- a/frontend/src/components/TodayPointsBadge/TodayPointsBadge.test.tsx
+++ /dev/null
@@ -1,46 +0,0 @@
-import { render, screen } from '@testing-library/react';
-import { describe, expect, it, vi } from 'vitest';
-
-import TodayPointsBadge from './TodayPointsBadge';
-
-const mockUseTodayPoints = vi.fn<() => { data: { points_today: number | null } | undefined }>(
-  () => ({ data: { points_today: 12 } })
-);
-
-vi.mock('../../hooks/usePlayer', () => ({
-  useTodayPoints: () => mockUseTodayPoints(),
-}));
-
-describe('TodayPointsBadge', () => {
-  it("shows the player's points earned today", () => {
-    mockUseTodayPoints.mockReturnValue({ data: { points_today: 12 } });
-
-    render(<TodayPointsBadge />);
-
-    expect(screen.getByText('You contributed 12 today')).toBeInTheDocument();
-  });
-
-  it('renders nothing when the player has no active character link', () => {
-    mockUseTodayPoints.mockReturnValue({ data: { points_today: null } });
-
-    const { container } = render(<TodayPointsBadge />);
-
-    expect(container).toBeEmptyDOMElement();
-  });
-
-  it('renders nothing (not a zero) while the query has no data yet', () => {
-    mockUseTodayPoints.mockReturnValue({ data: undefined });
-
-    const { container } = render(<TodayPointsBadge />);
-
-    expect(container).toBeEmptyDOMElement();
-  });
-
-  it('shows zero points as a real value, not treating it as "no link"', () => {
-    mockUseTodayPoints.mockReturnValue({ data: { points_today: 0 } });
-
-    render(<TodayPointsBadge />);
-
-    expect(screen.getByText('You contributed 0 today')).toBeInTheDocument();
-  });
-});
diff --git a/frontend/src/components/TodayPointsBadge/TodayPointsBadge.tsx b/frontend/src/components/TodayPointsBadge/TodayPointsBadge.tsx
deleted file mode 100644
index c2cb5cc4..00000000
--- a/frontend/src/components/TodayPointsBadge/TodayPointsBadge.tsx
+++ /dev/null
@@ -1,23 +0,0 @@
-import React from "react";
-import { useTodayPoints } from "../../hooks/usePlayer";
-import styles from "./TodayPointsBadge.module.scss";
-
-// Personal "points earned today" badge for the map view (issue #673) -
-// deliberately not attached to any village marker, and deliberately silent
-// about the player/character link: framed as "you contributed today" rather
-// than naming a character, since players don't yet know about the link.
-// Renders nothing (not a zero) when the player has no active
-// PlayerCharacterLink - see MeViewSet.today_points in api/views.py.
-export default function TodayPointsBadge(): React.ReactElement | null {
-  const { data } = useTodayPoints();
-
-  if (data?.points_today == null) {
-    return null;
-  }
-
-  return (
-    <div className={styles.badge} aria-live="polite" role="status">
-      You contributed {data.points_today} today
-    </div>
-  );
-}
diff --git a/frontend/src/components/UnifiedTimerHome/UnifiedTimerHome.module.scss b/frontend/src/components/UnifiedTimerHome/UnifiedTimerHome.module.scss
index 2793e6af..db2234e2 100644
--- a/frontend/src/components/UnifiedTimerHome/UnifiedTimerHome.module.scss
+++ b/frontend/src/components/UnifiedTimerHome/UnifiedTimerHome.module.scss
@@ -4,7 +4,7 @@
 @use '../../styles/semantic/spacing' as sp;
 @use 'sass:map';
 
-$row-control-height: 44px;
+$row-control-height: sp.$form-control-height;
 
 .wrapper {
   position: relative;
@@ -180,25 +180,13 @@ $row-control-height: 44px;
 }
 
 @include m.respond-to(md, down) {
-  .timerPill,
-  .ctaButton {
-    height: 40px;
-  }
-
   .inputText {
-    height: 40px;
     font-size: 1rem;
   }
 }
 
 @include m.respond-to(sm, down) {
-  .timerPill,
-  .ctaButton {
-    height: 38px;
-  }
-
   .inputText {
-    height: 38px;
     font-size: 0.9rem;
   }
 }
diff --git a/frontend/src/components/UnifiedTimerHome/UnifiedTimerHome.tsx b/frontend/src/components/UnifiedTimerHome/UnifiedTimerHome.tsx
index 8065af35..7b0b5b88 100644
--- a/frontend/src/components/UnifiedTimerHome/UnifiedTimerHome.tsx
+++ b/frontend/src/components/UnifiedTimerHome/UnifiedTimerHome.tsx
@@ -1,6 +1,7 @@
 import React, { useEffect, useRef, useState } from "react";
 import classNames from "classnames";
 import { AnimatePresence, motion } from "framer-motion";
+import { formatDuration } from "../../utils/formatUtils";
 
 import Button from "../Button/Button";
 import AlertDialog from "../AlertDialog/AlertDialog";
@@ -40,8 +41,7 @@ export default function UnifiedTimerHome() {
     inputValue,
     taskId,
     activityCatalogId,
-    minutes,
-    seconds,
+    elapsed,
     formattedLimit,
     showAutoStopWarning,
     flowState,
@@ -191,7 +191,7 @@ export default function UnifiedTimerHome() {
             <AnimatePresence mode="popLayout" initial={false}>
               {isActive && (
                 <motion.div key="timer" layout {...fadeProps} className={styles.timerPill}>
-                  {minutes}:{seconds.toString().padStart(2, "0")}
+                  {formatDuration(elapsed)}
                 </motion.div>
               )}
             </AnimatePresence>
diff --git a/frontend/src/config.ts b/frontend/src/config.ts
index 5cf9b01f..586d481d 100644
--- a/frontend/src/config.ts
+++ b/frontend/src/config.ts
@@ -1,16 +1,14 @@
 // src/config.ts
-let API_BASE_URL: string;
-const envApiBaseUrl = import.meta.env.VITE_API_BASE_URL as string | undefined;
+function resolveApiBaseUrl(): string {
+  const envApiBaseUrl = import.meta.env.VITE_API_BASE_URL as string | undefined;
 
-if (envApiBaseUrl) {
-  API_BASE_URL = envApiBaseUrl;
-} else if (window.location.hostname === 'localhost') {
-  API_BASE_URL = 'http://localhost:8000';
-} else {
-  API_BASE_URL = window.location.origin;
-}
+  const base =
+    envApiBaseUrl ??
+    (window.location.hostname === 'localhost'
+      ? 'http://localhost:8000'
+      : window.location.origin);
 
-API_BASE_URL = API_BASE_URL.replace(/\/api\/v1\/?$/i, '');
-API_BASE_URL = API_BASE_URL.replace(/\/$/, '');
+  return base.replace(/\/api\/v1\/?$/i, '').replace(/\/$/, '');
+}
 
-export { API_BASE_URL };
+export const API_BASE_URL = resolveApiBaseUrl();
diff --git a/frontend/src/context/WebSocketContext.tsx b/frontend/src/context/WebSocketContext.tsx
index 2c4d6c5a..aabc3b7d 100644
--- a/frontend/src/context/WebSocketContext.tsx
+++ b/frontend/src/context/WebSocketContext.tsx
@@ -10,7 +10,7 @@ import { handleGlobalWebSocketEvent } from '../websockets/handleGlobalWebSocketE
 import { useMaintenanceStatus } from '../hooks/useMaintenanceStatus';
 import { useMaintenanceContext } from './MaintenanceContext';
 import { WebSocketContext } from './webSocketContext';
-import type { IncomingWebSocketMessage, OutgoingWebSocketMessage } from '../types';
+import type { ActivityTimerApiData, IncomingWebSocketMessage, OutgoingWebSocketMessage } from '../types';
 
 // ---------------------------------------------------------------------------
 // Types
@@ -30,7 +30,7 @@ const HEARTBEAT_INTERVAL_MS = 60_000;
 // ---------------------------------------------------------------------------
 
 export const WebSocketProvider = ({ children }: ProviderProps): ReactElement => {
-  const { player } = useGame();
+  const { player, activityTimer, freeTimerLimitSeconds } = useGame();
   const { setOnlinePlayerCount } = useOnlineCount();
   const { isAuthenticated, loading: authLoading } = useAuth();
   const { showToast } = useToast();
@@ -40,14 +40,26 @@ export const WebSocketProvider = ({ children }: ProviderProps): ReactElement =>
   const eventHandlersRef = useRef<Set<(data: IncomingWebSocketMessage) => void>>(new Set());
   const wsEnabled = Boolean(!authLoading && isAuthenticated && player?.id);
 
+  const { loadFromServer } = activityTimer;
+  const onActivityTimerUpdate = useCallback((activityTimerData: ActivityTimerApiData) => {
+    // Reconciles this session's timer to the authoritative state pushed
+    // whenever another of the player's open sessions (tabs/devices) starts,
+    // labels, or submits the activity timer. loadFromServer just overwrites
+    // local state, so applying it to the session that originated the change
+    // (an echo of its own update) is harmless.
+    loadFromServer(activityTimerData, {
+      limitSeconds: player?.is_premium ? null : freeTimerLimitSeconds,
+    });
+  }, [loadFromServer, player?.is_premium, freeTimerLimitSeconds]);
+
   const onMessage = useCallback((data: IncomingWebSocketMessage) => {
     if (data.type === 'online_count') {
       setOnlinePlayerCount(data.count);
     }
     //console.log("[WS Provider] showToast:", showToast);
-    handleGlobalWebSocketEvent(data, { showToast, maintenanceRefetch, setMaintenance });
+    handleGlobalWebSocketEvent(data, { showToast, maintenanceRefetch, setMaintenance, onActivityTimerUpdate });
     eventHandlersRef.current.forEach((handler) => handler(data));
-  }, [showToast, maintenanceRefetch, setMaintenance, setOnlinePlayerCount]);
+  }, [showToast, maintenanceRefetch, setMaintenance, setOnlinePlayerCount, onActivityTimerUpdate]);
 
   const onError = useCallback(() => {
     console.error('WebSocket connection error');
diff --git a/frontend/src/featureFlags.ts b/frontend/src/featureFlags.ts
index a20f67b1..b19fd0af 100644
--- a/frontend/src/featureFlags.ts
+++ b/frontend/src/featureFlags.ts
@@ -16,7 +16,7 @@ const featureFlags: Record<FeatureFlagKey, FeatureFlagValue> = {
   unified_homepage: [],
   results_mode: [],
   map: ['testers'],
-  todayPointsBadge: ['all'],
+  dailyGoalsBadge: ['testers'],
 };
 
 export default featureFlags;
diff --git a/frontend/src/hooks/useActivities.ts b/frontend/src/hooks/useActivities.ts
index 17f6718c..0e05fc4d 100644
--- a/frontend/src/hooks/useActivities.ts
+++ b/frontend/src/hooks/useActivities.ts
@@ -1,7 +1,7 @@
 // src/hooks/useActivities.ts
 
 import { useMutation, useQueryClient, useQuery } from "@tanstack/react-query";
-import { updateActivity, deleteActivity, fetchActivities, createActivity } from "../api/activities";
+import { updateActivity, deleteActivity, fetchActivities, createActivity, logOfflineActivity } from "../api/activities";
 import type { PlayerActivity } from "../types";
 
 
@@ -26,6 +26,20 @@ export function useCreateActivity() {
 }
 
 
+export function useLogOfflineActivity() {
+  const queryClient = useQueryClient();
+
+  return useMutation({
+    mutationFn: logOfflineActivity,
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ["activities"] });
+      // A task may have been auto-created (or its total time updated) by the log.
+      queryClient.invalidateQueries({ queryKey: ["tasks"] });
+    },
+  });
+}
+
+
 export function useUpdateActivity() {
   const queryClient = useQueryClient();
 
diff --git a/frontend/src/hooks/usePlayer.ts b/frontend/src/hooks/usePlayer.ts
index 6773eedf..11e12ea2 100644
--- a/frontend/src/hooks/usePlayer.ts
+++ b/frontend/src/hooks/usePlayer.ts
@@ -1,27 +1,27 @@
 import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
 import { useNavigate } from "react-router";
-import { updatePlayer, downloadUserData, deleteAccount, fetchTodayPoints } from "../api/player";
+import { updatePlayer, downloadUserData, deleteAccount, fetchDailyGoals } from "../api/player";
 import { useAuth } from "../context/AuthContext";
 
 // Query key shared with useActivityInput's refreshAfterActivityChange, which
-// invalidates it after every completed task/session so the map view's
-// "today" badge (issue #673) updates immediately instead of waiting for the
-// next poll.
-export const TODAY_POINTS_QUERY_KEY = ["me", "today-points"];
+// invalidates it after every completed task/session so the map view's daily
+// goals badge (issue #673, redesigned in #751) updates immediately instead
+// of waiting for the next poll.
+export const DAILY_GOALS_QUERY_KEY = ["me", "daily-goals"];
 
 // Polled lightly (rather than one-shot like other /me/ data) so the badge
 // still rolls over to the new day's value on its own if the map view is left
 // open across midnight, without needing a dedicated push mechanism for that.
-const TODAY_POINTS_POLL_INTERVAL_MS = 60_000;
+const DAILY_GOALS_POLL_INTERVAL_MS = 60_000;
 
-export function useTodayPoints() {
+export function useDailyGoals() {
   const { isAuthenticated } = useAuth();
 
   return useQuery({
-    queryKey: TODAY_POINTS_QUERY_KEY,
-    queryFn: fetchTodayPoints,
+    queryKey: DAILY_GOALS_QUERY_KEY,
+    queryFn: fetchDailyGoals,
     enabled: isAuthenticated,
-    refetchInterval: TODAY_POINTS_POLL_INTERVAL_MS,
+    refetchInterval: DAILY_GOALS_POLL_INTERVAL_MS,
   });
 }
 
diff --git a/frontend/src/hooks/useSimpleCrudPanel.ts b/frontend/src/hooks/useSimpleCrudPanel.ts
index 9baa8297..e5437581 100644
--- a/frontend/src/hooks/useSimpleCrudPanel.ts
+++ b/frontend/src/hooks/useSimpleCrudPanel.ts
@@ -8,6 +8,11 @@ interface Entity {
   name: string;
 }
 
+interface SaveCallbacks {
+  onSuccess?: () => void;
+  onError?: () => void;
+}
+
 interface UseSimpleCrudPanelOptions<T extends Entity> {
   useList: () => Pick<UseQueryResult<T[]>, "data" | "isLoading">;
   useCreate: () => Pick<UseMutationResult<unknown, unknown, Partial<T>>, "mutate">;
@@ -41,8 +46,8 @@ export function useSimpleCrudPanel<T extends Entity>({
   );
 
   const handleEdit = useCallback(
-    (item: T, name: string) => {
-      update.mutate({ id: item.id, data: { name } as Partial<T> });
+    (item: T, name: string, callbacks?: SaveCallbacks) => {
+      update.mutate({ id: item.id, data: { name } as Partial<T> }, callbacks);
     },
     [update],
   );
diff --git a/frontend/src/pages/MapPage/MapPage.tsx b/frontend/src/pages/MapPage/MapPage.tsx
index 04a35d76..45e65503 100644
--- a/frontend/src/pages/MapPage/MapPage.tsx
+++ b/frontend/src/pages/MapPage/MapPage.tsx
@@ -5,7 +5,7 @@ import Button from "../../components/Button/Button";
 import PopulationCentreMap, {
   type PopulationCentreMapHandle,
 } from "../../components/Map/Map";
-import TodayPointsBadge from "../../components/TodayPointsBadge/TodayPointsBadge";
+import DailyGoalsBadge from "../../components/DailyGoalsBadge/DailyGoalsBadge";
 import { fetchPopulationCentreMap } from "../../api/map";
 import FeatureToggle from "../../components/FeatureToggle";
 import {
@@ -136,8 +136,8 @@ export default function MapPage(): React.ReactElement {
             onViewportChange={handleViewportChange}
             worldBounds={worldBounds?.bbox}
           >
-            <FeatureToggle flag="todayPointsBadge" fallback={null}>
-              <TodayPointsBadge />
+            <FeatureToggle flag="dailyGoalsBadge" fallback={null}>
+              <DailyGoalsBadge />
             </FeatureToggle>
             {nextVillage && (
               <Button
diff --git a/frontend/src/styles/semantic/_spacing.scss b/frontend/src/styles/semantic/_spacing.scss
index d9a3c5a1..3e326fe5 100644
--- a/frontend/src/styles/semantic/_spacing.scss
+++ b/frontend/src/styles/semantic/_spacing.scss
@@ -38,6 +38,9 @@ $button-padding: $spacing-xs $spacing-md;
 $button-radius: $spacing-md;
 $content-padding: $spacing-lg;
 
+$form-control-height: 2rem;
+$form-control-radius: $border-radius;
+
 // === Gap / radius / shadow collections ===
 $gap: (
   xs: map.get(s.$spacing, xs),
diff --git a/frontend/src/types/api.ts b/frontend/src/types/api.ts
index cb76f9a5..839d9e45 100644
--- a/frontend/src/types/api.ts
+++ b/frontend/src/types/api.ts
@@ -97,6 +97,16 @@ export interface AnnouncementReadMutationResponse {
   unread_count: number;
 }
 
+/** Response from POST /player-activities/log_offline/ */
+export interface OfflineActivityLogResponse {
+  success: boolean;
+  message: string;
+  activity: PlayerActivity;
+  xp_gained: number;
+  xp_eligible_seconds: number;
+  level_ups: number[];
+}
+
 // Forward references resolved in domain.ts
 import type { Player } from "./domain";
 import type { Character } from "./domain";
@@ -104,4 +114,5 @@ import type { Announcement } from "./domain";
 import type { ActivityTimerApiData } from "./timers";
 import type { PopulationCentre } from "./domain";
 import type { XpModifier } from "./domain";
+import type { PlayerActivity } from "./domain";
 import type { LoginState } from "./enums";
diff --git a/frontend/src/types/enums.ts b/frontend/src/types/enums.ts
index ec0dd774..97e3b83c 100644
--- a/frontend/src/types/enums.ts
+++ b/frontend/src/types/enums.ts
@@ -25,7 +25,7 @@ export type FeatureFlagKey =
   | "unified_homepage"
   | "results_mode"
   | "map"
-  | "todayPointsBadge";
+  | "dailyGoalsBadge";
 
 // ---------------------------------------------------------------------------
 // Timer statuses (Timer.STATUS_CHOICES in gameplay/models.py)
diff --git a/frontend/src/types/index.ts b/frontend/src/types/index.ts
index 2a2ff69e..35676180 100644
--- a/frontend/src/types/index.ts
+++ b/frontend/src/types/index.ts
@@ -19,6 +19,7 @@ export type {
   AnnouncementListResponse,
   AnnouncementUnreadCountResponse,
   AnnouncementReadMutationResponse,
+  OfflineActivityLogResponse,
 } from "./api";
 
 // Enums and literal union types
diff --git a/frontend/src/types/timers.ts b/frontend/src/types/timers.ts
index 229d3b4f..6dca6d7e 100644
--- a/frontend/src/types/timers.ts
+++ b/frontend/src/types/timers.ts
@@ -157,13 +157,19 @@ export interface WebSocketErrorMessage extends WebSocketMessageBase {
 /** Server-initiated action message (maintenance refresh, game events) */
 export interface WebSocketActionMessage {
   type: "action";
-  action: "refresh" | "load-game";
+  action: "refresh" | "load-game" | "activity_timer_update";
   message?: string;
   maintenance_active?: boolean;
   name?: string;
   description?: string;
   start_time?: string | null;
   end_time?: string | null;
+  /**
+   * Present when action is "activity_timer_update" — pushed whenever another
+   * of this player's sessions (tabs/devices) starts, labels, or submits the
+   * activity timer, so every open session can reconcile to server state.
+   */
+  data?: { activity_timer: ActivityTimerApiData };
 }
 
 /** Generic server message (currently unused payload) */
diff --git a/frontend/src/utils/formatUtils.test.ts b/frontend/src/utils/formatUtils.test.ts
index c4090fe3..474acf97 100644
--- a/frontend/src/utils/formatUtils.test.ts
+++ b/frontend/src/utils/formatUtils.test.ts
@@ -31,16 +31,16 @@ describe("formatDueAt", () => {
     expect(formatDueAt(null)).toBe("-");
   });
 
-  it("labels the current day as Today", () => {
-    expect(formatDueAt(atLocalMidnight(0))).toBe("Today");
+  it("labels the current day as today", () => {
+    expect(formatDueAt(atLocalMidnight(0))).toBe("today");
   });
 
-  it("labels the next day as Tomorrow", () => {
-    expect(formatDueAt(atLocalMidnight(1))).toBe("Tomorrow");
+  it("labels the next day as tomorrow", () => {
+    expect(formatDueAt(atLocalMidnight(1))).toBe("tomorrow");
   });
 
-  it("labels the previous day as Yesterday", () => {
-    expect(formatDueAt(atLocalMidnight(-1))).toBe("Yesterday");
+  it("labels the previous day as yesterday", () => {
+    expect(formatDueAt(atLocalMidnight(-1))).toBe("yesterday");
   });
 
   it("labels a few days out as 'in N days'", () => {
@@ -51,13 +51,37 @@ describe("formatDueAt", () => {
     expect(formatDueAt(atLocalMidnight(-3))).toBe("3 days ago");
   });
 
-  it("labels a further-back date in weeks", () => {
+  it("labels a further-back date in whole weeks", () => {
     expect(formatDueAt(atLocalMidnight(-14))).toBe("2 weeks ago");
   });
 
-  it("labels a further-out date as an absolute weekday/day/month", () => {
-    // 9 days out from Wed 15 Jul 2026 is Fri 24 Jul 2026.
-    expect(formatDueAt(atLocalMidnight(9))).toBe("Fri 24th Jul");
+  it("labels a further-out date in weeks, with a leftover-days remainder", () => {
+    expect(formatDueAt(atLocalMidnight(9))).toBe("in 1 week, 2 days");
+  });
+
+  it("labels a further-out whole-week date without a days remainder", () => {
+    expect(formatDueAt(atLocalMidnight(14))).toBe("in 2 weeks");
+  });
+
+  it("labels a further-back date in weeks, with a leftover-days remainder", () => {
+    expect(formatDueAt(atLocalMidnight(-20))).toBe("2 weeks, 6 days ago");
+  });
+
+  it("labels a date beyond the week cutoff in months (future)", () => {
+    expect(formatDueAt(atLocalMidnight(60))).toBe("in 2 months");
+  });
+
+  it("labels a date beyond the week cutoff in months (past)", () => {
+    expect(formatDueAt(atLocalMidnight(-60))).toBe("2 months ago");
+  });
+
+  it("keeps counting months uncapped on the past side", () => {
+    expect(formatDueAt(atLocalMidnight(-200))).toBe("7 months ago");
+  });
+
+  it("falls back to an absolute date beyond the month cap (future)", () => {
+    // 200 days out from Wed 15 Jul 2026 is Sun 31 Jan 2027.
+    expect(formatDueAt(atLocalMidnight(200))).toBe("Sun 31st Jan");
   });
 });
 
diff --git a/frontend/src/utils/formatUtils.ts b/frontend/src/utils/formatUtils.ts
index d7eed39c..3bbd83b4 100644
--- a/frontend/src/utils/formatUtils.ts
+++ b/frontend/src/utils/formatUtils.ts
@@ -75,6 +75,21 @@ function startOfDay(date: Date): Date {
   return new Date(date.getFullYear(), date.getMonth(), date.getDate());
 }
 
+const WEEK_CUTOFF_DAYS = 56; // 8 weeks: weeks[, days] granularity applies up to this many days out/back
+const MONTH_CUTOFF_DAYS = 180; // 6 months: beyond this on the future side, fall back to an absolute date
+
+function formatWeeksAndDays(totalDays: number): string {
+  const weeks = Math.floor(totalDays / 7);
+  const days = totalDays % 7;
+  const weeksPart = `${weeks} ${pluralize(weeks, "week")}`;
+  return days > 0 ? `${weeksPart}, ${days} ${pluralize(days, "day")}` : weeksPart;
+}
+
+function formatMonths(totalDays: number): string {
+  const months = Math.max(1, Math.round(totalDays / 30));
+  return `${months} ${pluralize(months, "month")}`;
+}
+
 export function formatDueAt(dueAt: string | null): string {
   if (!dueAt) return "-";
   const date = new Date(dueAt);
@@ -84,19 +99,23 @@ export function formatDueAt(dueAt: string | null): string {
     (startOfDay(date).getTime() - startOfDay(new Date()).getTime()) / (24 * 60 * 60 * 1000)
   );
 
-  if (diffDays === 0) return "Today";
-  if (diffDays === 1) return "Tomorrow";
-  if (diffDays === -1) return "Yesterday";
+  if (diffDays === 0) return "today";
+  if (diffDays === 1) return "tomorrow";
+  if (diffDays === -1) return "yesterday";
 
   if (diffDays > 1 && diffDays <= 6) return `in ${diffDays} days`;
   if (diffDays < -1 && diffDays >= -6) return `${-diffDays} days ago`;
 
-  if (diffDays < -6) {
-    const weeks = Math.round(-diffDays / 7);
-    return `${weeks} week${weeks === 1 ? "" : "s"} ago`;
+  if (diffDays > 6 && diffDays <= WEEK_CUTOFF_DAYS) return `in ${formatWeeksAndDays(diffDays)}`;
+  if (diffDays < -6 && diffDays >= -WEEK_CUTOFF_DAYS) return `${formatWeeksAndDays(-diffDays)} ago`;
+
+  if (diffDays < -WEEK_CUTOFF_DAYS) return `${formatMonths(-diffDays)} ago`;
+
+  if (diffDays > WEEK_CUTOFF_DAYS && diffDays <= MONTH_CUTOFF_DAYS) {
+    return `in ${formatMonths(diffDays)}`;
   }
 
-  // diffDays > 6: further out than a week, show an absolute date.
+  // diffDays > MONTH_CUTOFF_DAYS: further out than ~6 months, show an absolute date.
   const weekday = date.toLocaleDateString(undefined, { weekday: "short" });
   const month = date.toLocaleDateString(undefined, { month: "short" });
   const day = date.getDate();
diff --git a/frontend/src/websockets/handleGlobalWebSocketEvent.ts b/frontend/src/websockets/handleGlobalWebSocketEvent.ts
index d0438e52..a12599a2 100644
--- a/frontend/src/websockets/handleGlobalWebSocketEvent.ts
+++ b/frontend/src/websockets/handleGlobalWebSocketEvent.ts
@@ -1,16 +1,23 @@
 // websockets/handleGlobalWebSocketEvent.ts
-import type { IncomingWebSocketMessage } from '../types';
+import type { ActivityTimerApiData, IncomingWebSocketMessage } from '../types';
 import type { MaintenanceState } from '../context/MaintenanceContext';
 
 interface HandleGlobalWebSocketEventOptions {
   showToast?: (message: string) => void;
   maintenanceRefetch?: () => Promise<MaintenanceState>;
   setMaintenance?: (state: MaintenanceState) => void;
+  /**
+   * Called when the server pushes an authoritative activity-timer snapshot
+   * (another of this player's sessions started/labelled/submitted the
+   * timer) so the caller can reconcile local timer state, e.g. via
+   * useActivityTimer's loadFromServer.
+   */
+  onActivityTimerUpdate?: (activityTimer: ActivityTimerApiData) => void;
 }
 
 export async function handleGlobalWebSocketEvent(
   data: IncomingWebSocketMessage,
-  { showToast, maintenanceRefetch, setMaintenance }: HandleGlobalWebSocketEventOptions,
+  { showToast, maintenanceRefetch, setMaintenance, onActivityTimerUpdate }: HandleGlobalWebSocketEventOptions,
 ): Promise<void> {
   switch (data.type) {
     case 'notification':
@@ -66,6 +73,11 @@ export async function handleGlobalWebSocketEvent(
         case 'load-game':
           console.log("[WS] Django consumer 'load-game' message not currently in use.");
           break;
+        case 'activity_timer_update':
+          if (data.data?.activity_timer) {
+            onActivityTimerUpdate?.(data.data.activity_timer);
+          }
+          break;
         default:
           console.warn('[WS] Unknown action:', data);
       }
diff --git a/gameplay/models.py b/gameplay/models.py
index 3a04fde1..b6099271 100644
--- a/gameplay/models.py
+++ b/gameplay/models.py
@@ -350,7 +350,14 @@ def complete(
         reward_summary = self.activity.get_xp_reward_summary()
         xp_gained = self.activity.complete(reward_summary=reward_summary)
         level_ups = self.player.add_activity(self.elapsed_time, xp=xp_gained)
+
+        from progression.daily_goals import check_and_award_daily_goals
+
+        goals_state, bonus_level_ups = check_and_award_daily_goals(self.player)
+        level_ups = level_ups + bonus_level_ups
+
         reward_summary["level_ups"] = level_ups
+        reward_summary["daily_goals_bonus_ap"] = goals_state.bonus_ap
 
         logger.debug(
             f"[TIMER COMPLETE] Timer {self.id} completed — elapsed_time: {self.elapsed_time}, completed_at: {self.activity.completed_at}"
diff --git a/gameplay/tasks.py b/gameplay/tasks.py
index b0980c85..e1b02306 100644
--- a/gameplay/tasks.py
+++ b/gameplay/tasks.py
@@ -27,6 +27,7 @@ def auto_complete_timer_on_disconnect(self, player_id: int):
     Revoked by TimerConsumer.connect() if the player reconnects in time.
     """
     from .models import ActivityTimer
+    from .utils import broadcast_activity_timer
 
     stored_task_id = cache.get(DISCONNECT_TASK_CACHE_KEY.format(player_id=player_id))
     if stored_task_id != self.request.id:
@@ -44,6 +45,7 @@ def auto_complete_timer_on_disconnect(self, player_id: int):
         return f"skipped:{timer.status}"
 
     timer.complete(completion_source="auto")
+    broadcast_activity_timer(timer)
     cache.delete(DISCONNECT_TASK_CACHE_KEY.format(player_id=player_id))
     return "completed"
 
@@ -61,6 +63,7 @@ def auto_complete_timers_for_stale_players():
     completes them the same way the disconnect grace period does.
     """
     from .models import ActivityTimer
+    from .utils import broadcast_activity_timer
 
     cutoff = timezone.now() - STALE_TIMER_THRESHOLD
     stale_timers = (
@@ -72,6 +75,7 @@ def auto_complete_timers_for_stale_players():
     completed_count = 0
     for timer in stale_timers:
         timer.complete(completion_source="auto")
+        broadcast_activity_timer(timer)
         completed_count += 1
 
     return completed_count
diff --git a/gameplay/tests/test_activity_timer_premium.py b/gameplay/tests/test_activity_timer_premium.py
index d0978523..98eee912 100644
--- a/gameplay/tests/test_activity_timer_premium.py
+++ b/gameplay/tests/test_activity_timer_premium.py
@@ -49,6 +49,7 @@ def test_timer_completion_returns_premium_reward_breakdown(self):
                 "xp_gained": 120,
                 "skill_xp_gained": 0,
                 "level_ups": [1],
+                "daily_goals_bonus_ap": 0,
             },
         )
         self.assertEqual(self.player.level, 1)
diff --git a/gameplay/tests/test_disconnect_grace.py b/gameplay/tests/test_disconnect_grace.py
index e39fb8c5..bc55b745 100644
--- a/gameplay/tests/test_disconnect_grace.py
+++ b/gameplay/tests/test_disconnect_grace.py
@@ -141,12 +141,18 @@ def test_completes_active_timer_and_clears_cache(self):
 
         with patch.object(
             ActivityTimer, "complete", return_value={"xp_gained": 50}
-        ) as mock_complete:
+        ) as mock_complete, patch(
+            "gameplay.tasks.broadcast_activity_timer"
+        ) as mock_broadcast:
             result = _run_task(self.player.id, self.TASK_ID)
 
         self.assertEqual(result, "completed")
         mock_complete.assert_called_once_with(completion_source="auto")
         self.assertIsNone(cache.get(self._cache_key()))
+        # Any other open session (tabs/devices) for this player should be
+        # told the timer was auto-completed, so it stops ticking a timer
+        # the server has already closed out.
+        mock_broadcast.assert_called_once_with(self.timer)
 
 
 # ── consumer disconnect tests ──────────────────────────────────────────────────
diff --git a/gameplay/tests/test_models.py b/gameplay/tests/test_models.py
index 940f923e..7b9a0574 100644
--- a/gameplay/tests/test_models.py
+++ b/gameplay/tests/test_models.py
@@ -85,6 +85,44 @@ def test_complete(self):
         self.assertIsNone(self.timer.activity)
         self.assertEqual(result["base_xp"], 15)
 
+    def test_complete_reports_no_daily_goals_bonus_when_goals_unmet(self):
+        # No UserLogin recorded for today, so the "logged in today" goal
+        # isn't met and the completion bonus shouldn't fire.
+        self.timer.new_activity("Test activity")
+        self.timer.elapsed_time = 15
+        self.timer.start_time = now()
+
+        result = self.timer.complete()
+
+        self.assertEqual(result["daily_goals_bonus_ap"], 0)
+
+    def test_complete_awards_daily_goals_bonus_when_goals_met(self):
+        from core.models import GameSettings
+        from users.models import UserLogin
+
+        GameSettings.current()
+        settings = GameSettings.objects.get(pk=1)
+        settings.daily_goals_completion_bonus_ap = 25
+        settings.save(update_fields=["daily_goals_completion_bonus_ap"])
+        UserLogin.objects.create(user=self.user)
+
+        self.timer.new_activity("Test activity")
+        self.timer.elapsed_time = 3 * 60
+        self.timer.start_time = now()
+
+        from progression.ap import total_ap_earned
+
+        ap_before = total_ap_earned(self.player.level, self.player.xp)
+        result = self.timer.complete()
+
+        self.assertEqual(result["daily_goals_bonus_ap"], 25)
+        self.player.refresh_from_db()
+        ap_after = total_ap_earned(self.player.level, self.player.xp)
+        # Lifetime AP total (level-up-proof, unlike the raw xp field, which
+        # resets on level-up) went up by both the activity's own reward and
+        # the daily-goals bonus.
+        self.assertEqual(ap_after, ap_before + result["xp_gained"] + 25)
+
 
 class TestServerMessageModel(TestCase):
     @classmethod
diff --git a/gameplay/tests/test_stale_connection_sweep.py b/gameplay/tests/test_stale_connection_sweep.py
index 8a3bc89b..bed77b96 100644
--- a/gameplay/tests/test_stale_connection_sweep.py
+++ b/gameplay/tests/test_stale_connection_sweep.py
@@ -60,11 +60,16 @@ def test_completes_timer_when_last_seen_older_than_threshold(self):
             timezone.now() - (STALE_TIMER_THRESHOLD + timedelta(seconds=1))
         )
 
-        with patch.object(ActivityTimer, "complete") as mock_complete:
+        with patch.object(ActivityTimer, "complete") as mock_complete, patch(
+            "gameplay.tasks.broadcast_activity_timer"
+        ) as mock_broadcast:
             result = auto_complete_timers_for_stale_players()
 
         mock_complete.assert_called_once_with(completion_source="auto")
         self.assertEqual(result, 1)
+        # Any other open session (tabs/devices) for this player should be
+        # told the timer was auto-completed by this sweep.
+        mock_broadcast.assert_called_once_with(self.timer)
 
     def test_completes_timer_when_last_seen_was_never_set(self):
         self._make_active(None)
diff --git a/gameplay/tests/test_views.py b/gameplay/tests/test_views.py
index da388972..8a39eda5 100644
--- a/gameplay/tests/test_views.py
+++ b/gameplay/tests/test_views.py
@@ -1,3 +1,5 @@
+from unittest.mock import patch
+
 from django.contrib.auth import get_user_model
 from django.urls import reverse
 from rest_framework import status
@@ -94,3 +96,62 @@ def test_requires_authentication(self):
         response = self.client.post(self.url, {"activityName": "Nope"})
 
         self.assertEqual(response.status_code, status.HTTP_401_UNAUTHORIZED)
+
+
+class ActivityTimerBroadcastTests(APITestCase):
+    """
+    Every mutating activity-timer endpoint should push the updated timer to
+    the player's other open sessions (tabs/devices) over the `player_{id}`
+    WebSocket group, so they can reconcile via loadFromServer instead of
+    drifting until their next manual fetch. See issue #759.
+    """
+
+    def setUp(self):
+        self.user = user_factory(with_player=True)
+        self.player = self.user.player
+        self.client.force_authenticate(user=self.user)
+
+    def test_set_activity_broadcasts_timer_update(self):
+        with patch("gameplay.views.broadcast_activity_timer") as mock_broadcast:
+            response = self.client.post(
+                reverse("activitytimer-set-activity"), {"activityName": "Focus time"}
+            )
+
+        self.assertEqual(response.status_code, status.HTTP_200_OK)
+        mock_broadcast.assert_called_once_with(self.player.activity_timer)
+
+    def test_start_broadcasts_timer_update(self):
+        self.player.activity_timer.new_activity(name="Focus time")
+
+        with patch("gameplay.views.broadcast_activity_timer") as mock_broadcast:
+            response = self.client.post(reverse("activitytimer-start"))
+
+        self.assertEqual(response.status_code, status.HTTP_200_OK)
+        mock_broadcast.assert_called_once_with(self.player.activity_timer)
+
+    def test_label_activity_broadcasts_timer_update(self):
+        timer = self.player.activity_timer
+        timer.new_activity(name="Focus time")
+        timer.start()
+
+        with patch("gameplay.views.broadcast_activity_timer") as mock_broadcast:
+            response = self.client.post(
+                reverse("activitytimer-label-activity"), {"activityName": "Deep work"}
+            )
+
+        self.assertEqual(response.status_code, status.HTTP_200_OK)
+        mock_broadcast.assert_called_once_with(timer)
+
+    def test_complete_broadcasts_timer_update(self):
+        timer = self.player.activity_timer
+        timer.new_activity(name="Focus time")
+        timer.start()
+
+        with patch("gameplay.views.broadcast_activity_timer") as mock_broadcast:
+            response = self.client.post(
+                reverse("activitytimer-complete"),
+                {"activityName": "Focus time", "elapsedSeconds": 30},
+            )
+
+        self.assertEqual(response.status_code, status.HTTP_200_OK)
+        mock_broadcast.assert_called_once_with(timer)
diff --git a/gameplay/utils.py b/gameplay/utils.py
index 63676d80..2008f9b3 100644
--- a/gameplay/utils.py
+++ b/gameplay/utils.py
@@ -204,6 +204,26 @@ def process_completion(player: Player, character: Character, action: str) -> boo
         return True
 
 
+def broadcast_activity_timer(timer: ActivityTimer) -> None:
+    """
+    Push `timer`'s current state to every other open session (tabs, devices)
+    this player has connected, so they can reconcile via useActivityTimer's
+    loadFromServer instead of drifting until their next manual fetch.
+    Reuses the per-player `player_{id}` group that TimerConsumer already
+    joins on connect. Safe to call from sync contexts (views, Celery tasks).
+    """
+    from .serializers import ActivityTimerSerializer
+
+    async_to_sync(send_group_message)(
+        f"player_{timer.player_id}",
+        {
+            "type": "action",
+            "action": "activity_timer_update",
+            "data": {"activity_timer": ActivityTimerSerializer(timer).data},
+        },
+    )
+
+
 async def send_group_message(group_name: str, message: dict) -> bool:
     logger.info(
         f"[SEND GROUP MESSAGE] Sending message to group {group_name}. Message: {message}"
diff --git a/gameplay/views.py b/gameplay/views.py
index 1d2af1c0..21ea93ec 100644
--- a/gameplay/views.py
+++ b/gameplay/views.py
@@ -8,6 +8,7 @@
 import logging
 
 from .serializers import ActivityTimerSerializer
+from .utils import broadcast_activity_timer
 
 from progression.models import Task
 
@@ -34,22 +35,28 @@ def serialize(self, timer):
         assert self.serializer_class is not None
         return self.serializer_class(timer).data
 
+    def broadcast_timer_update(self, timer):
+        broadcast_activity_timer(timer)
+
     @action(detail=False, methods=["post"])
     def start(self, request):
         timer = self.get_timer(request)
         timer.start()
+        self.broadcast_timer_update(timer)
         return Response(self.serialize(timer))
 
     @action(detail=False, methods=["post"])
     def pause(self, request):
         timer = self.get_timer(request)
         timer.pause()
+        self.broadcast_timer_update(timer)
         return Response(self.serialize(timer))
 
     @action(detail=False, methods=["post"])
     def reset(self, request):
         timer = self.get_timer(request)
         timer.reset()
+        self.broadcast_timer_update(timer)
         return Response(self.serialize(timer))
 
     @action(detail=False, methods=["post"])
@@ -58,6 +65,7 @@ def complete(self, request):
         name = request.data.get("activityName")
 
         timer.complete(newName=name)
+        self.broadcast_timer_update(timer)
         return Response(self.serialize(timer))
 
 
@@ -90,6 +98,7 @@ def complete(self, request):  # type: ignore[override]
             client_elapsed_seconds=client_elapsed_seconds,
             completion_source=completion_source,
         )
+        self.broadcast_timer_update(timer)
 
         return Response({"activity_timer": self.serialize(timer), **completion})
 
@@ -108,6 +117,7 @@ def set_activity(self, request):
 
         updated = timer.new_activity(name=name, task=task)
         updated.refresh_from_db()
+        self.broadcast_timer_update(updated)
         return Response({"success": True, "activity_timer": self.serialize(updated)})
 
     @action(detail=False, methods=["post"])
@@ -135,5 +145,6 @@ def label_activity(self, request):
             timer.change_task(task)
 
         timer.rename_activity(name)
+        self.broadcast_timer_update(timer)
 
         return Response({"success": True, "activity_timer": self.serialize(timer)})
diff --git a/locations/management/commands/generate_characters.py b/locations/management/commands/generate_characters.py
index d57e5d5f..58000f5a 100644
--- a/locations/management/commands/generate_characters.py
+++ b/locations/management/commands/generate_characters.py
@@ -155,15 +155,11 @@ def generate_for_centre(self, centre: PopulationCentre):
                 given_name = random.choice(MALE_NAMES if sex == "M" else FEMALE_NAMES)
 
                 birth_date = birth_date_for_age(age)
-                # can_link possible for chars over 15 years old
-                age_days = (date.today() - birth_date).days
-                can_link = age_days >= int(15 * 365.25)
 
                 char = Character.objects.create(
                     given_name=given_name,
                     sex=sex,
                     birth_date=birth_date,
-                    can_link=can_link,
                 )
                 household_members.append((char, role))
                 household_characters.append(char)
diff --git a/progression/admin.py b/progression/admin.py
index 24d67956..a3f479c9 100644
--- a/progression/admin.py
+++ b/progression/admin.py
@@ -15,6 +15,7 @@
     ActivityDefinition,
     CharacterActivity,
     OfflineActivityLedger,
+    DailyGoalAward,
     CharacterActivityArchive,
     Project,
     Task,
@@ -196,6 +197,23 @@ def has_change_permission(self, request, obj=None):
         return False
 
 
+@admin.register(DailyGoalAward)
+class DailyGoalAwardAdmin(admin.ModelAdmin):
+    list_display = ("id", "player", "date", "bonus_ap", "created_at")
+    search_fields = ("player__name",)
+    list_filter = ("date",)
+    date_hierarchy = "date"
+    readonly_fields = ("player", "date", "bonus_ap", "created_at")
+
+    def has_add_permission(self, request):
+        # Rows are only ever written by
+        # progression.daily_goals.check_and_award_daily_goals.
+        return False
+
+    def has_change_permission(self, request, obj=None):
+        return False
+
+
 @admin.register(CharacterActivity)
 class CharacterActivityAdmin(admin.ModelAdmin):
     list_display = (
diff --git a/progression/daily_goals.py b/progression/daily_goals.py
new file mode 100644
index 00000000..7cd1deab
--- /dev/null
+++ b/progression/daily_goals.py
@@ -0,0 +1,123 @@
+# progression/daily_goals.py
+"""
+Daily goals for the map-view badge (issue #751, replacing the old
+`points_today` mechanic from issue #673).
+
+Three intentionally easy, binary-ish goals for the player's *current* day:
+
+1. Logged in today.
+2. Completed at least one activity today.
+3. Recorded at least ``MINUTES_GOAL_THRESHOLD`` minutes of activity time
+   today (cumulative across activities, not a per-activity minimum).
+
+Clearing all three once in a day awards a one-off lump-sum AP bonus via the
+existing AP system (``Player.add_activity``) - see ``DailyGoalAward`` for
+the idempotency record that keeps a day's bonus from being paid twice.
+
+"Today" is the current local calendar day (``timezone.localdate()``), the
+same convention already used for login streaks (see
+``users.models.UserLogin.local_date``) - there's no per-player timezone
+stored, so this is the server's configured local timezone, not literally
+the player's own.
+"""
+
+from dataclasses import dataclass
+
+from django.db import transaction
+from django.db.models import Sum
+from django.utils import timezone
+
+from .models import DailyGoalAward
+
+MINUTES_GOAL_THRESHOLD = 3
+
+
+@dataclass
+class DailyGoalsState:
+    logged_in_today: bool
+    completed_activity_today: bool
+    activity_minutes_today: int
+    minutes_goal_met: bool
+    all_goals_met: bool
+    bonus_awarded_today: bool
+    bonus_ap: int
+
+
+def get_daily_goals_state(player, *, today=None) -> DailyGoalsState:
+    """
+    Compute today's goal state for `player`, live from current data - no
+    stored counters to keep in sync, so this is safe to call as often as
+    the badge is polled.
+    """
+    from users.models import UserLogin
+
+    today = today or timezone.localdate()
+
+    logged_in_today = UserLogin.objects.filter(
+        user=player.user_id, timestamp__date=today
+    ).exists()
+
+    activities_today = player.activities.filter(
+        is_complete=True, completed_at__date=today
+    )
+    completed_activity_today = activities_today.exists()
+
+    total_seconds = activities_today.aggregate(total=Sum("duration"))["total"] or 0
+    activity_minutes_today = total_seconds // 60
+    minutes_goal_met = activity_minutes_today >= MINUTES_GOAL_THRESHOLD
+
+    all_goals_met = logged_in_today and completed_activity_today and minutes_goal_met
+
+    award = DailyGoalAward.objects.filter(player=player, date=today).first()
+
+    return DailyGoalsState(
+        logged_in_today=logged_in_today,
+        completed_activity_today=completed_activity_today,
+        activity_minutes_today=activity_minutes_today,
+        minutes_goal_met=minutes_goal_met,
+        all_goals_met=all_goals_met,
+        bonus_awarded_today=award is not None,
+        bonus_ap=award.bonus_ap if award else 0,
+    )
+
+
+@transaction.atomic
+def check_and_award_daily_goals(player, *, today=None):
+    """
+    Call after a player completes an activity (timer-based or offline-logged
+    - anything that can newly satisfy goals 2/3). Idempotently awards the
+    completion bonus the first time all three goals are met for `today`.
+
+    Returns (state, level_ups) - state.bonus_ap is the amount just awarded
+    (0 if the goals aren't all met yet, or the bonus was already claimed
+    earlier today).
+    """
+    from core.models import GameSettings
+
+    today = today or timezone.localdate()
+    state = get_daily_goals_state(player, today=today)
+
+    if not state.all_goals_met or state.bonus_awarded_today:
+        return state, []
+
+    # The unique (player, date) constraint on DailyGoalAward is what makes
+    # this race-safe: get_or_create falls back to a get() on the
+    # IntegrityError from a concurrent completion, so only one caller ever
+    # sees created=True for a given day.
+    award, created = DailyGoalAward.objects.get_or_create(
+        player=player, date=today, defaults={"bonus_ap": 0}
+    )
+    if not created:
+        state.bonus_awarded_today = True
+        state.bonus_ap = award.bonus_ap
+        return state, []
+
+    bonus_ap = int(GameSettings.current().daily_goals_completion_bonus_ap)
+    level_ups = player.add_activity(xp=bonus_ap) if bonus_ap else []
+
+    award.bonus_ap = bonus_ap
+    award.save(update_fields=["bonus_ap"])
+
+    state.bonus_awarded_today = True
+    state.bonus_ap = bonus_ap
+    return state, level_ups
diff --git a/progression/migrations/0023_dailygoalaward.py b/progression/migrations/0023_dailygoalaward.py
new file mode 100644
index 00000000..4cfa68c0
--- /dev/null
+++ b/progression/migrations/0023_dailygoalaward.py
@@ -0,0 +1,48 @@
+# Generated by Django 5.2.16 on 2026-08-10 00:00
+
+import django.db.models.deletion
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ("progression", "0022_note_activity_note_note_task_or_activity_not_both"),
+        ("users", "0013_player_link_points_multiplier"),
+    ]
+
+    operations = [
+        migrations.CreateModel(
+            name="DailyGoalAward",
+            fields=[
+                (
+                    "id",
+                    models.BigAutoField(
+                        auto_created=True,
+                        primary_key=True,
+                        serialize=False,
+                        verbose_name="ID",
+                    ),
+                ),
+                ("date", models.DateField()),
+                ("bonus_ap", models.PositiveIntegerField(default=0)),
+                ("created_at", models.DateTimeField(auto_now_add=True)),
+                (
+                    "player",
+                    models.ForeignKey(
+                        on_delete=django.db.models.deletion.CASCADE,
+                        related_name="daily_goal_awards",
+                        to="users.player",
+                    ),
+                ),
+            ],
+            options={
+                "constraints": [
+                    models.UniqueConstraint(
+                        fields=("player", "date"),
+                        name="unique_daily_goal_award_player_date",
+                    )
+                ],
+            },
+        ),
+    ]
diff --git a/progression/models.py b/progression/models.py
index 6de4ee2e..803c546c 100644
--- a/progression/models.py
+++ b/progression/models.py
@@ -768,6 +768,38 @@ def __str__(self):
         return f"OfflineActivityLedger(player={self.player_id}, date={self.date})"
 
 
+class DailyGoalAward(models.Model):
+    """
+    Records that a player's daily-goals completion bonus (issue #751) has
+    already been paid out for a given calendar day.
+
+    The unique constraint is what makes
+    ``progression.daily_goals.check_and_award_daily_goals`` idempotent under
+    concurrent activity completions - the row is only ever created once per
+    player per day, so a second completion in the same day can tell the
+    bonus has already been claimed instead of re-awarding it.
+    """
+
+    player = models.ForeignKey(
+        "users.Player",
+        on_delete=models.CASCADE,
+        related_name="daily_goal_awards",
+    )
+    date = models.DateField()
+    bonus_ap = models.PositiveIntegerField(default=0)
+    created_at = models.DateTimeField(auto_now_add=True)
+
+    class Meta:
+        constraints = [
+            models.UniqueConstraint(
+                fields=["player", "date"], name="unique_daily_goal_award_player_date"
+            )
+        ]
+
+    def __str__(self):
+        return f"DailyGoalAward(player={self.player_id}, date={self.date})"
+
+
 class CharacterActivity(TimeRecord):
     """
     Character's autonomous activity.
diff --git a/progression/services.py b/progression/services.py
index 579524ba..fe006729 100644
--- a/progression/services.py
+++ b/progression/services.py
@@ -104,6 +104,11 @@ def log_offline_activity(
 
     level_ups = player.add_activity(duration, xp=xp_gained) if xp_gained else []
 
+    from .daily_goals import check_and_award_daily_goals
+
+    _goals_state, bonus_level_ups = check_and_award_daily_goals(player)
+    level_ups = level_ups + bonus_level_ups
+
     return OfflineActivityLogResult(
         activity=activity,
         reward_summary=reward_summary,
diff --git a/progression/tests/test_daily_goals.py b/progression/tests/test_daily_goals.py
new file mode 100644
index 00000000..2e6c5591
--- /dev/null
+++ b/progression/tests/test_daily_goals.py
@@ -0,0 +1,192 @@
+"""Tests for the map-view "daily goals" badge (issue #751, replacing the
+old `points_today` mechanic from issue #673).
+
+Covers:
+- ``progression.daily_goals.get_daily_goals_state`` goal computation
+- ``progression.daily_goals.check_and_award_daily_goals`` idempotent bonus
+  award
+"""
+
+from datetime import timedelta
+
+from django.test import TestCase
+from django.utils import timezone
+
+from character.models import Character, PlayerCharacterLink
+from core.models import GameSettings
+from progression.daily_goals import (
+    MINUTES_GOAL_THRESHOLD,
+    check_and_award_daily_goals,
+    get_daily_goals_state,
+)
+from progression.models import DailyGoalAward, PlayerActivity
+from users.models import UserLogin
+from users.tests import user_factory
+
+
+class DailyGoalsTestBase(TestCase):
+    def setUp(self):
+        self.user = user_factory(with_player=True)
+        self.player = self.user.player
+        self.character = Character.objects.create(given_name="Hero")
+        PlayerCharacterLink.objects.create(player=self.player, character=self.character)
+
+    def complete_activity(self, minutes: int):
+        return PlayerActivity.objects.create(
+            player=self.player,
+            is_complete=True,
+            duration=minutes * 60,
+            completed_at=timezone.now(),
+        )
+
+
+class GetDailyGoalsStateTests(DailyGoalsTestBase):
+    def test_all_false_with_no_login_or_activity(self):
+        state = get_daily_goals_state(self.player)
+
+        self.assertFalse(state.logged_in_today)
+        self.assertFalse(state.completed_activity_today)
+        self.assertEqual(state.activity_minutes_today, 0)
+        self.assertFalse(state.minutes_goal_met)
+        self.assertFalse(state.all_goals_met)
+        self.assertFalse(state.bonus_awarded_today)
+        self.assertEqual(state.bonus_ap, 0)
+
+    def test_logged_in_today_reflects_userlogin(self):
+        UserLogin.objects.create(user=self.user)
+
+        state = get_daily_goals_state(self.player)
+
+        self.assertTrue(state.logged_in_today)
+        self.assertFalse(state.all_goals_met)
+
+    def test_activity_below_threshold_does_not_meet_minutes_goal(self):
+        self.complete_activity(MINUTES_GOAL_THRESHOLD - 1)
+
+        state = get_daily_goals_state(self.player)
+
+        self.assertTrue(state.completed_activity_today)
+        self.assertFalse(state.minutes_goal_met)
+
+    def test_activity_at_threshold_meets_minutes_goal(self):
+        self.complete_activity(MINUTES_GOAL_THRESHOLD)
+
+        state = get_daily_goals_state(self.player)
+
+        self.assertTrue(state.minutes_goal_met)
+
+    def test_several_short_activities_accumulate_toward_minutes_goal(self):
+        for _ in range(MINUTES_GOAL_THRESHOLD):
+            self.complete_activity(1)
+
+        state = get_daily_goals_state(self.player)
+
+        self.assertEqual(state.activity_minutes_today, MINUTES_GOAL_THRESHOLD)
+        self.assertTrue(state.minutes_goal_met)
+
+    def test_incomplete_activity_not_counted(self):
+        PlayerActivity.objects.create(
+            player=self.player,
+            is_complete=False,
+            duration=600,
+        )
+
+        state = get_daily_goals_state(self.player)
+
+        self.assertFalse(state.completed_activity_today)
+        self.assertEqual(state.activity_minutes_today, 0)
+
+    def test_yesterdays_activity_not_counted(self):
+        yesterday = timezone.now() - timedelta(days=1, hours=1)
+        PlayerActivity.objects.create(
+            player=self.player,
+            is_complete=True,
+            duration=600,
+            completed_at=yesterday,
+        )
+
+        state = get_daily_goals_state(self.player, today=timezone.localdate())
+
+        self.assertFalse(state.completed_activity_today)
+
+    def test_all_goals_met_when_logged_in_and_activity_clears_minutes(self):
+        UserLogin.objects.create(user=self.user)
+        self.complete_activity(MINUTES_GOAL_THRESHOLD)
+
+        state = get_daily_goals_state(self.player)
+
+        self.assertTrue(state.all_goals_met)
+
+    def test_reflects_existing_award_row(self):
+        today = timezone.localdate()
+        DailyGoalAward.objects.create(player=self.player, date=today, bonus_ap=42)
+
+        state = get_daily_goals_state(self.player, today=today)
+
+        self.assertTrue(state.bonus_awarded_today)
+        self.assertEqual(state.bonus_ap, 42)
+
+
+class CheckAndAwardDailyGoalsTests(DailyGoalsTestBase):
+    def test_no_award_when_goals_not_met(self):
+        state, level_ups = check_and_award_daily_goals(self.player)
+
+        self.assertFalse(state.all_goals_met)
+        self.assertEqual(level_ups, [])
+        self.assertFalse(DailyGoalAward.objects.filter(player=self.player).exists())
+
+    def test_awards_configured_bonus_when_all_goals_met(self):
+        settings = GameSettings.current()
+        settings.daily_goals_completion_bonus_ap = 30
+        settings.save(update_fields=["daily_goals_completion_bonus_ap"])
+
+        UserLogin.objects.create(user=self.user)
+        self.complete_activity(MINUTES_GOAL_THRESHOLD)
+
+        starting_xp = self.player.xp
+        state, _level_ups = check_and_award_daily_goals(self.player)
+
+        self.assertTrue(state.all_goals_met)
+        self.assertTrue(state.bonus_awarded_today)
+        self.assertEqual(state.bonus_ap, 30)
+
+        self.player.refresh_from_db()
+        self.assertEqual(self.player.xp, starting_xp + 30)
+
+        award = DailyGoalAward.objects.get(
+            player=self.player, date=timezone.localdate()
+        )
+        self.assertEqual(award.bonus_ap, 30)
+
+    def test_bonus_not_awarded_twice_in_the_same_day(self):
+        settings = GameSettings.current()
+        settings.daily_goals_completion_bonus_ap = 30
+        settings.save(update_fields=["daily_goals_completion_bonus_ap"])
+
+        UserLogin.objects.create(user=self.user)
+        self.complete_activity(MINUTES_GOAL_THRESHOLD)
+
+        check_and_award_daily_goals(self.player)
+        self.player.refresh_from_db()
+        xp_after_first_award = self.player.xp
+
+        self.complete_activity(MINUTES_GOAL_THRESHOLD)
+        state, level_ups = check_and_award_daily_goals(self.player)
+
+        self.assertEqual(level_ups, [])
+        self.assertEqual(state.bonus_ap, 30)
+        self.player.refresh_from_db()
+        self.assertEqual(self.player.xp, xp_after_first_award)
+        self.assertEqual(DailyGoalAward.objects.filter(player=self.player).count(), 1)
+
+    def test_returns_level_ups_when_bonus_crosses_a_level(self):
+        settings = GameSettings.current()
+        settings.daily_goals_completion_bonus_ap = 1000
+        settings.save(update_fields=["daily_goals_completion_bonus_ap"])
+
+        UserLogin.objects.create(user=self.user)
+        self.complete_activity(MINUTES_GOAL_THRESHOLD)
+
+        _state, level_ups = check_and_award_daily_goals(self.player)
+
+        self.assertTrue(level_ups)
diff --git a/progression/tests/test_offline_activity_logging.py b/progression/tests/test_offline_activity_logging.py
index 997d49eb..79e6e327 100644
--- a/progression/tests/test_offline_activity_logging.py
+++ b/progression/tests/test_offline_activity_logging.py
@@ -242,6 +242,32 @@ def test_uses_same_xp_multiplier_rules_as_timer_completion(self):
         expected = result.activity.get_xp_reward_summary(duration=600)
         self.assertEqual(result.activity.xp_gained, expected["xp_gained"])
 
+    def test_offline_logging_can_clear_daily_goals(self):
+        """Offline-logged activities count toward the daily-goals badge
+        (issue #751) the same as timer-based completions - both are player
+        activity completions."""
+        from users.models import UserLogin
+
+        from progression.daily_goals import MINUTES_GOAL_THRESHOLD
+        from progression.models import DailyGoalAward
+
+        UserLogin.objects.create(user=self.user)
+        completed_at = timezone.now() - timedelta(minutes=5)
+        started_at = completed_at - timedelta(minutes=MINUTES_GOAL_THRESHOLD)
+
+        log_offline_activity(
+            self.player,
+            name="Evening chores",
+            started_at=started_at,
+            completed_at=completed_at,
+        )
+
+        self.assertTrue(
+            DailyGoalAward.objects.filter(
+                player=self.player, date=timezone.localdate()
+            ).exists()
+        )
+
 
 class PlayerActivityLogOfflineApiTests(APITestCase):
     def setUp(self):
diff --git a/users/tests/tests.py b/users/tests/tests.py
index 551a522d..3bfcf425 100644
--- a/users/tests/tests.py
+++ b/users/tests/tests.py
@@ -46,9 +46,7 @@
 class UserCreationTest(TestCase):
     @classmethod
     def setUpTestData(cls):
-        cls.character = Character.objects.create(
-            given_name="Jane", sex="Female", can_link=True
-        )
+        cls.character = Character.objects.create(given_name="Jane", sex="Female")
         cls.user = user_factory(
             with_player=True, email="testuser@example.com", password="testpassword123"
         )
@@ -121,9 +119,7 @@ def test_admin_created_user_gets_player_and_activity_timer(self):
 class PlayerNameValidationTest(TestCase):
     @classmethod
     def setUpTestData(cls):
-        cls.character = Character.objects.create(
-            given_name="Jane", sex="Female", can_link=True
-        )
+        cls.character = Character.objects.create(given_name="Jane", sex="Female")
 
     def setUp(self):
         self.user = user_factory(with_player=True)
@@ -247,7 +243,7 @@ def test_completed_tier_five_stays_visible_as_complete(self):
         self.assertEqual([goal["next_threshold"] for goal in goals], [None, None, None])
 
     def test_player_serializer_includes_achievements(self):
-        Character.objects.create(given_name="Jane", can_link=True)
+        Character.objects.create(given_name="Jane")
         user = user_factory(with_player=True)
 
         data = PlayerSerializer(user.player).data
@@ -301,8 +297,8 @@ def test_initial_onboarding(self):
 @tag("fast")
 class PlayerMethodsTest(TestCase):
     def setUp(self):
-        self.character = Character.objects.create(given_name="Jane", can_link=True)
-        self.character2 = Character.objects.create(given_name="John", can_link=True)
+        self.character = Character.objects.create(given_name="Jane")
+        self.character2 = Character.objects.create(given_name="John")
         self.user = user_factory(with_player=True)
 
     def test_player_add_activity(self):
@@ -380,7 +376,7 @@ def test_unregister_connection_is_idempotent_at_zero(self):
 
 class UserLoginModelTest(TestCase):
     def setUp(self):
-        Character.objects.create(given_name="Jane", can_link=True)
+        Character.objects.create(given_name="Jane")
         self.user = user_factory(with_player=True)
 
     def _create_login(self, days_ago):
@@ -467,7 +463,7 @@ def test_annotate_first_of_day_empty_list_is_a_noop(self):
 
 class JwtLoginTrackingTest(TestCase):
     def setUp(self):
-        Character.objects.create(given_name="Jane", can_link=True)
+        Character.objects.create(given_name="Jane")
         self.user = user_factory(
             with_player=True, email="test@example.com", password="testpassword123"
         )
@@ -486,7 +482,7 @@ def test_token_serializer_creates_user_login_record(self):
 
 class DailyLoginRewardTest(TestCase):
     def setUp(self):
-        Character.objects.create(given_name="Jane", can_link=True)
+        Character.objects.create(given_name="Jane")
         self.user = user_factory(with_player=True)
 
     def _login_via_jwt(self):
@@ -546,7 +542,7 @@ def test_streak_reward_is_capped_at_20_xp(self):
 
 class UserTimezoneApiTest(TestCase):
     def setUp(self):
-        Character.objects.create(given_name="Jane", can_link=True)
+        Character.objects.create(given_name="Jane")
         self.user = user_factory(with_player=True)
         self.factory = APIRequestFactory()
 
@@ -568,7 +564,7 @@ def test_me_settings_patch_updates_timezone(self):
 
 class UserTimezoneMiddlewareTest(TestCase):
     def setUp(self):
-        Character.objects.create(given_name="Jane", can_link=True)
+        Character.objects.create(given_name="Jane")
         self.user = user_factory(with_player=True)
         self.user.timezone = "Europe/Paris"
         self.user.save(update_fields=["timezone"])
@@ -744,7 +740,7 @@ def test_wiped_player_is_marked_offline(self):
 
 class CustomAccountAdapterTest(TestCase):
     def setUp(self):
-        Character.objects.create(given_name="Jane", can_link=True)
+        Character.objects.create(given_name="Jane")
         self.user = user_factory(with_player=True)
 
     @patch("users.adapters.send_rendered_email_task.delay")
@@ -777,12 +773,10 @@ def setUp(self):
         self.npc1 = Character.objects.create(
             given_name="Available",
             sex="Male",
-            can_link=True,
         )
         self.npc2 = Character.objects.create(
             given_name="Available",
             sex="Female",
-            can_link=True,
         )
 
         # Create a user and player
@@ -817,14 +811,13 @@ def test_assign_character_filters_correctly(self):
         unlinkable = Character.objects.create(
             given_name="Unlinkable",
             sex="Male",
-            can_link=False,
+            is_reserved=True,
         )
 
         # Create a dead character
         dead = Character.objects.create(
             given_name="Dead",
             sex="Female",
-            can_link=True,
             death_date=date.today(),
         )
 
@@ -872,7 +865,7 @@ class CustomUserAdminChangelistQueryTest(TestCase):
     """
 
     def setUp(self):
-        Character.objects.create(given_name="Jane", can_link=True)
+        Character.objects.create(given_name="Jane")
         self.plan = SubscriptionPlan.objects.create(
             name="Premium", price="9.99", interval="monthly"
         )
@@ -930,7 +923,7 @@ class CustomUserAdminChangeViewQueryTest(TestCase):
     """
 
     def setUp(self):
-        Character.objects.create(given_name="Jane", can_link=True)
+        Character.objects.create(given_name="Jane")
         self.admin_user = get_user_model().objects.create_superuser(
             email="superadmin@example.com", password="testpassword123"
         )
diff --git a/users/utils.py b/users/utils.py
index 85b63c31..84dfa6d8 100644
--- a/users/utils.py
+++ b/users/utils.py
@@ -39,11 +39,7 @@ def assign_character_to_player(player):
     any currently active character and associates a new NPC with the Player.
     """
 
-    character = (
-        Character.objects.filter(can_link=True, death_date__isnull=True)
-        .exclude(links__is_active=True)
-        .first()
-    )
+    character = Character.objects.linkable().filter(death_date__isnull=True).first()
 
     if not character:
         logger.warning(f"No available NPC character to assign to player {player.id}")