infinity-context 0.1.0__py3-none-any.whl

infinity_context_server/api/v1/insights.py

@@ -0,0 +1,100 @@
+"""Memory management insights API."""
+
+from __future__ import annotations
+
+from time import perf_counter
+from typing import Annotated, Any
+
+from fastapi import APIRouter, Depends
+from infinity_context_core.application import BuildMemoryInsightsQuery
+
+from infinity_context_server.api.auth import require_service_token
+from infinity_context_server.api.dependencies import get_container
+from infinity_context_server.api.policy import should_retrieve
+from infinity_context_server.api.public_payload import safe_public_metadata
+from infinity_context_server.api.v1.scope_resolution import resolve_existing_context_scope
+from infinity_context_server.composition import Container
+from infinity_context_server.features.context_building import public as context_building_server
+
+router = APIRouter(tags=["insights"], dependencies=[Depends(require_service_token)])
+
+_LEGACY_MEMORY_INSIGHTS_API_RESPONSES = (
+    context_building_server.LegacyMemoryInsightsApiResponseMapper(
+        safe_public_metadata=safe_public_metadata,
+    )
+)
+
+
+@router.post("/insights")
+async def build_insights(
+    request: context_building_server.MemoryInsightsHttpRequest,
+    container: Annotated[Container, Depends(get_container)],
+) -> dict[str, Any]:
+    started = perf_counter()
+    request_id = container.ids.new_id("req")
+    if not should_retrieve(container):
+        response = _LEGACY_MEMORY_INSIGHTS_API_RESPONSES.empty_insights_response(
+            request_id=request_id,
+            policy_mode=container.settings.policy_mode.value,
+        )
+        container.runtime_metrics.record_context(
+            latency_ms=_elapsed_ms(started),
+            diagnostics=response["data"]["diagnostics"],
+            request_id=request_id,
+            use_case="build_insights",
+        )
+        return response
+
+    scope = await resolve_existing_context_scope(
+        container,
+        space_id=request.space_id,
+        memory_scope_ids=request.memory_scope_ids,
+        thread_id=request.thread_id,
+        space_slug=request.space_slug,
+        memory_scope_external_ref=request.memory_scope_external_ref,
+        memory_scope_external_refs=request.memory_scope_external_refs,
+        thread_external_ref=request.thread_external_ref,
+    )
+    if scope is None:
+        response = _LEGACY_MEMORY_INSIGHTS_API_RESPONSES.empty_insights_response(
+            request_id=request_id,
+            policy_mode=container.settings.policy_mode.value,
+            scope_not_found=True,
+        )
+        container.runtime_metrics.record_context(
+            latency_ms=_elapsed_ms(started),
+            diagnostics=response["data"]["diagnostics"],
+            request_id=request_id,
+            use_case="build_insights",
+        )
+        return response
+
+    insights = await container.build_memory_insights.execute(
+        BuildMemoryInsightsQuery(
+            space_id=scope.space_id,
+            memory_scope_ids=scope.memory_scope_ids,
+            thread_id=scope.thread_id,
+            max_facts=request.max_facts,
+            max_documents=request.max_documents,
+            max_episodes=request.max_episodes,
+            max_suggestions=request.max_suggestions,
+            max_captures=request.max_captures,
+            max_activity=request.max_activity,
+        )
+    )
+    response = _LEGACY_MEMORY_INSIGHTS_API_RESPONSES.insights_response_from_result(
+        insights,
+        request_id=request_id,
+    )
+    container.runtime_metrics.record_context(
+        latency_ms=_elapsed_ms(started),
+        diagnostics=insights.diagnostics,
+        request_id=request_id,
+        use_case="build_insights",
+        scope=insights.scope,
+    )
+    return response
+
+
+def _elapsed_ms(started: float) -> float:
+    return round((perf_counter() - started) * 1000, 3)

infinity_context_server/api/v1/internal_memory_comparison_runs.py

@@ -0,0 +1,406 @@
+"""Hidden internal API for Infinity canonical managed benchmark lifecycle."""
+
+from __future__ import annotations
+
+import hashlib
+from datetime import UTC, datetime
+from typing import Annotated, Any
+
+from fastapi import APIRouter, Depends, Header, Path, Response, status
+from infinity_context_core.application import (
+    CleanupBenchmarkRunCommand,
+    FinalizeBenchmarkRunCleanupCommand,
+    FinalizeUnsealedBenchmarkAbortCommand,
+    GetBenchmarkRunLifecycleQuery,
+    RegisterBenchmarkRunCommand,
+    SealProjectionManifestCommand,
+)
+from infinity_context_core.ports.benchmark_runs import (
+    BenchmarkAbortCompletionReceipt,
+    BenchmarkCleanupCompletionReceipt,
+    BenchmarkCleanupReceipt,
+)
+from pydantic import BaseModel, ConfigDict, Field
+
+from infinity_context_server.api.auth import (
+    require_strict_admin_service_token,
+)
+from infinity_context_server.api.dependencies import get_container
+from infinity_context_server.api.policy import ensure_server_writes_enabled
+from infinity_context_server.composition import Container
+
+router = APIRouter(
+    prefix="/internal/memory-comparison/runs",
+    tags=["internal-memory-comparison"],
+    dependencies=[Depends(require_strict_admin_service_token)],
+)
+_DIGEST_PATTERN = r"^[0-9a-f]{64}$"
+
+
+class RegisterBenchmarkRunRequest(BaseModel):
+    model_config = ConfigDict(extra="forbid")
+
+    schema_version: str = Field(pattern=r"^memory-comparison-run-registration\.v1$")
+    run_id_sha256: str = Field(pattern=_DIGEST_PATTERN)
+    binding_commitment_sha256: str = Field(pattern=_DIGEST_PATTERN)
+    infinity_target_identity_sha256: str = Field(pattern=_DIGEST_PATTERN)
+    space_slug: str = Field(
+        min_length=19,
+        max_length=98,
+        pattern=r"^memory-comparison-[a-z0-9-]{1,80}$",
+    )
+
+
+class CleanupBenchmarkRunRequest(BaseModel):
+    model_config = ConfigDict(extra="forbid")
+
+    schema_version: str = Field(pattern=r"^memory-comparison-run-cleanup\.v1$")
+    binding_commitment_sha256: str = Field(pattern=_DIGEST_PATTERN)
+    infinity_target_identity_sha256: str = Field(pattern=_DIGEST_PATTERN)
+    space_id: str = Field(min_length=1, max_length=80)
+    space_slug: str = Field(
+        min_length=19,
+        max_length=98,
+        pattern=r"^memory-comparison-[a-z0-9-]{1,80}$",
+    )
+
+
+class FinalizeBenchmarkRunCleanupRequest(BaseModel):
+    model_config = ConfigDict(extra="forbid", strict=True)
+
+    schema_version: str = Field(pattern=r"^memory-comparison-run-cleanup-finalize\.v1$")
+    receipt_sha256: str = Field(pattern=_DIGEST_PATTERN)
+
+
+class FinalizeUnsealedBenchmarkAbortRequest(BaseModel):
+    model_config = ConfigDict(extra="forbid", strict=True)
+
+    schema_version: str = Field(pattern=r"^memory-comparison-run-abort-finalize\.v1$")
+    binding_commitment_sha256: str = Field(pattern=_DIGEST_PATTERN)
+    infinity_target_identity_sha256: str = Field(pattern=_DIGEST_PATTERN)
+    space_id: str = Field(min_length=1, max_length=80)
+    space_slug: str = Field(
+        min_length=19,
+        max_length=98,
+        pattern=r"^memory-comparison-[a-z0-9-]{1,80}$",
+    )
+    receipt_sha256: str = Field(pattern=_DIGEST_PATTERN)
+
+
+class SealProjectionManifestRequest(BaseModel):
+    model_config = ConfigDict(extra="forbid", strict=True)
+
+    schema_version: str = Field(pattern=r"^memory-comparison-projection-manifest-seal\.v1$")
+    projection_manifest_sha256: str = Field(pattern=_DIGEST_PATTERN)
+    projection_manifest: dict[str, object]
+
+
+@router.post("", include_in_schema=False, status_code=status.HTTP_201_CREATED)
+async def register_benchmark_run(
+    request: RegisterBenchmarkRunRequest,
+    response: Response,
+    container: Annotated[Container, Depends(get_container)],
+    idempotency_key: Annotated[
+        str,
+        Header(alias="Idempotency-Key", min_length=8, max_length=240),
+    ],
+) -> dict[str, Any]:
+    ensure_server_writes_enabled(container)
+    result = await container.register_benchmark_run.execute(
+        RegisterBenchmarkRunCommand(
+            run_id_sha256=request.run_id_sha256,
+            binding_commitment_sha256=request.binding_commitment_sha256,
+            infinity_target_identity_sha256=request.infinity_target_identity_sha256,
+            space_slug=request.space_slug,
+            idempotency_key_sha256=_sha256(idempotency_key),
+        )
+    )
+    if not result.created:
+        response.status_code = status.HTTP_200_OK
+    record = result.record
+    return {
+        "data": {
+            "schema_version": "memory-comparison-run-registration-response.v1",
+            "authority": "infinity_canonical",
+            "run_id_sha256": record.run_id_sha256,
+            "binding_commitment_sha256": record.binding_commitment_sha256,
+            "infinity_target_identity_sha256": record.infinity_target_identity_sha256,
+            "space_id": record.space_id,
+            "space_slug": record.space_slug,
+            "state": record.state,
+            "created": result.created,
+        }
+    }
+
+
+@router.put("/{run_id_sha256}/projection-manifest", include_in_schema=False)
+async def seal_projection_manifest(
+    run_id_sha256: Annotated[str, Path(pattern=_DIGEST_PATTERN)],
+    request: SealProjectionManifestRequest,
+    container: Annotated[Container, Depends(get_container)],
+) -> dict[str, Any]:
+    ensure_server_writes_enabled(container)
+    result = await container.seal_projection_manifest.execute(
+        SealProjectionManifestCommand(
+            run_id_sha256=run_id_sha256,
+            projection_manifest_json=request.projection_manifest,
+            projection_manifest_sha256=request.projection_manifest_sha256,
+        )
+    )
+    record = result.record
+    return {
+        "data": {
+            "schema_version": "memory-comparison-projection-manifest-seal-response.v1",
+            "authority": "infinity_canonical",
+            "run_id_sha256": record.run_id_sha256,
+            "binding_commitment_sha256": record.binding_commitment_sha256,
+            "infinity_target_identity_sha256": (record.infinity_target_identity_sha256),
+            "projection_manifest_sha256": record.projection_manifest_sha256,
+            "state": record.state,
+            "projection_cleanup_state": record.projection_cleanup_state,
+            "replayed": result.replayed,
+        }
+    }
+
+
+@router.get("/{run_id_sha256}/cleanup", include_in_schema=False)
+async def get_benchmark_run_lifecycle(
+    run_id_sha256: Annotated[str, Path(pattern=_DIGEST_PATTERN)],
+    container: Annotated[Container, Depends(get_container)],
+) -> dict[str, Any]:
+    result = await container.get_benchmark_run_lifecycle.execute(
+        GetBenchmarkRunLifecycleQuery(run_id_sha256=run_id_sha256)
+    )
+    record = result.record
+    return {
+        "data": {
+            "schema_version": "memory-comparison-run-lifecycle-response.v1",
+            "authority": "infinity_canonical",
+            "run_id_sha256": record.run_id_sha256,
+            "binding_commitment_sha256": record.binding_commitment_sha256,
+            "infinity_target_identity_sha256": (record.infinity_target_identity_sha256),
+            "space_id": record.space_id,
+            "space_slug": record.space_slug,
+            "state": record.state,
+            "projection_cleanup_state": record.projection_cleanup_state,
+            "projection_manifest_sha256": record.projection_manifest_sha256,
+            "cleanup_receipt": _cleanup_receipt_json(record.cleanup_receipt),
+            "completion_receipt": _completion_receipt_json(record.completion_receipt),
+        }
+    }
+
+
+@router.delete("/{run_id_sha256}", include_in_schema=False)
+async def cleanup_benchmark_run(
+    run_id_sha256: Annotated[str, Path(pattern=_DIGEST_PATTERN)],
+    request: CleanupBenchmarkRunRequest,
+    container: Annotated[Container, Depends(get_container)],
+    idempotency_key: Annotated[
+        str,
+        Header(alias="Idempotency-Key", min_length=8, max_length=240),
+    ],
+) -> dict[str, Any]:
+    ensure_server_writes_enabled(container)
+    result = await container.cleanup_benchmark_run.execute(
+        CleanupBenchmarkRunCommand(
+            run_id_sha256=run_id_sha256,
+            binding_commitment_sha256=request.binding_commitment_sha256,
+            infinity_target_identity_sha256=request.infinity_target_identity_sha256,
+            space_id=request.space_id,
+            space_slug=request.space_slug,
+            idempotency_key_sha256=_sha256(idempotency_key),
+        )
+    )
+    receipt = result.receipt
+    return {
+        "data": {
+            "schema_version": "memory-comparison-run-cleanup-response.v1",
+            "authority": "infinity_canonical",
+            "run_id_sha256": receipt.run_id_sha256,
+            "space_id": receipt.space_id,
+            "space_slug": receipt.space_slug,
+            "state": "cleanup_pending",
+            "disposition": receipt.disposition,
+            "projection_cleanup": result.projection_cleanup_state,
+            "counts": {
+                "facts": receipt.counts.facts,
+                "documents": receipt.counts.documents,
+                "chunks": receipt.counts.chunks,
+                "episodes": receipt.counts.episodes,
+                "threads": receipt.counts.threads,
+                "memory_scopes": receipt.counts.memory_scopes,
+                "obsolete_upsert_jobs": receipt.counts.obsolete_upsert_jobs,
+                "vector_delete_jobs": receipt.counts.vector_delete_jobs,
+                "graph_delete_jobs": receipt.counts.graph_delete_jobs,
+                "cognee_delete_jobs": receipt.counts.cognee_delete_jobs,
+            },
+            "vector_delete_outbox_ids": list(receipt.vector_delete_outbox_ids),
+            "graph_delete_outbox_ids": list(receipt.graph_delete_outbox_ids),
+            "cognee_delete_outbox_ids": list(receipt.cognee_delete_outbox_ids),
+            "receipt_sha256": receipt.receipt_sha256,
+            "replayed": result.replayed,
+        }
+    }
+
+
+@router.post(
+    "/{run_id_sha256}/cleanup/finalize",
+    include_in_schema=False,
+)
+async def finalize_benchmark_run_cleanup(
+    run_id_sha256: Annotated[str, Path(pattern=_DIGEST_PATTERN)],
+    request: FinalizeBenchmarkRunCleanupRequest,
+    container: Annotated[Container, Depends(get_container)],
+    idempotency_key: Annotated[
+        str,
+        Header(alias="Idempotency-Key", min_length=8, max_length=240),
+    ],
+) -> dict[str, Any]:
+    ensure_server_writes_enabled(container)
+    result = await container.finalize_benchmark_run_cleanup.execute(
+        FinalizeBenchmarkRunCleanupCommand(
+            run_id_sha256=run_id_sha256,
+            expected_cleanup_receipt_sha256=request.receipt_sha256,
+            idempotency_key_sha256=_sha256(idempotency_key),
+        )
+    )
+    receipt = result.receipt
+    return {
+        "data": {
+            "schema_version": "memory-comparison-run-cleanup-finalize-response.v1",
+            "authority": "infinity_canonical",
+            "run_id_sha256": receipt.run_id_sha256,
+            "space_id": receipt.space_id,
+            "space_slug": receipt.space_slug,
+            "state": "cleanup_complete",
+            "disposition": receipt.disposition,
+            "projection_cleanup": receipt.projection_cleanup,
+            "projection_manifest_sha256": receipt.projection_manifest_sha256,
+            "cleanup_initiation_receipt_sha256": (receipt.cleanup_initiation_receipt_sha256),
+            "projection_absence_proof_sha256": (receipt.projection_absence_proof_sha256),
+            "completed_at": _rfc3339(receipt.completed_at),
+            "receipt_sha256": receipt.receipt_sha256,
+            "replayed": result.replayed,
+        }
+    }
+
+
+@router.post(
+    "/{run_id_sha256}/cleanup/abort/finalize",
+    include_in_schema=False,
+)
+async def finalize_unsealed_benchmark_abort(
+    run_id_sha256: Annotated[str, Path(pattern=_DIGEST_PATTERN)],
+    request: FinalizeUnsealedBenchmarkAbortRequest,
+    container: Annotated[Container, Depends(get_container)],
+    idempotency_key: Annotated[
+        str,
+        Header(alias="Idempotency-Key", min_length=8, max_length=240),
+    ],
+) -> dict[str, Any]:
+    ensure_server_writes_enabled(container)
+    result = await container.finalize_unsealed_benchmark_abort.execute(
+        FinalizeUnsealedBenchmarkAbortCommand(
+            run_id_sha256=run_id_sha256,
+            binding_commitment_sha256=request.binding_commitment_sha256,
+            infinity_target_identity_sha256=request.infinity_target_identity_sha256,
+            space_id=request.space_id,
+            space_slug=request.space_slug,
+            expected_cleanup_receipt_sha256=request.receipt_sha256,
+            idempotency_key_sha256=_sha256(idempotency_key),
+        )
+    )
+    receipt = result.receipt
+    return {
+        "data": {
+            "schema_version": "memory-comparison-run-abort-finalize-response.v1",
+            "authority": "infinity_canonical",
+            "run_id_sha256": receipt.run_id_sha256,
+            "binding_commitment_sha256": receipt.binding_commitment_sha256,
+            "infinity_target_identity_sha256": receipt.infinity_target_identity_sha256,
+            "space_id": receipt.space_id,
+            "space_slug": receipt.space_slug,
+            "state": "cleanup_aborted",
+            "disposition": receipt.disposition,
+            "projection_cleanup": receipt.projection_cleanup,
+            "cleanup_initiation_receipt_sha256": (receipt.cleanup_initiation_receipt_sha256),
+            "cleanup_verification_sha256": receipt.cleanup_verification_sha256,
+            "completed_at": _rfc3339(receipt.completed_at),
+            "receipt_sha256": receipt.receipt_sha256,
+            "replayed": result.replayed,
+        }
+    }
+
+
+def _cleanup_receipt_json(
+    receipt: BenchmarkCleanupReceipt | None,
+) -> dict[str, Any] | None:
+    if receipt is None:
+        return None
+    return {
+        "run_id_sha256": receipt.run_id_sha256,
+        "space_id": receipt.space_id,
+        "space_slug": receipt.space_slug,
+        "disposition": receipt.disposition,
+        "projection_cleanup": receipt.projection_cleanup,
+        "counts": {
+            "facts": receipt.counts.facts,
+            "documents": receipt.counts.documents,
+            "chunks": receipt.counts.chunks,
+            "episodes": receipt.counts.episodes,
+            "threads": receipt.counts.threads,
+            "memory_scopes": receipt.counts.memory_scopes,
+            "obsolete_upsert_jobs": receipt.counts.obsolete_upsert_jobs,
+            "vector_delete_jobs": receipt.counts.vector_delete_jobs,
+            "graph_delete_jobs": receipt.counts.graph_delete_jobs,
+            "cognee_delete_jobs": receipt.counts.cognee_delete_jobs,
+        },
+        "vector_delete_outbox_ids": list(receipt.vector_delete_outbox_ids),
+        "graph_delete_outbox_ids": list(receipt.graph_delete_outbox_ids),
+        "cognee_delete_outbox_ids": list(receipt.cognee_delete_outbox_ids),
+        "receipt_sha256": receipt.receipt_sha256,
+    }
+
+
+def _completion_receipt_json(
+    receipt: BenchmarkCleanupCompletionReceipt | BenchmarkAbortCompletionReceipt | None,
+) -> dict[str, Any] | None:
+    if receipt is None:
+        return None
+    if type(receipt) is BenchmarkAbortCompletionReceipt:
+        return {
+            "run_id_sha256": receipt.run_id_sha256,
+            "binding_commitment_sha256": receipt.binding_commitment_sha256,
+            "infinity_target_identity_sha256": receipt.infinity_target_identity_sha256,
+            "space_id": receipt.space_id,
+            "space_slug": receipt.space_slug,
+            "disposition": receipt.disposition,
+            "projection_cleanup": receipt.projection_cleanup,
+            "cleanup_initiation_receipt_sha256": (receipt.cleanup_initiation_receipt_sha256),
+            "cleanup_verification_sha256": receipt.cleanup_verification_sha256,
+            "completed_at": _rfc3339(receipt.completed_at),
+            "receipt_sha256": receipt.receipt_sha256,
+        }
+    return {
+        "run_id_sha256": receipt.run_id_sha256,
+        "space_id": receipt.space_id,
+        "space_slug": receipt.space_slug,
+        "disposition": receipt.disposition,
+        "projection_cleanup": receipt.projection_cleanup,
+        "projection_manifest_sha256": receipt.projection_manifest_sha256,
+        "cleanup_initiation_receipt_sha256": (receipt.cleanup_initiation_receipt_sha256),
+        "projection_absence_proof_sha256": receipt.projection_absence_proof_sha256,
+        "completed_at": _rfc3339(receipt.completed_at),
+        "receipt_sha256": receipt.receipt_sha256,
+    }
+
+
+def _rfc3339(value: datetime) -> str:
+    return value.astimezone(UTC).isoformat(timespec="microseconds").replace("+00:00", "Z")
+
+
+def _sha256(value: str) -> str:
+    return hashlib.sha256(value.encode()).hexdigest()
+
+
+__all__ = ("router",)

