livepilot 1.26.2 → 1.27.1

package/livepilot/skills/livepilot-release/SKILL.md

@@ -28,20 +28,20 @@ Run this checklist EVERY time the user says "update everything", "push", "releas
 
 ## 2. Tool Count (must ALL match)
 
-Current: **465 tools across 56 domains**.
+Current: **467 tools across 56 domains**.
 Spectral/analyzer (bridge-only): **38**. The remaining tool surface works without the bridge or degrades gracefully. Backed by 32 bridge commands.
 
 Verify: `grep -rc "@mcp.tool" mcp_server/tools/ | grep -v ":0" | awk -F: '{sum+=$2} END{print sum}'`
 
 Files that reference tool count:
-- [ ] `README.md` — header ("465 tools. 56 domains"), bridge section ("38 spectral/analyzer tools require bridge")
+- [ ] `README.md` — header ("467 tools. 56 domains"), bridge section ("38 spectral/analyzer tools require bridge")
 - [ ] `package.json` → `"description"`
 - [ ] `server.json` → `"description"`
 - [ ] `manifest.json` → `"description"`
 - [ ] `livepilot/.Codex-plugin/plugin.json` → `"description"` (primary Codex manifest)
 - [ ] `livepilot/.claude-plugin/plugin.json` → `"description"` (must match Codex plugin)
 - [ ] `.claude-plugin/marketplace.json` → `"description"`
-- [ ] `CLAUDE.md` → "465 tools across 56 domains"
+- [ ] `CLAUDE.md` → "467 tools across 56 domains"
 - [ ] `CONTRIBUTING.md` → tool count in intro
 - [ ] `livepilot/skills/livepilot-core/SKILL.md` — tool/domain count
 - [ ] `livepilot/skills/livepilot-core/references/overview.md` — tool/domain count
@@ -85,6 +85,8 @@ Current: **56 domains**: transport, tracks, clips, notes, devices, scenes, mixin
 
 ## 6. Plugin Cache
 
+- [ ] `python3 scripts/verify_codex_plugin_sync.py` passes after `npx livepilot --install-codex-plugin`
+- [ ] `python3 scripts/verify_plugin_sync.py` passes after Claude plugin cache/mirror sync
 - [ ] `~/.claude/plugins/cache/dreamrec-LivePilot/livepilot/` has current version directory
 - [ ] Old version directories removed
 - [ ] `~/.claude/plugins/installed_plugins.json` → `livepilot@dreamrec-LivePilot` entry: update `version`, `installPath`, `gitCommitSha`, `lastUpdated`
@@ -98,7 +100,7 @@ Current: **56 domains**: transport, tracks, clips, notes, devices, scenes, mixin
 
 - [ ] `README.md` — features match current capabilities, "Coming" section is accurate
 - [ ] `docs/manual/getting-started.md` — install instructions current
-- [ ] `docs/manual/tool-reference.md` — all 56 domains listed, all 465 tools present
+- [ ] `docs/manual/tool-reference.md` — all 56 domains listed, all 467 tools present
 - [ ] `docs/M4L_BRIDGE.md` — architecture accurate, core/bridge counts correct
 
 ## 9. Derived Artifacts
@@ -147,5 +149,5 @@ Current: **56 domains**: transport, tracks, clips, notes, devices, scenes, mixin
 ## Quick Verify Command
 
 ```bash
-echo "=== Versions ===" && grep -h '"version"' package.json server.json manifest.json livepilot/.Codex-plugin/plugin.json livepilot/.claude-plugin/plugin.json .claude-plugin/marketplace.json | head -8 && grep __version__ mcp_server/__init__.py remote_script/LivePilot/__init__.py && echo "=== Tool count ===" && grep -rc "@mcp.tool" mcp_server/ | grep -v ":0" | awk -F: '{sum+=$2} END{print "Total:", sum}' && echo "=== Tests ===" && python3 -m pytest tests/ -q 2>&1 | tail -1
+echo "=== Versions ===" && grep -h '"version"' package.json server.json manifest.json livepilot/.Codex-plugin/plugin.json livepilot/.claude-plugin/plugin.json .claude-plugin/marketplace.json | head -8 && grep __version__ mcp_server/__init__.py remote_script/LivePilot/__init__.py && echo "=== Metadata ===" && python3 scripts/sync_metadata.py --check && echo "=== Plugin sync ===" && python3 scripts/verify_codex_plugin_sync.py --quiet && python3 scripts/verify_plugin_sync.py --quiet && echo "=== Tests ===" && python3 -m pytest tests/ -q 2>&1 | tail -1
 ```

