diff --git a/.github/workflows/node.js.yml b/.github/workflows/node.js.yml
index e3a57a09..27f5c790 100644
--- a/.github/workflows/node.js.yml
+++ b/.github/workflows/node.js.yml
@@ -23,3 +23,4 @@ jobs:
         cache: 'npm'
     - run: npm ci
     - run: npm run build
+    - run: npm run test:node
diff --git a/app/src/app.vue b/app/src/app.vue
index 6b0f4c71..62528dfc 100644
--- a/app/src/app.vue
+++ b/app/src/app.vue
@@ -73,9 +73,13 @@
               tile
               prominent
             >
+              <!-- Intentionally rendered as trusted app/server-provided HTML. Do not pass user-supplied content here. -->
+              <!-- eslint-disable-next-line vue/no-v-html -->
               <span v-html="error.message"></span>
             </v-alert>
             <v-alert v-model="warning.show" dismissible type="warning" tile>
+              <!-- Intentionally rendered as trusted app/server-provided HTML. Do not pass user-supplied content here. -->
+              <!-- eslint-disable-next-line vue/no-v-html -->
               <span v-html="warning.message"></span>
             </v-alert>
             <v-alert
@@ -85,6 +89,8 @@
               tile
               @input="closedInfo"
             >
+              <!-- Intentionally rendered as trusted app/server-provided HTML. Do not pass user-supplied content here. -->
+              <!-- eslint-disable-next-line vue/no-v-html -->
               <span v-html="info.message"></span>
             </v-alert>
           </v-flex>
diff --git a/app/src/components/edit-location.vue b/app/src/components/edit-location.vue
index 26a20c36..82f8741e 100644
--- a/app/src/components/edit-location.vue
+++ b/app/src/components/edit-location.vue
@@ -49,7 +49,6 @@ import gql from "graphql-tag";
 
 import EditVehicleLocationSettings from "@app/components/edit-vehicle-location-settings.vue";
 import RemoveDialog from "@app/components/remove-dialog.vue";
-import deepmerge from "deepmerge";
 import equal from "fast-deep-equal";
 import { GQLLocation, GQLPriceList } from "@shared/sc-schema.js";
 import { UpdateLocationParams } from "@shared/sc-client.js";
