diff --git a/.changeset/ev-api-busy-recovery.md b/.changeset/ev-api-busy-recovery.md
new file mode 100644
index 0000000..07674fb
--- /dev/null
+++ b/.changeset/ev-api-busy-recovery.md
@@ -0,0 +1,5 @@
+---
+"ftw-webapp": patch
+---
+
+Retry brief busy refusals so charging status can recover without a reload. Expire queued API calls and discard them on disconnect. Never retry a write after a timeout or a lost answer.
diff --git a/.changeset/ev-client-readiness.md b/.changeset/ev-client-readiness.md
new file mode 100644
index 0000000..7817fe7
--- /dev/null
+++ b/.changeset/ev-client-readiness.md
@@ -0,0 +1,5 @@
+---
+"ftw-webapp": patch
+---
+
+Show Pause charging and Resume plan as separate actions. Show whether the charger has stopped, and keep the charging goal while paused. Let owners set battery size beside the current level, with direct saving and readback. Show viewers the battery level, expire old charger readings even when house power is live, and explain whether the level survives a box restart.
diff --git a/.changeset/ev-connected-status.md b/.changeset/ev-connected-status.md
new file mode 100644
index 0000000..5a99799
--- /dev/null
+++ b/.changeset/ev-connected-status.md
@@ -0,0 +1,5 @@
+---
+"ftw-webapp": patch
+---
+
+Show charger status when a car is connected and open its controls from a charging notification. Keep old readings visibly out of date after a dropped connection. Notification switches save directly and retain later edits while the box responds.
diff --git a/.changeset/ev-connection-confirmation-copy.md b/.changeset/ev-connection-confirmation-copy.md
new file mode 100644
index 0000000..3de9613
--- /dev/null
+++ b/.changeset/ev-connection-confirmation-copy.md
@@ -0,0 +1,5 @@
+---
+"ftw-webapp": patch
+---
+
+Explain when charging needs a new choice because the charger or connection could not be confirmed, including after reconnecting. Keep the message separate from confirmation that current has stopped.
diff --git a/.changeset/ev-effective-capacity.md b/.changeset/ev-effective-capacity.md
new file mode 100644
index 0000000..9676dce
--- /dev/null
+++ b/.changeset/ev-effective-capacity.md
@@ -0,0 +1,5 @@
+---
+"ftw-webapp": patch
+---
+
+Show when the current car uses a different battery size from the usual size just saved.
diff --git a/.changeset/ev-feedback-and-direct-controls.md b/.changeset/ev-feedback-and-direct-controls.md
new file mode 100644
index 0000000..9af8bc6
--- /dev/null
+++ b/.changeset/ev-feedback-and-direct-controls.md
@@ -0,0 +1,11 @@
+---
+"ftw-webapp": patch
+---
+
+Read the current FTW charge-level and schedule fields, including a plugged car at zero percent. Charging feedback follows the charger's status instead of treating a received request as proof of charging. Show unavailable readings and recover when contact returns.
+
+Apply schedule edits and changes to a running manual current without Save or Update. Keep an ongoing charge-level drag when an earlier response arrives. Keep failed requests visible, poll only while the panel is visible, and keep keyboard focus inside the dialog.
+
+Keep the charging goal and solar rule together, with no mode tabs. Show when Charge now overrides them. Show the current slider only while manual charging is active. Opening goal settings does not send a command.
+
+Preserve one-off goals and the home battery threshold for solar when editing a schedule.
diff --git a/.changeset/ev-first-connection-help.md b/.changeset/ev-first-connection-help.md
new file mode 100644
index 0000000..c86959e
--- /dev/null
+++ b/.changeset/ev-first-connection-help.md
@@ -0,0 +1,5 @@
+---
+"ftw-webapp": patch
+---
+
+Explain where to connect and add the first charger when the box has none, instead of showing an empty charging panel.
diff --git a/.changeset/ev-first-goal.md b/.changeset/ev-first-goal.md
new file mode 100644
index 0000000..2a46de2
--- /dev/null
+++ b/.changeset/ev-first-goal.md
@@ -0,0 +1,5 @@
+---
+"ftw-webapp": patch
+---
+
+Let the user choose the displayed first charging goal without changing its values. Opening settings keeps the current charging intent. Later edits still apply directly.
diff --git a/.changeset/ev-first-read-recovery.md b/.changeset/ev-first-read-recovery.md
new file mode 100644
index 0000000..5ab4280
--- /dev/null
+++ b/.changeset/ev-first-read-recovery.md
@@ -0,0 +1,5 @@
+---
+"ftw-webapp": patch
+---
+
+Keep a busy or failed charger read in a waiting state. Show setup help only after the box confirms that no charger is configured.
diff --git a/.changeset/ev-goal-plan-confirmation.md b/.changeset/ev-goal-plan-confirmation.md
new file mode 100644
index 0000000..5985560
--- /dev/null
+++ b/.changeset/ev-goal-plan-confirmation.md
@@ -0,0 +1,5 @@
+---
+"ftw-webapp": patch
+---
+
+Confirm a saved charging goal before its new plan finishes. Show planning progress, hide old charge windows and preserve the save confirmation if a later status read fails.
diff --git a/.changeset/ev-home-command-refresh.md b/.changeset/ev-home-command-refresh.md
new file mode 100644
index 0000000..3656111
--- /dev/null
+++ b/.changeset/ev-home-command-refresh.md
@@ -0,0 +1,5 @@
+---
+"ftw-webapp": patch
+---
+
+Refresh the home charging card after a command or goal change. Give viewers guidance they can act on without offering controls their account cannot use.
diff --git a/.changeset/ev-manual-save-feedback.md b/.changeset/ev-manual-save-feedback.md
new file mode 100644
index 0000000..70b8d92
--- /dev/null
+++ b/.changeset/ev-manual-save-feedback.md
@@ -0,0 +1,5 @@
+---
+"ftw-webapp": patch
+---
+
+Show when a charging choice is active but could not be saved for restart. The notice clears when the box confirms its retry succeeded.
diff --git a/.changeset/ev-new-goal-after-remove.md b/.changeset/ev-new-goal-after-remove.md
new file mode 100644
index 0000000..e192cd2
--- /dev/null
+++ b/.changeset/ev-new-goal-after-remove.md
@@ -0,0 +1,5 @@
+---
+"ftw-webapp": patch
+---
+
+Suggest 80% when setting a new charging goal after removing the previous one. Clear the old target in the demo as the box does.
diff --git a/.changeset/ev-plan-failure-feedback.md b/.changeset/ev-plan-failure-feedback.md
new file mode 100644
index 0000000..336b872
--- /dev/null
+++ b/.changeset/ev-plan-failure-feedback.md
@@ -0,0 +1,5 @@
+---
+"ftw-webapp": patch
+---
+
+When a new charging plan fails, explain that the settings are saved but charging times are unavailable. Keep the old plan hidden until a new one succeeds.
diff --git a/.changeset/ev-reconnect-tap.md b/.changeset/ev-reconnect-tap.md
new file mode 100644
index 0000000..5e01a94
--- /dev/null
+++ b/.changeset/ev-reconnect-tap.md
@@ -0,0 +1,5 @@
+---
+"ftw-webapp": patch
+---
+
+Open the charging panel when its car bubble is tapped during reconnection. Show connection progress and fill the same panel when the box answers; explain when a connected box lacks app charging controls.
diff --git a/.changeset/ev-remove-confirmation.md b/.changeset/ev-remove-confirmation.md
new file mode 100644
index 0000000..1615e15
--- /dev/null
+++ b/.changeset/ev-remove-confirmation.md
@@ -0,0 +1,5 @@
+---
+"ftw-webapp": patch
+---
+
+Confirm when a charging goal is removed, even if the next status read fails. Clear the previous save message so the removal's plan update cannot claim that a goal was saved.
diff --git a/.changeset/ev-restart-choice.md b/.changeset/ev-restart-choice.md
new file mode 100644
index 0000000..dddecd4
--- /dev/null
+++ b/.changeset/ev-restart-choice.md
@@ -0,0 +1,5 @@
+---
+"ftw-webapp": patch
+---
+
+Ask how to continue when an earlier charge request cannot be matched after restart. Offer Charge now, Resume plan and Pause charging without calling it a user pause. Keep actual power visible until a changed current limit reaches the charger.
diff --git a/.changeset/ev-review-read-confirmation.md b/.changeset/ev-review-read-confirmation.md
new file mode 100644
index 0000000..e305b05
--- /dev/null
+++ b/.changeset/ev-review-read-confirmation.md
@@ -0,0 +1,5 @@
+---
+"ftw-webapp": patch
+---
+
+Keep accepted battery levels and solar choices visible if the following status read fails. Use the charger's own plan windows to avoid blocking current status on a full plan read. Describe routine replanning without claiming a new goal was saved.
diff --git a/.changeset/ev-soc-and-pv-only.md b/.changeset/ev-soc-and-pv-only.md
new file mode 100644
index 0000000..3947ace
--- /dev/null
+++ b/.changeset/ev-soc-and-pv-only.md
@@ -0,0 +1,5 @@
+---
+"ftw-webapp": patch
+---
+
+Correct the car's charge level from the EV panel with a slider the box's own estimate prefills, and switch charging from solar surplus only on or off. Both write through the door and reread the charger once the box has answered.
diff --git a/.changeset/ev-soc-confirmation.md b/.changeset/ev-soc-confirmation.md
new file mode 100644
index 0000000..91ec06b
--- /dev/null
+++ b/.changeset/ev-soc-confirmation.md
@@ -0,0 +1,5 @@
+---
+"ftw-webapp": patch
+---
+
+Ask for the car's level when the box reports an unconfirmed battery estimate. Keep charging status attached to the active box after pairing or switching homes.
diff --git a/.changeset/ev-solar-save-failure.md b/.changeset/ev-solar-save-failure.md
new file mode 100644
index 0000000..cc52b89
--- /dev/null
+++ b/.changeset/ev-solar-save-failure.md
@@ -0,0 +1,5 @@
+---
+"ftw-webapp": patch
+---
+
+Explain a rejected solar-rule save without blaming charger connectivity. Keep the previous choice visible and allow retry.
diff --git a/.changeset/ev-unplugged-battery-size.md b/.changeset/ev-unplugged-battery-size.md
new file mode 100644
index 0000000..f835b32
--- /dev/null
+++ b/.changeset/ev-unplugged-battery-size.md
@@ -0,0 +1,5 @@
+---
+"ftw-webapp": patch
+---
+
+Let owners set the usual car battery size before plugging in. Save on field release and show the confirmed value, while keeping current charge and charging controls limited to a connected car.
diff --git a/.changeset/ev-unplugged-goal.md b/.changeset/ev-unplugged-goal.md
new file mode 100644
index 0000000..e32dab4
--- /dev/null
+++ b/.changeset/ev-unplugged-goal.md
@@ -0,0 +1,5 @@
+---
+"ftw-webapp": patch
+---
+
+Keep the saved target percentage beside the ready time when the car is unplugged or its battery level is unknown.
diff --git a/.changeset/live-sheet-shell-width.md b/.changeset/live-sheet-shell-width.md
new file mode 100644
index 0000000..425eeba
--- /dev/null
+++ b/.changeset/live-sheet-shell-width.md
@@ -0,0 +1,5 @@
+---
+"ftw-webapp": patch
+---
+
+Keep the live power sheet centered within the app's width on tablets and desktops, matching the EV sheet.
diff --git a/.changeset/overview-savings-week.md b/.changeset/overview-savings-week.md
new file mode 100644
index 0000000..764f621
--- /dev/null
+++ b/.changeset/overview-savings-week.md
@@ -0,0 +1,5 @@
+---
+"ftw-webapp": patch
+---
+
+Read only seven savings days on the home screen. The displayed today and week totals stay the same without calculating an unused month before charger requests.
diff --git a/.changeset/ux-native-feel-pass.md b/.changeset/ux-native-feel-pass.md
new file mode 100644
index 0000000..5e96fcc
--- /dev/null
+++ b/.changeset/ux-native-feel-pass.md
@@ -0,0 +1,7 @@
+---
+"ftw-webapp": patch
+---
+
+Make the app feel native on a phone: every control answers a press, tab changes slide in from the direction of travel, the theme follows the OS mid-session, and the Android keyboard no longer covers bottom sheets. On tablets and desktops the shell keeps a phone shape instead of hugging one edge.
+
+Recover on its own from two states that used to need an OS exit: a stalled passkey ceremony now offers Cancel, and a slow local open says so after a beat instead of sitting blank. Long-press shortcuts open Plan and History; update checks run at launch, not only after the first hide.
diff --git a/contract/push-catalogue.yaml b/contract/push-catalogue.yaml
index 5f4a2e1..f34ab4c 100644
--- a/contract/push-catalogue.yaml
+++ b/contract/push-catalogue.yaml
@@ -13,6 +13,9 @@
 # lost every notification that mattered.
 version: 1
 events:
+  - kind: charging.connected
+    title: Car plugged in
+    body: "Open to see charging status, check the battery level and set a ready time."
   - kind: charging.session_complete
     title: Car charged
     body: "{kwh} kWh delivered — ready to go."
diff --git a/index.html b/index.html
index 241a4b1..38756ca 100644
--- a/index.html
+++ b/index.html
@@ -2,7 +2,9 @@
 <html lang="en" data-theme="dark">
   <head>
     <meta charset="utf-8" />
-    <meta name="viewport" content="width=device-width, initial-scale=1, viewport-fit=cover" />
+    <!-- interactive-widget=resizes-content: Android Chrome paints the keyboard
+         over fixed bottom sheets unless the layout viewport shrinks instead. -->
+    <meta name="viewport" content="width=device-width, initial-scale=1, viewport-fit=cover, interactive-widget=resizes-content" />
 
     <title>FTW</title>
     <meta name="description" content="Your home's energy, from wherever you are." />
diff --git a/public/manifest.webmanifest b/public/manifest.webmanifest
index 2070351..c12a7f3 100644
--- a/public/manifest.webmanifest
+++ b/public/manifest.webmanifest
@@ -2,6 +2,7 @@
   "name": "FTW",
   "short_name": "FTW",
   "description": "Your home's energy, from wherever you are.",
+  "id": "/",
   "start_url": "/",
   "scope": "/",
   "display": "standalone",
@@ -9,6 +10,18 @@
   "background_color": "#0d0d0d",
   "theme_color": "#0d0d0d",
   "categories": ["utilities", "productivity"],
+  "shortcuts": [
+    {
+      "name": "Plan",
+      "url": "/#/plan",
+      "icons": [{ "src": "/icons/icon-192.png", "sizes": "192x192", "type": "image/png" }]
+    },
+    {
+      "name": "History",
+      "url": "/#/history",
+      "icons": [{ "src": "/icons/icon-192.png", "sizes": "192x192", "type": "image/png" }]
+    }
+  ],
   "icons": [
     {
       "src": "/icons/icon.svg",
diff --git a/src/App.svelte b/src/App.svelte
index b85af5d..8a54c49 100644
--- a/src/App.svelte
+++ b/src/App.svelte
@@ -13,7 +13,7 @@
   import Plan from '$views/Plan.svelte'
   import Pair from '$views/Pair.svelte'
   import { SiteStore } from '$lib/state/site.svelte'
-  import { Router, type Route } from '$lib/state/route.svelte'
+  import { Router, routeIndex, type Route } from '$lib/state/route.svelte'
   import { checkForAppUpdate } from '$lib/pwa/service-worker.svelte'
 
   // Replaced wholesale when someone signs out. `$state.raw` rather than
@@ -35,6 +35,14 @@
   // the browser tab's localStorage, and to any install whose localStorage was
   // evicted while the sites survived.
   let siteId = $state<string | null>(readSiteHint())
+  let ChargingNotice = $state<import('svelte').Component<{ site: SiteStore }> | null>(null)
+  $effect(() => {
+    if (!site.heardFromBox || ChargingNotice) return
+    let cancelled = false
+    void import('$lib/ui/ChargingNotice.svelte').then(m => { if (!cancelled) ChargingNotice = m.default })
+    return () => { cancelled = true }
+  })
+
   /** A public simulator session. It has no site id and writes no home to disk. */
   let demoActive = $state(false)
 
@@ -104,6 +112,25 @@
     })()
   }
 
