Fix Smart Dispatch scheduler reconciliation

Author: samuelkcc

CHANGELOG.md

@@ -1,5 +1,20 @@
 # Changelog
 
+## Unreleased
+
+- Fixed Raspberry Pi Smart Dispatch synchronization so FoxESS receives dynamic
+  charging periods in the next 24 hours, including slots that begin after
+  midnight on the following calendar date.
+- Queued dispatch changes that arrive while a FoxESS scheduler write is being
+  confirmed, so the newest schedule is applied immediately instead of being
+  silently skipped until a later polling cycle.
+- Refresh the visible Active Mode Scheduler shortly after Octopus dispatches
+  change, instead of leaving it stale until the normal 10-minute FoxESS poll.
+- Detect Smart Dispatch additions and removals in the Raspberry Pi worker within
+  15 seconds, without increasing the standalone HTML edition's polling rate.
+- Refresh Octopus and the REST-confirmed FoxESS scheduler immediately when an
+  iPhone or other LAN dashboard returns from the background.
+
 ## v2026.08.01.3 — 2026-08-01
 
 - Fix tariff charts escaping their dashboard column when the browser becomes

RELEASE_NOTES.md

@@ -421,3 +421,28 @@ v2026.07.26.9:
 
 - JavaScript syntax, scheduler, tariff-selection, chart, encrypted-state, proxy restriction, static-GUI, standalone build, and Raspberry Pi package checks run through `npm run check`.
 - GitHub Pages continues to publish `Octopus_IGO_Smart_Charging_Detector.html` as the root app.
+## Smart Dispatch scheduler reconciliation v2026.08.19.1
+
+### Fixed
+
+- Includes every valid Smart Dispatch in the next 24 hours, including
+  after-midnight periods, when constructing the FoxESS schedule.
+- Queues a fresh scheduler evaluation if Octopus changes while FoxESS is still
+  confirming the preceding write.
+- Removes obsolete dynamic Forced Charge periods promptly after Octopus removes
+  a dispatch, while preserving intentional weekly charge periods.
+
+### Improved
+
+- The Raspberry Pi worker detects dispatch additions and removals within 15
+  seconds and writes only when the calculated FoxESS schedule differs.
+- The Pi dashboard re-reads the confirmed scheduler after a dispatch change and
+  refreshes immediately when an iPhone or LAN client returns to the foreground.
+- Live WS remains read-only telemetry; all scheduler changes use official
+  FoxESS REST requests with confirmation readback.
+
+### Validation
+
+- Covers overnight dispatch selection, queued schedule reconciliation, Pi-only
+  fast polling, mobile resume refresh, Live WS policy, Linux service behavior,
+  and both release artifacts.

package-lock.json

