loki-mode 6.83.0 → 7.0.1

package/autonomy/run.sh

@@ -649,7 +649,23 @@ export LOKI_SESSION_MODEL LOKI_LEGACY_TIER_SWITCHING
 # Both off (default) => zero behavior change from v6.82.0.
 LOKI_MANAGED_AGENTS="${LOKI_MANAGED_AGENTS:-false}"
 LOKI_MANAGED_MEMORY="${LOKI_MANAGED_MEMORY:-false}"
-export LOKI_MANAGED_AGENTS LOKI_MANAGED_MEMORY
+# v7.0.0 Phase 2: remote->local hydrate on session boot (grandchild of MEMORY).
+# Pulls semantic patterns + procedural skills once at init_loki_dir time.
+LOKI_MANAGED_MEMORY_HYDRATE="${LOKI_MANAGED_MEMORY_HYDRATE:-false}"
+# v7.0.0 Phase 3+4 foundation: umbrella flag for the multiagent-session path.
+# Gates every providers/managed.py entry point (run_council,
+# run_completion_council). Off by default because the Managed Agents
+# multiagent surface is a research preview.
+LOKI_EXPERIMENTAL_MANAGED_AGENTS="${LOKI_EXPERIMENTAL_MANAGED_AGENTS:-false}"
+# v7.0.0 Phase 3 (T5): managed code-review council. Routes run_code_review
+# through providers/managed.py::run_council when true. Requires parent +
+# umbrella.
+LOKI_EXPERIMENTAL_MANAGED_REVIEW="${LOKI_EXPERIMENTAL_MANAGED_REVIEW:-false}"
+# v7.0.0 Phase 4 (T6): managed completion council. Routes council_should_stop
+# through providers/managed.py::run_completion_council when true. Requires
+# parent + umbrella.
+LOKI_EXPERIMENTAL_MANAGED_COUNCIL="${LOKI_EXPERIMENTAL_MANAGED_COUNCIL:-false}"
+export LOKI_MANAGED_AGENTS LOKI_MANAGED_MEMORY LOKI_MANAGED_MEMORY_HYDRATE LOKI_EXPERIMENTAL_MANAGED_AGENTS LOKI_EXPERIMENTAL_MANAGED_REVIEW LOKI_EXPERIMENTAL_MANAGED_COUNCIL
 
 # Fail-fast: child on with parent off is a misconfiguration.
 if [ "$LOKI_MANAGED_MEMORY" = "true" ] && [ "$LOKI_MANAGED_AGENTS" != "true" ]; then
@@ -657,6 +673,47 @@ if [ "$LOKI_MANAGED_MEMORY" = "true" ] && [ "$LOKI_MANAGED_AGENTS" != "true" ];
     exit 2
 fi
 
+# Phase 2 fail-fast: HYDRATE is a grandchild of MEMORY.
+if [ "$LOKI_MANAGED_MEMORY_HYDRATE" = "true" ] && [ "$LOKI_MANAGED_MEMORY" != "true" ]; then
+    echo "ERROR: LOKI_MANAGED_MEMORY_HYDRATE=true requires LOKI_MANAGED_MEMORY=true" >&2
+    exit 2
+fi
+
+# Same fail-fast for the experimental multiagent session path.
+if [ "$LOKI_EXPERIMENTAL_MANAGED_AGENTS" = "true" ] && [ "$LOKI_MANAGED_AGENTS" != "true" ]; then
+    echo "ERROR: LOKI_EXPERIMENTAL_MANAGED_AGENTS=true requires LOKI_MANAGED_AGENTS=true" >&2
+    exit 2
+fi
+
+# Phase 3 fail-fast: REVIEW requires parent AND umbrella.
+if [ "$LOKI_EXPERIMENTAL_MANAGED_REVIEW" = "true" ]; then
+    if [ "$LOKI_MANAGED_AGENTS" != "true" ]; then
+        echo "ERROR: LOKI_EXPERIMENTAL_MANAGED_REVIEW=true requires LOKI_MANAGED_AGENTS=true" >&2
+        exit 2
+    fi
+    if [ "$LOKI_EXPERIMENTAL_MANAGED_AGENTS" != "true" ]; then
+        echo "ERROR: LOKI_EXPERIMENTAL_MANAGED_REVIEW=true requires LOKI_EXPERIMENTAL_MANAGED_AGENTS=true" >&2
+        exit 2
+    fi
+fi
+
+# Phase 4 fail-fast: COUNCIL requires parent AND umbrella.
+if [ "$LOKI_EXPERIMENTAL_MANAGED_COUNCIL" = "true" ]; then
+    if [ "$LOKI_MANAGED_AGENTS" != "true" ]; then
+        echo "ERROR: LOKI_EXPERIMENTAL_MANAGED_COUNCIL=true requires LOKI_MANAGED_AGENTS=true" >&2
+        exit 2
+    fi
+    if [ "$LOKI_EXPERIMENTAL_MANAGED_AGENTS" != "true" ]; then
+        echo "ERROR: LOKI_EXPERIMENTAL_MANAGED_COUNCIL=true requires LOKI_EXPERIMENTAL_MANAGED_AGENTS=true" >&2
+        exit 2
+    fi
+fi
+
+# Research-preview warning banner.
+if [ "$LOKI_EXPERIMENTAL_MANAGED_AGENTS" = "true" ]; then
+    echo "WARN: LOKI_EXPERIMENTAL_MANAGED_AGENTS uses Managed Agents research preview; expect beta churn." >&2
+fi
+
 # Parallel Workflows (Git Worktrees)
 PARALLEL_MODE=${LOKI_PARALLEL_MODE:-false}
 MAX_WORKTREES=${LOKI_MAX_WORKTREES:-5}