package/m4l_device/livepilot_bridge.js

@@ -34,7 +34,7 @@ outlets = 2; // 0: to udpsend (responses), 1: to buffer~/status
 // Single source of truth for the bridge version — bumped alongside the
 // rest of the release manifest. Surfaced in the UI via messnamed("livepilot_version", ...)
 // so the frozen .amxd visibly reports which build it was last exported from.
-var VERSION = "1.26.2";
+var VERSION = "1.27.1";
 
 // ── State ──────────────────────────────────────────────────────────────────
 

package/mcp_server/__init__.py

@@ -1,2 +1,2 @@
 """LivePilot MCP Server — bridges MCP protocol to Ableton Live."""
-__version__ = "1.26.2"
+__version__ = "1.27.1"

package/mcp_server/atlas/__init__.py

@@ -7,9 +7,12 @@ suggestion, chain building, and device comparison.
 from __future__ import annotations
 
 import json
+import logging
 import os
 from typing import Any, Dict, List, Optional
 
+logger = logging.getLogger(__name__)
+
 
 class AtlasManager:
     """In-memory device atlas with indexed lookups."""
@@ -47,10 +50,26 @@ class AtlasManager:
             dev_category = dev.get("category", "")
 
             if dev_id:
+                if dev_id in self._by_id and self._by_id[dev_id] is not dev:
+                    logger.warning(
+                        "atlas: duplicate device id %r shadows a prior entry "
+                        "(name=%r); last-wins", dev_id, dev_name,
+                    )
                 self._by_id[dev_id] = dev
             if dev_name:
-                self._by_name[dev_name.lower()] = dev
+                name_key = dev_name.lower()
+                if name_key in self._by_name and self._by_name[name_key] is not dev:
+                    logger.warning(
+                        "atlas: duplicate device name %r shadows a prior entry "
+                        "(id=%r); last-wins", dev_name, dev_id,
+                    )
+                self._by_name[name_key] = dev
             if dev_uri:
+                if dev_uri in self._by_uri and self._by_uri[dev_uri] is not dev:
+                    logger.warning(
+                        "atlas: duplicate device uri %r shadows a prior entry "
+                        "(id=%r); last-wins", dev_uri, dev_id,
+                    )
                 self._by_uri[dev_uri] = dev
 
             # Category index

package/mcp_server/atlas/tools.py

