aether-robotics 5.2.2__tar.gz → 5.2.4__tar.gz

{aether_robotics-5.2.2/aether_robotics.egg-info → aether_robotics-5.2.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aether-robotics
-Version: 5.2.2
+Version: 5.2.4
 Summary: Autonomous multi-agent robotics system with DRL-First Hybrid FDIR
 Author: Chahel Paatur
 License: MIT
@@ -144,6 +144,20 @@ Full engineering detail, including the algorithms and where they came from: [doc
 
 ## What's New
 
+### v5.2.4 — The 22-second embedding load, and the warm-up that never ran
+
+Loading MiniLM takes **~22 s on a Pi 4**. Everything else was noise.
+
+- **The async warm-up had been dead since v5.1.0.** Its only call chain was `warm_up_async ← auto_migrate_on_boot ← print_startup`, and v5.1.0 moved `print_startup()` inside `if _verbose:` — so no normal boot warmed the model. It is now started explicitly from boot, nice'd, and instrumented (`[EMBED] warm-up loaded in 21840ms`).
+- **`available()` was loading the model.** It was `get_model() is not None`, so asking "are embeddings available?" performed the full load — on every `plan_cache.enabled()`, and in the guard in front of the warm-up itself. One level down, `is_installed()` did `import sentence_transformers`, which pulls torch. Both are now genuinely cheap (`find_spec`, 30 ms).
+- **Exact-match cache tier, no model required.** Repeating an objective verbatim — the common case — is now a normalized string comparison. Embedding similarity remains only as the fallback for genuinely reworded objectives.
+- **`AETHER_RAG_MODE=auto|always|off`** (default `auto`): while the model is cold, retrieval is *skipped* and planning proceeds normally. An optimisation that costs 22 s to save 1 s must yield, not block.
+- **`get_model()` is now lock-serialised.** Without it the main thread never waited for the warm-up thread — it started a *second* concurrent 22 s load.
+- **`--objective` one-shot was broken**: it used the autonomous path, which has no plan-cache lookup, and discarded the result. It now checks the cache and prints the outcome.
+- Never stall silently: `[MEM] Loading embedding model (first use, ~20s on a Pi)...`
+
+**A correction:** the v5.2.2 and v5.2.3 latency claims were measured on a macOS dev box and extrapolated. The import-time work in v5.2.3 was real but was never the 50 s. This one was found by measuring on the hardware that had the problem.
+
 ### v5.2.2 — Boot is the latency now, so boot got measured
 
 With planning cached at 0 ms and `get_distance` at 6 ms, the remaining ~5 s was boot — running before every objective, and entirely unmeasured. Instrumented first:
@@ -187,6 +201,8 @@ Five sit above 0.88. And the discriminator isn't "contains a number" — *open*
 
 **Faster.** A repeat objective no longer calls the LLM at all. On real hardware `get_distance` executes in 4-6 ms while planning takes ~1 s, so for sensor-only work the model was ~99% of wall clock — and users repeat themselves constantly.
 
+> **Note on the `[rag]` extra:** the embedding model costs **~22 s to load once per process on a Pi 4**. AETHER warms it in the background and, by default (`AETHER_RAG_MODE=auto`), skips retrieval entirely while it is still cold — so a cold first objective plans normally rather than waiting. Exact repeats of a previous objective are served from cache without touching the model at all.
+
 - **Semantic plan cache.** A successful plan is stored against the embedding of the objective that produced it; a semantically equivalent objective replays it. **~6 ms instead of ~1000 ms — roughly 158× on a repeat.** Every entry is keyed on the robot's genome hash and a mismatch is a *hard* miss: a cached plan is instructions for moving a physical machine and must never replay against different hardware. Parameters are replayed verbatim, never interpolated — 0.95 cosine still admits "2 seconds" vs "20 seconds". Needs the `[rag]` extra; degrades to normal planning without it.
 - **Anthropic prompt caching** on the static system prefix (~71 tool descriptions), plus **latency instrumentation** on every planning call: `[PLAN] via anthropic in 847ms (cached prefix: 4200 tok)`.
 - **Provider detection persisted** for 24 h against a credential-presence fingerprint, so boot stays off the detection path.

{aether_robotics-5.2.2 → aether_robotics-5.2.4}/README.md

@@ -96,6 +96,20 @@ Full engineering detail, including the algorithms and where they came from: [doc
 
 ## What's New
 
+### v5.2.4 — The 22-second embedding load, and the warm-up that never ran
+
+Loading MiniLM takes **~22 s on a Pi 4**. Everything else was noise.
+
+- **The async warm-up had been dead since v5.1.0.** Its only call chain was `warm_up_async ← auto_migrate_on_boot ← print_startup`, and v5.1.0 moved `print_startup()` inside `if _verbose:` — so no normal boot warmed the model. It is now started explicitly from boot, nice'd, and instrumented (`[EMBED] warm-up loaded in 21840ms`).
+- **`available()` was loading the model.** It was `get_model() is not None`, so asking "are embeddings available?" performed the full load — on every `plan_cache.enabled()`, and in the guard in front of the warm-up itself. One level down, `is_installed()` did `import sentence_transformers`, which pulls torch. Both are now genuinely cheap (`find_spec`, 30 ms).
+- **Exact-match cache tier, no model required.** Repeating an objective verbatim — the common case — is now a normalized string comparison. Embedding similarity remains only as the fallback for genuinely reworded objectives.
+- **`AETHER_RAG_MODE=auto|always|off`** (default `auto`): while the model is cold, retrieval is *skipped* and planning proceeds normally. An optimisation that costs 22 s to save 1 s must yield, not block.
+- **`get_model()` is now lock-serialised.** Without it the main thread never waited for the warm-up thread — it started a *second* concurrent 22 s load.
+- **`--objective` one-shot was broken**: it used the autonomous path, which has no plan-cache lookup, and discarded the result. It now checks the cache and prints the outcome.
+- Never stall silently: `[MEM] Loading embedding model (first use, ~20s on a Pi)...`
+
+**A correction:** the v5.2.2 and v5.2.3 latency claims were measured on a macOS dev box and extrapolated. The import-time work in v5.2.3 was real but was never the 50 s. This one was found by measuring on the hardware that had the problem.
+
 ### v5.2.2 — Boot is the latency now, so boot got measured
 
 With planning cached at 0 ms and `get_distance` at 6 ms, the remaining ~5 s was boot — running before every objective, and entirely unmeasured. Instrumented first:
@@ -139,6 +153,8 @@ Five sit above 0.88. And the discriminator isn't "contains a number" — *open*
 
 **Faster.** A repeat objective no longer calls the LLM at all. On real hardware `get_distance` executes in 4-6 ms while planning takes ~1 s, so for sensor-only work the model was ~99% of wall clock — and users repeat themselves constantly.
 
+> **Note on the `[rag]` extra:** the embedding model costs **~22 s to load once per process on a Pi 4**. AETHER warms it in the background and, by default (`AETHER_RAG_MODE=auto`), skips retrieval entirely while it is still cold — so a cold first objective plans normally rather than waiting. Exact repeats of a previous objective are served from cache without touching the model at all.
+
 - **Semantic plan cache.** A successful plan is stored against the embedding of the objective that produced it; a semantically equivalent objective replays it. **~6 ms instead of ~1000 ms — roughly 158× on a repeat.** Every entry is keyed on the robot's genome hash and a mismatch is a *hard* miss: a cached plan is instructions for moving a physical machine and must never replay against different hardware. Parameters are replayed verbatim, never interpolated — 0.95 cosine still admits "2 seconds" vs "20 seconds". Needs the `[rag]` extra; degrades to normal planning without it.
 - **Anthropic prompt caching** on the static system prefix (~71 tool descriptions), plus **latency instrumentation** on every planning call: `[PLAN] via anthropic in 847ms (cached prefix: 4200 tok)`.
 - **Provider detection persisted** for 24 h against a credential-presence fingerprint, so boot stays off the detection path.

aether_robotics-5.2.4/VERSION

@@ -0,0 +1 @@
+5.2.4

{aether_robotics-5.2.2 → aether_robotics-5.2.4}/aether/__init__.py

@@ -1,4 +1,11 @@
-__version__ = "5.2.2"
+import time as _time
+
+#: Wall clock at the very first moment AETHER code runs. boot_timer measures
+#: from here so "python_imports" is attributed rather than showing up as an
+#: unexplained gap between the phase total and wall clock (v5.2.3).
+_IMPORT_START = _time.time()
+
+__version__ = "5.2.4"
 __author__ = "Chahel Paatur"
 
 #: Where users should actually be sent. v5.1.2: the GitHub repository is

{aether_robotics-5.2.2 → aether_robotics-5.2.4}/aether/app.py

@@ -907,6 +907,7 @@ def _extract_key_facts(output) -> str:
 
 def run_agent(args) -> None:
     """Real agent mode: prompt-driven loop with live tool execution."""
+    from aether.core import boot_timer
     from aether.core.analytics import check_consent_or_prompt
     check_consent_or_prompt()   # v4.1.0.2: consent gate on every entrypoint
     from aether.core.tool_registry import ToolRegistry, ToolResult, register_built_tools
@@ -942,14 +943,15 @@ def run_agent(args) -> None:
     # ── Step 2: Banner already printed in main() ──────────────────────
 
     # ── Step 3: AutoUpdater ───────────────────────────────────────────
-    updater = AutoUpdater()
+    with boot_timer.phase("autoupdater"):
+        updater = AutoUpdater()
     AutoUpdater.ensure_version_file(_PROJECT_ROOT)
     updater.run(auto_update=auto_update, no_update=no_update)
 
     # ── Step 4: Capability Discovery ──────────────────────────────────
-    from aether.core import boot_timer
     discovery = ToolDiscovery()
-    discovery.discover()
+    with boot_timer.phase("discovery"):
+        discovery.discover()
     # v5.1.1 UI 1: the ~70-line inventory is a debugging surface, not a boot
     # screen. It stays one `capabilities` command (or AETHER_VERBOSE=1) away,
     # and `aether doctor` is untouched.
@@ -957,8 +959,10 @@ def run_agent(args) -> None:
         discovery.print_summary()
 
     # ── Step 5: AutoInstaller ─────────────────────────────────────────
-    installer = AutoInstaller(discovery.manifest)
-    packages_installed = installer.run(auto_install=auto_install, no_install=no_install)
+    with boot_timer.phase("autoinstaller"):
+        installer = AutoInstaller(discovery.manifest)
+        packages_installed = installer.run(auto_install=auto_install,
+                                           no_install=no_install)
 
     # ── Step 6: Re-run discovery if anything was installed ────────────
     if packages_installed:
@@ -1080,8 +1084,9 @@ def run_agent(args) -> None:
     planner = Planner()
 
     # ── Step 7: Build Tools + Navigation Engine ───────────────────────
-    builder = ToolBuilder(discovery.manifest)
-    built_tools = builder.build_all()
+    with boot_timer.phase("tool_build"):
+        builder = ToolBuilder(discovery.manifest)
+        built_tools = builder.build_all()
     _print_activity("TOOLS", builder.build_summary())
 
     # OLED startup animation (only on Pi with real hardware attached)
@@ -1093,7 +1098,8 @@ def run_agent(args) -> None:
         except Exception as e:
             _print_activity("OLED", f"startup animation failed: {e}")
 
-    nav_engine = NavigationEngine(discovery.manifest, tools=built_tools)
+    with boot_timer.phase("nav_engine"):
+        nav_engine = NavigationEngine(discovery.manifest, tools=built_tools)
     _register_gpio_cleanup(nav_engine)   # drain PWMs + GPIO.cleanup on exit
     nav_actions = nav_engine.available_actions()
     _print_activity("NAV", f"Level {nav_engine.level} ({nav_engine.level_name}) — "
@@ -1218,6 +1224,19 @@ def run_agent(args) -> None:
     # Load persistent memory
     recent_memory = _load_agent_memory(5)
 
+    # v5.2.4 (BUG 1): start the embedding warm-up EXPLICITLY. Its only call
+    # chain was warm_up_async <- auto_migrate_on_boot <- print_startup, and
+    # v5.1.0 moved print_startup() inside `if _verbose:` — so every normal
+    # boot since has had no warm-up at all, and the first objective paid the
+    # full ~22s model load on a Pi. Called here so it cannot be disconnected
+    # again by a change to what boot prints.
+    try:
+        from aether.core import embeddings as _embeddings
+        if _embeddings.available():
+            _embeddings.warm_up_async()
+    except Exception:
+        pass
+
     # v5.1.0 FIX 6: the 71-line tool dump is a debugging aid, not an
     # onboarding experience. It moves behind `tools` / --verbose, and a
     # first-time user gets three things they can actually type instead.
@@ -1260,7 +1279,10 @@ def run_agent(args) -> None:
             status = "OK" if mem.get("outcome") == "SUCCESS" else "FAIL"
             print(f"  [{status}] {mem.get('objective', '?')[:60]}")
 
-    if _firstrun.check_and_mark(_firstrun.QUICKSTART_SHOWN):
+    _is_one_shot = bool((getattr(args, "objective", "") or "").strip())
+    if _is_one_shot:
+        pass                      # v5.2.4: scripted use gets no REPL banner
+    elif _firstrun.check_and_mark(_firstrun.QUICKSTART_SHOWN):
         _print_quickstart(available)
     else:
         print("\nType an objective ('tools' to list tools, "
@@ -1320,11 +1342,16 @@ def run_agent(args) -> None:
     # invocation must not touch shell history or block waiting on input.
     _one_shot = (getattr(args, "objective", "") or "").strip()
     if _one_shot:
-        _execute_objective(_one_shot, registry, llm_planner, corrector,
-                           parser, manifest, _load_agent_memory(5),
-                           available)
+        # v5.2.4 (BUG 2): _execute_objective is the autonomous/TUI path and
+        # has NO plan-cache lookup, so one-shot mode always paid a full API
+        # call for an objective the REPL would have served from cache — and
+        # its return value was discarded, so nothing was printed either. Route
+        # through the shared helper the REPL uses instead.
+        _result = _run_one_shot(_one_shot, registry, llm_planner, corrector,
+                                parser, manifest, _load_agent_memory(5),
+                                available)
         _feedback.session_ended()
-        return
+        sys.exit(0 if _result.get("status") in ("SUCCESS", "DEGRADED") else 1)
 
     _ui.enable_readline()     # v5.1.1 UI 2: history + line editing
 
@@ -1397,10 +1424,6 @@ def run_agent(args) -> None:
         plan = None
         plan_source = "keyword"
 
-        # Inject planning hints from past experience
-        hints = _persistent_memory.planning_hints(objective)
-        if hints:
-            _print_activity("MEM", "Found similar past objectives")
 
         if oled_tool is not None:
             try:
@@ -1413,7 +1436,19 @@ def run_agent(args) -> None:
         # the genome hash — a plan built for one robot must never run on
         # another, so a hash mismatch is a hard miss, not a fuzzy match.
         from aether.core import plan_cache as _plan_cache
-        _cache_hit = _plan_cache.lookup(objective, _genome_hash(), available)
+        # v5.2.4 (BUG 1): the cache is consulted FIRST. On a hit the planner
+        # is never called, so building its retrieval context beforehand was
+        # pure waste — and on a cold model it was a ~22s stall to produce
+        # hints nothing would read.
+        _cache_hit = (_plan_cache.lookup_exact(objective, _genome_hash(),
+                                               available)
+                      or _plan_cache.lookup(objective, _genome_hash(),
+                                            available))
+        hints = None
+        if _cache_hit is None:
+            hints = _persistent_memory.planning_hints(objective)
+            if hints:
+                _print_activity("MEM", "Found similar past objectives")
         if _cache_hit is not None:
             _entry, _similarity = _cache_hit
             plan = [dict(step) for step in _entry["plan"]]
@@ -2301,6 +2336,57 @@ def _summarize_skill_output(output) -> Optional[str]:
     return None
 
 
+def _run_one_shot(objective, registry, llm_planner, corrector, parser,
+                  manifest, recent_memory, available):
+    """Execute one objective and PRINT what happened (v5.2.4 BUG 2).
+
+    Shares _execute_objective with autonomous mode, but adds the two things
+    one-shot mode was missing: a plan-cache lookup before planning, and
+    printing the result rather than exiting silently.
+    """
+    from aether.core import plan_cache as _plan_cache
+
+    hit = (_plan_cache.lookup_exact(objective, _genome_hash(), available)
+           or _plan_cache.lookup(objective, _genome_hash(), available))
+    if hit is not None:
+        entry, similarity = hit
+        print(f"  [CACHE] Reusing plan (similarity {similarity:.2f}) — "
+              f"skipped the planning call")
+        llm_planner = _CachedPlanner(entry["plan"], llm_planner)
+
+    result = _execute_objective(objective, registry, llm_planner, corrector,
+                                parser, manifest, recent_memory, available)
+
+    outcome = result.get("status", "?")
+    print(f"\n  {'✓' if outcome == 'SUCCESS' else '!'} {outcome} · "
+          f"{len(result.get('actions', []))} action(s) · "
+          f"{result.get('faults', 0)} fault(s)")
+    payload = result.get("result")
+    if payload:
+        text = _summarize_output(payload)
+        print(f"  {text}")
+    return result
+
+
+class _CachedPlanner:
+    """Serves a cached plan in place of an API call, keeping the planner's
+    interface so _execute_objective is unchanged."""
+
+    def __init__(self, plan, wrapped):
+        self._plan = [dict(step) for step in plan]
+        self._wrapped = wrapped
+        self.last_raw_response = ""
+        self.last_provider_error = ""
+        self.last_latency_ms = 0.0
+
+    @property
+    def available(self):
+        return True
+
+    def plan(self, objective, manifest, memory=None):
+        return self._plan
+
+
 def _execute_objective(objective: str, registry, llm_planner, corrector,
                        parser_obj, manifest, recent_memory,
                        available, fix_mode: bool = False,

{aether_robotics-5.2.2 → aether_robotics-5.2.4}/aether/core/auto_updater.py

@@ -87,6 +87,26 @@ class AutoUpdater:
                 pass
         return CURRENT_VERSION
 
+    #: v5.2.3: the update check is CACHED for a day. It used to hit PyPI on
+    #: every boot — network I/O on the critical path, which is exactly the
+    #: user>>real gap that made a 50s boot only 21s of CPU. A version check is
+    #: not worth a single millisecond of a robot's startup.
+    _CHECK_TTL_S = 24 * 3600
+
+    def _cached_check(self):
+        try:
+            from aether.core.providers._cache import cache_get
+            return cache_get("update:latest", self._CHECK_TTL_S)
+        except Exception:
+            return None
+
+    def _remember_check(self, payload) -> None:
+        try:
+            from aether.core.providers._cache import cache_set
+            cache_set("update:latest", payload)
+        except Exception:
+            pass
+
     def _fetch_latest_release(self) -> Optional[Dict]:
         """Latest published version, from PyPI.
 
@@ -98,6 +118,11 @@ class AutoUpdater:
 
         Returns the same {"tag_name", "body"} shape the callers already expect.
         """
+        cached = self._cached_check()
+        if isinstance(cached, dict) and cached.get("tag_name"):
+            return cached
+        if os.environ.get("AETHER_NO_UPDATE_CHECK"):
+            return None
         try:
             import urllib.request
             with urllib.request.urlopen(_PYPI_JSON_URL,
@@ -108,8 +133,11 @@ class AutoUpdater:
         version = str(info.get("version") or "").strip()
         if not version:
             return None
-        return {"tag_name": f"v{version}",
-                "body": f"See {info.get('project_url') or 'PyPI'} for details."}
+        payload = {"tag_name": f"v{version}",
+                   "body": f"See {info.get('project_url') or 'PyPI'} "
+                           f"for details."}
+        self._remember_check(payload)
+        return payload
 
     def check_for_update(self) -> Optional[str]:
         """Check GitHub releases for a newer version.

{aether_robotics-5.2.2 → aether_robotics-5.2.4}/aether/core/boot_timer.py

@@ -75,6 +75,56 @@ def summary_line(limit: int = 6) -> str:
     return " · ".join(parts) + f" · total {total_ms():.0f}ms"
 
 
+#: Wall clock at interpreter start, so the report covers process start to
+#: prompt rather than only the phases someone remembered to wrap.
+try:
+    from aether import _IMPORT_START as _PROCESS_START
+except Exception:
+    _PROCESS_START = time.time()
+
+#: The measured phases must account for at least this fraction of wall clock.
+#: v5.2.2 shipped a timer that wrapped ONE function and then printed
+#: "total 25ms" for a 50,845ms boot — a claim far worse than no instrumentation,
+#: because it said the problem was solved. If coverage is below this, the
+#: report says so instead of quoting a total it cannot justify.
+COVERAGE_FLOOR = 0.95
+
+
+def wall_ms() -> float:
+    return (time.time() - _PROCESS_START) * 1000.0
+
+
+def coverage() -> float:
+    """Fraction of wall clock the measured phases actually account for."""
+    wall = wall_ms()
+    return (total_ms() / wall) if wall > 0 else 0.0
+
+
+def coverage_note() -> str:
+    """'(wall 50845ms ✓)' or a loud warning that the numbers do not sum."""
+    wall = wall_ms()
+    if coverage() >= COVERAGE_FLOOR:
+        return f"(wall {wall:.0f}ms ✓)"
+    unmeasured = wall - total_ms()
+    return (f"(wall {wall:.0f}ms — ⚠ {unmeasured:.0f}ms UNMEASURED, "
+            f"phases cover only {coverage() * 100:.0f}%)")
+
+
+def record_import_phase() -> None:
+    """Attribute everything before the first timed phase to python_imports.
+
+    Without this the phases never sum to wall clock and the coverage check
+    warns forever, which would train everyone to ignore it — the same way the
+    v5.2.2 "total 25ms" line trained us to believe boot was fast.
+    """
+    if not _enabled or any(p["phase"] == "python_imports" for p in _phases):
+        return
+    already = total_ms()
+    before = wall_ms() - already
+    if before > 0:
+        _phases.insert(0, {"phase": "python_imports", "ms": round(before, 1)})
+
+
 def report() -> None:
     """Print the summary under AETHER_VERBOSE=1 and always emit analytics.
 
@@ -84,9 +134,13 @@ def report() -> None:
     """
     if not _phases:
         return
+    record_import_phase()
     try:
         if os.environ.get("AETHER_VERBOSE"):
-            print(f"  [BOOT] {summary_line()}")
+            for entry in sorted(_phases, key=lambda p: -p["ms"]):
+                print(f"  [BOOT] {entry['phase']:<24} {entry['ms']:>8.0f}ms")
+            print(f"  [BOOT] {'TOTAL':<24} {total_ms():>8.0f}ms "
+                  f"{coverage_note()}")
     except Exception:
         pass
     try:
@@ -94,5 +148,9 @@ def report() -> None:
         for entry in _phases:
             track("boot_latency", {"phase": entry["phase"], "ms": entry["ms"]})
         track("boot_latency", {"phase": "total", "ms": total_ms()})
+        # Coverage travels with the numbers: a total that accounts for 3% of
+        # wall clock must not be read as a fast boot.
+        track("boot_latency", {"phase": "wall", "ms": round(wall_ms(), 1),
+                               "coverage": round(coverage(), 3)})
     except Exception:
         pass

{aether_robotics-5.2.2 → aether_robotics-5.2.4}/aether/core/embeddings.py

@@ -55,14 +55,54 @@ def reset_model() -> None:
 
 
 def is_installed() -> bool:
-    """True when the sentence-transformers package can be imported."""
+    """True when sentence-transformers is present — WITHOUT importing it.
+
+    v5.2.4: this used to `import sentence_transformers`, which pulls torch —
+    ~0.6s on a dev Mac and 10-20s on a Pi 4. So the cheap-looking capability
+    check was itself the expensive thing, one level below available(). find_spec
+    locates the package without executing it.
+    """
     try:
-        import sentence_transformers  # noqa: F401
-        return True
+        import importlib.util
+        return importlib.util.find_spec("sentence_transformers") is not None
     except Exception:
         return False
 
 
+_LOAD_LOCK = None
+_warm_started = 0.0
+_warm_elapsed = None
+
+
+def _lock():
+    """One lock, created lazily so import stays cheap."""
+    global _LOAD_LOCK
+    if _LOAD_LOCK is None:
+        import threading
+        _LOAD_LOCK = threading.Lock()
+    return _LOAD_LOCK
+
+
+def is_loaded() -> bool:
+    """True when the model is resident and embedding is effectively free.
+
+    v5.2.4: callers use this to DECIDE whether an optional embedding is worth
+    it. On a Pi 4 a cold load is ~22s, so retrieval — an optimisation for a
+    ~1s planning call — must never be the thing that blocks.
+    """
+    return _model is not None
+
+
+def warm_state() -> dict:
+    """Diagnostics for the warm-up thread (v5.2.4)."""
+    import threading
+    alive = any(t.name == "aether-embed-warmup" and t.is_alive()
+                for t in threading.enumerate())
+    return {"loaded": is_loaded(), "failed": _load_failed,
+            "thread_alive": alive, "started_at": _warm_started,
+            "elapsed_ms": _warm_elapsed}
+
+
 def get_model():
     """Return the cached SentenceTransformer, loading it on first use.
 
@@ -74,6 +114,27 @@ def get_model():
         return _model
     if _load_failed:
         return None
+
+    # v5.2.4: without this lock the main thread did NOT wait for the warm-up
+    # thread — it saw _model is None and started a SECOND concurrent load.
+    # Two 22-second torch loads competing for four Pi cores is worse than one.
+    with _lock():
+        if _model is not None:
+            return _model
+        if _load_failed:
+            return None
+        # v5.2.4: fourteen silent seconds reads as a hang. Announced on the
+        # foreground path only — the warm-up thread has its own [EMBED] line
+        # and should not print over the boot screen.
+        import threading as _th
+        if _th.current_thread().name != "aether-embed-warmup":
+            print("  [MEM] Loading embedding model "
+                  "(first use, ~20s on a Pi)...", flush=True)
+        return _load_model_locked()
+
+
+def _load_model_locked():
+    global _model, _load_failed
     try:
         # Keep HF quiet: progress bars and telemetry would corrupt the v4.2.0
         # TUI screen and add noise to classic CLI output.
@@ -106,8 +167,24 @@ def get_model():
 
 
 def available() -> bool:
-    """True when embeddings can actually be computed right now."""
-    return get_model() is not None
+    """True when embeddings COULD be computed — without loading the model.
+
+    v5.2.4: this used to be `get_model() is not None`, i.e. asking "are
+    embeddings available?" performed the full ~22s load on a Pi. Every caller
+    that thought it was making a cheap capability check was paying for it,
+    including plan_cache.enabled() on every objective and the guard in front
+    of warm_up_async — which meant deciding whether to warm the model
+    asynchronously first loaded it synchronously.
+
+    Availability is now package-installability plus "we have not already
+    failed", which is what callers actually meant. Use is_loaded() to ask
+    whether embedding is free RIGHT NOW.
+    """
+    if _load_failed:
+        return False
+    if _model is not None:
+        return True
+    return is_installed()
 
 
 # Single source of truth for "why is retrieval off?" so every surface gives
@@ -143,14 +220,34 @@ def warm_up_async() -> None:
     import threading
 
     def _load():
+        global _warm_elapsed
+        import time as _t
+        start = _t.time()
         try:
+            # v5.2.4: nice the thread. The load is ~22s of CPU-bound torch
+            # work; on a 4-core Pi at default priority it contends with the
+            # boot path it is supposed to be hiding behind.
+            try:
+                os.nice(10)
+            except Exception:
+                pass
             get_model()
         except Exception:
             pass
+        finally:
+            _warm_elapsed = round((_t.time() - start) * 1000.0, 1)
+            if os.environ.get("AETHER_VERBOSE"):
+                state = "loaded" if is_loaded() else "FAILED"
+                print(f"  [EMBED] warm-up {state} in {_warm_elapsed:.0f}ms")
 
+    global _warm_started
     try:
+        import time as _t
+        _warm_started = _t.time()
         threading.Thread(target=_load, name="aether-embed-warmup",
                          daemon=True).start()
+        if os.environ.get("AETHER_VERBOSE"):
+            print("  [EMBED] warm-up thread started")
     except Exception:
         pass
 

{aether_robotics-5.2.2 → aether_robotics-5.2.4}/aether/core/memory.py

@@ -561,7 +561,23 @@ def build_retrieval_block(objective: str, k: int = 3,
     unavailable, or anything at all goes wrong — callers append the result
     unconditionally, so an empty string means the prompt is byte-identical
     to v4.2.0. Never injects empty scaffolding.
+
+    v5.2.4: in AETHER_RAG_MODE=auto (the default) this returns "" while the
+    embedding model is still cold. Retrieval improves a ~1s planning call; on
+    a Pi 4 loading MiniLM costs ~22s. An optimisation that is twenty times
+    more expensive than what it optimises must yield, not block.
     """
+    try:
+        from aether.core.plan_cache import embedding_ready, rag_mode
+        if not embedding_ready():
+            if rag_mode() == "auto":
+                import os as _os
+                if _os.environ.get("AETHER_VERBOSE"):
+                    print("  [MEM] Embedding model still loading — "
+                          "planning without retrieval this time")
+            return ""
+    except Exception:
+        pass
     try:
         # Resolve the default path at call time (not via the __init__ default
         # arg, which binds at import) so tests can redirect it.

{aether_robotics-5.2.2 → aether_robotics-5.2.4}/aether/core/navigation_engine.py

@@ -149,22 +149,44 @@ class _CameraNav:
     cv2 is not installed.
     """
 
+    @property
+    def _backend_name(self):
+        self._resolve_nav_backend()
+        return self._backend_name_cached
+
+    @property
+    def _backend_mod(self):
+        self._resolve_nav_backend()
+        return self._backend_mod_cached
+
+    def _resolve_nav_backend(self):
+        if self._nav_backend_resolved:
+            return
+        self._nav_backend_resolved = True
+        (self._backend_name_cached,
+         self._backend_mod_cached) = _detect_nav_camera_backend()
+        # Logged here, not in __init__: reading the backend just to name it
+        # was what imported cv2 on every boot.
+        if self._backend_name_cached == "cv2":
+            self._cv2 = self._backend_mod_cached
+            _nav_cam_log.info("Using cv2 backend")
+        elif self._backend_name_cached == "picamera2":
+            _nav_cam_log.info("Using picamera2 backend")
+        else:
+            _nav_cam_log.warning("No camera backend available")
+
     def __init__(self):
-        self._backend_name, self._backend_mod = _detect_nav_camera_backend()
+        # v5.2.3: deferred — this imported cv2 on every boot for a camera the
+        # session may never use.
+        self._backend_name_cached = None
+        self._backend_mod_cached = None
+        self._nav_backend_resolved = False
         self._cv2 = None
         self._cap = None           # cv2 VideoCapture
         self._picam = None         # picamera2 instance
         self._picam_started = False
         self._prev_gray = None
 
-        if self._backend_name == "cv2":
-            self._cv2 = self._backend_mod
-            _nav_cam_log.info("Using cv2 backend")
-        elif self._backend_name == "picamera2":
-            _nav_cam_log.info("Using picamera2 backend")
-        else:
-            _nav_cam_log.warning("No camera backend available")
-
         atexit.register(self.close)
 
     def _ensure_picamera(self) -> Optional[str]: