diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
new file mode 100644
index 0000000..d31d0b6
--- /dev/null
+++ b/.github/workflows/ci.yml
@@ -0,0 +1,31 @@
+name: CI
+
+on:
+  push:
+    branches:
+      - main
+      - master
+      - develop
+  pull_request:
+
+jobs:
+  lint-and-test:
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+
+      - name: Setup Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: '20'
+
+      - name: Install dependencies
+        run: npm install
+
+      - name: Run lint
+        run: npm run lint
+
+      - name: Run tests
+        run: npm test
diff --git a/AGENTS.md b/AGENTS.md
index e505d33..5a4180b 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -1,35 +1,57 @@
 # AGENTS
 
 ## Purpose
-This document orients automation and human collaborators to the structure, conventions, and workflows in this repository.
+Reference guide for automation and human contributors. Use it to understand the structure, contracts, and preferred workflows before touching code.
+
+## Quick Start
+- Serve the repo with `npm run dev` (wraps `http-server`) or any static file server. Both the root `index.html` and `workout-time/index.html` expect a browser environment.
+- The site ships as native ES modules. Keep files co-located and avoid bundler-only features (no JSX, CommonJS, or TypeScript transforms).
+- Run automated checks with the provided npm scripts: `npm test`, `npm run lint`, `npm run format`.
 
 ## Repository Map
-- `index.html` — public-facing exercise library landing page.
-- `styles.css` — shared styling for the public site.
-- `exercise_dump.json` — exported exercise metadata referenced by the app.
-- `js/` — modular ES modules that power the exercise plan builder (`builder.js`, `context.js`, `library.js`, etc.).
-  - `plan-storage.js` centralises workout plan persistence. Interact with localStorage through the helpers exposed here rather than reimplementing storage access.
-- `workout-time/` — standalone Vitruvian workout control UI (`index.html`, `app.js`, supporting assets).
-- `local-tests/` — lightweight Node-based test harness (currently `builder.test.js`).
+- `index.html`, `styles.css` — public exercise library landing page and shared styling.
+- `exercise_dump.json` — canonical exercise dataset. Schema changes must stay compatible with search, filters, storage, and workout-time consumers.
+- `js/` — modular frontend for the library and builder.
+  - `main.js` — bootstraps data loading, state wiring, and tab switching.
+  - `context.js` — centralised state/DOM registry; route mutations through its helpers.
+  - `constants.js` — shared enums and configuration (storage keys, modes, limits).
+  - `library.js` — filter orchestration, search invocation, card rendering.
+  - `search.js` — tokenisation, fuzzy scoring, and in-memory indices.
+  - `builder.js` — workout builder UI (drag/drop, set editing, export pipelines).
+  - `grouping.js` — grouping helpers reused by the builder and library views.
+  - `plan-storage.js` — local plan index management. Always use these helpers for persisted plans.
+  - `storage.js` — broader persistence (builder snapshot, plan metadata, share-link parsing).
+  - `utils.js`, `muscles.js` — shared helpers and canonical muscle metadata.
+- `tests/` — Node test runner suites (`node --test`) covering builder flows, search scoring, storage sync, and regression cases.
+- `workout-time/` — Vitruvian workout control UI.
+  - `app.js` — orchestrates device lifecycle, plan execution, and UI state.
+  - `plan-runner.js` — timeline building, rest timers, skip/rewind logic; loaded before `app.js`.
+  - `device.js`, `protocol.js`, `chart.js`, `modes.js`, `dropbox.js` — transport, telemetry, charting, and cloud sync support.
+- `scripts/` — mock CLIs for lint/format/http-server to support sandboxed automation.
+- Tooling: `package.json`, `eslint.config.js`, `prettier.config.js` define commands and formatting conventions.
 
 ## Key Flows
-- The builder UI is data-driven: `js/context.js` initializes shared state; `js/builder.js` consumes that state to serialize plans. Keep mutations centralized in `context.js` helpers.
-- The workout control in `workout-time/app.js` communicates with hardware over WebSocket. Update connection logic cautiously; mirror any protocol changes in both UI and device code.
-- Static assets are served as-is. No bundler is configured, so prefer vanilla JS modules and relative imports.
-- For storage interactions in the plan builder, rely on `plan-storage.js` helpers. They normalise plan names, manage the plan index, and guard against localStorage failures. Avoid duplicating that logic elsewhere to keep UI state and persistence consistent.
+- **Data bootstrapping** — `main.js` fetches `exercise_dump.json`, normalises it through `context.js`, then requests initial renders from `library.js` and `builder.js`.
+- **Builder state** — All mutations route through `context.js` helpers to keep `state.builder` and DOM references consistent. `builder.js` emits serialised payloads via `storage.js` and `plan-storage.js`.
+- **Persistence** — `plan-storage.js` governs plan naming, index updates, and storage error handling. Use it instead of direct `localStorage` access.
+- **Search** — `search.js` maintains token indices; `library.js` supplies filters and delegates to search for scoring. Changing tokens or weightings requires updates to both modules.
+- **Workout-Time device loop** — `workout-time/app.js` manages WebSocket connections, device telemetry, and integrates `plan-runner.js` for execution. Mirror protocol changes across `protocol.js` and any firmware.
 
