@simbimbo/memory-ocmemog 0.1.11 → 0.1.12

package/ocmemog/runtime/storage_paths.py

@@ -0,0 +1,70 @@
+"""Runtime storage path helpers owned by ocmemog."""
+
+from __future__ import annotations
+
+import os
+from pathlib import Path
+
+
+def _env_path(name: str) -> Path | None:
+    raw = os.environ.get(name)
+    if not raw:
+        return None
+    trimmed = raw.strip()
+    if not trimmed:
+        return None
+    return Path(trimmed).expanduser().resolve()
+
+
+def root_dir() -> Path:
+    configured = _env_path("OCMEMOG_STATE_DIR") or _env_path("BRAIN_STATE_DIR")
+    if configured:
+        base = configured
+    else:
+        base = Path(__file__).resolve().parents[2] / ".ocmemog-state"
+    base.mkdir(parents=True, exist_ok=True)
+    return base
+
+
+def data_dir() -> Path:
+    path = root_dir() / "data"
+    path.mkdir(parents=True, exist_ok=True)
+    return path
+
+
+def memory_dir() -> Path:
+    path = root_dir() / "memory"
+    path.mkdir(parents=True, exist_ok=True)
+    return path
+
+
+def reports_dir() -> Path:
+    path = root_dir() / "reports"
+    path.mkdir(parents=True, exist_ok=True)
+    return path
+
+
+def report_log_path() -> Path:
+    override = _env_path("OCMEMOG_REPORT_LOG_PATH") or _env_path("BRAIN_REPORT_LOG_PATH")
+    if override:
+        override.parent.mkdir(parents=True, exist_ok=True)
+        return override
+    reports = reports_dir()
+    native = reports / "ocmemog_memory.log.jsonl"
+    legacy = reports / "brain_memory.log.jsonl"
+    if native.exists() or not legacy.exists():
+        return native
+    return legacy
+
+
+def memory_db_path() -> Path:
+    override = _env_path("OCMEMOG_DB_PATH")
+    if override:
+        override.parent.mkdir(parents=True, exist_ok=True)
+        return override
+    memory = memory_dir()
+    native = memory / "ocmemog_memory.sqlite3"
+    legacy = memory / "brain_memory.sqlite3"
+    if native.exists() or not legacy.exists():
+        return native
+    return legacy

package/ocmemog/sidecar/app.py

@@ -1,10 +1,14 @@
 from __future__ import annotations
 
 import json
+import atexit
+import faulthandler
 import os
 import re
 import threading
 import time
+import sys
+from contextlib import asynccontextmanager
 from pathlib import Path
 from typing import Any, Dict, Iterable, List, Optional
 
@@ -13,17 +17,124 @@ from fastapi.responses import HTMLResponse, StreamingResponse, JSONResponse
 from pydantic import BaseModel, Field
 from datetime import datetime, timedelta
 
-from brain.runtime import state_store
-from brain.runtime.memory import api, conversation_state, distill, health, memory_links, pondering_engine, provenance, reinforcement, retrieval, store
+from ocmemog import __version__
+from ocmemog.runtime import state_store
+from ocmemog.runtime.memory import (
+    api,
+    conversation_state,
+    distill,
+    health,
+    memory_links,
+    pondering_engine,
+    provenance,
+    reinforcement,
+    retrieval,
+    store,
+)
 from ocmemog.sidecar.compat import flatten_results, probe_runtime
 from ocmemog.sidecar.transcript_watcher import watch_forever
 
 DEFAULT_CATEGORIES = tuple(store.MEMORY_TABLES)
 
-app = FastAPI(title="ocmemog sidecar", version="0.1.10")
-
 API_TOKEN = os.environ.get("OCMEMOG_API_TOKEN")
 