@@ -3021,6 +3078,30 @@ BUDGET_EOF
         log_info "Budget limit set: \$$BUDGET_LIMIT"
     fi
 
+    # v7.0.0 Phase 2: remote->local hydrate. Runs ONCE at session boot (not
+    # per iteration) to pull semantic patterns + procedural skills from the
+    # managed store into .loki/memory/semantic/patterns.json and
+    # .loki/memory/skills/*.json. Gated on parent + MEMORY + HYDRATE; all
+    # three must be "true". 10s hard timeout so a slow remote never blocks
+    # startup. Idempotent (sentinel: .loki/managed/hydrate.lock).
+    if [ "$LOKI_MANAGED_AGENTS" = "true" ] \
+        && [ "$LOKI_MANAGED_MEMORY" = "true" ] \
+        && [ "$LOKI_MANAGED_MEMORY_HYDRATE" = "true" ]; then
+        local _hydrate_target="${TARGET_DIR:-$(pwd)}"
+        local _hydrate_out
+        _hydrate_out=$(
+            cd "$PROJECT_DIR" 2>/dev/null && \
+            LOKI_TARGET_DIR="$_hydrate_target" \
+            timeout 10 python3 -m memory.managed_memory.retrieve --hydrate 2>/dev/null || true
+        )
+        if [ -n "$_hydrate_out" ]; then
+            log_info "Managed hydrate: $_hydrate_out"
+        else
+            LOKI_TARGET_DIR="$_hydrate_target" \
+            python3 -c "from memory.managed_memory.events import emit_managed_event; emit_managed_event('managed_memory_hydrate_timeout', {'phase': 'init'})" 2>/dev/null || true
+        fi
+    fi
+
     log_info "Loki directory initialized: .loki/"
 }
 