@@ -129,9 +128,11 @@ export default class EditLocation extends Vue {
 
   debounceTimer?: any;
   touchedFields: any = {};
-  clearSaving: any = {};
+  saveTicketSeq = 0;
+  saveTickets: Record<string, number> = {};
   async save(field: string) {
-    delete this.clearSaving[field];
+    const fieldTicket = ++this.saveTicketSeq;
+    this.saveTickets[field] = fieldTicket;
     this.$set(this.saving, field, true);
 
     if (this.debounceTimer) {
@@ -139,7 +140,14 @@ export default class EditLocation extends Vue {
     }
     this.debounceTimer = setTimeout(async () => {
       const form: any = this.$refs.form;
-      if (form.validate && form.validate()) {
+      const fieldsInRequest = Object.entries(this.saving)
+        .filter(([, value]) => value)
+        .map(([key]) => key);
+      const requestTickets: Record<string, number> = {};
+      for (const key of fieldsInRequest) {
+        requestTickets[key] = this.saveTickets[key] || 0;
+      }
+      if (!form.validate || form.validate()) {
         const update: UpdateLocationParams = {
           id: this.location.id,
         };
@@ -153,12 +161,18 @@ export default class EditLocation extends Vue {
           delete update.providerData;
         }
 
-        this.clearSaving = deepmerge(this.clearSaving, this.saving);
-
-        await this.$scClient.updateLocation(update);
-
-        for (const [key, value] of Object.entries(this.clearSaving)) {
-          if (value) {
+        try {
+          await this.$scClient.updateLocation(update);
+        } finally {
+          for (const key of fieldsInRequest) {
+            if (this.saveTickets[key] === requestTickets[key]) {
+              this.$set(this.saving, key, false);
+            }
+          }
+        }
+      } else {
+        for (const key of fieldsInRequest) {
+          if (this.saveTickets[key] === requestTickets[key]) {
             this.$set(this.saving, key, false);
           }
         }
diff --git a/app/src/components/edit-vehicle-location-settings.vue b/app/src/components/edit-vehicle-location-settings.vue
index 8c2ae3bb..22905b7b 100644
--- a/app/src/components/edit-vehicle-location-settings.vue
+++ b/app/src/components/edit-vehicle-location-settings.vue
@@ -1,7 +1,7 @@
 <template>
   <v-form ref="form">
     <v-row>
-      <v-col cols="12" sm="5" md="6" class="mt-2">
+      <v-col cols="12" sm="4" md="5" class="mt-2">
         <v-list-item-title>{{ name }}</v-list-item-title>
         <v-list-item-subtitle
           class="font-light overline caption secondary--text text--lighten-2"
@@ -9,8 +9,7 @@
           ({{ settings.locationID }})
         </v-list-item-subtitle>
       </v-col>
-      <v-spacer />
-      <v-col cols="6" sm="3" md="3">
+      <v-col cols="6" sm="3" md="2">
         <v-text-field
           v-model="directLevel"
           :rules="[directLevelRules]"
@@ -33,7 +32,25 @@
           </template>
         </v-text-field>
       </v-col>
-      <v-col cols="6" sm="4" md="3">
+      <v-col cols="6" sm="3" md="2">
+        <v-select
+          v-model="splitCharge"
+          :items="splitChargeList"
+          label="Split charge window"
+          placeholder=" "
+          :loading="saving.splitCharge"
+        >
+          <template #append-outer>
+            <v-tooltip bottom max-width="18rem">
+              <template #activator="{ on }">
+                <v-icon v-on="on">mdi-help-circle-outline</v-icon>
+              </template>
+              Control if charging is allowed to split into multiple windows.
+            </v-tooltip>
+          </template>
+        </v-select>
+      </v-col>
+      <v-col cols="12" sm="4" md="3">
         <v-combobox
           v-model="goal"
           :items="goalCBList"
@@ -62,7 +79,6 @@
             v-model="focus"
             active-class="selected-charge"
             color="primary"
-            label="hej"
             mandatory
           >
             <v-btn small>Low Cost</v-btn>
@@ -77,9 +93,8 @@
 
 <script lang="ts">
 import { Component, Vue, Prop } from "vue-property-decorator";
-import deepmerge from "deepmerge";
 import { GQLVehicle, GQLVehicleLocationSetting } from "@shared/sc-schema.js";
-import { SmartChargeGoal } from "@shared/sc-types.js";
+import { SmartChargeGoal, SplitCharge } from "@shared/sc-types.js";
 import { UpdateVehicleParams } from "@shared/sc-client.js";
 
 @Component({})
@@ -90,11 +105,13 @@ export default class EditVehicle extends Vue {
 
   saving!: { [key: string]: boolean };
   goalCBList!: { text: string; value: string }[];
+  splitChargeList!: { text: string; value: string }[];
   data() {
     return {
       saving: {
         directLevel: false,
         goal: false,
+        splitCharge: false,
       },
       goalCBList: [
         { text: "Low cost", value: SmartChargeGoal.Low },
@@ -102,6 +119,11 @@ export default class EditVehicle extends Vue {
         { text: "Full charge", value: SmartChargeGoal.Full },
         { text: "Custom", value: "%" },
       ],
+      splitChargeList: [
+        { text: "Never", value: SplitCharge.Never },
+        { text: "Auto", value: SplitCharge.Auto },
+        { text: "Always", value: SplitCharge.Always },
+      ],
     };
   }
 
@@ -153,11 +175,21 @@ export default class EditVehicle extends Vue {
     this.save("goal");
   }
 
+  get splitCharge(): string {
+    return this.settings.splitCharge || SplitCharge.Auto;
+  }
+  set splitCharge(value: string) {
+    this.settings.splitCharge = value;
+    this.save("splitCharge");
+  }
+
   debounceTimer?: any;
   touchedFields: any = {};
-  clearSaving: any = {};
+  saveTicketSeq = 0;
+  saveTickets: Record<string, number> = {};
   async save(field: string) {
-    delete this.clearSaving[field];
+    const fieldTicket = ++this.saveTicketSeq;
+    this.saveTickets[field] = fieldTicket;
     this.$set(this.saving, field, true);
 
     if (this.debounceTimer) {
@@ -165,7 +197,14 @@ export default class EditVehicle extends Vue {
     }
     this.debounceTimer = setTimeout(async () => {
       const form: any = this.$refs.form;
-      if (form.validate && form.validate()) {
+      const fieldsInRequest = Object.entries(this.saving)
+        .filter(([, value]) => value)
+        .map(([key]) => key);
+      const requestTickets: Record<string, number> = {};
+      for (const key of fieldsInRequest) {
+        requestTickets[key] = this.saveTickets[key] || 0;
+      }
+      if (!form.validate || form.validate()) {
         const goal = this.settings.goal as any;
         const update: UpdateVehicleParams = {
           id: this.vehicle.id,
@@ -174,16 +213,23 @@ export default class EditVehicle extends Vue {
               locationID: this.settings.locationID,
               directLevel: this.settings.directLevel,
               goal: goal.value || goal,
+              splitCharge: this.settings.splitCharge || SplitCharge.Auto,
             } as GQLVehicleLocationSetting,
           ],
         };
 
-        this.clearSaving = deepmerge(this.clearSaving, this.saving);
-
-        await this.$scClient.updateVehicle(update);
-
-        for (const [key, value] of Object.entries(this.clearSaving)) {
-          if (value) {
+        try {
+          await this.$scClient.updateVehicle(update);
+        } finally {
+          for (const key of fieldsInRequest) {
+            if (this.saveTickets[key] === requestTickets[key]) {
+              this.$set(this.saving, key, false);
+            }
+          }
+        }
+      } else {
+        for (const key of fieldsInRequest) {
+          if (this.saveTickets[key] === requestTickets[key]) {
             this.$set(this.saving, key, false);
           }
         }
diff --git a/app/src/components/edit-vehicle.vue b/app/src/components/edit-vehicle.vue
index 73477aa0..303fafb4 100644
--- a/app/src/components/edit-vehicle.vue
+++ b/app/src/components/edit-vehicle.vue
@@ -52,7 +52,7 @@
 
       <EditVehicleLocationSettings
         v-for="l in locationSettings()"
-        :key="l.settings.location"
+        :key="l.settings.locationID"
         :name="l.name"
         :settings="l.settings"
         :vehicle="vehicle"
@@ -94,7 +94,6 @@
 import { Component, Vue, Prop } from "vue-property-decorator";
 import EditVehicleLocationSettings from "@app/components/edit-vehicle-location-settings.vue";
 import RemoveDialog from "@app/components/remove-dialog.vue";
-import deepmerge from "deepmerge";
 import equal from "fast-deep-equal";
 import {
   GQLVehicle,
@@ -141,18 +140,24 @@ export default class EditVehicle extends Vue {
     return true;
   }
 
+  getOrCreateLocationSettings(locationID: string): GQLVehicleLocationSetting {
+    if (!this.vehicle.locationSettings) {
+      this.$set(this.vehicle, "locationSettings", []);
+    }
+    const existing = this.vehicle.locationSettings.find((f) => f.locationID === locationID);
+    if (existing) return existing;
+    const created = DefaultVehicleLocationSettings(locationID);
+    this.vehicle.locationSettings.push(created);
+    return created;
+  }
+
   locationSettings(): any[] {
     return (
       (this.locations &&
         this.locations
           .filter((l) => l.ownerID === this.vehicle.ownerID)
           .map((l) => {
-            const settings: GQLVehicleLocationSetting =
-              (this.vehicle.locationSettings &&
-                this.vehicle.locationSettings.find(
-                  (f) => f.locationID === l.id
-                )) ||
-              DefaultVehicleLocationSettings(l.id);
+            const settings = this.getOrCreateLocationSettings(l.id);
             return {
               name: l.name,
               settings,
@@ -216,9 +221,11 @@ export default class EditVehicle extends Vue {
 
   debounceTimer?: any;
   touchedFields: any = {};
-  clearSaving: any = {};
+  saveTicketSeq = 0;
+  saveTickets: Record<string, number> = {};
   async save(field: string) {
-    delete this.clearSaving[field];
+    const fieldTicket = ++this.saveTicketSeq;
+    this.saveTickets[field] = fieldTicket;
     this.$set(this.saving, field, true);
 
     if (this.debounceTimer) {
@@ -226,7 +233,14 @@ export default class EditVehicle extends Vue {
     }
     this.debounceTimer = setTimeout(async () => {
       const form: any = this.$refs.form;
-      if (form.validate && form.validate()) {
+      const fieldsInRequest = Object.entries(this.saving)
+        .filter(([, value]) => value)
+        .map(([key]) => key);
+      const requestTickets: Record<string, number> = {};
+      for (const key of fieldsInRequest) {
+        requestTickets[key] = this.saveTickets[key] || 0;
+      }
+      if (!form.validate || form.validate()) {
         const update: UpdateVehicleParams = {
           id: this.vehicle.id,
           providerData: {},
@@ -251,12 +265,18 @@ export default class EditVehicle extends Vue {
           delete update.providerData;
         }
 
-        this.clearSaving = deepmerge(this.clearSaving, this.saving);
-
-        await this.$scClient.updateVehicle(update);
-
-        for (const [key, value] of Object.entries(this.clearSaving)) {
-          if (value) {
+        try {
+          await this.$scClient.updateVehicle(update);
+        } finally {
+          for (const key of fieldsInRequest) {
+            if (this.saveTickets[key] === requestTickets[key]) {
+              this.$set(this.saving, key, false);
+            }
+          }
+        }
+      } else {
+        for (const key of fieldsInRequest) {
+          if (this.saveTickets[key] === requestTickets[key]) {
             this.$set(this.saving, key, false);
           }
         }
diff --git a/app/src/views/vehicle.vue b/app/src/views/vehicle.vue
index fde4a977..3ff4facd 100644
--- a/app/src/views/vehicle.vue
+++ b/app/src/views/vehicle.vue
@@ -33,13 +33,21 @@
               </v-tooltip>
             </v-flex>
             <v-flex sm12 grow class="" style="z-index: 2">
-              <div v-if="freshInfo" id="temperatures" style="margin: 0 auto">
-                <div>
+              <div v-if="freshInfo || scheduleSyncTooltip" id="temperatures" style="margin: 0 auto">
+                <div v-if="freshInfo">
                   <v-icon>mdi-weather-partly-cloudy</v-icon>{{ Number(vehicle.outsideTemperature).toFixed(1) }}&#176;
                 </div>
-                <div>
+                <div v-if="freshInfo">
                   <v-icon style="top: 1px">mdi-car</v-icon>{{ Number(vehicle.insideTemperature).toFixed(1) }}&#176;
                 </div>
+                <v-tooltip v-if="scheduleSyncTooltip" bottom>
+                  <template #activator="{ on }">
+                    <div class="schedule-sync-status" v-on="on">
+                      <v-icon :class="scheduleSyncStatusClass">{{ scheduleSyncIcon }}</v-icon>
+                    </div>
+                  </template>
+                  <span>{{ scheduleSyncTooltip }}</span>
+                </v-tooltip>
               </div>
             </v-flex>
           </v-layout>
@@ -279,6 +287,34 @@ export default class VehicleVue extends Vue {
   get vehicleConnectedAtUnknownLocation(): boolean {
     return Boolean(this.vehicleAtUnknownLocation && this.vehicle!.isConnected);
   }
+  get scheduleSyncIssue(): any {
+    const issue = this.vehicle?.providerData?.schedule_sync_issue;
+    return issue && typeof issue === "object" ? issue : undefined;
+  }
+  get effectiveScheduleSyncKind(): "incorrect" | "drift" | undefined {
+    const issue = this.scheduleSyncIssue;
+    if (!issue || !this.vehicle?.isConnected) return undefined;
+    return issue.kind;
+  }
+  get scheduleSyncStatusClass(): string {
+    return this.effectiveScheduleSyncKind === "incorrect"
+      ? "red--text text--accent-4"
+      : "light-blue--text text--darken-2";
+  }
+  get scheduleSyncIcon(): string {
+    return this.effectiveScheduleSyncKind === "incorrect"
+      ? "mdi-calendar-alert"
+      : "mdi-calendar-refresh";
+  }
+  get scheduleSyncTooltip(): string | undefined {
+    if (this.effectiveScheduleSyncKind === "incorrect") {
+      return "Vehicle onboard charge schedule or limit is incorrect and will affect planned charging. Please take the vehicle online.";
+    }
+    if (this.effectiveScheduleSyncKind === "drift") {
+      return "Vehicle onboard charge schedule or limit is not exact, but will update when online.";
+    }
+    return undefined;
+  }
   get addLocationURL(): RawLocation {
     assert(this.vehicle !== undefined);
     assert(this.vehicle.geoLocation !== null);
@@ -435,6 +471,11 @@ export default class VehicleVue extends Vue {
 #temperatures > div + div {
   margin-left: 1em;
 }
+#temperatures .schedule-sync-status {
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+}
 #temperatures .v-icon {
   font-size: 90%;
   margin-right: 0.2em;
diff --git a/package.json b/package.json
index 42c106a1..54844688 100644
--- a/package.json
+++ b/package.json
@@ -15,6 +15,8 @@
     "_create:schema": "node dist/server/gql/build-schema-files.js",
     "build:app": "vite build",
     "build:server": "npm run _babel:shared && npm run _babel:providers && npm run _babel:server && npm run _create:schema",
+    "test:node": "node --test providers/**/*.test.mjs",
+    "test": "npm run build:server && npm run test:node",
     "start:server": "node dist/server/server.js",
     "start:worker": "node dist/server/agency.js -d INTERNAL_SERVICE_TOKEN http://localhost:3030"
   },
diff --git a/providers/tesla/tesla-agent.schedule-purpose.test.mjs b/providers/tesla/tesla-agent.schedule-purpose.test.mjs
new file mode 100644
index 00000000..2af44c59
--- /dev/null
+++ b/providers/tesla/tesla-agent.schedule-purpose.test.mjs
@@ -0,0 +1,148 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+
+import {
+  TeslaAgent,
+  teslaSchedulePurposeCadenceMs,
+  teslaScheduleServesRequestedPurpose,
+  teslaShouldMaintainRemoteHomeSchedule,
+  teslaWantedSocLimit,
+} from "../../dist/providers/tesla/tesla-agent.js";
+import * as telemetryData from "../../dist/providers/tesla/telemetry-protos/vehicle_data_pb.js";
+
+const location = {
+  geoFenceRadius: 250,
+  geoLocation: {
+    latitude: 59.0,
+    longitude: 18.0,
+  },
+};
+
+const ts = (iso) => new Date(iso).getTime();
+
+test("approach band accepts future blocker purpose with start drift inside fluid cadence", () => {
+  const now = ts("2026-04-22T13:00:00Z");
+  const existing = { chargeStart: ts("2026-04-22T15:00:00Z"), chargeStop: ts("2026-04-22T16:00:00Z") };
+  const requested = { chargeStart: ts("2026-04-22T15:20:00Z"), chargeStop: ts("2026-04-22T20:00:00Z") };
+  assert.equal(
+    teslaScheduleServesRequestedPurpose(
+      false,
+      telemetryData.DetailedChargeStateValue.DetailedChargeStateDisconnected,
+      existing,
+      requested,
+      now,
+      location,
+      10_000,
+      TeslaAgent.LOCKED_IN_SCHEDULE_CADENCE_MS,
+      TeslaAgent.FLUID_SCHEDULE_CADENCE_MS
+    ),
+    true
+  );
+});
+
+test("immediate band accepts any future blocker schedule while still unplugged", () => {
+  const now = ts("2026-04-22T13:00:00Z");
+  const existing = { chargeStart: ts("2026-04-22T15:00:00Z"), chargeStop: ts("2026-04-22T16:00:00Z") };
+  const requested = { chargeStart: ts("2026-04-22T20:00:00Z"), chargeStop: ts("2026-04-22T23:00:00Z") };
+  assert.equal(
+    teslaScheduleServesRequestedPurpose(
+      false,
+      telemetryData.DetailedChargeStateValue.DetailedChargeStateDisconnected,
+      existing,
+      requested,
+      now,
+      location,
+      100,
+      TeslaAgent.LOCKED_IN_SCHEDULE_CADENCE_MS,
+      TeslaAgent.FLUID_SCHEDULE_CADENCE_MS
+    ),
+    true
+  );
+});
+
+test("connected vehicle requires start time inside locked-in cadence", () => {
+  const now = ts("2026-04-22T13:00:00Z");
+  const matched = teslaScheduleServesRequestedPurpose(
+    true,
+    telemetryData.DetailedChargeStateValue.DetailedChargeStateStopped,
+    { chargeStart: ts("2026-04-22T20:03:00Z"), chargeStop: ts("2026-04-22T21:00:00Z") },
+    { chargeStart: ts("2026-04-22T20:00:00Z"), chargeStop: ts("2026-04-22T23:00:00Z") },
+    now,
+    location,
+    100,
+    TeslaAgent.LOCKED_IN_SCHEDULE_CADENCE_MS,
+    TeslaAgent.FLUID_SCHEDULE_CADENCE_MS
+  );
+  const rejected = teslaScheduleServesRequestedPurpose(
+    true,
+    telemetryData.DetailedChargeStateValue.DetailedChargeStateStopped,
+    { chargeStart: ts("2026-04-22T20:10:00Z"), chargeStop: ts("2026-04-22T21:00:00Z") },
+    { chargeStart: ts("2026-04-22T20:00:00Z"), chargeStop: ts("2026-04-22T23:00:00Z") },
+    now,
+    location,
+    100,
+    TeslaAgent.LOCKED_IN_SCHEDULE_CADENCE_MS,
+    TeslaAgent.FLUID_SCHEDULE_CADENCE_MS
+  );
+  assert.equal(matched, true);
+  assert.equal(rejected, false);
+});
+
+test("active charging near stop time requires the correct stop time", () => {
+  const now = ts("2026-04-22T13:56:00Z");
+  const requested = { chargeStart: ts("2026-04-22T13:00:00Z"), chargeStop: ts("2026-04-22T14:00:00Z") };
+  const matched = teslaScheduleServesRequestedPurpose(
+    true,
+    telemetryData.DetailedChargeStateValue.DetailedChargeStateCharging,
+    { chargeStart: ts("2026-04-22T13:00:00Z"), chargeStop: ts("2026-04-22T14:03:00Z") },
+    requested,
+    now,
+    location,
+    100,
+    TeslaAgent.LOCKED_IN_SCHEDULE_CADENCE_MS,
+    TeslaAgent.FLUID_SCHEDULE_CADENCE_MS
+  );
+  const rejected = teslaScheduleServesRequestedPurpose(
+    true,
+    telemetryData.DetailedChargeStateValue.DetailedChargeStateCharging,
+    { chargeStart: ts("2026-04-22T13:00:00Z"), chargeStop: ts("2026-04-22T14:10:00Z") },
+    requested,
+    now,
+    location,
+    100,
+    TeslaAgent.LOCKED_IN_SCHEDULE_CADENCE_MS,
+    TeslaAgent.FLUID_SCHEDULE_CADENCE_MS
+  );
+  assert.equal(matched, true);
+  assert.equal(rejected, false);
+});
+
+test("remote home schedule maintenance is limited to the approach band", () => {
+  assert.equal(
+    teslaShouldMaintainRemoteHomeSchedule(false, location, 49_000, TeslaAgent.APPROACH_CHARGE_LOCATION_M),
+    true
+  );
+  assert.equal(
+    teslaShouldMaintainRemoteHomeSchedule(false, location, 51_000, TeslaAgent.APPROACH_CHARGE_LOCATION_M),
+    false
+  );
+});
+
+test("schedule cadence locks in when connected or inside the immediate band", () => {
+  assert.equal(
+    teslaSchedulePurposeCadenceMs(true, location, 10_000, TeslaAgent.LOCKED_IN_SCHEDULE_CADENCE_MS, TeslaAgent.FLUID_SCHEDULE_CADENCE_MS),
+    TeslaAgent.LOCKED_IN_SCHEDULE_CADENCE_MS
+  );
+  assert.equal(
+    teslaSchedulePurposeCadenceMs(false, location, 100, TeslaAgent.LOCKED_IN_SCHEDULE_CADENCE_MS, TeslaAgent.FLUID_SCHEDULE_CADENCE_MS),
+    TeslaAgent.LOCKED_IN_SCHEDULE_CADENCE_MS
+  );
+  assert.equal(
+    teslaSchedulePurposeCadenceMs(false, location, 10_000, TeslaAgent.LOCKED_IN_SCHEDULE_CADENCE_MS, TeslaAgent.FLUID_SCHEDULE_CADENCE_MS),
+    TeslaAgent.FLUID_SCHEDULE_CADENCE_MS
+  );
+});
+
+test("missing wanted SOC means no charge-limit target", () => {
+  assert.equal(teslaWantedSocLimit(undefined), null);
+});
diff --git a/providers/tesla/tesla-agent.ts b/providers/tesla/tesla-agent.ts
index 1dba550b..525ae983 100644
--- a/providers/tesla/tesla-agent.ts
+++ b/providers/tesla/tesla-agent.ts
@@ -10,21 +10,22 @@ import { strict as assert } from "assert";
 import {
   log,
   LogLevel,
+  vehicleLog,
   numericStopTime,
   numericStartTime,
   diffObjects,
   delay,
   compareStartStopTimes,
-  compareStopTimes,
   geoDistance,
   compareStartTimes,
 } from "@shared/utils.js";
 import { GQLLocationFragment, SCClient, UpdateVehicleParams } from "@shared/sc-client.js";
 import config from "./tesla-config.js";
-import teslaAPI, { TeslaAPI, TeslaChargeSchedule, TeslaPreconditionSchedule, TeslaScheduleTimeToDate, TeslaTelemetryConfig } from "./tesla-api.js";
+import teslaAPI, { redactSecret, TeslaAPI, TeslaChargeSchedule, TeslaPreconditionSchedule, TeslaScheduleTimeToDate, TeslaTelemetryConfig } from "./tesla-api.js";
 import { AgentJob, AbstractAgent, IProviderAgent } from "@providers/provider-agent.js";
 import provider, { TeslaServiceData, TeslaProviderMutates, TeslaProviderQueries, TeslaToken } from "./index.js";
 import { GQLVehicle, GQLUpdateVehicleDataInput, GQLChargeConnection, GQLChargeType, GQLGeoLocation, GQLScheduleType } from "@shared/sc-schema.js";
+import { DEFAULT_LOCATION_RADIUS } from "@shared/smartcharge-defines.js";
 import { Consumer, Kafka, LogEntry, logLevel } from "kafkajs";
 import * as protobuf from "@bufbuild/protobuf";
 import * as telemetryConnectivity from "./telemetry-protos/vehicle_connectivity_pb.js";
@@ -39,6 +40,8 @@ interface TeslaTelemetryData {
   Odometer: number;
   OutsideTemp: number;
   InsideTemp: number;
+  ModuleTempMin: number;
+  ModuleTempMax: number;
   TimeToFullCharge: number;
 
   HvacPower: telemetryData.HvacPowerState;
@@ -85,6 +88,8 @@ const telemetryFields: TelemetryFields = {
   Odometer: { interval_seconds: 15, minimum_delta: 0.05 }, // 0.05 miles = 80 meters
   OutsideTemp: { interval_seconds: 60, minimum_delta: 0.5 },
   InsideTemp: { interval_seconds: 30, minimum_delta: 0.5 },
+  ModuleTempMin: { interval_seconds: 60, minimum_delta: 0.5 },
+  ModuleTempMax: { interval_seconds: 60, minimum_delta: 0.5 },
   TimeToFullCharge: { interval_seconds: 10, minimum_delta: 0.02 }, // 0.02 hours = 1.2 minutes
 
   VehicleName: { interval_seconds: 5 },
@@ -129,6 +134,12 @@ interface NumericChargePlan {
   chargeStop: number | null;
 }
 
+interface TeslaScheduleSyncIssue {
+  kind: "incorrect" | "drift";
+  locationID: string;
+  since: number;
+}
+
 interface VehicleEntry {
   vin: string;
   vehicleUUID: string | null;
@@ -151,11 +162,194 @@ interface VehicleEntry {
 
   isSleepy: boolean;
   isOnline: boolean;
+  lastScheduleSyncAt?: number;
+  lastScheduleSyncAttemptAt?: number;
+  lastScheduleMutationAt?: number;
+  lastPlugInAt?: number;
+  lastImmediateScheduleCheckAt?: number;
+  lastChargingAt?: number;
+  lastEmergencyWakeUpAt?: number;
 
   charge_schedules?: { [id: number]: TeslaChargeSchedule }; // Cached charge schedules
   precondition_schedules?: { [id: number]: TeslaPreconditionSchedule }; // Cached precondition schedules
 }
 
+const logVehicle = (level: LogLevel, vehicle: VehicleEntry, data: unknown) => {
+  // Tesla issues are investigated by VIN first. Keep VIN on every vehicle-scoped
+  // log line, and include the internal vehicle UUID too once the vehicle is mapped.
+  const vehicleRef = vehicle.vehicleUUID ? `${vehicle.vehicleUUID} ${vehicle.vin}` : vehicle.vin;
+  vehicleLog(level, vehicleRef, data);
+};
+
+export function teslaSchedulePurposeCadenceMs(
+  connected: boolean,
+  location: GQLLocationFragment,
+  distanceToLocationM: number | null,
+  lockedInCadenceMs: number,
+  fluidCadenceMs: number
+): number {
+  const nearChargeLocationThresholdM = location.geoFenceRadius || DEFAULT_LOCATION_RADIUS;
+  if (connected || (distanceToLocationM !== null && distanceToLocationM < nearChargeLocationThresholdM)) {
+    return lockedInCadenceMs;
+  }
+  return fluidCadenceMs;
+}
+
+export function teslaScheduleServesRequestedPurpose(
+  connected: boolean,
+  detailedChargeState: telemetryData.DetailedChargeStateValue | undefined,
+  existing: NumericChargePlan,
+  requested: NumericChargePlan,
+  now: number,
+  location: GQLLocationFragment,
+  distanceToLocationM: number | null,
+  lockedInCadenceMs: number,
+  fluidCadenceMs: number
+): boolean {
+  const existingStart = numericStartTime(existing.chargeStart);
+  const existingStop = numericStopTime(existing.chargeStop);
+  const requestedStart = numericStartTime(requested.chargeStart);
+  const requestedStop = numericStopTime(requested.chargeStop);
+
+  if (teslaScheduleMatchesExactly(existing, requested)) {
+    return true;
+  }
+  if (requestedStop < now && existingStop < now && (now - existingStop) < 5 * 60 * 60e3) {
+    return true;
+  }
+  if (requestedStart < now && existingStart < now && existingStop === requestedStop) {
+    if (detailedChargeState === telemetryData.DetailedChargeStateValue.DetailedChargeStateStopped
+      && (now - existingStart) > 5 * 60 * 60e3) {
+      return false;
+    }
+    return true;
+  }
+
+  const nearChargeLocationThresholdM = location.geoFenceRadius || DEFAULT_LOCATION_RADIUS;
+  const immediateBand = distanceToLocationM !== null && distanceToLocationM < nearChargeLocationThresholdM;
+  const cadenceMs = teslaSchedulePurposeCadenceMs(connected, location, distanceToLocationM, lockedInCadenceMs, fluidCadenceMs);
+  if (requestedStart < now) {
+    const nearEnd = requestedStop <= now + lockedInCadenceMs;
+    if (nearEnd) {
+      return existingStart <= now
+        && Math.abs(existingStop - requestedStop) <= lockedInCadenceMs;
+    }
+    return existingStart <= now && existingStop > now;
+  }
+
+  if (connected) {
+    return existingStart > now
+      && Math.abs(existingStart - requestedStart) <= lockedInCadenceMs;
+  }
+
+  if (immediateBand) {
+    return existingStart > now;
+  }
+
+  return existingStart > now
+    && Math.abs(existingStart - requestedStart) <= cadenceMs;
+}
+
+function teslaScheduleMatchesExactly(existing: NumericChargePlan, requested: NumericChargePlan): boolean {
+  return numericStartTime(existing.chargeStart) === numericStartTime(requested.chargeStart)
+    && numericStopTime(existing.chargeStop) === numericStopTime(requested.chargeStop);
+}
+
+export function teslaWantedSocLimit(wantedSoc: number | undefined): number | null {
+  if (wantedSoc === undefined) return null;
+  return Math.max(config.TESLA_LOWEST_POSSIBLE_CHARGETO, Math.min(wantedSoc, 100));
+}
+
+function classifyScheduleSyncIssue(
+  requestedSchedule: ReadonlyArray<NumericChargePlan>,
+  existingSchedules: ReadonlyArray<NumericChargePlan>,
+  now: number,
+  hasInexactPurposeMatch: boolean
+): TeslaScheduleSyncIssue["kind"] | null {
+  const relevantRequestedSchedule = requestedSchedule.filter((r) => numericStopTime(r.chargeStop) > now);
+  if (relevantRequestedSchedule.length === 0) {
+    return null;
+  }
+  if (relevantRequestedSchedule[0].scheduleID === undefined) {
+    const firstRequested = relevantRequestedSchedule[0];
+    const firstExisting = existingSchedules
+      .filter((s) => numericStopTime(s.chargeStop) > now)
+      .sort((a, b) => compareStartStopTimes(a.chargeStart, a.chargeStop, b.chargeStart, b.chargeStop))[0];
+    if (!firstExisting) {
+      return "incorrect";
+    }
+    if (numericStartTime(firstExisting.chargeStart) > numericStartTime(firstRequested.chargeStart)) {
+      return "incorrect";
+    }
+    // An earlier start, earlier stop, or longer onboard schedule can still wake the car
+    // so Smart Charge can correct it before the desired charging behavior is affected.
+    return "drift";
+  }
+  if (relevantRequestedSchedule.some((r) => r.scheduleID === undefined)) {
+    return "drift";
+  }
+  if (hasInexactPurposeMatch) {
+    return "drift";
+  }
+  return null;
+}
+
+function classifyChargingSetupSyncIssue(
+  requestedSchedule: ReadonlyArray<NumericChargePlan>,
+  existingSchedules: ReadonlyArray<NumericChargePlan>,
+  now: number,
+  hasInexactPurposeMatch: boolean,
+  wantedSocLimit: number | null,
+  actualSocLimit: number | undefined,
+  currentSoc: number | undefined,
+  connected: boolean
+): TeslaScheduleSyncIssue["kind"] | null {
+  const scheduleIssueKind = classifyScheduleSyncIssue(requestedSchedule, existingSchedules, now, hasInexactPurposeMatch);
+  if (connected && wantedSocLimit !== null && actualSocLimit !== undefined) {
+    if ((currentSoc ?? Number.POSITIVE_INFINITY) < wantedSocLimit && actualSocLimit < wantedSocLimit) {
+      return "incorrect";
+    }
+    if (actualSocLimit !== wantedSocLimit) {
+      return scheduleIssueKind === "incorrect" ? "incorrect" : "drift";
+    }
+  }
+  return scheduleIssueKind;
+}
+
+export function teslaShouldMaintainRemoteHomeSchedule(
+  connected: boolean,
+  location: GQLLocationFragment,
+  distanceToLocationM: number | null,
+  approachChargeLocationM: number
+): boolean {
+  if (connected) {
+    return true;
+  }
+  const nearChargeLocationThresholdM = location.geoFenceRadius || DEFAULT_LOCATION_RADIUS;
+  if (distanceToLocationM !== null && distanceToLocationM < nearChargeLocationThresholdM) {
+    return true;
+  }
+  return distanceToLocationM !== null && distanceToLocationM < approachChargeLocationM;
+}
+
+function formatTelemetryValue(v: telemetryData.Value["value"]): string {
+  const value = v.value;
+  if (value === undefined || value === null) {
+    return `${value}`;
+  }
+  if (typeof value === "object") {
+    try {
+      return JSON.stringify(value);
+    } catch {
+      return String(value);
+    }
+  }
+  if (typeof value === "string") {
+    return JSON.stringify(value);
+  }
+  return String(value);
+}
+
 interface TeslaAgentState {
   [vehicleUUID: string]: string;  // vehicleUUID -> vin
 }
@@ -163,6 +357,7 @@ interface TeslaAgentJob extends AgentJob {
   serviceData: TeslaServiceData;
   mapped: number;
   state: TeslaAgentState;
+  teslaApiQueue?: Promise<void>;
 }
 
 function mapTelemetryNumber(v: telemetryData.Value["value"]): number {
@@ -170,7 +365,7 @@ function mapTelemetryNumber(v: telemetryData.Value["value"]): number {
     case "stringValue": case "intValue": case "floatValue": case "doubleValue":
       return +v.value;
     default:
-      log(LogLevel.Warning, `Tesla Telmetry invalid number value: ${v} (${v.case})`);
+      log(LogLevel.Warning, `Tesla Telemetry invalid number value: ${formatTelemetryValue(v)} (${v.case})`);
       return NaN;
   }
 }
@@ -190,10 +385,107 @@ function stringifyWithTimestamps(data: any): string {
   });
 }
 
+function normalizeChargeSchedules(schedules: { [id: number]: TeslaChargeSchedule } | undefined): unknown[] {
+  return Object.values(schedules || {})
+    .sort((a, b) => a.id - b.id)
+    .map((s) => ({
+      id: s.id,
+      latitude: s.latitude,
+      longitude: s.longitude,
+      start_enabled: s.start_enabled,
+      start_time: s.start_time,
+      end_enabled: s.end_enabled,
+      end_time: s.end_time,
+      days_of_week: s.days_of_week,
+      one_time: s.one_time,
+      enabled: s.enabled,
+    }));
+}
+
+function normalizePreconditionSchedules(schedules: { [id: number]: TeslaPreconditionSchedule } | undefined): unknown[] {
+  return Object.values(schedules || {})
+    .sort((a, b) => a.id - b.id)
+    .map((s) => ({
+      id: s.id,
+      latitude: s.latitude,
+      longitude: s.longitude,
+      precondition_time: s.precondition_time,
+      days_of_week: s.days_of_week,
+      one_time: s.one_time,
+      enabled: s.enabled,
+    }));
+}
+
+const SCHEDULE_COORD_ABS_EPSILON = 0.00001;
+
+function sameCoordinate(a: number, b: number): boolean {
+  return Math.abs(a - b) <= SCHEDULE_COORD_ABS_EPSILON;
+}
+
+function equalChargeSchedules(
+  left: { [id: number]: TeslaChargeSchedule } | undefined,
+  right: { [id: number]: TeslaChargeSchedule } | undefined
+): boolean {
+  const leftSchedules = Object.values(left || {}).sort((a, b) => a.id - b.id);
+  const rightSchedules = Object.values(right || {}).sort((a, b) => a.id - b.id);
+  if (leftSchedules.length !== rightSchedules.length) return false;
+  return leftSchedules.every((schedule, index) => {
+    const other = rightSchedules[index];
+    assert(other);
+    return schedule.id === other.id
+      && sameCoordinate(schedule.latitude, other.latitude)
+      && sameCoordinate(schedule.longitude, other.longitude)
+      && schedule.start_enabled === other.start_enabled
+      && schedule.start_time === other.start_time
+      && schedule.end_enabled === other.end_enabled
+      && schedule.end_time === other.end_time
+      && schedule.days_of_week === other.days_of_week
+      && schedule.one_time === other.one_time
+      && schedule.enabled === other.enabled;
+  });
+}
+
+function equalPreconditionSchedules(
+  left: { [id: number]: TeslaPreconditionSchedule } | undefined,
+  right: { [id: number]: TeslaPreconditionSchedule } | undefined
+): boolean {
+  const leftSchedules = Object.values(left || {}).sort((a, b) => a.id - b.id);
+  const rightSchedules = Object.values(right || {}).sort((a, b) => a.id - b.id);
+  if (leftSchedules.length !== rightSchedules.length) return false;
+  return leftSchedules.every((schedule, index) => {
+    const other = rightSchedules[index];
+    assert(other);
+    return schedule.id === other.id
+      && sameCoordinate(schedule.latitude, other.latitude)
+      && sameCoordinate(schedule.longitude, other.longitude)
+      && schedule.precondition_time === other.precondition_time
+      && schedule.days_of_week === other.days_of_week
+      && schedule.one_time === other.one_time
+      && schedule.enabled === other.enabled;
+  });
+}
+
 export class TeslaAgent extends AbstractAgent {
+  private static readonly EMERGENCY_WAKE_GRACE_MS = 15 * 60e3;
+  private static readonly EMERGENCY_WAKE_COOLDOWN_MS = 23 * 60 * 60e3;
+  private static readonly CHARGE_SCHEDULE_QUANTUM_MS = 15 * 60e3;
+  private static readonly EMERGENCY_WAKE_PROVIDER_FIELD = "emergency_wakeup_at";
+  private static readonly SCHEDULE_SYNC_ISSUE_PROVIDER_FIELD = "schedule_sync_issue";
+  private static readonly IDLE_SERVICE_INTERVAL_S = 5 * 60;
+  private static readonly ACTIVE_SERVICE_INTERVAL_S = 30;
+  private static readonly URGENT_SERVICE_INTERVAL_S = 10;
+  private static readonly FLUID_SCHEDULE_CADENCE_MS = 30 * 60e3;
+  private static readonly LOCKED_IN_SCHEDULE_CADENCE_MS = 5 * 60e3;
+  // 50 km is roughly 30-35 minutes of driving at mixed Swedish road speeds.
+  // Beyond this, a home schedule update is unlikely to help before the vehicle parks
+  // or loses coverage, so we stop maintaining it entirely.
+  private static readonly APPROACH_CHARGE_LOCATION_M = 50e3;
+  private static readonly SCHEDULE_SYNC_RETRY_MS = 60e3;
+
   public name: string = provider.name;
   public kafkaClient: Kafka;
   public kafkaConsumer: Consumer;
+  private telemetryConfigBackoff: { [vin: string]: { step: number; until: number } } = {};
   constructor(scClient: SCClient) {
     super(scClient);
     this.kafkaClient = new Kafka({
@@ -219,7 +511,7 @@ export class TeslaAgent extends AbstractAgent {
     this.kafkaConsumer.run({
       eachMessage: async ({ topic, message }) => {
         if (message.value === null) {
-          log(LogLevel.Error, `Tesla Telmetry message value is null`);
+          log(LogLevel.Error, `Tesla Telemetry message value is null`);
           return;
         }
         if (topic === "tesla_connectivity") {
@@ -242,10 +534,10 @@ export class TeslaAgent extends AbstractAgent {
             new Uint8Array(message.value)
           );
           for (const error of data.errors) {
-            log(LogLevel.Error, `Tesla Telmetry error ${error.name} (${JSON.stringify(error.tags)}): ${error.body}`);
+            log(LogLevel.Error, `Tesla Telemetry error ${error.name} (${JSON.stringify(error.tags)}): ${error.body}`);
           }
         } else {
-          log(LogLevel.Error, `Unknown Tesla Telmetry topic: ${topic}`);
+          log(LogLevel.Error, `Unknown Tesla Telemetry topic: ${topic}`);
         }
       },
     });
@@ -283,7 +575,7 @@ export class TeslaAgent extends AbstractAgent {
     }
     job.serviceData.token = token as TeslaToken;
     delete job.serviceData.invalid_token;
-    log(LogLevel.Debug, `Updated token for ${job.serviceID} to ${token.access_token}`);
+    log(LogLevel.Debug, `Updated token for ${job.serviceID} to ${redactSecret(token.access_token)}`);
   }
 
   // Check token and refresh through server provider API
@@ -302,8 +594,16 @@ export class TeslaAgent extends AbstractAgent {
     fn: (...args: [...T, TeslaToken]) => Promise<R>,
     ...args: T
   ): Promise<R> {
-    await this.maintainToken(job);
-    return fn.apply(teslaAPI, [...args, job.serviceData.token]);
+    // Serialize Tesla API calls per service/account. This is intentionally broader
+    // than per-vehicle queueing: it keeps ordering simple and dampens paid API bursts,
+    // at the cost of one vehicle being able to delay another on the same Tesla account.
+    const queue = job.teslaApiQueue || Promise.resolve();
+    const queued = queue.then(async () => {
+      await this.maintainToken(job);
+      return await fn.apply(teslaAPI, [...args, job.serviceData.token]);
+    });
+    job.teslaApiQueue = queued.then(() => undefined, () => undefined);
+    return queued;
   }
 
   private vehicleEntry(vin: string): VehicleEntry {
@@ -356,16 +656,176 @@ export class TeslaAgent extends AbstractAgent {
     return new Date(d.getTime() - this.locationTimezoneOffset(location, d));
   }
 
+  private requestServiceWork(vehicle: VehicleEntry, targetIntervalS: number, reason: string) {
+    if (!vehicle.job) return;
+    vehicle.job.interval = Math.min(vehicle.job.interval, targetIntervalS);
+    vehicle.job.nextrun = Math.min(vehicle.job.nextrun, Date.now());
+    logVehicle(
+      LogLevel.Trace,
+      vehicle,
+      `Requested Tesla service work in ${targetIntervalS}s due to ${reason}`
+    );
+  }
+
+  private isChargingState(
+    state: telemetryData.DetailedChargeStateValue | undefined
+  ): boolean {
+    return state === telemetryData.DetailedChargeStateValue.DetailedChargeStateCharging
+      || state === telemetryData.DetailedChargeStateValue.DetailedChargeStateStarting;
+  }
+
+  private shouldDeferScheduleMutation(
+    vehicle: VehicleEntry,
+    requestedSchedule: ReadonlyArray<NumericChargePlan>,
+    now: number,
+    location: GQLLocationFragment,
+    distanceToLocationM: number | null
+  ): boolean {
+    const cooldownMs = teslaSchedulePurposeCadenceMs(
+      Boolean(vehicle.dbData?.isConnected || this.isConnected(vehicle)),
+      location,
+      distanceToLocationM,
+      TeslaAgent.LOCKED_IN_SCHEDULE_CADENCE_MS,
+      TeslaAgent.FLUID_SCHEDULE_CADENCE_MS
+    );
+    if (!vehicle.lastScheduleMutationAt || vehicle.lastScheduleMutationAt + cooldownMs <= now) {
+      return false;
+    }
+    const nextAllowedMutationAt = vehicle.lastScheduleMutationAt + cooldownMs;
+    const firstRelevantStart = requestedSchedule
+      .map((window) => numericStartTime(window.chargeStart))
+      .filter((start) => start > now)
+      .sort((a, b) => a - b)[0];
+    return firstRelevantStart !== undefined && nextAllowedMutationAt < firstRelevantStart;
+  }
+
+  private scheduleAuditIntervalMs(now: number): number | null {
+    // Development-only schedule audit with a hard sunset so it cannot linger in release code.
+    // Starting April 22, 2026:
+    // - run every 10 minutes until July 22, 2026
+    // - then every 30 minutes until October 22, 2026
+    // - then disable completely
+    if (now < Date.UTC(2026, 6, 22)) return 10 * 60e3;
+    if (now < Date.UTC(2026, 9, 22)) return 30 * 60e3;
+    return null;
+  }
+
+  private lastEmergencyWakeUpAt(vehicle: VehicleEntry): number | undefined {
+    const cached = vehicle.lastEmergencyWakeUpAt;
+    if (cached !== undefined) return cached;
+    const providerValue = vehicle.dbData?.providerData?.[TeslaAgent.EMERGENCY_WAKE_PROVIDER_FIELD];
+    if (providerValue === undefined || providerValue === null) return undefined;
+    assert(typeof providerValue === "number", `${TeslaAgent.EMERGENCY_WAKE_PROVIDER_FIELD} must be stored as epoch milliseconds`);
+    assert(Number.isFinite(providerValue), `${TeslaAgent.EMERGENCY_WAKE_PROVIDER_FIELD} must be a finite epoch millisecond timestamp`);
+    vehicle.lastEmergencyWakeUpAt = providerValue;
+    return providerValue;
+  }
+
+  private async recordEmergencyWakeUp(vehicle: VehicleEntry, at: number) {
+    vehicle.lastEmergencyWakeUpAt = at;
+    if (!vehicle.vehicleUUID) return;
+    vehicle.dbData = await this.scClient.updateVehicle({
+      id: vehicle.vehicleUUID,
+      providerData: {
+        [TeslaAgent.EMERGENCY_WAKE_PROVIDER_FIELD]: at,
+      },
+    });
+  }
+
+  private async updateScheduleSyncIssue(vehicle: VehicleEntry, issue: TeslaScheduleSyncIssue | null) {
+    const current = vehicle.dbData?.providerData?.[TeslaAgent.SCHEDULE_SYNC_ISSUE_PROVIDER_FIELD] as TeslaScheduleSyncIssue | null | undefined;
+    if (issue === null) {
+      if (current === undefined || current === null) return;
+    } else if (
+      current
+      && current.kind === issue.kind
+      && current.locationID === issue.locationID
+    ) {
+      return;
+    }
+    assert(vehicle.vehicleUUID, "vehicle.vehicleUUID is null");
+    assert(vehicle.dbData, "vehicle.dbData is null");
+    vehicle.dbData = await this.scClient.updateVehicle({
+      id: vehicle.vehicleUUID,
+      providerData: {
+        [TeslaAgent.SCHEDULE_SYNC_ISSUE_PROVIDER_FIELD]: issue,
+      },
+    });
+  }
+
+  private async tryEmergencyWakeForCharging(
+    job: TeslaAgentJob,
+    vehicle: VehicleEntry,
+    requestedSchedule: ReadonlyArray<NumericChargePlan>,
+    wantedSoc: number | undefined
+  ): Promise<boolean> {
+    const now = Date.now();
+    const activeWindow = requestedSchedule.find((window) => {
+      const start = numericStartTime(window.chargeStart);
+      const stop = numericStopTime(window.chargeStop);
+      return start <= now && now < stop;
+    });
+    if (!activeWindow || vehicle.isOnline || !(vehicle.dbData?.isConnected || this.isConnected(vehicle))) {
+      return false;
+    }
+    if (this.isChargingState(vehicle.telemetryData.DetailedChargeState)) {
+      return false;
+    }
+    const rawTargetSoc = wantedSoc ?? vehicle.telemetryData.ChargeLimitSoc ?? null;
+    const targetSoc = rawTargetSoc === null || rawTargetSoc === undefined
+      ? null
+      : Math.max(config.TESLA_LOWEST_POSSIBLE_CHARGETO, Math.min(rawTargetSoc, 100));
+    if (targetSoc === null || vehicle.telemetryData.Soc === undefined || vehicle.telemetryData.Soc >= targetSoc - 1.5) {
+      return false;
+    }
+    const blockedSince = Math.max(
+      numericStartTime(activeWindow.chargeStart),
+      vehicle.lastChargingAt || 0
+    );
+    if (now < blockedSince + TeslaAgent.EMERGENCY_WAKE_GRACE_MS) {
+      return false;
+    }
+    const lastWakeUpAt = this.lastEmergencyWakeUpAt(vehicle);
+    if (
+      lastWakeUpAt
+      && now < lastWakeUpAt + TeslaAgent.EMERGENCY_WAKE_COOLDOWN_MS
+    ) {
+      logVehicle(
+        LogLevel.Debug,
+        vehicle,
+        `${vehicle.vin} skipping emergency wake-up because the cooldown is still active`
+      );
+      return false;
+    }
+
+    logVehicle(
+      LogLevel.Info,
+      vehicle,
+      `${vehicle.vin} emergency wake-up: connected, below target, and not charging for ${Math.round((now - blockedSince) / 60e3)}m`
+    );
+    const wake = await this.callTeslaAPI(job, teslaAPI.wakeUp, vehicle.vin);
+    const wakeState = wake?.response?.state;
+    if (wakeState !== "online") {
+      logVehicle(LogLevel.Warning, vehicle, `${vehicle.vin} emergency wake-up did not report online state`);
+      return false;
+    }
+    await this.recordEmergencyWakeUp(vehicle, now);
+    await this.refreshVehicleSchedules(job, vehicle, "post-emergency wake");
+    return true;
+  }
+
   public async serviceWork(job: TeslaAgentJob) {
-    job.interval = 60;
+    let desiredIntervalS = TeslaAgent.IDLE_SERVICE_INTERVAL_S;
 
     if (job.serviceData.invalid_token) {
       log(LogLevel.Trace, `Service ${job.serviceID} has an invalid token, skipping work`);
       return;
     }
 
-    const clearTelemetryConfigFor = [];
-    const setTelemetryConfigFor = [];
+    const clearTelemetryConfigFor: string[] = [];
+    const setTelemetryConfigFor: string[] = [];
+    const telemetryBackoffBaseMs = 5.625 * 60e3; // 5.625m -> 6m after ceil
+    const telemetryBackoffCapMs = 24 * 60 * 60e3;
 
     // Map service to vehicles
     if (!job.mapped || (job.serviceData.updated && job.mapped < job.serviceData.updated)) {
@@ -377,7 +837,7 @@ export class TeslaAgent extends AbstractAgent {
       for (const v of list) {
         if (v.vehicle_uuid) {
           job.state[v.vehicle_uuid] = v.vin;
-          log(LogLevel.Debug, `Service ${job.serviceID} found vehicle ${v.vin} (${v.vehicle_uuid})`);
+          vehicleLog(LogLevel.Debug, v.vehicle_uuid, `Service ${job.serviceID} found vehicle ${v.vin}`);
         } else {
           log(LogLevel.Debug, `Service ${job.serviceID} ignoring vehicle ${v.vin} (no vehicle_uuid)`);
           // Just always trigger a telemetry config clear for uncontolled vehicles
@@ -388,7 +848,7 @@ export class TeslaAgent extends AbstractAgent {
       job.mapped = Date.now();
       for (const uuid of Object.keys(unmapped)) {
         const vin = job.state[uuid];
-        log(LogLevel.Debug, `Service ${job.serviceID} unmapping vehicle ${vin} (no longer found)`);
+        vehicleLog(LogLevel.Debug, uuid, `Service ${job.serviceID} unmapping vehicle ${vin} (no longer found)`);
         delete job.state[uuid];
         delete this.vehicles[vin];
         // Just always trigger a telemetry config clear for unmapped vehicles
@@ -431,6 +891,10 @@ export class TeslaAgent extends AbstractAgent {
         vehicle.vehicleDataInput = { ...d, ...vehicle.vehicleDataInput };
         vehicle.lastVehicleDataInput = { ...d };
         vehicle.network = { ...data.providerData.network, ...vehicle.network };
+        vehicle.lastEmergencyWakeUpAt = this.lastEmergencyWakeUpAt(vehicle);
+        if (this.isChargingState(vehicle.telemetryData.DetailedChargeState)) {
+          vehicle.lastChargingAt = Date.now();
+        }
         await this.updateOnlineStatus(vehicle);
       } else {
         vehicle.dbData = data;
@@ -438,41 +902,62 @@ export class TeslaAgent extends AbstractAgent {
       }
 
       assert(vehicle !== undefined, "vehicle is undefined");
-      
+
+      const backoff = this.telemetryConfigBackoff[vehicle.vin];
+      if (backoff && backoff.until > Date.now()) {
+        logVehicle(
+          LogLevel.Debug,
+          vehicle,
+          `Telemetry config backoff active for ${vehicle.vin} until ${new Date(backoff.until).toISOString()}`
+        );
+        continue;
+      }
+
       // Handle telemetry config
       if (!vehicle.telemetryConfig) {
+        logVehicle(LogLevel.Trace, vehicle, `Calling TeslaAPI.getFleetTelemetryConfig`);
         vehicle.telemetryConfig = (await this.callTeslaAPI(job, teslaAPI.getFleetTelemetryConfig, vehicle.vin)).response;
       }
       const telemetryExpires = vehicle.telemetryConfig?.config && vehicle.telemetryConfig?.config.exp ? vehicle.telemetryConfig.config.exp : 0;
 
       if (vehicle.dbData.providerData.disabled) {
         if (vehicle.telemetryConfig?.config) {
-          log(LogLevel.Info, `Vehicle ${vehicle.vin} is disabled, but has telemetry config, deleting`);
+          logVehicle(LogLevel.Info, vehicle, `Vehicle ${vehicle.vin} is disabled, but has telemetry config, deleting`);
           clearTelemetryConfigFor.push(vehicle.vin);
           vehicle.telemetryConfig = null; // re-trigger a config read
           continue;
         }
       } else if (!vehicle.telemetryConfig?.config) {
-        log(LogLevel.Info, `No telemetry config for ${vehicle.vin}, creating`);
+        logVehicle(LogLevel.Info, vehicle, `No telemetry config for ${vehicle.vin}, creating`);
         setTelemetryConfigFor.push(vehicle.vin);
         vehicle.telemetryConfig = null; // re-trigger a config read
         continue;
       } else if (vehicle.telemetryConfig.config.hostname !== config.TESLA_TELEMETRY_HOST
         || vehicle.telemetryConfig.config.port !== config.TESLA_TELEMETRY_PORT
         || vehicle.telemetryConfig.config.ca !== config.TESLA_TELEMETRY_CA.replace(/\\n/g, "\n")) {
-        log(LogLevel.Info, `Telemetry config for ${vehicle.vin} has changed, refreshing`);
+        logVehicle(LogLevel.Info, vehicle, `Telemetry config for ${vehicle.vin} has changed, refreshing`);
         setTelemetryConfigFor.push(vehicle.vin);
         vehicle.telemetryConfig = null; // re-trigger a config read
         continue;
       } else if (telemetryExpires < Date.now() / 1e3) {
-        log(LogLevel.Info, `Telemetry config for ${vehicle.vin} expired, refreshing`);
+        logVehicle(LogLevel.Info, vehicle, `Telemetry config for ${vehicle.vin} expired, refreshing`);
         setTelemetryConfigFor.push(vehicle.vin);
         vehicle.telemetryConfig = null; // re-trigger a config read
         continue;
       } else {
         // From here we consider the telemetry config to be working so we can handle vehicle commands
+        desiredIntervalS = Math.min(
+          desiredIntervalS,
+          this.isConnected(vehicle)
+            ? this.isChargingState(vehicle.telemetryData.DetailedChargeState)
+              ? TeslaAgent.URGENT_SERVICE_INTERVAL_S
+              : TeslaAgent.ACTIVE_SERVICE_INTERVAL_S
+            : vehicle.isOnline
+              ? TeslaAgent.ACTIVE_SERVICE_INTERVAL_S
+              : TeslaAgent.IDLE_SERVICE_INTERVAL_S
+        );
         if (telemetryExpires < Date.now() / 1e3 + 60 * 60 * 24) {
-          log(LogLevel.Info, `Telemetry config for ${vehicle.vin} expires soon, refreshing`);
+          logVehicle(LogLevel.Info, vehicle, `Telemetry config for ${vehicle.vin} expires soon, refreshing`);
           setTelemetryConfigFor.push(vehicle.vin);
           vehicle.telemetryConfig = null;
         }
@@ -482,30 +967,67 @@ export class TeslaAgent extends AbstractAgent {
     }
 
     for (const vin of clearTelemetryConfigFor) {
+      const v = this.vehicles[vin];
+      if (v) {
+        logVehicle(LogLevel.Trace, v, `Calling TeslaAPI.deleteFleetTelemetryConfig`);
+      }
       log(LogLevel.Info, `Deleting telemetry config for ${vin}`);
       waitFor.push(this.callTeslaAPI(job, teslaAPI.deleteFleetTelemetryConfig, vin));
     }
     if (setTelemetryConfigFor.length > 0) {
       log(LogLevel.Info, `Creating telemetry config for ${setTelemetryConfigFor.join(", ")}`);
-      const telemetry = (await this.callTeslaAPI(job, teslaAPI.createFleetTelemetryConfig, {
-        vins: setTelemetryConfigFor,
-        config: {
-          hostname: config.TESLA_TELEMETRY_HOST,
-          port: config.TESLA_TELEMETRY_PORT,
-          ca: config.TESLA_TELEMETRY_CA.replace(/\\n/g, "\n"),
-          fields: telemetryFields,
-          prefer_typed: true,
-          exp: Math.trunc(Date.now() / 1e3 + 60 * 60 * 24 * 7), // 7 days
-        },
-      } as TeslaTelemetryConfig)).response;
+      for (const vin of setTelemetryConfigFor) {
+        const v = this.vehicles[vin];
+        if (v) {
+          logVehicle(LogLevel.Trace, v, `Calling TeslaAPI.createFleetTelemetryConfig (batch)`);
+        }
+      }
+      let telemetry;
+      try {
+        telemetry = (await this.callTeslaAPI(job, teslaAPI.createFleetTelemetryConfig, {
+          vins: setTelemetryConfigFor,
+          config: {
+            hostname: config.TESLA_TELEMETRY_HOST,
+            port: config.TESLA_TELEMETRY_PORT,
+            ca: config.TESLA_TELEMETRY_CA.replace(/\\n/g, "\n"),
+            fields: telemetryFields,
+            prefer_typed: true,
+            exp: Math.trunc(Date.now() / 1e3 + 60 * 60 * 24 * 7), // 7 days
+          },
+        } as TeslaTelemetryConfig)).response;
+      } catch (err) {
+        if (err instanceof RestClientError && err.code === 403 && err.message.includes("missing scopes")) {
+          for (const vin of setTelemetryConfigFor) {
+            const v = this.vehicles[vin];
+            const prev = this.telemetryConfigBackoff[vin];
+            const step = prev ? prev.step + 1 : 0;
+            const rawDelayMs = telemetryBackoffBaseMs * Math.pow(2, step);
+            const delayMs = Math.min(
+              telemetryBackoffCapMs,
+              Math.ceil(rawDelayMs / 60e3) * 60e3
+            );
+            const until = Date.now() + delayMs;
+            this.telemetryConfigBackoff[vin] = { step, until };
+            if (v) {
+              logVehicle(LogLevel.Warning, v, `Telemetry config blocked by scopes; backoff ${Math.round(delayMs / 60e3)}m`);
+            }
+          }
+          await Promise.all(waitFor);
+          return;
+        }
+        throw err;
+      }
       log(LogLevel.Debug, `Telemetry successfully created for ${telemetry.updated_vehicles} vehicles`);
+      for (const vin of setTelemetryConfigFor) {
+        delete this.telemetryConfigBackoff[vin];
+      }
       if (telemetry.skipped_vehicles) {
         log(LogLevel.Debug, `Skipped vehicles: ${JSON.stringify(telemetry)}`);
         if (telemetry.skipped_vehicles.missing_key) {
           for (const vin of telemetry.skipped_vehicles.missing_key) {
             const v = this.vehicles[vin];
             if (v.vehicleUUID) {
-              log(LogLevel.Warning, `Missing key for ${vin} (${v.vehicleUUID})`);
+              logVehicle(LogLevel.Warning, v, `Missing key for ${vin}`);
               v.dbData = await this.scClient.updateVehicle({
                 id: v.vehicleUUID,
                 status: "Missing virual key",
@@ -518,7 +1040,7 @@ export class TeslaAgent extends AbstractAgent {
           for (const vin of telemetry.skipped_vehicles.unsupported_hardware) {
             const v = this.vehicles[vin];
             if (v.vehicleUUID) {
-              log(LogLevel.Warning, `Unsupported hardware for ${vin} (${v.vehicleUUID})`);
+              logVehicle(LogLevel.Warning, v, `Unsupported hardware for ${vin}`);
               v.dbData = await this.scClient.updateVehicle({
                 id: v.vehicleUUID,
                 status: "Unsupported hardware",
@@ -531,7 +1053,7 @@ export class TeslaAgent extends AbstractAgent {
           for (const vin of telemetry.skipped_vehicles.unsupported_firmware) {
             const v = this.vehicles[vin];
             if (v.vehicleUUID) {
-              log(LogLevel.Warning, `Unsupported firmware for ${vin} (${v.vehicleUUID})`);
+              logVehicle(LogLevel.Warning, v, `Unsupported firmware for ${vin}`);
               v.dbData = await this.scClient.updateVehicle({
                 id: v.vehicleUUID,
                 status: "Unsupported firmware",
@@ -544,7 +1066,7 @@ export class TeslaAgent extends AbstractAgent {
           for (const vin of telemetry.skipped_vehicles.max_configs) {
             const v = this.vehicles[vin];
             if (v.vehicleUUID) {
-              log(LogLevel.Warning, `Max configs for ${vin} (${v.vehicleUUID})`);
+              logVehicle(LogLevel.Warning, v, `Max configs for ${vin}`);
               v.dbData = await this.scClient.updateVehicle({
                 id: v.vehicleUUID,
                 status: "No more telemetry configs allowed",
@@ -555,7 +1077,7 @@ export class TeslaAgent extends AbstractAgent {
         }
       }
     } else {
-      job.interval = 5 * 60; // Poll every 5 minutes
+      this.adjustInterval(job, desiredIntervalS);
     }
 
     await Promise.all(waitFor);
@@ -609,61 +1131,107 @@ export class TeslaAgent extends AbstractAgent {
   }
   public quantizeTime(t: string | number | null, method: (n: number) => number): number | null {
     const d = typeof t === "string" ? new Date(t).getTime() : typeof t === "number" ? t : null;
-    return d === null ? null : method(d / 15 / 60e3) * 15 * 60e3;
+    return d === null ? null : method(d / TeslaAgent.CHARGE_SCHEDULE_QUANTUM_MS) * TeslaAgent.CHARGE_SCHEDULE_QUANTUM_MS;
+  }
+  public async refreshVehicleSchedules(job: TeslaAgentJob, vehicle: VehicleEntry, reason: string, warnOnMismatch = false) {
+    logVehicle(LogLevel.Trace, vehicle, `Calling TeslaAPI.getVehicleSchedules (${reason})`);
+    vehicle.lastScheduleSyncAttemptAt = Date.now();
+    const schedules = (await this.callTeslaAPI(job, teslaAPI.getVehicleSchedules, vehicle.vin)).response;
+    const charge_schedules: { [id: number]: TeslaChargeSchedule } = {};
+    for (const s of schedules.charge_schedule_data.charge_schedules) {
+      charge_schedules[s.id] = s;
+    }
+    const precondition_schedules: { [id: number]: TeslaPreconditionSchedule } = {};
+    for (const s of schedules.preconditioning_schedule_data.precondition_schedules) {
+      precondition_schedules[s.id] = s;
+    }
+    logVehicle(LogLevel.Debug, vehicle, `${vehicle.vin} live charge schedules (${reason}): ${stringifyWithTimestamps(normalizeChargeSchedules(charge_schedules))}`);
+    logVehicle(LogLevel.Debug, vehicle, `${vehicle.vin} live preconditioning schedules (${reason}): ${stringifyWithTimestamps(normalizePreconditionSchedules(precondition_schedules))}`);
+    if (warnOnMismatch) {
+      const cachedCharge = stringifyWithTimestamps(normalizeChargeSchedules(vehicle.charge_schedules));
+      const liveCharge = stringifyWithTimestamps(normalizeChargeSchedules(charge_schedules));
+      if (!equalChargeSchedules(vehicle.charge_schedules, charge_schedules)) {
+        logVehicle(LogLevel.Warning, vehicle, `${vehicle.vin} cached charge schedules differ from live vehicle schedules (${reason}) cached=${cachedCharge} live=${liveCharge}`);
+      }
+      const cachedPrecon = stringifyWithTimestamps(normalizePreconditionSchedules(vehicle.precondition_schedules));
+      const livePrecon = stringifyWithTimestamps(normalizePreconditionSchedules(precondition_schedules));
+      if (!equalPreconditionSchedules(vehicle.precondition_schedules, precondition_schedules)) {
+        logVehicle(LogLevel.Warning, vehicle, `${vehicle.vin} cached preconditioning schedules differ from live vehicle schedules (${reason}) cached=${cachedPrecon} live=${livePrecon}`);
+      }
+    }
+    vehicle.charge_schedules = charge_schedules;
+    vehicle.precondition_schedules = precondition_schedules;
+    vehicle.lastScheduleSyncAt = Date.now();
   }
   public async vehicleWork(job: TeslaAgentJob, vehicle: VehicleEntry) {
     assert(vehicle.dbData !== null, "vehicle.dbData is null");
     try {
+      const now = Date.now();
+      const forceImmediateScheduleCheck = (vehicle.lastPlugInAt || 0) > (vehicle.lastImmediateScheduleCheckAt || 0);
+      const auditIntervalMs = this.scheduleAuditIntervalMs(now);
+
       // 24 minutes without a single update, I consider the vehicle offline
       if (vehicle.isOnline && vehicle.tsUpdate < Date.now() - 24 * 60e3) {
-        log(LogLevel.Info, `Vehicle ${vehicle.vin} is offline (stale connection)`);
+        logVehicle(LogLevel.Info, vehicle, `Vehicle ${vehicle.vin} is offline (stale connection)`);
         vehicle.network = {};
         await this.updateOnlineStatus(vehicle);
       }
 
-      // If this worker never polled the schedules, we do it now
+      // Poll schedules when we first see the vehicle online, then audit them periodically.
       if (vehicle.isOnline && (vehicle.charge_schedules === undefined || vehicle.precondition_schedules === undefined)) {
-        const schedules = (await this.callTeslaAPI(job, teslaAPI.getVehicleSchedules, vehicle.vin)).response;
-        // Map charge_schedule_data.charge_schedules to { [id: number]: TeslaChargeSchedule }
-        vehicle.charge_schedules = {};
-        for (const s of schedules.charge_schedule_data.charge_schedules) {
-          vehicle.charge_schedules[s.id] = s;
-        }
-        vehicle.precondition_schedules = {};
-        for (const s of schedules.preconditioning_schedule_data.precondition_schedules) {
-          vehicle.precondition_schedules[s.id] = s;
+        const lastAttemptAt = vehicle.lastScheduleSyncAttemptAt;
+        if (!forceImmediateScheduleCheck
+          && lastAttemptAt !== undefined
+          && lastAttemptAt + TeslaAgent.SCHEDULE_SYNC_RETRY_MS > now) {
+          return;
         }
+        await this.refreshVehicleSchedules(job, vehicle, "initial load");
+      } else if (auditIntervalMs !== null
+        && vehicle.isOnline
+        && (!vehicle.lastScheduleSyncAt || vehicle.lastScheduleSyncAt < now - auditIntervalMs)) {
+        await this.refreshVehicleSchedules(job, vehicle, "periodic audit", true);
       }
 
       const locationID = vehicle.dbData.chargePlanLocationID || vehicle.dbData.locationID;
-      if (locationID && vehicle.telemetryData.Location) {
+      if (locationID) {
         const location = await this.getLocation(locationID);
-        const distance = geoDistance(
-          location.geoLocation.latitude, location.geoLocation.longitude,
-          vehicle.telemetryData.Location.latitude, vehicle.telemetryData.Location.longitude
-        );
-        // If 7km or closer, take schedules into account
-        if (distance < 7e3) {
-          await this.handleSchedules(job, vehicle, location);
-        }
+        const distance = vehicle.telemetryData.Location
+          ? geoDistance(
+            location.geoLocation.latitude, location.geoLocation.longitude,
+            vehicle.telemetryData.Location.latitude, vehicle.telemetryData.Location.longitude
+          )
+          : null;
+        await this.handleSchedules(job, vehicle, location, distance, forceImmediateScheduleCheck);
+      } else {
+        await this.updateScheduleSyncIssue(vehicle, null);
       }
     } catch (err) {
       // Check if err is RestClientError
       if (err instanceof RestClientError) {
         if (err.code === 408) { // Request timeout
-          log(LogLevel.Warning, `Request timeout for ${vehicle.vin} (${err.message})`);
+          logVehicle(LogLevel.Warning, vehicle, `Request timeout for ${vehicle.vin} (${err.message})`);
           vehicle.network = {};
           await this.updateOnlineStatus(vehicle);
           return;
         }
       }
+      logVehicle(LogLevel.Error, vehicle, `vehicleWork error for ${vehicle.vin}: ${err instanceof Error ? err.message : String(err)}`);
     }
   }
-  public async handleSchedules(job: TeslaAgentJob, vehicle: VehicleEntry, location: GQLLocationFragment) {
+  public async handleSchedules(
+    job: TeslaAgentJob,
+    vehicle: VehicleEntry,
+    location: GQLLocationFragment,
+    distanceToLocationM: number | null,
+    forceImmediateScheduleCheck: boolean
+  ) {
     assert(vehicle.dbData !== null, "vehicle.dbData is null");
     assert(vehicle.telemetryData !== null, "vehicle.telemetryData is null");
     let wantedSoc: number | undefined;
     const now = Date.now();
+    if (forceImmediateScheduleCheck) {
+      vehicle.lastImmediateScheduleCheckAt = now;
+    }
 
     // Handle charge plans
     const chargePlan: (NumericChargePlan & { comment?: string })[] = (vehicle.dbData.chargePlan || [])
@@ -678,7 +1246,7 @@ export class TeslaAgent extends AbstractAgent {
       })
       // Convert to numeric charge plans with start and stop times rounded to 15 minutes
       .map((p): NumericChargePlan => {
-        if (wantedSoc === undefined && p.level) {
+        if (p.level !== undefined && (wantedSoc === undefined || wantedSoc < p.level)) {
           wantedSoc = p.level;
         }
         return {
@@ -699,22 +1267,31 @@ export class TeslaAgent extends AbstractAgent {
 
     } else if (vehicle.telemetryData.Soc && vehicle.telemetryData.ChargeLimitSoc && vehicle.telemetryData.Soc > vehicle.telemetryData.ChargeLimitSoc - 1.5) {
       // SOC is above or close to the limit, so we don't need schedule logic
-      log(LogLevel.Debug, `${vehicle.vin} skipping charge blocker logic because SOC is above or close to the limit`);
+      logVehicle(LogLevel.Debug, vehicle, `${vehicle.vin} skipping charge blocker logic because SOC is above or close to the limit`);
 
     } else if (vehicle.telemetryData.DetailedChargeState === telemetryData.DetailedChargeStateValue.DetailedChargeStateCharging && !insideFirstCharge) {
-      // We are charging to the limit, we need to stop charging
-      chargePlan.unshift({
-        chargeStart: null, chargeStop: this.quantizeTime(now - 10 * 60e3, Math.floor),
-        comment: "completed schedule to stop ongoing charging"
-      });
-      log(LogLevel.Debug, `${vehicle.vin} added charge blocker to stop ongoing charging`);
+      const nextFullSegmentEnd = this.quantizeTime(now, Math.ceil)! + TeslaAgent.CHARGE_SCHEDULE_QUANTUM_MS;
+      if (firstChargeStart < nextFullSegmentEnd) {
+        logVehicle(
+          LogLevel.Trace,
+          vehicle,
+          `${vehicle.vin} keeping ongoing charge because the next planned restart is before ${new Date(nextFullSegmentEnd).toISOString()}`
+        );
+      } else {
+        // We are charging outside the current plan. Only stop if the next planned restart is not
+        // before the end of the next full tariff segment; otherwise keep charging to avoid short
+        // stop/start churn while still respecting tariff-interval fidelity.
+        chargePlan.unshift({
+          chargeStart: null, chargeStop: this.quantizeTime(now - 10 * 60e3, Math.floor),
+          comment: "completed schedule to stop ongoing charging"
+        });
+      }
     } else if (vehicle.telemetryData.DetailedChargeState === telemetryData.DetailedChargeStateValue.DetailedChargeStateDisconnected && firstChargeStart > now + 17 * 60 * 60e3) {
       // We are disconnected, and the first charge is more than 17 hours in the future, so we need a charge blocker
       chargePlan.unshift({
         chargeStart: null, chargeStop: this.quantizeTime(now - 10 * 60e3, Math.floor),
         comment: "completed schedule to prevent charging when plugging in"
       });
-      log(LogLevel.Debug, `${vehicle.vin} added charge blocker to prevent charging when plugging in`);
     }
 
     // Build requested schedule
@@ -734,11 +1311,40 @@ export class TeslaAgent extends AbstractAgent {
         acc.push(p);
         return acc;
       }, [] as (NumericChargePlan & { comment?: string })[]);
-    log(LogLevel.Debug, `${vehicle.vin} requested schedule: ${stringifyWithTimestamps(requestedSchedule)}`);
+    logVehicle(LogLevel.Debug, vehicle, `${vehicle.vin} requested schedule: ${stringifyWithTimestamps(requestedSchedule)}`);
+
+    const connected = Boolean(vehicle.dbData?.isConnected || this.isConnected(vehicle));
+    if (!teslaShouldMaintainRemoteHomeSchedule(
+      connected,
+      location,
+      distanceToLocationM,
+      TeslaAgent.APPROACH_CHARGE_LOCATION_M
+    )) {
+      await this.updateScheduleSyncIssue(vehicle, null);
+      logVehicle(
+        LogLevel.Trace,
+        vehicle,
+        `${vehicle.vin} skipping home schedule maintenance while far from location (${Math.round((distanceToLocationM || 0) / 1e3)}km)`
+      );
+      return;
+    }
 
+    const canMutateSchedules = vehicle.isOnline
+      || await this.tryEmergencyWakeForCharging(job, vehicle, requestedSchedule, wantedSoc);
+
+    // Schedule reconciliation needs a live schedule view. After a restart, an offline vehicle may
+    // only get that by emergency-waking first and refreshing schedules as part of that wake path.
+    // If schedules are still unknown, do not invent a sync issue state; we only persist a flag
+    // when we know the vehicle schedule is wrong.
+    if (!vehicle.charge_schedules || !vehicle.precondition_schedules) {
+      logVehicle(LogLevel.Trace, vehicle, `${vehicle.vin} skipping schedule reconciliation because live schedules are unknown`);
+      return;
+    }
 
-    // If we know the vehicle schedules, we can start working on figuring out schedule updates
-    if (vehicle.charge_schedules && vehicle.precondition_schedules) {
+    {
+      const deferScheduleMutation = this.shouldDeferScheduleMutation(vehicle, requestedSchedule, now, location, distanceToLocationM);
+      let didMutateSchedules = false;
+      let hasInexactPurposeMatch = false;
       const freeScheduleIDs: number[] = [];
       const usedScheduleIDs = new Set<number>();
       const scheduleUpdates: (TeslaChargeSchedule & { comment: string })[] = [];
@@ -753,15 +1359,17 @@ export class TeslaAgent extends AbstractAgent {
           // Not our location
           // Due to a bug in Tesla API, when we overwrite a schedule, it does not update the location,
           // so we need to delete it if the location does not match
-          log(LogLevel.Debug, `${vehicle.vin} deleting schedule ${s.id} because it does not match location`);
+          logVehicle(LogLevel.Debug, vehicle, `${vehicle.vin} deleting schedule ${s.id} because it does not match location`);
+          logVehicle(LogLevel.Trace, vehicle, `Calling TeslaAPI.removeChargeSchedule(${s.id})`);
           await this.callTeslaAPI(job, teslaAPI.removeChargeSchedule, vehicle.vin, s.id);
+          didMutateSchedules = true;
           delete vehicle.charge_schedules[s.id];
         } else {
           vehicleSchedules[s.id] = { ...this.convertFromTeslaSchedule(s, location), scheduleID: s.id };
         }
       }
-      log(LogLevel.Debug, `${vehicle.vin} requested schedules: ${stringifyWithTimestamps(requestedSchedule)}`);
-      log(LogLevel.Debug, `${vehicle.vin} existing schedules: ${stringifyWithTimestamps(vehicleSchedules)}`);
+      logVehicle(LogLevel.Debug, vehicle, `${vehicle.vin} requested schedules: ${stringifyWithTimestamps(requestedSchedule)}`);
+      logVehicle(LogLevel.Debug, vehicle, `${vehicle.vin} existing schedules: ${stringifyWithTimestamps(vehicleSchedules)}`);
 
       const reversedVehicleSchedules = Object.values(vehicleSchedules).sort(
         (a, b) => compareStartStopTimes(b.chargeStart, b.chargeStop, a.chargeStart, a.chargeStop)
@@ -770,50 +1378,98 @@ export class TeslaAgent extends AbstractAgent {
       // Find out if we have a schedules that matches our request that we can use without modification
       // A modification is the same as creating a new schedule as we overwrite old IDs instead of deleting
       // overwrite = delete + create in one API call
-      for (const r of requestedSchedule.reverse()) {
-        const rStart = numericStartTime(r.chargeStart);
-        const rStop = numericStopTime(r.chargeStop);
+      for (const r of [...requestedSchedule].reverse()) {
         for (const s of reversedVehicleSchedules) {
           if (usedScheduleIDs.has(s.scheduleID)) continue;
-
-          const sStart = numericStartTime(s.chargeStart);
-          const sStop = numericStopTime(s.chargeStop);
-
-          if (sStart === rStart && sStop === rStop) {
-            log(LogLevel.Trace, `${vehicle.vin} found exact match for schedule ${s.scheduleID}`);
-          } else if (rStop < now && sStop < now && (now - sStop) < 5 * 60 * 60e3) {
-            log(LogLevel.Trace, `${vehicle.vin} found schedule ${s.scheduleID} in the past with stop time less than 5 hours ago (${new Date(sStop).toISOString()})`);
-          } else if (rStart < now && sStart < now && rStop === sStop) {
-            if (vehicle.telemetryData.DetailedChargeState === telemetryData.DetailedChargeStateValue.DetailedChargeStateStopped
-              && (now - sStart) > 5 * 60 * 60e3) {
-              log(LogLevel.Trace, `${vehicle.vin} found schedule ${s.scheduleID} in the past, but vehicle is not charging (${new Date(sStart).toISOString()})`);
-              continue;
-            }
-            log(LogLevel.Trace, `${vehicle.vin} found active schedule ${s.scheduleID} with matching stop time (${new Date(sStop).toISOString()})`);
-          } else {
+          if (!teslaScheduleServesRequestedPurpose(
+            connected,
+            vehicle.telemetryData.DetailedChargeState,
+            s,
+            r,
+            now,
+            location,
+            distanceToLocationM,
+            TeslaAgent.LOCKED_IN_SCHEDULE_CADENCE_MS,
+            TeslaAgent.FLUID_SCHEDULE_CADENCE_MS
+          )) {
             continue;
           }
+          logVehicle(
+            LogLevel.Trace,
+            vehicle,
+            `${vehicle.vin} found purpose match for schedule ${s.scheduleID}: ${stringifyWithTimestamps(s)}`
+          );
+          if (!teslaScheduleMatchesExactly(s, r)) {
+            hasInexactPurposeMatch = true;
+          }
           r.scheduleID = s.scheduleID;
           usedScheduleIDs.add(s.scheduleID);
           break;
         }
         if (r.scheduleID === undefined) {
           // No matching schedule found, we need to create a new one
-          log(LogLevel.Debug, `${vehicle.vin} requires a new schedule that starts ${r.chargeStart ? `at ${new Date(r.chargeStart).toISOString()}` : "now"} and ends ${r.chargeStop ? `at ${new Date(r.chargeStop).toISOString()}` : "whenever"}`);
+          logVehicle(LogLevel.Debug, vehicle, `${vehicle.vin} requires a new schedule that starts ${r.chargeStart ? `at ${new Date(r.chargeStart).toISOString()}` : "now"} and ends ${r.chargeStop ? `at ${new Date(r.chargeStop).toISOString()}` : "whenever"}`);
           scheduleUpdates.push({
             ...this.convertToTeslaSchedule(r, location),
             comment: "new schedule"
           });
         }
       }
-      log(LogLevel.Debug, `${vehicle.vin} schedule updates: ${stringifyWithTimestamps(scheduleUpdates)}`);
-
-      if (vehicle.isOnline) {
+      logVehicle(LogLevel.Debug, vehicle, `${vehicle.vin} schedule updates: ${stringifyWithTimestamps(scheduleUpdates)}`);
+      const wantedSocLimit = teslaWantedSocLimit(wantedSoc);
+      const issueKind = classifyChargingSetupSyncIssue(
+        requestedSchedule,
+        Object.values(vehicleSchedules),
+        now,
+        hasInexactPurposeMatch,
+        wantedSocLimit,
+        vehicle.telemetryData.ChargeLimitSoc,
+        vehicle.telemetryData.Soc,
+        connected
+      );
+      const scheduleMutationCooldownMs = teslaSchedulePurposeCadenceMs(
+        connected,
+        location,
+        distanceToLocationM,
+        TeslaAgent.LOCKED_IN_SCHEDULE_CADENCE_MS,
+        TeslaAgent.FLUID_SCHEDULE_CADENCE_MS
+      );
+      const nextAllowedScheduleMutationAt = (vehicle.lastScheduleMutationAt || now) + scheduleMutationCooldownMs;
+      const needsChargeLimitUpdate = connected
+        && wantedSocLimit !== null
+        && (vehicle.telemetryData.Soc ?? Number.POSITIVE_INFINITY) < wantedSocLimit
+        && vehicle.telemetryData.ChargeLimitSoc !== undefined
+        && vehicle.telemetryData.ChargeLimitSoc < wantedSocLimit
+        && requestedSchedule.some((window) => numericStopTime(window.chargeStop) > now && numericStartTime(window.chargeStart) <= nextAllowedScheduleMutationAt);
+
+      if (canMutateSchedules) {
+        if (!forceImmediateScheduleCheck && deferScheduleMutation && scheduleUpdates.length > 0 && !needsChargeLimitUpdate) {
+          await this.updateScheduleSyncIssue(
+            vehicle,
+            issueKind
+              ? {
+                kind: "drift",
+                locationID: location.id,
+                since: now,
+              }
+              : null
+          );
+          logVehicle(
+            LogLevel.Debug,
+            vehicle,
+            `${vehicle.vin} deferring schedule rewrite for ${Math.ceil((nextAllowedScheduleMutationAt - now) / 60e3)}m while schedule purpose is still fluid`
+          );
+          return;
+        }
+        await this.updateScheduleSyncIssue(vehicle, null);
         // Handle preconditioning schedules
         {
-          const scSchedule = vehicle.dbData.schedule
-            .filter((f) => f.type === GQLScheduleType.Trip && f.time && new Date(f.time).getTime() > now)
-            .sort((a, b) => compareStopTimes(a.time, b.time));
+          const autoHvac = vehicle.dbData.providerData && vehicle.dbData.providerData.auto_hvac !== false;
+          const scSchedule = autoHvac
+            ? vehicle.dbData.schedule
+              .filter((f) => f.type === GQLScheduleType.Trip && f.time && new Date(f.time).getTime() > now)
+              .sort((a, b) => compareStartTimes(a.time, b.time))
+            : [];
           let wantedPrecon: TeslaPreconditionSchedule | undefined;
           if (scSchedule.length > 0) {
             const departure = this.ConvertUTCtoLocationTime(location, new Date(scSchedule[0].time!));
@@ -829,20 +1485,25 @@ export class TeslaAgent extends AbstractAgent {
           }
           const existingPrecon = vehicle.precondition_schedules[TeslaScheduleIDs.Precondition];
           if (wantedPrecon) {
-            if (!existingPrecon || (wantedPrecon.precondition_time === existingPrecon.precondition_time
+            const isSame = !!existingPrecon
+              && wantedPrecon.precondition_time === existingPrecon.precondition_time
               && wantedPrecon.days_of_week === existingPrecon.days_of_week
-              && geoDistance(wantedPrecon.latitude, wantedPrecon.longitude, existingPrecon.latitude, existingPrecon.longitude) < 100
-            )) {
+              && geoDistance(wantedPrecon.latitude, wantedPrecon.longitude, existingPrecon.latitude, existingPrecon.longitude) < 100;
+            if (isSame) {
               // No change
-              log(LogLevel.Trace, `${vehicle.vin} preconditioning schedule is up to date`);
+              logVehicle(LogLevel.Trace, vehicle, `${vehicle.vin} preconditioning schedule is up to date`);
             } else {
-              log(LogLevel.Debug, `${vehicle.vin} updating preconditioning schedule`);
+              logVehicle(LogLevel.Debug, vehicle, `${vehicle.vin} updating preconditioning schedule`);
+              logVehicle(LogLevel.Trace, vehicle, `Calling TeslaAPI.addPreconditionSchedule`);
               await this.callTeslaAPI(job, teslaAPI.addPreconditionSchedule, vehicle.vin, wantedPrecon);
+              didMutateSchedules = true;
               vehicle.precondition_schedules[TeslaScheduleIDs.Precondition] = wantedPrecon;
             }
           } else if (existingPrecon) {
-            log(LogLevel.Debug, `${vehicle.vin} deleting preconditioning schedule`);
+            logVehicle(LogLevel.Debug, vehicle, `${vehicle.vin} deleting preconditioning schedule`);
+            logVehicle(LogLevel.Trace, vehicle, `Calling TeslaAPI.removePreconditionSchedule`);
             await this.callTeslaAPI(job, teslaAPI.removePreconditionSchedule, vehicle.vin, TeslaScheduleIDs.Precondition);
+            didMutateSchedules = true;
             delete vehicle.precondition_schedules[TeslaScheduleIDs.Precondition];
           }
         }
@@ -852,52 +1513,69 @@ export class TeslaAgent extends AbstractAgent {
           let findid = TeslaScheduleIDs.First;
           freeScheduleIDs.push(...Object.keys(vehicleSchedules).map((s) => parseInt(s)).filter((s) => !usedScheduleIDs.has(s)));
           for (const s of scheduleUpdates) {
-            if (s.id === undefined) {
-              if (freeScheduleIDs.length > 0) {
-                s.id = freeScheduleIDs.shift();
-              } else {
-                for (; findid <= TeslaScheduleIDs.Last; findid++) {
-                  if (!usedScheduleIDs.has(findid)) {
-                    s.id = findid;
-                    break;
-                  }
+            if (freeScheduleIDs.length > 0) {
+              s.id = freeScheduleIDs.shift();
+            } else {
+              for (; findid <= TeslaScheduleIDs.Last; findid++) {
+                if (!usedScheduleIDs.has(findid)) {
+                  s.id = findid;
+                  break;
                 }
               }
-              if (s.id === undefined) {
-                log(LogLevel.Warning, `${vehicle.vin} ran out of schedule IDs`);
-                break;
-              }
-              log(LogLevel.Debug, `${vehicle.vin} adding schedule ${s.id}`);
-              usedScheduleIDs.add(s.id);
+            }
+            if (s.id === undefined) {
+              logVehicle(LogLevel.Warning, vehicle, `${vehicle.vin} ran out of schedule IDs`);
+              break;
+            }
+            usedScheduleIDs.add(s.id);
+            if (s.comment === "new schedule") {
+              logVehicle(LogLevel.Debug, vehicle, `${vehicle.vin} setting schedule ${s.id}`);
             } else {
-              log(LogLevel.Debug, `${vehicle.vin} updating schedule ${s.id}`);
+              logVehicle(LogLevel.Debug, vehicle, `${vehicle.vin} ${s.comment}`);
             }
             assert(usedScheduleIDs.has(s.id), "Invalid schedule ID");
+            logVehicle(LogLevel.Trace, vehicle, `Calling TeslaAPI.addChargeSchedule(${s.id})`);
             await this.callTeslaAPI(job, teslaAPI.addChargeSchedule, vehicle.vin, s);
+            didMutateSchedules = true;
             // Cache the newly set schedule with correct lat/long (only after successful API call)
             vehicle.charge_schedules[s.id] = s;
-            log(LogLevel.Debug, `${vehicle.vin} cached schedule ${s.id} @ [${s.latitude},${s.longitude}]`);
+            logVehicle(LogLevel.Debug, vehicle, `${vehicle.vin} cached schedule ${s.id} @ [${s.latitude},${s.longitude}]`);
           }
         }
 
         // Remove any schedules that are not in use
         for (const s of Object.values(vehicleSchedules)) {
           if (!usedScheduleIDs.has(s.scheduleID)) {
-            log(LogLevel.Debug, `${vehicle.vin} deleting schedule ${s.scheduleID}`);
+            logVehicle(LogLevel.Debug, vehicle, `${vehicle.vin} deleting schedule ${s.scheduleID}`);
             // Log to database that we are deleting this schedule
+            logVehicle(LogLevel.Trace, vehicle, `Calling TeslaAPI.removeChargeSchedule(${s.scheduleID})`);
             await this.callTeslaAPI(job, teslaAPI.removeChargeSchedule, vehicle.vin, s.scheduleID);
+            didMutateSchedules = true;
             delete vehicle.charge_schedules[s.scheduleID];
           }
         }
 
         // Update SOC if needed
-        if (this.isConnected(vehicle) && wantedSoc) {
-          const limitedSoc = Math.max(config.TESLA_LOWEST_POSSIBLE_CHARGETO, Math.min(wantedSoc, 100));
-          if (vehicle.telemetryData.ChargeLimitSoc !== limitedSoc) {
-            log(LogLevel.Debug, `${vehicle.vin} setting charge limit to ${limitedSoc}%`);
-            await this.callTeslaAPI(job, teslaAPI.setChargeLimit, vehicle.vin, limitedSoc);
+        if (this.isConnected(vehicle) && wantedSocLimit !== null) {
+          if (vehicle.telemetryData.ChargeLimitSoc !== wantedSocLimit) {
+            logVehicle(LogLevel.Debug, vehicle, `${vehicle.vin} setting charge limit to ${wantedSocLimit}%`);
+            logVehicle(LogLevel.Trace, vehicle, `Calling TeslaAPI.setChargeLimit(${wantedSocLimit}%)`);
+            await this.callTeslaAPI(job, teslaAPI.setChargeLimit, vehicle.vin, wantedSocLimit);
           }
         }
+        if (this.scheduleAuditIntervalMs(now) !== null && didMutateSchedules) {
+          await this.refreshVehicleSchedules(job, vehicle, "post-update audit", true);
+        }
+        if (didMutateSchedules) {
+          vehicle.lastScheduleMutationAt = Date.now();
+        }
+      } else {
+        await this.updateScheduleSyncIssue(
+          vehicle,
+          issueKind
+            ? { kind: issueKind, locationID: location.id, since: now }
+            : null
+        );
       }
     }
   }
@@ -946,7 +1624,7 @@ export class TeslaAgent extends AbstractAgent {
       }
     }
     if (Object.keys(update).length > 1) {
-      log(LogLevel.Debug, `Updating vehicle ${vehicle.vin}: ${JSON.stringify(update)}`);
+      logVehicle(LogLevel.Debug, vehicle, `Updating vehicle ${vehicle.vin}: ${JSON.stringify(update)}`);
       vehicle.dbData = await this.scClient.updateVehicle(update);
     }
   }
@@ -954,8 +1632,12 @@ export class TeslaAgent extends AbstractAgent {
   public async telemetryConnectivityMessage(
     data: telemetryConnectivity.VehicleConnectivity
   ) {
-    log(LogLevel.Info, `Tesla Telmetry connectivity ${data.vin} ${data.connectionId} ${data.networkInterface} ${telemetryConnectivity.ConnectivityEvent[data.status]}`);
     const vehicle = this.vehicleEntry(data.vin);
+    logVehicle(
+      LogLevel.Info,
+      vehicle,
+      `Tesla Telemetry connectivity ${data.vin} ${data.connectionId} ${data.networkInterface} ${telemetryConnectivity.ConnectivityEvent[data.status]}`
+    );
     vehicle.tsUpdate = Date.now();
 
     if (data.status === telemetryConnectivity.ConnectivityEvent.DISCONNECTED) {
@@ -963,6 +1645,7 @@ export class TeslaAgent extends AbstractAgent {
     } else if (data.status === telemetryConnectivity.ConnectivityEvent.CONNECTED) {
       vehicle.network[data.connectionId] = data.networkInterface;
     }
+    this.requestServiceWork(vehicle, TeslaAgent.URGENT_SERVICE_INTERVAL_S, "connectivity change");
     if (vehicle.vehicleUUID) {
       await this.updateOnlineStatus(vehicle);
     }
@@ -972,10 +1655,13 @@ export class TeslaAgent extends AbstractAgent {
     if (!datum.value) return;
     const key = datum.key;
     const value = datum.value && datum.value.value;
-
-    log(LogLevel.Trace, `Telemetry data for ${vin}: ${telemetryData.Field[key]} = ${value.value} (${value.case})`);
-
     const vehicle = this.vehicleEntry(vin);
+    const previousDetailedChargeState = vehicle.telemetryData.DetailedChargeState;
+    logVehicle(
+      LogLevel.Trace,
+      vehicle,
+      `Telemetry data for ${vin}: ${telemetryData.Field[key]} = ${formatTelemetryValue(value)} (${value.case})`
+    );
     vehicle.tsUpdate = Date.now();
 
     if (value.case === "invalid") {
@@ -1021,6 +1707,8 @@ export class TeslaAgent extends AbstractAgent {
           case telemetryData.Field.Odometer:
           case telemetryData.Field.OutsideTemp:
           case telemetryData.Field.InsideTemp:
+          case telemetryData.Field.ModuleTempMin:
+          case telemetryData.Field.ModuleTempMax:
           case telemetryData.Field.TimeToFullCharge:
           case telemetryData.Field.ChargeAmps:
           case telemetryData.Field.ChargeCurrentRequest:
@@ -1049,6 +1737,10 @@ export class TeslaAgent extends AbstractAgent {
           case telemetryData.Field.DetailedChargeState:
             assert(value.case === "detailedChargeStateValue", `Invalid DetailedChargeState value type ${value.case}`);
             vehicle.telemetryData.DetailedChargeState = value.value;
+            if (previousDetailedChargeState === telemetryData.DetailedChargeStateValue.DetailedChargeStateDisconnected
+              && value.value !== telemetryData.DetailedChargeStateValue.DetailedChargeStateDisconnected) {
+              vehicle.lastPlugInAt = Date.now();
+            }
             break;
           case telemetryData.Field.HvacAutoMode:
             assert(value.case === "hvacAutoModeValue", `Invalid HvacAutoMode value type ${value.case}`);
@@ -1086,8 +1778,12 @@ export class TeslaAgent extends AbstractAgent {
         }
       } catch (err) {
         // We catch this here so that it doesn't crash the entire worker, leaving Kafka in a sad state
-        log(LogLevel.Error, `Failed to handle telemetry data for ${vin}: ${telemetryData.Field[key]} = ${value.value} (${value.case})`);
-        log(LogLevel.Error, err);
+        logVehicle(
+          LogLevel.Error,
+          vehicle,
+          `Failed to handle telemetry data for ${vin}: ${telemetryData.Field[key]} = ${formatTelemetryValue(value)} (${value.case})`
+        );
+        logVehicle(LogLevel.Error, vehicle, err);
         return;
       }
       // charger_phases seems to be reported wrong, or I simply don't understand and someone could explain it?
@@ -1097,9 +1793,22 @@ export class TeslaAgent extends AbstractAgent {
       // (charger_power * 1e3) / (charger_actual_current * charger_voltage)
     }
 
+    if (this.isChargingState(vehicle.telemetryData.DetailedChargeState)) {
+      vehicle.lastChargingAt = Date.now();
+    }
+    if (
+      key === telemetryData.Field.DetailedChargeState
+      || key === telemetryData.Field.ChargeState
+      || key === telemetryData.Field.ChargeEnableRequest
+      || key === telemetryData.Field.ScheduledChargingPending
+      || key === telemetryData.Field.Location
+    ) {
+      this.requestServiceWork(vehicle, TeslaAgent.URGENT_SERVICE_INTERVAL_S, telemetryData.Field[key]);
+    }
+
     if (vehicle.vehicleUUID) {
       if (vehicle.isUpdating) {
-        log(LogLevel.Info, `Vehicle ${vin} is already updating, waiting for it to finish`);
+        logVehicle(LogLevel.Info, vehicle, `Vehicle ${vin} is already updating, waiting for it to finish`);
         assert(vehicle.updatePromise !== null, "updatePromise is null");
         await vehicle.updatePromise;
       }
@@ -1189,7 +1898,7 @@ export class TeslaAgent extends AbstractAgent {
               } else {
                 vehicle.vehicleDataInput.chargingTo = null;
               }
-              log(LogLevel.Debug, `Updating vehicle ${vehicle.vin} with ${JSON.stringify(vehicleUpdate)}`);
+              logVehicle(LogLevel.Debug, vehicle, `Updating vehicle ${vehicle.vin} with ${JSON.stringify(vehicleUpdate)}`);
               innerPromises.push((async () => {
                 vehicle.dbData = await this.scClient.updateVehicle(vehicleUpdate);
               })());
@@ -1201,7 +1910,7 @@ export class TeslaAgent extends AbstractAgent {
             if (Object.keys(vehicleDataUpdate).length > 0) {
               assert(vehicle.vehicleUUID !== null, "vehicleUUID is null");
 
-              log(LogLevel.Debug, `Updating vehicle data ${vehicle.vin} with ${JSON.stringify(vehicleDataUpdate)}`);
+              logVehicle(LogLevel.Debug, vehicle, `Updating vehicle data ${vehicle.vin} with ${JSON.stringify(vehicleDataUpdate)}`);
               innerPromises.push(this.scClient.updateVehicleData({
                 id: vehicle.vehicleUUID,
                 ...vehicleDataUpdate,
@@ -1210,7 +1919,7 @@ export class TeslaAgent extends AbstractAgent {
 
             await Promise.all(innerPromises);
           } catch (err) {
-            log(LogLevel.Error, `Error in updatePromise: ${err}`);
+            logVehicle(LogLevel.Error, vehicle, `Error in updatePromise: ${err}`);
           } finally {
             vehicle.isUpdating = false;
             vehicle.updatePromise = null;
diff --git a/providers/tesla/tesla-api.ts b/providers/tesla/tesla-api.ts
index c9ad6587..73ca1b3c 100644
--- a/providers/tesla/tesla-api.ts
+++ b/providers/tesla/tesla-api.ts
@@ -14,6 +14,17 @@ function time(): number {
   return Math.floor(new Date().valueOf() / 1e3);
 }
 
+export function redactSecret(value: string): string {
+  if (value.length <= 6) return "***";
+  return `${value.slice(0, 3)}…${value.slice(-3)}`;
+}
+
+function responseShape(response: unknown): string {
+  if (typeof response !== "object" || !response) return `type=${typeof response}`;
+  const keys = Object.keys(response as Record<string, unknown>);
+  return `keys=[${keys.sort().join(",")}]`;
+}
+
 export interface TeslaTelemetryConfig {
   config: {
     hostname: string;
@@ -89,14 +100,14 @@ export class TeslaAPI {
   public parseTokenResponse(response: any): TeslaToken {
     // Parse the token response
     if (typeof response.access_token !== "string") {
-      throw new RestClientError(`Error parsing Tesla oauth2 v3 token response, missing access_token ${JSON.stringify(response)}`, 500);
+      throw new RestClientError(`Error parsing Tesla oauth2 v3 token response, missing access_token (${responseShape(response)})`, 500);
     }
     if (typeof response.refresh_token !== "string") {
-      throw new RestClientError(`Error parsing Tesla oauth2 v3 token response, missing refresh_token ${JSON.stringify(response)}`, 500);
+      throw new RestClientError(`Error parsing Tesla oauth2 v3 token response, missing refresh_token (${responseShape(response)})`, 500);
     }
     const expires = Number.parseInt(response.expires_in);
     if (!Number.isInteger(expires)) {
-      throw new RestClientError(`Error parsing Tesla oauth2 v3 token response, invalid expires_in ${JSON.stringify(response)}`, 500);
+      throw new RestClientError(`Error parsing Tesla oauth2 v3 token response, invalid expires_in (${responseShape(response)})`, 500);
     }
 
     return {
@@ -108,7 +119,7 @@ export class TeslaAPI {
 
   public async authorize(code: string, callbackURI: string): Promise<TeslaToken> {
     try {
-      log(LogLevel.Trace, `authorize(${code}, ${callbackURI})`);
+      log(LogLevel.Trace, `authorize(${redactSecret(code)}, ${callbackURI})`);
 
       // Tesla authAPI expects form data in the body
       const formData = new URLSearchParams();
@@ -135,11 +146,11 @@ export class TeslaAPI {
   private renewTokenLock: Set<string> = new Set();
   public async renewToken(refresh_token: string): Promise<TeslaToken> {
     if (this.renewTokenLock.has(refresh_token)) {
-      throw new RestClientError(`Concurrent renewToken(${refresh_token}) calls are not allowed`, 500);
+      throw new RestClientError(`Concurrent renewToken(${redactSecret(refresh_token)}) calls are not allowed`, 500);
     }
     this.renewTokenLock.add(refresh_token);
     try {
-      log(LogLevel.Trace, `TeslaAPI.renewToken(${refresh_token})`);
+      log(LogLevel.Trace, `TeslaAPI.renewToken(${redactSecret(refresh_token)})`);
 
       // Tesla authAPI expects form data in the body
       const formData = new URLSearchParams();
@@ -148,10 +159,10 @@ export class TeslaAPI {
       formData.append("refresh_token", refresh_token);
 
       const authResponse = (await this.authAPI.post("/oauth2/v3/token", formData.toString())) as any;
-      log(LogLevel.Trace, `TeslaAPI.renewToken(${refresh_token}) response: ${JSON.stringify(authResponse)}`);
+      log(LogLevel.Trace, `TeslaAPI.renewToken(${redactSecret(refresh_token)}) response: ${JSON.stringify({ expires_in: authResponse?.expires_in })}`);
       return this.parseTokenResponse(authResponse);
     } catch (e) {
-      console.debug(`TeslaAPI.renewToken(${refresh_token}) error: ${e}`);
+      console.debug(`TeslaAPI.renewToken(${redactSecret(refresh_token)}) error: ${e}`);
       throw e;
     } finally {
       this.renewTokenLock.delete(refresh_token);
diff --git a/providers/tesla/tesla-server.ts b/providers/tesla/tesla-server.ts
index d490a25a..b5073408 100644
--- a/providers/tesla/tesla-server.ts
+++ b/providers/tesla/tesla-server.ts
@@ -2,7 +2,7 @@ import { accountFilter } from "@server/gql/api.js";
 import type { IContext } from "@server/gql/api.js";
 import provider, { TeslaProviderMutates, TeslaProviderQueries, TeslaProviderData, TeslaToken } from "./index.js";
 import { DBInterface } from "@server/db-interface.js";
-import teslaAPI, { TeslaAPI } from "./tesla-api.js";
+import teslaAPI, { redactSecret, TeslaAPI } from "./tesla-api.js";
 import { log, LogLevel } from "@shared/utils.js";
 import { IProviderServer } from "@providers/provider-server.js";
 import { TeslaNewListEntry } from "./app/tesla-helper.js";
@@ -17,7 +17,7 @@ export async function authorize(
   callbackURI: string
 ): Promise<TeslaToken> {
   try {
-    log(LogLevel.Trace, `authorize(${code}, ${callbackURI})`);
+    log(LogLevel.Trace, `authorize(${redactSecret(code)}, ${callbackURI})`);
     return await teslaAPI.authorize(code, callbackURI);
   } catch (err) {
     log(LogLevel.Error, err);
@@ -38,7 +38,7 @@ export async function maintainServiceToken(
     service.service_data.token.expires_at !== undefined &&
     !TeslaAPI.tokenExpired(service.service_data.token as TeslaToken)
   ) {
-    log(LogLevel.Trace, `Token ${service.service_data.token.access_token} is still valid`);
+    log(LogLevel.Trace, `Token ${redactSecret(service.service_data.token.access_token)} is still valid`);
     return service.service_data.token as TeslaToken;
   }
 
@@ -51,11 +51,11 @@ export async function maintainServiceToken(
   );
   // If we got a row back, we are the only thread that is refreshing the token
   if (updateService) {
-    log(LogLevel.Debug, `Token ${service.service_data.token.access_token} is expired, calling renewToken`);
+    log(LogLevel.Debug, `Token ${redactSecret(service.service_data.token.access_token)} is expired, calling renewToken`);
     try {
       const newToken = await teslaAPI.renewToken(service.service_data.token.refresh_token);
       // Update the token in the database
-      log(LogLevel.Trace, `Token ${service.service_data.token.access_token} renewed to ${newToken.access_token}`);
+      log(LogLevel.Trace, `Token ${redactSecret(service.service_data.token.access_token)} renewed to ${redactSecret(newToken.access_token)}`);
       log(LogLevel.Info, `Updating service_provider ${service.service_uuid} with new token`);
       await db.pg.none(
         `UPDATE service_provider SET service_data = jsonb_strip_nulls(service_data || $2) WHERE service_uuid=$1;
@@ -74,7 +74,7 @@ export async function maintainServiceToken(
       return newToken;
     } catch (err: any) {
       if (err && (err.message === "login_required" || err.message === "server_error")) {
-        log(LogLevel.Warning, `Refresh token ${service.service_data.token.refresh_token} is invalid (${err.message})`);
+        log(LogLevel.Warning, `Refresh token ${redactSecret(service.service_data.token.refresh_token)} is invalid (${err.message})`);
         log(LogLevel.Info, `Setting service_provider ${service.service_uuid} as invalid token status`);
         await db.pg.none(
           `UPDATE service_provider SET service_data = jsonb_strip_nulls(service_data || $2) WHERE service_uuid=$1;
@@ -97,7 +97,7 @@ export async function maintainServiceToken(
       );
     }
   } else {
-    log(LogLevel.Debug, `Token ${service.service_data.token.access_token} is already being refreshed, ignoring`);
+    log(LogLevel.Debug, `Token ${redactSecret(service.service_data.token.access_token)} is already being refreshed, ignoring`);
     return null;
   }
 }
@@ -105,7 +105,6 @@ export async function maintainServiceToken(
 const server: IProviderServer = {
   ...provider,
   query: async (data: any, context: IContext) => {
-    console.debug(data);
     switch (data.query) {
       case TeslaProviderQueries.Vehicles: {
         if (data.token) {
diff --git a/server/db-interface.ts b/server/db-interface.ts
index 8735684c..2d4b2603 100644
--- a/server/db-interface.ts
+++ b/server/db-interface.ts
@@ -23,7 +23,7 @@ import {
 } from "./db-schema.js";
 import { log, LogLevel, geoDistance } from "@shared/utils.js";
 import config from "@shared/smartcharge-config.js";
-import { SmartChargeGoal } from "@shared/sc-types.js";
+import { SmartChargeGoal, SplitCharge } from "@shared/sc-types.js";
 import { DEFAULT_DIRECTLEVEL } from "@shared/smartcharge-defines.js";
 import { VehicleLocationSettings, Schedule } from "./gql/vehicle-type.js";
 
@@ -311,6 +311,7 @@ export class DBInterface {
       locationID: location_uuid || "",
       directLevel: DEFAULT_DIRECTLEVEL,
       goal: SmartChargeGoal.Balanced,
+      splitCharge: SplitCharge.Auto,
     };
   }
 
diff --git a/server/gql/vehicle-resolver.ts b/server/gql/vehicle-resolver.ts
index a66b479d..3f3b2f5d 100644
--- a/server/gql/vehicle-resolver.ts
+++ b/server/gql/vehicle-resolver.ts
@@ -30,7 +30,7 @@ import {
   VehicleLocationSettings,
   Schedule,
 } from "./vehicle-type.js";
-import { log, LogLevel, makePublicID } from "@shared/utils.js";
+import { LogLevel, makePublicID, vehicleLog } from "@shared/utils.js";
 import { plainToInstance } from "class-transformer";
 import { DBSchedule } from "@server/db-schema.js";
 import { ScheduleType } from "@shared/sc-types.js";
@@ -117,8 +117,8 @@ export class VehicleResolver {
     @Ctx() context: IContext
   ): Promise<boolean> {
     // verify vehicle ownage
-    log(LogLevel.Debug, `removeVehicle: ${JSON.stringify(id)}`);
     const vehicle = await context.db.getVehicle(accountFilter(context.accountUUID), id);
+    vehicleLog(LogLevel.Debug, vehicle.vehicle_uuid, `removeVehicle: ${JSON.stringify(id)}`);
 
     const publicID = makePublicID(vehicle.vehicle_uuid);
     if (confirm.toLowerCase() !== publicID) {
@@ -139,8 +139,8 @@ export class VehicleResolver {
     @PubSub() pubSub: PubSubEngine
   ): Promise<Vehicle> {
     // verify vehicle ownage
-    log(LogLevel.Debug, `updateVehicle: ${JSON.stringify(input)}`);
-    await context.db.getVehicle(accountFilter(context.accountUUID), input.id);
+    const vehicle = await context.db.getVehicle(accountFilter(context.accountUUID), input.id);
+    vehicleLog(LogLevel.Debug, vehicle.vehicle_uuid, `updateVehicle: ${JSON.stringify(input)}`);
 
     // remap settings array to settings map
     const locationSettingsMap =
@@ -150,6 +150,7 @@ export class VehicleResolver {
           map[obj.locationID] = {
             directLevel: obj.directLevel,
             goal: obj.goal,
+            splitCharge: obj.splitCharge,
           };
           return map;
         },
@@ -184,11 +185,11 @@ export class VehicleResolver {
     @PubSub() pubSub: PubSubEngine
   ): Promise<boolean> {
     // verify vehicle ownage
-    log(LogLevel.Debug, `removeSchedule: ${JSON.stringify(id)}`);
     const vehicle = await context.db.getVehicle(
       accountFilter(context.accountUUID),
       vehicleID
     );
+    vehicleLog(LogLevel.Debug, vehicle.vehicle_uuid, `removeSchedule: ${JSON.stringify(id)}`);
 
     await context.db.removeSchedule(id, vehicle.vehicle_uuid);
     await context.logic.refreshChargePlan(vehicle.vehicle_uuid);
@@ -213,8 +214,8 @@ export class VehicleResolver {
     @PubSub() pubSub: PubSubEngine
   ): Promise<DBSchedule[]> {
     // verify vehicle ownage
-    log(LogLevel.Debug, `updateSchedule: ${JSON.stringify(id)} ${JSON.stringify(vehicleID)}`);
     const vehicle = await context.db.getVehicle(accountFilter(context.accountUUID), vehicleID);
+    vehicleLog(LogLevel.Debug, vehicle.vehicle_uuid, `updateSchedule: ${JSON.stringify(id)} ${JSON.stringify(vehicleID)}`);
 
     await context.db.updateSchedule(
       id,
diff --git a/server/gql/vehicle-type.ts b/server/gql/vehicle-type.ts
index db473d39..50ee9941 100644
--- a/server/gql/vehicle-type.ts
+++ b/server/gql/vehicle-type.ts
@@ -11,6 +11,7 @@ import { GraphQLJSONObject } from "graphql-type-json";
 import { GeoLocation, Location } from "./location-type.js";
 import {
   SmartChargeGoal,
+  SplitCharge,
   ChargeType,
   ChargeConnection,
   ScheduleType,
@@ -34,12 +35,18 @@ export class VehicleLocationSettings {
     directLevel!: number;
   @Field((_type) => String)
     goal!: SmartChargeGoal | string;
+  @Field((_type) => SplitCharge)
+    splitCharge!: SplitCharge;
 }
 // Not used because we cannot union between enum and String in type-graphql
 registerEnumType(SmartChargeGoal, {
   name: "SmartChargeGoal",
   description: "Smart Charge Goal Presets",
 });
+registerEnumType(SplitCharge, {
+  name: "SplitCharge",
+  description: "Split Charge Preference",
+});
 
 /*******************************
  *         ChargePlan          *
@@ -292,4 +299,4 @@ export abstract class UpdateVehicleDataInput {
     energyUsed?: number | null;
   @Field((_type) => Float, { nullable: true, description: `charge added (kWh)` })
     energyAdded?: number | null;
-}
\ No newline at end of file
+}
diff --git a/server/logic.ts b/server/logic.ts
index 18b71311..d0bbaa50 100644
--- a/server/logic.ts
+++ b/server/logic.ts
@@ -11,19 +11,41 @@ import { DBInterface } from "./db-interface.js";
 import { DBVehicle, DBCharge, DBChargeCurrent, DBTrip, DBConnected, DBLocationStats, DBStatsMap, DBSchedule, } from "./db-schema.js";
 import {
   LogLevel,
-  log,
+  vehicleLog,
   arrayMean,
   compareStartStopTimes,
   numericStartTime,
   numericStopTime,
   compareStartTimes,
-  capitalize,
-  diffObjects
+  diffObjects,
 } from "@shared/utils.js";
 import { UpdateVehicleDataInput, ChargePlan, Schedule, VehicleLocationSettings } from "./gql/vehicle-type.js";
-import { SmartChargeGoal, ChargeType, ScheduleType } from "@shared/sc-types.js";
+import { SmartChargeGoal, SplitCharge, ChargeType, ScheduleType } from "@shared/sc-types.js";
 import { MIN_STATS_PERIOD, SCHEDULE_TOPUP_MARGIN } from "@shared/smartcharge-defines.js";
 
+const CHARGE_PRIO: Record<ChargeType, number> = {
+  [ChargeType.Disable]: 0,
+  [ChargeType.Calibrate]: 1,
+  [ChargeType.Minimum]: 2,
+  [ChargeType.Manual]: 3,
+  [ChargeType.Trip]: 4,
+  [ChargeType.Routine]: 5,
+  [ChargeType.Prefered]: 6,
+  [ChargeType.Fill]: 7,
+};
+
+// Detailed tariff data is expected to cover the next 48 hours. The price-based
+// planner only needs to consider scheduled intents once charging for them may
+// need to begin inside this window.
+const PRICE_PLAN_LOOKAHEAD_MS = 48 * 60 * 60e3;
+const PRICE_DATA_LOOKBACK_MS = 60 * 60e3;
+// Fetch one extra slot past the planning horizon so the last in-window slot keeps its real duration.
+const PRICE_DATA_PADDING_MS = 60 * 60e3;
+// Manual one-off schedules should survive very short repositioning trips, but be cleared
+// once the vehicle has clearly departed from the starting known location. This is a
+// departure heuristic, not a geofence: schedule maintenance uses its own distance bands.
+const MANUAL_SCHEDULE_DEPARTURE_THRESHOLD_M = 3e3;
+
 export class Logic {
   constructor(private db: DBInterface) { }
   public init() { }
@@ -34,8 +56,8 @@ export class Logic {
   ) {
     // Lookup old record
     const was: DBVehicle = await this.db.getVehicle(undefined, input.id);
-    log(LogLevel.Trace, `input: ${JSON.stringify(input)}`);
-    log(LogLevel.Trace, `vehicle: ${JSON.stringify(was)}`);
+    vehicleLog(LogLevel.Trace, was.vehicle_uuid, `input: ${JSON.stringify(input)}`);
+    vehicleLog(LogLevel.Trace, was.vehicle_uuid, `vehicle: ${JSON.stringify(was)}`);
 
     const vehicle = { ...was };
     let connection: DBConnected | null = null;
@@ -96,7 +118,7 @@ export class Logic {
               connected: true,
             }
           )) as DBConnected;
-          log(LogLevel.Debug, `Started connection ${connection.connected_id}`);
+          vehicleLog(LogLevel.Debug, vehicle.vehicle_uuid, `Started connection ${connection.connected_id}`);
           vehicle.connected_id = connection.connected_id;
           if (connection.location_uuid !== null) {
             await this.createNewStats(vehicle, connection.location_uuid);
@@ -107,20 +129,20 @@ export class Logic {
             `UPDATE connected SET type = $1, location_uuid = $2 WHERE connected_id = $3 RETURNING *;`,
             [input.connectedCharger, vehicle.location_uuid, connection.connected_id]
           )) as DBConnected;
-          log(LogLevel.Debug, `Reconnected to connection ${connection.connected_id}`);
+          vehicleLog(LogLevel.Debug, vehicle.vehicle_uuid, `Reconnected to connection ${connection.connected_id}`);
         }
         doPricePlan = true;
         vehicle.connected_id = connection.connected_id;
-        log(LogLevel.Debug, `Vehicle connected (connected_id=${connection.connected_id})`);
+        vehicleLog(LogLevel.Debug, vehicle.vehicle_uuid, `Vehicle connected (connected_id=${connection.connected_id})`);
       } else {
         // We disconnected
         if (was.connected_id !== null) {
-          log(LogLevel.Debug, `Ending connection ${was.connected_id}`);
+          vehicleLog(LogLevel.Debug, vehicle.vehicle_uuid, `Ending connection ${was.connected_id}`);
           await this.db.pg.none(
             `UPDATE connected SET end_ts = $1, end_level = $2, connected = false WHERE connected_id = $3;`,
             [now, vehicle.level, was.connected_id]
           );
-          log(LogLevel.Debug, `Vehicle no longer connected (connected_id=${was.connected_id})`);
+          vehicleLog(LogLevel.Debug, vehicle.vehicle_uuid, `Vehicle no longer connected (connected_id=${was.connected_id})`);
           vehicle.connected_id = null;
           vehicle.charge_id = null;
         }
@@ -182,7 +204,7 @@ export class Logic {
             }
           }
 
-          log(LogLevel.Debug, `Updating charge ${charge.charge_id} with ${deltaAdded} Wm added`);
+          vehicleLog(LogLevel.Debug, vehicle.vehicle_uuid, `Updating charge ${charge.charge_id} with ${deltaAdded} Wm added`);
           await this.db.pg.none(
             `UPDATE connected SET ($1:name) = ($1:csv) WHERE connected_id=$2;`,
             [{
@@ -214,7 +236,7 @@ export class Logic {
                 const used = (avgPower * duration) / 60; // power (W) * time (s) = Ws / 60 = Wm
                 const added = energyAdded - chargeCurrent.start_added; // Wm
                 const avgTemp = arrayMean(chargeCurrent.outside_deci_temperatures); // deci-celsius
-                log(LogLevel.Debug, `Calculated charge curve between ${chargeCurrent.start_level}% and ${vehicle.level}% is ${(used / 60.0).toFixed(2)}kWh in ${(duration / 60.0).toFixed(2)}m`);
+                vehicleLog(LogLevel.Debug, vehicle.vehicle_uuid, `Calculated charge curve between ${chargeCurrent.start_level}% and ${vehicle.level}% is ${(used / 60.0).toFixed(2)}kWh in ${(duration / 60.0).toFixed(2)}m`);
                 await this.db.setChargeCurve(
                   vehicle.vehicle_uuid, charge.charge_id, chargeCurrent.start_level, duration, avgTemp, used, added);
               }
@@ -263,7 +285,7 @@ export class Logic {
             }
           )) as DBCharge;
           vehicle.charge_id = charge.charge_id;
-          log(LogLevel.Debug, `Started charge ${charge.charge_id}`);
+          vehicleLog(LogLevel.Debug, vehicle.vehicle_uuid, `Started charge ${charge.charge_id}`);
         }
       }
     }
@@ -275,7 +297,7 @@ export class Logic {
         `UPDATE charge SET start_used = COALESCE(start_used, $1), end_used = $1 WHERE charge_id=$2 RETURNING *;`,
         [energyUsed, vehicle.charge_id]
       );
-      log(LogLevel.Trace, `charge: ${JSON.stringify(new_charge)}`);
+      vehicleLog(LogLevel.Trace, vehicle.vehicle_uuid, `charge: ${JSON.stringify(new_charge)}`);
     }
 
     if (input.powerUse && vehicle.charge_id !== null) {
@@ -288,13 +310,13 @@ export class Logic {
         }
       );
       if (new_current) {
-        log(LogLevel.Trace, `charge_current: ${JSON.stringify(new_current)}`);
+        vehicleLog(LogLevel.Trace, vehicle.vehicle_uuid, `charge_current: ${JSON.stringify(new_current)}`);
       }
     }
 
     if (was.charge_id !== null && vehicle.charge_id === null) {
       // We stopped charging
-      log(LogLevel.Debug, `Ending charge ${was.charge_id}`);
+      vehicleLog(LogLevel.Debug, vehicle.vehicle_uuid, `Ending charge ${was.charge_id}`);
       await this.db.pg.none(`DELETE FROM charge_current WHERE charge_id=$1;`, [was.charge_id]);
     }
 
@@ -326,26 +348,29 @@ export class Logic {
             }
           )) as DBTrip;
           vehicle.trip_id = trip.trip_id;
-          log(LogLevel.Debug, `Started trip ${trip.trip_id}`);
+          vehicleLog(LogLevel.Debug, vehicle.vehicle_uuid, `Started trip ${trip.trip_id}`);
         }
       } else {
         const distance = vehicle.odometer - trip.start_odometer;
         const traveled = Math.round(distance - trip.distance);
         if (traveled > 0) {
-          if (trip.start_location_uuid !== null && trip.distance < 7e3 && distance >= 7e3) {
-            // We have left the starting known location on a real trip (crossing the 7 km threshold), clear any manual schedule
+          if (trip.start_location_uuid !== null
+            && trip.distance < MANUAL_SCHEDULE_DEPARTURE_THRESHOLD_M
+            && distance >= MANUAL_SCHEDULE_DEPARTURE_THRESHOLD_M) {
+            // Clear manual schedules once departure crosses the real-trip threshold.
             const removed = await this.db.pg.oneOrNone(
               `DELETE FROM schedule WHERE vehicle_uuid = $1 AND schedule_type = $2 RETURNING *;`,
               [vehicle.vehicle_uuid, ScheduleType.Manual]
             );
             if (removed) {
-              log(
+              vehicleLog(
                 LogLevel.Trace,
-                `Removed manual schedule for vehicle ${vehicle.vehicle_uuid} after leaving location ${trip.start_location_uuid} on trip ${trip.trip_id} (${distance}m)`
+                vehicle.vehicle_uuid,
+                `Removed manual schedule after leaving location ${trip.start_location_uuid} on trip ${trip.trip_id} (${distance}m)`
               );
             }
           }
-          log(LogLevel.Debug, `Updating trip ${vehicle.trip_id} with ${traveled}m driven`);
+          vehicleLog(LogLevel.Debug, vehicle.vehicle_uuid, `Updating trip ${vehicle.trip_id} with ${traveled}m driven`);
           trip = (await this.db.pg.one(
             `UPDATE trip SET ($1:name) = ($1:csv) WHERE trip_id=$2 RETURNING *;`,
             [{
@@ -360,19 +385,18 @@ export class Logic {
           let stopTrip = false;
           if (vehicle.location_uuid !== null) {
             // We stopped driving at a location we know
-            log(LogLevel.Debug,
-              `Vehicle at location ${vehicle.location_uuid} after driving ${trip.distance / 1e3} km, ending trip ${trip.trip_id}`
+            vehicleLog(LogLevel.Debug, vehicle.vehicle_uuid, `Vehicle at location ${vehicle.location_uuid} after driving ${trip.distance / 1e3} km, ending trip ${trip.trip_id}`
             );
             stopTrip = true;
             if (trip.distance < 1e3) {
               // totally ignore trips less than 1 km
-              log(LogLevel.Debug, `Removing trip ${trip.trip_id}, because it only recorded ${trip.distance} meters`);
+              vehicleLog(LogLevel.Debug, vehicle.vehicle_uuid, `Removing trip ${trip.trip_id}, because it only recorded ${trip.distance} meters`);
               await this.db.pg.none(`DELETE FROM trip WHERE trip_id=$1;`, [
                 vehicle.trip_id,
               ]);
             }
           } else if (vehicle.connected) {
-            log(LogLevel.Debug, `Vehicle connected after driving ${trip.distance / 1e3} km, ending trip ${trip.trip_id}`);
+            vehicleLog(LogLevel.Debug, vehicle.vehicle_uuid, `Vehicle connected after driving ${trip.distance / 1e3} km, ending trip ${trip.trip_id}`);
             stopTrip = true;
           }
           if (stopTrip) {
@@ -380,7 +404,7 @@ export class Logic {
             doPricePlan = true;
           }
         }
-        log(LogLevel.Trace, `trip: ${JSON.stringify(trip)}`);
+        vehicleLog(LogLevel.Trace, vehicle.vehicle_uuid, `trip: ${JSON.stringify(trip)}`);
       }
     }
 
@@ -647,7 +671,7 @@ export class Logic {
         if (lvl > minimum_charge + needavg && f < bestCost * 0.95) {
           bestCost = f;
           threshold = t;
-          log(LogLevel.Debug, `Cost simulation ${vehicle.vehicle_uuid} t=${t} => ${f}`);
+          vehicleLog(LogLevel.Debug, vehicle.vehicle_uuid, `Cost simulation ${vehicle.vehicle_uuid} t=${t} => ${f}`);
         }
       }
     }
@@ -680,23 +704,13 @@ export class Logic {
   }
 
   private static cleanupPlan(plan: ChargePlan[]): ChargePlan[] {
-    const chargePrio = {
-      [ChargeType.Disable]: 0,
-      [ChargeType.Calibrate]: 1,
-      [ChargeType.Minimum]: 2,
-      [ChargeType.Manual]: 3,
-      [ChargeType.Trip]: 4,
-      [ChargeType.Routine]: 5,
-      [ChargeType.Prefered]: 6,
-      [ChargeType.Fill]: 7,
-    };
     plan.sort((a, b) =>
       compareStartStopTimes(
         a.chargeStart,
         a.chargeStop,
         b.chargeStart,
         b.chargeStop
-      ) || chargePrio[a.chargeType] - chargePrio[b.chargeType]
+      ) || CHARGE_PRIO[a.chargeType] - CHARGE_PRIO[b.chargeType]
     );
 
     function consolidate() {
@@ -840,7 +854,7 @@ export class Logic {
 
     if (!guess || !guess.before || !guess.charge) {
       // missing data to guess
-      log(LogLevel.Debug, `Missing data for smart charging.`);
+      vehicleLog(LogLevel.Debug, vehicle.vehicle_uuid, `Missing data for smart charging.`);
       return null;
     } else {
       const minimumLevel = Math.min(
@@ -853,28 +867,31 @@ export class Logic {
   }
 
   private async refreshVehicleChargePlan(vehicle: DBVehicle) {
-    log(LogLevel.Trace, `vehicle: ${JSON.stringify(vehicle)}`);
+    vehicleLog(LogLevel.Trace, vehicle.vehicle_uuid, `vehicle: ${JSON.stringify(vehicle)}`);
 
     let location_uuid = vehicle.location_uuid;
     if (location_uuid === null) {
       if (vehicle.connected) {
         // We are connected, but not at a known location
-        log(LogLevel.Debug, `Vehicle connected at unknown location`);
+        vehicleLog(LogLevel.Debug, vehicle.vehicle_uuid, `Vehicle connected at unknown location`);
       } else if (vehicle.location_micro_latitude && vehicle.location_micro_longitude) {
         const closest = await this.db.lookupClosestLocation(vehicle.account_uuid, vehicle.location_micro_latitude, vehicle.location_micro_longitude);
         if (closest) {
           location_uuid = closest.location.location_uuid;
-          log(LogLevel.Debug, `Vehicle at unknown location, closest known location is ${location_uuid} (${closest.distance}m)`);
+          vehicleLog(LogLevel.Debug, vehicle.vehicle_uuid, `Vehicle at unknown location, closest known location is ${location_uuid} (${closest.distance}m)`);
         }
       }
     }
 
     const now = Date.now();
+    const planningHorizonEnd = now + PRICE_PLAN_LOOKAHEAD_MS;
 
     // TODO: Check current vehicle.charge_plan and see if it needs to be recalculated?
 
     const locationSettings = this.getVehicleLocationSettings(vehicle, location_uuid);
     const minimum_charge = locationSettings.directLevel;
+    const splitCharge = locationSettings.splitCharge || SplitCharge.Auto;
+    const prevPlan = Array.isArray(vehicle.charge_plan) ? vehicle.charge_plan : null;
 
     // Cleanup schedule remove all entries 1 hour after the end time
     const schedule: DBSchedule[] = await this.db.pg.manyOrNone(
@@ -893,13 +910,15 @@ export class Logic {
     const manual = scheduleMap[ScheduleType.Manual];
     const trip = scheduleMap[ScheduleType.Trip];
 
-    const startLevel = vehicle.level - 1;
+    let startLevel = vehicle.level - 1;
+    const initialLevel = startLevel;
 
     let chargePlan: ChargePlan[] = [];
     let smartStatus = "";
+    let splitInfo = "";
 
     if (manual && !manual.level) {
-      log(LogLevel.Debug, `Charging disabled until next connection`);
+      vehicleLog(LogLevel.Debug, vehicle.vehicle_uuid, `Charging disabled until next connection`);
       chargePlan.push({
         chargeStart: null,
         chargeStop: null,
@@ -909,24 +928,37 @@ export class Logic {
       });
       smartStatus = `Charging disabled until next plug in`;
     } else {
-      const price_data: { ts: Date; price: number }[] = (location_uuid && (await this.db.pg.manyOrNone(
-        `SELECT ts, price FROM price_data p JOIN location l ON (l.price_list_uuid = p.price_list_uuid) WHERE location_uuid = $1 AND ts >= NOW() - interval '1 hour' ORDER BY ts`,
-        [location_uuid]
+      type PriceSlot = Readonly<{ from: number; to: number; price: number }>;
+
+      // TODO: user configurable per site or vehicle? Schedule splitting: "none/min/max"
+      // none = hard cap maxSegments to 1, min = only split if it saves cost, max = always split up to maxSegments
+      // Hard cap: drop any slot above (maxPrice * SOFT_MAXPRICE_CAP_FACTOR).
+      const SOFT_MAXPRICE_CAP_FACTOR = 1.5;
+      // Price values in DB are stored as integer(price * 1e5) to keep precision.
+      const DB_PRICE_SCALE = 1e5;
+      const ACTIVE_CHARGE_STICKY_MS = 10 * 60e3;
+      const fmtDbPrice = (p: number): string => (p / DB_PRICE_SCALE).toFixed(5);
+      const priceDataStart = new Date(now - PRICE_DATA_LOOKBACK_MS);
+      const priceDataEnd = new Date(planningHorizonEnd + PRICE_DATA_PADDING_MS);
+      const price_data: { ts: Date; price: number }[] = ( location_uuid && (await this.db.pg.manyOrNone(
+        `SELECT ts, price FROM price_data p JOIN location l ON (l.price_list_uuid = p.price_list_uuid)
+        WHERE location_uuid = $1 AND ts >= $2 AND ts < $3
+        ORDER BY ts`,
+        [location_uuid, priceDataStart, priceDataEnd]
       ))) || [];
       let duration = 60 * 60e3; // default 1 hour
       let priceAvailable = 0;
-      const priceMap: { ts: number; duration: number; price: number }[] = price_data.map((e, i) => {
-        const start = e.ts.getTime();
+      const priceSlots: ReadonlyArray<PriceSlot> = price_data.map((e, i): PriceSlot => {
+        const from = e.ts.getTime();
         if (i < price_data.length - 1) {
           duration = price_data[i + 1].ts.getTime() - e.ts.getTime();
         }
-        const end = start + duration;
-        if (end > priceAvailable) {
-          priceAvailable = end;
+        const to = from + duration;
+        if (from < planningHorizonEnd) {
+          priceAvailable = Math.max(priceAvailable, Math.min(to, planningHorizonEnd));
         }
-        return { ts: start, duration: duration, price: e.price };
-      }).sort((a, b) => a.price - b.price);
-      // @codex: is this sorted correctly by cheapest price first?
+        return { from, to, price: e.price };
+      });
 
       const chargeCurve = await this.db.getChargeCurve(vehicle.vehicle_uuid, location_uuid);
       const ChargeDuration = (from: number, to: number): number => {
@@ -936,45 +968,23 @@ export class Logic {
         }
         return sum * 1e3;
       };
-      let fillBefore: number = priceAvailable;
-
-      const GeneratePlan = (chargeType: ChargeType, comment: string, level: number, before_ts?: number, maxPrice?: number): boolean => {
-        // Adjust before_ts if it's passed already
-        before_ts = (before_ts || 0) <= now ? undefined : before_ts;
-
-        // Only adjust if it's earlier than 6h before the one we alread had in mind
-        if (before_ts && before_ts < priceAvailable && (fillBefore === priceAvailable || before_ts + 360 * 60e3 < fillBefore)) {
-          fillBefore = before_ts;
-        }
-
-        // Do charge goal adjustments
-        if (level > startLevel && before_ts !== undefined) {
-          // Do we need to split and do a partial charge for future target
-          if (priceAvailable && before_ts > priceAvailable) {
-            const timeNeeded = ChargeDuration(startLevel, level);
-            const startDeadline = before_ts - timeNeeded * 1.5;
-            log(LogLevel.Trace, `${capitalize(chargeType)} charge time ${Math.round(timeNeeded / 60e3)} min, deadline ${new Date(startDeadline).toISOString()}`);
-            if (startDeadline > priceAvailable) {
-              log(LogLevel.Trace, `deadline beyond price data, ignore charge`);
-              return false;
-            } else {
-              before_ts = priceAvailable;
-              level = Math.floor(
-                startLevel +
-                ((level - startLevel) * (priceAvailable - startDeadline)) /
-                (timeNeeded * 1.5)
-              );
-              log(LogLevel.Debug, `${capitalize(chargeType)} partial charge to ${level}% before ${new Date(before_ts).toISOString()}`);
-            }
-          }
-
-          // Do we need to topup charge above maximum
-          if (level > vehicle.maximum_charge) {
-            const topupTime = ChargeDuration(Math.max(startLevel, vehicle.maximum_charge), level);
-            const topupStart = before_ts - SCHEDULE_TOPUP_MARGIN - topupTime;
-            log(LogLevel.Debug,
-              `${capitalize(chargeType)} topup charge from ${vehicle.maximum_charge}% to ${level}% start at ${new Date(topupStart).toISOString()}`
-            );
+      let hardStart = now;
+      let hardEnd = Number.POSITIVE_INFINITY;
+      type SoftIntent = {
+        chargeType: ChargeType;
+        comment: string;
+        level: number;
+        requestedLevel: number;
+        beforeTs?: number;
+      };
+      const softIntents: SoftIntent[] = [];
+      let fillMaxPrice: number | null = null;
+      const addSoftIntent = (chargeType: ChargeType, comment: string, level: number, beforeTs?: number) => {
+        const requestedLevel = level;
+        if (level > vehicle.maximum_charge) {
+          if (beforeTs !== undefined) {
+            const topupTime = ChargeDuration(vehicle.maximum_charge, level);
+            const topupStart = beforeTs - SCHEDULE_TOPUP_MARGIN - topupTime;
             chargePlan.push({
               chargeStart: new Date(topupStart),
               chargeStop: null,
@@ -982,81 +992,612 @@ export class Logic {
               chargeType,
               comment: `topping up`,
             });
-
-            // Adjust charge target to exclude topup range
-            before_ts = topupStart;
-            level = vehicle.maximum_charge;
+            hardEnd = Math.min(hardEnd, topupStart);
           }
+          level = vehicle.maximum_charge;
         }
-
-        if (level > startLevel) {
-          const timeNeeded = ChargeDuration(startLevel, level);
-          assert(timeNeeded > 0);
-
-          if (priceAvailable && before_ts !== undefined) {
-            log(LogLevel.Trace, `${capitalize(chargeType)} charge to ${level}% before ${new Date(before_ts).toISOString()}`);
-
-            // Map priceMap prices to a list of hours to charge
-            let timeLeft = timeNeeded;
-            for (const price of priceMap) {
-              if (timeLeft < 1) break; // Done
-              if (maxPrice && price.price > maxPrice) break; // Prices too high
-
-              if (price.ts > before_ts) continue; // price beyond our target time
-
-              // Duration takes timeLeft, "now" and "before_ts" into account to be accurate
-              const duration = Math.min(Math.min(price.ts + price.duration, before_ts) - Math.max(price.ts, now), timeLeft);
-              if (duration < 1) continue; // no time here
-              chargePlan.push({
-                chargeStart: new Date(price.ts),
-                chargeStop: new Date(price.ts + price.duration),
-                level,
-                chargeType,
-                comment,
-              });
-              timeLeft -= duration;
-              log(LogLevel.Trace, `charge ${duration / 1e3}s ${JSON.stringify(price)} => ${timeLeft / 1e3}s left`);
+        softIntents.push({ chargeType, comment, level, requestedLevel, beforeTs });
+      };
+      const addUpcomingSoftIntent = (chargeType: ChargeType, comment: string, level: number, beforeTs: number) => {
+        const cappedLevel = Math.min(level, vehicle.maximum_charge);
+        const alreadyPlannedLevel = softIntents.reduce((max, intent) => Math.max(max, intent.level), startLevel);
+        const topupTime = level > vehicle.maximum_charge
+          ? ChargeDuration(vehicle.maximum_charge, level) + SCHEDULE_TOPUP_MARGIN
+          : 0;
+        const priceDeadline = beforeTs - topupTime;
+        const earliestChargeStart = priceDeadline - ChargeDuration(alreadyPlannedLevel, cappedLevel);
+        if (earliestChargeStart > planningHorizonEnd) {
+          vehicleLog(
+            LogLevel.Trace,
+            vehicle.vehicle_uuid,
+            `Deferring ${chargeType} intent at ${new Date(beforeTs).toISOString()} until it needs charging inside planning horizon ${new Date(planningHorizonEnd).toISOString()}`
+          );
+          return;
+        }
+        addSoftIntent(chargeType, comment, level, beforeTs);
+      };
+      const sortSoftIntents = (intents: SoftIntent[]): SoftIntent[] => {
+        return intents.slice().sort((a, b) => CHARGE_PRIO[a.chargeType] - CHARGE_PRIO[b.chargeType]);
+      };
+      const fillIntent = (level: number): SoftIntent => ({
+        chargeType: ChargeType.Fill,
+        comment: `low price`,
+        level,
+        requestedLevel: level
+      });
+      const isActiveCharge = (): boolean => vehicle.connected && Boolean(vehicle.charging_to) && hardStart <= now;
+      type Allocation = {
+        durationMs: number;
+        chargeType: ChargeType;
+        comment: string;
+        level: number;
+        requestedLevel: number;
+      };
+      const buildAllocations = (baseLevel: number, intents: SoftIntent[]) => {
+        const ordered = sortSoftIntents(intents);
+        let prevNeeded = 0;
+        const out: Allocation[] = [];
+        for (const intent of ordered) {
+          const needed = ChargeDuration(baseLevel, intent.level);
+          const durationMs = Math.max(0, needed - prevNeeded);
+          if (durationMs > 0) {
+            out.push({
+              durationMs,
+              chargeType: intent.chargeType,
+              comment: intent.comment,
+              level: intent.level,
+              requestedLevel: intent.requestedLevel
+            });
+            prevNeeded = needed;
+          }
+        }
+        return out;
+      };
+      const applyWindows = (
+        windows: Array<{ start: number; stop: number }>,
+        allocations: Array<{ durationMs: number; chargeType: ChargeType; comment: string; level: number; requestedLevel: number }>
+      ) => {
+        const planStartIndex = chargePlan.length;
+        const sorted = windows.slice().sort((a, b) => a.start - b.start);
+        let i = 0;
+        let remaining = allocations.length > 0 ? allocations[0].durationMs : 0;
+        let lastAppliedIndex = -1;
+        for (const w of sorted) {
+          let cursor = w.start;
+          let windowLeft = w.stop - w.start;
+          while (windowLeft > 0 && i < allocations.length) {
+            const a = allocations[i];
+            const take = Math.min(windowLeft, remaining);
+            chargePlan.push({
+              chargeStart: new Date(cursor),
+              chargeStop: new Date(cursor + take),
+              level: a.level,
+              chargeType: a.chargeType,
+              comment: a.comment,
+            });
+            lastAppliedIndex = chargePlan.length - 1;
+            cursor += take;
+            windowLeft -= take;
+            remaining -= take;
+            if (remaining <= 0) {
+              i++;
+              remaining = i < allocations.length ? allocations[i].durationMs : 0;
             }
+          }
+          if (windowLeft > 0 && lastAppliedIndex >= 0) {
+            // Scheduling follows tariff fidelity. If the optimizer selected a full tariff
+            // interval, keep the final interval intact even when the estimated target would
+            // otherwise end inside it.
+            chargePlan[lastAppliedIndex].chargeStop = new Date(chargePlan[lastAppliedIndex].chargeStop!.getTime() + windowLeft);
+          }
+        }
+        let lastStop = hardStart;
+        for (let j = planStartIndex; j < chargePlan.length; j++) {
+          const stop = chargePlan[j].chargeStop?.getTime();
+          if (stop !== undefined && stop > lastStop) lastStop = stop;
+        }
+        return lastStop;
+      };
+      const planFillWindows = (fromLevel: number, toLevel: number, deadline: number) => {
+        if (fillMaxPrice === null) return { windows: [], scheduledMs: 0 };
+        return planWindows(
+          ChargeDuration(fromLevel, toLevel),
+          deadline,
+          fillMaxPrice,
+          `fill:${toLevel}`,
+          isActiveCharge()
+        );
+      };
+      const scheduleSoftIntents = () => {
+        if (softIntents.length === 0 && fillMaxPrice === null) return;
+        const scheduledIntents = softIntents
+          .filter((i) => i.beforeTs !== undefined)
+          .sort((a, b) => numericStartTime(a.beforeTs) - numericStartTime(b.beforeTs));
+        if (scheduledIntents.length === 0) {
+          if (fillMaxPrice === null || startLevel >= vehicle.maximum_charge || priceAvailable < hardStart) return;
+          const fillWindows = planFillWindows(startLevel, vehicle.maximum_charge, priceAvailable);
+          if (fillWindows.windows.length > 0 && fillWindows.scheduledMs > 0) {
+            hardStart = applyWindows(fillWindows.windows, buildAllocations(startLevel, [fillIntent(vehicle.maximum_charge)]));
+          }
+          return;
+        }
+
+        let plannedLevel = startLevel;
+        const deadlines = [...new Set(scheduledIntents.map((i) => i.beforeTs!))];
+        for (const deadline of deadlines) {
+          const cohortIntents = scheduledIntents.filter((i) => i.beforeTs! <= deadline);
+          let cohortMaxLevel = plannedLevel;
+          for (const intent of cohortIntents) {
+            if (intent.level > cohortMaxLevel) cohortMaxLevel = intent.level;
+          }
+          const timeNeeded = cohortMaxLevel > plannedLevel ? ChargeDuration(plannedLevel, cohortMaxLevel) : 0;
+          if (timeNeeded <= 0) continue;
+          if (isActiveCharge() && timeNeeded <= ACTIVE_CHARGE_STICKY_MS) {
+            hardStart = applyWindows(
+              [{ start: hardStart, stop: hardStart + timeNeeded }],
+              buildAllocations(plannedLevel, cohortIntents)
+            );
+            vehicleLog(
+              LogLevel.Debug,
+              vehicle.vehicle_uuid,
+              `Keeping active charge sticky for the final ${Math.round(timeNeeded / 60e3)} minutes instead of rescheduling`
+            );
+            plannedLevel = cohortMaxLevel;
+            continue;
+          }
 
-            smartStatus = smartStatus || `${capitalize(chargeType)} charge to ${level}% scheduled`;
+          if (deadline >= hardStart) {
+            // Try to fully charge with cheap energy first
+            const max = vehicle.maximum_charge;
+            const fillWindows = planFillWindows(plannedLevel, max, deadline);
+            if (fillWindows.windows.length > 0 && fillWindows.scheduledMs >= timeNeeded) {
+              hardStart = applyWindows(fillWindows.windows, buildAllocations(plannedLevel, [
+                ...cohortIntents,
+                fillIntent(max)
+              ]));
+            } else {
+              const plan = planWindows(timeNeeded, deadline, undefined, `intent:${cohortMaxLevel}`, isActiveCharge());
+              hardStart = applyWindows(plan.windows, buildAllocations(plannedLevel, cohortIntents));
+            }
           } else {
-            log(LogLevel.Debug, `${capitalize(chargeType)} charge directly to ${level}%`);
+            // No price data or deadline: charge directly to the max soft intent level.
+            const topIntent = sortSoftIntents(cohortIntents)[0];
+            assert(topIntent);
             chargePlan.push({
               chargeStart: null,
-              chargeStop: new Date(Date.now() + timeNeeded),
-              chargeType,
-              level,
-              comment,
+              chargeStop: new Date(now + timeNeeded),
+              chargeType: topIntent.chargeType,
+              level: cohortMaxLevel,
+              comment: topIntent.comment,
             });
-            smartStatus = smartStatus || `${capitalize(chargeType)} charge directly to ${level}%`;
+            hardStart = now + timeNeeded;
           }
+          plannedLevel = cohortMaxLevel;
+        }
+      };
 
-          return true;
-        } else {
-          log(LogLevel.Debug, `${level} <= ${startLevel}, no ${chargeType} charge plan added for ${comment}`);
-          return false;
+      // Warmup penalty: extra effective charging time required after restarting a stopped charge.
+      const disallowGaps = splitCharge === SplitCharge.Never;
+      let warmupPenaltyMs : number | undefined;
+      if (splitCharge === SplitCharge.Always) {
+        warmupPenaltyMs = 0;
+      } else if (splitCharge === SplitCharge.Auto) {
+        if (location_uuid) {
+          // Estimate a warmup penalty based on the lowest observed temperature during charging at this location
+          const minTemp = await this.db.pg.oneOrNone(
+            `SELECT MIN(cc.outside_deci_temperature) AS min_temp
+            FROM charge_curve cc
+            JOIN charge c ON c.charge_id = cc.charge_id
+            WHERE c.location_uuid = $1
+              AND c.start_ts >= NOW() - interval '6 weeks';`,
+            [location_uuid]
+          );
+          if (minTemp && minTemp.min_temp !== null) {
+            const temp = minTemp.min_temp / 10;
+            // Cubic fit through (-20,60), (-10,30), (0,15), (10,0) with clamp to [0,60].
+            const rawMinutes = (-1 / 400) * temp ** 3 + (-5 / 4) * temp + 15;
+            const warmupMinutes = Math.min(60, Math.max(0, rawMinutes));
+            warmupPenaltyMs = Math.round(warmupMinutes * 60e3);
+            splitInfo = ` at ${temp.toFixed(1)}°C`;
+          }
+        }
+        if (warmupPenaltyMs === undefined) {
+          warmupPenaltyMs = 10 * 60 * 1000;
+          splitInfo = ` (default)`;
+        }
+        splitInfo = ` warmupPenalty=${Math.round(warmupPenaltyMs / 60e3)}min${splitInfo}`;
+      }
+      splitInfo = `; splitCharge=${splitCharge}${splitInfo}`;
+      vehicleLog(LogLevel.Debug, vehicle.vehicle_uuid, `Estimated warmup penalty${splitInfo}`);
+
+      /**
+       * Scheduling specification
+       *
+       * The planner works on whole tariff intervals only. Each candidate interval is the raw price
+       * interval clipped to the active planning window [hardStart, min(beforeTimestampMs, hardEnd)).
+       * The optimizer never invents finer precision than the tariff feed provides and never trims a
+       * selected interval internally. If a 30-minute interval is selected, the plan keeps the full
+       * 30 minutes. This intentionally favors tariff fidelity over exact target timestamps.
+       *
+       * Optimization model
+       *
+       * 1. Build an ordered list of candidate tariff intervals.
+       * 2. Walk the list from left to right and, for every interval, decide whether to take it or skip it.
+       * 3. Track an explicit charger phase at the start of each interval:
+       *    - idle:     no charging has been scheduled yet.
+       *    - charging: charging is active at the interval start and can continue without a restart.
+       *    - stopped:  charging has been stopped earlier, so taking a later interval is a restart.
+       * 4. A restart is allowed according to split mode:
+       *    - never:  restart is forbidden after charging stops, so at most one contiguous window.
+       *    - auto:   restart is allowed and pays a warmup penalty.
+       *    - always: restart is allowed with zero penalty.
+       * 5. The warmup penalty is modeled as lost effective charging time after a restart. When a
+       *    stopped plan restarts, it accrues warmupDebtMs. Selected intervals first pay down that
+       *    debt, and only the remaining time in those intervals counts as delivered charging.
+       *    If the vehicle is already charging and the first candidate interval starts later than
+       *    hardStart, the initial state is treated as stopped so a later take incurs warmup debt.
+       *
+       * maxPrice semantics
+       *
+       * - Intervals above maxPrice * SOFT_MAXPRICE_CAP_FACTOR are dropped entirely.
+       * - For the remaining intervals, the optimizer minimizes actual energy cost.
+       * - A finished plan is feasible only if its average raw interval price is <= maxPrice:
+       *     totalChargeCost <= maxPrice * totalScheduledDuration
+       * - If no full-duration feasible plan exists, best effort means "schedule the longest feasible
+       *   duration" rather than returning an invalid over-average plan.
+       *
+       * Objective and tie-breaks
+       *
+       * - Primary:   maximize delivered charging duration up to the requested target.
+       * - Secondary: minimize total energy cost of the selected tariff intervals.
+       * - Tertiary:  minimize number of charging windows.
+       * - Last:      prefer an earlier first charging start.
+       *
+       * Reconstruction
+       *
+       * Chosen intervals are merged back into contiguous windows after optimization. The rest of the
+       * system still consumes { start, stop } windows, so the refactor stays behind the existing
+       * planWindows() interface.
+       */
+      const planWindows = (
+        timeNeededMs: number,
+        beforeTimestampMs: number,
+        maxPrice: number | undefined,
+        scheduleTag: string,
+        isCharging: boolean
+      ): { windows: { start: number; stop: number }[]; scheduledMs: number } => {
+        type AtomicStep = Readonly<{ start: number; stop: number; duration: number; price: number; chargeCostMs: number }>;
+        type PlanPhase = "idle" | "charging" | "stopped";
+        type PlanAction = "seed" | "skip" | "take";
+        type PlanNode = Readonly<{
+          prev: number | null;
+          action: PlanAction;
+          stepIndex: number | null;
+          phase: PlanPhase;
+          deliveredMs: number;
+          scheduledMs: number;
+          warmupDebtMs: number;
+          chargeCostMs: number;
+          windows: number;
+          firstStartMs?: number;
+        }>;
+
+        const scheduled = { windows: [] as { start: number; stop: number }[], scheduledMs: 0 };
+        const hardCapPrice = maxPrice === undefined ? undefined : maxPrice * SOFT_MAXPRICE_CAP_FACTOR;
+        const atomicSteps: ReadonlyArray<AtomicStep> = priceSlots
+          .flatMap((slot: PriceSlot): AtomicStep[] => {
+            const start = Math.max(slot.from, hardStart);
+            const stop = Math.min(slot.to, beforeTimestampMs, hardEnd);
+            if (stop <= start) return [];
+            if (hardCapPrice !== undefined && slot.price > hardCapPrice) return [];
+            const duration = stop - start;
+            return [{ start, stop, duration, price: slot.price, chargeCostMs: slot.price * duration }];
+          })
+          .sort((a, b) => a.start - b.start);
+
+        if (atomicSteps.length === 0) {
+          vehicleLog(LogLevel.Trace, vehicle.vehicle_uuid, `scheduleWindows(${scheduleTag}): no segments (no price data?)`);
+          return scheduled;
+        }
+        let totalAvailableMs = 0;
+        let minIntervalMs = Number.POSITIVE_INFINITY;
+        for (const step of atomicSteps) {
+          totalAvailableMs += step.duration;
+          if (step.duration < minIntervalMs) minIntervalMs = step.duration;
+        }
+
+        const targetMaxMs = Math.max(0, Math.min(timeNeededMs, totalAvailableMs));
+        if (targetMaxMs < 1) {
+          vehicleLog(LogLevel.Trace, vehicle.vehicle_uuid, `scheduleWindows(${scheduleTag}): nothing to schedule (need=${Math.round(timeNeededMs / 60e3)}min avail=${Math.round(totalAvailableMs / 60e3)}min)`);
+          return scheduled;
         }
+        vehicleLog(
+          LogLevel.Trace,
+          vehicle.vehicle_uuid,
+          `scheduleWindows(${scheduleTag}): need=${Math.round(timeNeededMs / 60e3)}min targetMax=${Math.round(targetMaxMs / 60e3)}min before=${new Date(beforeTimestampMs).toISOString()} ` +
+          `intervals=${atomicSteps.length} avail=${Math.round(totalAvailableMs / 60e3)}min minQuantum=${Math.round(minIntervalMs / 60e3)}min ` +
+          `maxPrice=${maxPrice === undefined ? "none" : fmtDbPrice(maxPrice)} capFactor=${SOFT_MAXPRICE_CAP_FACTOR}`
+        );
+        vehicleLog(
+          LogLevel.Trace,
+          vehicle.vehicle_uuid,
+          `scheduleWindows(${scheduleTag}): intervalPreview=${atomicSteps.slice(0, 8).map((step) =>
+            `${new Date(step.start).toISOString()}..${new Date(step.stop).toISOString()}@${fmtDbPrice(step.price)}`
+          ).join(", ")}${atomicSteps.length > 8 ? ", ..." : ""}`
+        );
+
+        const phases: ReadonlyArray<PlanPhase> = ["idle", "charging", "stopped"];
+        const makePhaseMaps = (): Record<PlanPhase, Map<string, number[]>> => ({
+          idle: new Map<string, number[]>(),
+          charging: new Map<string, number[]>(),
+          stopped: new Map<string, number[]>(),
+        });
+        const nodes: PlanNode[] = [];
+        const firstStartForRanking = (node: PlanNode): number => node.firstStartMs ?? Number.POSITIVE_INFINITY;
+        let nodesRecorded = 0;
+        let nodesPrunedDominated = 0;
+        let nodesPrunedReplaced = 0;
+        const dominatesForContinuation = (left: PlanNode, right: PlanNode): boolean => {
+          assert(left.phase === right.phase);
+          assert(left.deliveredMs === right.deliveredMs);
+          assert(left.warmupDebtMs === right.warmupDebtMs);
+          const leftStart = firstStartForRanking(left);
+          const rightStart = firstStartForRanking(right);
+          return left.chargeCostMs <= right.chargeCostMs
+            && left.scheduledMs >= right.scheduledMs
+            && left.windows <= right.windows
+            && leftStart <= rightStart
+            && (
+              left.chargeCostMs < right.chargeCostMs
+              || left.scheduledMs > right.scheduledMs
+              || left.windows < right.windows
+              || leftStart < rightStart
+            );
+        };
+        const compareFinalNodes = (left: PlanNode, right: PlanNode): number => {
+          const leftDelivered = Math.min(left.deliveredMs, targetMaxMs);
+          const rightDelivered = Math.min(right.deliveredMs, targetMaxMs);
+          if (leftDelivered !== rightDelivered) return leftDelivered - rightDelivered;
+          if (left.chargeCostMs !== right.chargeCostMs) return right.chargeCostMs - left.chargeCostMs;
+          if (left.windows !== right.windows) return right.windows - left.windows;
+          return firstStartForRanking(right) - firstStartForRanking(left);
+        };
+        const recordNode = (
+          states: Record<PlanPhase, Map<string, number[]>>,
+          node: PlanNode
+        ) => {
+          const stateMap = states[node.phase];
+          assert(node.warmupDebtMs >= 0);
+          if (node.phase !== "charging") {
+            assert(node.warmupDebtMs === 0);
+          }
+          const stateKey = `${node.deliveredMs}:${node.warmupDebtMs}`;
+          const existingIndices = stateMap.get(stateKey) || [];
+          if (existingIndices.some((index) => dominatesForContinuation(nodes[index], node))) {
+            nodesPrunedDominated++;
+            return;
+          }
+          nodes.push(node);
+          nodesRecorded++;
+          const nodeIndex = nodes.length - 1;
+          const survivorIndices = existingIndices.filter((index) => !dominatesForContinuation(node, nodes[index]));
+          nodesPrunedReplaced += existingIndices.length - survivorIndices.length;
+          stateMap.set(stateKey, survivorIndices.concat(nodeIndex));
+        };
+        const countFrontierNodes = (states: Record<PlanPhase, Map<string, number[]>>): number => {
+          let count = 0;
+          for (const phase of phases) {
+            for (const stateIndices of states[phase].values()) count += stateIndices.length;
+          }
+          return count;
+        };
+        const frontierSummary = (states: Record<PlanPhase, Map<string, number[]>>): string => {
+          return phases.map((phase) => {
+            const buckets = states[phase].size;
+            let statesCount = 0;
+            for (const stateIndices of states[phase].values()) statesCount += stateIndices.length;
+            return `${phase}:buckets=${buckets},states=${statesCount}`;
+          }).join(" ");
+        };
+
+        const initialPhase: PlanPhase = isCharging
+          ? atomicSteps[0].start === hardStart ? "charging" : "stopped"
+          : "idle";
+        let states = makePhaseMaps();
+        recordNode(states, {
+          prev: null,
+          action: "seed",
+          stepIndex: null,
+          phase: initialPhase,
+          deliveredMs: 0,
+          scheduledMs: 0,
+          warmupDebtMs: 0,
+          chargeCostMs: 0,
+          windows: 0,
+        });
+        vehicleLog(
+          LogLevel.Trace,
+          vehicle.vehicle_uuid,
+          `scheduleWindows(${scheduleTag}): seed phase=${initialPhase} frontier=${frontierSummary(states)}`
+        );
+
+        for (let stepIndex = 0; stepIndex < atomicSteps.length; stepIndex++) {
+          const step = atomicSteps[stepIndex];
+          const nextStates = makePhaseMaps();
+          for (const phase of phases) {
+            for (const stateIndices of states[phase].values()) {
+              for (const stateIndex of stateIndices) {
+                const state = nodes[stateIndex];
+                assert(state);
+                const skipPhase: PlanPhase = phase === "charging" ? "stopped" : phase;
+                recordNode(nextStates, {
+                  prev: stateIndex,
+                  action: "skip",
+                  stepIndex,
+                  phase: skipPhase,
+                  deliveredMs: state.deliveredMs,
+                  scheduledMs: state.scheduledMs,
+                  warmupDebtMs: 0,
+                  chargeCostMs: state.chargeCostMs,
+                  windows: state.windows,
+                  firstStartMs: state.firstStartMs,
+                });
+
+                if (state.deliveredMs >= targetMaxMs) continue;
+                const restart = phase === "stopped";
+                if (restart && disallowGaps) continue;
+                const startsNewWindow = state.scheduledMs === 0 || phase !== "charging";
+                const warmupDebtMs = restart ? (warmupPenaltyMs ?? 0) : state.warmupDebtMs;
+                const consumedWarmupMs = Math.min(step.duration, warmupDebtMs);
+                const deliveredIncrementMs = step.duration - consumedWarmupMs;
+                const remainingWarmupDebtMs = warmupDebtMs - consumedWarmupMs;
+                const nextPhase: PlanPhase = stepIndex + 1 < atomicSteps.length && atomicSteps[stepIndex + 1].start === step.stop
+                  ? "charging"
+                  : "stopped";
+                recordNode(nextStates, {
+                  prev: stateIndex,
+                  action: "take",
+                  stepIndex,
+                  phase: nextPhase,
+                  deliveredMs: state.deliveredMs + deliveredIncrementMs,
+                  scheduledMs: state.scheduledMs + step.duration,
+                  warmupDebtMs: nextPhase === "charging" ? remainingWarmupDebtMs : 0,
+                  chargeCostMs: state.chargeCostMs + step.chargeCostMs,
+                  windows: state.windows + (startsNewWindow ? 1 : 0),
+                  firstStartMs: state.firstStartMs ?? step.start,
+                });
+              }
+            }
+          }
+          vehicleLog(
+            LogLevel.Trace,
+            vehicle.vehicle_uuid,
+            `scheduleWindows(${scheduleTag}): after step=${stepIndex + 1}/${atomicSteps.length} ` +
+            `${new Date(step.start).toISOString()}..${new Date(step.stop).toISOString()}@${fmtDbPrice(step.price)} ` +
+            `frontier=${frontierSummary(nextStates)} total=${countFrontierNodes(nextStates)} nodesRecorded=${nodesRecorded} ` +
+            `prunedDominated=${nodesPrunedDominated} prunedReplaced=${nodesPrunedReplaced}`
+          );
+          states = nextStates;
+        }
+
+        const isFeasibleAverage = (node: PlanNode): boolean => {
+          return maxPrice === undefined
+            || node.scheduledMs === 0
+            || node.chargeCostMs <= maxPrice * node.scheduledMs;
+        };
+
+        let bestIndex: number | undefined;
+        let feasibleFinalStates = 0;
+        for (const phase of phases) {
+          for (const stateIndices of states[phase].values()) {
+            for (const stateIndex of stateIndices) {
+              const node = nodes[stateIndex];
+              if (!isFeasibleAverage(node)) continue;
+              feasibleFinalStates++;
+              if (bestIndex === undefined || compareFinalNodes(node, nodes[bestIndex]) > 0) {
+                bestIndex = stateIndex;
+              }
+            }
+          }
+        }
+
+        if (bestIndex === undefined) {
+          vehicleLog(
+            LogLevel.Trace,
+            vehicle.vehicle_uuid,
+            `scheduleWindows(${scheduleTag}): no feasible final state frontier=${frontierSummary(states)} total=${countFrontierNodes(states)} ` +
+            `nodesRecorded=${nodesRecorded} prunedDominated=${nodesPrunedDominated} prunedReplaced=${nodesPrunedReplaced}`
+          );
+          return scheduled;
+        }
+        const best = nodes[bestIndex];
+        if (best.deliveredMs <= 0) {
+          vehicleLog(LogLevel.Trace, vehicle.vehicle_uuid, `scheduleWindows(${scheduleTag}): no feasible intervals after constraints`);
+          return scheduled;
+        }
+        vehicleLog(
+          LogLevel.Trace,
+          vehicle.vehicle_uuid,
+          `scheduleWindows(${scheduleTag}): best phase=${best.phase} delivered=${Math.round(best.deliveredMs / 60e3)}min ` +
+          `scheduled=${Math.round(best.scheduledMs / 60e3)}min chargeCost=${best.chargeCostMs} windows=${best.windows} ` +
+          `warmupDebt=${Math.round(best.warmupDebtMs / 60e3)}min firstStart=${new Date(firstStartForRanking(best)).toISOString()} ` +
+          `feasibleFinalStates=${feasibleFinalStates}`
+        );
+        const deliveredMs = Math.min(best.deliveredMs, targetMaxMs);
+        if (deliveredMs < targetMaxMs) {
+          vehicleLog(
+            LogLevel.Trace,
+            vehicle.vehicle_uuid,
+            `scheduleWindows(${scheduleTag}): best-effort fallback scheduled=${Math.round(deliveredMs / 60e3)}min ` +
+            `requested=${Math.round(targetMaxMs / 60e3)}min`
+          );
+        }
+
+        const selectedSteps: AtomicStep[] = [];
+        for (let nodeIndex: number | null = bestIndex; nodeIndex !== null; nodeIndex = nodes[nodeIndex].prev) {
+          const node = nodes[nodeIndex];
+          if (node.action === "take") {
+            assert(node.stepIndex !== null);
+            selectedSteps.push(atomicSteps[node.stepIndex]);
+          }
+        }
+        selectedSteps.reverse();
+        vehicleLog(
+          LogLevel.Trace,
+          vehicle.vehicle_uuid,
+          `scheduleWindows(${scheduleTag}): selectedSteps=${selectedSteps.map((step) =>
+            `${new Date(step.start).toISOString()}..${new Date(step.stop).toISOString()}@${fmtDbPrice(step.price)}`
+          ).join(", ")}`
+        );
+
+        const reconstructedWindows: { start: number; stop: number }[] = [];
+        for (const step of selectedSteps) {
+          const last = reconstructedWindows[reconstructedWindows.length - 1];
+          if (last && last.stop === step.start) {
+            last.stop = step.stop;
+          } else {
+            reconstructedWindows.push({ start: step.start, stop: step.stop });
+          }
+        }
+
+        vehicleLog(LogLevel.Trace, vehicle.vehicle_uuid, `scheduleWindows(${scheduleTag}): accepted avgPrice=${fmtDbPrice(best.chargeCostMs / best.scheduledMs)} ` +
+          `windows=${reconstructedWindows.map((w) => `${new Date(w.start).toISOString()}..${new Date(w.stop).toISOString()}`).join(", ")}`
+        );
+        scheduled.windows = reconstructedWindows;
+        scheduled.scheduledMs = best.scheduledMs;
+        return scheduled;
       };
 
       const HandleTripCharge = () => {
         if (trip) {
           assert(trip.level);
           assert(trip.schedule_ts);
-          GeneratePlan(ChargeType.Trip, `upcoming trip`, trip.level, trip.schedule_ts.getTime());
+          addUpcomingSoftIntent(ChargeType.Trip, `upcoming trip`, trip.level, trip.schedule_ts.getTime());
         }
       };
 
       if (startLevel < minimum_charge) {
         // Emergency charge up to minimum level
-        GeneratePlan(ChargeType.Minimum, `emergency charge`, minimum_charge);
+        const timeNeeded = ChargeDuration(startLevel, minimum_charge);
+        assert(timeNeeded > 0);
+        const stop = hardStart + timeNeeded;
+        chargePlan.push({
+          chargeStart: new Date(hardStart),
+          chargeStop: new Date(stop),
+          chargeType: ChargeType.Minimum,
+          level: minimum_charge,
+          comment: `emergency charge`,
+        });
+        hardStart = stop;
+        startLevel = minimum_charge;
         smartStatus = (vehicle.connected ? `Direct charging to ` : `Connect charger to charge to `) + `${minimum_charge}%`;
       }
 
-      // Manual schedule blocks everything
+      // Manual schedule overrides auto choices
       if (manual) {
         if (!manual.schedule_ts) {
           assert(manual.level);
-          log(LogLevel.Debug, `Manual charging directly to ${manual.level}%`);
+          vehicleLog(LogLevel.Debug, vehicle.vehicle_uuid, `Manual charging directly to ${manual.level}%`);
           chargePlan.push({
             chargeStart: null,
             chargeStop: null,
@@ -1064,16 +1605,11 @@ export class Logic {
             level: manual.level,
             comment: `manual charge`,
           });
-          smartStatus = smartStatus || `Manual charging to ${manual.level}%`;
+          smartStatus = `Manual charge directly to ${manual.level}%`;
         } else {
           assert(manual.level);
           assert(manual.schedule_ts);
-          GeneratePlan(
-            ChargeType.Manual,
-            `manual charge`,
-            manual.level,
-            manual.schedule_ts.getTime()
-          );
+          addUpcomingSoftIntent(ChargeType.Manual, `manual charge`, manual.level, manual.schedule_ts.getTime());
         }
 
         // Still do trip charging!
@@ -1082,7 +1618,12 @@ export class Logic {
         let stats: DBLocationStats | null = null;
         if (location_uuid) {
           stats = await this.currentStats(vehicle, location_uuid);
-          log(LogLevel.Trace, `stats: ${JSON.stringify(stats)}`);
+          vehicleLog(LogLevel.Trace, vehicle.vehicle_uuid, `stats: ${JSON.stringify(stats)}`);
+        }
+
+        if (stats && stats.weekly_avg7_price && stats.weekly_avg21_price && stats.threshold) {
+          const averagePrice = stats.weekly_avg7_price + (stats.weekly_avg7_price - stats.weekly_avg21_price) / 2;
+          fillMaxPrice = (averagePrice * stats.threshold) / 100;
         }
 
         const ai = {
@@ -1112,7 +1653,7 @@ export class Logic {
                 ai.ts = schedule.ts;
               } else {
                 // Disable smart charging because without threshold and averages it can not make a good decision
-                log(LogLevel.Debug, `Missing stats for smart charging.`);
+                vehicleLog(LogLevel.Debug, vehicle.vehicle_uuid, `Missing stats for smart charging.`);
                 ai.learning = true;
               }
             }
@@ -1136,8 +1677,8 @@ export class Logic {
                 }
               }
               smartStatus = smartStatus || `Smart charging disabled (learning)`;
-              GeneratePlan(ChargeType.Fill, `learning`, vehicle.maximum_charge, start_ts + 12 * 60 * 60e3);
-              fillBefore = 0; // disable low-price filling
+              addSoftIntent(ChargeType.Fill, `learning`, vehicle.maximum_charge, start_ts + 12 * 60 * 60e3);
+              fillMaxPrice = null; // disable low-price filling
             } else {
               assert(ai.level);
               assert(ai.ts);
@@ -1145,8 +1686,8 @@ export class Logic {
               const before = new Date(ai.ts);
               smartStatus = smartStatus
                 || `Predicting battery level ${ai.level}% (${neededCharge > 0 ? Math.round(neededCharge) + "%" : "no"} charge) is needed before ${before.toISOString()}`;
-              log(LogLevel.Debug, `Current level: ${vehicle.level}, predicting ${ai.level}% (${minimum_charge}+${neededCharge - minimum_charge}) is needed before ${before.toISOString()}`);
-              GeneratePlan(ChargeType.Routine, `routine charge`, ai.level, ai.ts);
+              vehicleLog(LogLevel.Debug, vehicle.vehicle_uuid, `Current level: ${vehicle.level}, predicting ${ai.level}% (${minimum_charge}+${neededCharge - minimum_charge}) is needed before ${before.toISOString()}`);
+              addSoftIntent(ChargeType.Routine, `routine charge`, ai.level, ai.ts);
 
               // locations settings charging
               {
@@ -1160,30 +1701,121 @@ export class Logic {
                   );
 
                 if (goalLevel > ai.level) {
-                  GeneratePlan(ChargeType.Prefered, `charge setting`, goalLevel, ai.ts);
+                  addSoftIntent(ChargeType.Prefered, `charge setting`, goalLevel, ai.ts);
                 }
               }
             }
           }
+        }
+      }
 
-          // Low price fill charging
-          if (fillBefore && stats && stats.weekly_avg7_price && stats.weekly_avg21_price && stats.threshold) {
-            const averagePrice = stats.weekly_avg7_price + (stats.weekly_avg7_price - stats.weekly_avg21_price) / 2;
-            const thresholdPrice = (averagePrice * stats.threshold) / 100;
+      scheduleSoftIntents();
+    }
 
-            GeneratePlan(ChargeType.Fill, `low price`, vehicle.maximum_charge, fillBefore, thresholdPrice);
-          }
+    if (chargePlan.length) {
+      chargePlan = Logic.cleanupPlan(chargePlan);
+      vehicleLog(LogLevel.Trace, vehicle.vehicle_uuid, chargePlan);
+    }
+
+    if (!smartStatus && chargePlan.length > 0) {
+      const milestones: { level: number; chargeType: ChargeType }[] = [];
+      let plannedLevel = initialLevel;
+      for (const entry of chargePlan) {
+        if (entry.level > plannedLevel) {
+          milestones.push({ level: entry.level, chargeType: entry.chargeType });
+          plannedLevel = entry.level;
         }
       }
+      if (milestones.length > 0) {
+        const first = milestones[0];
+        const last = milestones[milestones.length - 1];
+        const firstText = first.chargeType === ChargeType.Manual
+          ? `Manual charge to ${first.level}%`
+          : first.chargeType === ChargeType.Trip
+            ? `Charge to ${first.level}% before trip`
+            : first.chargeType === ChargeType.Fill
+              ? `Fill charge to ${first.level}% scheduled`
+              : `Charge to ${first.level}% scheduled`;
+        smartStatus = last.level > first.level
+          ? `${firstText}, then ${last.chargeType === ChargeType.Fill ? `fill to ${last.level}%` : `to ${last.level}%`}`
+          : firstText;
+      }
     }
 
     if (smartStatus) {
       this.setSmartStatus(vehicle, smartStatus);
     }
 
-    if (chargePlan.length) {
-      chargePlan = Logic.cleanupPlan(chargePlan);
-      log(LogLevel.Trace, chargePlan);
+    {
+      // DESCRIBE CHARGE PLAN IN A HUMAN-READABLE WAY
+      // Compare the new plan with the existing one and log changes in a human-readable way.
+      // We want to log when the plan changes, but the raw JSON can be hard to read.
+    
+      const normalizePlan = (plan: any[] | null): string => {
+        if (!plan || plan.length === 0) return "[]";
+        const normalized = plan.map((entry) => ({
+          type: entry.chargeType ?? entry.charge_type ?? "",
+          level: entry.level ?? null,
+          comment: entry.comment ?? "",
+          start: entry.chargeStart ? new Date(entry.chargeStart).getTime() : null,
+          stop: entry.chargeStop ? new Date(entry.chargeStop).getTime() : null,
+        }));
+        return JSON.stringify(normalized);
+      };
+      const fmtDuration = (ms: number): string => {
+        const totalMinutes = Math.round(ms / 60e3);
+        const hours = Math.floor(totalMinutes / 60);
+        const minutes = totalMinutes % 60;
+        if (hours > 0 && minutes > 0) return `${hours}h ${minutes}m`;
+        if (hours > 0) return `${hours}h`;
+        return `${minutes}m`;
+      };
+      const fmtTime = (d: Date | null): string => {
+        if (!d) return "now";
+        return d.toISOString().replace("T", " ").replace("Z", "Z");
+      };
+
+      const nextPlan = chargePlan.length > 0 ? chargePlan : null;
+      const prevNorm = normalizePlan(prevPlan);
+      const nextNorm = normalizePlan(nextPlan);
+      const locationChanged = (vehicle.charge_plan_location_uuid || null) !== (nextPlan ? location_uuid : null);
+      if (prevNorm !== nextNorm || locationChanged) {
+        if (!nextPlan) {
+          vehicleLog(LogLevel.Info, vehicle.vehicle_uuid, `Charge schedule cleared`);
+        } else {
+          const totalMs = nextPlan.reduce((sum, entry) => {
+            if (entry.chargeStart && entry.chargeStop) {
+              return sum + (entry.chargeStop.getTime() - entry.chargeStart.getTime());
+            }
+            return sum;
+          }, 0);
+          const windows = nextPlan
+            .map((entry) => {
+              const start = fmtTime(entry.chargeStart);
+              const stop = entry.chargeStop ? fmtTime(entry.chargeStop) : "until done";
+              return `${start} → ${stop} (${entry.chargeType} to ${entry.level}%)`;
+            })
+            .join("; ");
+          let gapInfo = "";
+          for (let i = 0; i < nextPlan.length - 1; i++) {
+            const a = nextPlan[i];
+            const b = nextPlan[i + 1];
+            if (a.chargeStop && b.chargeStart) {
+              const gapMs = b.chargeStart.getTime() - a.chargeStop.getTime();
+              if (gapMs > 0) {
+                gapInfo = `; gaps: ${fmtDuration(gapMs)}`;
+                break;
+              }
+            }
+          }
+          const totalInfo = totalMs > 0 ? `total ${fmtDuration(totalMs)}` : `total unknown`;
+          vehicleLog(
+            LogLevel.Info,
+            vehicle.vehicle_uuid,
+            `Charge schedule updated: ${totalInfo}; ${windows}${gapInfo}${splitInfo}`
+          );
+        }
+      }
     }
     await this.db.pg.one(
       `UPDATE vehicle SET charge_plan = $1:json, charge_plan_location_uuid = $2 WHERE vehicle_uuid = $3 RETURNING *;`,
diff --git a/shared/sc-client.ts b/shared/sc-client.ts
index f4cc13a8..b1fcc55e 100644
--- a/shared/sc-client.ts
+++ b/shared/sc-client.ts
@@ -92,6 +92,7 @@ locationSettings {
   locationID
   directLevel
   goal
+  splitCharge
 }
 batteryLevel
 odometer
diff --git a/shared/sc-schema.graphql b/shared/sc-schema.graphql
index be6de445..3a96f46d 100644
--- a/shared/sc-schema.graphql
+++ b/shared/sc-schema.graphql
@@ -206,6 +206,13 @@ type ServiceProvider {
   serviceID: ID!
 }
 
+"""Split Charge Preference"""
+enum SplitCharge {
+  Always
+  Auto
+  Never
+}
+
 type StateMap {
   chargeCost: Float!
   chargeCostSaved: Float!
@@ -361,6 +368,7 @@ type VehicleLocationSetting {
 
   """location id"""
   locationID: ID!
+  splitCharge: SplitCharge!
 }
 
 input VehicleLocationSettingInput {
@@ -370,4 +378,5 @@ input VehicleLocationSettingInput {
 
   """location id"""
   locationID: ID!
+  splitCharge: SplitCharge!
 }
diff --git a/shared/sc-schema.ts b/shared/sc-schema.ts
index 2cc0aca4..227868bd 100644
--- a/shared/sc-schema.ts
+++ b/shared/sc-schema.ts
@@ -275,6 +275,16 @@ export interface GQLVehicleLocationSetting {
    */
   directLevel: number;
   goal: string;
+  splitCharge: GQLSplitCharge;
+}
+
+/**
+ * Split Charge Preference
+ */
+export enum GQLSplitCharge {
+  Never = 'Never',
+  Auto = 'Auto',
+  Always = 'Always'
 }
 
 export interface GQLResolverTest {
@@ -434,6 +444,7 @@ export interface GQLVehicleLocationSettingInput {
    */
   directLevel: number;
   goal: string;
+  splitCharge: GQLSplitCharge;
 }
 
 export interface GQLSubscription {
@@ -1032,6 +1043,7 @@ export interface GQLVehicleLocationSettingTypeResolver<TParent = GQLVehicleLocat
   locationID?: VehicleLocationSettingToLocationIDResolver<TParent>;
   directLevel?: VehicleLocationSettingToDirectLevelResolver<TParent>;
   goal?: VehicleLocationSettingToGoalResolver<TParent>;
+  splitCharge?: VehicleLocationSettingToSplitChargeResolver<TParent>;
 }
 
 export interface VehicleLocationSettingToLocationIDResolver<TParent = GQLVehicleLocationSetting, TResult = string> {
@@ -1046,6 +1058,10 @@ export interface VehicleLocationSettingToGoalResolver<TParent = GQLVehicleLocati
   (parent: TParent, args: {}, context: any, info: GraphQLResolveInfo): TResult | Promise<TResult>;
 }
 
+export interface VehicleLocationSettingToSplitChargeResolver<TParent = GQLVehicleLocationSetting, TResult = GQLSplitCharge> {
+  (parent: TParent, args: {}, context: any, info: GraphQLResolveInfo): TResult | Promise<TResult>;
+}
+
 export interface GQLResolverTestTypeResolver<TParent = GQLResolverTest> {
   isFieldResolverWorking?: ResolverTestToIsFieldResolverWorkingResolver<TParent>;
 }
diff --git a/shared/sc-types.ts b/shared/sc-types.ts
index a8b5b52d..718e372e 100644
--- a/shared/sc-types.ts
+++ b/shared/sc-types.ts
@@ -18,6 +18,12 @@ export enum SmartChargeGoal {
   Full = "full",
 }
 
+export enum SplitCharge {
+  Never = "never",
+  Auto = "auto",
+  Always = "always",
+}
+
 export enum ChargeType {
   Disable = "disable",
   Calibrate = "calibrate",
diff --git a/shared/sc-utils.ts b/shared/sc-utils.ts
index e3fd4d94..22ac7d38 100644
--- a/shared/sc-utils.ts
+++ b/shared/sc-utils.ts
@@ -12,7 +12,7 @@ import {
 } from "./sc-schema.js";
 import { compareStartTimes } from "./utils.js";
 import { DEFAULT_DIRECTLEVEL } from "./smartcharge-defines.js";
-import { SmartChargeGoal } from "./sc-types.js";
+import { SmartChargeGoal, SplitCharge } from "./sc-types.js";
 
 export function scheduleMap(
   schedule: GQLSchedule[]
@@ -33,6 +33,7 @@ export function DefaultVehicleLocationSettings(
     locationID: location_uuid,
     directLevel: DEFAULT_DIRECTLEVEL,
     goal: SmartChargeGoal.Balanced,
+    splitCharge: SplitCharge.Auto,
   };
 }
 
diff --git a/shared/utils.ts b/shared/utils.ts
index 1d52b671..e01cf6d5 100644
--- a/shared/utils.ts
+++ b/shared/utils.ts
@@ -39,12 +39,33 @@ export function log(level: LogLevel, data: unknown) {
     }
   }
 }
+
+export function vehicleLog(level: LogLevel, vehicleUUID: string, data: unknown) {
+  if (level <= LOGLEVEL) {
+    const s = logFormat(level, `${vehicleUUID} ${formatLogData(data)}`);
+    switch (level) {
+      case LogLevel.Error:
+      case LogLevel.Warning:
+        console.error(s);
+        break;
+      case LogLevel.Info:
+        console.log(s);
+        break;
+      case LogLevel.Debug:
+      case LogLevel.Trace:
+        console.debug(s);
+        break;
+    }
+  }
+}
 export function logFormat(level: LogLevel, data: unknown): string {
-  return `${new Date().toISOString()} ${logSymbol[level]} ${
-    data instanceof Error ? (data as Error).message
+  return `${new Date().toISOString()} ${logSymbol[level]} ${formatLogData(data)}`;
+}
+
+function formatLogData(data: unknown): string {
+  return data instanceof Error ? data.message
     : typeof data === "object" ? JSON.stringify(data)
-    : data
-  }`;
+    : String(data);
 }
 
 export function arrayMean(list: number[]) {
@@ -253,4 +274,4 @@ export function diffObjects<T extends object>(a: T, b: T): Partial<T> {
     }
   }
   return result;
-}
\ No newline at end of file
+}
diff --git a/vite.config.mjs b/vite.config.mjs
index 09f11937..f2f30d62 100644
--- a/vite.config.mjs
+++ b/vite.config.mjs
@@ -12,9 +12,11 @@ import path from 'path';
 import globals from './shared/smartcharge-globals.json'; // Adjusted to resolve from `shared`
 import { VitePWA } from 'vite-plugin-pwa'
 
+dotenv.config();
+
 const commitHash = process.env.SOURCE_VERSION || execSync('git rev-parse --short HEAD').toString().trim();
+const serverURL = `http://${process.env.SERVER_IP ? (process.env.SERVER_IP.includes(":" ) ? `[${process.env.SERVER_IP}]` : process.env.SERVER_IP) : "localhost"}:${process.env.SERVER_PORT || globals.DEFAULT_PORT}`;
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
-dotenv.config();
 
 export default defineConfig({
   root: 'app', // Root directory for the Vue app
@@ -30,7 +32,7 @@ export default defineConfig({
   server: {
     proxy: {
       ["/api"]: {
-        target: `http://localhost:${process.env.SERVER_PORT || globals.DEFAULT_PORT}`,
+        target: serverURL,
         ws: true,
       },
     },