ltcai 11.1.0 → 11.2.0

package/latticeai/api/chat_helpers.py

@@ -212,8 +212,17 @@ def build_context_quality(
     lexical-only, or when retrieval failed entirely — so the frontend can
     tell the user the answer is weakly grounded instead of implying rich
     graph context. Never raises.
+
+    A fifth key, ``multimodal``, appears only when the matches really include
+    picture nodes (v11.2.0). "6 nodes" reads differently when two of them are
+    screenshots whose text came out of OCR, and until this call site passed
+    ``multimodal=`` the shipped chat surface could not tell the difference the
+    signal was built to report.
     """
-    from lattice_brain.graph.retrieval import context_quality_signal
+    from lattice_brain.graph.retrieval import (
+        context_quality_signal,
+        multimodal_signal,
+    )
 
     query = str(query or "").strip()
     if knowledge_graph is None or not query:
@@ -233,7 +242,9 @@ def build_context_quality(
             return context_quality_signal("none", 0, reason="그래프 검색에 실패했습니다")
         matches = result.get("matches") or []
         return context_quality_signal(
-            str(result.get("mode") or "hybrid"), len(matches)
+            str(result.get("mode") or "hybrid"),
+            len(matches),
+            multimodal=multimodal_signal(matches),
         )
     # Lexical-only stores without the hybrid mixin.
     try:
@@ -242,7 +253,9 @@ def build_context_quality(
         ).get("matches") or []
     except Exception:  # noqa: BLE001 — signal building must never fail chat
         return context_quality_signal("none", 0, reason="그래프 검색에 실패했습니다")
-    return context_quality_signal("lexical_only", len(matches))
+    return context_quality_signal(
+        "lexical_only", len(matches), multimodal=multimodal_signal(matches)
+    )
 
 
 # ── answer-citation binding (backlog #11, review §7.2 E #4) ──────────────────

package/latticeai/api/chat_hybrid.py

@@ -14,7 +14,10 @@ from latticeai.core.network_boundary import (
     NetworkBoundaryMode,
     normalize_network_mode,
 )
-from latticeai.runtime.network_boundary_wiring import resolve_active_network_mode
+from latticeai.runtime.network_boundary_wiring import (
+    get_hybrid_policy_service,
+    resolve_active_network_mode,
+)
 from latticeai.services.hybrid_chat import stream_hybrid_cloud_turn
 
 
@@ -32,6 +35,28 @@ def resolve_request_network_mode(
     )
 
 
+def resolve_hybrid_auto_commit(
+    *,
+    user_email: Optional[str],
+    workspace_id: Optional[str],
+) -> bool:
+    """The scoped hybrid policy's ``auto_commit`` decision for this turn.
+
+    Sibling of :func:`resolve_request_network_mode`: the dial says whether the
+    turn may reach the cloud, this says what may happen to what comes back.
+    Default is ``False`` — cloud-derived knowledge waits in the Review Center
+    — and a policy that cannot be read is treated as the default rather than
+    as permission.
+    """
+    try:
+        policy = get_hybrid_policy_service().resolve(
+            user_email=user_email, workspace_id=workspace_id
+        )
+    except Exception:  # noqa: BLE001 — an unreadable policy never grants a write
+        return False
+    return bool(policy.get("auto_commit", False))
+
+
 def maybe_hybrid_stream_response(
     *,
     req: Any,
@@ -45,6 +70,7 @@ def maybe_hybrid_stream_response(
     chat_service: Any,
     notify: Any,
     model_id: Optional[str],
+    review_queue: Any = None,
 ) -> Optional[StreamingResponse]:
     """Return a StreamingResponse when cloud path should run; else None."""
     if mode != NetworkBoundaryMode.CLOUD_ALLOWED:
@@ -66,6 +92,10 @@ def maybe_hybrid_stream_response(
             history_user=history_user,
             notify=notify,
             source=req.source,
+            review_queue=review_queue,
+            auto_commit=resolve_hybrid_auto_commit(
+                user_email=effective_email, workspace_id=workspace_id
+            ),
         ),
         media_type="text/event-stream",
         headers={
@@ -78,5 +108,6 @@ def maybe_hybrid_stream_response(
 
 __all__ = [
     "resolve_request_network_mode",
+    "resolve_hybrid_auto_commit",
     "maybe_hybrid_stream_response",
 ]

package/latticeai/api/features.py

@@ -0,0 +1,70 @@
+"""Feature switchboard API — read the catalog, move one switch (v11.2.0).
+
+Two routes and no more. The catalog is rendered by the service (labels,
+explanations, defaults, which options are even installable), so this router
+carries no product knowledge at all: adding a feature is a line in
+``latticeai/services/feature_toggles.CATALOG``, not a change here or in the
+client.
+"""
+
+from __future__ import annotations
+
+from typing import Any, Callable, Union
+
+from fastapi import APIRouter, HTTPException, Request
+from pydantic import BaseModel, Field
+
+from latticeai.core.messages import http_error, resolve_language
+from latticeai.services.feature_toggles import (
+    FeatureToggleService,
+    InvalidFeatureValue,
+    UnknownFeature,
+)
+
+
+class SetFeatureRequest(BaseModel):
+    """One switch move. ``value`` is a bool for a toggle, a string for a choice."""
+
+    value: Union[bool, str] = Field(
+        ..., description="true/false for a toggle, or the option id for a choice"
+    )
+
+
+def create_features_router(
+    *,
+    service: FeatureToggleService,
+    require_user: Callable[..., str],
+) -> APIRouter:
+    router = APIRouter(tags=["features"])
+
+    @router.get("/api/features")
+    async def list_features(request: Request) -> Any:
+        """Every opt-in feature, its live value, and where that value came from."""
+        require_user(request)
+        return service.catalog(resolve_language(request))
+
+    @router.post("/api/features/{feature_id}")
+    async def set_feature(
+        feature_id: str, body: SetFeatureRequest, request: Request
+    ) -> Any:
+        """Persist one person's choice; the answer is the feature as it now reads."""
+        user = require_user(request)
+        language = resolve_language(request)
+        try:
+            return service.set(
+                feature_id, body.value, language=language, user_email=user
+            )
+        except UnknownFeature as exc:
+            raise http_error(
+                400, "features.unknown", language, feature=feature_id
+            ) from exc
+        except InvalidFeatureValue as exc:
+            # Pass-through: the service already localized the reason through the
+            # same catalog (wrong type, or an option whose optional dependency
+            # is not installed), and re-wording it here would only lose it.
+            raise HTTPException(status_code=400, detail=str(exc)) from exc
+
+    return router
+
+
+__all__ = ["SetFeatureRequest", "create_features_router"]

package/latticeai/api/local_files.py

@@ -60,12 +60,36 @@ class FolderWatchEnableRequest(BaseModel):
     path: str
     recursive: bool = True
     workspace_id: Optional[str] = None
+    #: ``folder`` (default, unchanged) or ``vault`` — a watched external
+    #: Obsidian vault, which re-runs the whole bridge sync when it changes and
+    #: carries its own opt-in gate on top of this approval.
+    kind: str = "folder"
     # Watching continuously reads local disk → same approval dance as
     # /api/ingestion/folder. This is the explicit opt-in the review requires.
     approved: bool = False
     approval_token: Optional[str] = None
 
 
+class InteropIngestRequest(BaseModel):
+    """Read one local interop source through the one ingestion gate (v11.2.0).
+
+    ``source`` picks the bridge — ``notion`` (an export directory or ``.zip``),
+    ``git`` (a local repository), ``mail`` (``.eml``/``.ics`` files or a folder
+    of them). Every one of them reads a path the user approves through the same
+    local-read dance as ``/api/ingestion/folder``, and ``dry_run`` reports what
+    a real run would touch without writing anything.
+    """
+
+    source: str
+    path: str
+    workspace_id: Optional[str] = None
+    dry_run: bool = False
+    #: Git only: how far back to read. Ignored by the other bridges.
+    max_commits: Optional[int] = None
+    approved: bool = False
+    approval_token: Optional[str] = None
+
+
 class ObsidianSyncRequest(BaseModel):
     """One-shot sync of an *external* Obsidian vault (v11.1.0).
 
@@ -107,10 +131,18 @@ def create_local_files_router(
     if folder_watch is None and ingestion_pipeline is not None and data_dir is not None:
         try:
             from latticeai.services.folder_watch import FolderWatchService
+            from latticeai.services.obsidian_bridge import ObsidianVaultBridge
 
             folder_watch = FolderWatchService(
                 pipeline=ingestion_pipeline,
                 config_path=Path(data_dir) / "folder_watch.json",
+                # A watched vault re-runs the *whole* bridge sync, which is what
+                # makes its link edges real; the bridge is handed in rather than
+                # imported inside the poller so the watch service keeps knowing
+                # nothing about how a vault is parsed.
+                vault_bridge=ObsidianVaultBridge(
+                    pipeline=ingestion_pipeline, knowledge_graph=knowledge_graph,
+                ),
             )
             folder_watch.restore()
         except Exception:  # noqa: BLE001 — watch mode is optional, never blocks routes
@@ -405,6 +437,66 @@ def create_local_files_router(
             dry_run=req.dry_run,
         )
 
+    # ── interop bridges: Notion export / git history / mail + calendar ───────
+    @router.get("/api/ingestion/interop")
+    async def interop_status(request: Request):
+        """Which interop bridges this machine can actually run, and why not."""
+        require_user(request)
+        from latticeai.services.interop_bridges import bridge_status
+
+        return bridge_status()
+
+    @router.post("/api/ingestion/interop")
+    async def interop_ingest(req: InteropIngestRequest, request: Request):
+        """Read an approved local interop source through the one gate.
+
+        Same approval dance and the same ``IngestionPipeline`` door as the
+        vault bridge: no vendor API, no credentials, nothing leaves the
+        machine. ``dry_run`` writes nothing and reports what a real run would.
+        """
+        current_user = permission_gateway.require_local_user(request)
+        _require_pipeline()
+        workspace_id = _ingestion_write_workspace(request, req.workspace_id, current_user)
+        path = (req.path or "").strip()
+        if not path:
+            raise http_error(400, "ingestion.interop_path_required", resolve_language(request))
+        from latticeai.services.interop_bridges import build_bridge
+
+        try:
+            bridge = build_bridge(
+                req.source, pipeline=ingestion_pipeline, knowledge_graph=knowledge_graph,
+            )
+        except ValueError:
+            raise http_error(
+                400,
+                "ingestion.interop_unknown_source",
+                resolve_language(request),
+                source=req.source,
+            )
+        if not req.approved:
+            return permission_gateway.local_permission_response(path, "read", current_user)
+        permission_gateway.require_local_approval(
+            token=req.approval_token,
+            path=path,
+            action="read",
+            user_email=current_user,
+        )
+        options: Dict[str, Any] = {}
+        if req.max_commits is not None:
+            options["max_commits"] = req.max_commits
+        # Walking an export and embedding its pages is blocking work; the server
+        # owns one event loop and it may not sit here (10.9.0 ASYNC gate).
+        return await asyncio.to_thread(
+            lambda: bridge.sync(
+                path,
+                owner=current_user or None,
+                workspace_id=workspace_id,
+                user_email=current_user or None,
+                dry_run=req.dry_run,
+                **options,
+            )
+        )
+
     # ── folder watch mode: opt-in, off by default (backlog #8) ────────────────
     def _require_folder_watch(request: Request):
         _require_pipeline()
@@ -446,7 +538,16 @@ def create_local_files_router(
             owner=current_user or None,
             workspace_id=workspace_id,
             recursive=req.recursive,
+            kind=req.kind,
         )
+        if result.get("status") == "disabled":
+            # Turned off rather than broken: 403 with the reason, the same shape
+            # every other opt-in gate in this product answers with.
+            raise HTTPException(
+                status_code=403,
+                detail=result.get("detail")
+                or translate("ingestion.vault_watch_disabled", resolve_language(request)),
+            )
         if result.get("status") != "ok":
             raise HTTPException(
                 status_code=400,
@@ -518,6 +619,7 @@ def create_local_files_router(
 __all__ = [
     "FolderIngestRequest",
     "FolderWatchEnableRequest",
+    "InteropIngestRequest",
     "LocalAccessRequest",
     "LocalWriteRequest",
     "ObsidianSyncRequest",

package/latticeai/api/portability.py

@@ -87,8 +87,16 @@ class SubgraphSelection(BaseModel):
 
 
 class SubgraphArchiveRequest(SubgraphSelection):
+    """Exactly one recipient mechanism — a passphrase, or a public key.
+
+    Both optional at the schema level and validated in the service, so the
+    error a caller gets names the rule ("choose one") instead of a field.
+    """
+
     path: Optional[str] = None
-    passphrase: str
+    passphrase: Optional[str] = None
+    #: The recipient's X25519 public key, from their ``/share/recipient-key``.
+    recipient_public_key: Optional[str] = None
 
 
 class SubgraphImportRequest(BaseModel):
@@ -269,6 +277,22 @@ def create_portability_router(
         except (ValueError, RuntimeError) as exc:
             raise HTTPException(status_code=400, detail=str(exc))
 
+    @router.get("/api/knowledge-graph/share/recipient-key")
+    async def share_recipient_key(request: Request):
+        """This Brain's X25519 receiving key, for a sender to seal a bundle to.
+
+        Public by construction — a public key encrypts, it does not decrypt —
+        so handing it out is the whole point. Still admin-gated and still
+        behind the share flag, because minting the key is a decision to
+        participate in sharing at all.
+        """
+        require_admin(request)
+        _require_service(request)
+        try:
+            return service.recipient_key()
+        except PermissionError:
+            raise http_error(403, "portability.brain_network_disabled", resolve_language(request))
+
     @router.post("/api/knowledge-graph/share/archive")
     async def share_archive(req: SubgraphArchiveRequest, request: Request):
         """Same bundle, written as an encrypted ``.latticebrain`` file."""
@@ -277,8 +301,14 @@ def create_portability_router(
         body = req.model_dump()
         path = body.pop("path")
         passphrase = body.pop("passphrase")
+        recipient_public_key = body.pop("recipient_public_key")
         try:
-            return service.export_subgraph_archive(path, passphrase=passphrase, **body)
+            return service.export_subgraph_archive(
+                path,
+                passphrase=passphrase,
+                recipient_public_key=recipient_public_key,
+                **body,
+            )
         except PermissionError:
             raise http_error(403, "portability.brain_network_disabled", resolve_language(request))
         except (ValueError, RuntimeError) as exc:
@@ -294,8 +324,13 @@ def create_portability_router(
         try:
             artifact = req.artifact
             if artifact is None:
-                if not req.path or not req.passphrase:
-                    raise ValueError("Provide an artifact, or a path with its passphrase.")
+                if not req.path:
+                    raise ValueError(
+                        "Provide an artifact, or the path of a bundle on disk."
+                    )
+                # A sealed bundle needs no passphrase — the envelope says which
+                # mechanism it used and the service refuses if the wrong one is
+                # supplied, so the route does not have to guess here.
                 artifact = service.read_subgraph_archive(req.path, passphrase=req.passphrase)
             return service.import_subgraph_proposals(
                 artifact,

package/latticeai/api/review_queue.py

@@ -70,6 +70,39 @@ class ReviewCounts(BaseModel):
     pending_by_source: Dict[str, int] = Field(default_factory=dict)
 
 
+class BulkActionRequest(BaseModel):
+    """Decide several review items at once, named explicitly.
+
+    ``ids`` is required and never defaults to "everything pending": a bulk
+    action whose scope is implicit is how an inbox gets emptied by accident.
+    """
+
+    ids: List[str] = Field(default_factory=list)
+    reason: str = ""
+
+
+class BulkActionOutcome(BaseModel):
+    """Per-item verdict, so a partial success is legible rather than a total."""
+
+    id: str
+    status: str  # ok | not_found | conflict | failed
+    item_status: Optional[str] = None
+    detail: Optional[str] = None
+
+
+class BulkActionResult(BaseModel):
+    action: str
+    requested: int
+    succeeded: int
+    failed: int
+    results: List[BulkActionOutcome] = Field(default_factory=list)
+
+
+#: Ceiling on one bulk call. Large enough for "clear today's inbox", small
+#: enough that one request cannot walk the whole table inside a web worker.
+BULK_ACTION_CAP = 200
+
+
 def create_review_queue_router(
     *,
     service: ReviewQueueService,
@@ -123,6 +156,19 @@ def create_review_queue_router(
         scope = gate_read(request)
         return service.counts(workspace_id=scope, user_email=user)
 
+    # NOTE: declared *before* /automation/reviews/{item_id} for the same reason
+    # "counts" is — routes match in declaration order, so a later /bulk/... would
+    # be swallowed by the {item_id} matcher and answer 404 for a missing item.
+    @router.post("/automation/reviews/bulk/approve", response_model=BulkActionResult)
+    async def bulk_approve(req: BulkActionRequest, request: Request):
+        """Approve several items, reporting each one's outcome individually."""
+        return _bulk(request, req, "approve")
+
+    @router.post("/automation/reviews/bulk/dismiss", response_model=BulkActionResult)
+    async def bulk_dismiss(req: BulkActionRequest, request: Request):
+        """Dismiss several items, reporting each one's outcome individually."""
+        return _bulk(request, req, "dismiss")
+
     @router.get("/automation/reviews/{item_id}", response_model=ReviewItem)
     async def get_item(item_id: str, request: Request):
         require_user(request)
@@ -205,6 +251,86 @@ def create_review_queue_router(
     async def unsnooze_item(item_id: str, request: Request):
         return _act(request, item_id, "unsnooze")
 
+    def _bulk(request: Request, req: BulkActionRequest, action: str) -> Dict[str, Any]:
+        """One transition applied N times through the *same* single-item guard.
+
+        Deliberately not a bulk UPDATE. Every id goes through the ordinary
+        service call, so an already-approved item still 409s, a
+        ``change_proposal`` still applies its staged content, and the audit
+        trail records N decisions — because that is what happened. A failure
+        on one id never aborts the rest, and the response says exactly which
+        ones did not land instead of returning a single number the caller has
+        to interpret.
+        """
+        user = require_user(request)
+        scope = gate_write(request)
+        language = resolve_language(request)
+        wanted = [str(item).strip() for item in req.ids if str(item).strip()]
+        if not wanted:
+            raise http_error(422, "review.bulk_ids_required", language)
+        if len(wanted) > BULK_ACTION_CAP:
+            raise http_error(422, "review.bulk_too_many", language, cap=BULK_ACTION_CAP)
+        results: List[Dict[str, Any]] = []
+        succeeded = 0
+        for item_id in wanted:
+            outcome = _bulk_one(request, item_id, action, user=user, scope=scope, reason=req.reason)
+            if outcome["status"] == "ok":
+                succeeded += 1
+            results.append(outcome)
+        return {
+            "action": action,
+            "requested": len(wanted),
+            "succeeded": succeeded,
+            "failed": len(wanted) - succeeded,
+            "results": results,
+        }
+
+    def _bulk_one(
+        request: Request,
+        item_id: str,
+        action: str,
+        *,
+        user: str,
+        scope: Optional[str],
+        reason: str,
+    ) -> Dict[str, Any]:
+        try:
+            if action == "dismiss":
+                item = service.dismiss(item_id, workspace_id=scope, reason=reason or None)
+            else:
+                item = _approve_one(request, item_id, user=user, scope=scope)
+        except (FileNotFoundError, KeyError):
+            return {"id": item_id, "status": "not_found", "detail": None}
+        except InvalidReviewTransition as exc:
+            return {"id": item_id, "status": "conflict", "detail": str(exc)}
+        except ProposalConflictError as exc:
+            return {"id": item_id, "status": "conflict", "detail": str(exc)}
+        except HTTPException as exc:
+            return {
+                "id": item_id,
+                "status": "conflict" if exc.status_code == 409 else "failed",
+                "detail": str(exc.detail),
+            }
+        except ValueError as exc:
+            return {"id": item_id, "status": "failed", "detail": str(exc)}
+        append_audit_event(f"review_item_{action}", user_email=user, item_id=item_id)
+        return {"id": item_id, "status": "ok", "item_status": item.get("status"), "detail": None}
+
+    def _approve_one(
+        request: Request, item_id: str, *, user: str, scope: Optional[str]
+    ) -> Dict[str, Any]:
+        """Approve exactly the way the single-item route does, staged content included."""
+        if change_proposals is not None:
+            stored = service.get(item_id, workspace_id=scope)
+            if stored.get("source") == "change_proposal":
+                if stored.get("effective_status") not in ("pending", "snoozed"):
+                    raise InvalidReviewTransition("approve", str(stored.get("status")))
+                applied = change_proposals.approve_and_apply(
+                    item_id, user_email=user, workspace_id=scope
+                )
+                return dict(applied["item"])
+        return service.approve(item_id, workspace_id=scope)
+
     @router.post("/automation/reviews/{item_id}/run_now", response_model=ReviewItem)
     async def run_now_item(item_id: str, request: Request):
         user = require_user(request)

package/latticeai/api/search.py

@@ -25,6 +25,11 @@ class HybridSearchRequest(SearchRequest):
     vector_limit: int = 30
     graph_limit: int = 30
     weights: Optional[Dict[str, float]] = None
+    #: Opt in to scoring this text query against the *image* index too
+    #: (v11.2.0). Only possible when a shared-space vision model is
+    #: configured; when it is not, the response says so instead of quietly
+    #: returning the text-only ranking as if fusion had happened.
+    image_fusion: bool = False
 
 
 class GraphNodeRequest(BaseModel):
@@ -106,17 +111,26 @@ def create_search_router(
                 vector_limit=req.vector_limit,
                 graph_limit=req.graph_limit,
                 weights=req.weights or DEFAULT_HYBRID_WEIGHTS,
+                image_fusion=req.image_fusion,
             )
         except ValueError as exc:
             _raise_graph_error(exc)
 
     @router.get("/api/search/hybrid")
-    async def hybrid_search_get(q: str, request: Request, limit: int = 30) -> Dict[str, Any]:
+    async def hybrid_search_get(
+        q: str, request: Request, limit: int = 30, image_fusion: bool = False,
+    ) -> Dict[str, Any]:
         try:
-            return _guarded(request).hybrid_search(q, limit=limit)
+            return _guarded(request).hybrid_search(q, limit=limit, image_fusion=image_fusion)
         except ValueError as exc:
             _raise_graph_error(exc)
 
+    @router.get("/api/search/image-query")
+    async def image_query_status(request: Request) -> Dict[str, Any]:
+        """Whether a typed question can reach the image index on this install."""
+        require_user(request)
+        return service.image_query_status()
+
     @router.post("/api/search/keyword")
     async def keyword_search(req: SearchRequest, request: Request) -> Dict[str, Any]:
         try:

package/latticeai/core/agent.py

@@ -114,7 +114,8 @@ class AgentRunContext:
     __slots__ = ("state", "plan", "transcript", "retry_count",
                  "state_history", "corrections", "final_message", "rollback_log",
                  "executing_model", "reviewing_model", "approved_by_human", "trace",
-                 "on_step", "project_context", "permission_mode")
+                 "on_step", "project_context", "permission_mode",
+                 "self_model_summary")
 
     def __init__(self) -> None:
         self.state:           AgentState   = AgentState.IDLE
@@ -143,6 +144,12 @@ class AgentRunContext:
         # per-tool gate in the same run agree; ``None`` falls back to the
         # process-wide resolver on ``deps``.
         self.permission_mode: Optional[str] = None
+        # Self-Model summary resolved once per run (v11.2.0). The executor
+        # prompt is rebuilt on every turn of the loop; reading the profile
+        # once and reusing it keeps a graph query off that hot path — and
+        # keeps every turn of one run describing the same person. ``None``
+        # means "not resolved yet"; ``""`` is a resolved, empty profile.
+        self.self_model_summary: Optional[str] = None
 
 
 @dataclass
@@ -242,6 +249,17 @@ class AgentDeps:
     # which is exactly the pre-9.9.8 behaviour.
     permission_mode: Any = None
 
+    # ── Self-Model port (optional, v11.2.0) ──────────────────────────
+    # What the Brain has learned about its owner, injected into the executor
+    # prompt. Either a fixed string or a resolver callable taking
+    # ``user_email``/``workspace_id`` scope kwargs (or none at all). 11.1.0
+    # built ``executor_prompt_for(self_model_summary=…)`` and then had nothing
+    # to pass it, because the runtime held its executor prompt as a fixed
+    # string; this is the port that was missing. ``None`` — and an empty
+    # summary — produce exactly the prompt bytes the loop produced before it
+    # existed.
+    self_model_summary: Any = None
+
 
 class SingleAgentRuntime:
     """Drives the agent state machine over injected :class:`AgentDeps`."""
@@ -608,6 +626,41 @@ class SingleAgentRuntime:
 
         ctx.state = AgentState.VERIFYING
 
+    def _self_model_summary(
+        self, ctx: AgentRunContext, current_user: str, request_workspace: Optional[str]
+    ) -> str:
+        """What this Brain knows about its owner, resolved once per run.
+
+        The port may be a plain string or a resolver taking scope kwargs — the
+        same two shapes ``permission_mode`` accepts, so there is one convention
+        for "a value or a way to get one". Anything that goes wrong yields an
+        empty summary: prompt assembly must not fail because a profile could
+        not be read, and an empty summary is byte-identical to having no port
+        at all.
+        """
+        if ctx.self_model_summary is not None:
+            return ctx.self_model_summary
+        source = self.deps.self_model_summary
+        summary = ""
+        if source is not None:
+            try:
+                if callable(source):
+                    try:
+                        summary = source(
+                            user_email=current_user or None,
+                            workspace_id=request_workspace,
+                        )
+                    except TypeError:
+                        # A resolver that takes no scope arguments is allowed.
+                        summary = source()
+                else:
+                    summary = source
+            except Exception:  # noqa: BLE001 — a profile is never worth a failed run
+                logging.debug("agent: self-model summary unavailable", exc_info=True)
+                summary = ""
+        ctx.self_model_summary = str(summary or "").strip()
+        return ctx.self_model_summary
+
     def _executor_context(
         self, ctx: AgentRunContext, req: Any, lang_hint: str,
         current_user: str, request_workspace: Optional[str],
@@ -650,7 +703,7 @@ class SingleAgentRuntime:
             # v11.1.0: the executor prompt carries profile-aware file-writing
             # hints, because "wrote nothing at all" was the weak-model failure
             # mode the loop could not repair after the fact.
-            f"{executor_prompt_for(d.executor_prompt, profile=profile)}\n\n"
+            f"{executor_prompt_for(d.executor_prompt, profile=profile, self_model_summary=self._self_model_summary(ctx, current_user, request_workspace))}\n\n"
             f"[LANGUAGE HINT: {lang_hint}]\n"
             f"Workspace root: {d.agent_root}{self._project_block(ctx)}\n\n"
             f"PLAN:\n{json.dumps(ctx.plan, ensure_ascii=False)}{written_hint}\n\n"