-## Development Tips
-- Use `npx http-server .` or similar to preview pages locally. Both the root `index.html` and `workout-time/index.html` expect to run in a browser environment.
-- Run `node local-tests/builder.test.js` to sanity-check plan serialization and rebuilding logic after modifying builder modules.
-- Maintain accessibility: new UI components should include keyboard support and ARIA labelling consistent with existing markup.
-- After touching persistence or plan-index flows, update `plan-storage.js` first and adapt consumers (currently `js/main.js`) to avoid drift between cached plan state and saved plans.
+## Development Workflow
+- Add or mutate state through `context.js`. Avoid duplicating DOM queries outside of its registry.
+- Maintain accessibility: mirror existing ARIA usage and keyboard interactions when extending UI.
+- When touching persistence or plan serialisation, update Node tests (`tests/plan-storage.test.js`, `tests/builder-load-plan.test.js`, `tests/builder-plan-items.test.js`) to capture new expectations.
+- Target evergreen browsers. If introducing less supported APIs, ship polyfills inline with usage.
+- Styles live in `styles.css` and component-scoped `<style>` blocks. Reserve inline styles for dynamic states only.
 
-## Agent Guidance
-- When adding features, reflect changes in both the documentation and the relevant UI (root site vs. workout control panel) to keep experiences in sync.
-- Validate data contract changes against `exercise_dump.json` to avoid breaking the plan builder.
-- For styling adjustments, prefer editing `styles.css` or component-level `<style>` blocks; avoid inline styles unless scoped to dynamic states.
+## Guidance for Agents
+- Synchronise feature updates across the builder and workout-time surfaces; document behavioural changes in `README.md` or inline comments where appropriate.
+- Validate data contract changes against `exercise_dump.json` and ensure downstream consumers still parse expected fields.
+- Reuse existing utilities before introducing new helpers. Shared logic between the browser UI and workout-time app should sit in clearly named modules to prevent drift.
+- Expand automated tests alongside features. Prefer Node’s built-in runner under `tests/`; use lightweight DOM stubs when browser-specific behaviour must be verified.
 
 ## Outstanding Opportunities
-- Add automated linting (ESLint) and formatting to catch regressions early.
-- Expand the `local-tests` suite to cover additional modules (search, storage sync, progression calculations).
-- Consider extracting shared utilities between the root UI and `workout-time` into a common module to reduce duplication.
+- Extend coverage for progression settings, equipment grouping, and workout-time plan execution edge cases.
+- Wire lint and test scripts into CI to catch regressions before deploys.
+- Extract shared plan serialisation helpers consumed by both the browser builder and workout-time runner.
+- Improve telemetry logging in `workout-time/app.js` to surface connection failures and protocol mismatches.
diff --git a/js/plan-storage.js b/js/plan-storage.js
index 70abc97..eeaca73 100644
--- a/js/plan-storage.js
+++ b/js/plan-storage.js
@@ -60,12 +60,18 @@ const parsePlanItems = (raw) => {
   }
 };
 