@@ -109,11 +109,14 @@ def atlas_search(ctx: Context, query: str, category: str = "all", limit: int = 1
     try:
         from .overlays import get_overlay_index
         idx = get_overlay_index()
-        # Search all non-`packs` namespaces; `packs` is already in the bundled atlas
-        for ns in idx.list_namespaces():
-            if ns == "packs":
-                continue
-            overlay_results.extend(idx.search(query, namespace=ns, limit=limit))
+        # Single pass over the overlay index (namespace=None scans all
+        # namespaces at once), then drop `packs` client-side — `packs` is
+        # already covered by the bundled atlas. Avoids re-scanning the whole
+        # index once per namespace.
+        overlay_results = [
+            e for e in idx.search(query, namespace=None, limit=limit * 2)
+            if e.namespace != "packs"
+        ]
     except Exception:  # noqa: BLE001 — never fail atlas_search over an overlay glitch
         pass
 
@@ -177,10 +180,13 @@ def atlas_search(ctx: Context, query: str, category: str = "all", limit: int = 1
 
 
 @mcp.tool()
-def atlas_device_info(ctx: Context, device_id: str) -> dict:
+def atlas_device_info(ctx: Context, device_id: str, verbose: bool = True) -> dict:
     """Get complete atlas knowledge about a device — parameters, recipes, pairings, gotchas.
 
     device_id: the atlas ID or device name (e.g., "drift", "Compressor", "808_core_kit")
+    verbose:   when True (default) return the full raw atlas record. Set False for a
+               compact summary (capped description, tag/technique counts) — useful
+               when you only need to identify the device, not read every recipe.
     """
     atlas = _get_atlas()
     if atlas is None:
@@ -189,7 +195,29 @@ def atlas_device_info(ctx: Context, device_id: str) -> dict:
     entry = atlas.lookup(device_id)
     if entry is None:
         return {"error": f"Device '{device_id}' not found in atlas", "suggestion": "Use atlas_search to find devices"}
-    return entry
+    if verbose:
+        return entry
+    # Compact mode: the common case doesn't need the full multi-KB record.
+    # Truncate the longest free-text fields the way atlas_search already caps
+    # sonic_description, and report counts for list-heavy fields so the caller
+    # knows to re-request verbose for the full detail.
+    summary: dict = {
+        "id": entry.get("id", ""),
+        "name": entry.get("name", ""),
+        "uri": entry.get("uri", ""),
+        "category": entry.get("category", ""),
+        "enriched": bool(entry.get("enriched", False)),
+        "sonic_description": (
+            entry.get("sonic_description") or entry.get("description", "")
+        )[:_ATLAS_SEARCH_DESCRIPTION_CHAR_CAP],
+        "character_tags": (
+            entry.get("character_tags") or entry.get("tags", [])
+        )[:8],
+        "sweet_spot": str(entry.get("sweet_spot", ""))[:_ATLAS_SEARCH_DESCRIPTION_CHAR_CAP],
+    }
+    summary.update(_surface_enriched_fields(entry))
+    summary["verbose_available"] = True
+    return summary
 
 
 @mcp.tool()
@@ -258,20 +286,20 @@ def atlas_chain_suggest(ctx: Context, role: str, genre: str = "") -> dict:
             query_parts.append(genre)
         query = " ".join(query_parts)
 
-        for ns in idx.list_namespaces():
-            if ns == "packs":
-                continue
-            hits = idx.search(query, namespace=ns, limit=5)
-            for entry in hits:
-                overlay_suggestions.append({
+        hits = [
+            e for e in idx.search(query, namespace=None, limit=10)
+            if e.namespace != "packs"
+        ]
+        for entry in hits:
+            overlay_suggestions.append({
                     "namespace": entry.namespace,
                     "entity_id": entry.entity_id,
                     "name": entry.name,
                     "description": (entry.description or "")[:120],
                     "tags": list(entry.tags)[:5],
-                    "source": f"user_overlay:{entry.namespace}",
-                    "note": "Load via search_browser or extension_atlas_get; no Live URI.",
-                })
+                "source": f"user_overlay:{entry.namespace}",
+                "note": "Load via search_browser or extension_atlas_get; no Live URI.",
+            })
     except Exception:  # noqa: BLE001 — never fail chain_suggest over an overlay glitch
         pass
 
@@ -662,14 +690,17 @@ def scan_full_library(
     if not force and os.path.exists(atlas_path):
         age = time.time() - os.path.getmtime(atlas_path)
         if age < 86400:
-            # Reload if not already loaded
-            import mcp_server.atlas as atlas_mod
-            if atlas_mod._atlas_instance is None:
-                atlas_mod._atlas_instance = AtlasManager(atlas_path)
+            # Use the public, thread-safe loader rather than poking the
+            # legacy `_atlas_instance` cell directly: get_atlas() loads
+            # lazily via the Singleton holder and is the only path the rest
+            # of the module actually reads back from. The old direct
+            # AtlasManager(atlas_path) construction wrote a cell get_atlas()
+            # never consults.
+            from . import get_atlas
             return {
                 "status": "already_exists",
                 "age_hours": round(age / 3600, 1),
-                "device_count": atlas_mod._atlas_instance.device_count,
+                "device_count": get_atlas().device_count,
                 "message": "Atlas is recent. Use force=True to rescan.",
             }
 
@@ -796,6 +827,34 @@ def _serialize_overlay_entry(entry) -> dict:
     }
 
 
+_OVERLAY_DESCRIPTION_PREVIEW = 240
+
+
+def _serialize_overlay_entry_lite(entry) -> dict:
+    """Lightweight search-result serializer: drops the full YAML `body`.
+
+    The `body` of an overlay entry can be ~17 KB; inlining it for every one of
+    up to `limit` matches makes a single extension_atlas_search return hundreds
+    of KB. The search path only needs identity + a description preview so the
+    caller can decide which entry to fetch in full via extension_atlas_get.
+    """
+    description = entry.description or ""
+    truncated = len(description) > _OVERLAY_DESCRIPTION_PREVIEW
+    return {
+        "namespace": entry.namespace,
+        "entity_type": entry.entity_type,
+        "entity_id": entry.entity_id,
+        "name": entry.name,
+        "description": (
+            description[:_OVERLAY_DESCRIPTION_PREVIEW] + "…"
+            if truncated else description
+        ),
+        "tags": entry.tags,
+        "artists": entry.artists,
+        "requires_box": entry.requires_box,
+    }
+
+
 @mcp.tool()
 def extension_atlas_search(ctx: Context, query: str,
                            namespace: str = "",
@@ -822,7 +881,9 @@ def extension_atlas_search(ctx: Context, query: str,
         "namespace": namespace or None,
         "entity_type": entity_type or None,
         "count": len(matches),
-        "results": [_serialize_overlay_entry(e) for e in matches],
+        "results": [_serialize_overlay_entry_lite(e) for e in matches],
+        "note": "Search results omit the full YAML body; call "
+                "extension_atlas_get(namespace, entity_id) for the complete entry.",
     }
 
 

package/mcp_server/composer/full/apply.py

@@ -719,6 +719,15 @@ async def apply_full_plan_v2(ctx: Context, plan: dict) -> dict:
                 continue
         else:
             track_index = int(track_index)
+            # BUG-FIX (P2 zombie-cleanup): a reused/existing track must also be
+            # registered as "applied". Otherwise the postflight zombie-cleanup
+            # (which excludes only applied_track_indices) sees a reused track
+            # that currently has no session clips / instrument — e.g. one given
+            # only arrangement clips — as an empty leftover and DELETES it.
+            # Reused tracks must never be eligible for cleanup, and postflight
+            # monitoring must be restored on them too.
+            if track_index >= 0 and track_index not in applied_track_indices:
+                applied_track_indices.append(track_index)
 
         # Optional instrument load
         instrument = track_spec.get("instrument") or {}

package/mcp_server/composer/full/layer_planner.py

@@ -408,12 +408,22 @@ def plan_sections(
     Returns a list of dicts: {name, bars, layers, start_bar}.
     """
     if section_template is None:
-        raise ValueError(
-            "plan_sections() requires explicit section_template in v1.24+. "
-            "SECTION_TEMPLATES was removed — the LLM provides form, not the "
-            "framework. Pass a section_template list or use the v1.24 full-mode "
-            "compose flow which is LLM-creative."
-        )
+        # v1.24 removed the built-in SECTION_TEMPLATES registry (form is the
+        # LLM's job, not the framework's). But the deterministic scaffolding
+        # tools (augment_with_samples, get_composition_plan,
+        # propose_composer_branches) and wonder_mode still call this without a
+        # template. Degrade to a SINGLE full-length section containing every
+        # selected role — this is NOT a form template (no genre-keyed
+        # multi-section sequence, no module-level bar-count registry), it just
+        # lets those tools emit a working skeleton. Callers that want real form
+        # pass an explicit section_template.
+        roles = _select_roles(intent)
+        return [{
+            "name": "Full",
+            "bars": max(4, int(intent.duration_bars or 64)),
+            "layers": list(roles),
+            "start_bar": 0,
+        }]
 
     template = section_template
 

package/mcp_server/creative_constraints/engine.py

@@ -72,9 +72,28 @@ def validate_plan_against_constraints(
     session_info = session_info or {}
     violations: list[str] = []
     warnings: list[str] = []
+    unenforced: list[str] = []
 
     steps = plan.get("steps", [])
 
+    # Modes that carry no structural step-level rule (taste/heuristic only).
+    # They were previously skipped silently — surface them as warnings so a
+    # caller can't mistake "no violations" for "validated against this mode".
+    advisory_modes = {
+        "mood_shift_without_new_fx": (
+            "shift the mood with existing tools — adding effects is discouraged "
+            "but not auto-detected here"
+        ),
+        "make_it_stranger_but_keep_the_hook": (
+            "push novelty while preserving the hook — not enforceable from plan "
+            "steps alone"
+        ),
+        "club_translation_safe": (
+            "keep changes club/DJ-friendly — judged by mix/tempo character, not "
+            "individual steps"
+        ),
+    }
+
     for constraint in constraint_set.constraints:
         if constraint == "no_new_tracks":
             for step in steps:
@@ -96,10 +115,37 @@ def validate_plan_against_constraints(
                 if step.get("action", "") in mix_actions:
                     violations.append(f"Step modifies mix ({step['action']}) — violates arrangement_only")
 
+        elif constraint == "use_loaded_devices_only":
+            load_actions = {"load_browser_item", "insert_device", "find_and_load_device",
+                           "load_device_by_uri", "load_sample_to_simpler",
+                           "replace_simpler_sample", "insert_rack_chain"}
+            for step in steps:
+                if step.get("action", "") in load_actions:
+                    violations.append(
+                        f"Step loads a new device ({step['action']}) — violates use_loaded_devices_only"
+                    )
+
+        elif constraint == "performance_safe_creative":
+            unsafe_actions = {"create_midi_track", "create_audio_track", "create_return_track",
+                             "delete_track", "delete_device", "delete_clip", "delete_scene"}
+            for step in steps:
+                if step.get("action", "") in unsafe_actions:
+                    violations.append(
+                        f"Step is unsafe during live performance ({step['action']}) — "
+                        f"violates performance_safe_creative"
+                    )
+
+        elif constraint in advisory_modes:
+            unenforced.append(constraint)
+            warnings.append(
+                f"{constraint} is advisory: {advisory_modes[constraint]}"
+            )
+
     return {
         "valid": len(violations) == 0,
         "violations": violations,
         "warnings": warnings,
+        "unenforced_constraints": unenforced,
         "constraint_count": len(constraint_set.constraints),
     }
 

package/mcp_server/experiment/engine.py

@@ -244,12 +244,19 @@ async def run_branch_async(
     ]
 
     steps_executed = sum(1 for r in exec_results if r.ok)
+    # Only remote_command steps land on Ableton's linear undo stack. Bridge
+    # (M4L/OSC) and mcp_tool mutations do NOT, so issuing one `undo` per
+    # successful step over-undoes and walks back unrelated prior user edits.
+    # Count undos from remote_command successes alone.
+    undo_count = sum(
+        1 for r in exec_results if r.ok and r.backend == "remote_command"
+    )
     branch.executed_at_ms = int(time.time() * 1000)
     branch.after_snapshot = capture_fn()
 
-    # Undo all successful steps back to checkpoint. Undo is a remote_command,
-    # route it through the normal ableton.send_command path for simplicity.
-    for _ in range(steps_executed):
+    # Undo only the remote_command steps back to checkpoint. Undo is itself a
+    # remote_command, routed through the normal ableton.send_command path.
+    for _ in range(undo_count):
         try:
             ableton.send_command("undo", {})
         except Exception as exc:

package/mcp_server/grader/client.py

@@ -17,11 +17,14 @@ session state, returning the same shape used by `mcp_server/audit/checks.py`:
 
 from __future__ import annotations
 
+import logging
 from typing import Any, Callable, Iterable
 
 from mcp_server.audit import checks as audit_checks
 from mcp_server.audit.checks import infer_role
 
+_logger = logging.getLogger(__name__)
+
 
 _TRACK_COUNT_WARN = 8
 _TRACK_COUNT_FAIL = 12
@@ -441,11 +444,21 @@ def _aggregate_per_track(
         try:
             result = check_fn(*args)
         except Exception as exc:
+            _logger.warning(
+                "grader check %s failed for criterion %r track %r (%s): %s",
+                getattr(check_fn, "__name__", repr(check_fn)),
+                criterion_id,
+                t.get("index"),
+                t.get("name"),
+                exc,
+                exc_info=True,
+            )
             per_track.append({
                 "track_index": t.get("index"),
                 "name": t.get("name"),
                 "role": role,
                 "severity": "n/a",
+                "errored": True,
                 "summary": f"check failed: {type(exc).__name__}",
                 "issues": [],
                 "evidence": {},
@@ -459,15 +472,30 @@ def _aggregate_per_track(
         })
 
     actionable = [r for r in per_track if r["severity"] != "n/a"]
+    n_errored = sum(1 for r in per_track if r.get("errored"))
 
     if not actionable:
+        if n_errored:
+            # Every checkable track raised — do NOT masquerade an all-error
+            # sweep as a benign no-op pass. Surface it as a failure.
+            return {
+                "id": criterion_id,
+                "passed": False,
+                "severity": "fail",
+                "summary": (
+                    f"{n_errored} track(s) errored during check; no track "
+                    "produced a usable result"
+                ),
+                "issues": [],
+                "evidence": {"per_track": per_track, "errored": n_errored},
+            }
         return {
             "id": criterion_id,
             "passed": True,
             "severity": "n/a",
             "summary": "No checkable tracks (data missing or no applicable role)",
             "issues": [],
-            "evidence": {"per_track": per_track},
+            "evidence": {"per_track": per_track, "errored": n_errored},
         }
 
     has_fail = any(r["severity"] == "fail" for r in actionable)
@@ -505,7 +533,7 @@ def _aggregate_per_track(
         "severity": rubric_severity,
         "summary": summary,
         "issues": issues,
-        "evidence": {"per_track": per_track},
+        "evidence": {"per_track": per_track, "errored": n_errored},
     }
 
 

package/mcp_server/grader/tools.py

@@ -64,9 +64,15 @@ def _build_light_state(ctx: Context) -> dict[str, Any]:
         info = _safe_call(ableton, "get_track_info", {"track_index": idx})
         if not info:
             continue
-        if info.get("is_foldable") and info.get("is_master"):
+        # Skip master/return tracks (real Remote Script field names are
+        # is_master_track / is_return_track, not is_master / is_return).
+        if info.get("is_master_track") or info.get("is_return_track"):
             continue
-        if info.get("is_return"):
+        # Skip group containers — foldable group tracks hold no clips or
+        # devices of their own, so they inflate the §7.3 track count and
+        # (having a mixer volume but no role/ghost tag) trip the
+        # buried-track check. Only count real, content-bearing layers.
+        if info.get("is_foldable"):
             continue
         tracks.append({
             "index": idx,

package/mcp_server/hook_hunter/analyzer.py

@@ -108,8 +108,21 @@ def find_hook_candidates(
     for c in candidates:
         # Check if hook is present in payoff sections (via motif locations)
         if c.hook_type == "melodic" and motif_data:
-            for motif in motif_data.get("motifs", []):
-                if motif.get("name", "") in c.hook_id:
+            for idx, motif in enumerate(motif_data.get("motifs", [])):
+                # BUG-B61 fix: the old test `motif.get("name", "") in c.hook_id`
+                # was always True for real motif data, because the engine emits
+                # `motif_id` (not `name`) so .get("name","") returned "", and
+                # `"" in c.hook_id` is True for every candidate. That boosted
+                # every melodic candidate by every motif's recurrence. Rebuild
+                # the source motif's hook_id exactly as it was constructed above
+                # (motif_id -> name -> idxN fallback) and require an exact match
+                # so each candidate is boosted only by its own source motif.
+                identifier = (
+                    motif.get("motif_id")
+                    or motif.get("name")
+                    or f"idx{idx}"
+                )
+                if f"motif_{identifier}" == c.hook_id:
                     # Motif with high recurrence across sections = stronger hook
                     c.memorability = min(1.0, c.memorability + motif.get("recurrence", 0) * 0.2)
 

package/mcp_server/m4l_bridge.py

@@ -497,6 +497,7 @@ class SpectralReceiver(asyncio.DatagramProtocol):
         self._chunks: dict[str, dict] = {}  # Reassembly buffer for chunked responses
         self._chunk_times: dict[str, float] = {}  # Monotonic timestamp per chunk sequence
         self._chunk_id = 0
+        self._chunk_key: Optional[str] = None  # Key of the single active reassembly bucket
         self._response_callback: Optional[asyncio.Future] = None
         self._capture_future: Optional[asyncio.Future] = None
         self._miditool_handler: Optional[Callable[[str, dict, list], None]] = None
@@ -733,29 +734,26 @@ class SpectralReceiver(asyncio.DatagramProtocol):
         way we never poison a prior sequence, and the problem surfaces in
         logs if it happens.
         """
-        if index == 0:
+        # Only one response is chunked at a time: send_command serialises on
+        # _cmd_lock, so a single active reassembly bucket is sufficient and we
+        # do NOT need the first packet to be index 0. Accepting chunks in any
+        # order fixes the permanent-loss path where an index>0 chunk arriving
+        # before index 0 (UDP loopback reordering under load) used to split
+        # one response across two buckets that never completed.
+        active = self._chunks.get(self._chunk_key)
+        if active is None or active["total"] != total:
+            # No bucket open, OR a chunk with a different `total` arrived,
+            # meaning a new response started (e.g. the previous one timed out
+            # without ever completing). Evict any stale partial and open fresh.
+            if active is not None:
+                self._chunks.pop(self._chunk_key, None)
+                self._chunk_times.pop(self._chunk_key, None)
             self._chunk_id += 1
-            key = str(self._chunk_id)
-            self._chunks[key] = {"parts": {}, "total": total}
-            self._chunk_times[key] = time.monotonic()
-        else:
-            key = str(self._chunk_id)
-            if key not in self._chunks:
-                # Out-of-order arrival. Start a new bucket rather than append
-                # to the previous sequence's parts — that's the corruption
-                # path. Log once so it's diagnosable.
-                import sys
-                print(
-                    f"LivePilot: chunk index={index}/{total} arrived before "
-                    f"index=0 — starting fresh bucket. UDP reordering on "
-                    f"loopback suggests system load.",
-                    file=sys.stderr,
-                )
-                self._chunk_id += 1
-                key = str(self._chunk_id)
-                self._chunks[key] = {"parts": {}, "total": total}
-                self._chunk_times[key] = time.monotonic()
+            self._chunk_key = str(self._chunk_id)
+            self._chunks[self._chunk_key] = {"parts": {}, "total": total}
+            self._chunk_times[self._chunk_key] = time.monotonic()
 
+        key = self._chunk_key
         self._chunks[key]["parts"][index] = encoded
 
         if len(self._chunks[key]["parts"]) == total:

package/mcp_server/memory/taste_graph.py

@@ -182,6 +182,14 @@ class TasteGraph:
         self.evidence_count += 1
         self.last_updated_ms = now
 
+        # Write-back to persistent store
+        if self._persistent_store is not None:
+            try:
+                self._persistent_store.record_device_use(device_name, positive)
+            except Exception as exc:
+                logger.debug("record_device_use failed: %s", exc)
+                pass  # persistence is best-effort
+
     def update_novelty_from_experiment(
         self, chose_bold: bool, goal_mode: str = "improve",
     ) -> None:
@@ -200,6 +208,14 @@ class TasteGraph:
             new_val = max(0.0, current - 0.05)
         self.novelty_bands[goal_mode] = new_val
 
+        # Write-back to persistent store
+        if self._persistent_store is not None:
+            try:
+                self._persistent_store.update_novelty(chose_bold, goal_mode)
+            except Exception as exc:
+                logger.debug("update_novelty failed: %s", exc)
+                pass  # persistence is best-effort
+
     # ── Ranking ──────────────────────────────────────────────────────
 
     def rank_moves(