fix(learning): harden maintenance scheduler lifecycle

aceclaw-daemon/src/main/java/dev/aceclaw/daemon/LearningMaintenanceScheduler.java

@@ -31,6 +31,7 @@ public final class LearningMaintenanceScheduler {
     private final IntSupplier activeSessionCount;
     private final LongSupplier largestMemoryFileBytes;
     private final MaintenancePipeline pipeline;
+    private final Object lifecycleLock = new Object();
 
     private final AtomicBoolean running = new AtomicBoolean(false);
     private final AtomicBoolean maintenanceRunning = new AtomicBoolean(false);
@@ -57,17 +58,21 @@ public LearningMaintenanceScheduler(Config config,
     }
 
     public void start() {
-        if (!running.compareAndSet(false, true)) {
-            log.debug("LearningMaintenanceScheduler already running");
-            return;
+        synchronized (lifecycleLock) {
+            if (running.get()) {
+                log.debug("LearningMaintenanceScheduler already running");
+                return;
+            }
+            var nextScheduler = Executors.newSingleThreadScheduledExecutor(r -> {
+                var thread = new Thread(r, "learning-maintenance-scheduler");
+                thread.setDaemon(true);
+                return thread;
+            });
+            long tickMillis = Math.max(1, config.tickInterval().toMillis());
+            nextScheduler.scheduleAtFixedRate(this::tick, tickMillis, tickMillis, TimeUnit.MILLISECONDS);
+            scheduler = nextScheduler;
+            running.set(true);
         }
-        scheduler = Executors.newSingleThreadScheduledExecutor(r -> {
-            var thread = new Thread(r, "learning-maintenance-scheduler");
-            thread.setDaemon(true);
-            return thread;
-        });
-        long tickMillis = Math.max(1, config.tickInterval().toMillis());
-        scheduler.scheduleAtFixedRate(this::tick, tickMillis, tickMillis, TimeUnit.MILLISECONDS);
         log.info("LearningMaintenanceScheduler started: tick={}s timeTrigger={}h sessionTrigger={} sizeTrigger={}KB idleTrigger={}m",
                 config.tickInterval().toSeconds(),
                 config.timeTriggerInterval().toHours(),
@@ -77,18 +82,27 @@ public void start() {
     }
 
     public void stop() {
-        if (!running.compareAndSet(true, false)) {
-            return;
+        ScheduledExecutorService currentScheduler;
+        synchronized (lifecycleLock) {
+            if (!running.get()) {
+                return;
+            }
+            running.set(false);
+            currentScheduler = scheduler;
+            scheduler = null;
         }
-        if (scheduler != null) {
-            scheduler.shutdown();
+        if (currentScheduler != null) {
+            currentScheduler.shutdown();
             try {
-                if (!scheduler.awaitTermination(10, TimeUnit.SECONDS)) {
-                    scheduler.shutdownNow();
+                if (!currentScheduler.awaitTermination(10, TimeUnit.SECONDS)) {
+                    currentScheduler.shutdownNow();
                 }
             } catch (InterruptedException e) {
-                scheduler.shutdownNow();
+                currentScheduler.shutdownNow();
                 Thread.currentThread().interrupt();
+            } finally {
+                maintenanceRunning.set(false);
+                sessionsSinceLastRun.set(0);
             }
         }
         log.info("LearningMaintenanceScheduler stopped");
@@ -98,6 +112,10 @@ public boolean isRunning() {
         return running.get();
     }
 
+    boolean isMaintenanceRunningForTest() {
+        return maintenanceRunning.get();
+    }
+
     public void onSessionClosed() {
         if (!running.get()) {
             return;
@@ -135,12 +153,13 @@ private void tryTrigger(Trigger trigger) {
         if (!maintenanceRunning.compareAndSet(false, true)) {
             return;
         }
+        int sessionsAtStart = sessionsSinceLastRun.get();
 
         Thread.ofVirtual().name("learning-maintenance-" + trigger.id()).start(() -> {
             try {
                 pipeline.run(trigger.id());
                 lastRunAt = clock.instant();
-                sessionsSinceLastRun.set(0);
+                sessionsSinceLastRun.updateAndGet(current -> Math.max(0, current - sessionsAtStart));
                 if (trigger == Trigger.SIZE_THRESHOLD) {
                     sizeTriggerArmed = false;
                 }

aceclaw-daemon/src/test/java/dev/aceclaw/daemon/LearningMaintenanceSchedulerTest.java

@@ -9,6 +9,7 @@
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.List;
+import java.util.concurrent.CountDownLatch;
 import java.util.concurrent.atomic.AtomicInteger;
 import java.util.concurrent.atomic.AtomicLong;
 
@@ -121,6 +122,51 @@ void sessionCloseDoesNotTriggerWhileStopped() throws Exception {
         assertThat(triggers).isEmpty();
     }
 
+    @Test
+    void sessionsClosedDuringMaintenanceArePreserved() throws Exception {
+        var clock = new MutableClock(Instant.parse("2026-03-13T10:00:00Z"));
+        var activeSessions = new AtomicInteger(0);
+        var memoryBytes = new AtomicLong(0);
+        var triggers = Collections.synchronizedList(new ArrayList<String>());
+        var started = new CountDownLatch(1);
+        var release = new CountDownLatch(1);
+        var scheduler = new LearningMaintenanceScheduler(
+                new LearningMaintenanceScheduler.Config(
+                        Duration.ofHours(6),
+                        2,
+                        50L * 1024L,
+                        Duration.ofMinutes(5),
+                        Duration.ofDays(1)),
+                clock,
+                activeSessions::get,
+                memoryBytes::get,
+                trigger -> {
+                    triggers.add(trigger);
+                    started.countDown();
+                    release.await();
+                }
+        );
+        scheduler.start();
+        try {
+            scheduler.onSessionClosed();
+            scheduler.onSessionClosed();
+            assertThat(started.await(2, java.util.concurrent.TimeUnit.SECONDS)).isTrue();
+            assertThat(triggers).containsExactly("session-count");
+
+            scheduler.onSessionClosed();
+
+            release.countDown();
+            waitForMaintenanceToSettle(scheduler);
+
+            scheduler.onSessionClosed();
+            waitForTriggers(triggers, 2);
+
+            assertThat(triggers).containsExactly("session-count", "session-count");
+        } finally {
+            scheduler.stop();
+        }
+    }
+
     private static LearningMaintenanceScheduler scheduler(MutableClock clock,
                                                           AtomicInteger activeSessions,
                                                           AtomicLong memoryBytes,
@@ -154,6 +200,17 @@ private static void waitForTriggers(List<String> triggers, int expected) throws
         throw new AssertionError("Timed out waiting for trigger count " + expected + ", got " + triggers.size());
     }
 
+    private static void waitForMaintenanceToSettle(LearningMaintenanceScheduler scheduler) throws InterruptedException {
+        long deadline = System.currentTimeMillis() + 2_000;
+        while (System.currentTimeMillis() < deadline) {
+            if (!scheduler.isMaintenanceRunningForTest()) {
+                return;
+            }
+            Thread.sleep(20);
+        }
+        throw new AssertionError("Timed out waiting for maintenance to settle");
+    }
+
     private static final class MutableClock extends Clock {
         private Instant instant;
 

aceclaw-memory/src/main/java/dev/aceclaw/memory/AutoMemoryStore.java

@@ -348,6 +348,7 @@ private static long fileSize(Path file) {
         try {
             return Files.exists(file) ? Files.size(file) : 0L;
         } catch (IOException e) {
+            log.debug("Failed to read memory file size for {}: {}", file, e.getMessage());
             return 0L;
         }
     }