-const readPlanPayload = (name, storage = getStorage()) => {
+export const getPlanStorageKey = (name) => {
+  const trimmed = normalizePlanName(name);
+  return trimmed ? `${PLAN_STORAGE_PREFIX}${trimmed}` : null;
+};
+
+export const readPlanPayload = (name, storage = getStorage()) => {
   const target = getStorage(storage);
   if (!target) return [];
   const trimmed = normalizePlanName(name);
   if (!trimmed) return [];
-  const raw = target.getItem(`${PLAN_STORAGE_PREFIX}${trimmed}`);
+  const key = getPlanStorageKey(trimmed);
+  const raw = key ? target.getItem(key) : null;
   return parsePlanItems(raw);
 };
 
@@ -79,7 +85,9 @@ export const persistPlanLocally = (name, items, storage = getStorage()) => {
     throw new Error('Local storage is unavailable in this environment.');
   }
   try {
-    target.setItem(`${PLAN_STORAGE_PREFIX}${trimmed}`, JSON.stringify(Array.isArray(items) ? items : []));
+    const key = getPlanStorageKey(trimmed);
+    if (!key) throw new Error('Invalid plan key');
+    target.setItem(key, JSON.stringify(Array.isArray(items) ? items : []));
   } catch (error) {
     console.warn('Failed to store plan locally', error);
     throw new Error('Unable to store plan in local storage.');
@@ -93,7 +101,8 @@ export const removePlanLocally = (name, storage = getStorage()) => {
   const trimmed = normalizePlanName(name);
   if (!trimmed || !target) return;
   try {
-    target.removeItem(`${PLAN_STORAGE_PREFIX}${trimmed}`);
+    const key = getPlanStorageKey(trimmed);
+    if (key) target.removeItem(key);
   } catch (error) {
     console.warn('Failed to remove local plan', error);
   }
@@ -126,3 +135,19 @@ export const loadLocalPlanEntries = (storage = getStorage()) => {
 
   return entries;
 };
+
+// Expose helpers on window for non-module consumers (e.g., workout-time app)
+if (typeof window !== 'undefined') {
+  window.PlanStorage = Object.freeze({
+    PLAN_INDEX_KEY,
+    PLAN_STORAGE_PREFIX,
+    normalizePlanName,
+    readLocalPlanIndex,
+    writeLocalPlanIndex,
+    persistPlanLocally,
+    removePlanLocally,
+    loadLocalPlanEntries,
+    getPlanStorageKey,
+    readPlanPayload
+  });
+}
diff --git a/tests/builder-plan-items.test.js b/tests/builder-plan-items.test.js
index 1ffaf47..c44c1bc 100644
--- a/tests/builder-plan-items.test.js
+++ b/tests/builder-plan-items.test.js
@@ -201,3 +201,69 @@ test('buildPlanItems normalizes builder entries into plan items', () => {
     state.builder.items = new Map(originalItems);
   }
 });
+
+test('buildPlanItems clamps progression percent and respects metric units', () => {
+  const originalWeightUnit = state.weightUnit;
+  const originalOrder = [...state.builder.order];
+  const originalItems = new Map(state.builder.items);
+
+  try {
+    state.weightUnit = 'KG';
+    state.builder.order = ['metric-exercise'];
+
+    state.builder.items = new Map([
+      [
+        'metric-exercise',
+        {
+          exercise: {
+            id: 'metric-exercise',
+            name: 'Metric Builder'
+          },
+          sets: [
+            {
+              mode: 'PUMP',
+              reps: '12',
+              weight: '30',
+              progression: '1.5',
+              progressionPercent: '450'
+            },
+            {
+              mode: 'OLD_SCHOOL',
+              reps: '8',
+              weight: '28',
+              progression: '',
+              progressionPercent: '-120'
+            },
+            {
+              mode: 'OLD_SCHOOL',
+              reps: '6',
+              weight: '24',
+              progression: 'not-a-number',
+              progressionPercent: 'n/a'
+            }
+          ]
+        }
+      ]
+    ]);
+
+    const planItems = buildPlanItems();
+    assert.equal(planItems.length, 3);
+
+    const [firstSet, secondSet, thirdSet] = planItems;
+
+    assert.equal(firstSet.progressionUnit, 'KG');
+    assert.equal(firstSet.progressionDisplay, '1.5');
+    assert.equal(firstSet.progressionKg, 1.5);
+    assert.equal(firstSet.progressionPercent, 400);
+
+    assert.equal(secondSet.progressionKg, 0);
+    assert.equal(secondSet.progressionPercent, -100);
+
+    assert.equal(thirdSet.progressionKg, 0);
+    assert.equal(thirdSet.progressionPercent, null);
+  } finally {
+    state.weightUnit = originalWeightUnit;
+    state.builder.order = originalOrder;
+    state.builder.items = originalItems;
+  }
+});
diff --git a/tests/grouping.test.js b/tests/grouping.test.js
new file mode 100644
index 0000000..fdbd1c3
--- /dev/null
+++ b/tests/grouping.test.js
@@ -0,0 +1,123 @@
+import test, { beforeEach, afterEach } from 'node:test';
+import assert from 'node:assert/strict';
+
+const noop = () => {};
+const stubElement = () => ({
+  addEventListener: noop,
+  appendChild: noop,
+  removeChild: noop,
+  classList: { add: noop, remove: noop, toggle: noop },
+  setAttribute: noop,
+  style: {},
+  innerHTML: '',
+  textContent: ''
+});
+
+globalThis.document = {
+  getElementById: stubElement,
+  createElement: () => stubElement(),
+  createDocumentFragment: () => ({ appendChild: noop }),
+  body: {
+    appendChild: noop,
+    removeChild: noop,
+    classList: { add: noop, remove: noop, toggle: noop }
+  }
+};
+
+globalThis.window = globalThis;
+globalThis.requestAnimationFrame = (fn) => (typeof fn === 'function' ? fn() : undefined);
+
+const { state, groupColorMap } = await import('../js/context.js');
+const {
+  applyGrouping,
+  getGroupingClusters,
+  getGroupColor
+} = await import('../js/grouping.js');
+
+const makeExercise = (name, equipment = []) => ({
+  exercise: {
+    id: name.toLowerCase().replace(/\s+/g, '-'),
+    name,
+    equipment: Array.from(equipment)
+  },
+  sets: []
+});
+
+let snapshot = null;
+
+const captureSnapshot = () => ({
+  order: [...state.builder.order],
+  items: new Map(state.builder.items),
+  flags: {
+    equipment: state.groupByEquipment,
+    muscles: state.groupByMuscles,
+    muscleGroups: state.groupByMuscleGroups
+  }
+});
+
+const restoreSnapshot = (value) => {
+  state.builder.order = [...value.order];
+  state.builder.items = new Map(value.items);
+  state.groupByEquipment = value.flags.equipment;
+  state.groupByMuscles = value.flags.muscles;
+  state.groupByMuscleGroups = value.flags.muscleGroups;
+};
+
+beforeEach(() => {
+  snapshot = captureSnapshot();
+  state.builder.order = [];
+  state.builder.items = new Map();
+  state.groupByEquipment = false;
+  state.groupByMuscles = false;
+  state.groupByMuscleGroups = false;
+  groupColorMap.clear();
+});
+
+afterEach(() => {
+  restoreSnapshot(snapshot);
+  groupColorMap.clear();
+});
+
+test('applyGrouping clusters exercises by equipment in stable order', () => {
+  state.builder.order = ['row', 'curl', 'squat', 'plank'];
+  state.builder.items = new Map([
+    ['row', makeExercise('Row', ['Barbell'])],
+    ['curl', makeExercise('Curl', ['Dumbbell'])],
+    ['squat', makeExercise('Squat', ['Barbell'])],
+    ['plank', makeExercise('Plank', [])]
+  ]);
+
+  const changed = applyGrouping('equipment');
+  assert.equal(changed, true);
+  assert.deepEqual(state.builder.order, ['row', 'squat', 'curl', 'plank']);
+
+  const unchanged = applyGrouping('equipment');
+  assert.equal(unchanged, false);
+});
+
+test('getGroupingClusters returns metadata with consistent colors', () => {
+  state.builder.order = ['row', 'squat', 'curl', 'plank'];
+  state.builder.items = new Map([
+    ['row', makeExercise('Row', ['Barbell'])],
+    ['squat', makeExercise('Squat', ['Barbell'])],
+    ['curl', makeExercise('Curl', ['Dumbbell'])],
+    ['plank', makeExercise('Plank', [])]
+  ]);
+
+  const clusters = getGroupingClusters(state.builder.order, state.builder.items, 'equipment');
+
+  assert.equal(clusters.length, 3);
+  assert.deepEqual(clusters.map((c) => c.ids), [
+    ['row', 'squat'],
+    ['curl'],
+    ['plank']
+  ]);
+
+  assert.equal(clusters[2].label, 'No Equipment');
+
+  clusters.forEach((cluster) => {
+    const color = getGroupColor('equipment', cluster.key);
+    assert.equal(cluster.color, color);
+    assert.ok(typeof color === 'string' && color.length > 0);
+  });
+});
diff --git a/tests/plan-runner.test.js b/tests/plan-runner.test.js
new file mode 100644
index 0000000..9554192
--- /dev/null
+++ b/tests/plan-runner.test.js
@@ -0,0 +1,74 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { readFile } from 'node:fs/promises';
+import path from 'node:path';
+import vm from 'node:vm';
+import { fileURLToPath } from 'node:url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+const planRunnerPath = path.join(__dirname, '..', 'workout-time', 'plan-runner.js');
+
+const windowStub = {
+  console,
+  setTimeout: () => 0,
+  clearTimeout: () => {},
+  setInterval: () => 0,
+  clearInterval: () => {},
+  alert: () => {},
+  document: { getElementById: () => null },
+  requestAnimationFrame: (fn) => (typeof fn === 'function' ? fn() : undefined),
+  cancelAnimationFrame: noop,
+  performance: { now: () => 0 }
+};
+
+function noop() {}
+
+windowStub.window = windowStub;
+windowStub.globalThis = windowStub;
+
+vm.runInNewContext(await readFile(planRunnerPath, 'utf8'), windowStub, { filename: 'plan-runner.js' });
+
+const PlanRunnerPrototype = windowStub.PlanRunnerPrototype;
+
+test('buildPlanTimeline coerces invalid set counts', () => {
+  const items = [
+    { type: 'exercise', sets: 0 },
+    { type: 'exercise', sets: 3 },
+    null,
+    { type: 'echo', sets: '2' }
+  ];
+
+  const timeline = PlanRunnerPrototype.buildPlanTimeline.call({ planItems: items }, items);
+
+  assert.deepEqual(timeline, [
+    { itemIndex: 0, set: 1 },
+    { itemIndex: 1, set: 1 },
+    { itemIndex: 1, set: 2 },
+    { itemIndex: 1, set: 3 },
+    { itemIndex: 3, set: 1 },
+    { itemIndex: 3, set: 2 }
+  ]);
+});
+
+test('describePlanItem notes unlimited reps for Just Lift blocks', () => {
+  const summary = PlanRunnerPrototype.describePlanItem.call(
+    {
+      getUnitLabel: () => 'kg',
+      convertKgToDisplay: (value) => value,
+      getWeightInputDecimals: () => 1
+    },
+    {
+      type: 'exercise',
+      name: 'Unlimited Pump',
+      mode: 1,
+      perCableKg: 20,
+      reps: 0,
+      justLift: true,
+      cables: 2
+    }
+  );
+
+  assert.match(summary, /Unlimited reps/);
+});
diff --git a/workout-time/app.js b/workout-time/app.js
index b250ec3..e032d73 100644
--- a/workout-time/app.js
+++ b/workout-time/app.js
@@ -4,6 +4,8 @@ const LB_PER_KG = 2.2046226218488;
 const KG_PER_LB = 1 / LB_PER_KG;
 const DEFAULT_PER_CABLE_KG = 4; // ≈8.8 lb baseline when nothing is loaded
 
+const getPlanStorage = () => (typeof window !== "undefined" ? window.PlanStorage : null);
+
 class VitruvianApp {
   constructor() {
     this.device = new VitruvianDevice();
@@ -76,6 +78,8 @@ class VitruvianApp {
     this.planPauseLastSample = null;
     this._restState = null;
 
+    this._protocolWarningCache = new Set();
+
     this._hasPerformedInitialSync = false; // track if we've auto-synced once per session
     this._autoSyncInFlight = false;
 
@@ -3861,6 +3865,36 @@ class VitruvianApp {
     this.lastRepCounter = completeCounter;
   }
 
+  logConnectionFailure(error, phase = "connect") {
+    if (!error) {
+      this.addLogEntry(`[Device ${phase}] Unknown connection failure.`, "error");
+      return;
+    }
+
+    const name = error.name || "Error";
+    const message = error.message || "Unknown error";
+    const hints = [];
+
+    if (name === "NotFoundError") {
+      hints.push("No Vitruvian device detected. Ensure the trainer is powered on and nearby.");
+    } else if (name === "NotSupportedError") {
+      hints.push("This browser does not expose Web Bluetooth. Use a recent Chrome, Edge, or Opera build.");
+    } else if (name === "InvalidStateError") {
+      hints.push("The Bluetooth stack reported a busy adapter. Toggle Bluetooth or close other apps using the trainer.");
+    } else if (name === "SecurityError") {
+      hints.push("Grant Bluetooth permissions to this page and retry.");
+    } else if (name === "NetworkError") {
+      hints.push("Connection dropped mid-handshake. Move closer to the device and try again.");
+    }
+
+    if (typeof error?.code === "number" && error.code === 8) {
+      hints.push("Another application might already control the trainer.");
+    }
+
+    const hintText = hints.length ? ` Hint: ${hints.join(" ")}` : "";
+    this.addLogEntry(`[Device ${phase}] ${name}: ${message}.${hintText}`, "error");
+  }
+
   async connect() {
     try {
       // Check if Web Bluetooth is supported
@@ -3874,11 +3908,29 @@ class VitruvianApp {
       await this.device.connect();
       this.updateConnectionStatus(true);
 
+      const deviceName = this.device?.device?.name || "Vitruvian trainer";
+      this.addLogEntry(`Connected to ${deviceName}. Initialising protocol…`, "info");
+
       // Send initialization sequence
       await this.device.sendInit();
+
+      const missingCharacteristics = [];
+      if (!this.device.monitorChar) missingCharacteristics.push("monitor (0x0039)");
+      if (!this.device.propertyChar) missingCharacteristics.push("property (0x003f)");
+      if (!this.device.repNotifyChar) missingCharacteristics.push("rep notifications");
+
+      if (missingCharacteristics.length) {
+        const label = missingCharacteristics.join(", ");
+        this.addLogEntry(
+          `Protocol mismatch detected — missing ${label}. Update the trainer firmware and ensure the Workout Builder is up to date before retrying.`,
+          "error",
+        );
+      } else {
+        this.addLogEntry("Protocol handshake complete. Telemetry channels ready.", "success");
+      }
     } catch (error) {
       console.error("Connection error:", error);
-      this.addLogEntry(`Connection failed: ${error.message}`, "error");
+      this.logConnectionFailure(error, "connect");
       this.updateConnectionStatus(false);
     }
   }
@@ -3889,7 +3941,7 @@ class VitruvianApp {
       this.updateConnectionStatus(false);
     } catch (error) {
       console.error("Disconnect error:", error);
-      this.addLogEntry(`Disconnect failed: ${error.message}`, "error");
+      this.logConnectionFailure(error, "disconnect");
     }
   }
 
@@ -4702,19 +4754,276 @@ class VitruvianApp {
 
 
 
+  /* =========================
+     PLAN — NORMALISATION
+     ========================= */
+
+  normalizePlanItemsForRunner(items, options = {}) {
+    const planName = typeof options.planName === "string" && options.planName.trim()
+      ? options.planName.trim()
+      : "Unnamed plan";
+    const context = options.context || "general";
+    const sourceItems = Array.isArray(items) ? items : [];
+    const sanitized = sourceItems.map((entry) => (entry && typeof entry === "object" ? { ...entry } : {}));
+    const warnings = [];
+    let modified = false;
+
+    const labelFor = (item, index) => {
+      if (item && typeof item.name === "string" && item.name.trim()) {
+        return item.name.trim();
+      }
+      return item?.type === "echo" ? `Echo block ${index + 1}` : `Exercise ${index + 1}`;
+    };
+
+    const record = (message, severity = "warning") => {
+      warnings.push({ message, severity });
+    };
+
+    const resolveProgramMode = (value) => {
+      if (typeof value === "number" && Number.isFinite(value)) {
+        return value;
+      }
+      if (typeof value === "string") {
+        const trimmed = value.trim();
+        if (!trimmed) return null;
+        if (Object.prototype.hasOwnProperty.call(ProgramMode, trimmed)) {
+          return ProgramMode[trimmed];
+        }
+        const upper = trimmed.toUpperCase();
+        if (Object.prototype.hasOwnProperty.call(ProgramMode, upper)) {
+          return ProgramMode[upper];
+        }
+        const numeric = Number.parseInt(trimmed, 10);
+        if (Number.isFinite(numeric)) {
+          return numeric;
+        }
+      }
+      return null;
+    };
+
+    const resolveEchoLevel = (value) => {
+      if (typeof value === "number" && Number.isFinite(value)) {
+        return value;
+      }
+      if (typeof value === "string") {
+        const trimmed = value.trim();
+        if (!trimmed) return null;
+        if (Object.prototype.hasOwnProperty.call(EchoLevel, trimmed)) {
+          return EchoLevel[trimmed];
+        }
+        const upper = trimmed.toUpperCase();
+        if (Object.prototype.hasOwnProperty.call(EchoLevel, upper)) {
+          return EchoLevel[upper];
+        }
+        const numeric = Number.parseInt(trimmed, 10);
+        if (Number.isFinite(numeric)) {
+          return numeric;
+        }
+      }
+      return null;
+    };
+
+    sanitized.forEach((item, index) => {
+      if (!item || typeof item !== "object") {
+        sanitized[index] = { type: "exercise", name: `Entry ${index + 1}` };
+        modified = true;
+        record(`Entry ${index + 1} is not recognised as a workout item. Using a placeholder exercise.`, "error");
+      }
+
+      const current = sanitized[index];
+      const originalType = current.type;
+      if (typeof current.type === "string") {
+        const lowered = current.type.toLowerCase();
+        if (lowered === "exercise" || lowered === "echo") {
+          if (current.type !== lowered) {
+            current.type = lowered;
+            modified = true;
+          }
+        } else {
+          current.type = "exercise";
+          modified = true;
+          record(`Plan entry "${labelFor(current, index)}" used an unknown type (${originalType}). Defaulted to an exercise block.`, "error");
+        }
+      } else {
+        current.type = "exercise";
+      }
+
+      if (current.type === "exercise") {
+        const label = labelFor(current, index);
+        const resolvedMode = resolveProgramMode(current.mode);
+        if (resolvedMode === null) {
+          record(`Exercise "${label}" is missing a numeric mode. Update the Workout Builder and re-sync.`, "error");
+        } else if (resolvedMode !== current.mode) {
+          current.mode = resolvedMode;
+          modified = true;
+          record(`Converted legacy mode data for "${label}".`, "info");
+        }
+
+        if (!Number.isFinite(current.perCableKg)) {
+          const parsed = Number.parseFloat(current.perCableKg);
+          if (Number.isFinite(parsed)) {
+            current.perCableKg = parsed;
+            modified = true;
+            record(`Normalised per-cable weight for "${label}".`, "info");
+          } else {
+            current.perCableKg = 0;
+            modified = true;
+            record(`Exercise "${label}" has an invalid per-cable weight.`, "error");
+          }
+        }
+
+        if (!Number.isFinite(current.reps)) {
+          const parsed = Number.parseInt(current.reps, 10);
+          if (Number.isFinite(parsed)) {
+            current.reps = parsed;
+            modified = true;
+          } else {
+            current.reps = 0;
+            modified = true;
+            record(`Exercise "${label}" is missing rep data. Defaulted to 0.`, "warning");
+          }
+        }
+
+        if (!Number.isFinite(current.sets) || current.sets <= 0) {
+          const parsed = Number.parseInt(current.sets, 10);
+          current.sets = Number.isFinite(parsed) && parsed > 0 ? parsed : 1;
+          modified = true;
+        }
+
+        if (!Number.isFinite(current.restSec) || current.restSec < 0) {
+          const parsed = Number.parseInt(current.restSec, 10);
+          current.restSec = Number.isFinite(parsed) && parsed >= 0 ? parsed : 60;
+          modified = true;
+        }
+
+        if (typeof current.justLift !== "boolean") {
+          current.justLift = Boolean(current.justLift);
+          modified = true;
+        }
+
+        if (typeof current.stopAtTop !== "boolean") {
+          current.stopAtTop = Boolean(current.stopAtTop);
+          modified = true;
+        }
+
+        if (!Number.isFinite(current.progressionKg)) {
+          const parsed = Number.parseFloat(current.progressionKg);
+          if (Number.isFinite(parsed)) {
+            current.progressionKg = parsed;
+            modified = true;
+          } else {
+            current.progressionKg = 0;
+          }
+        }
+
+        if (!Number.isFinite(current.progressionPercent)) {
+          const parsed = Number.parseFloat(current.progressionPercent);
+          if (Number.isFinite(parsed)) {
+            current.progressionPercent = parsed;
+            modified = true;
+          } else {
+            current.progressionPercent = 0;
+          }
+        }
+
+        if (!Number.isFinite(current.cables) || current.cables <= 0) {
+          const parsed = Number.parseInt(current.cables, 10);
+          current.cables = Number.isFinite(parsed) && parsed > 0 ? parsed : 2;
+          modified = true;
+        }
+      } else if (current.type === "echo") {
+        const label = labelFor(current, index);
+        const resolvedLevel = resolveEchoLevel(current.level);
+        if (resolvedLevel === null) {
+          record(`Echo block "${label}" is missing a numeric level.`, "error");
+        } else if (resolvedLevel !== current.level) {
+          current.level = resolvedLevel;
+          modified = true;
+          record(`Converted legacy Echo level for "${label}".`, "info");
+        }
+
+        if (!Number.isFinite(current.eccentricPct)) {
+          const parsed = Number.parseInt(current.eccentricPct, 10);
+          if (Number.isFinite(parsed)) {
+            current.eccentricPct = parsed;
+            modified = true;
+          } else {
+            current.eccentricPct = 100;
+            modified = true;
+            record(`Echo block "${label}" missing eccentric percentage. Defaulted to 100%.`, "warning");
+          }
+        }
+
+        if (!Number.isFinite(current.targetReps)) {
+          const parsed = Number.parseInt(current.targetReps, 10);
+          current.targetReps = Number.isFinite(parsed) ? parsed : 0;
+          modified = true;
+        }
+
+        if (!Number.isFinite(current.sets) || current.sets <= 0) {
+          const parsed = Number.parseInt(current.sets, 10);
+          current.sets = Number.isFinite(parsed) && parsed > 0 ? parsed : 1;
+          modified = true;
+        }
+
+        if (!Number.isFinite(current.restSec) || current.restSec < 0) {
+          const parsed = Number.parseInt(current.restSec, 10);
+          current.restSec = Number.isFinite(parsed) && parsed >= 0 ? parsed : 60;
+          modified = true;
+        }
+
+        if (typeof current.justLift !== "boolean") {
+          current.justLift = Boolean(current.justLift);
+          modified = true;
+        }
+      }
+    });
+
+    if (warnings.length) {
+      const seen = this._protocolWarningCache;
+      warnings.forEach(({ message, severity }) => {
+        const key = `${context}|${planName}|${message}`;
+        if (!seen.has(key)) {
+          seen.add(key);
+          this.addLogEntry(`[Plan "${planName}"] ${message}`, severity);
+        }
+      });
+    }
+
+    return { items: sanitized, modified };
+  }
+
+
   /* =========================
      PLAN — PERSISTENCE
      ========================= */
 
-  plansKey() { return "vitruvian.plans.index"; }
-  planKey(name) { return `vitruvian.plan.${name}`; }
+  plansKey() {
+    const storage = getPlanStorage();
+    return storage?.PLAN_INDEX_KEY ?? "vitruvian.plans.index";
+  }
+  planKey(name) {
+    const storage = getPlanStorage();
+    if (storage?.getPlanStorageKey) {
+      return storage.getPlanStorageKey(name);
+    }
+    const trimmed = typeof name === "string" ? name.trim() : "";
+    return trimmed ? `vitruvian.plan.${trimmed}` : null;
+  }
   dropboxPlansKey() { return "vitruvian.plans.dropboxIndex"; }
 
   getAllPlanNames() {
+    const storage = getPlanStorage();
+    if (storage?.readLocalPlanIndex) {
+      return storage.readLocalPlanIndex();
+    }
+
     try {
       const raw = localStorage.getItem(this.plansKey());
       return raw ? JSON.parse(raw) : [];
-    } catch { return []; }
+    } catch {
+      return [];
+    }
   }
 
   getDropboxPlanNames() {
@@ -4725,6 +5034,11 @@ class VitruvianApp {
   }
 
   setAllPlanNames(arr) {
+    const storage = getPlanStorage();
+    if (storage?.writeLocalPlanIndex) {
+      return storage.writeLocalPlanIndex(arr);
+    }
+
     const names = Array.isArray(arr) ? Array.from(new Set(arr)) : [];
     names.sort((a, b) => a.localeCompare(b, undefined, { sensitivity: "base" }));
     try {
@@ -4747,8 +5061,24 @@ class VitruvianApp {
       throw new Error('Invalid plan payload');
     }
 
+    const normalization = this.normalizePlanItemsForRunner(items, {
+      planName: name,
+      context: 'builder-sync'
+    });
+    const payload = normalization.items;
+
     try {
-      localStorage.setItem(this.planKey(name), JSON.stringify(items));
+      const storage = getPlanStorage();
+      if (storage?.persistPlanLocally) {
+        storage.persistPlanLocally(name, payload);
+      } else {
+        const key = this.planKey(name);
+        if (!key) throw new Error('Invalid plan key');
+        localStorage.setItem(key, JSON.stringify(payload));
+        const names = new Set(this.getAllPlanNames());
+        names.add(name);
+        this.setAllPlanNames([...names]);
+      }
     } catch (error) {
       throw new Error('Unable to store plan locally');
     }
@@ -4798,12 +5128,30 @@ class VitruvianApp {
     const name = (nameInput?.value || "").trim();
     if (!name) { alert("Enter a plan name first."); return; }
     try {
-      localStorage.setItem(this.planKey(name), JSON.stringify(this.planItems));
-      const names = new Set(this.getAllPlanNames());
-      names.add(name);
-      this.setAllPlanNames([...names]);
+      let persistedName = name;
+      const storage = getPlanStorage();
+      const normalization = this.normalizePlanItemsForRunner(this.planItems, {
+        planName: name,
+        context: 'save-current'
+      });
+      const payload = normalization.items;
+      if (normalization.modified) {
+        this.planItems = payload;
+        this.renderPlanUI();
+      }
+      if (storage?.persistPlanLocally) {
+        const result = storage.persistPlanLocally(name, payload);
+        if (result?.name) persistedName = result.name;
+      } else {
+        const key = this.planKey(name);
+        if (!key) throw new Error("Invalid plan name");
+        localStorage.setItem(key, JSON.stringify(payload));
+        const names = new Set(this.getAllPlanNames());
+        names.add(name);
+        this.setAllPlanNames([...names]);
+      }
       this.refreshPlanSelectNames();
-      this.addLogEntry(`Saved plan "${name}" (${this.planItems.length} items)`, "success");
+      this.addLogEntry(`Saved plan "${persistedName}" (${this.planItems.length} items)`, "success");
     } catch (e) {
       alert(`Could not save plan: ${e.message}`);
       return;
@@ -4821,15 +5169,46 @@ class VitruvianApp {
     const sel = document.getElementById("planSelect");
     if (!sel || !sel.value) { alert("No saved plan selected."); return; }
     try {
-      let raw = localStorage.getItem(this.planKey(sel.value));
+      const key = this.planKey(sel.value);
+      if (!key) { alert("Saved plan not found."); return; }
+
+      let raw = localStorage.getItem(key);
 
       if (!raw && this.dropboxManager.isConnected) {
         await this.syncPlansFromDropbox({ silent: true });
-        raw = localStorage.getItem(this.planKey(sel.value));
+        raw = localStorage.getItem(key);
+      }
+
+      if (raw === null) { alert("Saved plan not found."); return; }
+
+      const storage = getPlanStorage();
+      const parsed = storage?.readPlanPayload
+        ? storage.readPlanPayload(sel.value)
+        : JSON.parse(raw) || [];
+
+      const normalization = this.normalizePlanItemsForRunner(parsed, {
+        planName: sel.value,
+        context: 'load-plan'
+      });
+      this.planItems = Array.isArray(normalization.items) ? normalization.items : [];
+
+      if (normalization.modified) {
+        try {
+          if (storage?.persistPlanLocally) {
+            const result = storage.persistPlanLocally(sel.value, this.planItems);
+            if (result?.name && sel.value !== result.name) {
+              this.refreshPlanSelectNames();
+              const select = document.getElementById("planSelect");
+              if (select) select.value = result.name;
+            }
+          } else {
+            localStorage.setItem(key, JSON.stringify(this.planItems));
+          }
+        } catch {
+          // Ignore persistence failures when normalising legacy data
+        }
       }
 
-      if (!raw) { alert("Saved plan not found."); return; }
-      this.planItems = JSON.parse(raw) || [];
       this.applyPlanUnitOverride(this.planItems);
       this.renderPlanUI();
       this.addLogEntry(`Loaded plan "${sel.value}"`, "success");
@@ -4859,8 +5238,14 @@ class VitruvianApp {
     }
 
     try {
-      localStorage.removeItem(this.planKey(name));
-      this.setAllPlanNames(remaining);
+      const storage = getPlanStorage();
+      if (storage?.removePlanLocally) {
+        storage.removePlanLocally(name);
+      } else {
+        const key = this.planKey(name);
+        if (key) localStorage.removeItem(key);
+        this.setAllPlanNames(remaining);
+      }
       this.refreshPlanSelectNames();
       this.addLogEntry(`Deleted plan "${name}"`, "info");
     } catch (e) {
diff --git a/workout-time/index.html b/workout-time/index.html
index 02b9576..6701863 100644
--- a/workout-time/index.html
+++ b/workout-time/index.html
@@ -2662,6 +2662,7 @@ <h2 id="planSummaryTitle" class="plan-summary-title">
         <button type="button" id="appScrollDown" class="scroll-btn down" aria-label="Jump to bottom">↓</button>
 
         <script src="https://leeoniya.github.io/uPlot/dist/uPlot.iife.js"></script>
+        <script type="module" src="../js/plan-storage.js"></script>
         <script src="modes.js"></script>
         <script src="protocol.js"></script>
         <script src="device.js"></script>