ltcai 11.1.0 → 11.2.0

package/latticeai/core/config.py

@@ -172,7 +172,10 @@ class Config:
         trusted_proxies = [item.strip() for item in _value(env, "LATTICEAI_TRUSTED_PROXIES", "").split(",") if item.strip()]
 
         public_model = _value(env, "LATTICEAI_PUBLIC_MODEL", _value(env, "LATTICEAI_DEFAULT_MODEL", "openai:gpt-4o-mini"))
-        local_model = _value(env, "LATTICEAI_LOCAL_MODEL", "mlx-community/gemma-4-12b-it-4bit")
+        # Canonical HF casing (the Hub answers `gemma-4-12b-it-4bit` with
+        # `gemma-4-12B-it-4bit`); keeping it identical everywhere means the
+        # download path, the on-disk cache dir and the catalog key all agree.
+        local_model = _value(env, "LATTICEAI_LOCAL_MODEL", "mlx-community/gemma-4-12B-it-4bit")
 
         data_dir = Path(_value(env, "LATTICEAI_DATA_DIR", str(Path.home() / ".ltcai")))
         static_dir = Path(_value(env, "LATTICEAI_STATIC_DIR", str(base_dir / "static")))

package/latticeai/core/context_builder.py

@@ -26,7 +26,7 @@ import re
 from typing import Any, Dict, List
 
 from lattice_brain.context import approx_tokens
-from lattice_brain.graph.retrieval import context_quality_signal
+from lattice_brain.graph.retrieval import context_quality_signal, multimodal_signal
 from lattice_brain.self_model import DEFAULT_SUMMARY_TOKENS, summary_for_prompt
 
 _CLEAN_RE = re.compile(r"\s+")
@@ -250,8 +250,11 @@ def retrieve_context_for_generation(
             "graph_edges": len(hop_data.get("edges", [])),
             "budget_trimmed": trimmed,
         },
-        # Same honest signal chat reports for the same Brain.
-        "context_quality": context_quality_signal("hybrid", len(results)),
+        # Same honest signal chat reports for the same Brain — including the
+        # multimodal key when the document's context really rests on pictures.
+        "context_quality": context_quality_signal(
+            "hybrid", len(results), multimodal=multimodal_signal(results)
+        ),
         "trace": {
             "budget_approx_tokens": budget,
             "used_approx_tokens": approx_tokens(assembled),

package/latticeai/core/legacy_compatibility.py

@@ -13,7 +13,7 @@ from dataclasses import dataclass
 from pathlib import Path
 from typing import Any, Dict, List
 
-LEGACY_COMPATIBILITY_VERSION = "11.1.0"
+LEGACY_COMPATIBILITY_VERSION = "11.2.0"
 
 
 @dataclass(frozen=True)

package/latticeai/core/marketplace.py

@@ -10,7 +10,7 @@ from __future__ import annotations
 from copy import deepcopy
 from typing import Any, Dict, List, Optional
 
-MARKETPLACE_VERSION = "11.1.0"
+MARKETPLACE_VERSION = "11.2.0"
 TEMPLATE_KINDS = ("plugin", "workflow", "agent", "ingestion_bridge")
 
 

package/latticeai/core/messages.py

@@ -307,6 +307,31 @@ MESSAGES: Dict[str, Dict[str, str]] = {
         "ko": "'{status}' 상태의 검토 항목은 승인할 수 없습니다.",
         "en": "A review item in status '{status}' cannot be approved.",
     },
+    "review.bulk_ids_required": {
+        "ko": "한꺼번에 처리할 검토 항목을 하나 이상 골라 주세요.",
+        "en": "Choose at least one review item to act on.",
+    },
+    "review.bulk_too_many": {
+        "ko": "한 번에 최대 {cap}개까지 처리할 수 있습니다.",
+        "en": "At most {cap} items can be handled in one request.",
+    },
+    # ── interop bridges (Notion export / git / mail / calendar) ──────────
+    "ingestion.interop_path_required": {
+        "ko": "불러올 파일이나 폴더 경로가 필요합니다.",
+        "en": "A file or folder path to read is required.",
+    },
+    "ingestion.interop_unknown_source": {
+        "ko": "알 수 없는 연동 종류입니다: {source}",
+        "en": "Unknown interop source: {source}",
+    },
+    "ingestion.vault_watch_unavailable": {
+        "ko": "보관함 자동 확인 기능을 사용할 수 없습니다.",
+        "en": "Vault watch is unavailable.",
+    },
+    "ingestion.vault_watch_disabled": {
+        "ko": "보관함 자동 확인은 기본으로 꺼져 있습니다. 설정에서 켜야 사용할 수 있습니다.",
+        "en": "Vault watch is off by default; turn it on in settings to use it.",
+    },
     # ── projects ────────────────────────────────────────────────────────
     "project.not_found": {
         "ko": "프로젝트를 찾을 수 없습니다.",
@@ -317,6 +342,124 @@ MESSAGES: Dict[str, Dict[str, str]] = {
         "ko": "혼합 검색 정책 서비스가 설정되지 않았습니다.",
         "en": "The hybrid policy service is not configured.",
     },
+    # ── feature toggles ─────────────────────────────────────────────────
+    # The switchboard renders from the server (see
+    # ``latticeai/services/feature_toggles.py``), so every label and one-line
+    # explanation a person reads lives here. The rule for the summaries: say
+    # what turning it *on* does, in the words someone who never read the
+    # environment-variable docs would use.
+    "features.note": {
+        "ko": "모두 지금 바로 적용됩니다. 다시 시작하지 않아도 됩니다.",
+        "en": "Every switch here takes effect right away — no restart needed.",
+    },
+    "features.unknown": {
+        "ko": "그런 기능은 없습니다: {feature}",
+        "en": "There is no such feature: {feature}",
+    },
+    "features.invalid_value": {
+        "ko": "이 기능에 쓸 수 없는 값입니다: {value}",
+        "en": "That is not a value this feature can take: {value}",
+    },
+    "features.choice.install_required": {
+        "ko": "설치 필요 — {reason}",
+        "en": "Install required — {reason}",
+    },
+    "features.allow_multimodal.label": {
+        "ko": "사진·녹음도 기억하기",
+        "en": "Remember pictures and recordings",
+    },
+    "features.allow_multimodal.summary": {
+        "ko": "폴더를 읽을 때 글뿐 아니라 사진과 녹음도 함께 저장합니다.",
+        "en": "A folder scan stores pictures and recordings too, not just text.",
+    },
+    "features.video_ingest.label": {
+        "ko": "영상도 함께",
+        "en": "Include videos",
+    },
+    "features.video_ingest.summary": {
+        "ko": "사진·녹음을 켠 상태에서, 영상은 장면과 자막으로 저장합니다.",
+        "en": "With the switch above on, videos are stored as keyframes and subtitles.",
+    },
+    "features.vault_watch.label": {
+        "ko": "노트 보관함 지켜보기",
+        "en": "Watch my notes vault",
+    },
+    "features.vault_watch.summary": {
+        "ko": "밖에 있는 노트 보관함이 바뀌면 알아서 다시 읽어옵니다.",
+        "en": "When an outside notes vault changes, it is re-read on its own.",
+    },
+    "features.brain_network.label": {
+        "ko": "골라서 나누기",
+        "en": "Share selected knowledge",
+    },
+    "features.brain_network.summary": {
+        "ko": "내가 고른 기억 묶음만 다른 기기로 내보내고 받아올 수 있습니다.",
+        "en": "Lets you export a hand-picked slice of memory to another device, and receive one.",
+    },
+    "features.brain_network.caution": {
+        "ko": "이 기능만 기억을 이 컴퓨터 밖으로 내보냅니다. 받은 내용은 바로 합쳐지지 않고 검토함으로 갑니다.",
+        "en": "This is the one switch that sends memory off this computer. Anything received waits in the review inbox instead of merging.",
+    },
+    "features.synthesis.label": {
+        "ko": "스스로 정리하기",
+        "en": "Tidy up on its own",
+    },
+    "features.synthesis.summary": {
+        "ko": "자료가 쌓이면 알아서 훑어보고, 고칠 거리를 검토함에 제안합니다.",
+        "en": "As material piles up, the Brain reviews it and proposes tidy-ups in the review inbox.",
+    },
+    "features.auto_vector_index.label": {
+        "ko": "넣자마자 검색 준비",
+        "en": "Make new material searchable at once",
+    },
+    "features.auto_vector_index.summary": {
+        "ko": "새 자료를 넣으면 바로 의미 검색까지 준비합니다. 끄면 나중에 한 번에 만듭니다.",
+        "en": "New material is prepared for meaning-based search immediately; off means you rebuild later.",
+    },
+    "features.auto_late_fusion.label": {
+        "ko": "글로 사진 찾기",
+        "en": "Find pictures by typing",
+    },
+    "features.auto_late_fusion.summary": {
+        "ko": "글로 물어봐도 사진까지 함께 찾습니다. 사진을 읽는 모델이 있어야 켜집니다.",
+        "en": "A typed question also searches pictures — needs a vision model that shares the same space.",
+    },
+    "features.fusion_rrf.label": {
+        "ko": "검색 결과 합치는 방식 바꾸기",
+        "en": "Blend search results by rank",
+    },
+    "features.fusion_rrf.summary": {
+        "ko": "점수 대신 순위로 합칩니다. 검색 채널마다 점수 크기가 달라도 흔들리지 않습니다.",
+        "en": "Combines channels by position instead of score, so mismatched score scales stop skewing results.",
+    },
+    "features.graph_expansion.label": {
+        "ko": "옆에 있는 기억까지 보기",
+        "en": "Look at neighbouring memories",
+    },
+    "features.graph_expansion.summary": {
+        "ko": "찾은 기억과 바로 이어진 기억도 후보로 넣습니다. 답은 넓어지고 조금 흐려집니다.",
+        "en": "Adds memories one link away from a hit as candidates — wider answers, slightly less focused.",
+    },
+    "features.vector_backend.label": {
+        "ko": "의미 검색 방식",
+        "en": "Meaning-search engine",
+    },
+    "features.vector_backend.summary": {
+        "ko": "빠르기와 정확함 사이에서 고릅니다. 기본값은 전부 훑어보는 정확한 방식입니다.",
+        "en": "Trade speed against exactness. The default compares everything and is exact.",
+    },
+    "features.vector_backend.choice.brute": {
+        "ko": "전부 비교 (정확)",
+        "en": "Compare everything (exact)",
+    },
+    "features.vector_backend.choice.quantized": {
+        "ko": "간추려 비교 (빠름)",
+        "en": "Compare compressed (faster)",
+    },
+    "features.vector_backend.choice.hnsw": {
+        "ko": "근사 검색 (가장 빠름)",
+        "en": "Approximate search (fastest)",
+    },
     # ── models ──────────────────────────────────────────────────────────
     "models.other_user_credentials": {
         "ko": "다른 사용자의 모델 자격 증명을 사용할 수 없습니다.",

package/latticeai/core/model_compat.py

@@ -32,14 +32,54 @@ FAMILY_PATTERNS: List[Tuple[str, re.Pattern]] = [
     ("qwen", re.compile(r"qwen", re.I)),
     ("llama", re.compile(r"\bllama|meta[-_]?llama", re.I)),
     ("claude", re.compile(r"claude", re.I)),
+    # gpt-oss is its own local family with its own chat format, so it must be
+    # matched before the cloud `gpt` pattern rather than falling into it.
+    ("gpt_oss", re.compile(r"gpt[-_]?oss", re.I)),
     ("gpt", re.compile(r"gpt[-_]?(?:4|5)|openai", re.I)),
     ("gemini", re.compile(r"gemini", re.I)),
     ("grok", re.compile(r"grok|x[-_]?ai", re.I)),
+    ("lfm2", re.compile(r"\blfm[-_]?2", re.I)),
 ]
 
+#: HF ``config.json`` ``model_type`` → family code. An id is a name somebody
+#: chose; an architecture is what mlx-lm / mlx-vlm actually dispatches on, so it
+#: is the more reliable signal when we have it. Values here are the architectures
+#: pinned in the model capability registry (11.2.0) plus the ones that came
+#: before, so a model already on disk keeps its profile after its generation
+#: stops being offered.
+ARCHITECTURE_FAMILIES: Dict[str, str] = {
+    "gemma2": "gemma",
+    "gemma3": "gemma",
+    "gemma4": "gemma",
+    "gemma4_unified": "gemma",
+    "qwen2_5_vl": "qwen",
+    "qwen3_vl": "qwen",
+    "qwen3_vl_moe": "qwen",
+    "qwen3_5": "qwen",
+    "qwen3_5_moe": "qwen",
+    "llama": "llama",
+    "llama4": "llama",
+    "mllama": "llama",
+    "gpt_oss": "gpt_oss",
+    "lfm2": "lfm2",
+}
+
+
+def family_for_architecture(architecture: Optional[str]) -> str:
+    """Map an HF ``model_type`` to a family code (``"unknown"`` when unmapped)."""
+    return ARCHITECTURE_FAMILIES.get(str(architecture or "").strip().lower(), "unknown")
+
 
-def detect_model_family(model_id: str) -> str:
-    """주어진 model_id 문자열에서 family 코드를 추론한다."""
+def detect_model_family(model_id: str, architecture: Optional[str] = None) -> str:
+    """주어진 model_id 문자열에서 family 코드를 추론한다.
+
+    ``architecture`` (HF config ``model_type``) 가 주어지고 알려진 값이면 그것을
+    우선한다 — 로더가 실제로 분기하는 값이기 때문이다.
+    """
+    if architecture:
+        by_arch = family_for_architecture(architecture)
+        if by_arch != "unknown":
+            return by_arch
     if not model_id:
         return "unknown"
     raw = str(model_id)
@@ -96,6 +136,35 @@ FAMILY_PROFILES: Dict[str, Dict[str, Any]] = {
         "disable_draft": False,
         "postprocess": ["strip_role_tokens"],
     },
+    # gpt-oss speaks the "harmony" response format: the channel markers are
+    # stop sequences, not text, so the reply never has to be salvaged from them.
+    "gpt_oss": {
+        "family": "gpt_oss",
+        "supports_system": True,
+        "supports_vision": False,
+        "chat_template": "tokenizer_default",
+        "preferred_engines": ["local_mlx", "ollama", "llamacpp"],
+        "temperature": 0.2,
+        "top_p": 0.9,
+        "max_tokens": 4096,
+        "stop_sequences": ["<|return|>", "<|call|>", "<|endoftext|>"],
+        "disable_draft": False,
+        "postprocess": ["strip_role_tokens"],
+    },
+    # LFM2 uses a ChatML-style template; text only, so no vision claim.
+    "lfm2": {
+        "family": "lfm2",
+        "supports_system": True,
+        "supports_vision": False,
+        "chat_template": "tokenizer_default",
+        "preferred_engines": ["local_mlx", "ollama", "llamacpp"],
+        "temperature": 0.2,
+        "top_p": 0.9,
+        "max_tokens": 4096,
+        "stop_sequences": ["<|im_end|>", "<|endoftext|>"],
+        "disable_draft": False,
+        "postprocess": ["strip_role_tokens"],
+    },
     "unknown": {
         "family": "unknown",
         "supports_system": True,
@@ -623,9 +692,11 @@ def get_stop_sequences(model_id: str, engine: Optional[str] = None) -> List[str]
 
 
 __all__ = [
+    "ARCHITECTURE_FAMILIES",
     "FAMILY_PROFILES",
     "CompatProfile",
     "detect_model_family",
+    "family_for_architecture",
     "friendly_model_runtime_error",
     "get_model_profile",
     "model_runtime_compatibility",

package/latticeai/core/workspace_os_constants.py

@@ -10,7 +10,7 @@ from __future__ import annotations
 
 from typing import Dict
 
-WORKSPACE_OS_VERSION = "11.1.0"
+WORKSPACE_OS_VERSION = "11.2.0"
 
 # Workspace types separate single-user Personal workspaces from shared
 # Organization workspaces. Both keep the same local-first JSON store; the type

package/latticeai/models/model_providers.py

@@ -32,7 +32,11 @@ OPENAI_COMPATIBLE_PROVIDERS = {
     "xai": {
         "env_key": "XAI_API_KEY",
         "base_url": "https://api.x.ai/v1",
-        "default_model": "grok-beta",
+        # ``grok-beta`` was xAI's 2024 preview id and has been decommissioned;
+        # a request naming it now 404s at the provider. ``grok-4.5`` is the
+        # current flagship on api.x.ai and is multimodal, which is also why the
+        # separate ``grok-vision-beta`` row below is gone rather than renamed.
+        "default_model": "grok-4.5",
     },
     "ollama": {
         "env_key": "OLLAMA_API_KEY",
@@ -83,7 +87,7 @@ PROVIDER_MODEL_CATALOG = {
         {"id": "anthropic/claude-haiku-4.5", "name": "Claude Haiku 4.5 via OpenRouter", "family": "Claude"},
         {"id": "qwen/qwen3-vl-235b-a22b-instruct", "name": "Qwen3-VL 235B A22B via OpenRouter", "family": "Qwen"},
         {"id": "google/gemma-4-12b-it", "name": "Gemma 4 12B via OpenRouter", "family": "Gemma"},
-        {"id": "x-ai/grok-2", "name": "Grok 2 via OpenRouter", "family": "Grok"},
+        {"id": "x-ai/grok-4.5", "name": "Grok 4.5 via OpenRouter", "family": "Grok"},
         {"id": "meta-llama/llama-4-scout-17b-16e-instruct", "name": "Llama 4 Scout via OpenRouter", "family": "Llama"},
         {"id": "google/gemini-2.5-flash", "name": "Gemini 2.5 Flash via OpenRouter", "family": "Gemini"},
     ],
@@ -96,8 +100,12 @@ PROVIDER_MODEL_CATALOG = {
         {"id": "meta-llama/Llama-4-Scout-17B-16E-Instruct", "name": "Llama 4 Scout", "family": "Llama"},
     ],
     "xai": [
-        {"id": "grok-beta", "name": "Grok Beta", "family": "Grok"},
-        {"id": "grok-vision-beta", "name": "Grok Vision Beta", "family": "Grok"},
+        # One current generation only, per MODEL_POLICY's "do not keep old
+        # same-family generations" rule. The retired preview ids
+        # (grok-beta / grok-vision-beta) are not carried as fallbacks: a model
+        # the provider no longer serves is not compatibility, it is a 404 the
+        # user has to discover for themselves.
+        {"id": "grok-4.5", "name": "Grok 4.5", "family": "Grok"},
     ],
 }
 

package/latticeai/runtime/build_phases.py

@@ -621,6 +621,29 @@ def phase_domain(ctx: RuntimeContext) -> None:
     )
 
 
+def self_model_port(workspace_graph: Any) -> Any:
+    """The agent loop's Self-Model port (v11.2.0).
+
+    11.1.0 built ``executor_prompt_for(self_model_summary=…)`` and had nothing
+    to pass it; this is what the composition root passes. ``summary_for_prompt``
+    never raises and answers ``""`` for a Brain that knows nothing about its
+    owner — which produces exactly the pre-11.2.0 prompt bytes.
+
+    A module-level factory rather than a closure inside ``phase_services``
+    because a port that cannot be called on its own cannot be tested on its own.
+    """
+
+    def _summary(*, user_email: Any = None, workspace_id: Any = None) -> str:
+        from lattice_brain.self_model import summary_for_prompt
+
+        graph = workspace_graph()
+        if graph is None:
+            return ""
+        return summary_for_prompt(graph, workspace_id=workspace_id)
+
+    return _summary
+
+
 # ── phase 6b: retrieval, agent runtime, and the typed AppContext ─────────────
 def phase_services(ctx: RuntimeContext) -> None:
     """Retrieval/context assembly, the chat agent runtime, and the AppContext.
@@ -756,6 +779,9 @@ def phase_services(ctx: RuntimeContext) -> None:
             audit=ctx.append_audit_event,
             hooks=ctx.HOOKS_REGISTRY,
             brain_memory=ctx.BRAIN_MEMORY,
+            self_model_summary=self_model_port(
+                lambda: ctx.KNOWLEDGE_GRAPH if ctx.ENABLE_GRAPH else None
+            ),
         )
     )
 
@@ -803,6 +829,8 @@ def phase_services(ctx: RuntimeContext) -> None:
             require_graph=ctx._require_graph,
             workspace_graph=ctx._workspace_graph,
             graph_stats=ctx._graph_stats_safe,
+            # Provider, not a value: REVIEW_QUEUE lands two phases later.
+            review_queue=lambda: ctx.REVIEW_QUEUE,
             workspace_models=_workspace_models_payload,
             workspace_settings=_workspace_settings_payload,
             scan_environment=scan_environment,

package/latticeai/runtime/chat_wiring.py

@@ -25,6 +25,7 @@ def build_chat_agent_runtime_from_context(
     audit: Any,
     hooks: Any,
     brain_memory: Any,
+    self_model_summary: Any = None,
 ) -> Any:
     # Ensure dispatch + agent share the same autonomy dial before the runtime
     # is constructed (process-wide service; data_dir refined later at router mount).
@@ -39,6 +40,9 @@ def build_chat_agent_runtime_from_context(
         hooks=hooks,
         brain_memory=brain_memory,
         permission_mode=resolve_active_permission_mode,
+        # v11.2.0: a scoped resolver, not a snapshot — the profile a run sees is
+        # the one the Brain holds when the run starts, per user and workspace.
+        self_model_summary=self_model_summary,
     )
 
 

package/latticeai/runtime/feature_toggle_wiring.py

@@ -0,0 +1,163 @@
+"""Wire the feature switchboard into the running app (v11.2.0).
+
+Same shape as ``permission_mode_wiring``: one process-wide service, an
+idempotent router mount guarded on ``app.state``, and explicit arguments that
+*rebind* an already-created service rather than being dropped — a lazy first
+caller must not pin the store to a fallback data dir with no audit sink.
+
+The one job unique to this module is :func:`bind_feature_gates`: it points each
+opt-in gate's resolver at the service, which is the step that turns a persisted
+preference into behaviour. Every gate is imported inside the function so
+importing this module costs nothing; ``lattice_brain.synthesis`` in particular
+drags in the graph layer.
+
+Unbinding is a supported operation (:func:`unbind_feature_gates`) because these
+gates are module-level singletons: a test that bound them must be able to give
+them back, and "the environment answers again" has to be reachable.
+"""
+
+from __future__ import annotations
+
+import os
+import threading
+from pathlib import Path
+from typing import Any, Callable, List, Optional, Tuple
+
+from latticeai.services.feature_toggles import FeatureToggleService
+
+_LOCK = threading.Lock()
+_SHARED: Optional[FeatureToggleService] = None
+
+#: ``feature id -> (module, attribute)`` for every boolean gate. Resolved lazily
+#: by :func:`_boolean_gates` so the table stays readable next to the catalog it
+#: mirrors, and a rename that breaks the pairing fails loudly at wiring time.
+GATE_BINDINGS: Tuple[Tuple[str, str, str], ...] = (
+    ("allow_multimodal", "lattice_brain.ingestion", "MULTIMODAL_GATE"),
+    ("video_ingest", "lattice_brain.ingestion", "VIDEO_GATE"),
+    ("auto_vector_index", "lattice_brain.ingestion", "AUTO_VECTOR_INDEX_GATE"),
+    ("brain_network", "lattice_brain.portability", "BRAIN_NETWORK_GATE"),
+    ("synthesis", "lattice_brain.synthesis", "SYNTHESIS_GATE"),
+    ("fusion_rrf", "lattice_brain.graph.fusion", "FUSION_RRF_GATE"),
+    ("graph_expansion", "lattice_brain.graph.fusion", "GRAPH_EXPANSION_GATE"),
+    ("vault_watch", "latticeai.services.folder_watch", "VAULT_WATCH_GATE"),
+    ("auto_late_fusion", "latticeai.services.search_service", "IMAGE_QUERY_FUSION_GATE"),
+)
+
+#: The one non-boolean seam: the vector backend is a pick-one-of-three.
+CHOICE_FEATURE = "vector_backend"
+
+
+def _default_data_dir() -> Path:
+    raw = os.environ.get("LATTICEAI_DATA_DIR", "").strip()
+    if raw:
+        return Path(raw)
+    return Path.home() / ".ltcai"
+
+
+def _boolean_gates() -> List[Tuple[str, Any]]:
+    """``[(feature id, gate)]`` — imports are here, not at module import."""
+    from importlib import import_module
+
+    return [
+        (feature_id, getattr(import_module(module), attribute))
+        for feature_id, module, attribute in GATE_BINDINGS
+    ]
+
+
+def _bind_vector_index(resolver: Any) -> None:
+    from lattice_brain.graph.vector_index.selector import bind_vector_index_resolver
+
+    bind_vector_index_resolver(resolver)
+
+
+def get_feature_toggle_service(
+    *,
+    data_dir: Optional[Path] = None,
+    audit: Optional[Callable[..., None]] = None,
+) -> FeatureToggleService:
+    """Process-wide singleton; explicit arguments rebind an existing one."""
+    global _SHARED
+    with _LOCK:
+        if _SHARED is None:
+            _SHARED = FeatureToggleService(
+                data_dir=Path(data_dir) if data_dir is not None else _default_data_dir(),
+                audit=audit,
+            )
+            return _SHARED
+        if data_dir is not None:
+            _SHARED.rebind_data_dir(Path(data_dir))
+        if audit is not None:
+            _SHARED.rebind_audit(audit)
+        return _SHARED
+
+
+def bind_feature_gates(service: Optional[FeatureToggleService] = None) -> None:
+    """Point every opt-in gate at the switchboard.
+
+    After this, a persisted preference beats the environment variable for every
+    feature in the catalog — which is the whole point, since the panel is the
+    only control surface most people will ever use.
+    """
+    resolved = service or get_feature_toggle_service()
+    for feature_id, gate in _boolean_gates():
+        # ``gate.local`` is the fallback on purpose: the switchboard speaks only
+        # for switches this person actually moved. Everything else still answers
+        # from the gate's own override → env → default, so binding changes
+        # nothing at all for an install that never opened the panel.
+        gate.bind(resolved.resolver(feature_id, gate.local))
+    _bind_vector_index(resolved.choice_resolver(CHOICE_FEATURE))
+
+
+def unbind_feature_gates() -> None:
+    """Hand every gate back to its environment variable."""
+    for _feature_id, gate in _boolean_gates():
+        gate.bind(None)
+    _bind_vector_index(None)
+
+
+def reset_feature_toggle_service() -> None:
+    """Drop the singleton *and* the bindings that pointed at it (tests)."""
+    global _SHARED
+    unbind_feature_gates()
+    with _LOCK:
+        _SHARED = None
+
+
+def register_features_router(
+    app: Any,
+    *,
+    require_user: Callable[..., str],
+    data_dir: Optional[Path] = None,
+    append_audit_event: Optional[Callable[..., None]] = None,
+) -> FeatureToggleService:
+    """Install GET/POST /api/features on ``app`` and bind the gates. Idempotent.
+
+    The guard is a flag on ``app.state`` rather than a scan of route paths: a
+    router included through fastapi >= 0.140 has no flat ``path`` to introspect,
+    so path scanning silently stopped seeing the mount (see
+    ``permission_mode_wiring`` for the same note).
+    """
+    from latticeai.api.features import create_features_router
+
+    service = get_feature_toggle_service(data_dir=data_dir, audit=append_audit_event)
+    bind_feature_gates(service)
+    state = getattr(app, "state", None)
+    if state is not None and getattr(state, "_ltcai_features_mounted", False):
+        return service
+    app.include_router(
+        create_features_router(service=service, require_user=require_user)
+    )
+    if state is not None:
+        state._ltcai_features_mounted = True
+    return service
+
+
+__all__ = [
+    "CHOICE_FEATURE",
+    "GATE_BINDINGS",
+    "bind_feature_gates",
+    "get_feature_toggle_service",
+    "register_features_router",
+    "reset_feature_toggle_service",
+    "unbind_feature_gates",
+]

package/latticeai/runtime/router_registration.py

@@ -675,4 +675,15 @@ def register_review_and_brain_tail_routers(
         append_audit_event=append_audit_event,
         knowledge_graph=knowledge_graph,
     )
+    # The opt-in switchboard. Mounted last on purpose: binding the gates to the
+    # service is what makes a stored preference beat an env var, and every
+    # module that owns one of those gates has been imported by now.
+    from latticeai.runtime.feature_toggle_wiring import register_features_router
+
+    register_features_router(
+        app,
+        require_user=require_user,
+        data_dir=data_dir,
+        append_audit_event=append_audit_event,
+    )
     return brain_network

package/latticeai/services/app_context.py

@@ -76,6 +76,14 @@ class AppContext:
     workspace_graph: Optional[Callable[[], Any]] = None
     graph_stats: Optional[Callable[[], dict]] = None
 
+    # ── review center ─────────────────────────────────────────────────────
+    # ``ReviewQueueService``, reached through a provider like
+    # ``workspace_graph`` above: the queue is built in a later runtime phase
+    # than this context, so a value captured here would be ``None`` forever.
+    # Call it per request; ``None`` means no Review Center is wired (tests,
+    # headless helpers) and the callers stage nothing rather than writing.
+    review_queue: Optional[Callable[[], Any]] = None
+
     # ── workspace payload providers / skills ──────────────────────────────
     workspace_models: Optional[Callable[[], dict]] = None
     workspace_settings: Optional[Callable[[], dict]] = None

package/latticeai/services/architecture_readiness.py

@@ -16,7 +16,7 @@ from typing import Any, Dict, List
 
 from latticeai.core.legacy_compatibility import legacy_shim_report
 
-ARCHITECTURE_VERSION_TARGET = "11.1.0"
+ARCHITECTURE_VERSION_TARGET = "11.2.0"
 
 PREFERRED_REFACTORING_ORDER = [
     "agent-runtime",