@@ -1,6 +1,6 @@
 {
   "name": "octopus-foxess-smart-charging",
-  "version": "2026.8.1.3",
+  "version": "2026.8.19.1",
   "private": true,
   "type": "module",
   "dependencies": {

package.json

@@ -41,12 +41,13 @@ const utilities = new Function(`
   ${extractFunction('getWeeklyModePeriods')}
   ${extractFunction('getWeeklyForcedChargePeriods')}
   ${extractFunction('getWeeklyForcedDischargePeriods')}
+  ${extractFunction('getUpcomingSmartDispatches')}
   ${extractFunction('resolveAutomationMinute')}
   ${extractFunction('buildScheduleGroupsFromTimeline')}
   ${extractFunction('getAutoResumeSource')}
   ${extractFunction('getAutoResumeUntil')}
   ${extractFunction('isScheduleMinuteSuppressed')}
-  return { window, isFoxScheduleActiveAt, getActiveFoxScheduleAt, getEffectiveFoxWorkMode, scheduleFingerprint, prepareFoxSchedulePayload, getActiveAgreement, selectActiveElectricityTariffs, getProductCodeFromTariffCode, getRateAtTime, getTariffSlotsForDate, getWeeklyForcedChargePeriods, getWeeklyForcedDischargePeriods, resolveAutomationMinute, buildScheduleGroupsFromTimeline, getAutoResumeSource, getAutoResumeUntil, isScheduleMinuteSuppressed };
+  return { window, isFoxScheduleActiveAt, getActiveFoxScheduleAt, getEffectiveFoxWorkMode, scheduleFingerprint, prepareFoxSchedulePayload, getActiveAgreement, selectActiveElectricityTariffs, getProductCodeFromTariffCode, getRateAtTime, getTariffSlotsForDate, getWeeklyForcedChargePeriods, getWeeklyForcedDischargePeriods, getUpcomingSmartDispatches, resolveAutomationMinute, buildScheduleGroupsFromTimeline, getAutoResumeSource, getAutoResumeUntil, isScheduleMinuteSuppressed };
 `)();
 
 const tariffNow = new Date('2026-07-26T12:00:00Z');
@@ -192,6 +193,21 @@ assert.deepEqual(
 );
 assert.deepEqual(utilities.getWeeklyForcedChargePeriods({ enabled: true, startTime: '05:30', endTime: '05:30', days: [1] }, new Date(2026, 6, 20, 12, 0)), []);
 
+const eveningDispatchCheck = new Date(2026, 7, 19, 20, 21);
+const upcomingDispatches = utilities.getUpcomingSmartDispatches([
+  { startDt: '2026-08-19T21:30:00+01:00', endDt: '2026-08-19T22:00:00+01:00' },
+  { startDt: '2026-08-20T02:00:00+01:00', endDt: '2026-08-20T03:00:00+01:00' },
+  { startDt: '2026-08-20T03:30:00+01:00', endDt: '2026-08-20T04:00:00+01:00' },
+  { startDt: '2026-08-20T05:00:00+01:00', endDt: '2026-08-20T05:30:00+01:00' },
+  { startDt: '2026-08-20T21:30:00+01:00', endDt: '2026-08-20T22:00:00+01:00' },
+  { startDt: 'invalid', endDt: 'invalid' }
+], eveningDispatchCheck);
+assert.deepEqual(
+  upcomingDispatches.map(dispatch => [dispatch.start.getDate(), dispatch.start.getHours(), dispatch.start.getMinutes()]),
+  [[19, 21, 30], [20, 2, 0], [20, 3, 30], [20, 5, 0]],
+  'The FoxESS schedule must include every valid dispatch in the next 24 hours, including slots after midnight'
+);
+
 const dischargeOvernight = utilities.getWeeklyForcedDischargePeriods({
   enabled: true,
   startTime: '23:30',
@@ -270,6 +286,12 @@ assert.equal(utilities.isScheduleMinuteSuppressed(fulfilledWeekly, 'weekly', new
 
 assert.doesNotMatch(source, /localStorage\.setItem\(['"](?:octoAcc|octoApi|foxSn|foxToken|gasUrl)['"]/);
 assert.match(source, /if \(refreshTimerId !== null\) clearInterval\(refreshTimerId\)/);
+assert.match(source, /function scheduleFoxScheduleReadbacks\(\)[\s\S]*?\[5000, 20000, 40000\]/, 'A changed Octopus dispatch must trigger prompt FoxESS REST readbacks in the visible dashboard');
+assert.match(source, /currentDispatchesStr !== lastDispatchesStr[\s\S]*?scheduleFoxScheduleReadbacks\(\)/, 'Dispatch changes must start the FoxESS scheduler readback sequence');
+assert.match(source, /function getEffectiveOctopusRefreshInterval\(\)[\s\S]*?window\.linuxRole === 'worker'[\s\S]*?LINUX_WORKER_OCTOPUS_INTERVAL_SECONDS/, 'The Pi worker must detect added and removed dispatches faster than the visible dashboard polling interval');
+assert.match(source, /document\.addEventListener\('visibilitychange'[\s\S]*?refreshLinuxDashboardAfterResume/, 'A resumed iPhone dashboard must immediately refresh its Octopus and FoxESS state');
+assert.match(source, /window\.addEventListener\('pageshow', refreshLinuxDashboardAfterResume\)/, 'A restored iOS page must immediately refresh its scheduler state');
+assert.match(source, /if \(!window\.linuxRuntime \|\| window\.linuxRole === 'worker' \|\| !activeCredentials\)/, 'Pi dashboard resume handling must not affect the standalone HTML edition');
 assert.match(source, /async function fetchJson/);
 assert.match(source, /dispatchActiveNow/, 'Auto-Resume must not cancel an active Smart Dispatch');
 assert.match(source, /if \(isAutoPrice && window\.importRates\?\.length\)/, 'Target-price charging must use import rates');
@@ -284,6 +306,8 @@ assert.match(source, /getElementById\('importPriceChart'\)/, 'The import tariff
 assert.match(source, /getElementById\('exportPriceChart'\)/, 'The export tariff must use its own chart');
 assert.match(source, /window\.linuxRole === 'worker'/, 'Only the Raspberry Pi worker may run unattended actions');
 assert.match(source, /if \(!btn && !canRunAutomaticActions\(\)\) return false/, 'LAN dashboards must not duplicate unattended schedule writes');
+assert.match(source, /if \(isCurrentlyUpdatingMode\) \{[\s\S]*?pendingAutomationEvaluation = true;/, 'A dispatch refresh during a FoxESS write must queue the newest automation schedule');
+assert.match(source, /if \(pendingAutomationEvaluation\) \{[\s\S]*?evaluateLocalAutomations\(null, true\)/, 'A queued automation schedule must run as soon as the current FoxESS write completes');
 assert.match(source, /gasUrl: '\/api\/foxess'/, 'Raspberry Pi credentials must use the local FoxESS relay');
 assert.match(source, /scheduleFetchButton\.style\.display = hideManualFetch \? 'none' : ''/, 'Live WS must hide the redundant scheduler Fetch Now button');
 assert.match(source, /async function setLiveWsPolicy\(policy\)/, 'The Mobile and LAN dashboard must support all three Live WS policies');

scripts/test.mjs

@@ -10,10 +10,12 @@ let octoCountdown = 60;
 let foxRefreshInterval = 600;
 let foxCountdown = 600;
 let refreshTimerId = null;
+let foxScheduleReadbackTimeoutIds = [];
 let linuxConfigPollId = null;
 let linuxLiveTelemetryPollId = null;
 let linuxLiveTelemetryBusy = false;
 let activeCredentials = null;
+let pendingAutomationEvaluation = false;
 
 const CREDENTIAL_STORAGE_KEY = 'encryptedCredentialsV1';
 const CREDENTIAL_DB_NAME = 'octopusFoxessSecureStorage';
@@ -22,6 +24,7 @@ const LINUX_CONFIG_ENDPOINT = '/api/config';
 const LINUX_OCTOPUS_ENDPOINT = '/api/octopus';
 const LINUX_FOX_LIVE_ENDPOINT = '/api/foxess/live';
 const LINUX_ACCESS_STORAGE_KEY = 'octopusFoxessDashboardAccessCode';
+const LINUX_WORKER_OCTOPUS_INTERVAL_SECONDS = 15;
 const DASHBOARD_SECTION_VISIBILITY_KEY = 'dashboardSectionVisibilityV1';
 const DASHBOARD_SECTION_IDS = {
     intelligentOctopus: 'section-intelligent-octopus',
@@ -407,6 +410,8 @@ function removeSavedAccessCode() {
     sessionStorage.removeItem('sessionCredentials');
     if (refreshTimerId !== null) clearInterval(refreshTimerId);
     refreshTimerId = null;
+    foxScheduleReadbackTimeoutIds.forEach(clearTimeout);
+    foxScheduleReadbackTimeoutIds = [];
     if (linuxLiveTelemetryPollId !== null) clearInterval(linuxLiveTelemetryPollId);
     linuxLiveTelemetryPollId = null;
     document.getElementById('dashboard')?.classList.remove('visible');
@@ -421,6 +426,53 @@ function removeSavedAccessCode() {
     document.getElementById('local-access-key')?.focus();
 }
 
+function scheduleFoxScheduleReadbacks() {
+    if (!window.linuxRuntime || window.linuxRole === 'worker' || !globalFoxSN || !globalGasUrl) return;
+
+    // The unattended worker and visible dashboard poll Octopus independently.
+    // Give the worker up to one complete poll cycle to write the new schedule,
+    // while refreshing the visible REST-confirmed state much sooner than 10 min.
+    foxScheduleReadbackTimeoutIds.forEach(clearTimeout);
+    foxScheduleReadbackTimeoutIds = [5000, 20000, 40000].map(delay => setTimeout(() => {
+        fetchFoxSchedules().catch(error => {
+            console.warn('FoxESS schedule readback after a dispatch change failed.', error);
+        });
+    }, delay));
+}
+
+function getEffectiveOctopusRefreshInterval() {
+    if (window.linuxRuntime && window.linuxRole === 'worker') {
+        return Math.min(octoRefreshInterval, LINUX_WORKER_OCTOPUS_INTERVAL_SECONDS);
+    }
+    return octoRefreshInterval;
+}
+
+let linuxDashboardResumeRefreshPromise = null;
+
+function refreshLinuxDashboardAfterResume() {
+    if (!window.linuxRuntime || window.linuxRole === 'worker' || !activeCredentials) return Promise.resolve();
+    if (document.visibilityState === 'hidden') return Promise.resolve();
+    if (linuxDashboardResumeRefreshPromise) return linuxDashboardResumeRefreshPromise;
+
+    linuxDashboardResumeRefreshPromise = (async () => {
+        await initDashboard(true);
+        scheduleFoxScheduleReadbacks();
+        if (globalFoxSN && globalGasUrl) await fetchFoxSchedules();
+    })().catch(error => {
+        console.warn('Raspberry Pi dashboard refresh after resume failed.', error);
+    }).finally(() => {
+        linuxDashboardResumeRefreshPromise = null;
+    });
+
+    return linuxDashboardResumeRefreshPromise;
+}
+
+document.addEventListener('visibilitychange', () => {
+    if (document.visibilityState === 'visible') refreshLinuxDashboardAfterResume();
+});
+window.addEventListener('pageshow', refreshLinuxDashboardAfterResume);
+window.addEventListener('focus', refreshLinuxDashboardAfterResume);
+
 function startLinuxWorkerConfigPoll() {
     if (!window.linuxRuntime || window.linuxRole !== 'worker' || linuxConfigPollId !== null) return;
     linuxConfigPollId = setInterval(async () => {
@@ -1392,31 +1444,34 @@ async function initDashboard(isAutoRefresh = false, retryCount = 1) {
 }
 
 function startAutoRefreshTimer() {
-    window.nextOctoTime = Date.now() + (octoRefreshInterval * 1000);
+    const initialOctoInterval = getEffectiveOctopusRefreshInterval();
+    window.nextOctoTime = Date.now() + (initialOctoInterval * 1000);
     window.nextFoxTime = Date.now() + (foxRefreshInterval * 1000);
 
     if (refreshTimerId !== null) clearInterval(refreshTimerId);
     refreshTimerId = setInterval(() => {
         const now = Date.now();
+        const effectiveOctoInterval = getEffectiveOctopusRefreshInterval();
 
         // 1. Octopus Logic Loop
         octoCountdown = Math.max(0, Math.ceil((window.nextOctoTime - now) / 1000));
-        updateCircleTimer('octo-timer', octoCountdown, octoRefreshInterval);
+        updateCircleTimer('octo-timer', octoCountdown, effectiveOctoInterval);
 
         if (now >= window.nextOctoTime) {
-            window.nextOctoTime = now + (octoRefreshInterval * 1000);
+            window.nextOctoTime = now + (effectiveOctoInterval * 1000);
             initDashboard(true).then(() => {
                 const currentDispatchesStr = JSON.stringify(window.currentDispatches || []);
                 if (currentDispatchesStr !== lastDispatchesStr) {
                     lastDispatchesStr = currentDispatchesStr;
+                    scheduleFoxScheduleReadbacks();
                 }
                 // Tariff slots, Smart Dispatches, and today's weekly windows can
                 // all change after an Octopus refresh. Rebuild the complete,
                 // conflict-resolved timeline once instead of updating one rule.
                 if (hasEnabledLocalAutomation()) {
                     evaluateLocalAutomations(null, true);
                 }
-                updateCircleTimer('octo-timer', octoCountdown, octoRefreshInterval);
+                updateCircleTimer('octo-timer', octoCountdown, effectiveOctoInterval);
             });
         }
 
@@ -1960,6 +2015,25 @@ function getWeeklyForcedDischargePeriods(config, now = new Date(), fdSoc = 11) {
     return getWeeklyModePeriods(config, now, 'ForceDischarge', 'dischargeSchedule', fdSoc);
 }
 
+function getUpcomingSmartDispatches(dispatches, now = new Date(), horizonHours = 24) {
+    const nowTime = now.getTime();
+    const horizonTime = nowTime + horizonHours * 60 * 60 * 1000;
+
+    return (dispatches || [])
+        .map(dispatch => ({
+            ...dispatch,
+            start: new Date(dispatch.startDt),
+            end: new Date(dispatch.endDt)
+        }))
+        .filter(dispatch =>
+            Number.isFinite(dispatch.start.getTime())
+            && Number.isFinite(dispatch.end.getTime())
+            && dispatch.end > now
+            && dispatch.start < horizonTime
+        )
+        .sort((a, b) => a.start - b.start);
+}
+
 function resolveAutomationMinute(existingState, incomingState, options) {
     options = options || {};
     if (!incomingState) return existingState;
@@ -2130,6 +2204,12 @@ async function pushGroupsToFoxESS(groups, maxAttempts = 3) {
         throw lastError || new Error('FoxESS schedule synchronization failed');
     } finally {
         isCurrentlyUpdatingMode = false;
+        if (pendingAutomationEvaluation) {
+            pendingAutomationEvaluation = false;
+            setTimeout(() => {
+                if (hasEnabledLocalAutomation()) evaluateLocalAutomations(null, true);
+            }, 0);
+        }
     }
 }
 
@@ -2211,8 +2291,12 @@ function resetAutomationApplyButton(button) {
 
 // RUNS TO PUSH SCHEDULES VIA V3 API INSTEAD OF V0 LIVE-TOGGLE
 async function evaluateLocalAutomations(btn = null, isStartup = false) {
-    if (!globalFoxSN || !globalGasUrl || isCurrentlyUpdatingMode) return;
+    if (!globalFoxSN || !globalGasUrl) return;
     if (!btn && !canRunAutomaticActions()) return false;
+    if (isCurrentlyUpdatingMode) {
+        pendingAutomationEvaluation = true;
+        return false;
+    }
 
     if (btn) {
         btn.textContent = "Syncing...";
@@ -2380,9 +2464,8 @@ async function evaluateLocalAutomations(btn = null, isStartup = false) {
     // 3. Dispatch Check (Higher priority - overrides target-price and weekly charge blocks)
     if (isAutoDispatch && window.currentDispatches) {
         const soc = applyDispatchLimit ? dispatchSocLimit : 100;
-        window.currentDispatches.forEach(d => {
-            const s = new Date(d.startDt); const e = new Date(d.endDt);
-            if(e > now && s.getDate() === now.getDate()) fillTimeline(s, e, "ForceCharge", soc, "dispatch");
+        getUpcomingSmartDispatches(window.currentDispatches, now).forEach(dispatch => {
+            fillTimeline(dispatch.start, dispatch.end, "ForceCharge", soc, "dispatch");
         });
     }