@@ -5869,6 +5950,236 @@ run_magic_debate_gate() {
 # architecture-strategist always included, 2 more selected by keyword scoring
 # ============================================================================
 
+# Write managed-council verdicts into the legacy per-reviewer .txt layout so
+# the dashboard quality panel (which only reads .loki/quality/reviews/$id/*.txt)
+# stays functional. Called from the managed branch of run_code_review().
+# Single-writer invariant: either this helper writes the files, or the legacy
+# CLI fan-out does -- never both for the same review_id.
+council_verdicts_to_txt_files() {
+    local review_id="$1"
+    local verdicts_json="$2"
+    local loki_dir="${TARGET_DIR:-.}/.loki"
+    local review_dir="$loki_dir/quality/reviews/$review_id"
+    mkdir -p "$review_dir"
+
+    # Use python3 to fan the JSON verdict list out to individual .txt files
+    # in the same VERDICT/FINDINGS format the legacy parser expects.
+    local out_dir_env="$review_dir"
+    export LOKI_COUNCIL_OUT_DIR="$out_dir_env"
+    export LOKI_COUNCIL_VERDICTS_JSON="$verdicts_json"
+    python3 << 'COUNCIL_WRITE'
+import json
+import os
+import re
+
+out_dir = os.environ["LOKI_COUNCIL_OUT_DIR"]
+raw = os.environ.get("LOKI_COUNCIL_VERDICTS_JSON", "").strip()
+if not raw:
+    raise SystemExit(0)
+
+try:
+    payload = json.loads(raw)
+except json.JSONDecodeError:
+    raise SystemExit("council_verdicts_to_txt_files: invalid JSON")
+
+if isinstance(payload, dict):
+    verdicts = payload.get("verdicts") or []
+else:
+    verdicts = payload or []
+
+SAFE_NAME = re.compile(r"[^A-Za-z0-9._-]+")
+DOT_RUN = re.compile(r"\.{2,}")
+
+def _pool_name(v):
+    name = v.get("pool_name") or v.get("name") or v.get("agent_id") or "reviewer"
+    cleaned = SAFE_NAME.sub("-", str(name))
+    # Defend against path-traversal via ".." in pool names.
+    cleaned = DOT_RUN.sub("-", cleaned).strip("-.")
+    return cleaned[:80] or "reviewer"
+
+def _verdict_token(v):
+    token = str(v.get("verdict") or "").strip().upper()
+    if token in ("APPROVE", "PASS"):
+        return "PASS"
+    if token in ("REQUEST_CHANGES", "REJECT", "FAIL"):
+        return "FAIL"
+    return "PASS"  # ABSTAIN => PASS per legacy behavior
+
+def _findings(v):
+    rationale = (v.get("rationale") or "").strip()
+    sev = v.get("severity")
+    if not rationale:
+        return "- None"
+    lines = []
+    for line in rationale.splitlines():
+        line = line.strip()
+        if not line:
+            continue
+        if line.lstrip().startswith("- ["):
+            lines.append(line)
+        else:
+            tag = f"[{sev.capitalize()}]" if sev else "[Medium]"
+            lines.append(f"- {tag} {line}")
+    return "\n".join(lines) if lines else "- None"
+
+for v in verdicts:
+    if not isinstance(v, dict):
+        continue
+    name = _pool_name(v)
+    path = os.path.join(out_dir, f"{name}.txt")
+    body = f"VERDICT: {_verdict_token(v)}\nFINDINGS:\n{_findings(v)}\n"
+    with open(path, "w", encoding="utf-8") as f:
+        f.write(body)
+COUNCIL_WRITE
+    local rc=$?
+    unset LOKI_COUNCIL_OUT_DIR LOKI_COUNCIL_VERDICTS_JSON
+    return $rc
+}
+
+# Execute the managed-agents multiagent council path. Writes legacy .txt
+# files via council_verdicts_to_txt_files() on success so the existing
+# aggregation loop below can read them exactly like the CLI path.
+# Returns 0 on success, 1 on ManagedUnavailable (caller should fall back).
+_run_managed_review_council() {
+    local review_id="$1"
+    local diff_file="$2"
+    local files_file="$3"
+    local review_dir="${TARGET_DIR:-.}/.loki/quality/reviews/$review_id"
+    mkdir -p "$review_dir"
+
+    export LOKI_MANAGED_REVIEW_ID="$review_id"
+    export LOKI_MANAGED_REVIEW_DIFF_FILE="$diff_file"
+    export LOKI_MANAGED_REVIEW_FILES_FILE="$files_file"
+    export LOKI_MANAGED_REVIEW_OUT_JSON="$review_dir/managed_result.json"
+    local project_dir_env="${PROJECT_DIR:-.}"
+    export LOKI_MANAGED_REVIEW_PROJECT_DIR="$project_dir_env"
+
+    local result_json
+    result_json=$(python3 << 'MANAGED_REVIEW' 2>&1
+import json
+import os
+import sys
+
+project_dir = os.environ.get("LOKI_MANAGED_REVIEW_PROJECT_DIR", ".")
+if project_dir and project_dir not in sys.path:
+    sys.path.insert(0, project_dir)
+
+try:
+    from providers import managed as managed_mod
+except Exception as e:
+    print(json.dumps({"status": "unavailable", "reason": f"import_failed: {e}"}))
+    sys.exit(0)
+
+# Test hook: allow tests to inject a fake run_council by setting
+# LOKI_MANAGED_REVIEW_FAKE_MODULE to a dotted path exposing run_council.
+fake_mod = os.environ.get("LOKI_MANAGED_REVIEW_FAKE_MODULE", "").strip()
+if fake_mod:
+    try:
+        import importlib
+        fm = importlib.import_module(fake_mod)
+        if hasattr(fm, "install"):
+            fm.install(managed_mod)
+    except Exception as e:
+        print(json.dumps({"status": "unavailable", "reason": f"fake_install_failed: {e}"}))
+        sys.exit(0)
+
+if not managed_mod.is_enabled():
+    print(json.dumps({"status": "unavailable", "reason": "is_enabled_false"}))
+    sys.exit(0)
+
+diff_path = os.environ.get("LOKI_MANAGED_REVIEW_DIFF_FILE", "")
+files_path = os.environ.get("LOKI_MANAGED_REVIEW_FILES_FILE", "")
+diff_text = ""
+files_text = ""
+if diff_path and os.path.exists(diff_path):
+    with open(diff_path, "r", encoding="utf-8", errors="replace") as f:
+        diff_text = f.read()
+if files_path and os.path.exists(files_path):
+    with open(files_path, "r", encoding="utf-8", errors="replace") as f:
+        files_text = f.read()
+
+target_paths = [p.strip() for p in files_text.splitlines() if p.strip()]
+
+pool = ["security-sentinel", "test-coverage-auditor", "performance-oracle"]
+context = {
+    "diff": diff_text,
+    "files": target_paths,
+    "target_paths": target_paths,
+}
+
+try:
+    result = managed_mod.run_council(pool, context, timeout_s=300)
+except managed_mod.ManagedUnavailable as e:
+    print(json.dumps({"status": "unavailable", "reason": str(e)}))
+    sys.exit(0)
+except Exception as e:
+    # Anything else is unexpected; bubble up as unavailable so the caller
+    # falls back rather than aborting the iteration.
+    print(json.dumps({"status": "unavailable", "reason": f"unexpected: {e}"}))
+    sys.exit(0)
+
+verdicts_out = []
+for v in (result.verdicts or []):
+    verdicts_out.append({
+        "agent_id": getattr(v, "agent_id", ""),
+        "pool_name": getattr(v, "pool_name", ""),
+        "verdict": getattr(v, "verdict", ""),
+        "rationale": getattr(v, "rationale", ""),
+        "severity": getattr(v, "severity", None),
+    })
+out = {
+    "status": "ok",
+    "verdicts": verdicts_out,
+    "session_id": getattr(result, "session_id", None),
+    "elapsed_ms": getattr(result, "elapsed_ms", 0),
+    "partial": getattr(result, "partial", False),
+}
+print(json.dumps(out))
+MANAGED_REVIEW
+)
+    local py_rc=$?
+    unset LOKI_MANAGED_REVIEW_ID LOKI_MANAGED_REVIEW_DIFF_FILE LOKI_MANAGED_REVIEW_FILES_FILE
+    unset LOKI_MANAGED_REVIEW_OUT_JSON LOKI_MANAGED_REVIEW_PROJECT_DIR
+
+    if [ $py_rc -ne 0 ] || [ -z "$result_json" ]; then
+        emit_event_json "managed_agents_fallback" \
+            "op=run_code_review" \
+            "reason=subprocess_failed" \
+            "review_id=$review_id"
+        return 1
+    fi
+
+    local status
+    status=$(printf '%s' "$result_json" | python3 -c "import json,sys; d=json.loads(sys.stdin.read() or '{}'); print(d.get('status',''))" 2>/dev/null || echo "")
+
+    if [ "$status" != "ok" ]; then
+        local reason
+        reason=$(printf '%s' "$result_json" | python3 -c "import json,sys; d=json.loads(sys.stdin.read() or '{}'); print(d.get('reason',''))" 2>/dev/null || echo "")
+        emit_event_json "managed_agents_fallback" \
+            "op=run_code_review" \
+            "reason=managed_unavailable" \
+            "detail=${reason//\"/}" \
+            "review_id=$review_id"
+        return 1
+    fi
+
+    # Persist the raw managed result for observability and write legacy .txt
+    # files for the dashboard panel / aggregation loop.
+    printf '%s\n' "$result_json" > "$review_dir/managed_result.json"
+    if ! council_verdicts_to_txt_files "$review_id" "$result_json"; then
+        emit_event_json "managed_agents_fallback" \
+            "op=run_code_review" \
+            "reason=verdict_write_failed" \
+            "review_id=$review_id"
+        return 1
+    fi
+
+    emit_event_json "managed_review_council_ok" \
+        "review_id=$review_id" \
+        "iteration=${ITERATION_COUNT:-0}"
+    return 0
+}
+
 run_code_review() {
     local loki_dir="${TARGET_DIR:-.}/.loki"
     local review_dir="$loki_dir/quality/reviews"
@@ -5888,6 +6199,51 @@ run_code_review() {
     changed_files=$(git -C "${TARGET_DIR:-.}" diff --name-only HEAD~1 2>/dev/null || git -C "${TARGET_DIR:-.}" diff --name-only --cached 2>/dev/null || echo "")
 
     log_header "CODE REVIEW: $review_id"
+
+    # Phase 3 (v7.0.0): managed code-review council. When the flag is on,
+    # route to providers/managed.py::run_council. On ManagedUnavailable,
+    # emit a fallback event and drop through to the legacy CLI fan-out
+    # below -- the existing v6.83.1 behavior is preserved.
+    if [ "${LOKI_EXPERIMENTAL_MANAGED_REVIEW:-false}" = "true" ]; then
+        local managed_diff_file="$review_dir/$review_id/diff.txt"
+        local managed_files_file="$review_dir/$review_id/files.txt"
+        printf '%s\n' "$diff_content" > "$managed_diff_file"
+        printf '%s\n' "$changed_files" > "$managed_files_file"
+        log_info "Managed review council: attempting multiagent session (Phase 3)"
+        if _run_managed_review_council "$review_id" "$managed_diff_file" "$managed_files_file"; then
+            log_info "Managed review council: verdicts written, skipping CLI fan-out"
+            # Managed path wrote legacy .txt files; skip CLI fan-out but let
+            # the aggregation step run by setting a minimal selection.json
+            # the downstream loop can read.
+            emit_event_json "code_review_complete" \
+                "review_id=$review_id" \
+                "source=managed" \
+                "iteration=${ITERATION_COUNT:-0}"
+            # Build a selection.json so any downstream consumer can find the
+            # reviewer list. Mirrors the shape the CLI path writes below.
+            python3 - "$review_dir/$review_id/selection.json" << 'MANAGED_SELECTION'
+import json
+import sys
+
+path = sys.argv[1]
+selection = {
+    "reviewers": [
+        {"name": "security-sentinel", "focus": "managed", "checks": "managed council"},
+        {"name": "test-coverage-auditor", "focus": "managed", "checks": "managed council"},
+        {"name": "performance-oracle", "focus": "managed", "checks": "managed council"},
+    ],
+    "scores": {},
+    "pool_size": 3,
+    "source": "managed",
+}
+with open(path, "w", encoding="utf-8") as f:
+    json.dump(selection, f)
+MANAGED_SELECTION
+            return 0
+        fi
+        log_warn "Managed review council unavailable; falling back to CLI fan-out"
+    fi
+
     log_info "Selecting 3 specialist reviewers from pool..."
 
     # Write diff/files to temp files for python to read (avoid env var size limits)

package/dashboard/__init__.py

@@ -7,7 +7,7 @@ Modules:
     control: Session control API (start/stop/pause/resume)
 """
 
-__version__ = "6.83.0"
+__version__ = "7.0.1"
 
 # Expose the control app for easy import
 try:

package/dashboard/server.py

@@ -5559,6 +5559,241 @@ def start_migration_phase(migration_id: str, request_body: dict):
         raise HTTPException(status_code=500, detail="Failed to start phase")
 
 
+# ---------------------------------------------------------------------------
+# Managed Agents Memory bridge (Phase 5, read-only)
+#
+# These endpoints expose the contents of .loki/managed/events.ndjson plus a
+# thin proxy to beta.memory_stores.memory_versions.list(). All endpoints are
+# safe to call when the managed-agents flags are off: they return empty
+# lists / {enabled: false} rather than 500s. No endpoint writes to the
+# managed store -- the only writer in the codebase remains
+# memory/managed_memory/shadow_write.py.
+# ---------------------------------------------------------------------------
+
+_MANAGED_EVENTS_TAIL_MAX = 10000  # Safety ceiling on tail reads.
+
+
+def _managed_events_path() -> _Path:
+    """Return the absolute path to .loki/managed/events.ndjson."""
+    return _get_loki_dir() / "managed" / "events.ndjson"
+
+
+def _managed_flags_snapshot() -> dict[str, Any]:
+    """Read managed-agents flags without importing the SDK path."""
+    parent = os.environ.get("LOKI_MANAGED_AGENTS", "").strip().lower() == "true"
+    child = os.environ.get("LOKI_MANAGED_MEMORY", "").strip().lower() == "true"
+    try:
+        from memory.managed_memory._beta import BETA_HEADER as _beta_header
+    except Exception:
+        _beta_header = "managed-agents-2026-04-01"
+    return {
+        "enabled": parent and child,
+        "parent_flag": parent,
+        "child_flags": {"LOKI_MANAGED_MEMORY": child},
+        "beta_header": _beta_header,
+    }
+
+
+def _tail_ndjson(
+    path: _Path,
+    limit: int,
+    since_iso: Optional[str],
+    event_type: Optional[str],
+) -> list[dict[str, Any]]:
+    """
+    Return the last *limit* records from an ndjson file, optionally filtered
+    by ts >= since_iso and/or type == event_type. The file is streamed line
+    by line; malformed lines are skipped rather than raising.
+    """
+    if not path.exists():
+        return []
+    try:
+        # Read lines (file is small: rotation at 10MB per the writer).
+        with open(path, "r", encoding="utf-8") as f:
+            lines = f.readlines()
+    except OSError:
+        return []
+
+    results: list[dict[str, Any]] = []
+    # Scan from newest to oldest so we can early-exit once we have enough.
+    for raw in reversed(lines):
+        line = raw.strip()
+        if not line:
+            continue
+        try:
+            record = json.loads(line)
+        except (json.JSONDecodeError, ValueError):
+            continue
+        if not isinstance(record, dict):
+            continue
+        if event_type and record.get("type") != event_type:
+            continue
+        if since_iso:
+            ts = record.get("ts", "")
+            if isinstance(ts, str) and ts < since_iso:
+                # ISO-8601 strings sort lexicographically with Z suffix; once
+                # we pass the floor we can stop scanning.
+                break
+        results.append(record)
+        if len(results) >= limit:
+            break
+    # Return in chronological order (oldest first) for UI convenience.
+    results.reverse()
+    return results
+
+
+def _last_fallback_ts(events: list[dict[str, Any]]) -> Optional[str]:
+    """Return the ts of the most recent managed_agents_fallback event, if any."""
+    for rec in reversed(events):
+        if rec.get("type") == "managed_agents_fallback":
+            ts = rec.get("ts")
+            return ts if isinstance(ts, str) else None
+    return None
+
+
+@app.get("/api/managed/events")
+async def get_managed_events(
+    limit: int = Query(default=100, ge=1, le=_MANAGED_EVENTS_TAIL_MAX),
+    since: Optional[str] = Query(default=None),
+    type: Optional[str] = Query(default=None, alias="type"),
+):
+    """
+    Return the tail of .loki/managed/events.ndjson.
+
+    Works regardless of flag state. When the flags are off or the file does
+    not exist yet, returns an empty list. Never raises on I/O error.
+    """
+    try:
+        path = _managed_events_path()
+        records = _tail_ndjson(path, limit=limit, since_iso=since, event_type=type)
+        return {
+            "events": records,
+            "count": len(records),
+            "source": str(path),
+        }
+    except Exception as exc:  # defensive: never 500 on read-only tail.
+        logger.warning("managed events tail failed: %s", exc)
+        return {"events": [], "count": 0, "error": str(exc)}
+
+
+@app.get("/api/managed/status")
+async def get_managed_status():
+    """
+    Return the managed-agents flag snapshot plus last_fallback_ts.
+
+    When flags are off, returns {enabled: false, ...} rather than 503. This
+    endpoint is meant to be polled by the UI to decide whether to surface
+    the managed-memory panel at all.
+    """
+    snapshot = _managed_flags_snapshot()
+    # last_fallback_ts is best-effort from the local events file.
+    try:
+        events = _tail_ndjson(
+            _managed_events_path(),
+            limit=500,
+            since_iso=None,
+            event_type="managed_agents_fallback",
+        )
+        snapshot["last_fallback_ts"] = _last_fallback_ts(events)
+    except Exception:
+        snapshot["last_fallback_ts"] = None
+    return snapshot
+
+
+@app.get("/api/managed/memory_versions/{memory_id}")
+async def list_managed_memory_versions(memory_id: str):
+    """
+    Proxy to beta.memory_stores.memory_versions.list(memory_id=...).
+
+    Returns 503 with a helpful JSON body when flags are off or the SDK does
+    not expose the expected attribute path. On any SDK / transport error the
+    endpoint returns 502 with the error detail -- the managed store owns the
+    source of truth, so we do NOT silently return an empty list here.
+    """
+    # Validate memory_id early so we don't leak path-traversal attempts into
+    # the SDK payload. The managed API uses opaque identifiers; alphanumerics,
+    # hyphens, underscores only.
+    if (
+        not memory_id
+        or len(memory_id) > 256
+        or ".." in memory_id
+        or not re.match(r"^[a-zA-Z0-9_\-]+$", memory_id)
+    ):
+        raise HTTPException(status_code=400, detail="Invalid memory_id")
+
+    snapshot = _managed_flags_snapshot()
+    if not snapshot["enabled"]:
+        raise HTTPException(
+            status_code=503,
+            detail=(
+                "managed memory disabled: set LOKI_MANAGED_AGENTS=true and "
+                "LOKI_MANAGED_MEMORY=true to enable"
+            ),
+        )
+
+    try:
+        from memory.managed_memory import ManagedDisabled
+        from memory.managed_memory.client import get_client
+    except Exception as exc:
+        raise HTTPException(status_code=503, detail=f"managed client unavailable: {exc}")
+
+    try:
+        client = get_client()
+    except ManagedDisabled as exc:
+        raise HTTPException(status_code=503, detail=str(exc))
+
+    # Resolve beta.memory_stores.memory_versions.list(...) defensively. Some
+    # SDK versions may not expose this path yet; treat missing attributes as
+    # 503 (flag state prevents us from guaranteeing anything else).
+    try:
+        beta = getattr(client._client, "beta", None)  # type: ignore[attr-defined]
+        memory_stores = getattr(beta, "memory_stores", None) if beta is not None else None
+        memory_versions = (
+            getattr(memory_stores, "memory_versions", None)
+            if memory_stores is not None
+            else None
+        )
+        list_fn = getattr(memory_versions, "list", None) if memory_versions is not None else None
+        if list_fn is None:
+            raise HTTPException(
+                status_code=503,
+                detail="memory_versions.list not available in installed SDK",
+            )
+    except HTTPException:
+        raise
+    except Exception as exc:
+        raise HTTPException(status_code=503, detail=f"SDK introspection failed: {exc}")
+
+    try:
+        result = list_fn(memory_id=memory_id)
+    except Exception as exc:
+        # Distinguish "not found" from transport errors when we can.
+        status = getattr(exc, "status_code", None) or getattr(exc, "status", None)
+        if status == 404:
+            raise HTTPException(status_code=404, detail=f"memory_id not found: {memory_id}")
+        logger.warning("memory_versions.list failed: %s", exc)
+        raise HTTPException(status_code=502, detail=f"managed API error: {exc}")
+
+    # Normalize to a list of dicts.
+    data = getattr(result, "data", result)
+    if data is None:
+        data = []
+    items: list[dict[str, Any]] = []
+    for entry in data:
+        if isinstance(entry, dict):
+            items.append(entry)
+            continue
+        to_dict = getattr(entry, "model_dump", None) or getattr(entry, "dict", None)
+        if callable(to_dict):
+            try:
+                items.append(to_dict())
+                continue
+            except Exception:
+                pass
+        items.append({"raw": str(entry)})
+    return {"memory_id": memory_id, "versions": items, "count": len(items)}
+
+
 # ---------------------------------------------------------------------------
 # SPA catch-all: serve index.html for any path not matched by API routes
 # or static asset mounts.  This lets the dashboard UI handle client-side routing.

package/docs/INSTALLATION.md

@@ -2,7 +2,7 @@
 
 The flagship product of [Autonomi](https://www.autonomi.dev/). Complete installation instructions for all platforms and use cases.
 
-**Version:** v6.83.0
+**Version:** v7.0.1
 
 ---
 

package/mcp/__init__.py

@@ -57,4 +57,4 @@ try:
 except ImportError:
     __all__ = ['mcp']
 
-__version__ = '6.83.0'
+__version__ = '7.0.1'