infinity_context_server/api/v1/memory_browser.py

@@ -0,0 +1,183 @@
+"""Memory browser read model API."""
+
+from __future__ import annotations
+
+from typing import Annotated, Any
+
+from fastapi import APIRouter, Depends, Query
+from infinity_context_core.application import MemoryBrowserQuery
+
+from infinity_context_server.api.auth import require_service_token
+from infinity_context_server.api.dependencies import get_container
+from infinity_context_server.api.v1.anchors import anchor_to_response
+from infinity_context_server.api.v1.captures import capture_to_response
+from infinity_context_server.api.v1.context_links import (
+    context_link_suggestion_to_response,
+    context_link_to_response,
+)
+from infinity_context_server.api.v1.episodes import episode_to_response
+from infinity_context_server.api.v1.scope_resolution import resolve_existing_single_scope
+from infinity_context_server.composition import Container
+from infinity_context_server.features.document_ingestion import (
+    public as document_ingestion_feature,
+)
+from infinity_context_server.features.memory_facts import public as memory_facts_feature
+from infinity_context_server.features.memory_scopes import public as memory_scopes_feature
+
+router = APIRouter(
+    tags=["memory-browser"],
+    dependencies=[Depends(require_service_token)],
+)
+
+
+@router.get("/memory-browser")
+async def get_memory_browser(
+    container: Annotated[Container, Depends(get_container)],
+    space_id: Annotated[str | None, Query(min_length=1, max_length=80)] = None,
+    memory_scope_id: Annotated[str | None, Query(min_length=1, max_length=80)] = None,
+    space_slug: Annotated[str | None, Query(min_length=1, max_length=160)] = None,
+    memory_scope_external_ref: Annotated[str | None, Query(min_length=1, max_length=200)] = None,
+    limit: Annotated[int, Query(ge=1, le=200)] = 50,
+    fact_status: Annotated[str | None, Query(max_length=40)] = "active",
+    episode_status: Annotated[str | None, Query(max_length=40)] = "active",
+    document_status: Annotated[str | None, Query(max_length=40)] = "active",
+    chunk_status: Annotated[str | None, Query(max_length=40)] = "active",
+    extraction_status: Annotated[str | None, Query(max_length=40)] = None,
+    thread_status: Annotated[str | None, Query(max_length=40)] = "active",
+    capture_status: Annotated[str | None, Query(max_length=40)] = None,
+    asset_status: Annotated[str | None, Query(max_length=40)] = "stored",
+    anchor_status: Annotated[str | None, Query(max_length=40)] = "active",
+    link_status: Annotated[str | None, Query(max_length=40)] = None,
+    suggestion_status: Annotated[str | None, Query(max_length=40)] = None,
+) -> dict[str, Any]:
+    scope = await resolve_existing_single_scope(
+        container,
+        space_id=space_id,
+        memory_scope_id=memory_scope_id,
+        thread_id=None,
+        space_slug=space_slug,
+        memory_scope_external_ref=memory_scope_external_ref,
+        thread_external_ref=None,
+        thread_required=False,
+    )
+    if scope is None:
+        return {"data": _empty_browser_response(limit=limit)}
+    result = await container.build_memory_browser.execute(
+        MemoryBrowserQuery(
+            space_id=scope.space_id,
+            memory_scope_id=scope.memory_scope_id,
+            limit=limit,
+            fact_status=fact_status,
+            episode_status=episode_status,
+            document_status=document_status,
+            chunk_status=chunk_status,
+            extraction_status=extraction_status,
+            thread_status=thread_status,
+            capture_status=capture_status,
+            asset_status=asset_status,
+            anchor_status=anchor_status,
+            link_status=link_status,
+            suggestion_status=suggestion_status,
+        )
+    )
+    return {
+        "data": {
+            "generated_at": result.generated_at.isoformat(),
+            "memory_scope": memory_scopes_feature.memory_scope_to_response(
+                result.memory_scope,
+            ),
+            "facts": [
+                memory_facts_feature.fact_to_response(fact) for fact in result.facts
+            ],
+            "episodes": [episode_to_response(episode) for episode in result.episodes],
+            "documents": [
+                document_ingestion_feature.document_to_response(document)
+                for document in result.documents
+            ],
+            "chunks": [
+                document_ingestion_feature.chunk_to_response(chunk)
+                for chunk in result.chunks
+            ],
+            "extraction_jobs": [
+                document_ingestion_feature.asset_extraction_to_response(job)
+                for job in result.extraction_jobs
+            ],
+            "threads": [
+                memory_scopes_feature.thread_to_response(thread) for thread in result.threads
+            ],
+            "captures": [capture_to_response(capture) for capture in result.captures],
+            "assets": [
+                document_ingestion_feature.asset_to_response(asset)
+                for asset in result.assets
+            ],
+            "anchors": [anchor_to_response(anchor) for anchor in result.anchors],
+            "context_links": [context_link_to_response(link) for link in result.context_links],
+            "context_link_suggestions": [
+                context_link_suggestion_to_response(suggestion)
+                for suggestion in result.context_link_suggestions
+            ],
+            "stats": result.stats,
+            "visual_summary": result.visual_summary,
+            "quick_actions": list(result.quick_actions),
+            "diagnostics": result.diagnostics,
+        }
+    }
+
+
+def _empty_browser_response(*, limit: int) -> dict[str, Any]:
+    return {
+        "generated_at": None,
+        "memory_scope": None,
+        "facts": [],
+        "episodes": [],
+        "documents": [],
+        "chunks": [],
+        "extraction_jobs": [],
+        "threads": [],
+        "captures": [],
+        "assets": [],
+        "anchors": [],
+        "context_links": [],
+        "context_link_suggestions": [],
+        "stats": {
+            "facts": 0,
+            "episodes": 0,
+            "documents": 0,
+            "chunks": 0,
+            "extraction_jobs": 0,
+            "threads": 0,
+            "captures": 0,
+            "assets": 0,
+            "anchors": 0,
+            "context_links": 0,
+            "context_link_suggestions": 0,
+            "pending_context_link_suggestions": 0,
+            "active_context_links": 0,
+        },
+        "visual_summary": {
+            "status": "empty",
+            "evidence_count": 0,
+            "relationship_count": 0,
+            "pending_review_count": 0,
+            "active_link_count": 0,
+            "processing_job_count": 0,
+            "failed_job_count": 0,
+            "visible_sources": [],
+            "limit_reached": False,
+            "health_hints": ["scope_not_found", "empty_scope"],
+        },
+        "quick_actions": [
+            {
+                "id": "create_memory_scope",
+                "label": "Create memory scope",
+                "description": "Create this MemoryScope before saving visual memory.",
+                "priority": 1,
+            }
+        ],
+        "diagnostics": {
+            "scope_not_found": True,
+            "browser_version": "memory-browser-v1",
+            "visual_summary_version": "visual-memory-summary-v1",
+            "limit": limit,
+        },
+    }