+  /**
+   * The settling pane is quiet on purpose; this is its one exception.
+   *
+   * Opening a home is a local read that lands in a frame or two and paints
+   * nothing. If it outlives a beat — a cold database, a slow device — one
+   * line appears, because a blank pane that never changes reads as frozen.
+   * The timer dies with settling, however settling ends.
+   */
+  let settlingSlow = $state(false)
+
+  $effect(() => {
+    if (!(resolvingSite || restoringHome)) {
+      settlingSlow = false
+      return
+    }
+    const slowTimer = setTimeout(() => (settlingSlow = true), 700)
+    return () => clearTimeout(slowTimer)
+  })
+
   /**
    * Landing on a pairing link, from a camera or a shared URL.
    *
@@ -154,6 +181,8 @@
   let displayedRoute = $state<Route | null>(
     router.current === 'history' || router.current === 'box' ? null : router.current
   )
+  /** Which way the incoming panel slides, read off the tab order. */
+  let viewDir = $state<'fwd' | 'back'>('fwd')
   let seen = $state({
     plan: router.current === 'plan',
     history: false,
@@ -214,6 +243,11 @@
       scrollByRoute[displayedRoute] = scrollPane.scrollTop
     }
     routeSavedFrom = null
+    // Read before the swap: the direction is where this panel sits in the bar
+    // relative to the one leaving. A first paint has nothing to compare to.
+    if (displayedRoute) {
+      viewDir = routeIndex(route) >= routeIndex(displayedRoute) ? 'fwd' : 'back'
+    }
     displayedRoute = route
     await tick()
     if (request === routeRequest && scrollPane) {
@@ -230,6 +264,8 @@
   })
 
   function go(route: Route): void {
+    // Android ticks the tab switch; iOS Safari has no vibrate API and skips it.
+    if ('vibrate' in navigator) navigator.vibrate?.(5)
     // Save before changing the hash. WebKit may reset the scroller as it
     // updates history, which is too late for the async panel swap to read it.
     if (displayedRoute && scrollPane) {
@@ -638,6 +674,8 @@
     />
   {/if}
 
+  {#if hasHome && !recovering && ChargingNotice}<ChargingNotice {site} />{/if}
+
   <main bind:this={scrollPane}>
     <div class="pull-refresh" data-state="idle" aria-hidden="true" bind:this={pullIndicator}>
       <svg viewBox="0 0 24 24" aria-hidden="true">
@@ -649,8 +687,13 @@
     {#if (resolvingSite || restoringHome) && !pairingFragment}
       <!-- A local read, so this is a frame or two. Deliberately quiet: it is
            not a spinner for a network call, it is the app checking what it
-           already knows. -->
-      <section class="settling"></section>
+           already knows. Only if the read outlives the beat does one line
+           appear — a blank pane must never be mistaken for a frozen one. -->
+      <section class="settling">
+        {#if settlingSlow}
+          <p class="settling-note">Opening your home</p>
+        {/if}
+      </section>
     {:else if needsPairing || pairingFragment || recovering}
       <!-- `problem` is what this phone cannot do, and it decides which ways in
            the screen offers. Null unless a carrier could not be built at all,
@@ -670,7 +713,7 @@
            leave the shell with nothing to paint. Each tab also gets its own
            saved scroll position. A view that has never been requested is not
            built; `seen` pays that cost once and keeps its state after. -->
-      <div class="view" hidden={displayedRoute !== 'now'}>
+      <div class="view" data-dir={viewDir} hidden={displayedRoute !== 'now'}>
         <Now
           {site}
           active={displayedRoute === 'now'}
@@ -680,7 +723,7 @@
       </div>
 
       {#if seen.plan}
-        <div class="view" hidden={displayedRoute !== 'plan'}>
+        <div class="view" data-dir={viewDir} hidden={displayedRoute !== 'plan'}>
           <Plan {site} />
         </div>
       {/if}
@@ -688,7 +731,7 @@
       {#if seen.history}
         <!-- Loaded on demand: the chart, its canvas and the tile cache must
              not sit on the path to the first frame of the app. -->
-        <div class="view" hidden={displayedRoute !== 'history'}>
+        <div class="view" data-dir={viewDir} hidden={displayedRoute !== 'history'}>
           {#if HistoryView}
             <HistoryView {site} active={displayedRoute === 'history'} />
           {:else if viewLoadError.history}
@@ -702,7 +745,7 @@
       {#if seen.box}
         <!-- Opened by hand a handful of times in the life of an install, so it
              is loaded when someone asks for it and never before. -->
-        <div class="view" hidden={displayedRoute !== 'box'}>
+        <div class="view" data-dir={viewDir} hidden={displayedRoute !== 'box'}>
           {#if demoActive && DemoBoxView}
             <DemoBoxView {site} onExit={exitDemo} />
           {:else if BoxView}
@@ -764,7 +807,7 @@
 
 <style>
   .demo-band {
-    z-index: 5;
+    z-index: var(--z-band);
     display: flex;
     align-items: center;
     gap: var(--space-2);
@@ -801,6 +844,15 @@
     min-height: 60vh;
   }
 
+  /* The settling pane's one word, shown only when opening outlives the beat.
+     Same grammar as Now's .note: mono, small, saying what is happening. */
+  .settling-note {
+    padding: var(--space-7) var(--space-4) 0;
+    font-family: var(--mono);
+    font-size: 11px;
+    color: var(--fg-muted);
+  }
+
   /* A view whose code never arrived. Quiet prose where the screen would be,
      because a blank panel under a working tab bar reads as a broken app. */
   .load-note {
@@ -816,15 +868,50 @@
     display: none;
   }
 
+  /* A tab switch slides the incoming panel in from the direction of travel.
+     Leaving display:none restarts the animation, so only the panel coming in
+     moves and the three hidden ones cost nothing. Reduced motion is already
+     covered globally: --motion-base collapses to 1ms in tokens.css, which
+     turns this into a plain swap with no per-rule override needed. */
+  .view {
+    animation: view-fwd var(--motion-base) var(--ease);
+  }
+
+  .view[data-dir='back'] {
+    animation-name: view-back;
+  }
+
+  @keyframes view-fwd {
+    from {
+      opacity: 0;
+      transform: translateX(14px);
+    }
+  }
+
+  @keyframes view-back {
+    from {
+      opacity: 0;
+      transform: translateX(-14px);
+    }
+  }
+
   /* The shell is exactly one screen, and the view inside it scrolls — the
      tab bar stays put and `main` scrolls inside itself.
 
      Anchored with `position: fixed; inset: 0`, not a dynamic viewport unit.
      The insets live here: the top padding reserves the notch, the tab bar
-     reserves the home indicator, and <body> only paints the backstop. */
+     reserves the home indicator, and <body> only paints the backstop.
+
+     This is a phone-shaped app. On a tablet or desktop the shell keeps that
+     shape as one centred column — both insets pin the box and the auto
+     margins split what is left of the 34rem cap. Everything inside inherits
+     the cap, so the band above main and the tab bar below it need no rule
+     of their own; body paints the same surface behind the margins. */
   .app {
     position: fixed;
     inset: 0;
+    max-width: 34rem;
+    margin-inline: auto;
     display: flex;
     flex-direction: column;
     padding: env(safe-area-inset-top) env(safe-area-inset-right) 0 env(safe-area-inset-left);
diff --git a/src/App.svelte.test.ts b/src/App.svelte.test.ts
index e39c1bc..0f71542 100644
--- a/src/App.svelte.test.ts
+++ b/src/App.svelte.test.ts
@@ -474,6 +474,92 @@ describe('signing out, from the phone', () => {
   })
 })
 
+/* Tab transitions and the settling pane, both shell-level behaviours whose
+ * pieces live in several files and can only be judged where they meet. */
+describe('tab transitions', () => {
+  beforeEach(async () => {
+    vi.stubGlobal('localStorage', stubStorage())
+    history.replaceState(null, '', '/')
+    location.hash = ''
+    const database = await db()
+    for (const store of ['sites', 'snapshot', 'tiles', 'meta', 'keys'] as const) {
+      await database.clear(store)
+    }
+    await pairPhone(SITE_ID)
+  })
+
+  afterEach(() => {
+    globalThis.ftwSim?.stop()
+    cleanup()
+    vi.restoreAllMocks()
+  })
+
+  it('slides down the bar forward and up it backward', async () => {
+    await houseOnScreen()
+    /** Direction stamped on whichever panel is currently showing. */
+    const dir = () =>
+      [...document.querySelectorAll<HTMLElement>('.view')]
+        .find((view) => !view.hidden)
+        ?.getAttribute('data-dir')
+
+    ;(await screen.findByRole('button', { name: /^plan$/i })).click()
+    // Wait for the swap itself, not just the attribute: the outgoing panel
+    // still carries the direction it arrived with.
+    await screen.findByText(/How your home is run/i, undefined, { timeout: 4_000 })
+    expect(dir()).toBe('fwd')
+
+    ;(await screen.findByRole('button', { name: /^history$/i })).click()
+    await screen.findByText(/Last 7 days/i, undefined, { timeout: 4_000 })
+    expect(dir()).toBe('fwd')
+
+    ;(await screen.findByRole('button', { name: /^now$/i })).click()
+    // Backwards is the one case the old panel cannot fake: it left pointing
+    // the other way, so this waits for the incoming panel.
+    await vi.waitFor(() => expect(dir()).toBe('back'), { timeout: 4_000 })
+  })
+})
+
+describe('the settling pane', () => {
+  beforeEach(async () => {
+    vi.stubGlobal('localStorage', stubStorage())
+    history.replaceState(null, '', '/')
+    location.hash = ''
+    const database = await db()
+    for (const store of ['sites', 'snapshot', 'tiles', 'meta', 'keys'] as const) {
+      await database.clear(store)
+    }
+  })
+
+  afterEach(() => {
+    cleanup()
+    vi.useRealTimers()
+    vi.restoreAllMocks()
+  })
+
+  it('stays quiet for a quick open, says so when it outlives a beat, then stops', async () => {
+    // Opening held open past any honest frame count: the slowest case the
+    // pane can be honest about is still a local read, so the store's start
+    // is gated rather than pointed at a network.
+    let release!: () => void
+    const gate = new Promise<void>((done) => (release = done))
+    vi.spyOn(SiteStore.prototype, 'start').mockImplementation(() => gate)
+    localStorage.setItem('ftw.site', 'slow-home')
+
+    vi.useFakeTimers()
+    render(App)
+
+    await vi.advanceTimersByTimeAsync(699)
+    expect(screen.queryByText(/opening your home/i)).toBeNull()
+
+    await vi.advanceTimersByTimeAsync(1)
+    expect(screen.getByText(/opening your home/i)).toBeTruthy()
+
+    release()
+    await vi.advanceTimersByTimeAsync(0)
+    expect(screen.queryByText(/opening your home/i)).toBeNull()
+  })
+})
+
 /* The state this whole screen was built for, and the one it used to get wrong.
  *
  * A phone that is paired, cannot reach its box and has nothing cached. Not a
diff --git a/src/lib/format/command.ts b/src/lib/format/command.ts
index f298b2c..3a28bde 100644
--- a/src/lib/format/command.ts
+++ b/src/lib/format/command.ts
@@ -22,6 +22,7 @@ export function commandHelp(result: CmdResult): string {
     case 'E_BOOTING':
       return 'Your box is still starting. Give it a minute.'
     case 'E_UNAVAILABLE':
+      if (result.error.args?.['op'] === 'loadpoint.surplus_only.set') return 'Solar rule not saved. Your previous choice is unchanged. Try again.'
       return "Your box can't reach the charger right now. Try again shortly."
     default:
       return "That didn't go through. Try again."
@@ -48,3 +49,19 @@ export function boostHelp(result: CmdResult): string {
   }
   return commandHelp(result)
 }
+
+/**
+ * The level correction's own refusal, before the door's.
+ *
+ * The box refuses a level for a car that is not on the cable with
+ * E_UNAVAILABLE naming the op and `reason: "unplugged"` — the session's
+ * spelling of the HTTP route's 409. That is not the charger being out of
+ * reach, so it gets its own sentence and everything else falls through.
+ */
+export function socHelp(result: CmdResult): string {
+  const e = result.error
+  if (e?.code === 'E_UNAVAILABLE' && e.args?.['reason'] === 'unplugged') {
+    return 'Plug the car in first — your box has no car to set a level for.'
+  }
+  return commandHelp(result)
+}
diff --git a/src/lib/format/ev.test.ts b/src/lib/format/ev.test.ts
index 3f71fd0..021a7d6 100644
--- a/src/lib/format/ev.test.ts
+++ b/src/lib/format/ev.test.ts
@@ -5,6 +5,7 @@ import { describe, it, expect } from 'vitest'
 import {
   toLoadpoint,
   evStatusSentence,
+  evPlanSentence,
   evScheduleSentence,
   evSessionSentence,
   localClock,
@@ -17,6 +18,7 @@ import {
   currentReadout,
   boostActiveSentence,
   boostStoppedSentence,
+  socSourceSentence,
   type WireLoadpoint,
 } from './ev'
 
@@ -45,7 +47,7 @@ describe('a charger described in words', () => {
   })
 
   it('does not call a plugged, resting charger anything but resting', () => {
-    const s = evStatusSentence(toLoadpoint({ ...WIRE, current_power_w: 0 }))
+    const s = evStatusSentence(toLoadpoint({ ...WIRE, current_power_w: 4.39 }))
     expect(s).toMatch(/not charging/i)
     expect(s).not.toMatch(/\d/)
   })
@@ -59,16 +61,30 @@ describe('a charger described in words', () => {
     expect(s).toContain('every day')
   })
 
-  it('claims no target percentage when the charger cannot measure charge', () => {
-    // soc_source none: the box knows the goal but not the distance to it.
-    // "84 % ready by 07:00" reads as a measurement, so the percent stays off.
+  it('shows the saved target even when the current battery level is unknown', () => {
     const s = evScheduleSentence(toLoadpoint(WIRE))
-    expect(s).not.toContain('%')
+    expect(s).toContain('84 %')
   })
 
-  it('shows the percent when the charge is really known', () => {
-    const s = evScheduleSentence(toLoadpoint({ ...WIRE, current_soc_pct: 25.0057 }))
+  it('keeps the saved goal percentage visible while the car is unplugged', () => {
+    const s = evScheduleSentence(toLoadpoint({ ...WIRE, plugged_in: false }))
     expect(s).toContain('84 %')
+    expect(s).toContain(`Ready by ${localClock(360)}`)
+  })
+
+  it('reports a replan without claiming a save or changing the actual charge status', () => {
+    const lp = toLoadpoint({ ...WIRE, plan_pending: true, plan_next_start_ms: Date.now(), plan_next_end_ms: Date.now() + 60_000 })
+    expect(evPlanSentence(lp)).toBe('Updating the charging plan…')
+    expect(evStatusSentence(lp)).toBe('Charging at 8.6 kW')
+    expect(evPlanSentence({ ...lp, manualActive: true })).toBe('Updating the charging plan…')
+    expect(evPlanSentence({ ...lp, planPending: false, planOutdated: true })).toBe('Charging times are unavailable. Your settings are saved.')
+  })
+
+  it('shows the percent when the charge is really known', () => {
+    // The box serves a fraction; an older one served a percent. Either is a
+    // level the box knows, and the sentence says so for both.
+    expect(evScheduleSentence(toLoadpoint({ ...WIRE, current_soc: 0.250057 }))).toContain('84 %')
+    expect(evScheduleSentence(toLoadpoint({ ...WIRE, current_soc_pct: 25.0057 }))).toContain('84 %')
   })
 
   it('says nothing at all about a schedule it has not read', () => {
@@ -119,6 +135,36 @@ describe('a charger described in words', () => {
   })
 })
 
+describe("the car's level, in words", () => {
+  it('reads the fraction off the wire in whole percent, and where it came from', () => {
+    const lp = toLoadpoint({ ...WIRE, current_soc: 0.6049, soc_source: 'inferred' })
+    expect(lp.socPct).toBe(60)
+    expect(lp.socSource).toBe('inferred')
+  })
+
+  it('reads a level an older box wrote as a percent', () => {
+    expect(toLoadpoint({ ...WIRE, current_soc_pct: 60 }).socPct).toBe(60)
+  })
+
+  it('knows no level for an empty bay', () => {
+    // The box's zero values: a zero fraction and no source at all.
+    const lp = toLoadpoint({ ...WIRE, plugged_in: false, current_soc: 0, soc_source: undefined })
+    expect(lp.socPct).toBeNull()
+    expect(lp.socSource).toBe('')
+  })
+
+  it("says where the level came from, in the box page's words", () => {
+    const from = (soc_source: string) => socSourceSentence(toLoadpoint({ ...WIRE, soc_source }))
+    expect(from('vehicle')).toBe('Reported by the car. Drag only to correct drift.')
+    expect(from('completed')).toMatch(/actual battery level is not confirmed/)
+    expect(from('assumed')).toMatch(/Battery level needs confirmation.*entered again after a box restart/);
+    expect(from('inferred')).toMatch(/^Estimated from energy delivered/)
+    // A source this app has not heard of reads as the estimate, which is
+    // the box's own fallback.
+    expect(from('something_new')).toMatch(/^Estimated from energy delivered/)
+  })
+})
+
 describe('the current a hold may ask for', () => {
   /** What a real box serves beside the fixture: a three-phase 16 A wallbox. */
   const RANGE: WireLoadpoint = {
@@ -246,3 +292,64 @@ describe('the boost, in words', () => {
     expect(boostStoppedSentence(toLoadpoint(WIRE))).toBeNull()
   })
 })
+
+describe('current core fields and charger feedback', () => {
+  it('reads the fraction schema, including a plugged car at zero percent', () => {
+    const lp = toLoadpoint({ ...WIRE, current_soc: 0, target_soc: 0.8, target_soc_pct: undefined, schedule: { soc: 0.8, time_of_day_min_utc: 360 } })
+    expect(lp.socPct).toBe(0)
+    expect(lp.targetSocPct).toBe(80)
+    expect(lp.schedule?.socPct).toBe(80)
+    expect(toLoadpoint({ ...WIRE, schedule: { soc: 0, time_of_day_min_utc: 0 } }).schedule).toBeNull()
+  })
+  it('does not call a core acknowledgement charging at zero power', () => {
+    const lp = toLoadpoint({ ...WIRE, current_power_w: 0, manual_active: true, manual: { active: true, state: 'accepted', requested_a: 16, commanded_a: 16 } })
+    expect(evStatusSentence(lp)).toMatch(/Charger reports a 16 A limit/)
+    expect(evStatusSentence(lp)).not.toMatch(/Charging at/)
+  })
+  it('marks old positive power as unknown in both manual and planned charging', () => {
+    for (const manual_active of [true, false]) {
+      const lp = toLoadpoint({ ...WIRE, manual_active, charger: { known: true, available: false } })
+      expect(evStatusSentence(lp)).toMatch(/out of date/)
+      expect(evStatusSentence(lp)).not.toMatch(/Charging at/)
+    }
+  })
+})
+
+
+describe('a retained level and a car that declines charge', () => {
+  it('does not call a declined charge full or a reached target', () => {
+    const lp = toLoadpoint({ id: 'car', plugged_in: true, charging_declined: true, current_soc: 0.37 })
+    expect(evStatusSentence(lp)).toContain('does not confirm the battery is full')
+    expect(lp.socPct).toBe(37)
+  })
+  it('uses the reported retention, including a failed disk save', () => {
+    const lp = toLoadpoint({ plugged_in: true, current_soc: 0.12, soc_source: 'inferred', soc_retention: 'session' })
+    expect(socSourceSentence(lp)).toContain('same charging session')
+    expect(socSourceSentence({ ...lp, socRetention: 'error' })).toContain('could not be saved')
+    expect(socSourceSentence({ ...lp, socRetention: 'unavailable' })).toContain('entered again after a box restart')
+  })
+})
+
+
+it('a charger limit is not described as a main-fuse limit', () => {
+  const lp = toLoadpoint({ plugged_in: true, manual_active: true, manual: { state: 'limited', requested_a: 16, commanded_a: 10, limit_reason: 'charger_limit' } })
+  expect(evStatusSentence(lp)).toContain('The charger limits this request to 10 A (16 A requested)')
+  expect(evStatusSentence(lp)).not.toContain('Main fuse')
+})
+
+
+it('asks for a new choice when the charger or connection is unconfirmed', () => {
+  const lp = toLoadpoint({ plugged_in: true, manual_active: false, manual_restore_unconfirmed: true })
+  expect(evStatusSentence(lp)).toContain('Confirm how to continue charging')
+  expect(evStatusSentence(lp)).toContain('could not confirm the charger or connection')
+  expect(evStatusSentence(lp)).not.toMatch(/after restart|[Pp]aused|stopped/)
+  expect(evStatusSentence(lp)).not.toContain('Paused by you')
+  expect(evStatusSentence(lp, false)).toContain('An owner needs to confirm how charging should continue')
+  expect(evStatusSentence(lp, false)).not.toContain('after restart')
+})
+it('keeps the old power visible until a lower current request is confirmed', () => {
+  const lp = toLoadpoint({ plugged_in: true, current_power_w: 11000, manual_active: true, manual: { state: 'sent', requested_a: 6 } })
+  expect(evStatusSentence(lp)).toContain('Waiting for the charger to confirm the new limit')
+  expect(evStatusSentence(lp)).toContain('Still charging at 11 kW')
+  expect(evStatusSentence({ ...lp, manual: { state: 'stalled', requested_a: 6 } })).toContain('Still charging at 11 kW')
+})
diff --git a/src/lib/format/ev.ts b/src/lib/format/ev.ts
index 0262f96..55ae0b9 100644
--- a/src/lib/format/ev.ts
+++ b/src/lib/format/ev.ts
@@ -17,16 +17,36 @@ export interface WireLoadpoint {
   id?: unknown
   driver_name?: unknown
   plugged_in?: unknown
+  vehicle_capacity_wh?: unknown
+  capacity_source?: unknown
+  soc_retention?: unknown
+  charging_declined?: unknown
+  /** A 0–1 fraction since srcfl/ftw#962; `current_soc_pct` is what older boxes served. */
+  current_soc?: unknown
   current_soc_pct?: unknown
   current_power_w?: unknown
   delivered_wh_session?: unknown
+  target_soc?: unknown
   target_soc_pct?: unknown
+  manual?: WireManualStatus
+  charger?: { known?: unknown; available?: unknown; updated_at_ms?: unknown; reason?: unknown; limit_a?: unknown }
+  grid_deferred?: unknown
+  plan_next_start_ms?: unknown
+  plan_next_end_ms?: unknown
+  plan_pending?: unknown
+  plan_outdated?: unknown
+  plan_windows?: unknown
   updated_at_ms?: unknown
   soc_source?: unknown
   min_charge_w?: unknown
   max_charge_w?: unknown
   phases?: unknown
   voltage_v?: unknown
+  commanded_w?: unknown
+  commanded_reason?: unknown
+  commanded_known?: unknown
+  manual_save_error?: unknown
+  manual_restore_unconfirmed?: unknown
   manual_active?: unknown
   manual_charge_w?: unknown
   surplus_only?: unknown
@@ -39,13 +59,27 @@ export interface WireLoadpoint {
     stopped_at_ms?: unknown
   }
   schedule?: {
+    soc?: unknown
     soc_pct?: unknown
     time_of_day_min_utc?: unknown
+    surplus_unlock_bat_soc?: unknown
     recurring?: unknown
     days?: unknown
   } | null
 }
 
+export interface WireManualStatus {
+  active?: unknown
+  state?: unknown
+  requested_a?: unknown
+  requested_w?: unknown
+  commanded_a?: unknown
+  charger_reason?: unknown
+  limit_reason?: unknown
+  since_ms?: unknown
+  charger_updated_at_ms?: unknown
+}
+
 export interface Loadpoint {
   id: string
   /** Whether a cable is in. False means the rest is about an empty bay. */
@@ -54,6 +88,16 @@ export interface Loadpoint {
   powerW: number
   /** The car's charge, or null for a charger that honestly does not know. */
   socPct: number | null
+  /**
+   * Where that level came from, in the box's own token: `vehicle` from the
+   * car, `inferred` from energy delivered, `assumed` until confirmed.
+   * Older boxes may still send `completed`; that is never a BMS reading.
+   */
+  socSource: string
+  vehicleCapacityWh?: number | null
+  capacitySource?: string
+  socRetention?: string
+  chargingDeclined?: boolean
   targetSocPct: number | null
   /** What this session has delivered, in watt-hours. */
   sessionWh: number
@@ -63,7 +107,20 @@ export interface Loadpoint {
   /** Phase count and phase voltage, for the amp slider. Null when the box did not say. */
   phases: number | null
   voltageV: number | null
+  manualSaveError?: boolean
+  manualRestoreUnconfirmed?: boolean
   manualActive: boolean
+  manual?: WireManualStatus
+  charger?: WireLoadpoint['charger']
+  commandedW?: number | null
+  commandedReason?: string
+  commandedKnown?: boolean
+  updatedAtMs?: number | null
+  gridDeferred?: boolean
+  planStartMs?: number | null
+  planEndMs?: number | null
+  planPending?: boolean
+  planOutdated?: boolean
   /** What the running hold asks for, in watts. Null when there is none, or the box did not say. */
   manualChargeW: number | null
   surplusOnly: boolean
@@ -77,6 +134,7 @@ export interface Loadpoint {
   schedule: {
     socPct: number | null
     timeOfDayMinUtc: number
+    surplusUnlockPct?: number
     recurring: boolean
     /** 7-bit weekday mask, bit 0 = Monday. Zero means every day. */
     days: number
@@ -102,19 +160,40 @@ const pct = (v: unknown): number | null => {
 export function toLoadpoint(w: WireLoadpoint): Loadpoint {
   const sched = w.schedule
   const schedMin = sched ? num(sched.time_of_day_min_utc) : null
+  const schedPct = pct(sched?.soc) ?? num(sched?.soc_pct)
+  const socFraction = num(w.current_soc)
   const boost = w.battery_boost
   return {
     id: typeof w.id === 'string' ? w.id : '',
     pluggedIn: w.plugged_in === true,
     powerW: num(w.current_power_w) ?? 0,
-    socPct: num(w.current_soc_pct),
-    targetSocPct: num(w.target_soc_pct),
+    socPct: w.plugged_in === false ? null : socFraction !== null && socFraction >= 0 && socFraction <= 1
+      ? Math.round(socFraction * 100) : num(w.current_soc_pct),
+    socSource: typeof w.soc_source === 'string' ? w.soc_source : '',
+    vehicleCapacityWh: num(w.vehicle_capacity_wh),
+    capacitySource: typeof w.capacity_source === 'string' ? w.capacity_source : '',
+    socRetention: typeof w.soc_retention === 'string' ? w.soc_retention : '',
+    chargingDeclined: w.charging_declined === true,
+    targetSocPct: pct(w.target_soc) ?? num(w.target_soc_pct),
     sessionWh: Math.max(0, Math.round(num(w.delivered_wh_session) ?? 0)),
     minChargeW: num(w.min_charge_w),
     maxChargeW: num(w.max_charge_w),
     phases: num(w.phases),
     voltageV: num(w.voltage_v),
     manualActive: w.manual_active === true,
+    manualRestoreUnconfirmed: w.manual_restore_unconfirmed === true,
+    manualSaveError: w.manual_save_error === true,
+    ...(w.manual ? { manual: w.manual } : {}),
+    ...(w.charger ? { charger: w.charger } : {}),
+    commandedW: num(w.commanded_w),
+    commandedReason: typeof w.commanded_reason === 'string' ? w.commanded_reason : '',
+    commandedKnown: w.commanded_known === true,
+    updatedAtMs: num(w.updated_at_ms),
+    gridDeferred: w.grid_deferred === true,
+    planStartMs: num(w.plan_next_start_ms),
+    planEndMs: num(w.plan_next_end_ms),
+    planPending: w.plan_pending === true,
+    planOutdated: w.plan_outdated === true,
     manualChargeW: w.manual_active === true ? num(w.manual_charge_w) : null,
     surplusOnly: w.surplus_only === true,
     boostActive: boost?.active === true,
@@ -125,12 +204,13 @@ export function toLoadpoint(w: WireLoadpoint): Loadpoint {
         ? boost.stop_reason
         : null,
     schedule:
-      schedMin === null
+      schedMin === null || schedPct === null || schedPct <= 0
         ? null
         : {
-            socPct: num(sched!.soc_pct),
+            socPct: schedPct,
             timeOfDayMinUtc: schedMin,
             recurring: sched!.recurring === true,
+            surplusUnlockPct: typeof sched!.surplus_unlock_bat_soc === 'number' ? sched!.surplus_unlock_bat_soc * 100 : 0,
             days: (num(sched!.days) ?? 0) & 0x7f,
           },
   }
@@ -188,6 +268,8 @@ export function daysWord(mask: number): string {
   return DAY_LABELS.filter((_, i) => m & (1 << i)).join(', ')
 }
 
+export const MANUAL_SAVE_ERROR_TEXT = 'This choice is active now, but could not be saved for restart. FTW is retrying.'
+
 /**
  * The headline: what the charger is doing at this moment.
  *
@@ -195,20 +277,83 @@ export function daysWord(mask: number): string {
  * fact someone opens this panel for. The idle cases say what is true about
  * the bay, never what might happen later — the schedule line owns later.
  */
-export function evStatusSentence(lp: Loadpoint): string {
+export function evStatusSentence(lp: Loadpoint, canControl = true): string {
+  if (lp.manualRestoreUnconfirmed) return (canControl ? 'Confirm how to continue charging.' : 'An owner needs to confirm how charging should continue.') + ' FTW could not confirm the charger or connection.'
+
+  if (lp.charger && lp.charger.available !== true) return lp.charger.known ? 'Charger status is out of date. FTW cannot confirm whether the car is charging.' : 'Waiting for the charger’s first status report.'
   if (!lp.pluggedIn) return 'Not plugged in'
-  if (lp.powerW > 0) {
+  if (lp.manualActive) return manualStatusSentence(lp)
+  if (lp.powerW >= 100) {
     const p = formatPower(lp.powerW)
     return `Charging at ${p.text} ${p.unit}`
   }
+  if (lp.chargingDeclined) return 'The car stopped asking for charge. Check its charge limit or schedule. This does not confirm the battery is full.'
+  if (lp.commandedKnown && lp.commandedReason === 'site_meter_stale') return 'Paused for safety: house power readings are out of date. Charging resumes when readings return.'
+  if (lp.commandedKnown && lp.commandedW === 0 && ['fuse_cooldown', 'fuse_limit'].includes(lp.commandedReason ?? '')) return 'Paused: main-fuse protection. Charging resumes on its own.'
+  if (lp.commandedKnown && (lp.commandedW ?? 0) > 0) return `FTW requests ${formatPower(lp.commandedW!).text} ${formatPower(lp.commandedW!).unit}. Waiting for the car to draw power.` + (lp.charger?.reason ? ` Charger reports: ${String(lp.charger.reason)}.` : '')
   return 'Plugged in — not charging right now'
 }
 
+/** A zero hold is a pause; older boxes omit their zero setpoint. */
+export function isPaused(lp: Loadpoint): boolean {
+  return !lp.manualRestoreUnconfirmed && lp.manualActive && (lp.manualChargeW === 0 || lp.manual?.state === 'paused' || lp.manual?.state === 'pausing' || (lp.manualChargeW === null && (lp.manual?.requested_w === 0 || lp.manual?.requested_a === 0)))
+}
+
+/** The hold is intent; only a fresh charger reading proves charging. */
+export function manualStatusSentence(lp: Loadpoint): string {
+  const m = lp.manual
+  const reqA = num(m?.requested_a)
+  const cmdA = num(m?.commanded_a)
+  const request = reqA !== null ? `${Math.round(reqA)} A` : 'your charge request'
+  const limit = cmdA !== null ? `${Math.round(cmdA)} A` : 'the requested current'
+  const reason = typeof m?.charger_reason === 'string' && m.charger_reason
+    ? ` Charger reports: ${m.charger_reason}.` : ''
+  if (m?.state === 'unavailable') return 'Charger status is out of date. FTW cannot confirm whether the car is charging.'
+  switch (m?.state) {
+    case 'pausing': return 'Pause requested. ' + (lp.powerW >= 100 ? `${formatPower(lp.powerW).text} ${formatPower(lp.powerW).unit} is still flowing. ` : '') + 'Waiting for the charger to stop.'
+    case 'paused': return 'Paused by you. Charging stays off until you resume the plan, choose Charge now, or unplug.'
+    case 'charging': {
+      const p = formatPower(lp.powerW)
+      return lp.powerW > 0 ? `Charging at ${p.text} ${p.unit}. ${request} requested.` : 'The charger reports charging. Waiting for a power reading.'
+    }
+    case 'sent': return `FTW received ${request}. Waiting for the charger to confirm the new limit.` + (lp.powerW >= 100 ? ` Still charging at ${formatPower(lp.powerW).text} ${formatPower(lp.powerW).unit}.` : '')
+    case 'accepted': return `Charger reports a ${limit} limit. Waiting for the car to start drawing…${reason}`
+    case 'not_drawing': return `Charger offers ${limit} but the car is not drawing.${reason || ' Check the car’s charge limit or schedule.'}`
+    case 'stalled': return isPaused(lp) ? 'The charger has not stopped after your pause request. Check the charger’s app.' : `The charger has not acted on ${request}.` + (lp.powerW >= 100 ? ` Still charging at ${formatPower(lp.powerW).text} ${formatPower(lp.powerW).unit}.` : '') + (reason || ' Check the charger and the car’s charge limit or schedule.')
+    case 'limited':
+      if (m.limit_reason === 'charger_limit') return `The charger limits this request to ${limit} (${request} requested).`
+      if (m.limit_reason === 'site_meter_stale') return 'Paused for safety: house power readings are out of date. Charging resumes when readings return.'
+      if (m.limit_reason === 'fuse_cooldown') return 'Paused: main-fuse protection. Charging resumes on its own.'
+      return `Main fuse limits this charge to ${limit} right now (${request} requested).`
+    default:
+      if (lp.powerW >= 100) {
+        const p = formatPower(lp.powerW)
+        return `Charging at ${p.text} ${p.unit}`
+      }
+      return 'Manual charge requested. Waiting for charger status.'
+  }
+}
+
+export function evPlanSentence(lp: Loadpoint, now = Date.now(), canControl = true): string | null {
+  if (lp.planPending) return 'Updating the charging plan…'
+  if (lp.planOutdated) return 'Charging times are unavailable. Your settings are saved.'
+  if (!lp.pluggedIn || lp.manualActive || lp.manualRestoreUnconfirmed || lp.chargingDeclined || (lp.charger && lp.charger.available !== true)) return null
+  if (lp.gridDeferred && lp.schedule) return 'Waiting for tomorrow’s electricity prices. Solar surplus can charge the car meanwhile.'
+  if (lp.planStartMs && lp.planEndMs && lp.planEndMs > now) {
+    const clock = (t: number) => new Date(t).toLocaleTimeString(undefined, { hour: '2-digit', minute: '2-digit' })
+    return `Charging planned ${clock(lp.planStartMs)}–${clock(lp.planEndMs)}.`
+  }
+  if (lp.surplusOnly) return 'Solar only: charging waits for spare solar power.'
+  if (!lp.schedule && lp.powerW < 100) return canControl ? 'No charging plan yet. Set a ready time, or choose Charge now.' : 'No charging plan yet. Ask an owner to set a ready time or start charging.'
+  if (lp.schedule && lp.powerW < 100) return canControl ? 'No charge window yet for this goal. Choose Charge now if you need to charge immediately.' : 'No charge window yet for this goal. An owner can start charging now.'
+  return null
+}
+
 /**
  * The schedule, as one sentence.
  *
- * "Ready by 07:00 · weekdays", with the target charge in front when the
- * charger can measure it. A schedule the box does not have is null here and
+ * "85 % Ready by 07:00 · weekdays" names the saved goal, even when the
+ * current battery level is unknown. A schedule the box does not have is null here and
  * no sentence at all — the panel says nothing rather than "no schedule",
  * because an app that cannot read one cannot claim its absence.
  */
@@ -217,7 +362,7 @@ export function evScheduleSentence(lp: Loadpoint, at: Date = new Date()): string
   if (!s) return null
   const when = localClock(s.timeOfDayMinUtc, at)
   const cadence = s.recurring ? daysWord(s.days) : 'once'
-  const target = s.socPct !== null && lp.socPct !== null ? `${Math.round(s.socPct)} % ` : ''
+  const target = s.socPct !== null ? `${Math.round(s.socPct)} % ` : ''
   return `${target}Ready by ${when} · ${cadence}`
 }
 
@@ -229,6 +374,40 @@ export function evSessionSentence(lp: Loadpoint): string | null {
   return `${text} kWh this session`
 }
 
+// --------------------------------------------------------------------------
+// The car's charge level
+// --------------------------------------------------------------------------
+
+/**
+ * Where the slider rests when the box has no level for the car — the box
+ * page's own default, so both surfaces start from the same place.
+ */
+export const SOC_DEFAULT_PCT = 50
+
+/**
+ * Where the level came from, as the box's own page says it.
+ *
+ * The token is the box's; every word is the app's. A source the app has not
+ * heard of reads as the estimate, which is what the box falls back to.
+ */
+export function socSourceSentence(lp: Loadpoint): string {
+  const retention = lp.socRetention === 'session'
+    ? ' FTW keeps this level for the same charging session, including after a box restart.'
+    : lp.socRetention === 'error'
+      ? ' This level could not be saved for a box restart. Enter it again before relying on the plan after restarting.'
+      : ' This level must be entered again after a box restart.'
+  switch (lp.socSource) {
+    case 'assumed':
+      return `Battery level needs confirmation. The plan currently assumes ${lp.socPct ?? SOC_DEFAULT_PCT} %. Drag to match the car.` + retention
+    case 'vehicle':
+      return 'Reported by the car. Drag only to correct drift.'
+    case 'completed':
+      return 'The car stopped asking for charge. Its actual battery level is not confirmed. Drag to match the car.'
+    default:
+      return 'Estimated from energy delivered. Drag to the real value and the plan follows.' + retention
+  }
+}
+
 // --------------------------------------------------------------------------
 // Charge now, in amps
 // --------------------------------------------------------------------------
diff --git a/src/lib/notify/kinds.ts b/src/lib/notify/kinds.ts
index 1204f9b..5756c1e 100644
--- a/src/lib/notify/kinds.ts
+++ b/src/lib/notify/kinds.ts
@@ -9,6 +9,7 @@
  */
 
 export const KINDS = [
+  'charging.connected',
   'charging.session_complete',
   'charging.interrupted',
   'update.installed',
@@ -32,6 +33,7 @@ export const RULE_KINDS = KINDS.filter((k) => k !== 'box.unreachable')
  * writes the notification itself, this names the decision to receive it.
  */
 export const KIND_LABELS: Record<PushKind, string> = {
+  'charging.connected': 'When the car is plugged in',
   'charging.session_complete': 'When the car finishes charging',
   'charging.interrupted': 'If charging stops before it is done',
   'update.installed': 'When your box updates itself',
diff --git a/src/lib/protocol/session.ts b/src/lib/protocol/session.ts
index 76d694f..eccae3d 100644
--- a/src/lib/protocol/session.ts
+++ b/src/lib/protocol/session.ts
@@ -381,6 +381,7 @@ export class Session {
   #pendingCmd = new Map<string, PendingCmd>()
   /** The api queue's tail. Always settled-safe; see api(). */
   #apiTail: Promise<void> = Promise.resolve()
+  #apiGeneration = 0
   /** Set only while the box says it is starting. See BOOT_RETRY_MS. */
   #bootRetry: ReturnType<typeof setTimeout> | undefined
 
@@ -623,17 +624,41 @@ export class Session {
    * serves: a second in flight is answered "busy", which costs whichever view
    * lost the race a thirty-second backoff over a collision no view can see.
    * The queue is chained on settle, not success, so a call that fails hands
-   * the wire to the one behind it — and each call's deadline is armed when it
-   * dispatches, because a place in the queue is not time spent waiting on the
-   * box.
+   * the wire to the one behind it. Queue waits expire separately from wire
+   * silence, and a call never crosses a disconnect into a new session.
    */
   api(req: ApiReq): Promise<ApiResponse> {
-    const turn = this.#apiTail.then(() => this.#dispatchApi(req))
-    this.#apiTail = turn.then(
-      () => undefined,
-      () => undefined
-    )
-    return turn
+    const generation = this.#apiGeneration
+    return new Promise<ApiResponse>((resolve, reject) => {
+      let queued = true
+      const timer = setTimeout(() => {
+        queued = false
+        reject(new Error('api queue wait timed out'))
+      }, API_TIMEOUT_MS)
+      const turn = this.#apiTail.then(() => {
+        if (!queued) return
+        queued = false
+        clearTimeout(timer)
+        return this.#apiWithRetry(req, generation).then(resolve, reject)
+      })
+      this.#apiTail = turn.then(() => undefined, () => undefined)
+    })
+  }
+
+  async #apiWithRetry(req: ApiReq, generation: number): Promise<ApiResponse> {
+    for (let attempt = 0; ; attempt++) {
+      if (generation !== this.#apiGeneration) throw new Error('carrier closed')
+      try {
+        return await this.#dispatchApi(req)
+      } catch (err) {
+        // The box can send its last frame before releasing its API slot.
+        // Only this explicit refusal proves that no handler ran. Never retry
+        // a timeout, a lost answer, a handler failure or a step-up refusal.
+        if (!(err instanceof ApiError) || err.detail.code !== 'E_UNAVAILABLE' ||
+          err.detail.args?.['reason'] !== 'busy' || !err.detail.retryable || attempt >= 3) throw err
+        await new Promise(resolve => setTimeout(resolve, 250 * 2 ** attempt))
+      }
+    }
   }
 
   #dispatchApi(req: ApiReq): Promise<ApiResponse> {
@@ -1193,6 +1218,7 @@ export class Session {
    * later, on its own timer, against a view that has long since moved on.
    */
   #settlePending(): void {
+    this.#apiGeneration++
     for (const map of [
       this.#pendingHistory,
       this.#pendingPlan,
diff --git a/src/lib/pwa/service-worker.svelte.test.ts b/src/lib/pwa/service-worker.svelte.test.ts
index e48437a..e34fd6a 100644
--- a/src/lib/pwa/service-worker.svelte.test.ts
+++ b/src/lib/pwa/service-worker.svelte.test.ts
@@ -75,6 +75,24 @@ describe('checking for an app update', () => {
     expect(parked.postMessage).toHaveBeenCalledWith({ type: 'skip-waiting' })
   })
 
+  it('checks for an update at launch, not only when hidden first', async () => {
+    vi.stubEnv('PROD', true)
+    const update = vi.fn(async () => {})
+    installNavigator({
+      waiting: null,
+      installing: null,
+      update,
+      addEventListener: vi.fn(),
+    })
+    const { registerServiceWorker } = await import('./service-worker.svelte')
+
+    await registerServiceWorker()
+
+    // A page left in the foreground never fires visibilitychange; without
+    // this check it would never learn a new build exists.
+    expect(update).toHaveBeenCalledOnce()
+  })
+
   it('lands a build already waiting at launch', async () => {
     vi.stubEnv('PROD', true)
     const parked = worker()
@@ -102,6 +120,8 @@ describe('checking for an app update', () => {
     const listen = vi.spyOn(document, 'addEventListener')
     const { registerServiceWorker } = await import('./service-worker.svelte')
     await registerServiceWorker()
+    // The launch already checked; only the foreground return is under test.
+    update.mockClear()
 
     const visibilityListener = listen.mock.calls.find(([type]) => type === 'visibilitychange')?.[1]
     expect(visibilityListener).toBeTypeOf('function')
diff --git a/src/lib/pwa/service-worker.svelte.ts b/src/lib/pwa/service-worker.svelte.ts
index b0da258..55f0c8b 100644
--- a/src/lib/pwa/service-worker.svelte.ts
+++ b/src/lib/pwa/service-worker.svelte.ts
@@ -49,6 +49,12 @@ export async function registerServiceWorker(): Promise<void> {
     currentRegistration = registration
     armReload()
     watch(registration)
+
+    // A page kept in the foreground never hides, so visibilitychange never
+    // gives it a reason to look for a newer build — it would only learn of
+    // one at the next launch. Check once now; this already runs after `load`,
+    // so nothing moves onto the critical path.
+    void checkForAppUpdate()
   } catch {
     // No worker means no offline launch, and nothing else. Every other path in
     // the app already treats the network as optional, so there is no failure
diff --git a/src/lib/sim/api.ts b/src/lib/sim/api.ts
index 7dd2903..da7416f 100644
--- a/src/lib/sim/api.ts
+++ b/src/lib/sim/api.ts
@@ -45,6 +45,7 @@ const RULE_TYPES = [
   'update_available',
   'fuse_over_limit',
   'concurrent_drivers_offline',
+  'charging.connected',
   'charging.session_complete',
   'charging.interrupted',
   'update.installed',
@@ -125,6 +126,7 @@ const ROUTES: Record<string, RouteFacts> = {
   // stays actuation, because target also carries one-shot fields that move
   // energy now.
   'GET /api/loadpoints': { tier: 'read' },
+  'POST /api/loadpoints/{id}/vehicle': { tier: 'configure' },
   'PUT /api/loadpoints/{id}/schedule': { tier: 'configure' },
   'DELETE /api/loadpoints/{id}/schedule': { tier: 'configure' },
   'GET /api/mpc/plan': { tier: 'read' },
@@ -245,6 +247,9 @@ export interface SimApiOptions {
     boost: { expiresAtMs: number; minBatterySoc: number } | null
     /** The last stop's reason, kept until the next boost, as the box keeps it. */
     boostStop: { reason: string; atMs: number } | null
+    /** The car's level as the box holds it, a 0–1 fraction. */
+    soc: number
+    surplusOnly: boolean
   }
   /**
    * The live sample the 1 Hz stream is already sending. Status must describe
@@ -255,6 +260,18 @@ export interface SimApiOptions {
 
 const DAY_MS = 86_400_000
 
+/**
+ * Whether the simulated car is on the cable: from the evening commute until
+ * the morning departure, UTC. One rule for the loadpoints answer and for the
+ * door, so a level set for a car that is not there is refused the way the
+ * box refuses it.
+ */
+export function evPluggedIn(nowMs: number): boolean {
+  const d = new Date(nowMs)
+  const hourOfDay = d.getUTCHours() + d.getUTCMinutes() / 60
+  return hourOfDay >= 17 || hourOfDay < 7
+}
+
 /** The box's own word for a code somebody reads aloud, and its own TTL. */
 const appPairingKindSpoken = 'spoken'
 const PAIRING_TTL_MS = 10 * 60_000
@@ -289,6 +306,7 @@ function json(status: number, value: unknown): ApiAnswer {
 export class SimApi {
   #opts: SimApiOptions
   #devices: SimDevice[]
+  #vehicleCapacityWh = 60000
   #pairing: { code: string; role: Role; expiresAtMs: number } | null = null
   /**
    * The charger's standing instruction, mutable the way the box's is.
@@ -296,7 +314,7 @@ export class SimApi {
    * app must meet that as an absence rather than an empty object.
    */
   #schedule: Record<string, unknown> | null = {
-    soc_pct: 84,
+    soc: 0.84,
     time_of_day_min_utc: 360,
     recurring: true,
   }
@@ -488,6 +506,16 @@ export class SimApi {
     if (route === 'GET /api/savings/daily') return this.#savingsDaily(req.query)
     if (route === 'GET /api/loadpoints') return this.#loadpoints()
     if (route === 'GET /api/mpc/plan') return this.#mpcPlan()
+    if (route === 'POST /api/loadpoints/{id}/vehicle') {
+      if (matched.params['id'] !== 'carport') return json(404, { error: 'Unknown charger' })
+      let body: { capacity_wh?: unknown }
+      try { body = JSON.parse(new TextDecoder().decode(req.body ?? new Uint8Array())) }
+      catch { return json(400, { error: 'Enter a valid battery size' }) }
+      const capacity = body.capacity_wh
+      if (typeof capacity !== 'number' || !Number.isFinite(capacity) || capacity < 1000 || capacity > 300000) return json(400, { error: 'Enter a battery size from 1 to 300 kWh' })
+      this.#vehicleCapacityWh = capacity
+      return json(200, { ok: true, vehicle_capacity_wh: capacity, capacity_source: 'configured' })
+    }
     if (route === 'PUT /api/loadpoints/{id}/schedule') {
       return this.#putSchedule(matched.params['id'] ?? '', req.body)
     }
@@ -631,22 +659,29 @@ export class SimApi {
    *
    * Field names are the box's own: `loadpoint.State` marshals snake_case,
    * and an app built against camelCase here would render blanks against
-   * every real box while this tree stayed green. No `current_soc_pct` on
-   * purpose — an easee without a car API genuinely does not know it, and
-   * the honest absence is a case the panel has to carry.
+   * every real box while this tree stayed green. `current_soc` is a
+   * fraction and its source is `inferred`: an easee without a car API does
+   * not know the car's level, and the box estimates one from energy
+   * delivered rather than serving none — which is what its own page
+   * prefills the slider with, and what this app's panel must meet.
    */
   #loadpoints(): ApiAnswer {
     const now = this.#opts.now()
     const r = sample(this.#opts.house, now, 500, this.#opts.ceilingW)
     // What the door has done overrides what the generator would do — the
     // stream applies the same override, so both surfaces tell one story.
-    const door = this.#opts.loadpointState?.() ?? { holdW: null, boost: null, boostStop: null }
+    const door = this.#opts.loadpointState?.() ?? {
+      holdW: null,
+      boost: null,
+      boostStop: null,
+      soc: 0,
+      surplusOnly: false,
+    }
     const powerW = door.holdW ?? r.evW
     const d = new Date(now)
     const hourOfDay = d.getUTCHours() + d.getUTCMinutes() / 60
 
-    // Plugged in from the evening commute until the morning departure.
-    const pluggedIn = hourOfDay >= 17 || hourOfDay < 7
+    const pluggedIn = evPluggedIn(now)
 
     // What the session has delivered so far: the charging window is flat
     // ~7.2 kW, so the meter is minutes-into-window times that rate.
@@ -665,20 +700,24 @@ export class SimApi {
         {
           id: 'carport',
           driver_name: 'easee',
+          vehicle_capacity_wh: this.#vehicleCapacityWh,
+          capacity_source: 'configured',
           plugged_in: pluggedIn,
+          // The box's zero values for an empty bay; it omits an empty source.
+          current_soc: pluggedIn ? door.soc : 0,
+          ...(pluggedIn ? { soc_source: 'inferred' } : {}),
           current_power_w: powerW,
           delivered_wh_session: pluggedIn ? sessionWh : 0,
-          target_soc_pct: 84,
+          target_soc: typeof this.#schedule?.soc === 'number' ? this.#schedule.soc : 0,
           updated_at_ms: now,
-          soc_source: 'none',
           min_charge_w: 4140,
           max_charge_w: 11000,
           phases: 3,
           voltage_v: 230,
           manual_active: door.holdW !== null,
-          // `manual_charge_w` is omitempty on the box: absent for a 0 W
-          // pause hold, present with the setpoint for any other.
-          ...(door.holdW ? { manual_charge_w: door.holdW } : {}),
+          // Zero is a pause; the manual status still names it if a box omits zero watts.
+          ...(door.holdW !== null ? { manual_charge_w: door.holdW } : {}),
+          ...(door.holdW === 0 ? { manual: { active: true, state: 'paused', requested_a: 0 } } : {}),
           // The box's BatteryBoostStatus, in its three states.
           battery_boost: door.boost
             ? {
@@ -695,8 +734,8 @@ export class SimApi {
                   stopped_at_ms: door.boostStop.atMs,
                 }
               : { state: 'inactive', active: false },
-          surplus_only: false,
-          ...(this.#schedule ? { schedule: this.#schedule } : {}),
+          surplus_only: door.surplusOnly,
+          schedule: this.#schedule ?? { soc: 0, time_of_day_min_utc: 0, recurring: false },
         },
       ],
     })
@@ -732,7 +771,10 @@ export class SimApi {
     if (days !== undefined && (typeof days !== 'number' || days < 0 || days > 127)) {
       return json(400, { error: 'days must be a 7-bit weekday mask (0..127, bit 0 = Monday)' })
     }
-    this.#schedule = s
+    const soc = typeof s['soc'] === 'number' ? s['soc'] : typeof s['soc_pct'] === 'number' ? s['soc_pct'] / 100 : 0
+    if (soc < 0 || soc > 1) return json(400, { error: 'soc must be between 0 and 1' })
+    const { soc_pct: _legacy, ...fields } = s
+    this.#schedule = { ...fields, soc }
     return json(200, { ok: true })
   }
 
diff --git a/src/lib/sim/box.ts b/src/lib/sim/box.ts
index 6008326..9f56060 100644
--- a/src/lib/sim/box.ts
+++ b/src/lib/sim/box.ts
@@ -49,7 +49,7 @@ import {
   carriesOverSession,
   isRetryable,
 } from '$lib/protocol/messages'
-import { SimApi } from './api'
+import { SimApi, evPluggedIn } from './api'
 import { roleHasScope, ROLE_SCOPES } from '$lib/protocol/contract'
 import { buildPlan, priceAt, importTotalMinor } from './planner'
 import {
@@ -329,6 +329,16 @@ export class SimBox {
    * keeps its terminal status the same way, and its page reads it back.
    */
   #evBoostStop: { reason: string; atMs: number } | null = null
+  /**
+   * The car's level as the box holds it, a fraction: the plug-in anchor
+   * until an operator corrects it, which is what the box's inferred estimate
+   * is. Fixed rather than climbing with the session, because what the tests
+   * and the demo need is a level to prefill and to read back, not a battery
+   * model.
+   */
+  #evSoc = 0.42
+  /** PV-only charging, set through the door. */
+  #evSurplusOnly = false
   #subscribed = false
   #negotiatedProto = PROTO_MAX
   #bucket: 256 | 512 = 512
@@ -379,6 +389,8 @@ export class SimBox {
         holdW: this.#evHold?.powerW ?? null,
         boost: this.#liveBoost(),
         boostStop: this.#evBoostStop,
+        soc: this.#evSoc,
+        surplusOnly: this.#evSurplusOnly,
       }),
       liveReading: () => this.#lastReading,
     })
@@ -785,7 +797,8 @@ export class SimBox {
         // The box's rules, value for value: exactly one of duration_s and
         // expires_at_ms; a reserve of 5–100 % after its legacy-percent
         // reading; one minute to four hours; and a refusal, not a lease,
-        // while an operator hold is on the charger.
+        // while an operator hold is on the charger or it runs on spare
+        // solar only.
         const durS = typeof cmd.args['duration_s'] === 'number' ? cmd.args['duration_s'] : 0
         const expiresAt =
           typeof cmd.args['expires_at_ms'] === 'number' ? cmd.args['expires_at_ms'] : 0
@@ -809,7 +822,7 @@ export class SimBox {
           })
           return
         }
-        if (this.#evHold) {
+        if (this.#evHold || this.#evSurplusOnly) {
           this.#cmdResult(cmd.cmdId, 'rejected', {
             code: 'E_UNAVAILABLE',
             args: { op: cmd.op },
@@ -828,6 +841,66 @@ export class SimBox {
       return
     }
 
+    // The car's level, corrected: a fraction in [0, 1] as the box takes it,
+    // refused by name when no car is on the cable — the route's 409 — and
+    // read back as the level the box now holds.
+    if (cmd.op === OP_LOADPOINT_SOC_SET) {
+      if (cmd.args['id'] !== 'carport') {
+        this.#cmdResult(cmd.cmdId, 'rejected', { code: 'E_UNKNOWN_OP', args: { field: 'id' } })
+        return
+      }
+      const soc = cmd.args['soc']
+      if (typeof soc !== 'number' || soc < 0 || soc > 1) {
+        this.#cmdResult(cmd.cmdId, 'rejected', {
+          code: 'E_UNKNOWN_OP',
+          args: { op: cmd.op, arg: 'soc', value: soc ?? null },
+        })
+        return
+      }
+      if (!evPluggedIn(this.#now())) {
+        this.#cmdResult(cmd.cmdId, 'rejected', {
+          code: 'E_UNAVAILABLE',
+          args: { op: cmd.op, reason: 'unplugged' },
+        })
+        return
+      }
+      this.#evSoc = soc
+      this.#cmdResult(cmd.cmdId, 'applied', undefined, {
+        value: this.#evSoc,
+        src: 'core',
+        uptimeMs: this.uptimeMs,
+      })
+      this.#sendPlan()
+      return
+    }
+
+    // PV only, on or off: stored, read back as 1 or 0 the way the box
+    // reports a flag, and — as the box's own tick does — a running boost is
+    // withdrawn the moment the charger goes back to spare solar only.
+    if (cmd.op === OP_LOADPOINT_SURPLUS_ONLY_SET) {
+      if (cmd.args['id'] !== 'carport') {
+        this.#cmdResult(cmd.cmdId, 'rejected', { code: 'E_UNKNOWN_OP', args: { field: 'id' } })
+        return
+      }
+      const on = cmd.args['surplus_only']
+      if (typeof on !== 'boolean') {
+        this.#cmdResult(cmd.cmdId, 'rejected', {
+          code: 'E_UNKNOWN_OP',
+          args: { op: cmd.op, arg: 'surplus_only', value: on ?? null },
+        })
+        return
+      }
+      this.#evSurplusOnly = on
+      if (on) this.#stopBoost('surplus_only')
+      this.#cmdResult(cmd.cmdId, 'applied', undefined, {
+        value: this.#evSurplusOnly ? 1 : 0,
+        src: 'core',
+        uptimeMs: this.uptimeMs,
+      })
+      this.#sendPlan()
+      return
+    }
+
     const value = typeof cmd.args['watts'] === 'number' ? cmd.args['watts'] : 0
     this.#cmdResult(cmd.cmdId, 'applied', undefined, {
       value,
diff --git a/src/lib/state/charging-watch.test.ts b/src/lib/state/charging-watch.test.ts
new file mode 100644
index 0000000..4d1c39e
--- /dev/null
+++ b/src/lib/state/charging-watch.test.ts
@@ -0,0 +1,100 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+import { watchCharging, refreshCharging, type ChargingSnapshot } from './charging-watch'
+import { callBox } from './box-api'
+import { CAP_API_PASSTHROUGH } from '$lib/protocol/contract'
+import type { SiteStore } from './site.svelte'
+
+vi.mock('./box-api', () => ({ callBox: vi.fn() }))
+const read = vi.mocked(callBox)
+const stops: (() => void)[] = []
+function site() { return { session: { phase: 'streaming', caps: new Set([CAP_API_PASSTHROUGH]) } } as unknown as SiteStore }
+const plugged = { id: 'garage', plugged_in: true, current_power_w: 4300, charger: { available: true } }
+
+beforeEach(() => { vi.useFakeTimers(); read.mockReset(); vi.spyOn(document, 'hidden', 'get').mockReturnValue(false) })
+afterEach(() => { stops.splice(0).forEach(stop => stop()); vi.restoreAllMocks(); vi.useRealTimers() })
+
+describe('shared charging status', () => {
+  it('uses one request for two views and stops after both leave', async () => {
+    read.mockResolvedValue({ loadpoints: [plugged] })
+    const home = site(), a = vi.fn(), b = vi.fn()
+    const stopA = watchCharging(home, a), stopB = watchCharging(home, b)
+    stops.push(stopA, stopB)
+    await vi.advanceTimersByTimeAsync(0)
+    expect(read).toHaveBeenCalledTimes(1)
+    expect(a.mock.lastCall?.[0].fresh).toBe(true)
+    expect(b.mock.lastCall?.[0].points[0].pluggedIn).toBe(true)
+    stopA()
+    await vi.advanceTimersByTimeAsync(5000)
+    expect(read).toHaveBeenCalledTimes(2)
+    stopB()
+    await vi.advanceTimersByTimeAsync(30000)
+    expect(read).toHaveBeenCalledTimes(2)
+  })
+  it('refreshes both views after an action without waiting for the poll', async () => {
+    read.mockResolvedValueOnce({ loadpoints: [plugged] })
+      .mockResolvedValue({ loadpoints: [{ ...plugged, current_power_w: 0, manual_active: true, manual: { state: 'paused' } }] })
+    const home = site(), listener = vi.fn()
+    stops.push(watchCharging(home, listener))
+    await vi.advanceTimersByTimeAsync(0)
+    expect(listener.mock.lastCall?.[0].points[0].powerW).toBe(4300)
+    refreshCharging(home)
+    await vi.advanceTimersByTimeAsync(0)
+    expect(read).toHaveBeenCalledTimes(2)
+    expect(listener.mock.lastCall?.[0].points[0].manual?.state).toBe('paused')
+  })
+  it('re-asks after an older in-flight read when an action requests a refresh', async () => {
+    let finish!: (value: unknown) => void
+    read.mockReturnValueOnce(new Promise(resolve => { finish = resolve }))
+      .mockResolvedValue({ loadpoints: [{ ...plugged, current_power_w: 0 }] })
+    const home = site(), listener = vi.fn()
+    stops.push(watchCharging(home, listener))
+    refreshCharging(home)
+    finish({ loadpoints: [plugged] })
+    await vi.advanceTimersByTimeAsync(1)
+    expect(read).toHaveBeenCalledTimes(2)
+    expect(listener.mock.lastCall?.[0].points[0].powerW).toBe(0)
+  })
+  it('expires the last reading while the next request is still waiting', async () => {
+    read.mockResolvedValueOnce({ loadpoints: [plugged] }).mockReturnValue(new Promise(() => {}))
+    let latest: ChargingSnapshot | undefined
+    stops.push(watchCharging(site(), next => { latest = next }))
+    await vi.advanceTimersByTimeAsync(0)
+    expect(latest?.fresh).toBe(true)
+    await vi.advanceTimersByTimeAsync(15001)
+    expect(latest?.fresh).toBe(false)
+    expect(latest?.points[0]?.pluggedIn).toBe(true)
+  })
+  it('keeps connection evidence on failed or unavailable reads, then accepts a fresh unplug', async () => {
+    read.mockResolvedValueOnce({ loadpoints: [plugged] })
+      .mockRejectedValueOnce(new Error('offline'))
+      .mockResolvedValueOnce({ loadpoints: [{ ...plugged, plugged_in: false, charger: { available: false } }] })
+      .mockResolvedValue({ loadpoints: [{ ...plugged, plugged_in: false }] })
+    let latest: ChargingSnapshot | undefined
+    stops.push(watchCharging(site(), next => { latest = next }))
+    await vi.advanceTimersByTimeAsync(5000)
+    expect(latest?.fresh).toBe(false)
+    expect(latest?.points[0]?.pluggedIn).toBe(true)
+    await vi.advanceTimersByTimeAsync(5000)
+    expect(latest?.points[0]?.pluggedIn).toBe(true)
+    expect(latest?.points[0]?.charger?.available).toBe(false)
+    await vi.advanceTimersByTimeAsync(5000)
+    expect(latest?.points[0]?.pluggedIn).toBe(false)
+  })
+  it('marks hidden status stale, stops polling, and refreshes on return', async () => {
+    const hidden = vi.spyOn(document, 'hidden', 'get').mockReturnValue(false)
+    read.mockResolvedValue({ loadpoints: [plugged] })
+    const listener = vi.fn()
+    stops.push(watchCharging(site(), listener))
+    await vi.advanceTimersByTimeAsync(0)
+    hidden.mockReturnValue(true)
+    document.dispatchEvent(new Event('visibilitychange'))
+    expect(listener.mock.lastCall?.[0].fresh).toBe(false)
+    await vi.advanceTimersByTimeAsync(30000)
+    expect(read).toHaveBeenCalledTimes(1)
+    hidden.mockReturnValue(false)
+    document.dispatchEvent(new Event('visibilitychange'))
+    await vi.advanceTimersByTimeAsync(0)
+    expect(read).toHaveBeenCalledTimes(2)
+    expect(listener.mock.lastCall?.[0].fresh).toBe(true)
+  })
+})
diff --git a/src/lib/state/charging-watch.ts b/src/lib/state/charging-watch.ts
new file mode 100644
index 0000000..58c81d7
--- /dev/null
+++ b/src/lib/state/charging-watch.ts
@@ -0,0 +1,71 @@
+import { callBox } from './box-api'
+import { toLoadpoint, type Loadpoint, type WireLoadpoint } from '$lib/format/ev'
+import { CAP_API_PASSTHROUGH } from '$lib/protocol/contract'
+import type { SiteStore } from './site.svelte'
+
+export interface ChargingSnapshot { points: Loadpoint[]; fresh: boolean }
+type Listener = (snapshot: ChargingSnapshot) => void
+const watches = new WeakMap<SiteStore, { subscribe: (listener: Listener) => () => void; refresh: () => void }>()
+
+/** A confirmed action should reach the home card before its next timer. */
+export function refreshCharging(site: SiteStore): void { watches.get(site)?.refresh() }
+
+/** One read for the home card and power diagram. Hidden phones stop polling. */
+export function watchCharging(site: SiteStore, listener: Listener): () => void {
+  let watch = watches.get(site)
+  if (!watch) {
+    const listeners = new Set<Listener>()
+    let snapshot: ChargingSnapshot = { points: [], fresh: false }
+    let timer: ReturnType<typeof setTimeout> | undefined
+    let reading = false
+    let refreshPending = false
+    let staleTimer: ReturnType<typeof setTimeout> | undefined
+    const expire = () => { snapshot = { ...snapshot, fresh: false }; publish() }
+    const publish = () => { for (const fn of listeners) fn(snapshot) }
+    const tick = async () => {
+      clearTimeout(timer)
+      if (!listeners.size || reading || document.hidden) return
+      reading = true
+      refreshPending = false
+      try {
+        if (site.session.phase !== 'streaming' || !site.session.caps.has(CAP_API_PASSTHROUGH)) {
+          snapshot = { ...snapshot, fresh: false }
+        } else {
+          const wire = await callBox<{ loadpoints?: WireLoadpoint[] }>(site, { method: 'GET', path: '/api/loadpoints' })
+          if (!Array.isArray(wire.loadpoints)) throw new Error('Missing charger status')
+          const points = wire.loadpoints.map(toLoadpoint).map(lp => {
+            const previous = snapshot.points.find(p => p.id === lp.id)
+            return lp.charger?.available === false && previous?.pluggedIn ? { ...lp, pluggedIn: true } : lp
+          })
+          snapshot = { points, fresh: !document.hidden && site.session.phase === 'streaming' }
+          clearTimeout(staleTimer)
+          if (listeners.size) staleTimer = setTimeout(expire, 15_000)
+        }
+      } catch { snapshot = { ...snapshot, fresh: false } }
+      finally {
+        reading = false
+        if (listeners.size) { publish(); timer = setTimeout(() => void tick(), refreshPending ? 0 : 5_000) }
+      }
+    }
+    const visibility = () => {
+      clearTimeout(timer)
+      snapshot = { ...snapshot, fresh: false }
+      publish()
+      if (!document.hidden) void tick()
+    }
+    watch = { refresh() {
+      if (reading) refreshPending = true
+      else void tick()
+    }, subscribe(fn) {
+      listeners.add(fn)
+      fn({ ...snapshot, fresh: false })
+      if (listeners.size === 1) { document.addEventListener('visibilitychange', visibility); void tick() }
+      return () => {
+        listeners.delete(fn)
+        if (!listeners.size) { clearTimeout(timer); clearTimeout(staleTimer); document.removeEventListener('visibilitychange', visibility) }
+      }
+    } }
+    watches.set(site, watch)
+  }
+  return watch.subscribe(listener)
+}
diff --git a/src/lib/state/loadpoints.svelte.ts b/src/lib/state/loadpoints.svelte.ts
index 91de784..e0ef27f 100644
--- a/src/lib/state/loadpoints.svelte.ts
+++ b/src/lib/state/loadpoints.svelte.ts
@@ -1,18 +1,13 @@
 /* The charger, as the panel sees it.
  *
- * Two reads over the passthrough: `/api/loadpoints` for what the charger is
- * and does, `/api/mpc/plan` for when the optimiser intends to run it. The
- * first is the panel; the second is decoration on it. They fail separately
- * on purpose — a box old enough to lack the plan route still has a charger
- * worth showing, and a panel that went blank over missing decoration would
- * be the tail wagging the dog.
- *
- * Nothing here commands anything. Round two brings the schedule editor and
- * round three the buttons; until then every field is a fact the box served.
+ * Current boxes report status and charge windows together on `/api/loadpoints`.
+ * Older boxes need a separate plan read. The current path avoids that extra
+ * request so a slow full plan cannot hold up the five-second charger poll.
  */
 
 import { callBox, BoxApiError } from './box-api'
-import { commandHelp, boostHelp } from '$lib/format/command'
+import { refreshCharging } from './charging-watch'
+import { commandHelp, boostHelp, socHelp } from '$lib/format/command'
 import {
   toLoadpoint,
   chargeCurrent,
@@ -20,7 +15,13 @@ import {
   type Loadpoint,
   type WireLoadpoint,
 } from '$lib/format/ev'
-import { OP_LOADPOINT_HOLD, OP_LOADPOINT_BOOST, type CmdResult } from '$lib/protocol/messages'
+import {
+  OP_LOADPOINT_HOLD,
+  OP_LOADPOINT_BOOST,
+  OP_LOADPOINT_SOC_SET,
+  OP_LOADPOINT_SURPLUS_ONLY_SET,
+  type CmdResult,
+} from '$lib/protocol/messages'
 import { CommandError } from '$lib/protocol/session'
 import type { SiteStore } from './site.svelte'
 
@@ -29,7 +30,9 @@ export interface ChargeWindow {
   fromMs: number
   toMs: number
   /** The plan's peak for the window, in watts. */
-  peakW: number
+  peakW: number | null
+  /** Current boxes report window energy, not peak power. Never infer a peak. */
+  energyWh?: number
   /** The box's own reason token for the window's first slot. */
   reason: string
 }
@@ -62,7 +65,7 @@ export function chargeWindows(actions: WireAction[], loadpointId: string): Charg
     const last = out[out.length - 1]
     if (last && start <= last.toMs) {
       last.toMs = endMs
-      last.peakW = Math.max(last.peakW, w)
+      last.peakW = Math.max(last.peakW ?? 0, w)
     } else {
       out.push({
         fromMs: start,
@@ -75,11 +78,31 @@ export function chargeWindows(actions: WireAction[], loadpointId: string): Charg
   return out
 }
 
+/** Windows from the same snapshot as the charger's status. */
+function inlineWindows(lp: WireLoadpoint): ChargeWindow[] {
+  if (lp.plan_pending === true || lp.plan_outdated === true || !Array.isArray(lp.plan_windows)) return []
+  return lp.plan_windows.flatMap(w => {
+    if (!w || typeof w !== 'object' ||
+      typeof w.start_ms !== 'number' || !Number.isFinite(w.start_ms) ||
+      typeof w.end_ms !== 'number' || !Number.isFinite(w.end_ms) || w.end_ms <= w.start_ms ||
+      typeof w.wh !== 'number' || !Number.isFinite(w.wh) || w.wh < 0) return []
+    return [{ fromMs: w.start_ms, toMs: w.end_ms, peakW: null, energyWh: w.wh, reason: '' }]
+  })
+}
+
 /** Which control on the panel a command belongs to, so its outcome lands under it. */
-export type Control = 'hold' | 'boost'
+export type Control = 'hold' | 'boost' | 'soc' | 'surplus'
 
 /** What an applied command did, for the one sentence that says so. */
-export type Outcome = 'hold' | 'release' | 'boost' | 'unboost'
+export type Outcome =
+  | 'hold'
+  | 'release'
+  | 'pause'
+  | 'boost'
+  | 'unboost'
+  | 'soc'
+  | 'surplus_on'
+  | 'surplus_off'
 
 export class LoadpointsStore {
   /** Every charger the box reported. Empty until an answer lands. */
@@ -94,6 +117,9 @@ export class LoadpointsStore {
    * means an idle week.
    */
   planMissing = $state(false)
+  /** The box is calculating a new plan; previous windows cannot confirm it. */
+  planPending = $state(false)
+  planOutdated = $state(false)
 
   /** True only while waiting on the box. Whatever is drawn stays drawn. */
   loading = $state(false)
@@ -101,6 +127,9 @@ export class LoadpointsStore {
   /** Whether the box has ever answered. Absence of an answer is not an empty bay. */
   loaded = $state(false)
 
+  /** Age of the charger read, independent of the house power stream. */
+  readAt = $state<number | null>(null)
+
   /** A sentence, never a code. Null when there is nothing to say. */
   error = $state<string | null>(null)
 
@@ -121,9 +150,17 @@ export class LoadpointsStore {
     | { kind: 'failed'; of: Control; help: string }
   >({ kind: 'idle' })
 
+  commandLpId = $state<string | null>(null)
+  /** Applied choices remain visible until a later charger read confirms state. */
+  acceptedSoc = $state.raw<Record<string, { value: number }>>({})
+  acceptedSurplus = $state.raw<Record<string, { value: boolean }>>({})
+
   #site: SiteStore
   /** Guards a slow answer against a panel that already asked again. */
   #token = 0
+  #chargerRead: Promise<void> | null = null
+  #fullRead: Promise<void> | null = null
+  #inlinePlan = false
   #settle: ReturnType<typeof setTimeout> | null = null
 
   constructor(site: SiteStore) {
@@ -160,6 +197,10 @@ export class LoadpointsStore {
     )
   }
 
+  async pauseCharging(lp: Loadpoint): Promise<void> {
+    await this.#send(OP_LOADPOINT_HOLD, { id: lp.id, power_w: 0, hold_s: 0 }, 'hold', 'pause', commandHelp)
+  }
+
   /** Release the hold. The plan takes back over. */
   async stopCharging(lp: Loadpoint): Promise<void> {
     await this.#send(OP_LOADPOINT_HOLD, { id: lp.id, clear: true }, 'hold', 'release', commandHelp)
@@ -188,6 +229,29 @@ export class LoadpointsStore {
     await this.#send(OP_LOADPOINT_BOOST, { id: lp.id, cancel: true }, 'boost', 'unboost', boostHelp)
   }
 
+  /**
+   * Correct the car's charge level.
+   *
+   * Whole percent from the slider, the wire's 0–1 fraction to the box — the
+   * same re-anchor its own page posts to `soc`. The box applies the level,
+   * starts a replan and answers. A car that is not on the cable is
+   * refused by name, and `socHelp` says so.
+   */
+  async setSoc(lp: Loadpoint, pct: number): Promise<void> {
+    await this.#send(OP_LOADPOINT_SOC_SET, { id: lp.id, soc: pct / 100 }, 'soc', 'soc', socHelp)
+  }
+
+  /** Charge from spare solar only, or let the grid and the house battery back in. */
+  async setSurplusOnly(lp: Loadpoint, on: boolean): Promise<void> {
+    await this.#send(
+      OP_LOADPOINT_SURPLUS_ONLY_SET,
+      { id: lp.id, surplus_only: on },
+      'surplus',
+      on ? 'surplus_on' : 'surplus_off',
+      commandHelp
+    )
+  }
+
   async #send(
     op: string,
     args: Record<string, unknown>,
@@ -197,6 +261,7 @@ export class LoadpointsStore {
   ): Promise<void> {
     if (this.command.kind === 'sending') return
     if (this.#settle) clearTimeout(this.#settle)
+    this.commandLpId = typeof args.id === 'string' ? args.id : null
     this.command = { kind: 'sending', of }
 
     try {
@@ -204,6 +269,14 @@ export class LoadpointsStore {
       switch (result.state) {
         case 'applied':
           this.command = { kind: 'applied', of, did }
+          if (typeof args.id === 'string') {
+            if (of === 'soc' && typeof args.soc === 'number') {
+              this.acceptedSoc = { ...this.acceptedSoc, [args.id]: { value: Math.round(args.soc * 100) } }
+            }
+            if (of === 'surplus' && typeof args.surplus_only === 'boolean') {
+              this.acceptedSurplus = { ...this.acceptedSurplus, [args.id]: { value: args.surplus_only } }
+            }
+          }
           break
         case 'unconfirmed':
           this.command = { kind: 'unconfirmed', of }
@@ -215,19 +288,26 @@ export class LoadpointsStore {
       this.command = {
         kind: 'failed',
         of,
-        help: err instanceof CommandError ? err.help : "That didn't go through. Try again.",
+        help: err instanceof CommandError ? err.help : "FTW did not confirm the request. Reading its current state…",
       }
     }
 
+    // Keep a refusal or an uncertain result visible until the next action.
+    if (this.command.kind === 'applied') {
+      this.#settle = setTimeout(() => {
+        this.command = { kind: 'idle' }
+        this.#settle = null
+      }, 6_000)
+    }
+
     // Whatever the outcome, the box's account of the charger is the truth
     // to repaint from — even a refusal can follow a change someone else
-    // made. A failed reread keeps the sentence already on screen.
-    void this.load().catch(() => {})
-
-    this.#settle = setTimeout(() => {
-      this.command = { kind: 'idle' }
-      this.#settle = null
-    }, 6_000)
+    // made. A failed reread keeps the sentence already on screen. Awaited,
+    // so a caller holding a draft against the box's value knows when the
+    // box's own value is the one on screen and can let go of the draft.
+    if (this.#chargerRead) await this.#chargerRead.catch(() => {})
+    await this.loadChargers().catch(() => {})
+    refreshCharging(this.#site)
   }
 
   /**
@@ -245,9 +325,17 @@ export class LoadpointsStore {
    * the plan too; that is decoration, and a live overlay must not wait on it.
    */
   async loadChargers(): Promise<void> {
+    if (this.#chargerRead) return this.#chargerRead
+    this.#chargerRead = this.#readChargers()
+    try { await this.#chargerRead } finally { this.#chargerRead = null }
+  }
+
+  async #readChargers(): Promise<void> {
     const token = ++this.#token
+    // A read started before a command cannot confirm that command's choice.
+    const socChoices = this.acceptedSoc
+    const surplusChoices = this.acceptedSurplus
     this.loading = true
-    this.error = null
 
     try {
       const wire = await callBox<{ enabled?: boolean; loadpoints?: WireLoadpoint[] }>(this.#site, {
@@ -256,8 +344,25 @@ export class LoadpointsStore {
       })
       if (token !== this.#token) return
 
-      this.points = (wire.loadpoints ?? []).map(toLoadpoint)
+      const points = wire.loadpoints ?? []
+      this.points = points.map(toLoadpoint)
+      this.#inlinePlan = points.every(lp =>
+        (typeof lp.plan_pending === 'boolean' && typeof lp.plan_outdated === 'boolean') || Array.isArray(lp.plan_windows))
+      if (this.#inlinePlan) {
+        this.planPending = this.points.some(lp => lp.planPending)
+        this.planOutdated = this.points.some(lp => lp.planOutdated)
+        this.windows = Object.fromEntries(points.map(lp => [typeof lp.id === 'string' ? lp.id : '', inlineWindows(lp)]))
+        this.planMissing = false
+      } else {
+        this.windows = Object.fromEntries(Object.entries(this.windows).filter(([id]) => {
+          const lp = this.points.find(point => point.id === id)
+          return !lp?.planPending && !lp?.planOutdated
+        }))
+      }
+      this.acceptedSoc = Object.fromEntries(Object.entries(this.acceptedSoc).filter(([id, choice]) => choice !== socChoices[id]))
+      this.acceptedSurplus = Object.fromEntries(Object.entries(this.acceptedSurplus).filter(([id, choice]) => choice !== surplusChoices[id]))
       this.loaded = true
+      this.readAt = Date.now()
       this.error = null
     } catch (err) {
       if (token !== this.#token) return
@@ -273,20 +378,34 @@ export class LoadpointsStore {
     }
   }
 
-  async load(): Promise<void> {
+  async load(force = false): Promise<void> {
+    if (this.#fullRead) {
+      await this.#fullRead.catch(() => {})
+      if (!force) return
+    }
+    if (force && this.#chargerRead) await this.#chargerRead.catch(() => {})
+    this.#fullRead = this.#readAll()
+    try { await this.#fullRead } finally { this.#fullRead = null }
+  }
+
+  async #readAll(): Promise<void> {
     await this.loadChargers()
+    if (this.#inlinePlan) return
 
     // The decoration, after the panel is safe. Its failure is a note.
     const token = this.#token
     try {
       const wire = await callBox<{
         plan?: { actions?: WireAction[] }
+        meta?: { replanning?: boolean; outdated?: boolean }
       }>(this.#site, { method: 'GET', path: '/api/mpc/plan' })
       if (token !== this.#token) return
 
       const actions = wire.plan?.actions ?? []
+      this.planPending = wire.meta?.replanning === true
+      this.planOutdated = wire.meta?.outdated === true
       const windows: Record<string, ChargeWindow[]> = {}
-      for (const lp of this.points) windows[lp.id] = chargeWindows(actions, lp.id)
+      for (const lp of this.points) windows[lp.id] = this.planPending || this.planOutdated || lp.planPending || lp.planOutdated ? [] : chargeWindows(actions, lp.id)
       this.windows = windows
       this.planMissing = false
     } catch {
diff --git a/src/lib/state/loadpoints.test.ts b/src/lib/state/loadpoints.test.ts
index 9b2ce15..a2db69f 100644
--- a/src/lib/state/loadpoints.test.ts
+++ b/src/lib/state/loadpoints.test.ts
@@ -10,7 +10,12 @@ import { LoadpointsStore, chargeWindows } from './loadpoints.svelte'
 import { SiteStore } from './site.svelte'
 import { LoopbackCarrier } from '$lib/carrier/loopback'
 import { SimBox } from '$lib/sim/box'
-import { OP_LOADPOINT_HOLD, OP_LOADPOINT_BOOST } from '$lib/protocol/messages'
+import {
+  OP_LOADPOINT_HOLD,
+  OP_LOADPOINT_BOOST,
+  OP_LOADPOINT_SOC_SET,
+  OP_LOADPOINT_SURPLUS_ONLY_SET,
+} from '$lib/protocol/messages'
 
 /** Half past six in the evening UTC: the sim car is plugged in and drawing. */
 const CHARGING_EVENING = Date.UTC(2026, 6, 15, 18, 30, 0)
@@ -48,8 +53,10 @@ describe('the charger over the wire', () => {
     expect(lp.id).toBe('carport')
     expect(lp.pluggedIn).toBe(true)
     expect(lp.powerW).toBeGreaterThan(7000)
-    // The sim charger honestly does not know the car's charge.
-    expect(lp.socPct).toBeNull()
+    // The sim charger estimates the car's level the way the box does for a
+    // charger without a car API: a fraction on the wire, inferred.
+    expect(lp.socPct).toBe(42)
+    expect(lp.socSource).toBe('inferred')
     expect(lp.schedule).not.toBeNull()
 
     // The plan's charging window covers this very evening.
@@ -87,6 +94,45 @@ describe('the charger over the wire', () => {
     expect(store.planMissing, 'a missing plan was passed off as an idle week').toBe(true)
   })
 
+  it('hides old windows when replanning begins between the charger and plan reads', async () => {
+    vi.useFakeTimers()
+    vi.setSystemTime(CHARGING_EVENING)
+    const site = await streamingSite(new SimBox({ now: () => Date.now() }))
+    let pending = true
+    let outdated = false
+    const api = site.api.bind(site)
+    vi.spyOn(site, 'api').mockImplementation(async req => {
+      const answer = await api(req)
+      if (req.path === '/api/mpc/plan') {
+        const payload = JSON.parse(new TextDecoder().decode(answer.body))
+        payload.meta = { ...payload.meta, replanning: pending, outdated }
+        return { ...answer, body: new TextEncoder().encode(JSON.stringify(payload)) }
+      }
+      return answer
+    })
+    const store = new LoadpointsStore(site)
+    const first = store.load()
+    await vi.advanceTimersByTimeAsync(500)
+    await first
+    expect(store.points[0]!.powerW).toBeGreaterThan(7000)
+    expect(store.planPending).toBe(true)
+    expect(store.windows['carport']).toEqual([])
+    pending = false
+    outdated = true
+    const next = store.load()
+    await vi.advanceTimersByTimeAsync(500)
+    await next
+    expect(store.planPending).toBe(false)
+    expect(store.planOutdated).toBe(true)
+    expect(store.windows['carport']).toEqual([])
+    outdated = false
+    const recovered = store.load()
+    await vi.advanceTimersByTimeAsync(500)
+    await recovered
+    expect(store.planOutdated).toBe(false)
+    expect(store.windows['carport']!.length).toBeGreaterThan(0)
+  })
+
   it('rejects and says so when the box is out of reach, keeping what was drawn', async () => {
     vi.useFakeTimers()
     vi.setSystemTime(CHARGING_EVENING)
@@ -226,6 +272,90 @@ describe('the charger over the wire', () => {
     expect(store.command.kind === 'failed' && store.command.help).toMatch(/reserve and time/)
     expect(store.points[0]!.boostActive).toBe(false)
   })
+
+  it("corrects the car's level as a fraction, and reads back what the box holds", async () => {
+    vi.useFakeTimers()
+    vi.setSystemTime(CHARGING_EVENING)
+    const { site, store } = await loadedStore()
+    expect(store.points[0]!.socPct).toBe(42)
+
+    const sent = vi.spyOn(site, 'command')
+    await settled(store.setSoc(store.points[0]!, 60))
+
+    // Whole percent in, the wire's fraction out: the body the box's own
+    // page posts to `soc`.
+    expect(sent).toHaveBeenCalledWith(OP_LOADPOINT_SOC_SET, { id: 'carport', soc: 0.6 })
+    expect(store.command).toEqual({ kind: 'applied', of: 'soc', did: 'soc' })
+    // The reread is the level the box holds, not the slider's echo.
+    expect(store.points[0]!.socPct).toBe(60)
+  })
+
+  it('resolves a command only once the charger has been reread', async () => {
+    vi.useFakeTimers()
+    vi.setSystemTime(CHARGING_EVENING)
+    const { store } = await loadedStore()
+
+    // The panel holds a slider draft until this resolves and lets the box's
+    // value through afterwards, so the order is load-bearing.
+    const run = store.setSoc(store.points[0]!, 60)
+    await vi.advanceTimersByTimeAsync(500)
+    await run
+    expect(store.points[0]!.socPct).toBe(60)
+  })
+
+  it('says to plug the car in when the box has no car to set a level for', async () => {
+    vi.useFakeTimers()
+    // Midday: the sim car left with the morning commute.
+    vi.setSystemTime(Date.UTC(2026, 6, 15, 12, 0, 0))
+    const { store } = await loadedStore()
+    expect(store.points[0]!.pluggedIn).toBe(false)
+
+    await settled(store.setSoc(store.points[0]!, 60))
+    expect(store.command.kind).toBe('failed')
+    expect(store.command.kind === 'failed' && store.command.help).toMatch(/Plug the car in first/)
+  })
+
+  it('turns PV only on and off, and the box refuses a boost while it is on', async () => {
+    vi.useFakeTimers()
+    vi.setSystemTime(CHARGING_EVENING)
+    const { site, store } = await loadedStore()
+    expect(store.points[0]!.surplusOnly).toBe(false)
+
+    const sent = vi.spyOn(site, 'command')
+    await settled(store.setSurplusOnly(store.points[0]!, true))
+    expect(sent).toHaveBeenCalledWith(OP_LOADPOINT_SURPLUS_ONLY_SET, {
+      id: 'carport',
+      surplus_only: true,
+    })
+    expect(store.command).toEqual({ kind: 'applied', of: 'surplus', did: 'surplus_on' })
+    expect(store.points[0]!.surplusOnly).toBe(true)
+
+    await settled(store.boost(store.points[0]!, 30, 3600))
+    expect(store.command.kind).toBe('failed')
+    expect(store.command.kind === 'failed' && store.command.help).toMatch(/won't boost/)
+
+    await settled(store.setSurplusOnly(store.points[0]!, false))
+    expect(sent).toHaveBeenCalledWith(OP_LOADPOINT_SURPLUS_ONLY_SET, {
+      id: 'carport',
+      surplus_only: false,
+    })
+    expect(store.command).toEqual({ kind: 'applied', of: 'surplus', did: 'surplus_off' })
+    expect(store.points[0]!.surplusOnly).toBe(false)
+  })
+
+  it('reports PV only ending a running boost', async () => {
+    vi.useFakeTimers()
+    vi.setSystemTime(CHARGING_EVENING)
+    const { store } = await loadedStore()
+
+    await settled(store.boost(store.points[0]!, 30, 3600))
+    expect(store.points[0]!.boostActive).toBe(true)
+
+    await settled(store.setSurplusOnly(store.points[0]!, true))
+    const lp = store.points[0]!
+    expect(lp.boostActive).toBe(false)
+    expect(lp.boostStopReason).toBe('surplus_only')
+  })
 })
 
 describe('charge windows folded from plan slots', () => {
diff --git a/src/lib/state/notify.svelte.ts b/src/lib/state/notify.svelte.ts
index 8c3bcb3..5df303e 100644
--- a/src/lib/state/notify.svelte.ts
+++ b/src/lib/state/notify.svelte.ts
@@ -88,6 +88,7 @@ export class NotifyStore {
 
   /** The box answered E_UNKNOWN_OP: it has no notification routes yet. */
   oldBox = $state(false)
+  availableKinds = $state<string[]>([])
 
   busy = $state<'none' | 'enabling' | 'disabling' | 'saving' | 'testing'>('none')
 
@@ -114,6 +115,7 @@ export class NotifyStore {
 
   #applyDoc(doc: RulesDoc): void {
     this.#doc = doc
+    this.availableKinds = doc.events.map(rule => rule.type)
     this.boxEnabled = doc.enabled
     const next = allOff()
     for (const rule of doc.events) {
@@ -304,6 +306,9 @@ export class NotifyStore {
     this.testSent = false
     try {
       return await this.#writeRules(next)
+    } catch (err) {
+      this.#fail(err)
+      return false
     } finally {
       this.busy = 'none'
     }
diff --git a/src/lib/state/now-ev-overlay.ts b/src/lib/state/now-ev-overlay.ts
index 5af0a26..271ead1 100644
--- a/src/lib/state/now-ev-overlay.ts
+++ b/src/lib/state/now-ev-overlay.ts
@@ -10,41 +10,10 @@
  * putting them on Now pushed the entry bundle 33 bytes over the budget.
  */
 
-import { callBox } from './box-api'
-import { toLoadpoint, type WireLoadpoint } from '$lib/format/ev'
+import { watchCharging } from './charging-watch'
 import { loadpointChargeW } from './flow'
-import { CAP_API_PASSTHROUGH } from '$lib/protocol/contract'
 import type { SiteStore } from './site.svelte'
 
-const PERIOD_MS = 5_000
-
-/**
- * Poll charger power while the session is live. Calls `onWatts` with the
- * sum of loadpoints that are actually drawing. Returns a stop function.
- */
 export function watchLoadpointCharge(site: SiteStore, onWatts: (w: number) => void): () => void {
-  let stopped = false
-  let timer: ReturnType<typeof setTimeout> | undefined
-
-  const tick = async () => {
-    if (stopped) return
-    if (site.session.phase === 'streaming' && site.session.caps.has(CAP_API_PASSTHROUGH)) {
-      try {
-        const wire = await callBox<{ loadpoints?: WireLoadpoint[] }>(site, {
-          method: 'GET',
-          path: '/api/loadpoints',
-        })
-        if (!stopped) onWatts(loadpointChargeW((wire.loadpoints ?? []).map(toLoadpoint)))
-      } catch {
-        // Keep the last reading. A failed ask is not "the car went to 0 W".
-      }
-    }
-    if (!stopped) timer = setTimeout(() => void tick(), PERIOD_MS)
-  }
-
-  void tick()
-  return () => {
-    stopped = true
-    clearTimeout(timer)
-  }
+  return watchCharging(site, snapshot => { if (snapshot.fresh) onWatts(loadpointChargeW(snapshot.points)) })
 }
diff --git a/src/lib/state/route.svelte.ts b/src/lib/state/route.svelte.ts
index 7a50cce..573e64a 100644
--- a/src/lib/state/route.svelte.ts
+++ b/src/lib/state/route.svelte.ts
@@ -13,8 +13,15 @@ export type Route = 'now' | 'plan' | 'history' | 'box'
 
 const ROUTES: Route[] = ['now', 'plan', 'history', 'box']
 
+/** Position of a route in the tab bar. The shell reads slide direction from
+ * it: a tap further down the bar arrives from the right, back up it from
+ * the left. */
+export function routeIndex(route: Route): number {
+  return ROUTES.indexOf(route)
+}
+
 function fromHash(hash: string): Route {
-  const name = hash.replace(/^#\/?/, '')
+  const name = hash.replace(/^#\/?/, '').split('?')[0]
   return ROUTES.find((r) => r === name) ?? 'now'
 }
 
diff --git a/src/lib/state/route.test.ts b/src/lib/state/route.test.ts
new file mode 100644
index 0000000..f12041b
--- /dev/null
+++ b/src/lib/state/route.test.ts
@@ -0,0 +1,14 @@
+import { describe, it, expect } from 'vitest'
+import { routeIndex } from './route.svelte'
+
+/* The shell reads slide direction from this ordering, so the numbers have to
+ * match the order the tab bar draws them in — now on the left, box on the
+ * right. */
+describe('routeIndex', () => {
+  it('numbers the routes in tab bar order', () => {
+    expect(routeIndex('now')).toBe(0)
+    expect(routeIndex('plan')).toBe(1)
+    expect(routeIndex('history')).toBe(2)
+    expect(routeIndex('box')).toBe(3)
+  })
+})
diff --git a/src/lib/ui/ChargingNotice.svelte b/src/lib/ui/ChargingNotice.svelte
new file mode 100644
index 0000000..84d5e1d
--- /dev/null
+++ b/src/lib/ui/ChargingNotice.svelte
@@ -0,0 +1,31 @@
+<script lang="ts">
+  import { untrack } from 'svelte'
+  import { watchCharging, type ChargingSnapshot } from '$lib/state/charging-watch'
+  import { evStatusSentence, evPlanSentence, MANUAL_SAVE_ERROR_TEXT } from '$lib/format/ev'
+  import type { SiteStore } from '$lib/state/site.svelte'
+  let { site }: { site: SiteStore } = $props()
+  let snapshot = $state<ChargingSnapshot>({ points: [], fresh: false })
+  $effect(() => {
+    const currentSite = site
+    return untrack(() => watchCharging(currentSite, next => { snapshot = next }))
+  })
+  const fresh = $derived(snapshot.fresh && site.session.phase === 'streaming')
+</script>
+
+{#each snapshot.points.filter(lp => lp.pluggedIn) as lp (lp.id)}
+  <section class="charging-notice" aria-label="Car connection">
+    <div class="title" role="status">{fresh && lp.charger?.available !== false ? 'Car connected' : 'Car status is out of date'}</div>
+    <p>{fresh && lp.charger?.available !== false ? evStatusSentence(lp, site.canConfigure) : 'Waiting for current charger status. The last reading cannot confirm charging.'}</p>
+    {#if fresh && lp.charger?.available !== false && evPlanSentence(lp, Date.now(), site.canConfigure)}<p class="detail">{evPlanSentence(lp, Date.now(), site.canConfigure)}</p>{/if}
+    {#if lp.manualSaveError}<p class="detail" role="status">{MANUAL_SAVE_ERROR_TEXT}</p>{/if}
+    <a href={`#/now?charger=${encodeURIComponent(lp.id)}`}>Check charging{lp.socSource !== 'vehicle' ? ' and battery level' : ''}</a>
+  </section>
+{/each}
+
+<style>
+.charging-notice { margin: var(--space-3) var(--space-4); padding: var(--space-3); border: 1px solid var(--line); border-radius: var(--radius-md); background: var(--surface-raised); font-size: 14px; }
+.title { font-weight: 500; margin-bottom: var(--space-2); }
+p { margin: 0 0 var(--space-2); }
+.detail { color: var(--fg-dim); }
+a { color: var(--accent); text-decoration: underline; text-underline-offset: 3px; }
+</style>
diff --git a/src/lib/ui/ChargingNotice.svelte.test.ts b/src/lib/ui/ChargingNotice.svelte.test.ts
new file mode 100644
index 0000000..5056a3f
--- /dev/null
+++ b/src/lib/ui/ChargingNotice.svelte.test.ts
@@ -0,0 +1,41 @@
+import { afterEach, describe, expect, it, vi } from 'vitest'
+import { cleanup, render } from '@testing-library/svelte'
+import { flushSync } from 'svelte'
+import ChargingNotice from './ChargingNotice.svelte'
+import { watchCharging, type ChargingSnapshot } from '$lib/state/charging-watch'
+import { toLoadpoint } from '$lib/format/ev'
+import type { SiteStore } from '$lib/state/site.svelte'
+
+vi.mock('$lib/state/charging-watch', () => ({ watchCharging: vi.fn() }))
+afterEach(() => { cleanup(); vi.restoreAllMocks() })
+
+describe('charging status when the active box changes', () => {
+ it('switches the shared subscription and does not resubscribe on each reading', async () => {
+  const callbacks: ((snapshot: ChargingSnapshot) => void)[] = []
+  const stops: ReturnType<typeof vi.fn>[] = []
+  vi.mocked(watchCharging).mockReset().mockImplementation((_site, next) => {
+   callbacks.push(next)
+   const stop = vi.fn(); stops.push(stop)
+   next({points: [], fresh: false})
+   return stop
+  })
+  const first = {session: {phase: 'streaming'}} as SiteStore
+  const second = {session: {phase: 'streaming'}} as SiteStore
+  const view = render(ChargingNotice, {site: first})
+  flushSync()
+  expect(watchCharging).toHaveBeenCalledTimes(1)
+  flushSync(() => callbacks[0]!({fresh: true, points: [toLoadpoint({id: 'first', plugged_in: true})]}))
+  expect(view.getByRole('link').getAttribute('href')).toBe('#/now?charger=first')
+  expect(watchCharging).toHaveBeenCalledTimes(1)
+  await view.rerender({site: second})
+  flushSync()
+  expect(stops[0]).toHaveBeenCalledOnce()
+  expect(watchCharging).toHaveBeenCalledTimes(2)
+  expect(watchCharging).toHaveBeenLastCalledWith(second, expect.any(Function))
+  expect(view.queryByRole('link')).toBeNull()
+  flushSync(() => callbacks[1]!({fresh: true, points: [toLoadpoint({id: 'second', plugged_in: true})]}))
+  expect(view.getByRole('link').getAttribute('href')).toBe('#/now?charger=second')
+  view.unmount()
+  expect(stops[1]).toHaveBeenCalledOnce()
+ })
+})
diff --git a/src/lib/ui/FreshnessBand.svelte b/src/lib/ui/FreshnessBand.svelte
index 17d8933..548f809 100644
--- a/src/lib/ui/FreshnessBand.svelte
+++ b/src/lib/ui/FreshnessBand.svelte
@@ -165,9 +165,9 @@
 
 <style>
   .band {
-    position: sticky;
-    top: 0;
-    z-index: 5;
+    /* Sits above the scroller as an .app sibling, so it never scrolls and
+         needs no sticky of its own. */
+    z-index: var(--z-band);
     display: flex;
     align-items: center;
     gap: var(--space-2);
diff --git a/src/lib/ui/LiveChart.svelte b/src/lib/ui/LiveChart.svelte
index e6db751..c0362a2 100644
--- a/src/lib/ui/LiveChart.svelte
+++ b/src/lib/ui/LiveChart.svelte
@@ -45,6 +45,12 @@
 
   let canvas = $state<HTMLCanvasElement | null>(null)
 
+  /** Reduced motion steps straight to each new reading: no easing, no axis
+   *  drift. Read per use, so a mid-session OS change is honoured. */
+  function motionReduced(): boolean {
+    return window.matchMedia?.('(prefers-reduced-motion: reduce)').matches === true
+  }
+
   // The rolling history and the eased leading edge live outside Svelte's
   // reactivity: they change every animation frame, and routing that through
   // signals would be a repaint a frame for nothing on screen to gain.
@@ -72,6 +78,7 @@
   }
 
   function eased(at: number): number {
+    if (motionReduced()) return targetV
     const t = Math.min(1, (at - transitionAt) / EASE_MS)
     const e = 1 - Math.pow(1 - t, 3)
     return prevV + (targetV - prevV) * e
@@ -89,6 +96,11 @@
     const pad = (hi - lo) * 0.08
     lo -= pad
     hi += pad
+    if (motionReduced()) {
+      minY = lo
+      maxY = hi
+      return
+    }
     minY += (lo - minY) * BOUNDS_SPEED
     maxY += (hi - maxY) * BOUNDS_SPEED
   }
@@ -124,11 +136,13 @@
     // The line colour is resolved by the browser from the design role the
     // host set inline; the fill is that same colour, faint. Reading it off
     // the canvas means one source of truth for the hue.
-    const line = getComputedStyle(el).getPropertyValue('--live-line').trim() || color
+    const styles = getComputedStyle(el)
+    const line = styles.getPropertyValue('--live-line').trim() || color
 
-    // The zero line, where the data can sit on both sides of it.
+    // The zero line, where the data can sit on both sides of it. The same
+    // rule the borders read, so neither theme gets a hand-picked grey.
     if (signed && minY < 0 && maxY > 0) {
-      ctx.strokeStyle = 'rgba(128,128,128,0.3)'
+      ctx.strokeStyle = styles.getPropertyValue('--line').trim() || 'rgba(128,128,128,0.3)'
       ctx.lineWidth = 1
       ctx.beginPath()
       ctx.moveTo(0, yOf(0))
diff --git a/src/main.ts b/src/main.ts
index f02405f..bd827f3 100644
--- a/src/main.ts
+++ b/src/main.ts
@@ -15,3 +15,21 @@ markLinkPhase('app-open')
 addEventListener('load', () => void registerServiceWorker())
 
 export default mount(App, { target })
+
+// The boot script resolves the theme once and never listens, so a switch of
+// the OS scheme mid-session would go unnoticed. Follow it for installs with
+// no stored choice; an explicit choice always wins. Same storage policy as
+// the boot script: blocked storage keeps the theme already resolved.
+try {
+  matchMedia('(prefers-color-scheme: light)').addEventListener('change', ({ matches }) => {
+    try {
+      if (!localStorage.getItem('ftw.theme')) {
+        document.documentElement.dataset.theme = matches ? 'light' : 'dark'
+      }
+    } catch {
+      /* Storage blocked: leave the boot script's resolution in place. */
+    }
+  })
+} catch {
+  /* No live media queries here: the boot script's resolution stands. */
+}
diff --git a/src/styles/base.css b/src/styles/base.css
index 76ead37..b00d941 100644
--- a/src/styles/base.css
+++ b/src/styles/base.css
@@ -52,11 +52,34 @@ body {
   -webkit-user-select: none;
   user-select: none;
   -webkit-tap-highlight-color: transparent;
+  /* iOS Safari's long-press card is a browser affordance on an app shell.
+     .selectable opts back in with the selection it belongs to. */
+  -webkit-touch-callout: none;
 }
 
 .selectable {
   -webkit-user-select: text;
   user-select: text;
+  -webkit-touch-callout: default;
+}
+
+/* Tap targets answer at tap speed: manipulation drops iOS's double-tap-zoom
+   wait without touching pinch zoom. */
+button,
+a,
+[role='button'],
+label[for],
+input,
+select,
+textarea {
+  touch-action: manipulation;
+}
+
+/* One quiet press response for every tappable control, so no component has
+   to style its own :active to avoid feeling dead. */
+button:active:not(:disabled),
+[role='button']:active {
+  opacity: 0.6;
 }
 
 button {
diff --git a/src/styles/tokens.css b/src/styles/tokens.css
index ad6b8bc..3c3ea3d 100644
--- a/src/styles/tokens.css
+++ b/src/styles/tokens.css
@@ -27,6 +27,10 @@
   --line: #2a2a2a;
   --line-soft: #222222;
 
+  /* Dim behind overlays and sheets. Darker in the dark theme so a modal
+     still reads as lifted off a near-black page. */
+  --scrim: oklch(0 0 0 / 0.45);
+
   --fg: #e8e8e8;
   --fg-label: #d8d8d8;
   --fg-dim: #a0a0a0;
@@ -115,6 +119,13 @@
   --radius-md: 14px;
   --radius-sm: 10px;
   --radius-xs: 8px;
+  --radius-pill: 999px;
+
+  /* Stacking bands, named once rather than numeric at every call site:
+     content sits below the band, the sheet above whatever overlay dims it. */
+  --z-band: 5;
+  --z-overlay: 40;
+  --z-sheet: 41;
 
   --pad-card: 14px 16px;
   --pad-card-tight: 12px 14px;
@@ -146,6 +157,8 @@ html[data-theme='light'] {
   --line: #cecec7;
   --line-soft: #ddddd7;
 
+  --scrim: oklch(0 0 0 / 0.32);
+
   --fg: #191919;
   --fg-label: #4f4f4b;
   --fg-dim: #4f4f4b;
diff --git a/src/sw.ts b/src/sw.ts
index 4ac4437..e0aa77e 100644
--- a/src/sw.ts
+++ b/src/sw.ts
@@ -119,26 +119,38 @@ async function fromCache(path: string, request: Request): Promise<Response> {
 sw.addEventListener('push', (event) => {
   let title = 'Something happened at home'
   let body = 'Open the app to see what.'
+  let loadpointId: string | undefined
   try {
-    const payload = event.data?.json() as { title?: unknown; body?: unknown } | null
+    const payload = event.data?.json() as { title?: unknown; body?: unknown; kind?: unknown; loadpoint_id?: unknown } | null
     if (payload && typeof payload.title === 'string' && payload.title !== '') {
       title = payload.title
       body = typeof payload.body === 'string' ? payload.body : ''
+      if (typeof payload.kind === 'string' && payload.kind.startsWith('charging.')) {
+        loadpointId = chargerId(payload.loadpoint_id)
+      }
     }
   } catch {
     /* Not the JSON it claimed to be. The generic sentence stands. */
   }
-  event.waitUntil(sw.registration.showNotification(title, { body }))
+  event.waitUntil(sw.registration.showNotification(title, { body, ...(loadpointId ? { data: { loadpointId } } : {}) }))
 })
 
 sw.addEventListener('notificationclick', (event) => {
   event.notification.close()
   event.waitUntil(
     (async () => {
-      // The app is one screen, so any open client is the right one to front.
+      const loadpointId = chargerId(event.notification.data?.loadpointId)
       const open = await sw.clients.matchAll({ type: 'window', includeUncontrolled: true })
-      if (open[0]) await open[0].focus()
-      else await sw.clients.openWindow('/')
+      if (open[0]) {
+        if (loadpointId) open[0].postMessage({ type: 'ftw-open-charger', loadpointId })
+        await open[0].focus()
+      } else {
+        await sw.clients.openWindow(loadpointId ? '/#/now?charger=' + encodeURIComponent(loadpointId) : '/')
+      }
     })()
   )
 })
+
+function chargerId(value: unknown): string | undefined {
+  return typeof value === 'string' && value.length > 0 && value.length <= 256 ? value : undefined
+}
diff --git a/src/views/Energy.svelte b/src/views/Energy.svelte
index 6ada9e8..bba071e 100644
--- a/src/views/Energy.svelte
+++ b/src/views/Energy.svelte
@@ -269,14 +269,6 @@
     flex-wrap: wrap;
   }
 
-  .label {
-    font-family: var(--mono);
-    font-size: 11px;
-    letter-spacing: 0.1em;
-    text-transform: uppercase;
-    color: var(--fg-muted);
-  }
-
   .ranges {
     display: flex;
     gap: 2px;
@@ -287,7 +279,8 @@
   }
 
   .range {
-    min-height: 34px;
+    /* Height comes from base.css: 44px is the smallest reliably hittable
+       target on a phone held one-handed. */
     padding: 0 var(--space-3);
     border-radius: var(--radius-xs);
     font-family: var(--mono);
diff --git a/src/views/EvPanel.svelte b/src/views/EvPanel.svelte
index 487f78a..3f6800e 100644
--- a/src/views/EvPanel.svelte
+++ b/src/views/EvPanel.svelte
@@ -6,16 +6,21 @@
   fact the box served — what flows now, what this session has delivered,
   what the schedule says, and when the optimiser intends to charge next.
   The controls express intent — a hold at a chosen current, a bounded boost
-  from the house battery — and the box decides; the panel repaints from
-  what the box then reports.
+  from the house battery, a corrected charge level, solar surplus only — and
+  the box decides; the panel repaints from what the box then reports.
 -->
 <script lang="ts">
   import { untrack, onDestroy } from 'svelte'
   import { LoadpointsStore, type Control, type Outcome } from '$lib/state/loadpoints.svelte'
   import { askWhenLive } from '$lib/state/ask.svelte'
   import { callBox, BoxApiError } from '$lib/state/box-api'
+  import { refreshCharging } from '$lib/state/charging-watch'
+  import { CAP_API_PASSTHROUGH } from '$lib/protocol/contract'
   import {
     evStatusSentence,
+    MANUAL_SAVE_ERROR_TEXT,
+    isPaused,
+    evPlanSentence,
     evScheduleSentence,
     evSessionSentence,
     utcMinutesToLocalInput,
@@ -25,6 +30,8 @@
     currentReadout,
     boostActiveSentence,
     boostStoppedSentence,
+    socSourceSentence,
+    SOC_DEFAULT_PCT,
     BOOST_DURATIONS,
     BOOST_DURATION_DEFAULT_S,
     BOOST_RESERVE_DEFAULT_PCT,
@@ -40,28 +47,37 @@
     site: SiteStore
     /** Close the sheet. The panel never decides that itself. */
     onclose: () => void
+    loadpointId?: string | null
   }
 
-  let { site, onclose }: Props = $props()
+  let { site, onclose, loadpointId = null }: Props = $props()
 
   const store = new LoadpointsStore(untrack(() => site))
   onDestroy(() => store.destroy())
 
-  // Fresh while open: the ask name carries a minute epoch, so askWhenLive
+  // Fresh while open: the ask name changes every five seconds, so askWhenLive
   // re-asks as the window ages — the same rule History and Energy follow.
   // The panel mounts when it opens and unmounts when it closes, so the
   // ticker lives exactly as long as someone is looking.
-  let epochMin = $state(Math.floor(Date.now() / 60_000))
+  let visible = $state(!document.hidden)
+  $effect(() => {
+    const changed = () => { visible = !document.hidden }
+    document.addEventListener('visibilitychange', changed)
+    return () => document.removeEventListener('visibilitychange', changed)
+  })
+  let now = $state(Date.now())
+  let pollEpoch = $state(Math.floor(Date.now() / 5_000))
   $effect(() => {
     const t = setInterval(() => {
-      epochMin = Math.floor(Date.now() / 60_000)
-    }, 15_000)
+      now = Date.now()
+      pollEpoch = Math.floor(now / 5_000)
+    }, 1_000)
     return () => clearInterval(t)
   })
 
   askWhenLive(
     untrack(() => site),
-    () => `loadpoints ${epochMin}`,
+    () => visible && site.session.caps.has(CAP_API_PASSTHROUGH) ? `loadpoints ${pollEpoch}` : null,
     () => store.load()
   )
 
@@ -69,18 +85,57 @@
     return new Date(ms).toLocaleTimeString(undefined, { hour: '2-digit', minute: '2-digit' })
   }
 
+  let sheet: HTMLDivElement | undefined
+  $effect(() => {
+    if (!sheet) return
+    const previous = document.activeElement
+    sheet.focus()
+    return () => { if (previous instanceof HTMLElement && previous.isConnected) previous.focus() }
+  })
+
   function onkeydown(e: KeyboardEvent) {
-    if (e.key === 'Escape') onclose()
+    if (e.key === 'Escape') { e.preventDefault(); onclose(); return }
+    if (e.key !== 'Tab' || !sheet) return
+    const items = [...sheet.querySelectorAll<HTMLElement>('button:not(:disabled), input:not(:disabled), select:not(:disabled), a[href], summary, [tabindex="0"]')].filter(el => !el.hidden && el.getClientRects().length > 0)
+    const first = items[0], last = items.at(-1)
+    if (!first || !last) { e.preventDefault(); return }
+    if (e.shiftKey && (document.activeElement === first || document.activeElement === sheet)) {
+      e.preventDefault(); last.focus()
+    } else if (!e.shiftKey && document.activeElement === last) {
+      e.preventDefault(); first.focus()
+    }
   }
 
   const sending = $derived(store.command.kind === 'sending')
+  const stale = $derived(!!store.error || site.session.phase !== 'streaming' || (store.readAt !== null && now - store.readAt >= 15_000))
 
-  /** One sentence per thing the box did, under the control that asked. */
-  const DID: Record<Outcome, string> = {
-    hold: 'Done — your box holds that current now.',
-    release: 'Stopped — the plan decides again.',
-    boost: 'Boost on — the house battery is helping the car.',
-    unboost: 'Boost stopped — the plan decides again.',
+  /**
+   * One sentence per thing the box did, under the control that asked. The
+   * level names the figure the box read back, in the box page's own words.
+   */
+  function did(o: Outcome, lp: Loadpoint): string {
+    switch (o) {
+      case 'hold':
+        return stale ? 'Waiting for current charger status.' : lp.manual ? evStatusSentence(lp) : 'FTW received your charge request. Waiting for charger status.'
+      case 'release':
+        return 'The plan decides when to charge.'
+      case 'pause':
+        return evStatusSentence(lp)
+      case 'boost':
+        return 'Battery boost selected. The power readings show what the house battery supplies.'
+      case 'unboost':
+        return 'Boost stopped — the plan decides again.'
+      case 'soc':
+        if (store.acceptedSoc[lp.id]) return `Charge level accepted: ${store.acceptedSoc[lp.id]!.value} %. Waiting for updated charging status.`
+        return (lp.socRetention === 'error' ? `Charge level updated: ${lp.socPct ?? socFor(lp)} %. It could not be saved for a box restart.` : `Charge level saved: ${lp.socPct ?? socFor(lp)} %.`) +
+          (!lp.schedule && !lp.manualActive && !lp.surplusOnly ? ' Set a ready time, or choose Charge now.' : store.planMissing ? ' Charging times are not available yet.' : '')
+      case 'surplus_on':
+        if (store.acceptedSurplus[lp.id]) return 'Solar rule accepted. Waiting for updated charging status.'
+        return 'Solar rule saved. The plan uses spare solar only.'
+      case 'surplus_off':
+        if (store.acceptedSurplus[lp.id]) return 'Solar rule accepted. Waiting for updated charging status.'
+        return 'Solar rule saved. The plan may use grid power again.'
+    }
   }
 
   /**
@@ -91,9 +146,20 @@
    * thumb mid-drag is not snapped back by the minute's ask.
    */
   let amps = $state<Record<string, number>>({})
+  const ampVersion: Record<string, number> = {}
+  function editAmps(lp: Loadpoint, value: number): void {
+    amps[lp.id] = value
+    ampVersion[lp.id] = (ampVersion[lp.id] ?? 0) + 1
+  }
+  async function setAmps(lp: Loadpoint, value: number): Promise<void> {
+    editAmps(lp, value)
+    const version = ampVersion[lp.id]
+    await store.chargeNow(lp, value)
+    if (ampVersion[lp.id] === version) delete amps[lp.id]
+  }
 
   function heldAmps(lp: Loadpoint): number | null {
-    return lp.manualActive && lp.manualChargeW !== null ? wattsToAmps(lp, lp.manualChargeW) : null
+    return lp.manualActive && !lp.manualRestoreUnconfirmed && !isPaused(lp) && lp.manualChargeW !== null ? wattsToAmps(lp, lp.manualChargeW) : null
   }
 
   function ampsFor(lp: Loadpoint): number {
@@ -102,6 +168,82 @@
     return Math.min(range.maxA, Math.max(range.minA, chosen))
   }
 
+  /**
+   * The car's level per charger while a thumb has the slider: from the
+   * first move until the box has answered the release and the panel has
+   * reread it. Outside that window the slider follows the box, because the
+   * estimate climbs as the car charges; inside it, the minute's reread must
+   * not snap the thumb from under a finger.
+   */
+  let socDraft = $state<Record<string, number>>({})
+  const socVersion: Record<string, number> = {}
+  function editSoc(lp: Loadpoint, value: number): void {
+    socDraft[lp.id] = value
+    socVersion[lp.id] = (socVersion[lp.id] ?? 0) + 1
+  }
+
+  function socFor(lp: Loadpoint): number {
+    return socDraft[lp.id] ?? store.acceptedSoc[lp.id]?.value ?? lp.socPct ?? SOC_DEFAULT_PCT
+  }
+
+  /** Written on release, as the box's page does. There is no button. */
+  async function setSoc(lp: Loadpoint, pct: number): Promise<void> {
+    editSoc(lp, pct)
+    const version = socVersion[lp.id]
+    await store.setSoc(lp, pct)
+    if (socVersion[lp.id] === version) delete socDraft[lp.id]
+  }
+
+  /**
+   * The switch's position while its command is out. Without it a refused
+   * toggle would leave the switch on beside a box that says off: the reread
+   * brings the same value back, and an unchanged value repaints nothing.
+   */
+  let surplusDraft = $state<Record<string, boolean>>({})
+  function surplusFor(lp: Loadpoint): boolean {
+    return surplusDraft[lp.id] ?? store.acceptedSurplus[lp.id]?.value ?? lp.surplusOnly
+  }
+
+  async function setSurplusOnly(lp: Loadpoint, on: boolean): Promise<void> {
+    surplusDraft[lp.id] = on
+    await store.setSurplusOnly(lp, on)
+    delete surplusDraft[lp.id]
+  }
+
+  let capacityDraft = $state<Record<string, string>>({})
+  let capacityNote = $state<Record<string, string>>({})
+  let capacityBusy = $state<Record<string, boolean>>({})
+  let capacityFailed = $state<Record<string, boolean>>({})
+
+  async function setCapacity(lp: Loadpoint): Promise<void> {
+    if (capacityBusy[lp.id]) return
+    const value = Number(capacityDraft[lp.id])
+    if (!Number.isFinite(value) || value < 1 || value > 300) {
+      capacityNote[lp.id] = 'Enter the usable battery size from 1 to 300 kWh.'
+      capacityFailed[lp.id] = true
+      return
+    }
+    let accepted = false
+    capacityBusy[lp.id] = true
+    capacityFailed[lp.id] = false
+    capacityNote[lp.id] = 'Sending battery size…'
+    try {
+      await callBox(site, { method: 'POST', path: `/api/loadpoints/${encodeURIComponent(lp.id)}/vehicle`, body: { capacity_wh: Math.round(value * 1000) } })
+      accepted = true
+      capacityNote[lp.id] = 'Battery size saved. Reading charging status…'
+      await store.load(true)
+      refreshCharging(site)
+      const active = store.points.find(point => point.id === lp.id)?.vehicleCapacityWh
+      capacityNote[lp.id] = active != null && active !== Math.round(value * 1000)
+        ? `Saved as the usual battery size. This session uses ${active / 1000} kWh.`
+        : 'Battery size saved. The plan uses this size for its estimates.'
+      delete capacityDraft[lp.id]
+    } catch (err) {
+      capacityFailed[lp.id] = !accepted
+      capacityNote[lp.id] = accepted ? 'Battery size saved. Current charging status is unavailable.' : err instanceof BoxApiError ? err.help : 'Battery size is not confirmed. Check the current value before trying again.'
+    } finally { capacityBusy[lp.id] = false }
+  }
+
   /** The boost under edit: a reserve and a bound, sent as one lease. */
   let boostDraft = $state<{ lpId: string; reservePct: number; durationS: number } | null>(null)
 
@@ -138,12 +280,14 @@
    * is applied optimistically — the box's answer repaints the panel, and
    * until it does the old schedule stands on screen as the truth it is.
    */
-  let draft = $state<{ lpId: string; time: string; days: number; socPct: number } | null>(null)
+  let draft = $state<{ lpId: string; time: string; days: number; socPct: number; recurring: boolean; surplusUnlockPct: number } | null>(null)
   let saving = $state(false)
   let saveError = $state<string | null>(null)
 
   function beginEdit(lp: Loadpoint): void {
+    if (removedGoalId === lp.id) removedGoalId = null
     saveError = null
+    scheduleNote = lp.schedule ? 'Changes apply as you make them.' : 'No goal set yet. Choose this goal, or change the level or time.'
     // The wire's zero means every day; the draft holds all seven bits
     // instead, so tapping Saturday off an every-day schedule means "not
     // Saturday" — with a raw zero it would have meant "only Saturday",
@@ -151,21 +295,55 @@
     const wireDays = lp.schedule?.days ?? 0
     draft = {
       lpId: lp.id,
-      time: utcMinutesToLocalInput(lp.schedule?.timeOfDayMinUtc ?? 6 * 60),
+      time: lp.schedule ? utcMinutesToLocalInput(lp.schedule.timeOfDayMinUtc) : '07:00',
       days: wireDays === 0 ? 0x7f : wireDays & 0x7f,
-      socPct: Math.round(lp.schedule?.socPct ?? lp.targetSocPct ?? 80),
+      socPct: Math.round(lp.schedule?.socPct ?? (lp.targetSocPct != null && lp.targetSocPct >= 10 ? lp.targetSocPct : 80)),
+      recurring: lp.schedule?.recurring ?? false,
+      surplusUnlockPct: lp.schedule?.surplusUnlockPct ?? 0,
     }
   }
 
   function toggleDay(bit: number): void {
     if (draft) draft.days ^= 1 << bit
+    scheduleSave()
+  }
+
+  let scheduleNote = $state('Changes apply as you make them.')
+  let justSavedGoal = $state<{ id: string; readAt: number | null } | null>(null)
+  let removedGoalId = $state<string | null>(null)
+  $effect(() => {
+    if (!store.error && store.points.some(lp => lp.id === removedGoalId && lp.schedule)) removedGoalId = null
+    const saved = justSavedGoal
+    if (!saved || store.error || store.readAt === saved.readAt) return
+    const lp = store.points.find(point => point.id === saved.id)
+    if (lp && !lp.planPending && !store.planPending) justSavedGoal = null
+  })
+  let saveTimer: ReturnType<typeof setTimeout> | undefined
+  let pendingSchedule = $state(false)
+  let scheduleRevision = 0
+  onDestroy(() => {
+    // A released control is an instruction, including when the sheet closes.
+    if (saveTimer) { clearTimeout(saveTimer); saveTimer = undefined; void saveDraft() }
+  })
+
+  function scheduleSave(): void {
+    scheduleRevision++
+    saveError = null
+    scheduleNote = 'Applying schedule…'
+    pendingSchedule = true
+    clearTimeout(saveTimer)
+    saveTimer = setTimeout(() => { saveTimer = undefined; void saveDraft() }, 400)
   }
 
   async function saveDraft(): Promise<void> {
-    if (!draft) return
-    const minUtc = localInputToUtcMinutes(draft.time)
-    if (minUtc === null) {
-      saveError = 'That is not a time this app understands.'
+    if (!draft || saving) return
+    const next = { ...draft }
+    const revision = scheduleRevision
+    const minUtc = localInputToUtcMinutes(next.time)
+    pendingSchedule = false
+    if (!Number.isFinite(next.surplusUnlockPct) || next.surplusUnlockPct < 0 || next.surplusUnlockPct > 100) { saveError = 'Choose a home battery level from 1 to 100 %.'; return }
+    if (minUtc === null || (next.recurring && next.days === 0) || !Number.isFinite(next.socPct) || next.socPct < 10 || next.socPct > 100) {
+      saveError = minUtc === null ? 'Choose a valid ready time.' : next.recurring && next.days === 0 ? 'Choose at least one day.' : 'Choose a charge target from 10 to 100 %.'
       return
     }
     saving = true
@@ -173,40 +351,56 @@
     try {
       await callBox(untrack(() => site), {
         method: 'PUT',
-        path: `/api/loadpoints/${draft.lpId}/schedule`,
+        path: `/api/loadpoints/${encodeURIComponent(next.lpId)}/schedule`,
         body: {
-          soc_pct: draft.socPct,
+          soc: next.socPct / 100,
           time_of_day_min_utc: minUtc,
-          recurring: true,
-          // All seven days is the wire's zero — the canonical spelling of
-          // "every day", and what every schedule saved before masks
-          // existed already carries.
-          days: draft.days === 0x7f ? 0 : draft.days & 0x7f,
+          recurring: next.recurring,
+          days: !next.recurring || next.days === 0x7f ? 0 : next.days & 0x7f,
+          surplus_unlock_bat_soc: next.surplusUnlockPct / 100,
         },
       })
-      draft = null
-      await store.load()
+      justSavedGoal = { id: next.lpId, readAt: store.readAt }
+      if (revision === scheduleRevision) scheduleNote = 'Goal saved. Updating the plan…'
+      // A confirmed write stays confirmed if the following read fails.
+      // The plan can take longer than the charger read; polling follows it.
+      await store.loadChargers().catch(() => {})
+      refreshCharging(site)
+      if (revision === scheduleRevision) scheduleNote = 'Schedule saved.'
+      void store.load().catch(() => {})
     } catch (err) {
-      saveError =
-        err instanceof BoxApiError ? err.help : "Your box didn't answer. Nothing was changed."
+      if (revision === scheduleRevision) {
+        saveError = err instanceof BoxApiError ? err.help : "Your box didn't confirm the change. Check the current settings before trying again."
+      }
     } finally {
       saving = false
+      if (pendingSchedule) void saveDraft()
     }
   }
 
   async function removeSchedule(lpId: string): Promise<void> {
+    clearTimeout(saveTimer)
+    saveTimer = undefined
+    pendingSchedule = false
     saving = true
     saveError = null
+    scheduleNote = 'Removing goal…'
     try {
       await callBox(untrack(() => site), {
         method: 'DELETE',
-        path: `/api/loadpoints/${lpId}/schedule`,
+        path: `/api/loadpoints/${encodeURIComponent(lpId)}/schedule`,
       })
+      if (justSavedGoal?.id === lpId) justSavedGoal = null
+      removedGoalId = lpId
+      // The DELETE confirms these settings even if its status reread fails.
+      store.points = store.points.map(lp => lp.id === lpId ? { ...lp, schedule: null, targetSocPct: null } : lp)
       draft = null
-      await store.load()
+      await store.loadChargers().catch(() => {})
+      refreshCharging(site)
+      void store.load().catch(() => {})
     } catch (err) {
       saveError =
-        err instanceof BoxApiError ? err.help : "Your box didn't answer. Nothing was changed."
+        err instanceof BoxApiError ? err.help : "Your box didn't confirm the change. Reading its current settings…"
     } finally {
       saving = false
     }
@@ -217,13 +411,20 @@
 
 <!-- The fate of the last command, under the control that sent it. One
      command is in flight at a time, so the outcome belongs to exactly one. -->
-{#snippet outcome(of: Control)}
-  {#if store.command.kind === 'applied' && store.command.of === of}
-    <p class="hint">{DID[store.command.did]}</p>
-  {:else if store.command.kind === 'unconfirmed' && store.command.of === of}
-    <p class="hint">Your box took it. The charger hasn't confirmed yet.</p>
-  {:else if store.command.kind === 'failed' && store.command.of === of}
-    <p class="hint">{store.command.help}</p>
+{#snippet outcome(of: Control, lp: Loadpoint)}
+  {#if store.commandLpId === lp.id && store.command.kind === 'applied' && store.command.of === of && (of !== 'hold' || store.command.did === 'release')}
+    <p class="hint" role="status">{did(store.command.did, lp)}</p>
+  {:else if store.commandLpId === lp.id && store.command.kind === 'unconfirmed' && store.command.of === of}
+    <p class="hint" role="status">FTW received the request. Its result is not confirmed yet.</p>
+  {:else if store.commandLpId === lp.id && store.command.kind === 'failed' && store.command.of === of}
+    <p class="hint" role="alert">{store.command.help}</p>
+  {/if}
+  {#if !(store.commandLpId === lp.id && store.command.kind === 'applied' && store.command.of === of)}
+    {#if of === 'soc' && store.acceptedSoc[lp.id]}
+      <p class="hint" role="status">{did('soc', lp)}</p>
+    {:else if of === 'surplus' && store.acceptedSurplus[lp.id]}
+      <p class="hint" role="status">Solar rule accepted. Waiting for updated charging status.</p>
+    {/if}
   {/if}
 {/snippet}
 
@@ -234,22 +435,39 @@
      is a dialog, so what is behind it is inert to a screen reader. -->
 <div class="backdrop" onclick={onclose} aria-hidden="true"></div>
 
-<div class="sheet" role="dialog" aria-modal="true" aria-label="EV charger" tabindex="-1">
+<div class="sheet" bind:this={sheet} role="dialog" aria-modal="true" aria-label="EV charger" tabindex="-1">
   <header>
     <h2>EV charger</h2>
     <button class="close" onclick={onclose} aria-label="Close">Close</button>
   </header>
 
+  {#if site.session.phase === 'streaming' && !site.session.caps.has(CAP_API_PASSTHROUGH)}
+    <p class="note" role="status">Charging controls are not available from this box yet. Open the box’s own page to manage charging.</p>
+  {:else}
+  {#if site.session.phase !== 'streaming'}
+    <p class="note" role="status">Connecting to your box. Charging status will appear here when it answers.</p>
+  {/if}
   {#if store.error}
     <p class="note">{store.error}</p>
   {/if}
 
   {#if !store.loaded && !store.error}
-    <p class="note">Reading your box…</p>
+    {#if site.session.phase === 'streaming'}<p class="note">Reading your box…</p>{/if}
   {:else}
-    {#each store.points as lp (lp.id)}
+    {#if store.loaded && !store.error && store.points.length === 0}
+      <p class="note">{site.canConfigure ? 'Connect your first charger on your box: open Settings → Chargers, then choose Connect a charger.' : 'Ask an owner to connect the first charger on the box, under Settings → Chargers.'} Once connected and added there, it appears here too.</p>
+    {/if}
+    {#each store.points.filter(lp => !loadpointId || lp.id === loadpointId) as lp (lp.id)}
+      {@const planStatus = (lp.planPending || store.planPending) && justSavedGoal?.id === lp.id
+        ? 'Goal saved. Updating the plan…'
+        : evPlanSentence({ ...lp, planPending: lp.planPending || store.planPending, planOutdated: lp.planOutdated || store.planOutdated }, now, site.canConfigure)}
       <div class="charger">
-        <p class="status">{evStatusSentence(lp)}</p>
+        <p class="status" role="status" aria-live="polite">{stale ? 'Waiting for current charger status. The last reading is out of date.' : evStatusSentence(lp, site.canConfigure)}</p>
+        {#if lp.manualSaveError}<p class="hint" role="status">{MANUAL_SAVE_ERROR_TEXT}</p>{/if}
+        {#if !stale && planStatus}<p class="hint">{planStatus}</p>{/if}
+        {#if lp.charger?.updated_at_ms || lp.manual?.charger_updated_at_ms}
+          <p class="hint">Charger last seen: {clock(Number(lp.charger?.updated_at_ms ?? lp.manual?.charger_updated_at_ms))}</p>
+        {/if}
 
         {#if evSessionSentence(lp)}
           <p class="session">{evSessionSentence(lp)}</p>
@@ -263,7 +481,7 @@
                 Stop boost
               </button>
             </div>
-            {@render outcome('boost')}
+            {@render outcome('boost', lp)}
           {/if}
         {/if}
 
@@ -272,16 +490,72 @@
              Hidden from viewers as presentation — the box's refusal is the
              actual gate. Absent when the bay is empty, because "charge now"
              with no cable is a promise nobody can keep. -->
+        {#if lp.pluggedIn}
+          {@const level = socFor(lp)}
+          <!-- The car's level, above the charging controls as on the box's
+               own page: the estimate the plan runs from, and a slider to
+               correct it. Written on release, no button; the box replans
+               before it answers. Absent when the bay is empty, because
+               there is no car to hold a level. -->
+          <div class="control">
+            <div class="row">
+              <span class="label">Battery now</span>
+              <span class="readout">{lp.socSource === 'assumed' && socDraft[lp.id] === undefined && !store.acceptedSoc[lp.id] ? 'Not confirmed' : `${level} %`}</span>
+            </div>
+            {#if site.canConfigure}
+            <input
+              class="slider"
+              type="range"
+              min="0"
+              max="100"
+              step="1"
+              value={level}
+              aria-label="Car's current charge, percent"
+              disabled={sending}
+              oninput={(e) => editSoc(lp, Number(e.currentTarget.value))}
+              onchange={(e) => void setSoc(lp, Number(e.currentTarget.value))}
+            />
+            {/if}
+            {#if store.commandLpId === lp.id && store.command.kind === 'sending' && store.command.of === 'soc'}
+              <p class="hint">Sending charge level: {level} %…</p>
+            {:else if store.acceptedSoc[lp.id] || (store.commandLpId === lp.id && store.command.kind !== 'idle' && store.command.of === 'soc')}
+              {@render outcome('soc', lp)}
+            {:else}
+              <p class="hint">{site.canConfigure ? socSourceSentence(lp) : lp.socSource === 'assumed' ? 'Battery level needs confirmation by someone who can control this charger.' : lp.socSource === 'vehicle' ? 'Reported by the car.' : 'Estimated from energy delivered.'}</p>
+            {/if}
+          </div>
+
+        {/if}
+
+        {#if site.canConfigure && lp.vehicleCapacityWh != null}
+          <details class="extras">
+            <summary>Car battery · {lp.vehicleCapacityWh / 1000} kWh</summary>
+            <p class="hint">{lp.capacitySource === 'default' ? 'FTW is using a default size. Check it against your car.' : 'Used for estimates. Check this size if you use another car.'}</p>
+            <label class="row capacity">
+              <span>Usable battery size (kWh)</span>
+              <input type="number" min="1" max="300" step="0.1" inputmode="decimal"
+                aria-label="Usable battery size, kWh"
+                value={capacityDraft[lp.id] ?? String(lp.vehicleCapacityWh / 1000)}
+                disabled={capacityBusy[lp.id]}
+                oninput={(e) => { capacityDraft[lp.id] = e.currentTarget.value }}
+                onchange={() => void setCapacity(lp)} />
+            </label>
+            <p class="hint">Applies when you leave the field. Find the usable size in your car’s specifications.</p>
+            {#if capacityNote[lp.id]}<p class="hint" role={capacityFailed[lp.id] ? 'alert' : 'status'}>{capacityNote[lp.id]}</p>{/if}
+            {#if capacityFailed[lp.id]}<button class="quiet" disabled={capacityBusy[lp.id]} onclick={() => void setCapacity(lp)}>Try battery size again</button>{/if}
+          </details>
+        {/if}
+
         {#if site.canConfigure && lp.pluggedIn}
           {@const range = chargeCurrent(lp)}
           {@const chosen = ampsFor(lp)}
-          {@const held = heldAmps(lp)}
           <!-- The slider is the box's own page's: whole amps between the
                charger's floor and ceiling, sent as watts for a hold that
                runs until the car is full, Stop, or an unplug. -->
           <div class="control">
+            {#if lp.manualActive && !lp.manualRestoreUnconfirmed && !isPaused(lp)}
             <div class="row">
-              <span class="label">Charge now</span>
+              <span class="label">Charge now is active</span>
               <span class="readout">{currentReadout(lp, chosen)}</span>
             </div>
             <input
@@ -293,41 +567,184 @@
               value={chosen}
               aria-label="Charging current"
               disabled={sending}
-              oninput={(e) => (amps[lp.id] = Number(e.currentTarget.value))}
+              oninput={(e) => editAmps(lp, Number(e.currentTarget.value))}
+              onchange={(e) => { if (lp.manualActive) void setAmps(lp, Number(e.currentTarget.value)) }}
             />
+            {/if}
             <div class="actions">
-              {#if lp.manualActive}
-                <button
-                  class="primary"
-                  disabled={sending || chosen === held}
-                  onclick={() => void store.chargeNow(lp, chosen)}
-                >
-                  {sending ? 'Asking your box…' : 'Update'}
-                </button>
+              {#if lp.manualActive || lp.manualRestoreUnconfirmed}
                 <button class="quiet" disabled={sending} onclick={() => void store.stopCharging(lp)}>
-                  Stop charging
+                  {isPaused(lp) || lp.manualRestoreUnconfirmed ? 'Resume plan' : 'Return to plan'}
                 </button>
-              {:else}
+              {/if}
+              {#if !lp.manualActive || isPaused(lp) || lp.manualRestoreUnconfirmed}
                 <button
                   class="primary"
                   disabled={sending}
                   onclick={() => void store.chargeNow(lp, chosen)}
                 >
-                  {sending ? 'Asking your box…' : 'Charge now'}
+                  {store.command.kind === 'sending' && store.commandLpId === lp.id && store.command.of === 'hold' ? 'Sending charge request…' : 'Charge now'}
                 </button>
               {/if}
+              {#if !isPaused(lp)}
+                <button class="quiet" disabled={sending} onclick={() => void store.pauseCharging(lp)}>Pause charging</button>
+              {/if}
             </div>
             <p class="hint">
-              {#if lp.manualActive}
-                Charging now{held !== null ? ` at ${held} A` : ''} until the car is full. Stop it,
-                or unplug, and the plan takes back over.
+              {#if lp.manualRestoreUnconfirmed}
+                Choose Charge now to request charging, Resume plan to use your goal, or Pause charging to request a stop.
+              {:else if isPaused(lp)}
+                The goal and solar rule wait until you resume the plan. Charge now starts immediately.
+              {:else if lp.manualActive}
+                Changes apply when you release the slider. Return to plan restores your schedule and solar settings.
               {:else}
-                Runs at this current until the car is full, you stop it, or you unplug.
+                Starts at up to {currentReadout(lp, chosen)}. Ignores the goal and solar rule until you return to the plan or unplug.
               {/if}
             </p>
-            {@render outcome('hold')}
+            {@render outcome('hold', lp)}
           </div>
 
+        {/if}
+
+        <section class="goal" aria-label="Your goal">
+          <h3>Your goal</h3>
+          {#if lp.manualActive || lp.manualRestoreUnconfirmed}
+            <p class="hint">{isPaused(lp) || lp.manualRestoreUnconfirmed ? 'Resume the plan to use this goal. Edits apply then.' : 'Charge now overrides this goal. Edits apply when you return to the plan.'}</p>
+          {/if}
+        {#if draft?.lpId === lp.id}
+          <!-- Released controls write in order; the draft stays during rereads. -->
+          <div class="editor">
+            <div class="row">
+              <span class="label">Ready by</span>
+              <input type="time" aria-label="Ready by" bind:value={draft.time} onchange={scheduleSave} />
+            </div>
+            <label class="switch">
+              <input type="checkbox" bind:checked={draft.recurring} onchange={scheduleSave} />
+              <span>Repeat on chosen days</span>
+            </label>
+            {#if draft.recurring}
+            <div class="chips" role="group" aria-label="Days">
+              {#each DAY_LABELS as day, bit (day)}
+                <button
+                  class="chip"
+                  aria-pressed={(draft.days & (1 << bit)) !== 0}
+                  onclick={() => toggleDay(bit)}
+                >
+                  {day}
+                </button>
+              {/each}
+            </div>
+            {/if}
+            <div class="row">
+              <span class="label">Charge to</span>
+              <input
+                type="range"
+                class="slider"
+                aria-label="Target charge, percent"
+                min="10"
+                max="100"
+                step="5"
+                bind:value={draft.socPct}
+                onchange={scheduleSave}
+              />
+              <span class="readout">{draft.socPct} %</span>
+            </div>
+            <details class="extras">
+              <summary>Solar timing</summary>
+              <label class="switch">
+                <input type="checkbox" checked={draft.surplusUnlockPct > 0}
+                  onchange={(e) => { if (draft) draft.surplusUnlockPct = e.currentTarget.checked ? 50 : 0; scheduleSave() }} />
+                <span>Also use spare solar before the planned hours</span>
+              </label>
+              {#if draft.surplusUnlockPct > 0}
+                <label class="row">
+                  <span>Keep home battery above</span>
+                  <input type="number" min="1" max="100" step="1" bind:value={draft.surplusUnlockPct}
+                    onchange={scheduleSave} aria-label="Home battery solar threshold, percent" />
+                  <span>%</span>
+                </label>
+              {/if}
+            </details>
+            <div class="actions">
+              {#if !lp.schedule}
+                <button class="primary" disabled={saving || pendingSchedule} onclick={scheduleSave}>
+                  Use {draft.socPct} % by {draft.time}
+                </button>
+              {/if}
+              <button class="quiet" disabled={saving || pendingSchedule} onclick={() => (draft = null)}>
+                Close goal settings
+              </button>
+              {#if lp.schedule}
+                <button
+                  class="quiet"
+                  disabled={saving}
+                  onclick={() => void removeSchedule(lp.id)}
+                >
+                  Remove
+                </button>
+              {/if}
+            </div>
+            <p class="hint" role="status">{saveError ?? (scheduleNote === 'Schedule saved.' && store.error ? 'Schedule saved. Current charging status is unavailable.' : scheduleNote)}</p>
+            {#if saveError}
+              <button class="quiet" disabled={saving} onclick={scheduleSave}>Try again</button>
+            {/if}
+          </div>
+        {:else}
+          {#if removedGoalId === lp.id}
+            <p class="hint" role="status">{store.error ? 'Goal removed. Current charging status is unavailable.' : 'Goal removed.'}</p>
+          {/if}
+          {#if evScheduleSentence(lp)}
+            <div class="row">
+              <span>{evScheduleSentence(lp)}</span>
+              {#if site.canConfigure}
+                <button class="quiet edit" onclick={() => beginEdit(lp)}>Change goal</button>
+              {/if}
+            </div>
+          {:else if store.loaded && site.canConfigure}
+            <div class="row">
+              <button class="quiet edit" onclick={() => beginEdit(lp)}>
+                Set a ready time
+              </button>
+            </div>
+          {/if}
+          {#if saveError}
+            <p class="hint">{saveError}</p>
+          {/if}
+        {/if}
+        {#if site.canConfigure}
+          <!-- A standing setting rather than a hold: it outlives an unplug,
+               so it is offered whether or not a car is on the cable. The
+               box refuses a boost while it is on, and the boost row above
+               reads the same flag. -->
+          <label class="switch">
+            <input
+              type="checkbox"
+              role="switch"
+              checked={surplusFor(lp)}
+              disabled={sending || lp.manualActive || lp.manualRestoreUnconfirmed}
+              onchange={(e) => void setSurplusOnly(lp, e.currentTarget.checked)}
+            />
+            <span>Only spare solar</span>
+          </label>
+          <p class="hint">{lp.manualActive || lp.manualRestoreUnconfirmed
+            ? isPaused(lp) || lp.manualRestoreUnconfirmed ? 'This rule resumes with the plan.' : 'Charge now overrides this rule. It resumes when you return to the plan.'
+            : surplusFor(lp)
+              ? 'No grid or home battery. Your target may not be reached in time.'
+              : 'The plan may use grid power to reach your target.'}</p>
+          {#if store.command.kind === 'sending' && store.command.of === 'surplus'}
+            <p class="hint">Asking your box…</p>
+          {:else}
+            {@render outcome('surplus', lp)}
+          {/if}
+        {:else if lp.surplusOnly}
+          <p class="hint">Charges from spare solar only.</p>
+        {/if}
+
+        </section>
+
+        {#if site.canConfigure && lp.pluggedIn}
+          <details class="extras">
+            <summary>Home battery boost</summary>
           <!-- The boost: a bounded lease the box caps at four hours. The
                box refuses one while a hold runs or the charger is on spare
                solar only, so the offer says so up front from what the box
@@ -381,14 +798,14 @@
                 <p class="hint">
                   Ends when the time is up, the house battery reaches the reserve, or you stop it.
                 </p>
-                {@render outcome('boost')}
+                {@render outcome('boost', lp)}
               </div>
             {:else}
               <div class="row">
                 <span class="label">Battery boost</span>
                 {#if lp.manualActive}
-                  <span class="hint">Not while charging now — stop that first.</span>
-                {:else if lp.surplusOnly}
+                  <span class="hint">Available after returning to the plan.</span>
+                {:else if surplusFor(lp)}
                   <span class="hint">Not while the charger uses spare solar only.</span>
                 {:else}
                   <button class="quiet edit" onclick={() => beginBoost(lp)}>
@@ -396,100 +813,17 @@
                   </button>
                 {/if}
               </div>
-              {@render outcome('boost')}
+              {@render outcome('boost', lp)}
             {/if}
           {/if}
+          </details>
         {/if}
 
         {#if boostStoppedSentence(lp)}
           <p class="hint">{boostStoppedSentence(lp)}</p>
         {/if}
 
-        {#if draft?.lpId === lp.id}
-          <!-- One draft, one save, one ceremony. The box revalidates and
-               answers; what it stores is what the panel then rereads. -->
-          <div class="editor">
-            <div class="row">
-              <span class="label">Ready by</span>
-              <input type="time" bind:value={draft.time} disabled={saving} />
-            </div>
-            <div class="chips" role="group" aria-label="Days">
-              {#each DAY_LABELS as day, bit (day)}
-                <button
-                  class="chip"
-                  aria-pressed={(draft.days & (1 << bit)) !== 0}
-                  disabled={saving}
-                  onclick={() => toggleDay(bit)}
-                >
-                  {day}
-                </button>
-              {/each}
-            </div>
-            <div class="row">
-              <span class="label">Charge to</span>
-              <input
-                type="number"
-                min="10"
-                max="100"
-                step="5"
-                bind:value={draft.socPct}
-                disabled={saving}
-              />
-              <span>%</span>
-            </div>
-            <div class="actions">
-              <!-- Every day off is not a schedule — the wire has no way to
-                   say it, and zero would silently mean the opposite. -->
-              <button
-                class="primary"
-                disabled={saving || draft.days === 0}
-                onclick={() => void saveDraft()}
-              >
-                {saving ? 'Saving…' : 'Save schedule'}
-              </button>
-              <button class="quiet" disabled={saving} onclick={() => (draft = null)}>
-                Cancel
-              </button>
-              {#if lp.schedule}
-                <button
-                  class="quiet"
-                  disabled={saving}
-                  onclick={() => void removeSchedule(lp.id)}
-                >
-                  Remove
-                </button>
-              {/if}
-            </div>
-            {#if saveError}
-              <p class="hint">{saveError}</p>
-            {/if}
-          </div>
-        {:else}
-          {#if evScheduleSentence(lp)}
-            <div class="row">
-              <span class="label">Schedule</span>
-              <span>{evScheduleSentence(lp)}</span>
-              {#if site.canConfigure}
-                <button class="quiet edit" onclick={() => beginEdit(lp)}>Change</button>
-              {/if}
-            </div>
-          {:else if store.loaded && site.canConfigure}
-            <div class="row">
-              <span class="label">Schedule</span>
-              <button class="quiet edit" onclick={() => beginEdit(lp)}>
-                Set a charging schedule
-              </button>
-            </div>
-          {/if}
-          {#if saveError}
-            <p class="hint">{saveError}</p>
-          {/if}
-        {/if}
-        {#if lp.surplusOnly}
-          <p class="hint">Charges from spare solar only.</p>
-        {/if}
-
-        {#if (store.windows[lp.id] ?? []).length > 0}
+        {#if !lp.manualActive && !stale && !lp.planPending && !store.planPending && !lp.planOutdated && !store.planOutdated && (store.windows[lp.id] ?? []).length > 0}
           <div class="windows">
             <span class="label">Charging ahead</span>
             <ul>
@@ -497,25 +831,29 @@
                 <li>
                   <span class="when">{clock(w.fromMs)}–{clock(w.toMs)}</span>
                   <span class="power">
-                    up to {formatPower(w.peakW).text} {formatPower(w.peakW).unit}
+                    {#if w.energyWh !== undefined}
+                      {(w.energyWh / 1000).toLocaleString(undefined, { maximumFractionDigits: 1 })} kWh
+                    {:else if w.peakW !== null}
+                      up to {formatPower(w.peakW).text} {formatPower(w.peakW).unit}
+                    {/if}
                   </span>
                 </li>
               {/each}
             </ul>
           </div>
-        {:else if store.planMissing}
+        {:else if !lp.manualActive && !lp.planPending && !store.planPending && !lp.planOutdated && !store.planOutdated && store.planMissing}
           <!-- The plan read failed while the charger read did not. An empty
                list here would claim an idle week the app has not read. -->
           <p class="hint">Charging times aren't readable right now.</p>
         {/if}
       </div>
     {:else}
-      <!-- The box answered, and the answer is: no charger. The bubble that
-           opened this panel draws from a live field, so meeting this means
-           the charger left between two reads — say so plainly. -->
-      <p class="note">Your box no longer reports a charger.</p>
+      {#if store.loaded && !store.error && store.points.length > 0}
+        <p class="note">This charger is no longer listed. Close this view and choose a charger on the home screen.</p>
+      {/if}
     {/each}
   {/if}
+  {/if}
 </div>
 </div>
 
@@ -527,16 +865,18 @@
   .backdrop {
     position: fixed;
     inset: 0;
-    background: rgb(0 0 0 / 45%);
-    z-index: 40;
+    background: var(--scrim);
+    z-index: var(--z-overlay);
   }
 
   .sheet {
+    max-width: 34rem;
+    margin-inline: auto;
     position: fixed;
     left: 0;
     right: 0;
     bottom: 0;
-    z-index: 41;
+    z-index: var(--z-sheet);
     background: var(--surface-raised);
     border-top: 1px solid var(--line);
     border-radius: var(--radius-lg) var(--radius-lg) 0 0;
@@ -570,6 +910,19 @@
     font-size: 14px;
   }
 
+  .goal {
+    padding: var(--space-3);
+    border: 1px solid var(--line);
+    border-radius: var(--radius-md);
+    display: flex;
+    flex-direction: column;
+    gap: var(--space-3);
+  }
+
+  .goal h3 { font-size: 15px; font-weight: 500; }
+  .extras summary { cursor: pointer; font-size: 13px; color: var(--fg-dim); }
+  .extras[open] summary { margin-bottom: var(--space-3); }
+
   .charger {
     display: flex;
     flex-direction: column;
@@ -667,6 +1020,9 @@
     padding: var(--space-1) var(--space-2);
   }
 
+  .capacity { margin-top: var(--space-2); flex-wrap: wrap; }
+  .capacity input { width: 8ch; border: 1px solid var(--line); border-radius: var(--radius-xs); padding: var(--space-1); color: var(--fg); background: var(--surface-sunken); }
+
   .editor input[type='number'] {
     /* Three digits plus the browser's own spinner, or "84" clips to "8". */
     width: 8ch;
@@ -727,6 +1083,7 @@
   }
 
   .readout {
+    white-space: nowrap;
     margin-left: auto;
     font-family: var(--num);
   }
@@ -737,4 +1094,17 @@
     margin: 0;
     accent-color: var(--accent);
   }
+
+  /* Its one switch, likewise. */
+  .switch {
+    display: flex;
+    gap: var(--space-2);
+    align-items: baseline;
+    font-size: 14px;
+  }
+
+  .switch input {
+    margin: 0;
+    accent-color: var(--accent);
+  }
 </style>
diff --git a/src/views/EvPanel.svelte.test.ts b/src/views/EvPanel.svelte.test.ts
index d8dbb60..ba498e1 100644
--- a/src/views/EvPanel.svelte.test.ts
+++ b/src/views/EvPanel.svelte.test.ts
@@ -12,8 +12,17 @@ import EvPanel from './EvPanel.svelte'
 import { SiteStore } from '$lib/state/site.svelte'
 import { LoopbackCarrier } from '$lib/carrier/loopback'
 import { SimBox } from '$lib/sim/box'
-import { ROLE_VIEWER, OP_LOADPOINT_HOLD, OP_LOADPOINT_BOOST } from '$lib/protocol/messages'
+import { ApiError } from '$lib/protocol/session'
+import { CAP_API_PASSTHROUGH } from '$lib/protocol/contract'
+import {
+  ROLE_VIEWER,
+  OP_LOADPOINT_HOLD,
+  OP_LOADPOINT_BOOST,
+  OP_LOADPOINT_SOC_SET,
+  OP_LOADPOINT_SURPLUS_ONLY_SET,
+} from '$lib/protocol/messages'
 import { FID } from '$lib/format/explanation'
+import { wireBytes } from '$lib/protocol/frame'
 import { localInputToUtcMinutes, localClock } from '$lib/format/ev'
 
 // The ceremony, played by a hand. The sim's configure tier refuses without
@@ -86,6 +95,75 @@ describe('the charger behind its bubble', () => {
     expect(sheet?.getAttribute('aria-label')).not.toBe('EV charger')
   })
 
+  it('preserves a car-bubble tap before capabilities return and fills the same sheet when connected', async () => {
+    vi.useFakeTimers()
+    vi.setSystemTime(CHARGING_EVENING)
+    const site = await streaming()
+    const connected = site.session
+    site.session = { ...connected, phase: 'idle', caps: new Set() }
+    const api = vi.spyOn(site, 'api')
+    render(Now, { props: { site } })
+    await vi.advanceTimersByTimeAsync(50)
+    document.querySelector('ftw-energy-flow')!.dispatchEvent(
+      new CustomEvent('ftw-planet-click', { detail: { role: 'ev' }, bubbles: true })
+    )
+    await vi.advanceTimersByTimeAsync(50)
+    const sheet = document.querySelector('[role="dialog"]')!
+    expect(sheet.textContent).toContain('Connecting to your box.')
+    expect(api.mock.calls.filter(([req]) => req.path === '/api/loadpoints')).toHaveLength(0)
+    site.session = connected
+    await vi.advanceTimersByTimeAsync(500)
+    expect(document.querySelector('[role="dialog"]')).toBe(sheet)
+    expect(sheet.textContent).toMatch(/Charging at 7\.\d kW/)
+    expect(sheet.textContent).not.toContain('Connecting to your box.')
+  })
+
+  it('explains a known box without charging API support instead of ignoring the tap', async () => {
+    vi.useFakeTimers()
+    vi.setSystemTime(CHARGING_EVENING)
+    const connected = (await streaming()).session
+    const site = new SiteStore('older-box')
+    site.session = { ...connected, caps: new Set([...connected.caps].filter(cap => cap !== CAP_API_PASSTHROUGH)) }
+    const api = vi.spyOn(site, 'api')
+    render(Now, { props: { site } })
+    await vi.advanceTimersByTimeAsync(50)
+    document.querySelector('ftw-energy-flow')!.dispatchEvent(
+      new CustomEvent('ftw-planet-click', { detail: { role: 'ev' }, bubbles: true })
+    )
+    await vi.advanceTimersByTimeAsync(50)
+    expect(document.querySelector('[role="dialog"]')?.textContent).toContain('Charging controls are not available from this box yet.')
+    expect(document.querySelector('[role="dialog"]')?.textContent).toContain('Open the box’s own page')
+    expect(api.mock.calls.filter(([req]) => req.path === '/api/loadpoints')).toHaveLength(0)
+  })
+
+  it('recovers from a busy first read after opening the car bubble without claiming setup is missing', async () => {
+    vi.useFakeTimers()
+    vi.setSystemTime(CHARGING_EVENING)
+    const site = await streaming()
+    const api = site.api.bind(site)
+    let chargerReads = 0
+    vi.spyOn(site, 'api').mockImplementation((req) => {
+      if (req.path === '/api/loadpoints' && ++chargerReads <= 2) {
+        return Promise.reject(new ApiError({ code: 'E_UNAVAILABLE', retryable: true, args: { reason: 'busy' } }))
+      }
+      return api(req)
+    })
+    const command = vi.spyOn(site, 'command')
+    render(Now, { props: { site } })
+    await vi.advanceTimersByTimeAsync(50)
+    document.querySelector('ftw-energy-flow')!.dispatchEvent(
+      new CustomEvent('ftw-planet-click', { detail: { role: 'ev' }, bubbles: true })
+    )
+    await vi.advanceTimersByTimeAsync(500)
+    const sheet = document.querySelector('[role="dialog"]')!
+    expect(sheet.textContent).toContain('Your box is busy')
+    expect(sheet.textContent).not.toMatch(/not set up|Connect your first charger/)
+    await vi.advanceTimersByTimeAsync(12_000)
+    expect(sheet.textContent).toMatch(/Charging at 7\.\d kW/)
+    expect(sheet.textContent).not.toContain('Your box is busy')
+    expect(command).not.toHaveBeenCalled()
+  })
+
   it('closes on Escape and on the backdrop', async () => {
     vi.useFakeTimers()
     vi.setSystemTime(CHARGING_EVENING)
@@ -155,7 +233,7 @@ describe('the charger behind its bubble', () => {
     await vi.advanceTimersByTimeAsync(500)
 
     const change = [...document.querySelectorAll('button')].find(
-      (b) => b.textContent?.trim() === 'Change'
+      (b) => b.textContent?.trim() === 'Change goal'
     )!
     expect(change, 'no way in to the editor for an owner').toBeDefined()
     change.click()
@@ -177,9 +255,7 @@ describe('the charger behind its bubble', () => {
     }
 
     const put = vi.spyOn(box.api, 'serve')
-    ;[...document.querySelectorAll('button')]
-      .find((b) => b.textContent?.trim() === 'Save schedule')!
-      .click()
+    document.querySelector('input[type="time"]')!.dispatchEvent(new Event('change', { bubbles: true }))
     await vi.advanceTimersByTimeAsync(1_000)
 
     // One ceremony for the whole draft, not one per field.
@@ -195,8 +271,161 @@ describe('the charger behind its bubble', () => {
     expect(bodyOnWire.recurring).toBe(true)
 
     // The panel reread the box rather than trusting its own draft.
-    expect(document.body.textContent).toContain(`Ready by ${localClock(bodyOnWire.time_of_day_min_utc)}`)
-    expect(document.body.textContent).toContain('weekdays')
+    expect((document.querySelector('input[type="time"]') as HTMLInputElement).value).toBe('08:00')
+    expect(document.body.textContent).toContain('Schedule saved')
+  })
+
+  it('confirms a saved goal while a long replan hides old windows, then shows the new plan without another write', async () => {
+    vi.useFakeTimers()
+    vi.setSystemTime(CHARGING_EVENING)
+    const box = new SimBox({ now: () => Date.now() })
+    const site = new SiteStore('test')
+    site.connect(new LoopbackCarrier(box, { latencyMs: 5 }))
+    for (let i = 0; i < 100 && site.session.phase !== 'streaming'; i++) await vi.advanceTimersByTimeAsync(10)
+    let pending = false
+    let outdated = false
+    let writes = 0
+    const serve = box.api.serve.bind(box.api)
+    vi.spyOn(box.api, 'serve').mockImplementation(req => {
+      const answer = serve(req)
+      if (req.method === 'PUT' && req.path.endsWith('/schedule') && req.stepUp && 'status' in answer && answer.status === 200) {
+        pending = true
+        writes++
+      }
+      if ('body' in answer && (req.path === '/api/loadpoints' || req.path === '/api/mpc/plan')) {
+        const payload = JSON.parse(new TextDecoder().decode(answer.body))
+        if (req.path === '/api/loadpoints') for (const lp of payload.loadpoints) {
+          lp.plan_pending = pending; lp.plan_outdated = outdated
+          lp.plan_windows = [{ start_ms: CHARGING_EVENING, end_ms: CHARGING_EVENING + 3_600_000, wh: 4600 }]
+        }
+        else payload.meta = { ...payload.meta, replanning: pending, outdated }
+        answer.body = wireBytes(new TextEncoder().encode(JSON.stringify(payload)))
+      }
+      return answer
+    })
+    render(EvPanel, { props: { site, onclose: () => {} } })
+    await vi.advanceTimersByTimeAsync(500)
+    expect(document.body.textContent).toContain('Charging ahead')
+    ;[...document.querySelectorAll('button')].find(b => b.textContent?.trim() === 'Change goal')!.click()
+    await vi.advanceTimersByTimeAsync(20)
+    const target = document.querySelector('[aria-label="Target charge, percent"]') as HTMLInputElement
+    target.value = '85'
+    target.dispatchEvent(new Event('input', { bubbles: true }))
+    target.dispatchEvent(new Event('change', { bubbles: true }))
+    await vi.advanceTimersByTimeAsync(1_000)
+    expect(document.body.textContent).toContain('Schedule saved.')
+    expect(document.body.textContent).toContain('Goal saved. Updating the plan…')
+    expect(document.body.textContent).not.toContain('Charging ahead')
+    expect(document.body.textContent).toMatch(/Charging at 7\.\d kW/)
+    await vi.advanceTimersByTimeAsync(45_000)
+    expect(document.body.textContent).toContain('Goal saved. Updating the plan…')
+    expect(document.body.textContent).not.toContain('Try again')
+    expect(writes).toBe(1)
+    pending = false
+    outdated = true
+    await vi.advanceTimersByTimeAsync(6_000)
+    expect(document.body.textContent).toContain('Charging times are unavailable. Your settings are saved.')
+    expect(document.body.textContent).not.toContain('Updating the plan')
+    expect(document.body.textContent).not.toContain('Charging ahead')
+    expect(document.body.textContent).toMatch(/Charging at 7\.\d kW/)
+    expect(writes).toBe(1)
+    outdated = false
+    await vi.advanceTimersByTimeAsync(6_000)
+    expect(document.body.textContent).not.toContain('Updating the plan')
+    expect(document.body.textContent).not.toContain('Charging times are unavailable.')
+    expect(document.body.textContent).toContain('Charging ahead')
+    expect(writes).toBe(1)
+    pending = true // A later routine replan is not another save by this owner.
+    await vi.advanceTimersByTimeAsync(6_000)
+    expect(document.body.textContent).toContain('Updating the charging plan…')
+    expect(document.body.textContent).not.toContain('Goal saved. Updating the plan…')
+    expect(writes).toBe(1)
+  })
+
+  it('keeps a successful save confirmed when its status read fails and recovers without rewriting', async () => {
+    vi.useFakeTimers()
+    vi.setSystemTime(CHARGING_EVENING)
+    const site = await streaming()
+    render(EvPanel, { props: { site, onclose: () => {} } })
+    await vi.advanceTimersByTimeAsync(500)
+    let failRead = false
+    let writes = 0
+    const api = site.api.bind(site)
+    vi.spyOn(site, 'api').mockImplementation(async req => {
+      if (failRead && req.path === '/api/loadpoints') throw new ApiError({ code: 'E_UNAVAILABLE', retryable: true, args: { reason: 'busy' } })
+      const answer = await api(req)
+      if (req.method === 'PUT' && answer.status === 200) { failRead = true; writes++ }
+      return answer
+    })
+    ;[...document.querySelectorAll('button')].find(b => b.textContent?.trim() === 'Change goal')!.click()
+    await vi.advanceTimersByTimeAsync(20)
+    document.querySelector('input[type="time"]')!.dispatchEvent(new Event('change', { bubbles: true }))
+    await vi.advanceTimersByTimeAsync(1_000)
+    expect(document.body.textContent).toContain('Schedule saved. Current charging status is unavailable.')
+    expect(document.body.textContent).not.toContain('Try again')
+    expect(writes).toBe(1)
+    failRead = false
+    await vi.advanceTimersByTimeAsync(6_000)
+    expect(document.body.textContent).toContain('Schedule saved.')
+    expect(document.body.textContent).not.toContain('Current charging status is unavailable.')
+    expect(writes).toBe(1)
+  })
+
+  it('serializes schedule edits while an earlier save is slow', async () => {
+    vi.useFakeTimers()
+    vi.setSystemTime(CHARGING_EVENING)
+    const site = await streaming()
+    render(EvPanel, { props: { site, onclose: () => {} } })
+    await vi.advanceTimersByTimeAsync(500)
+    ;[...document.querySelectorAll('button')].find(b => b.textContent?.trim() === 'Change goal')!.click()
+    await vi.advanceTimersByTimeAsync(20)
+    const original = site.api.bind(site)
+    let release!: () => void
+    const gate = new Promise<void>(r => { release = r })
+    let active = 0, peak = 0
+    const sent: number[] = []
+    vi.spyOn(site, 'api').mockImplementation(async request => {
+      if (request.method !== 'PUT') return original(request)
+      const body = JSON.parse(new TextDecoder().decode(request.body ?? undefined))
+      if (!request.stepUp) {
+        active++; peak = Math.max(peak, active); sent.push(body.soc)
+        if (sent.length === 1) await gate
+      }
+      try { return await original(request) } finally { if (!request.stepUp) active-- }
+    })
+    const target = document.querySelector<HTMLInputElement>('[aria-label="Target charge, percent"]')!
+    target.value = '70'; target.dispatchEvent(new Event('input', { bubbles: true })); target.dispatchEvent(new Event('change', { bubbles: true }))
+    await vi.advanceTimersByTimeAsync(500)
+    target.value = '90'; target.dispatchEvent(new Event('input', { bubbles: true })); target.dispatchEvent(new Event('change', { bubbles: true }))
+    await vi.advanceTimersByTimeAsync(500)
+    expect(sent).toEqual([0.7])
+    expect(document.body.textContent).toContain('Applying schedule')
+    release(); await vi.advanceTimersByTimeAsync(2000)
+    expect(sent).toEqual([0.7, 0.9])
+    expect(peak).toBe(1)
+    expect(target.value).toBe('90')
+    expect(document.body.textContent).toContain('Schedule saved')
+  })
+
+  it('does not erase a new SOC drag when an earlier readback arrives', async () => {
+    vi.useFakeTimers()
+    vi.setSystemTime(CHARGING_EVENING)
+    const site = await streaming()
+    render(EvPanel, { props: { site, onclose: () => {} } })
+    await vi.advanceTimersByTimeAsync(500)
+    const original = site.api.bind(site)
+    let release!: () => void
+    const gate = new Promise<void>(r => { release = r })
+    vi.spyOn(site, 'api').mockImplementation(async request => {
+      if (request.method === 'GET' && request.path === '/api/loadpoints') await gate
+      return original(request)
+    })
+    const soc = document.querySelector<HTMLInputElement>('[aria-label="Car\'s current charge, percent"]')!
+    soc.value = '30'; soc.dispatchEvent(new Event('input', { bubbles: true })); soc.dispatchEvent(new Event('change', { bubbles: true }))
+    await vi.advanceTimersByTimeAsync(100)
+    soc.value = '40'; soc.dispatchEvent(new Event('input', { bubbles: true }))
+    release(); await vi.advanceTimersByTimeAsync(1000)
+    expect(soc.value).toBe('40')
   })
 
   it('shows a viewer the schedule but never the pen', async () => {
@@ -215,7 +444,7 @@ describe('the charger behind its bubble', () => {
 
     expect(document.body.textContent).toContain('Ready by')
     expect([...document.querySelectorAll('button')].map((b) => b.textContent?.trim())).not.toContain(
-      'Change'
+      'Change goal'
     )
   })
 
@@ -238,18 +467,16 @@ describe('the charger behind its bubble', () => {
     const before = document.body.textContent
 
     ;[...document.querySelectorAll('button')]
-      .find((b) => b.textContent?.trim() === 'Change')!
+      .find((b) => b.textContent?.trim() === 'Change goal')!
       .click()
     await vi.advanceTimersByTimeAsync(50)
-    ;[...document.querySelectorAll('button')]
-      .find((b) => b.textContent?.trim() === 'Save schedule')!
-      .click()
+    document.querySelector('input[type="time"]')!.dispatchEvent(new Event('change', { bubbles: true }))
     await vi.advanceTimersByTimeAsync(1_000)
 
     expect(document.body.textContent).toContain('Nothing was changed')
     // Cancel out and the schedule reads exactly as before the attempt.
     ;[...document.querySelectorAll('button')]
-      .find((b) => b.textContent?.trim() === 'Cancel')!
+      .find((b) => b.textContent?.trim() === 'Close goal settings')!
       .click()
     await vi.advanceTimersByTimeAsync(200)
     expect(document.body.textContent).toContain(
@@ -272,7 +499,7 @@ describe('the charger behind its bubble', () => {
     await vi.advanceTimersByTimeAsync(500)
     expect(document.body.textContent).toContain('Ready by')
     ;[...document.querySelectorAll('button')]
-      .find((b) => b.textContent?.trim() === 'Change')!
+      .find((b) => b.textContent?.trim() === 'Change goal')!
       .click()
     await vi.advanceTimersByTimeAsync(50)
     ;[...document.querySelectorAll('button')]
@@ -282,7 +509,68 @@ describe('the charger behind its bubble', () => {
 
     // No sentence claims a schedule; the offer to set one takes its place.
     expect(document.body.textContent).not.toContain('Ready by')
-    expect(document.body.textContent).toContain('Set a charging schedule')
+    expect(document.body.textContent).toContain('Set a ready time')
+    // Accept the shown proposal without moving either control away and back.
+    ;[...document.querySelectorAll('button')].find(b => b.textContent?.trim() === 'Set a ready time')!.click()
+    await vi.advanceTimersByTimeAsync(50)
+    const use = [...document.querySelectorAll('button')].find(b => /^Use \d+ % by 07:00$/.test(b.textContent?.trim() ?? ''))!
+    expect(use?.textContent?.trim()).toBe('Use 80 % by 07:00')
+    const expectedSoc = Number(use.textContent!.trim().match(/^Use (\d+)/)![1]) / 100
+    const put = vi.spyOn(box.api, 'serve')
+    use.click()
+    await vi.advanceTimersByTimeAsync(1000)
+    const writes = put.mock.calls.filter(c => c[0].method === 'PUT' && c[0].path.endsWith('/schedule') && c[0].stepUp)
+    expect(writes).toHaveLength(1)
+    const selected = JSON.parse(new TextDecoder().decode(writes[0]![0].body!))
+    expect(selected.soc).toBe(expectedSoc)
+    expect(selected.time_of_day_min_utc).toBe(localInputToUtcMinutes('07:00'))
+    expect(document.body.textContent).toContain('Schedule saved')
+  })
+
+  it.each([false, true])('confirms Remove during a pending save replan even when its reread fails: %s', async failRead => {
+    vi.useFakeTimers()
+    vi.setSystemTime(CHARGING_EVENING)
+    const site = await streaming()
+    const api = site.api.bind(site)
+    let deleted = false, pending = true
+    const asked = vi.spyOn(site, 'api').mockImplementation(async req => {
+      if (deleted && failRead && req.path === '/api/loadpoints') throw new Error('read unavailable')
+      const answer = await api(req)
+      if (req.method === 'DELETE' && answer.status === 200) deleted = true
+      if (req.path === '/api/loadpoints') {
+        const payload = JSON.parse(new TextDecoder().decode(answer.body))
+        Object.assign(payload.loadpoints[0], { plan_pending: pending, plan_outdated: pending })
+        return { ...answer, body: new TextEncoder().encode(JSON.stringify(payload)) }
+      }
+      return answer
+    })
+    render(EvPanel, { props: { site, onclose: () => {} } })
+    await vi.advanceTimersByTimeAsync(500)
+    ;[...document.querySelectorAll('button')].find(b => b.textContent?.trim() === 'Change goal')!.click()
+    await vi.advanceTimersByTimeAsync(20)
+    const target = document.querySelector<HTMLInputElement>('[aria-label="Target charge, percent"]')!
+    target.value = '85'; target.dispatchEvent(new Event('input', { bubbles: true })); target.dispatchEvent(new Event('change', { bubbles: true }))
+    await vi.advanceTimersByTimeAsync(1_000)
+    expect(document.body.textContent).toContain('Goal saved. Updating the plan…')
+    ;[...document.querySelectorAll('button')].find(b => b.textContent?.trim() === 'Remove')!.click()
+    await vi.advanceTimersByTimeAsync(0)
+    expect.soft(document.body.textContent).toContain('Removing goal…')
+    await vi.advanceTimersByTimeAsync(1_000)
+    expect.soft(document.body.textContent).toContain(failRead ? 'Goal removed. Current charging status is unavailable.' : 'Goal removed.')
+    expect(document.body.textContent).not.toContain('Goal saved')
+    expect(document.body.textContent).not.toContain('Ready by')
+    expect(document.body.textContent).toContain('Set a ready time')
+    expect(document.body.textContent).not.toContain('Try again')
+    failRead = false
+    await vi.advanceTimersByTimeAsync(6_000)
+    expect(document.body.textContent).toContain('Updating the charging plan…')
+    expect(document.body.textContent).not.toContain('Goal saved')
+    pending = false
+    await vi.advanceTimersByTimeAsync(6_000)
+    expect(document.body.textContent).toContain('Goal removed.')
+    expect(document.body.textContent).not.toContain('Current charging status is unavailable.')
+    expect(document.body.textContent).not.toContain('Goal saved')
+    expect(asked.mock.calls.filter(([req]) => req.method === 'DELETE' && req.stepUp)).toHaveLength(1)
   })
 
   it('charges now through the door, and the whole household says so', async () => {
@@ -311,9 +599,9 @@ describe('the charger behind its bubble', () => {
     // what happens now.
     expect(document.body.textContent).toMatch(/Charging at 11 kW/)
     expect(
-      [...document.querySelectorAll('button')].some((b) => b.textContent?.trim() === 'Stop charging')
+      [...document.querySelectorAll('button')].some((b) => b.textContent?.trim() === 'Return to plan')
     ).toBe(true)
-    expect(document.body.textContent).toContain('the plan takes back over')
+    expect(document.body.textContent).toContain('Return to plan restores')
 
     // And the 1 Hz stream tells the same story — one household, whichever
     // surface asks.
@@ -340,11 +628,11 @@ describe('the charger behind its bubble', () => {
       .click()
     await vi.advanceTimersByTimeAsync(1_000)
     ;[...document.querySelectorAll('button')]
-      .find((b) => b.textContent?.trim() === 'Stop charging')!
+      .find((b) => b.textContent?.trim() === 'Return to plan')!
       .click()
     await vi.advanceTimersByTimeAsync(1_000)
 
-    expect(document.body.textContent).toContain('the plan decides again')
+    expect(document.body.textContent).toContain('The plan decides when to charge')
     expect(
       [...document.querySelectorAll('button')].some((b) => b.textContent?.trim() === 'Charge now')
     ).toBe(true)
@@ -418,9 +706,8 @@ describe('the charger behind its bubble', () => {
 
     carrier.drop('wire died')
     await vi.advanceTimersByTimeAsync(5_000)
-    expect(document.body.textContent, 'the charger vanished instead of aging').toMatch(
-      /Charging at/
-    )
+    expect(document.body.textContent).toContain('The last reading is out of date')
+    expect(document.querySelector('[aria-label="Car\'s current charge, percent"]')).not.toBeNull()
     const whileDown = asked.mock.calls.length
 
     carrier.restore()
@@ -450,27 +737,37 @@ describe('the charger behind its bubble', () => {
       (b) => b.textContent?.trim() === label
     )
 
-  const slider = () => document.querySelector<HTMLInputElement>('input[type="range"]')
+  const slider = () => document.querySelector<HTMLInputElement>('input[aria-label="Charging current"]')
+  const socSlider = () =>
+    document.querySelector<HTMLInputElement>('input[aria-label="Car\'s current charge, percent"]')
+  const pvOnly = () => document.querySelector<HTMLInputElement>('input[role="switch"]')
 
-  /** Move the thumb the way a browser reports it. */
-  function slide(to: number): void {
-    const s = slider()!
+  /** Move a thumb the way a browser reports it, and let go of it. */
+  function slideTo(s: HTMLInputElement, to: number): void {
     s.value = String(to)
     s.dispatchEvent(new Event('input', { bubbles: true }))
   }
+  function release(s: HTMLInputElement): void {
+    s.dispatchEvent(new Event('change', { bubbles: true }))
+  }
+  const slide = (to: number) => slideTo(slider()!, to)
 
   it("offers the charger's own range of current, at its ceiling by default", async () => {
     vi.useFakeTimers()
     vi.setSystemTime(CHARGING_EVENING)
     await openedFor()
 
+    expect(slider()).toBeNull()
+    expect(document.body.textContent).toContain('Starts at up to 16 A')
+    button('Charge now')!.click()
+    await vi.advanceTimersByTimeAsync(1_000)
     const s = slider()
-    expect(s, 'no slider for an owner with a plugged car').not.toBeNull()
+    expect(s, 'manual current must be editable after Charge now').not.toBeNull()
     expect(s!.min).toBe('6')
     expect(s!.max).toBe('16')
     expect(s!.value).toBe('16')
     expect(document.body.textContent).toContain('16 A · 11.0 kW')
-    expect(document.body.textContent).toContain('until the car is full')
+    expect(document.body.textContent).toContain('Charge now is active')
   })
 
   it('charges now at the current the thumb chose, and the whole household says so', async () => {
@@ -478,12 +775,14 @@ describe('the charger behind its bubble', () => {
     vi.setSystemTime(CHARGING_EVENING)
     const { box, site } = await openedFor()
 
+    button('Charge now')!.click()
+    await vi.advanceTimersByTimeAsync(1_000)
+    const sent = vi.spyOn(site, 'command')
     slide(10)
     await vi.advanceTimersByTimeAsync(50)
     expect(document.body.textContent).toContain('10 A · 6.9 kW')
-
-    const sent = vi.spyOn(site, 'command')
-    button('Charge now')!.click()
+    expect(sent).not.toHaveBeenCalled()
+    release(slider()!)
     await vi.advanceTimersByTimeAsync(1_000)
 
     // The box page's own body: the watts for 10 A, a persistent hold, three
@@ -495,12 +794,12 @@ describe('the charger behind its bubble', () => {
       phase_mode: '3p',
     })
     expect(document.body.textContent).toMatch(/Charging at 6\.9 kW/)
-    expect(document.body.textContent).toContain('at 10 A until the car is full')
-    expect(button('Update')).toBeDefined()
-    expect(button('Stop charging')).toBeDefined()
+    expect(document.body.textContent).toContain('Changes apply when you release the slider')
+    expect(button('Update')).toBeUndefined()
+    expect(button('Return to plan')).toBeDefined()
     // The thumb stays put, and Update has nothing new to send yet.
     expect(slider()!.value).toBe('10')
-    expect(button('Update')!.disabled).toBe(true)
+    expect(button('Update')).toBeUndefined()
 
     box.tick()
     await vi.advanceTimersByTimeAsync(100)
@@ -514,23 +813,60 @@ describe('the charger behind its bubble', () => {
 
     button('Charge now')!.click()
     await vi.advanceTimersByTimeAsync(1_000)
-    expect(document.body.textContent).toContain('at 16 A until the car is full')
-
-    slide(8)
-    await vi.advanceTimersByTimeAsync(50)
-    expect(button('Update')!.disabled).toBe(false)
+    expect(document.body.textContent).toContain('Changes apply when you release the slider')
 
     const sent = vi.spyOn(site, 'command')
-    button('Update')!.click()
+    slide(8)
+    expect(sent).not.toHaveBeenCalled()
+    slider()!.dispatchEvent(new Event('change', { bubbles: true }))
     await vi.advanceTimersByTimeAsync(1_000)
     expect(sent).toHaveBeenCalledWith(
       OP_LOADPOINT_HOLD,
       expect.objectContaining({ power_w: 5520, hold_s: 0 })
     )
-    expect(document.body.textContent).toContain('at 8 A until the car is full')
+    expect(document.body.textContent).toContain('Changes apply when you release the slider')
     expect(document.body.textContent).toMatch(/Charging at 5\.5 kW/)
   })
 
+  it('opening goal settings does not change charging, and a one-off goal stays one-off', async () => {
+    vi.useFakeTimers()
+    vi.setSystemTime(CHARGING_EVENING)
+    const { site } = await openedFor()
+    const asked = vi.spyOn(site, 'api')
+    const sent = vi.spyOn(site, 'command')
+    button('Change goal')!.click()
+    await vi.advanceTimersByTimeAsync(100)
+    expect(asked.mock.calls.filter(c => c[0].method !== 'GET')).toHaveLength(0)
+    expect(sent).not.toHaveBeenCalled()
+    const repeat = [...document.querySelectorAll('label')].find(l => l.textContent?.includes('Repeat on chosen days'))!.querySelector('input')!
+    expect(repeat.checked).toBe(true)
+    repeat.click()
+    await vi.advanceTimersByTimeAsync(1_000)
+    const saved = asked.mock.calls.find(c => c[0].method === 'PUT')![0]
+    const body = JSON.parse(new TextDecoder().decode(saved.body!))
+    expect(body.recurring).toBe(false)
+    expect(body.days).toBe(0)
+    expect(body).toHaveProperty('surplus_unlock_bat_soc')
+  })
+
+  it('shows that Charge now overrides the goal and solar rule until Return to plan', async () => {
+    vi.useFakeTimers()
+    vi.setSystemTime(CHARGING_EVENING)
+    const { site } = await openedFor()
+    button('Charge now')!.click()
+    await vi.advanceTimersByTimeAsync(1_000)
+    expect(document.body.textContent).toContain('Charge now overrides this goal')
+    expect(document.body.textContent).not.toContain('Charging ahead')
+    expect(pvOnly()!.disabled).toBe(true)
+    const sent = vi.spyOn(site, 'command')
+    pvOnly()!.click()
+    expect(sent).not.toHaveBeenCalled()
+    button('Return to plan')!.click()
+    await vi.advanceTimersByTimeAsync(1_000)
+    expect(pvOnly()!.disabled).toBe(false)
+    expect(slider()).toBeNull()
+  })
+
   it('boosts from the house battery and stops it, saying why it ended', async () => {
     vi.useFakeTimers()
     vi.setSystemTime(CHARGING_EVENING)
@@ -540,7 +876,7 @@ describe('the charger behind its bubble', () => {
     await vi.advanceTimersByTimeAsync(50)
 
     // The box page's own defaults: a 30 % reserve for an hour.
-    const reserve = document.querySelector<HTMLInputElement>('input[type="number"]')!
+    const reserve = document.querySelector<HTMLInputElement>('[aria-label="House battery reserve"]')!
     expect(reserve.value).toBe('30')
     expect(button('1 h')!.getAttribute('aria-pressed')).toBe('true')
     button('2 h')!.click()
@@ -578,7 +914,286 @@ describe('the charger behind its bubble', () => {
     await vi.advanceTimersByTimeAsync(1_000)
 
     expect(button('Boost from the house battery')).toBeUndefined()
-    expect(document.body.textContent).toContain('stop that first')
+    expect(document.body.textContent).toContain('Available after returning to the plan')
+  })
+
+  it('explains where to connect a first charger instead of showing an empty panel', async () => {
+    vi.useFakeTimers()
+    vi.setSystemTime(CHARGING_EVENING)
+    const { box } = await openedFor()
+    const serve = box.api.serve.bind(box.api)
+    vi.spyOn(box.api, 'serve').mockImplementation(req => {
+      const answer = serve(req)
+      if (req.path === '/api/loadpoints' && 'body' in answer) answer.body = wireBytes(new TextEncoder().encode(JSON.stringify({ loadpoints: [] })))
+      return answer
+    })
+    await vi.advanceTimersByTimeAsync(5_000)
+    expect(document.body.textContent).toContain('Connect your first charger on your box: open Settings → Chargers, then choose Connect a charger.')
+    expect(document.body.textContent).toContain('Once connected and added there, it appears here too.')
+    expect(button('Charge now')).toBeUndefined()
+  })
+
+  it('offers three explicit choices when the charger or connection is unconfirmed', async () => {
+    vi.useFakeTimers()
+    vi.setSystemTime(CHARGING_EVENING)
+    const { box, site } = await openedFor()
+    const serve = box.api.serve.bind(box.api)
+    let waiting = true
+    vi.spyOn(box.api, 'serve').mockImplementation(req => {
+      const answer = serve(req)
+      if (waiting && req.path === '/api/loadpoints' && 'body' in answer) {
+        const payload = JSON.parse(new TextDecoder().decode(answer.body))
+        Object.assign(payload.loadpoints[0], { manual_restore_unconfirmed: true, manual_active: false })
+        answer.body = wireBytes(new TextEncoder().encode(JSON.stringify(payload)))
+      }
+      return answer
+    })
+    await vi.advanceTimersByTimeAsync(5_000)
+    expect(document.body.textContent).toContain('Confirm how to continue charging')
+    expect(document.body.textContent).not.toContain('Paused by you')
+    for (const choice of ['Charge now', 'Resume plan', 'Pause charging']) expect(button(choice)).toBeDefined()
+    expect(slider()).toBeNull()
+    waiting = false
+    const sent = vi.spyOn(site, 'command')
+    button('Pause charging')!.click()
+    await vi.advanceTimersByTimeAsync(1_000)
+    expect(sent).toHaveBeenCalledWith(OP_LOADPOINT_HOLD, { id: 'carport', power_w: 0, hold_s: 0 })
+    expect(document.body.textContent).toContain('Paused by you')
+    expect(document.body.textContent).not.toContain('Confirm how to continue charging')
+  })
+
+  it('reports unsaved charging intent until a later poll confirms recovery', async () => {
+    vi.useFakeTimers()
+    vi.setSystemTime(CHARGING_EVENING)
+    const { box } = await openedFor()
+    button('Pause charging')!.click()
+    await vi.advanceTimersByTimeAsync(1_000)
+    const serve = box.api.serve.bind(box.api)
+    let saveFailed = true
+    vi.spyOn(box.api, 'serve').mockImplementation(req => {
+      const answer = serve(req)
+      if (req.path === '/api/loadpoints' && 'body' in answer) {
+        const payload = JSON.parse(new TextDecoder().decode(answer.body))
+        payload.loadpoints[0].manual_save_error = saveFailed
+        answer.body = wireBytes(new TextEncoder().encode(JSON.stringify(payload)))
+      }
+      return answer
+    })
+    await vi.advanceTimersByTimeAsync(5_000)
+    expect(document.body.textContent).toContain('Paused by you')
+    expect(document.body.textContent).toContain('This choice is active now, but could not be saved for restart. FTW is retrying.')
+    expect(button('Save')).toBeUndefined()
+    saveFailed = false
+    await vi.advanceTimersByTimeAsync(5_000)
+    expect(document.body.textContent).not.toContain('could not be saved for restart')
+    expect(document.body.textContent).toContain('Paused by you')
+  })
+
+  it('pauses without removing the goal and resumes only when asked', async () => {
+    vi.useFakeTimers()
+    vi.setSystemTime(CHARGING_EVENING)
+    const { site } = await openedFor()
+    const sent = vi.spyOn(site, 'command')
+    button('Pause charging')!.click()
+    await vi.advanceTimersByTimeAsync(1_000)
+    expect(sent).toHaveBeenCalledWith(OP_LOADPOINT_HOLD, { id: 'carport', power_w: 0, hold_s: 0 })
+    expect(document.body.textContent).toContain('Paused by you')
+    expect(document.body.textContent).toContain('Ready by')
+    expect(slider()).toBeNull()
+    expect(button('Resume plan')).toBeDefined()
+    expect(button('Charge now')).toBeDefined()
+    await vi.advanceTimersByTimeAsync(20_000)
+    expect(document.body.textContent).toContain('Paused by you')
+    button('Resume plan')!.click()
+    await vi.advanceTimersByTimeAsync(1_000)
+    expect(sent).toHaveBeenLastCalledWith(OP_LOADPOINT_HOLD, { id: 'carport', clear: true })
+    expect(document.body.textContent).not.toContain('Paused by you')
+  })
+
+  it('Charge now from a pause uses the normal charger limit, not a clamped zero', async () => {
+    vi.useFakeTimers()
+    vi.setSystemTime(CHARGING_EVENING)
+    const { site } = await openedFor()
+    const sent = vi.spyOn(site, 'command')
+    button('Pause charging')!.click()
+    await vi.advanceTimersByTimeAsync(1_000)
+    button('Charge now')!.click()
+    await vi.advanceTimersByTimeAsync(1_000)
+    expect(sent).toHaveBeenLastCalledWith(OP_LOADPOINT_HOLD, { id: 'carport', power_w: 11000, hold_s: 0, phase_mode: '3p' })
+    expect(document.body.textContent).toContain('Charge now is active')
+    expect(document.body.textContent).not.toContain('Paused by you')
+  })
+
+  it('saves battery size on field release, reads it back, and keeps it after reopening', async () => {
+    vi.useFakeTimers()
+    vi.setSystemTime(CHARGING_EVENING)
+    const { box, site } = await openedFor()
+    const requests = vi.spyOn(box.api, 'serve')
+    const capacity = document.querySelector<HTMLInputElement>('[aria-label="Usable battery size, kWh"]')!
+    capacity.value = '77.4'
+    capacity.dispatchEvent(new Event('input', { bubbles: true }))
+    await vi.advanceTimersByTimeAsync(100)
+    expect(requests.mock.calls.some(c => c[0].path.endsWith('/vehicle'))).toBe(false)
+    capacity.dispatchEvent(new Event('change', { bubbles: true }))
+    await vi.advanceTimersByTimeAsync(1_000)
+    const writes = requests.mock.calls.filter(c => c[0].path.endsWith('/vehicle') && c[0].stepUp)
+    expect(writes).toHaveLength(1)
+    expect(JSON.parse(new TextDecoder().decode(writes[0]![0].body!))).toEqual({ capacity_wh: 77400 })
+    expect(document.body.textContent).toContain('Car battery · 77.4 kWh')
+    expect(document.body.textContent).toContain('Battery size saved')
+    document.body.replaceChildren()
+    render(EvPanel, { props: { site, onclose: () => {} } })
+    await vi.advanceTimersByTimeAsync(500)
+    expect(document.body.textContent).toContain('Car battery · 77.4 kWh')
+  })
+
+  it('lets an unplugged owner save the usual battery size without offering live car controls', async () => {
+    vi.useFakeTimers()
+    vi.setSystemTime(Date.UTC(2026, 6, 15, 12, 0, 0))
+    const { box, site } = await openedFor()
+    const requests = vi.spyOn(box.api, 'serve')
+    const commands = vi.spyOn(site, 'command')
+    expect(document.body.textContent).toContain('Not plugged in')
+    expect(socSlider()).toBeNull()
+    expect(slider()).toBeNull()
+    expect(button('Charge now')).toBeUndefined()
+    expect(button('Pause charging')).toBeUndefined()
+    const capacity = document.querySelector<HTMLInputElement>('[aria-label="Usable battery size, kWh"]')
+    expect(capacity, 'the next car size must be editable before plugging in').not.toBeNull()
+    capacity!.value = '61'
+    capacity!.dispatchEvent(new Event('input', { bubbles: true }))
+    await vi.advanceTimersByTimeAsync(100)
+    expect(requests.mock.calls.some(([req]) => req.path.endsWith('/vehicle'))).toBe(false)
+    capacity!.dispatchEvent(new Event('change', { bubbles: true }))
+    await vi.advanceTimersByTimeAsync(1_000)
+    const writes = requests.mock.calls.filter(([req]) => req.path.endsWith('/vehicle') && req.stepUp)
+    expect(writes).toHaveLength(1)
+    expect(JSON.parse(new TextDecoder().decode(writes[0]![0].body!))).toEqual({ capacity_wh: 61000 })
+    expect(document.body.textContent).toContain('Car battery · 61 kWh')
+    expect(document.body.textContent).toContain('Battery size saved. The plan uses this size for its estimates.')
+    document.body.replaceChildren()
+    render(EvPanel, { props: { site, onclose: () => {} } })
+    await vi.advanceTimersByTimeAsync(500)
+    expect(document.querySelector<HTMLInputElement>('[aria-label="Usable battery size, kWh"]')?.value).toBe('61')
+    expect(document.body.textContent).toContain('Not plugged in')
+    expect(socSlider()).toBeNull()
+    expect(slider()).toBeNull()
+    expect(button('Charge now')).toBeUndefined()
+    expect(commands).not.toHaveBeenCalled()
+  })
+
+  it('does not offer battery-size edits to an unplugged viewer', async () => {
+    vi.useFakeTimers()
+    vi.setSystemTime(Date.UTC(2026, 6, 15, 12, 0, 0))
+    const { site } = await openedFor(ROLE_VIEWER)
+    const requests = vi.spyOn(site, 'api')
+    expect(document.body.textContent).toContain('Not plugged in')
+    expect(document.querySelector('[aria-label="Usable battery size, kWh"]')).toBeNull()
+    expect(socSlider()).toBeNull()
+    expect(button('Charge now')).toBeUndefined()
+    await vi.advanceTimersByTimeAsync(6_000)
+    expect(requests.mock.calls.some(([req]) => req.method !== 'GET')).toBe(false)
+  })
+
+  it('distinguishes a saved default from the size used by the current car', async () => {
+    vi.useFakeTimers()
+    vi.setSystemTime(CHARGING_EVENING)
+    const { box } = await openedFor()
+    const serve = box.api.serve.bind(box.api)
+    vi.spyOn(box.api, 'serve').mockImplementation(req => {
+      const answer = serve(req)
+      if (req.method === 'GET' && req.path === '/api/loadpoints' && 'body' in answer) {
+        const payload = JSON.parse(new TextDecoder().decode(answer.body))
+        payload.loadpoints[0].vehicle_capacity_wh = 40000
+        answer.body = wireBytes(new TextEncoder().encode(JSON.stringify(payload)))
+      }
+      return answer
+    })
+    const capacity = document.querySelector<HTMLInputElement>('[aria-label="Usable battery size, kWh"]')!
+    capacity.value = '77.4'
+    capacity.dispatchEvent(new Event('input', { bubbles: true }))
+    capacity.dispatchEvent(new Event('change', { bubbles: true }))
+    await vi.advanceTimersByTimeAsync(1_000)
+    expect(document.body.textContent).toContain('Saved as the usual battery size. This session uses 40 kWh.')
+    expect(document.body.textContent).toContain('Car battery · 40 kWh')
+  })
+
+  it('shows an invalid battery size without sending it', async () => {
+    vi.useFakeTimers()
+    vi.setSystemTime(CHARGING_EVENING)
+    const { site } = await openedFor()
+    const asked = vi.spyOn(site, 'api')
+    const capacity = document.querySelector<HTMLInputElement>('[aria-label="Usable battery size, kWh"]')!
+    capacity.value = ''
+    capacity.dispatchEvent(new Event('input', { bubbles: true }))
+    capacity.dispatchEvent(new Event('change', { bubbles: true }))
+    await vi.advanceTimersByTimeAsync(100)
+    expect(document.body.textContent).toContain('Enter the usable battery size')
+    expect(asked.mock.calls.some(c => c[0].method === 'POST')).toBe(false)
+  })
+
+  it('ages charger status while its read hangs on a live house connection', async () => {
+    vi.useFakeTimers()
+    vi.setSystemTime(CHARGING_EVENING)
+    const { site } = await openedFor()
+    const api = site.api.bind(site)
+    vi.spyOn(site, 'api').mockImplementation(req => req.path === '/api/loadpoints' ? new Promise(() => {}) : api(req))
+    await vi.advanceTimersByTimeAsync(17_000)
+    expect(site.session.phase).toBe('streaming')
+    expect(document.body.textContent).toContain('The last reading is out of date')
+    expect(document.querySelector('.status')?.textContent).not.toContain('Charging at')
+  })
+
+  it('polls current charging and its windows without requesting the full plan on current boxes', async () => {
+    vi.useFakeTimers()
+    vi.setSystemTime(CHARGING_EVENING)
+    const site = await streaming()
+    const api = site.api.bind(site)
+    let reads = 0
+    const asked = vi.spyOn(site, 'api').mockImplementation(async req => {
+      // An optional route that never answers must not be needed by this sheet.
+      if (req.path === '/api/mpc/plan') return new Promise(() => {})
+      const answer = await api(req)
+      if (req.path === '/api/loadpoints') {
+        reads++
+        const payload = JSON.parse(new TextDecoder().decode(answer.body))
+        Object.assign(payload.loadpoints[0], {
+          current_power_w: 5000 + reads * 100,
+          plan_pending: false, plan_outdated: false,
+          plan_windows: [{ start_ms: CHARGING_EVENING, end_ms: CHARGING_EVENING + 3_600_000, wh: 4600 }],
+        })
+        return { ...answer, body: new TextEncoder().encode(JSON.stringify(payload)) }
+      }
+      return answer
+    })
+    render(EvPanel, { props: { site, onclose: () => {} } })
+    await vi.advanceTimersByTimeAsync(21_000)
+    expect(reads).toBeGreaterThanOrEqual(5)
+    expect(asked.mock.calls.filter(([req]) => req.path === '/api/mpc/plan')).toHaveLength(0)
+    expect(document.body.textContent).not.toContain('The last reading is out of date')
+    expect(document.querySelector('.status')?.textContent).toContain('Charging at 5.5 kW')
+    expect(document.body.textContent).toContain('Charging ahead')
+    expect(document.body.textContent).toContain('4.6 kWh')
+    expect(document.querySelector('.windows')?.textContent).not.toContain('up to')
+  })
+
+  it('describes a routine global replan without claiming that this owner saved a goal', async () => {
+    vi.useFakeTimers()
+    vi.setSystemTime(CHARGING_EVENING)
+    const site = await streaming()
+    const api = site.api.bind(site)
+    const asked = vi.spyOn(site, 'api').mockImplementation(async req => {
+      const answer = await api(req)
+      const payload = JSON.parse(new TextDecoder().decode(answer.body))
+      if (req.path === '/api/loadpoints') payload.loadpoints[0].plan_pending = true
+      if (req.path === '/api/mpc/plan') payload.meta = { replanning: true }
+      return { ...answer, body: new TextEncoder().encode(JSON.stringify(payload)) }
+    })
+    render(EvPanel, { props: { site, onclose: () => {} } })
+    await vi.advanceTimersByTimeAsync(500)
+    expect(document.body.textContent).toContain('Updating the charging plan…')
+    expect(document.body.textContent).not.toContain('Goal saved')
+    expect(asked.mock.calls.every(([req]) => req.method === 'GET')).toBe(true)
   })
 
   it('never draws the slider or the boost for a viewer', async () => {
@@ -589,5 +1204,210 @@ describe('the charger behind its bubble', () => {
     expect(slider()).toBeNull()
     expect(button('Boost from the house battery')).toBeUndefined()
     expect(button('Stop boost')).toBeUndefined()
+    expect(socSlider()).toBeNull()
+    expect(pvOnly()).toBeNull()
+    expect(document.body.textContent).toContain('Battery now')
+    expect(document.body.textContent).toContain('42 %')
+    expect(document.querySelector('[aria-label="Usable battery size, kWh"]')).toBeNull()
+    expect(button('Pause charging')).toBeUndefined()
+    expect(document.body.textContent).not.toContain('Choose Charge now')
+  })
+
+  it("prefills the car's level from the box and says where it came from", async () => {
+    vi.useFakeTimers()
+    vi.setSystemTime(CHARGING_EVENING)
+    await openedFor()
+
+    const s = socSlider()
+    expect(s, 'no level slider for an owner with a plugged car').not.toBeNull()
+    expect(s!.min).toBe('0')
+    expect(s!.max).toBe('100')
+    expect(s!.value).toBe('42')
+    expect(document.body.textContent).toContain('42 %')
+    expect(document.body.textContent).toContain('Estimated from energy delivered')
+  })
+
+  it("corrects the car's level on release, and the sentence follows the box", async () => {
+    vi.useFakeTimers()
+    vi.setSystemTime(CHARGING_EVENING)
+    const { site } = await openedFor()
+
+    const sent = vi.spyOn(site, 'command')
+    slideTo(socSlider()!, 60)
+    await vi.advanceTimersByTimeAsync(20)
+    // A thumb mid-drag sends nothing; the readout follows it.
+    expect(sent).not.toHaveBeenCalled()
+    expect(document.body.textContent).toContain('60 %')
+
+    release(socSlider()!)
+    // A flush, not a wait: over the 5 ms loopback the box has answered
+    // before the first timer, and what is under test is the moment before.
+    await vi.advanceTimersByTimeAsync(0)
+    expect(sent).toHaveBeenCalledWith(OP_LOADPOINT_SOC_SET, { id: 'carport', soc: 0.6 })
+    expect(document.body.textContent).toContain('Sending charge level: 60 %…')
+
+    await vi.advanceTimersByTimeAsync(1_000)
+    expect(document.body.textContent).toContain('Charge level saved: 60 %.')
+    expect(socSlider()!.value).toBe('60')
+
+    // The sentence gives way to the source again; the slider stays on the
+    // level the box now holds.
+    await vi.advanceTimersByTimeAsync(6_000)
+    expect(document.body.textContent).not.toContain('Plan updated')
+    expect(document.body.textContent).toContain('Estimated from energy delivered')
+    expect(socSlider()!.value).toBe('60')
+  })
+
+  it('keeps the accepted charge level through a failed reread, then follows fresh box state', async () => {
+    vi.useFakeTimers()
+    vi.setSystemTime(CHARGING_EVENING)
+    const { site } = await openedFor()
+    const api = site.api.bind(site)
+    let failRead = true
+    vi.spyOn(site, 'api').mockImplementation(async req => {
+      if (req.path === '/api/loadpoints' && failRead) throw new Error('read unavailable')
+      const answer = await api(req)
+      if (req.path === '/api/loadpoints') {
+        const payload = JSON.parse(new TextDecoder().decode(answer.body))
+        payload.loadpoints[0].current_soc = 0.61 // Fresh state has moved on since the accepted choice.
+        return { ...answer, body: new TextEncoder().encode(JSON.stringify(payload)) }
+      }
+      return answer
+    })
+    const sent = vi.spyOn(site, 'command')
+    slideTo(socSlider()!, 60)
+    release(socSlider()!)
+    await vi.advanceTimersByTimeAsync(1_000)
+    expect(socSlider()!.value).toBe('60')
+    expect(document.body.textContent).toContain('Charge level accepted: 60 %.')
+    expect(document.body.textContent).not.toContain('Charge level saved: 42')
+    expect(document.body.textContent).toContain('Waiting for updated charging status')
+    await vi.advanceTimersByTimeAsync(7_000)
+    expect(socSlider()!.value).toBe('60')
+    expect(document.body.textContent).toContain('Waiting for updated charging status')
+    failRead = false
+    await vi.advanceTimersByTimeAsync(6_000)
+    expect(socSlider()!.value).toBe('61')
+    expect(document.body.textContent).not.toContain('Waiting for updated charging status')
+    expect(document.body.textContent).not.toContain('The last reading is out of date')
+    expect(sent).toHaveBeenCalledTimes(1)
+  })
+
+  it('keeps an accepted solar switch through a failed reread without sending it again', async () => {
+    vi.useFakeTimers()
+    vi.setSystemTime(CHARGING_EVENING)
+    const { site } = await openedFor()
+    const api = site.api.bind(site)
+    let failRead = true
+    vi.spyOn(site, 'api').mockImplementation(req => req.path === '/api/loadpoints' && failRead
+      ? Promise.reject(new Error('read unavailable')) : api(req))
+    const sent = vi.spyOn(site, 'command')
+    pvOnly()!.click()
+    await vi.advanceTimersByTimeAsync(1_000)
+    expect(pvOnly()!.checked).toBe(true)
+    expect(document.body.textContent).toContain('Solar rule accepted. Waiting for updated charging status.')
+    await vi.advanceTimersByTimeAsync(7_000)
+    expect(pvOnly()!.checked).toBe(true)
+    expect(document.body.textContent).toContain('Waiting for updated charging status')
+    failRead = false
+    await vi.advanceTimersByTimeAsync(6_000)
+    expect(pvOnly()!.checked).toBe(true)
+    expect(document.body.textContent).not.toContain('Waiting for updated charging status')
+    expect(sent).toHaveBeenCalledTimes(1)
+  })
+
+  it('does not let a reread snap the slider from under a thumb', async () => {
+    vi.useFakeTimers()
+    vi.setSystemTime(CHARGING_EVENING)
+    const { site } = await openedFor()
+
+    const asked = vi.spyOn(site, 'api')
+    slideTo(socSlider()!, 70)
+    // Well over a minute mid-drag: the panel's own ask comes and goes.
+    await vi.advanceTimersByTimeAsync(90_000)
+    expect(asked.mock.calls.length).toBeGreaterThan(0)
+    expect(socSlider()!.value).toBe('70')
+    expect(document.body.textContent).toContain('70 %')
+  })
+
+  it('hides the level slider for an empty bay, and keeps the PV-only switch', async () => {
+    vi.useFakeTimers()
+    // Midday: the car left with the morning commute.
+    vi.setSystemTime(Date.UTC(2026, 6, 15, 12, 0, 0))
+    await openedFor()
+
+    expect(document.body.textContent).toContain('Not plugged in')
+    expect(socSlider()).toBeNull()
+    expect(slider()).toBeNull()
+    // A standing setting outlives an unplug, so it is still offered.
+    expect(pvOnly()).not.toBeNull()
+  })
+
+  it('switches to solar surplus only through the door, and the boost offer follows', async () => {
+    vi.useFakeTimers()
+    vi.setSystemTime(CHARGING_EVENING)
+    const { site } = await openedFor()
+
+    const sw = pvOnly()
+    expect(sw, 'no PV-only switch for an owner').not.toBeNull()
+    expect(sw!.checked).toBe(false)
+    expect(button('Boost from the house battery')).toBeDefined()
+
+    const sent = vi.spyOn(site, 'command')
+    sw!.click()
+    await vi.advanceTimersByTimeAsync(1_000)
+
+    expect(sent).toHaveBeenCalledWith(OP_LOADPOINT_SURPLUS_ONLY_SET, {
+      id: 'carport',
+      surplus_only: true,
+    })
+    expect(pvOnly()!.checked).toBe(true)
+    expect(document.body.textContent).toContain('The plan uses spare solar only')
+    // The box refuses a boost while PV only is on; the offer says so instead.
+    expect(button('Boost from the house battery')).toBeUndefined()
+    expect(document.body.textContent).toContain('Not while the charger uses spare solar only')
+
+    pvOnly()!.click()
+    await vi.advanceTimersByTimeAsync(1_000)
+    expect(sent).toHaveBeenCalledWith(OP_LOADPOINT_SURPLUS_ONLY_SET, {
+      id: 'carport',
+      surplus_only: false,
+    })
+    expect(pvOnly()!.checked).toBe(false)
+    expect(document.body.textContent).toContain('may use grid power again')
+    expect(button('Boost from the house battery')).toBeDefined()
+  })
+
+  it('names a solar save failure, preserves the previous choice and allows retry', async () => {
+    vi.useFakeTimers()
+    vi.setSystemTime(CHARGING_EVENING)
+    const { site } = await openedFor()
+    const sent = vi.spyOn(site, 'command').mockResolvedValueOnce({
+      cmdId: 'solar-save-failed', state: 'rejected',
+      error: { code: 'E_UNAVAILABLE', args: { op: OP_LOADPOINT_SURPLUS_ONLY_SET } },
+    })
+    pvOnly()!.click()
+    await vi.advanceTimersByTimeAsync(1_000)
+    expect(pvOnly()!.checked).toBe(false)
+    expect(document.body.textContent).toContain('Solar rule not saved. Your previous choice is unchanged. Try again.')
+    expect(document.body.textContent).not.toContain("can't reach the charger")
+    sent.mockRestore()
+    pvOnly()!.click()
+    await vi.advanceTimersByTimeAsync(1_000)
+    expect(pvOnly()!.checked).toBe(true)
+    expect(document.body.textContent).toContain('Solar rule saved')
+  })
+
+  it('puts a refused switch back where the box says it is', async () => {
+    vi.useFakeTimers()
+    vi.setSystemTime(CHARGING_EVENING)
+    const { box } = await openedFor()
+
+    box.faults = { ...box.faults, failPreconditions: true }
+    pvOnly()!.click()
+    await vi.advanceTimersByTimeAsync(1_000)
+
+    expect(document.body.textContent).toContain('Your home changed while that was sending')
+    expect(pvOnly()!.checked).toBe(false)
   })
 })
diff --git a/src/views/History.svelte b/src/views/History.svelte
index 203660a..8d9cc25 100644
--- a/src/views/History.svelte
+++ b/src/views/History.svelte
@@ -234,7 +234,7 @@
           {#each yLabels as label (label.value)}
             <span class="ytick num" style:top="{label.at * 100}%">
               {label.text}
-              {#if label.dir}<em>{label.dir}</em>{/if}
+              {#if label.dir}<em class="label">{label.dir}</em>{/if}
             </span>
           {/each}
         </div>
@@ -280,8 +280,9 @@
           {/if}
         </span>
         <!-- The wire's sign convention is right for the wire and wrong for a
-             person. Never a minus sign; a direction word instead. -->
-        <span class="dir">
+             person. Never a minus sign; a direction word instead, set in the
+             shared .label grammar like every other small caps word here. -->
+        <span class="label">
           {#if watts === null}
             no reading
           {:else if trace.name === 'load_w'}
@@ -334,14 +335,6 @@
     flex-wrap: wrap;
   }
 
-  .label {
-    font-family: var(--mono);
-    font-size: 11px;
-    letter-spacing: 0.1em;
-    text-transform: uppercase;
-    color: var(--fg-muted);
-  }
-
   hr {
     width: 100%;
     height: 1px;
@@ -360,7 +353,8 @@
   }
 
   .range {
-    min-height: 34px;
+    /* Height comes from base.css: 44px is the smallest reliably hittable
+       target on a phone held one-handed. */
     padding: 0 var(--space-4);
     border-radius: var(--radius-xs);
     font-family: var(--mono);
@@ -402,21 +396,19 @@
     right: 0;
     transform: translateY(-50%);
     text-align: right;
-    font-size: 9px;
+    font-size: 10px;
     line-height: 1.2;
     color: var(--fg-muted);
     white-space: nowrap;
   }
 
   /* The direction word, under its number. The chart never shows a minus
-     sign; this is what carries the sign convention instead. */
+     sign; this is what carries the sign convention instead. The word itself
+     follows the shared .label grammar from base.css; placement and dimming
+     are all this chart adds. */
   .ytick em {
     display: block;
     font-style: normal;
-    font-size: 8px;
-    letter-spacing: 0.1em;
-    text-transform: uppercase;
-    color: var(--fg-muted);
     opacity: 0.75;
   }
 
@@ -489,14 +481,6 @@
     letter-spacing: 0;
   }
 
-  .dir {
-    font-family: var(--mono);
-    font-size: 9px;
-    letter-spacing: 0.14em;
-    text-transform: uppercase;
-    color: var(--fg-muted);
-  }
-
   .note {
     font-family: var(--mono);
     font-size: 10px;
diff --git a/src/views/LivePanel.svelte b/src/views/LivePanel.svelte
index 3690ad7..34d1674 100644
--- a/src/views/LivePanel.svelte
+++ b/src/views/LivePanel.svelte
@@ -164,16 +164,18 @@
   .backdrop {
     position: fixed;
     inset: 0;
-    background: rgb(0 0 0 / 45%);
-    z-index: 40;
+    background: var(--scrim);
+    z-index: var(--z-overlay);
   }
 
   .sheet {
+    max-width: 34rem;
+    margin-inline: auto;
     position: fixed;
     left: 0;
     right: 0;
     bottom: 0;
-    z-index: 41;
+    z-index: var(--z-sheet);
     max-height: 75dvh;
     overflow-y: auto;
     overflow-anchor: none;
diff --git a/src/views/LivePanel.svelte.test.ts b/src/views/LivePanel.svelte.test.ts
index dd7dc1c..9917b07 100644
--- a/src/views/LivePanel.svelte.test.ts
+++ b/src/views/LivePanel.svelte.test.ts
@@ -78,10 +78,10 @@ describe('a live line behind a bubble', () => {
     // spying that no api call is made when a bubble is tapped.
     const api = vi.spyOn(site, 'api')
     render(Now, { props: { site } })
-    await vi.advanceTimersByTimeAsync(50)
-    // Now asks for chargers so the house/car split can match the LAN page.
-    // The live line itself still needs only the stream — clear those asks
-    // before tapping, or they would look like the panel reaching the API.
+    // Now's own background asks — chargers for the house/car split, the
+    // box-page snapshot the hero reads — land in chunks after mount. Let
+    // them settle, so what is judged next is what the tap alone adds.
+    await vi.advanceTimersByTimeAsync(500)
     api.mockClear()
 
     openBubble('pv')
diff --git a/src/views/Notifications.svelte b/src/views/Notifications.svelte
index ae33b23..91c0ab9 100644
--- a/src/views/Notifications.svelte
+++ b/src/views/Notifications.svelte
@@ -54,33 +54,43 @@
     () => Promise.all([notify.loadHistory(), notify.loadRules()]).then(() => {})
   )
 
-  /**
-   * The unsaved toggle edits, or null when the switches show the box's own
-   * document. One draft, one save, one ceremony — the schedule editor's rule.
-   */
   let draft = $state<Record<string, boolean> | null>(null)
-
-  // Off until the box's document says otherwise: the box seeds every rule
-  // disabled — sparse by design — and a switch drawn on before the document
-  // was read would promise a notification nobody arranged.
-  const dirty = $derived(
-    draft !== null &&
-      RULE_KINDS.some((kind) => (draft?.[kind] ?? false) !== (notify.rules[kind] ?? false))
-  )
+  let writeStatus = $state('')
+  let failed = $state(false)
+  let writing = false
+  let version = 0
 
   function shown(kind: string): boolean {
     return (draft ?? notify.rules)[kind] ?? false
   }
 
   function toggle(kind: string): void {
-    const next = { ...(draft ?? notify.rules) }
-    next[kind] = !(next[kind] ?? false)
-    draft = next
+    draft = { ...(draft ?? notify.rules), [kind]: !shown(kind) }
+    version++
+    failed = false
+    writeStatus = 'Saving…'
+    void save()
   }
 
   async function save(): Promise<void> {
-    if (draft === null) return
-    if (await notify.saveRules(draft)) draft = null
+    if (writing || draft === null) return
+    writing = true
+    failed = false
+    writeStatus = 'Saving…'
+    try {
+      while (draft !== null) {
+        const sentVersion = version
+        const saved = await notify.saveRules({ ...draft })
+        if (version !== sentVersion) continue
+        if (!saved) {
+          failed = true
+          writeStatus = 'Changes have not been saved.'
+          break
+        }
+        draft = null
+        writeStatus = 'Saved'
+      }
+    } finally { writing = false }
   }
 
   function when(ms: number | null): string {
@@ -116,13 +126,13 @@
   <p>Your box can reach this phone, even with the app closed.</p>
 
   <ul class="kinds">
-    {#each RULE_KINDS as kind (kind)}
+    {#each RULE_KINDS.filter(kind => notify.availableKinds.includes(kind)) as kind (kind)}
       <li>
         <label>
           <input
             type="checkbox"
             checked={shown(kind)}
-            disabled={notify.busy !== 'none'}
+            disabled={notify.busy !== 'none' && notify.busy !== 'saving'}
             onchange={() => toggle(kind)}
           />
           <span>{KIND_LABELS[kind]}</span>
@@ -135,10 +145,9 @@
        being enabled here is what turns it on. -->
   <p class="hint">{KIND_LABELS['box.unreachable']} is always on while this is enabled.</p>
 
-  {#if dirty}
-    <button class="quiet outline" disabled={notify.busy !== 'none'} onclick={() => void save()}>
-      {notify.busy === 'saving' ? 'Saving…' : 'Save'}
-    </button>
+  {#if writeStatus}<p class="meta" role="status">{writeStatus}</p>{/if}
+  {#if failed}
+    <button class="quiet outline" disabled={notify.busy !== 'none'} onclick={() => void save()}>Try again</button>
   {/if}
 
   <div class="actions">
diff --git a/src/views/Notifications.svelte.test.ts b/src/views/Notifications.svelte.test.ts
index 9522099..ad7dea2 100644
--- a/src/views/Notifications.svelte.test.ts
+++ b/src/views/Notifications.svelte.test.ts
@@ -180,40 +180,26 @@ describe('the notifications section', () => {
     expect(text()).toContain('Your box updated itself')
   })
 
-  it('saves the toggles as one write, one ceremony', async () => {
+  it('saves released toggles directly and keeps later changes made during the first write', async () => {
     vi.useFakeTimers()
     vi.setSystemTime(NOON)
     installPush({ subscribed: true })
     const { box, site } = open()
-    const stepup = await import('$lib/identity/stepup')
-
     render(Notifications, { props: { site } })
     await vi.advanceTimersByTimeAsync(500)
-
-    // Five switches: box.unreachable has none — the box cannot gate a
-    // message about its own absence, so it follows the subscription itself.
     const boxes = [...document.querySelectorAll('input[type="checkbox"]')] as HTMLInputElement[]
-    expect(boxes.length).toBe(5)
-
-    // Everything starts off, because the box seeds every rule disabled —
-    // sparse by design. Two edits, and no save yet: a toggle is an edit,
-    // not a request.
-    expect(boxes.every((b) => !b.checked)).toBe(true)
+    expect(boxes.length).toBe(6)
+    expect(boxes.every(b => !b.checked)).toBe(true)
     boxes[0]!.click()
-    await vi.advanceTimersByTimeAsync(10)
+    await vi.advanceTimersByTimeAsync(1)
+    expect(text()).toContain('Saving…')
     boxes[1]!.click()
-    await vi.advanceTimersByTimeAsync(10)
-    expect(box.api.pushRules['charging.session_complete'], 'a toggle wrote on its own').toBe(false)
-
-    // Counted from here: the module mock's history survives other tests.
-    vi.mocked(stepup.stepUp).mockClear()
-    buttonSaying(/^\s*Save\s*$/)!.click()
     await vi.advanceTimersByTimeAsync(500)
-
+    expect(box.api.pushRules['charging.connected']).toBe(true)
     expect(box.api.pushRules['charging.session_complete']).toBe(true)
-    expect(box.api.pushRules['charging.interrupted']).toBe(true)
-    expect(box.api.pushRules['update.installed']).toBe(false)
-    expect(vi.mocked(stepup.stepUp), 'the batch cost more than one ceremony').toHaveBeenCalledOnce()
+    expect(box.api.pushRules['charging.interrupted']).toBe(false)
+    expect(buttonSaying(/^\s*Save\s*$/)).toBeUndefined()
+    expect(text()).toContain('Saved')
   })
 
   it('asks the box to send a test through the whole pipe', async () => {
diff --git a/src/views/Now.svelte b/src/views/Now.svelte
index 8d85d82..864431a 100644
--- a/src/views/Now.svelte
+++ b/src/views/Now.svelte
@@ -9,12 +9,11 @@
 <script lang="ts">
   // The box's own hero component, vendored verbatim. Importing registers
   // <ftw-energy-flow>; the app and the on-box dashboard render one file.
-  import { untrack } from 'svelte'
+  import { onMount, untrack } from 'svelte'
   import '$vendor/ftw/ftw-energy-flow.js'
   import type { FtwEnergyFlowElement } from '$vendor/ftw/ftw-energy-flow.js'
   import { flowReadings, flowReadingsFromStatus, withLoadpointEv, type SiteStatus } from '$lib/state/flow'
   import { explain } from '$lib/format/explanation'
-  import { CAP_API_PASSTHROUGH } from '$lib/protocol/contract'
   import LivePanel, { type LiveRole } from './LivePanel.svelte'
   import type { SiteStore } from '$lib/state/site.svelte'
   import type { Component } from 'svelte'
@@ -137,7 +136,36 @@
   /** The charger's sheet, opened by a tap on its bubble. Loaded on demand
    *  so callBox and the loadpoint store stay out of the first frame. */
   let evOpen = $state(false)
-  let EvPanel = $state<Component<{ site: SiteStore; onclose: () => void }> | null>(null)
+  let selectedCharger = $state<string | null>(null)
+  let requestedCharger = $state<string | null>(null)
+  onMount(() => {
+    const read = () => {
+      const hash = location.hash
+      requestedCharger = hash.startsWith('#/now?') ? new URLSearchParams(hash.split('?')[1]).get('charger') : null
+    }
+    const message = (e: MessageEvent) => {
+      if (e.data?.type === 'ftw-open-charger' && typeof e.data.loadpointId === 'string') {
+        location.hash = '#/now?charger=' + encodeURIComponent(e.data.loadpointId)
+        requestedCharger = e.data.loadpointId
+      }
+    }
+    read(); window.addEventListener('hashchange', read)
+    navigator.serviceWorker?.addEventListener('message', message)
+    return () => { window.removeEventListener('hashchange', read); navigator.serviceWorker?.removeEventListener('message', message) }
+  })
+  $effect(() => {
+    if (active && requestedCharger) {
+      selectedCharger = requestedCharger
+      evOpen = true
+      requestedCharger = null
+    }
+  })
+  function closeEv() {
+    evOpen = false
+    selectedCharger = null
+    if (location.hash.startsWith('#/now?charger=')) history.replaceState(null, '', location.pathname + location.search + '#/now')
+  }
+  let EvPanel = $state<Component<{ site: SiteStore; onclose: () => void; loadpointId?: string | null }> | null>(null)
   $effect(() => {
     if (!evOpen || EvPanel) return
     void import('./EvPanel.svelte').then((m) => {
@@ -164,17 +192,16 @@
 
   const LIVE_ROLES = new Set<string>(['grid', 'pv', 'battery', 'load'])
 
-  // The hero says which bubble was tapped. The charger opens its own panel of
-  // controls — but only when the box's API is actually reachable, or the
-  // panel would be a door painted on a wall. Every other bubble opens its
-  // live line, which needs nothing but the stream already on screen.
+  // Preserve a charger tap while the saved home reconnects. The panel shows
+  // connection progress, then checks the capabilities the box reports.
   $effect(() => {
     const el = flow
     if (!el) return
     const onPlanet = (e: Event) => {
       const role = (e as CustomEvent<{ role?: string }>).detail?.role
       if (role === 'ev') {
-        if (untrack(() => site).session.caps.has(CAP_API_PASSTHROUGH)) evOpen = true
+        selectedCharger = null
+        evOpen = true
       } else if (role && LIVE_ROLES.has(role) && untrack(() => live)) {
         liveRole = role as LiveRole
       }
@@ -315,7 +342,7 @@
   {/if}
 
   {#if evOpen && EvPanel}
-    <EvPanel {site} onclose={() => (evOpen = false)} />
+    <EvPanel {site} loadpointId={selectedCharger} onclose={closeEv} />
   {/if}
 
   {#if liveRole}
diff --git a/src/views/NowOutlook.svelte b/src/views/NowOutlook.svelte
index 15a0556..bd92566 100644
--- a/src/views/NowOutlook.svelte
+++ b/src/views/NowOutlook.svelte
@@ -158,7 +158,8 @@
     const wire = await callBox<{ days?: unknown[] }>(site, {
       method: 'GET',
       path: '/api/savings/daily',
-      query: { days: '31' },
+      // This card only shows today and the last seven days.
+      query: { days: '7' },
     })
     const days = (wire.days ?? [])
       .map((row) => (row && typeof row === 'object' ? toSavingsDay(row) : null))
@@ -329,13 +330,15 @@
     margin-bottom: var(--space-3);
   }
 
+  /* Kicker follows the shared .label grammar from base.css; the margin is
+     the only thing this card adds. */
   .kicker {
     font-family: var(--mono);
     font-size: 10px;
-    letter-spacing: 0.12em;
+    letter-spacing: 0.14em;
     text-transform: uppercase;
     color: var(--fg-muted);
-    margin-bottom: 4px;
+    margin-bottom: var(--space-1);
   }
 
   h2 {
@@ -429,7 +432,7 @@
     min-height: 74px;
     flex-direction: column;
     justify-content: center;
-    gap: 5px;
+    gap: var(--space-1);
     padding: 12px 14px;
     background: var(--surface-sunken);
     border: 1px solid var(--line);
@@ -439,14 +442,14 @@
   .tile span {
     color: var(--fg-muted);
     font-family: var(--mono);
-    font-size: 9px;
-    letter-spacing: 0.1em;
+    font-size: 10px;
+    letter-spacing: 0.14em;
     text-transform: uppercase;
   }
 
   .tile strong {
     overflow: hidden;
-    font-size: 1.05rem;
+    font-size: 17px;
     text-overflow: ellipsis;
     white-space: nowrap;
   }
@@ -482,8 +485,8 @@
   .fallback {
     display: flex;
     flex-direction: column;
-    gap: 6px;
-    padding: 10px 12px;
+    gap: var(--space-1);
+    padding: var(--pad-card-tight);
     background: var(--surface-sunken);
     border: 1px solid var(--line);
     border-radius: var(--radius-md);
@@ -491,26 +494,26 @@
 
   .phase-lab {
     font-family: var(--mono);
-    font-size: 9px;
-    letter-spacing: 0.1em;
+    font-size: 10px;
+    letter-spacing: 0.14em;
     text-transform: uppercase;
     color: var(--fg-muted);
   }
 
   .phase-val {
-    font-size: 1rem;
+    font-size: 16px;
   }
 
   .bar {
     height: 6px;
-    border-radius: 99px;
+    border-radius: var(--radius-pill);
     background: var(--line);
     overflow: hidden;
   }
 
   .fill {
     height: 100%;
-    border-radius: 99px;
+    border-radius: var(--radius-pill);
     background: var(--energy-export);
   }
 
diff --git a/src/views/NowOutlook.svelte.test.ts b/src/views/NowOutlook.svelte.test.ts
new file mode 100644
index 0000000..e61f4b5
--- /dev/null
+++ b/src/views/NowOutlook.svelte.test.ts
@@ -0,0 +1,36 @@
+import { afterEach, expect, it, vi } from 'vitest'
+import { cleanup, render } from '@testing-library/svelte'
+import NowOutlook from './NowOutlook.svelte'
+import { SiteStore } from '$lib/state/site.svelte'
+import { LoopbackCarrier } from '$lib/carrier/loopback'
+import { SimBox } from '$lib/sim/box'
+
+afterEach(() => { cleanup(); vi.useRealTimers(); vi.restoreAllMocks() })
+
+it('requests only seven savings days and keeps the same today and week amounts', async () => {
+  vi.useFakeTimers()
+  vi.setSystemTime(Date.UTC(2026, 6, 31, 18, 30))
+  const site = new SiteStore('test')
+  site.connect(new LoopbackCarrier(new SimBox({ now: () => Date.now() }), { latencyMs: 5 }))
+  for (let i = 0; i < 100 && site.session.phase !== 'streaming'; i++) await vi.advanceTimersByTimeAsync(10)
+  const month = Array.from({ length: 31 }, (_, i) => ({
+    day: `2026-07-${String(i + 1).padStart(2, '0')}`,
+    saved_ore: (i + 1) * 100,
+    resolution: 'slot',
+  }))
+  const requested: string[] = []
+  const api = site.api.bind(site)
+  vi.spyOn(site, 'api').mockImplementation(async req => {
+    if (req.path !== '/api/savings/daily') return api(req)
+    const days = String(req.query?.days)
+    requested.push(days)
+    return { status: 200, headers: {}, body: new TextEncoder().encode(JSON.stringify({ days: month.slice(-Number(days)) })) }
+  })
+  render(NowOutlook, { props: { site, status: { energy: { today: { import_wh: 0, export_wh: 0, pv_wh: 0 } } } } })
+  await vi.advanceTimersByTimeAsync(1_000)
+  expect(requested).toEqual(['7'])
+  expect(document.querySelector('.card.today')?.textContent).toContain('+31.0')
+  expect(document.querySelector('.card.today')?.textContent).toContain('+196 this week')
+  await vi.advanceTimersByTimeAsync(60_000)
+  expect(requested).toEqual(['7'])
+})
diff --git a/src/views/Pair.svelte b/src/views/Pair.svelte
index e5dfea1..6258541 100644
--- a/src/views/Pair.svelte
+++ b/src/views/Pair.svelte
@@ -335,12 +335,17 @@
   {:else if stage === 'pairing'}
     <h1>Securing this phone</h1>
     <p>Confirm with Face ID or Touch ID if your phone asks.</p>
+    <!-- The ceremony usually answers by itself. When it stalls instead, this
+         is the way out that does not need the OS: the screen steps back, and
+         a result that lands anyway still applies. -->
+    <button class="quiet" onclick={cancel}>Cancel</button>
   {:else if stage === 'demoing'}
     <h1>Starting the demo</h1>
     <p>Loading a simulated home.</p>
   {:else if stage === 'recovering'}
     <h1>Checking</h1>
     <p>Asking your passkey what it can open.</p>
+    <button class="quiet" onclick={cancel}>Cancel</button>
   {:else if stage === 'choosing'}
     <!-- Named by fingerprint as well as label, for the same reason the offer
          above a scanned link is: two homes with the same name are two
diff --git a/src/views/Pair.svelte.test.ts b/src/views/Pair.svelte.test.ts
index 286cf33..fafca94 100644
--- a/src/views/Pair.svelte.test.ts
+++ b/src/views/Pair.svelte.test.ts
@@ -130,6 +130,25 @@ describe('bringing a home back from a sealed copy', () => {
     // Still on the screen it started on, with the scan still offered.
     expect(screen.getByRole('button', { name: /open with your passkey/i })).toBeTruthy()
   })
+
+  it('offers a way back when the passkey ceremony stalls', async () => {
+    mock = installMockAuthenticator()
+    // A ceremony that never answers: no sheet ever came and the promise
+    // never settles. The screen must still have an exit that is not the OS.
+    Object.defineProperty(navigator, 'credentials', {
+      value: { get: () => new Promise(() => {}) },
+      configurable: true,
+    })
+    vi.stubGlobal('fetch', vi.fn(async () => new Response('{}', { status: 404 })))
+
+    render(Pair, { props: { onPaired: vi.fn() } })
+    ;(await screen.findByRole('button', { name: /open with your passkey/i })).click()
+
+    expect(await screen.findByRole('heading', { name: /checking/i })).toBeTruthy()
+    ;(await screen.findByRole('button', { name: /cancel/i })).click()
+    // Back where it started, with every way in offered again.
+    expect(await screen.findByRole('button', { name: /open with your passkey/i })).toBeTruthy()
+  })
 })
 
 /* A phone that still has its home can either open it or scan a fresh QR.
diff --git a/src/views/Plan.svelte b/src/views/Plan.svelte
index e21a601..9eba362 100644
--- a/src/views/Plan.svelte
+++ b/src/views/Plan.svelte
@@ -462,7 +462,8 @@
     font-size: 13px;
     text-decoration: underline;
     text-underline-offset: 3px;
-    min-height: 36px;
+    /* Height comes from base.css: 44px is the smallest reliably hittable
+       target on a phone held one-handed. */
   }
 
   .choice-label {
diff --git a/tests/api-passthrough.test.ts b/tests/api-passthrough.test.ts
index 24a0e43..e9510c7 100644
--- a/tests/api-passthrough.test.ts
+++ b/tests/api-passthrough.test.ts
@@ -550,6 +550,114 @@ class ManualCarrier extends CarrierBase implements Carrier {
   }
 }
 
+describe('API admission while the box is busy', () => {
+  afterEach(() => vi.useRealTimers())
+
+  function setup() {
+    vi.useFakeTimers()
+    const carrier = new ManualCarrier()
+    const session = new Session({ build: 'test' })
+    session.connect(carrier)
+    const requests = () => carrier.sent.filter(e => e.t === 'api.req')
+    const answer = () => {
+      const id = requests().at(-1)!.id!
+      carrier.deliver({ t: 'api.head', id, b: { status: 200, headers: {}, len: 0 } })
+      carrier.deliver({ t: 'api.end', id, b: { bytes: 0, truncated: false } })
+    }
+    const busy = () => carrier.deliver({ t: 'error', id: requests().at(-1)!.id!,
+      b: { code: 'E_UNAVAILABLE', retryable: true, args: { reason: 'busy' } } })
+    return { carrier, session, requests, answer, busy }
+  }
+
+  it('retries an explicit busy refusal before admitting the next view', async () => {
+    const { session, requests, answer, busy } = setup()
+    const save = session.api({ method: 'PUT', path: '/api/loadpoints/easee/schedule' })
+    const read = session.api({ method: 'GET', path: '/api/loadpoints' })
+    await vi.advanceTimersByTimeAsync(0)
+    busy()
+    await vi.advanceTimersByTimeAsync(249)
+    expect(requests()).toHaveLength(1)
+    await vi.advanceTimersByTimeAsync(1)
+    expect(requests().map(e => (e.b as { method: string }).method)).toEqual(['PUT', 'PUT'])
+    answer()
+    await expect(save).resolves.toMatchObject({ status: 200 })
+    await vi.advanceTimersByTimeAsync(0)
+    expect((requests().at(-1)!.b as { method: string }).method).toBe('GET')
+    answer()
+    await expect(read).resolves.toMatchObject({ status: 200 })
+  })
+
+  it('stops after three retries and leaves the queue usable', async () => {
+    const { session, requests, answer, busy } = setup()
+    const result = session.api({ method: 'PUT', path: '/api/loadpoints/easee/schedule' }).catch(e => e)
+    await vi.advanceTimersByTimeAsync(0)
+    for (const delay of [250, 500, 1000]) {
+      busy()
+      await vi.advanceTimersByTimeAsync(delay)
+    }
+    busy()
+    expect(await result).toMatchObject({ detail: { code: 'E_UNAVAILABLE' } })
+    expect(requests()).toHaveLength(4)
+    const next = session.api({ method: 'GET', path: '/api/loadpoints' })
+    await vi.advanceTimersByTimeAsync(0)
+    answer()
+    await expect(next).resolves.toMatchObject({ status: 200 })
+  })
+
+  it.each([
+    { code: 'E_UNAVAILABLE', retryable: true, args: { reason: 'timeout' } },
+    { code: 'E_UNAVAILABLE', retryable: false, args: { reason: 'busy' } },
+    { code: 'E_NEEDS_STEP_UP', retryable: true },
+  ])('never retries another refusal: %j', async detail => {
+    const { session, carrier, requests } = setup()
+    const result = session.api({ method: 'POST', path: '/api/settings' }).catch(e => e)
+    await vi.advanceTimersByTimeAsync(0)
+    carrier.deliver({ t: 'error', id: requests()[0]!.id!, b: detail })
+    expect(await result).toMatchObject({ detail })
+    await vi.advanceTimersByTimeAsync(2000)
+    expect(requests()).toHaveLength(1)
+  })
+
+  it('does not repeat a write whose answer was lost', async () => {
+    const { session, requests } = setup()
+    const result = session.api({ method: 'POST', path: '/api/settings' }).catch(e => e)
+    await vi.advanceTimersByTimeAsync(API_TIMEOUT_MS + 2000)
+    expect(await result).toHaveProperty('message', 'api request timed out')
+    expect(requests()).toHaveLength(1)
+  })
+
+  it('discards retries and queued writes when a connection is replaced', async () => {
+    const { session, busy } = setup()
+    const retry = session.api({ method: 'PUT', path: '/api/settings' }).catch(e => e)
+    const queued = session.api({ method: 'POST', path: '/api/settings' }).catch(e => e)
+    await vi.advanceTimersByTimeAsync(0)
+    busy()
+    await vi.advanceTimersByTimeAsync(1)
+    const replacement = new ManualCarrier()
+    session.connect(replacement)
+    await vi.advanceTimersByTimeAsync(1000)
+    expect(await retry).toHaveProperty('message', 'carrier closed')
+    expect(await queued).toHaveProperty('message', 'carrier closed')
+    expect(replacement.sent.filter(e => e.t === 'api.req')).toHaveLength(0)
+  })
+
+  it('expires a queued write while a large read is still arriving', async () => {
+    const { session, carrier, requests, answer } = setup()
+    const read = session.api({ method: 'GET', path: '/api/energy/daily' })
+    const queued = session.api({ method: 'PUT', path: '/api/settings' }).catch(e => e)
+    await vi.advanceTimersByTimeAsync(0)
+    const id = requests()[0]!.id!
+    await vi.advanceTimersByTimeAsync(API_TIMEOUT_MS / 2)
+    carrier.deliver({ t: 'api.head', id, b: { status: 200, headers: {}, len: null } })
+    await vi.advanceTimersByTimeAsync(API_TIMEOUT_MS / 2 + 1)
+    expect(await queued).toHaveProperty('message', 'api queue wait timed out')
+    answer()
+    await read
+    await vi.advanceTimersByTimeAsync(0)
+    expect(requests()).toHaveLength(1)
+  })
+})
+
 describe('a body that did not all arrive', () => {
   it('is refused rather than handed up as an answer', async () => {
     const carrier = new ManualCarrier()
diff --git a/tests/service-worker.test.ts b/tests/service-worker.test.ts
index e901c10..37b6f0f 100644
--- a/tests/service-worker.test.ts
+++ b/tests/service-worker.test.ts
@@ -258,3 +258,29 @@ describe('tapping a notification', () => {
     expect(worker.opened).toEqual(['/'])
   })
 })
+
+
+describe('charging notifications open the right charger', () => {
+  it('carries the charger id through push and a cold launch', async () => {
+    const worker = await activate('charging')
+    await worker.push(JSON.stringify({ title: 'Car plugged in', body: 'Check charging.', kind: 'charging.connected', loadpoint_id: 'garage & drive' }))
+    expect(worker.shown).toEqual([{ title: 'Car plugged in', body: 'Check charging.' }])
+    expect(await worker.clickNotification(worker.notificationData[0])).toBe(true)
+    expect(worker.opened).toEqual(['/#/now?charger=garage%20%26%20drive'])
+  })
+  it('opens the charger in an existing app without reloading it', async () => {
+    const worker = await activate('charging')
+    const postMessage = vi.fn(), focus = vi.fn(async () => {})
+    worker.windows.push({ focused: false, postMessage, focus })
+    await worker.clickNotification({ loadpointId: 'garage' })
+    expect(postMessage).toHaveBeenCalledWith({ type: 'ftw-open-charger', loadpointId: 'garage' })
+    expect(focus).toHaveBeenCalledOnce()
+    expect(worker.opened).toEqual([])
+  })
+  it('never follows a URL supplied by a push', async () => {
+    const worker = await activate('charging')
+    await worker.push(JSON.stringify({ title: 'Update', kind: 'update.installed', loadpoint_id: 'garage', url: 'https://untrusted.invalid/' }))
+    await worker.clickNotification(worker.notificationData[0])
+    expect(worker.opened).toEqual(['/'])
+  })
+})
diff --git a/tests/support/cache-storage.ts b/tests/support/cache-storage.ts
index 1b26731..7936028 100644
--- a/tests/support/cache-storage.ts
+++ b/tests/support/cache-storage.ts
@@ -68,7 +68,7 @@ export interface SwEvent {
   /** A push payload or a page message, depending on the event. */
   data?: unknown
   /** The notification a click landed on. */
-  notification?: { close(): void }
+  notification?: { close(): void; data?: unknown }
   waitUntil(promise: Promise<unknown>): void
   respondWith(response: Promise<unknown>): void
 }
@@ -77,6 +77,7 @@ export interface SwEvent {
 export interface FakeWindowClient {
   focused: boolean
   focus(): Promise<void>
+  postMessage?(message: unknown): void
 }
 
 /**
@@ -90,14 +91,16 @@ export class FakeWorker {
   /** Every notification shown, in order. */
   shown: { title: string; body: string }[] = []
   /** Whether the page explicitly asked this installed worker to take over. */
+  notificationData: unknown[] = []
   skipped = false
   /** What the page side sees: open windows, and URLs opened fresh. */
   windows: FakeWindowClient[] = []
   opened: string[] = []
 
   readonly registration = {
-    showNotification: async (title: string, options?: { body?: string }): Promise<void> => {
+    showNotification: async (title: string, options?: { body?: string; data?: unknown }): Promise<void> => {
       this.shown.push({ title, body: options?.body ?? '' })
+      this.notificationData.push(options?.data)
     },
   }
 
@@ -154,10 +157,11 @@ export class FakeWorker {
   }
 
   /** A tap on a shown notification. Returns whether it was closed. */
-  async clickNotification(): Promise<boolean> {
+  async clickNotification(data?: unknown): Promise<boolean> {
     let closed = false
     await this.fire('notificationclick', undefined, {
       notification: {
+        data,
         close: () => {
           closed = true
         },