+
+_BOOL_TRUE_VALUES = {"1", "true", "yes", "on", "y", "t"}
+_BOOL_FALSE_VALUES = {"0", "false", "no", "off", "n", "f"}
+
+
+def _parse_bool_env_value(raw: Any | None, default: bool = False) -> tuple[bool, bool]:
+    """Return ``(value, valid)``, where ``valid`` indicates parser confidence."""
+    if raw is None:
+        return default, True
+
+    raw_value = str(raw).strip().lower()
+    if raw_value in _BOOL_TRUE_VALUES:
+        return True, True
+    if raw_value in _BOOL_FALSE_VALUES:
+        return False, True
+    if not raw_value:
+        return default, False
+    return default, False
+
+
+def _parse_bool_env(name: str, default: bool = False) -> bool:
+    raw = os.environ.get(name)
+    value, _ = _parse_bool_env_value(raw, default=default)
+    return value
+
+
+def _parse_float_env(name: str, default: float, minimum: float | None = None) -> float:
+    raw = os.environ.get(name)
+    try:
+        value = float(raw if raw is not None else default)
+    except Exception:
+        print(
+            f"[ocmemog][config] invalid float env value: {name}={raw!r}; using default {default}",
+            file=sys.stderr,
+        )
+        return default
+    if minimum is not None and value < minimum:
+        print(
+            f"[ocmemog][config] env value below minimum: {name}={value}; using default {default}",
+            file=sys.stderr,
+        )
+        return default
+    return value
+
+
+def _parse_int_env(name: str, default: int, minimum: int | None = None) -> int:
+    raw = os.environ.get(name)
+    try:
+        value = int(raw if raw is not None else default)
+    except Exception:
+        print(
+            f"[ocmemog][config] invalid int env value: {name}={raw!r}; using default {default}",
+            file=sys.stderr,
+        )
+        return default
+    if minimum is not None and value < minimum:
+        print(
+            f"[ocmemog][config] env value below minimum: {name}={value}; using default {default}",
+            file=sys.stderr,
+        )
+        return default
+    return value
+
+
+_SHUTDOWN_TIMING = _parse_bool_env("OCMEMOG_SHUTDOWN_TIMING", default=True)
+
+
+@asynccontextmanager
+async def _sidecar_lifespan(_: FastAPI):
+    _startup_started = time.perf_counter()
+    try:
+        _start_transcript_watcher()
+        _start_ingest_worker()
+        if _SHUTDOWN_TIMING:
+            print(
+                f"[ocmemog][shutdown] lifespan_startup elapsed={time.perf_counter()-_startup_started:.3f}s",
+                file=sys.stderr,
+            )
+        yield
+    finally:
+        shutdown_started = time.perf_counter()
+        _stop_background_workers()
+        if _SHUTDOWN_TIMING:
+            print(
+                f"[ocmemog][shutdown] lifespan_shutdown elapsed={time.perf_counter()-shutdown_started:.3f}s",
+                file=sys.stderr,
+            )
+
+
+app = FastAPI(title="ocmemog sidecar", version=__version__, lifespan=_sidecar_lifespan)
+
+_INGEST_WORKER_STOP = threading.Event()
+_INGEST_WORKER_THREAD: threading.Thread | None = None
+_INGEST_WORKER_LOCK = threading.Lock()
+_WATCHER_STOP = threading.Event()
+_WATCHER_THREAD: threading.Thread | None = None
+_WATCHER_LOCK = threading.Lock()
 QUEUE_LOCK = threading.Lock()
 QUEUE_PROCESS_LOCK = threading.Lock()
 QUEUE_STATS = {
@@ -33,6 +144,8 @@ QUEUE_STATS = {
     "last_error": None,
     "last_batch": 0,
 }
+_POSTPROCESS_TASK_KEY = "_ocmemog_task"
+_POSTPROCESS_TASK_VALUE = "postprocess_memory"
 
 
 _REFLECTION_RECLASSIFY_PREFERENCE_PATTERNS = (
@@ -100,14 +213,23 @@ async def _auth_middleware(request: Request, call_next):
     return await call_next(request)
 
 
-@app.on_event("startup")
 def _start_transcript_watcher() -> None:
+    global _WATCHER_THREAD
     _load_queue_stats()
-    enabled = os.environ.get("OCMEMOG_TRANSCRIPT_WATCHER", "").lower() in {"1", "true", "yes"}
+    enabled = _parse_bool_env("OCMEMOG_TRANSCRIPT_WATCHER")
     if not enabled:
         return
-    thread = threading.Thread(target=watch_forever, daemon=True)
-    thread.start()
+    with _WATCHER_LOCK:
+        if _WATCHER_THREAD and _WATCHER_THREAD.is_alive():
+            return
+        _WATCHER_STOP.clear()
+        _WATCHER_THREAD = threading.Thread(
+            target=watch_forever,
+            args=(_WATCHER_STOP,),
+            daemon=True,
+            name="ocmemog-transcript-watcher",
+        )
+        _WATCHER_THREAD.start()
 
 
 def _queue_path() -> Path:
@@ -186,6 +308,24 @@ def _enqueue_payload(payload: Dict[str, Any]) -> int:
         return _queue_depth()
 
 
+def _enqueue_postprocess(reference: str, *, skip_embedding_provider: bool = True) -> int:
+    return _enqueue_payload({
+        _POSTPROCESS_TASK_KEY: _POSTPROCESS_TASK_VALUE,
+        "reference": reference,
+        "skip_embedding_provider": bool(skip_embedding_provider),
+    })
+
+
+def _run_postprocess_payload(payload: Dict[str, Any]) -> None:
+    reference = str(payload.get("reference") or "").strip()
+    if not reference:
+        raise ValueError("missing_reference")
+    skip_embedding_provider = bool(payload.get("skip_embedding_provider", True))
+    result = api.postprocess_stored_memory(reference, skip_embedding_provider=skip_embedding_provider)
+    if not result.get("ok"):
+        raise RuntimeError(str(result.get("error") or "postprocess_failed"))
+
+
 
 def _process_queue(limit: Optional[int] = None) -> Dict[str, Any]:
     processed = 0
@@ -208,8 +348,11 @@ def _process_queue(limit: Optional[int] = None) -> Dict[str, Any]:
             acknowledged = 0
             for line_no, payload in batch:
                 try:
-                    req = IngestRequest(**payload)
-                    _ingest_request(req)
+                    if isinstance(payload, dict) and payload.get(_POSTPROCESS_TASK_KEY) == _POSTPROCESS_TASK_VALUE:
+                        _run_postprocess_payload(payload)
+                    else:
+                        req = IngestRequest(**payload)
+                        _ingest_request(req)
                     processed += 1
                     batch_processed += 1
                     acknowledged = line_no
@@ -240,15 +383,16 @@ def _process_queue(limit: Optional[int] = None) -> Dict[str, Any]:
 
 
 def _ingest_worker() -> None:
-    enabled = os.environ.get("OCMEMOG_INGEST_ASYNC_WORKER", "true").lower() in {"1", "true", "yes"}
+    enabled = _parse_bool_env("OCMEMOG_INGEST_ASYNC_WORKER", default=True)
     if not enabled:
         return
-    poll_seconds = float(os.environ.get("OCMEMOG_INGEST_ASYNC_POLL_SECONDS", "5"))
-    batch_max = int(os.environ.get("OCMEMOG_INGEST_ASYNC_BATCH_MAX", "25"))
+    poll_seconds = _parse_float_env("OCMEMOG_INGEST_ASYNC_POLL_SECONDS", default=5.0, minimum=0.0)
+    batch_max = _parse_int_env("OCMEMOG_INGEST_ASYNC_BATCH_MAX", default=25, minimum=1)
 
-    while True:
+    while not _INGEST_WORKER_STOP.is_set():
         _process_queue(batch_max)
-        time.sleep(poll_seconds)
+        if _INGEST_WORKER_STOP.wait(poll_seconds):
+            break
 
 
 
@@ -256,10 +400,122 @@ def _drain_queue(limit: Optional[int] = None) -> Dict[str, Any]:
     return _process_queue(limit)
 
 
-@app.on_event("startup")
 def _start_ingest_worker() -> None:
-    thread = threading.Thread(target=_ingest_worker, daemon=True)
-    thread.start()
+    global _INGEST_WORKER_THREAD
+    with _INGEST_WORKER_LOCK:
+        if _INGEST_WORKER_THREAD and _INGEST_WORKER_THREAD.is_alive():
+            return
+        _INGEST_WORKER_STOP.clear()
+        _INGEST_WORKER_THREAD = threading.Thread(
+            target=_ingest_worker,
+            daemon=True,
+            name="ocmemog-ingest-worker",
+        )
+        _INGEST_WORKER_THREAD.start()
+
+
+def _stop_background_workers() -> None:
+    global _INGEST_WORKER_THREAD, _WATCHER_THREAD
+    shutdown_start = time.perf_counter()
+    if _SHUTDOWN_TIMING:
+        print(f"[ocmemog][shutdown] shutdown_begin", file=sys.stderr)
+    timeout = _parse_float_env(
+        "OCMEMOG_WORKER_SHUTDOWN_TIMEOUT_SECONDS",
+        default=0.35,
+        minimum=0.0,
+    )
+    if _SHUTDOWN_TIMING:
+        print(f"[ocmemog][shutdown] shutdown_config timeout={timeout:.3f}s", file=sys.stderr)
+
+    queue_drain_requested = _parse_bool_env("OCMEMOG_SHUTDOWN_DRAIN_QUEUE")
+    if queue_drain_requested and _queue_depth() > 0:
+        _queue_drain_start = time.perf_counter()
+        drain_stats = _drain_queue()
+        if _SHUTDOWN_TIMING:
+            print(
+                f"[ocmemog][shutdown] queue_drain elapsed={time.perf_counter()-_queue_drain_start:.3f}s processed={drain_stats.get('processed', 0)} errors={drain_stats.get('errors', 0)}",
+                file=sys.stderr,
+            )
+    _INGEST_WORKER_STOP.set()
+    _WATCHER_STOP.set()
+    if _SHUTDOWN_TIMING:
+        print(
+            f"[ocmemog][shutdown] stop_signals_set elapsed={time.perf_counter()-shutdown_start:.3f}s",
+            file=sys.stderr,
+        )
+
+    if _parse_bool_env("OCMEMOG_SHUTDOWN_DUMP_THREADS"):
+        _dump_thread_dump("post-stop requested")
+
+    with _INGEST_WORKER_LOCK:
+        ingest_worker = _INGEST_WORKER_THREAD
+    if ingest_worker is not None and ingest_worker.is_alive():
+        ingest_join_start = time.perf_counter()
+        ingest_worker.join(timeout=timeout)
+        if _SHUTDOWN_TIMING:
+            print(
+                f"[ocmemog][shutdown] ingest_worker_join elapsed={time.perf_counter()-ingest_join_start:.3f}s alive={ingest_worker.is_alive()}",
+                file=sys.stderr,
+            )
+        if _parse_bool_env("OCMEMOG_SHUTDOWN_DUMP_THREADS"):
+            _dump_join_result("ingest-worker", ingest_worker, timeout)
+        if not ingest_worker.is_alive():
+            with _INGEST_WORKER_LOCK:
+                if _INGEST_WORKER_THREAD is ingest_worker:
+                    _INGEST_WORKER_THREAD = None
+
+    with _WATCHER_LOCK:
+        watcher_thread = _WATCHER_THREAD
+    if watcher_thread is not None and watcher_thread.is_alive():
+        watcher_join_start = time.perf_counter()
+        watcher_thread.join(timeout=timeout)
+        if _SHUTDOWN_TIMING:
+            print(
+                f"[ocmemog][shutdown] transcript_watcher_join elapsed={time.perf_counter()-watcher_join_start:.3f}s alive={watcher_thread.is_alive()}",
+                file=sys.stderr,
+            )
+    if _parse_bool_env("OCMEMOG_SHUTDOWN_DUMP_THREADS"):
+        _dump_join_result("transcript-watcher", watcher_thread, timeout)
+        if not watcher_thread.is_alive():
+            with _WATCHER_LOCK:
+                if _WATCHER_THREAD is watcher_thread:
+                    _WATCHER_THREAD = None
+    if _SHUTDOWN_TIMING:
+        print(
+            f"[ocmemog][shutdown] shutdown_complete elapsed={time.perf_counter()-shutdown_start:.3f}s",
+            file=sys.stderr,
+        )
+
+
+def _dump_thread_dump(context: str) -> None:
+    print(f"[ocmemog][thread-dump:{context}]", file=sys.stderr)
+    _dump_thread_states()
+    faulthandler.dump_traceback(file=sys.stderr, all_threads=True)
+
+
+def _dump_join_result(thread_label: str, thread: threading.Thread, timeout: float) -> None:
+    if thread.is_alive():
+        print(
+            f"[ocmemog][shutdown] {thread_label} still alive after join timeout={timeout:.3f}s",
+            file=sys.stderr,
+        )
+        _dump_thread_dump(thread_label)
+    else:
+        print(
+            f"[ocmemog][shutdown] {thread_label} joined cleanly",
+            file=sys.stderr,
+        )
+
+
+def _dump_thread_states() -> None:
+    for thread in threading.enumerate():
+        print(
+            f"[ocmemog][thread-state] name={thread.name} alive={thread.is_alive()} daemon={thread.daemon} ident={thread.ident}",
+            file=sys.stderr,
+        )
+
+
+atexit.register(_stop_background_workers)
 
 
 class SearchRequest(BaseModel):
@@ -481,6 +737,8 @@ def _runtime_payload() -> Dict[str, Any]:
     return {
         "mode": status.mode,
         "missingDeps": status.missing_deps,
+        "identity": status.identity,
+        "capabilities": status.capabilities,
         "todo": status.todo,
         "warnings": status.warnings,
     }
@@ -679,6 +937,7 @@ def _read_transcript_snippet(path: Path, line_start: Optional[int], line_end: Op
 def healthz() -> dict[str, Any]:
     payload = _runtime_payload()
     payload["ok"] = True
+    payload["ready"] = payload.get("mode") == "ready"
     return payload
 
 
@@ -686,14 +945,35 @@ def healthz() -> dict[str, Any]:
 def memory_search(request: SearchRequest) -> dict[str, Any]:
     categories = _normalize_categories(request.categories)
     runtime = _runtime_payload()
+    started = time.perf_counter()
+    query = request.query or ""
+    skip_vector_provider = _parse_bool_env("OCMEMOG_SEARCH_SKIP_EMBEDDING_PROVIDER", default=True)
     try:
-        results = retrieval.retrieve_for_queries([request.query], limit=request.limit, categories=categories)
+        results = retrieval.retrieve_for_queries(
+            [query],
+            limit=request.limit,
+            categories=categories,
+            skip_vector_provider=skip_vector_provider,
+        )
         flattened = flatten_results(results)
+        if len(flattened) > request.limit:
+            flattened = flattened[: request.limit]
         used_fallback = False
     except Exception as exc:
         flattened = _fallback_search(request.query, request.limit, categories)
         used_fallback = True
         runtime["warnings"] = [*runtime["warnings"], f"search fallback enabled: {exc}"]
+    elapsed_ms = round((time.perf_counter() - started) * 1000, 3)
+    if elapsed_ms >= 10:
+        print(
+            f"[ocmemog][route] memory_search elapsed_ms={elapsed_ms:.3f} limit={request.limit} categories={','.join(categories)} fallback={used_fallback}",
+            file=sys.stderr,
+        )
+        if elapsed_ms >= 200:
+            print(
+                f"[ocmemog][route] memory_search slow_path query={query[:128]!r} result_count={len(flattened)}",
+                file=sys.stderr,
+            )
 
     return {
         "ok": True,
@@ -1197,8 +1477,10 @@ def _ingest_request(request: IngestRequest) -> dict[str, Any]:
             source=request.source,
             metadata=metadata,
             timestamp=request.timestamp,
+            post_process=False,
         )
         reference = f"{memory_type}:{memory_id}"
+        _enqueue_postprocess(reference, skip_embedding_provider=_parse_bool_env("OCMEMOG_POSTPROCESS_SKIP_EMBEDDING_PROVIDER", default=True))
         if request.conversation_id:
             memory_links.add_memory_link(reference, "conversation", f"conversation:{request.conversation_id}")
         if request.session_id:
@@ -1295,7 +1577,11 @@ def _ingest_request(request: IngestRequest) -> dict[str, Any]:
 
 @app.post("/memory/ingest")
 def memory_ingest(request: IngestRequest) -> dict[str, Any]:
-    return _ingest_request(request)
+    started = time.perf_counter()
+    payload = _ingest_request(request)
+    elapsed_ms = round((time.perf_counter() - started) * 1000, 3)
+    print(f"[ocmemog][route] memory_ingest elapsed_ms={elapsed_ms:.3f} kind={request.kind} reference={payload.get('reference', '')}", file=sys.stderr)
+    return payload
 
 
 @app.post("/memory/ingest_async")
@@ -1369,7 +1655,7 @@ def metrics() -> dict[str, Any]:
 
 
 def _event_stream():
-    path = state_store.reports_dir() / "brain_memory.log.jsonl"
+    path = state_store.report_log_path()
     path.parent.mkdir(parents=True, exist_ok=True)
     if not path.exists():
         path.write_text("")
@@ -1389,12 +1675,13 @@ def events() -> StreamingResponse:
 
 
 def _tail_events(limit: int = 50) -> str:
-    path = state_store.reports_dir() / "brain_memory.log.jsonl"
+    path = state_store.report_log_path()
     if not path.exists():
         return ""
     try:
         lines = path.read_text(encoding="utf-8", errors="ignore").splitlines()
-    except Exception:
+    except Exception as exc:
+        print(f"[ocmemog][events] tail_read_failed path={path} error={exc!r}", file=sys.stderr)
         return ""
     return "\n".join(lines[-limit:])
 

package/ocmemog/sidecar/compat.py

@@ -6,6 +6,8 @@ import os
 from dataclasses import dataclass
 from typing import Any
 
+from ocmemog.runtime import identity
+
 
 @dataclass(frozen=True)
 class RuntimeStatus:
@@ -13,45 +15,80 @@ class RuntimeStatus:
     missing_deps: list[str]
     todo: list[str]
     warnings: list[str]
+    identity: dict[str, Any]
+    capabilities: list[dict[str, Any]]
 
 
 TODO_ITEMS = [
-    "Add a role registry (brain.runtime.roles) if you want role-prioritized context building.",
     "Add non-OpenAI embedding providers if required.",
 ]
 
+_EMBEDDING_PROVIDER_BACKEND_HINTS = {
+    "openai",
+    "openai_compatible",
+    "openai-compatible",
+    "local-openai",
+    "local_openai",
+    "llamacpp",
+    "llama.cpp",
+    "ollama",
+    "local-ollama",
+}
+
 
 def probe_runtime() -> RuntimeStatus:
+    runtime_identity = identity.get_runtime_identity()
+    capabilities = runtime_identity.get("capabilities", [])
+
     missing_deps: list[str] = []
     warnings: list[str] = []
 
     for module_name in (
-        "brain.runtime.memory.store",
-        "brain.runtime.memory.retrieval",
-        "brain.runtime.memory.vector_index",
-        "brain.runtime.memory.memory_links",
+        "ocmemog.runtime.memory.store",
+        "ocmemog.runtime.memory.retrieval",
+        "ocmemog.runtime.memory.vector_index",
+        "ocmemog.runtime.memory.memory_links",
     ):
         try:
             importlib.import_module(module_name)
         except Exception as exc:
             missing_deps.append(f"{module_name}: {exc}")
 
-    provider = os.environ.get("BRAIN_EMBED_MODEL_PROVIDER", "").strip().lower()
-    if importlib.util.find_spec("sentence_transformers") is None and provider not in {"ollama", "openai", "openai_compatible", "openai-compatible", "local-ollama"}:
+    provider = (
+        os.environ.get("OCMEMOG_EMBED_MODEL_PROVIDER")
+        or os.environ.get("OCMEMOG_EMBED_PROVIDER", "")
+        or os.environ.get("BRAIN_EMBED_MODEL_PROVIDER", "")
+    ).strip().lower()
+    if importlib.util.find_spec("sentence_transformers") is None and provider not in _EMBEDDING_PROVIDER_BACKEND_HINTS:
         warnings.append("Optional dependency missing: sentence-transformers; using local hash embeddings.")
 
     try:
-        from brain.runtime import inference, providers
+        from ocmemog.runtime import inference, providers
 
         if getattr(inference, "__shim__", False):
-            missing_deps.append("brain.runtime.inference (shim only)")
+            missing_deps.append("ocmemog.runtime.inference (shim only)")
         if getattr(getattr(providers, "provider_execute", None), "__shim__", False):
-            missing_deps.append("brain.runtime.providers.provider_execute (shim only)")
+            missing_deps.append("ocmemog.runtime.providers.provider_execute (shim only)")
     except Exception as exc:
-        missing_deps.append(f"brain.runtime compatibility probe failed: {exc}")
+        missing_deps.append(f"ocmemog.runtime compatibility probe failed: {exc}")
+
+    shim_count = sum(1 for item in capabilities if item.get("owner") == "brain-runtime-shim")
+    if shim_count:
+        warnings.append(f"Runtime still relies on {shim_count} legacy compatibility surface(s).")
+        mode = "degraded"
+    else:
+        mode = "ready"
 
-    mode = "degraded" if missing_deps else "ready"
-    return RuntimeStatus(mode=mode, missing_deps=missing_deps, todo=list(TODO_ITEMS), warnings=warnings)
+    if missing_deps:
+        mode = "degraded"
+    return RuntimeStatus(
+        mode=mode,
+        missing_deps=missing_deps,
+        todo=list(TODO_ITEMS),
+        warnings=warnings,
+        identity=runtime_identity,
+        capabilities=capabilities,
+    )
 
 
 def flatten_results(results: dict[str, list[dict[str, Any]]]) -> list[dict[str, Any]]: