ltcai 11.0.1 → 11.2.0

package/latticeai/runtime/persistence_runtime.py

@@ -42,6 +42,10 @@ def build_persistence_runtime(
     from latticeai.services.brain_intelligence import BrainIntelligenceService
     from latticeai.services.funnel_metrics import FunnelMetricsService
     from latticeai.services.memory_service import MemoryService
+    from latticeai.services.multimodal_ports import (
+        build_multimodal_ports,
+        multimodal_enabled,
+    )
     from latticeai.services.workspace_service import WorkspaceService
 
     realtime_bus = RealtimeBus()
@@ -80,21 +84,53 @@ def build_persistence_runtime(
     funnel_metrics = FunnelMetricsService(Path(data_dir) / "funnel_metrics.json")
 
     def _funnel_audit(action, detail, user):
-        try:
-            if action == "kg_ingest":
+        """Best-effort sinks for a landed ingest, then the real audit.
+
+        Both sinks are isolated separately: one failing must not cost the
+        other, and neither may cost the ingest that is already persisted.
+        """
+        if action == "kg_ingest":
+            try:
                 funnel_metrics.record_ingest(
                     duplicate=bool((detail or {}).get("duplicate"))
                 )
-        except Exception:  # noqa: BLE001 — metrics must never break ingestion
-            quiet()
+            except Exception:  # noqa: BLE001 — metrics must never break ingestion
+                quiet()
+            # v11.1.0: the same seam drives synthesis. The pipeline audits an
+            # ingest only after the graph write landed, so ``status: "ok"`` is
+            # a fact about this call site rather than a guess; ``duplicate``
+            # travels in the detail and is what keeps a re-import from pushing
+            # the Brain toward a pass it has nothing new to say in.
+            try:
+                brain_intelligence.note_ingest(
+                    {"status": "ok", **(detail or {})}, user_email=user
+                )
+            except Exception:  # noqa: BLE001 — synthesis must never break ingestion
+                quiet()
         audit(action, detail, user)
 
+    # Multi-modal capture (v11.1.0): off unless the user turned it on, and
+    # even then only as capable as the models actually present. With nothing
+    # configured this resolves to an empty bundle without importing or loading
+    # anything.
+    multimodal_ports = build_multimodal_ports()
     ingestion_pipeline = IngestionPipeline(
         knowledge_graph,
         hooks=hooks_registry,
         enable_graph=enable_graph,
         audit=_funnel_audit,
+        allow_multimodal=multimodal_enabled(),
+        multimodal=multimodal_ports,
     )
+    # The local folder scanner reads images through the same ports, so a
+    # caption in the Evidence panel and a caption on a scanned screenshot come
+    # from one model or from none. A disabled/absent graph has nothing to
+    # attach them to, and a store that refuses new attributes is not a reason
+    # to fail startup.
+    try:
+        knowledge_graph.multimodal_ports = multimodal_ports
+    except AttributeError:
+        quiet()
     device_identity = DeviceIdentity(data_dir)
     kg_portability = KGPortabilityService(
         knowledge_graph=knowledge_graph,
@@ -116,6 +152,7 @@ def build_persistence_runtime(
         "BRAIN_INTELLIGENCE": brain_intelligence,
         "AUTOMATION_INTELLIGENCE": automation_intelligence,
         "INGESTION_PIPELINE": ingestion_pipeline,
+        "MULTIMODAL_PORTS": multimodal_ports,
         "DEVICE_IDENTITY": device_identity,
         "KG_PORTABILITY": kg_portability,
         "FUNNEL_METRICS": funnel_metrics,

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/runtime/runtime_context.py

@@ -144,6 +144,7 @@ class RuntimeContext:
     BRAIN_INTELLIGENCE: Any
     AUTOMATION_INTELLIGENCE: Any
     INGESTION_PIPELINE: Any
+    MULTIMODAL_PORTS: Any
     DEVICE_IDENTITY: Any
     KG_PORTABILITY: Any
     FUNNEL_METRICS: Any

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.0.1"
+ARCHITECTURE_VERSION_TARGET = "11.2.0"
 
 PREFERRED_REFACTORING_ORDER = [
     "agent-runtime",

package/latticeai/services/automation_intelligence.py

@@ -55,6 +55,13 @@ _SIGNATURE_SIMILARITY = 0.6
 _MIN_SUGGESTION_CONFIDENCE = 0.35
 _LOW_CONFIDENCE_THRESHOLD = 0.5
 _KG_GROUNDING_LIMIT = 5
+#: Charged when the graph *was* consulted and found nothing related. v11.2.0
+#: fixes a dead policy: the floor above was unreachable for recurring questions
+#: (the cheapest possible question — asked twice, one phrasing, no recipe —
+#: scored 0.475), so the suppression branch could only ever be exercised by a
+#: test that moved the constant. Absence of grounding is real evidence, and
+#: charging for it is what makes the floor mean something again.
+_UNGROUNDED_PENALTY = 0.15
 
 
 def _question_confidence(
@@ -67,7 +74,13 @@ def _question_confidence(
 
     Evidence factors: how often the question repeats, how many distinct
     phrasings exist, whether it maps onto a known starter-recipe intent, and
-    (when the graph is available) how many Brain nodes relate to it.
+    what the Brain knows about it.
+
+    That last factor is three-valued on purpose. ``None`` means the graph could
+    not be consulted — unknown, so nothing is added or taken away. A positive
+    count is supporting evidence. **Zero** is not the same as unknown: the
+    graph was asked, and it knows nothing about this question, which is a
+    reason to be less sure rather than a reason to be neutral.
     """
     score = 0.3 + 0.5 * min(1.0, (int(count) - 1) / 4)
     score += min(0.15, 0.05 * len(examples or []))
@@ -75,13 +88,16 @@ def _question_confidence(
         score += 0.15
     if kg_related:
         score += min(0.2, 0.05 * int(kg_related))
+    elif kg_related == 0:
+        score -= _UNGROUNDED_PENALTY
     factors = {
         "repeat_count": int(count),
         "distinct_examples": len(examples or []),
         "intent_match": bool(recipe_id),
         "kg_related_nodes": kg_related,
+        "kg_grounded": None if kg_related is None else bool(kg_related),
     }
-    return round(min(1.0, score), 2), factors
+    return round(max(0.0, min(1.0, score)), 2), factors
 
 
 def _source_confidence(indexed: int, watch_enabled: bool) -> tuple:
@@ -357,6 +373,10 @@ class AutomationIntelligenceService:
                 pattern["count"], pattern["examples"], recipe_id, kg_related
             )
             if confidence < _MIN_SUGGESTION_CONFIDENCE:
+                # Asked a couple of times, phrased one way, matching no recipe,
+                # and the Brain knows nothing about it — not enough to propose
+                # automating. Counted, so the surface can say how many were held
+                # back rather than silently showing fewer.
                 suppressed_low_confidence += 1
                 continue
             if recipe_id:

package/latticeai/services/brain_intelligence.py

@@ -52,6 +52,21 @@ def _parse_ts(value: Any) -> Optional[datetime]:
     return parsed
 
 
+def _no_graph_reason(graph_available: bool) -> str:
+    """Why a graph-derived health dimension has nothing to say.
+
+    Two different situations that both end in ``status: "unavailable"``: the
+    graph could not be read at all, and the graph read fine but holds nothing
+    yet. Telling them apart is the difference between "something is broken"
+    and "you have not saved anything yet".
+    """
+    return (
+        "no knowledge saved yet"
+        if graph_available
+        else "the knowledge graph could not be read"
+    )
+
+
 class BrainIntelligenceService:
     def __init__(
         self,
@@ -395,7 +410,11 @@ class BrainIntelligenceService:
                 "stale_threshold_days": _STALE_DAYS,
             }
         else:
-            dimensions["freshness"] = {"status": "unavailable", "score": None}
+            dimensions["freshness"] = {
+                "status": "unavailable",
+                "score": None,
+                "reason": _no_graph_reason(sample["available"]),
+            }
 
         # Connectivity — orphan nodes are knowledge the Brain cannot reason
         # across; a well-tended graph keeps them rare.
@@ -414,7 +433,11 @@ class BrainIntelligenceService:
                 "edges": len(edges),
             }
         else:
-            dimensions["connectivity"] = {"status": "unavailable", "score": None}
+            dimensions["connectivity"] = {
+                "status": "unavailable",
+                "score": None,
+                "reason": _no_graph_reason(sample["available"]),
+            }
 
         # Embedding coverage — semantic recall only works for indexed items.
         index_status: Dict[str, Any] = {}
@@ -425,7 +448,23 @@ class BrainIntelligenceService:
                 LOGGER.exception("brain intelligence index status failed")
                 index_status = {"error": str(exc)}
         scale = index_status.get("scale") or {}
-        if "coverage_ratio" in scale:
+        indexable = scale.get("source_items", index_status.get("source_items"))
+        if "coverage_ratio" not in scale:
+            dimensions["embedding_coverage"] = {
+                "status": "unavailable",
+                "score": None,
+                "reason": "this knowledge store does not report vector index coverage",
+            }
+        elif indexable == 0:
+            # An empty index covers 100% of nothing. Scoring that as a perfect
+            # 100 is how a brand-new Brain used to grade itself "excellent"
+            # off its only measurable dimension (audit v11.2.0, Finding 3).
+            dimensions["embedding_coverage"] = {
+                "status": "unavailable",
+                "score": None,
+                "reason": "no indexable items yet",
+            }
+        else:
             dimensions["embedding_coverage"] = {
                 "status": "ok",
                 "score": round(float(scale["coverage_ratio"]) * 100),
@@ -433,8 +472,6 @@ class BrainIntelligenceService:
                 "pending_items": scale.get("pending_items"),
                 "needs_reindex": index_status.get("status") == "needs_reindex",
             }
-        else:
-            dimensions["embedding_coverage"] = {"status": "unavailable", "score": None}
 
         # Edge quality + contradiction pressure — reuses the quality layer.
         if sample["available"] and edges:
@@ -450,7 +487,15 @@ class BrainIntelligenceService:
                 "contradiction_edges": len(contradiction_edges),
             }
         else:
-            dimensions["consistency"] = {"status": "unavailable", "score": None}
+            dimensions["consistency"] = {
+                "status": "unavailable",
+                "score": None,
+                "reason": (
+                    _no_graph_reason(sample["available"])
+                    if not (sample["available"] and nodes)
+                    else "no relationships recorded yet"
+                ),
+            }
 
         scores = [d["score"] for d in dimensions.values() if d.get("score") is not None]
         overall = round(sum(scores) / len(scores)) if scores else None
@@ -461,6 +506,29 @@ class BrainIntelligenceService:
             else "attention" if overall >= 50
             else "critical"
         )
+        # What the verdict rests on. A composite averages only what could be
+        # measured, so the count of measured dimensions is part of the answer
+        # rather than a footnote — and when nothing could be measured the
+        # report says so instead of leaving a bare null (the 9.9.7 rule: a
+        # "—" always states why).
+        unmeasured = sorted(
+            name for name, dim in dimensions.items() if dim.get("score") is None
+        )
+        coverage: Dict[str, Any] = {
+            "measured": len(scores),
+            "total": len(dimensions),
+            "unavailable": unmeasured,
+            "partial": bool(unmeasured),
+        }
+        reason: Optional[str] = None
+        if overall is None:
+            reason = (
+                "no health dimension could be measured yet — "
+                + "; ".join(
+                    f"{name}: {dimensions[name].get('reason') or 'unavailable'}"
+                    for name in unmeasured
+                )
+            )
 
         actions: List[Dict[str, str]] = []
         emb = dimensions["embedding_coverage"]
@@ -490,14 +558,18 @@ class BrainIntelligenceService:
                 "reason": f"{cons_dim['contradiction_edges']} contradiction edges recorded in the graph.",
             })
 
-        return {
+        report: Dict[str, Any] = {
             "overall_score": overall,
             "grade": grade,
             "dimensions": dimensions,
+            "coverage": coverage,
             "recommended_actions": actions,
             "graph_available": sample["available"],
             "generated_at": _now(),
         }
+        if reason is not None:
+            report["reason"] = reason
+        return report
 
     # ── vector freshness (v9.8.0) ────────────────────────────────────────
 
@@ -511,7 +583,51 @@ class BrainIntelligenceService:
         raises. The vector index is store-global (not workspace-partitioned);
         scope arguments are accepted for router symmetry but do not narrow
         the report.
+
+        Since v11.2.0 a store that can split its backlog also gets a
+        ``breakdown`` key (see :meth:`_freshness_breakdown`). It is additive:
+        the four keys above keep their meaning and their types, so the
+        freshness chip that reads ``pending_items`` is untouched, and a store
+        without the split simply has no ``breakdown``.
         """
+        payload = self._vector_freshness_contract()
+        breakdown = self._freshness_breakdown()
+        if breakdown is not None:
+            payload["breakdown"] = breakdown
+        return payload
+
+    def _freshness_breakdown(self) -> Optional[Dict[str, Any]]:
+        """``vector_freshness_breakdown()`` from the store, or ``None``.
+
+        "12 pending" hides two different situations — twelve items never
+        embedded (a new import) and twelve whose text changed under an
+        existing embedding (edits, where current answers are quietly wrong).
+        The store has always known the difference; until now nothing asked it.
+
+        ``None`` covers every reason the split is not available (graph off,
+        an older store, an unreadable index), because a caller can only act on
+        numbers that were really measured — never on zeros standing in for
+        them.
+        """
+        if not self._enable_graph or self._kg is None:
+            return None
+        breakdown_fn = getattr(self._kg, "vector_freshness_breakdown", None)
+        if not callable(breakdown_fn):
+            return None
+        try:
+            raw = breakdown_fn()
+        except Exception:
+            LOGGER.exception("vector freshness breakdown read failed")
+            return None
+        # An empty or unrecognisable answer is "not measured", which is what
+        # ``None`` already means here — publishing an empty block would claim
+        # a split nobody computed.
+        if not isinstance(raw, dict) or not raw:
+            return None
+        return dict(raw)
+
+    def _vector_freshness_contract(self) -> Dict[str, Any]:
+        """The four-key freshness payload, unchanged since v9.8.0."""
 
         def _unavailable(detail: str) -> Dict[str, Any]:
             return {

package/latticeai/services/change_proposals.py

@@ -31,6 +31,11 @@ from typing import Any, Callable, Dict, List, Optional, Tuple
 
 from latticeai.core.quiet import quiet
 from latticeai.core.tool_governor import classify_tool_call
+from latticeai.core.workspace_reorganization import (
+    REORG_KIND,
+    apply_reorganization,
+    propose_reorganization,
+)
 
 LOGGER = logging.getLogger(__name__)
 
@@ -301,6 +306,33 @@ class ChangeProposalService:
         )
         return item
 
+    def propose_reorganization(
+        self,
+        *,
+        root: str = "",
+        graph: Any = None,
+        user_email: Optional[str] = None,
+        workspace_id: Optional[str] = None,
+        max_moves: int = 20,
+    ) -> Dict[str, Any]:
+        """Stage a whole-folder reorganization as one reviewable proposal.
+
+        Moves only — see :mod:`latticeai.core.workspace_reorganization`. It
+        goes through this service (rather than the review queue directly) so
+        approving it from the Review Center applies it the same way every
+        other staged change is applied.
+        """
+        return propose_reorganization(
+            root=root,
+            resolve_path=self._resolve_path,
+            review_queue=self._review_queue,
+            graph=graph,
+            user_email=user_email,
+            workspace_id=workspace_id,
+            max_moves=max_moves,
+            audit=self._audit,
+        )
+
     # ── listing / apply / reject ─────────────────────────────────────────
 
     def pending(
@@ -362,8 +394,8 @@ class ChangeProposalService:
                 raise KeyError(f"not a change proposal: {item_id}")
             payload = item.get("payload") or {}
             kind = str(item.get("kind") or "")
-            path = str(payload.get("path") or "")
-            if kind not in ("file_update", "file_delete"):
+            path = str(payload.get("path") or payload.get("root") or "")
+            if kind not in ("file_update", "file_delete", REORG_KIND):
                 raise ValueError(f"unknown change proposal kind: {kind}")
 
             # Duplicate/concurrent approval guard: a resolved proposal must
@@ -375,20 +407,28 @@ class ChangeProposalService:
                     rebase_hint="이미 처리된 제안입니다. 다시 적용할 수 없습니다.",
                 )
 
-            self._check_base_unchanged(payload, path=path, kind=kind)
-
-            target = self._resolve_path(path)
-            if kind == "file_update":
-                self._atomic_write(target, str(payload.get("new_content") or ""))
-            else:  # file_delete — existence re-verified inside the lock
-                if target.is_file():
+            moves: Optional[Dict[str, Any]] = None
+            if kind == REORG_KIND:
+                # A reorganization has no single base file to hash: each move
+                # is re-checked at apply time and a drifted one is skipped,
+                # never forced (see workspace_reorganization.apply_*).
+                moves = apply_reorganization(payload, resolve_path=self._resolve_path)
+            else:
+                self._check_base_unchanged(payload, path=path, kind=kind)
+                target = self._resolve_path(path)
+                if kind == "file_update":
+                    self._atomic_write(target, str(payload.get("new_content") or ""))
+                elif target.is_file():  # file_delete — re-verified inside the lock
                     target.unlink()
             approved = self._review_queue.approve(item_id, workspace_id=workspace_id)
         self._audit(
             "change_proposal_applied", user_email=user_email,
             proposal_id=item_id, path=path, kind=kind,
         )
-        return {"item": approved, "applied": True, "path": path, "kind": kind}
+        result = {"item": approved, "applied": True, "path": path, "kind": kind}
+        if moves is not None:
+            result["moves"] = moves
+        return result
 
     def _check_base_unchanged(
         self, payload: Dict[str, Any], *, path: str, kind: str

package/latticeai/services/command_center.py

@@ -214,11 +214,17 @@ class CommandCenterService:
         except Exception:
             LOGGER.exception("command center health read failed")
             return {"available": False}
-        overall = report.get("overall") or {}
+        # ``BrainIntelligenceService.health_report()`` publishes the score and
+        # the grade at the top level. This used to read them out of a nested
+        # ``overall`` block that no producer has ever written, so the section
+        # was permanently unavailable: Today's Briefing showed a dash with no
+        # reason beside it, and the "check-health" quick action below could
+        # never fire. Read the shape the real collaborator returns.
+        score = report.get("overall_score")
         return {
-            "available": overall.get("score") is not None,
-            "grade": overall.get("grade"),
-            "score": overall.get("score"),
+            "available": score is not None,
+            "grade": report.get("grade"),
+            "score": score,
             "recommended_actions": list(report.get("recommended_actions") or [])[:3],
         }