ltcai 11.0.1 → 11.1.0

package/lattice_brain/runtime/multi_agent.py

@@ -49,7 +49,7 @@ from typing import Any, Callable, Dict, List, Optional
 from ..utils import now_iso as _now
 from .contracts import multi_agent_contract
 
-MULTI_AGENT_VERSION = "11.0.1"
+MULTI_AGENT_VERSION = "11.1.0"
 
 AGENT_ROLES = ("researcher", "planner", "executor", "reviewer", "release")
 CORE_PIPELINE = ("planner", "executor", "reviewer")

package/lattice_brain/self_model.py

@@ -37,7 +37,7 @@ import hashlib
 import json
 import logging
 import re
-from typing import Any, Callable, Dict, List, Optional, Sequence, Tuple
+from typing import Any, Callable, Dict, Iterable, List, Optional, Sequence, Tuple
 
 from .context import approx_tokens
 from .synthesis import ProposalDesk
@@ -127,7 +127,7 @@ _PATTERNS: Tuple[Tuple[str, "re.Pattern[str]", int, float, str], ...] = (
     (
         "preference",
         re.compile(
-            r"(?:나는|저는|내가|제가)\s*(?P<v>[^\n.。]+?)"
+            r"(?:나는|저는|내가|제가)\s*(?P<v>[^\n.。]+?)\s*(?:을|를|이|가)?"
             r"\s*(?:좋아|선호|싫어)(?:합니다|한다|해요|해|하고)"
         ),
         1,
@@ -145,11 +145,10 @@ _PATTERNS: Tuple[Tuple[str, "re.Pattern[str]", int, float, str], ...] = (
         "en_first_person_preference",
     ),
     (
+        # The frequency word stays inside the capture: "회고를 씁니다" is a
+        # sentence, "매일 회고를 씁니다" is a habit.
         "habit",
-        re.compile(
-            r"(?:매일|매주|매달|아침마다|항상|늘)\s*(?P<v>[^\n.。]+?)"
-            r"\s*(?:합니다|한다|해요|해)(?:\b|[\s.。!?]|$)"
-        ),
+        re.compile(r"(?P<v>(?:매일|매주|매달|아침마다|항상|늘)\s*[^\n.。!?]+)"),
         1,
         0.65,
         "ko_routine",
@@ -157,7 +156,8 @@ _PATTERNS: Tuple[Tuple[str, "re.Pattern[str]", int, float, str], ...] = (
     (
         "habit",
         re.compile(
-            r"\bI\s+(?:always|usually|every\s+(?:morning|day|week))\s+(?P<v>[^\n.!?]+)",
+            r"\bI\s+(?P<v>(?:always|usually|every\s+(?:morning|day|week))"
+            r"\s+[^\n.!?]+)",
             re.IGNORECASE,
         ),
         1,
@@ -205,7 +205,17 @@ _PATTERNS: Tuple[Tuple[str, "re.Pattern[str]", int, float, str], ...] = (
 
 
 class SelfModelError(ValueError):
-    """Raised when a Self-Model operation cannot be carried out as asked."""
+    """Raised when a Self-Model operation cannot be carried out as asked.
+
+    Carries a machine-readable ``code`` alongside the developer message: Brain
+    Core cannot reach the server's message catalog (isolation), so the API
+    layer translates the code instead of forwarding an English sentence to a
+    Korean user.
+    """
+
+    def __init__(self, message: str, *, code: str = "invalid") -> None:
+        self.code = code
+        super().__init__(message)
 
 
 # ── extraction (deterministic) ───────────────────────────────────────────────
@@ -347,12 +357,18 @@ def apply_self_model_proposal(
     """
     item = review_queue.get(item_id, workspace_id=workspace_id)
     if str(item.get("kind")) != SELF_MODEL_KIND:
-        raise SelfModelError(f"review item {item_id} is not a Self-Model proposal")
+        raise SelfModelError(
+            f"review item {item_id} is not a Self-Model proposal",
+            code="not_a_proposal",
+        )
     fact = dict((item.get("payload") or {}).get("fact") or {})
     kind = str(fact.get("kind") or "")
     text = _normalize(str(fact.get("text") or ""))
     if kind not in FACT_NODE_TYPES or not text:
-        raise SelfModelError(f"review item {item_id} carries no Self-Model fact")
+        raise SelfModelError(
+            f"review item {item_id} carries no Self-Model fact",
+            code="empty_proposal",
+        )
     approved = review_queue.approve(item_id, workspace_id=workspace_id)
     node = _write_fact(
         store,
@@ -386,9 +402,11 @@ def upsert_self_model_fact(
     kind = str(kind or "").strip().lower()
     value = _normalize(text)
     if kind not in FACT_NODE_TYPES:
-        raise SelfModelError(f"kind must be one of {sorted(FACT_NODE_TYPES)}")
+        raise SelfModelError(
+            f"kind must be one of {sorted(FACT_NODE_TYPES)}", code="invalid_kind"
+        )
     if not value:
-        raise SelfModelError("a Self-Model fact needs text")
+        raise SelfModelError("a Self-Model fact needs text", code="text_required")
     return _write_fact(
         store,
         kind=kind,
@@ -405,14 +423,14 @@ def delete_self_model_fact(store: Any, node_id: str) -> Dict[str, Any]:
     """Remove one fact (or the whole root) from the subgraph, permanently."""
     identifier = str(node_id or "").strip()
     if not identifier.startswith(SELF_ID_PREFIX):
-        raise SelfModelError(f"not a Self-Model node: {identifier}")
+        raise SelfModelError(f"not a Self-Model node: {identifier}", code="not_self_model")
     with store._connect() as conn:
         deleted = conn.execute(
             "DELETE FROM nodes WHERE id=?", (identifier,)
         ).rowcount
         conn.execute("DELETE FROM nodes_v2 WHERE id=?", (identifier,))
     if not deleted:
-        raise SelfModelError(f"Self-Model node not found: {identifier}")
+        raise SelfModelError(f"Self-Model node not found: {identifier}", code="not_found")
     return {"status": "ok", "id": identifier, "deleted_at": now_iso()}
 
 
@@ -420,13 +438,18 @@ def delete_self_model_fact(store: Any, node_id: str) -> Dict[str, Any]:
 
 
 def list_self_model(
-    store: Any, *, workspace_id: Optional[str] = None
+    store: Any,
+    *,
+    workspace_id: Optional[str] = None,
+    allowed_workspaces: Optional[Iterable[str]] = None,
 ) -> Dict[str, Any]:
     """Every fact the Brain holds about its owner, grouped for display."""
-    facts = _read_facts(store, workspace_id=workspace_id)
+    facts = _read_facts(
+        store, workspace_id=workspace_id, allowed_workspaces=allowed_workspaces
+    )
     counts: Dict[str, int] = {kind: 0 for kind in KIND_ORDER}
     for fact in facts:
-        counts[fact["kind"]] = counts.get(fact["kind"], 0) + 1
+        counts[fact["kind"]] += 1
     return {
         "available": True,
         "facts": facts,
@@ -442,6 +465,7 @@ def self_model_summary(
     *,
     limit_tokens: int = DEFAULT_SUMMARY_TOKENS,
     workspace_id: Optional[str] = None,
+    allowed_workspaces: Optional[Iterable[str]] = None,
 ) -> str:
     """Plain-text Self-Model summary for injection into a model's context.
 
@@ -450,7 +474,9 @@ def self_model_summary(
     An empty subgraph returns ``""`` — the caller injects nothing rather than a
     header with nothing under it.
     """
-    facts = _read_facts(store, workspace_id=workspace_id)
+    facts = _read_facts(
+        store, workspace_id=workspace_id, allowed_workspaces=allowed_workspaces
+    )
     if not facts or limit_tokens <= 0:
         return ""
     header = "사용자에 대해 확인된 사실:"
@@ -523,8 +549,28 @@ def _write_fact(
     }
 
 
+def _allowed_set(
+    workspace_id: Optional[str], allowed_workspaces: Optional[Iterable[str]]
+) -> Optional[set]:
+    """Normalize the two scoping spellings into one allow-set (``None`` = all).
+
+    ``allowed_workspaces`` is the scoping vocabulary the graph reads already
+    use (``filter_scoped_nodes``); ``workspace_id`` is the single-scope sugar
+    the API surfaces speak. A fact with no workspace is personal-global and
+    stays visible in both.
+    """
+    if allowed_workspaces is not None:
+        return {str(item) for item in allowed_workspaces if item}
+    if workspace_id is None:
+        return None
+    return {str(workspace_id)}
+
+
 def _read_facts(
-    store: Any, *, workspace_id: Optional[str] = None
+    store: Any,
+    *,
+    workspace_id: Optional[str] = None,
+    allowed_workspaces: Optional[Iterable[str]] = None,
 ) -> List[Dict[str, Any]]:
     """Fact rows for a workspace, ordered deterministically (kind, then text).
 
@@ -533,6 +579,10 @@ def _read_facts(
     both read modes. A store that cannot be read yields no facts rather than
     raising into a prompt-assembly path.
     """
+    if not hasattr(store, "_connect"):
+        # Not a Brain store (a doc-generation seam may be handed a stand-in).
+        # There is no profile to read, and that is not an error worth logging.
+        return []
     try:
         with store._connect() as conn:
             rows = conn.execute(
@@ -544,11 +594,12 @@ def _read_facts(
         logger.exception("self-model read failed")
         return []
     facts = [fact for fact in (_row_to_fact(row) for row in rows) if fact]
-    if workspace_id is not None:
+    allowed = _allowed_set(workspace_id, allowed_workspaces)
+    if allowed is not None:
         facts = [
             fact
             for fact in facts
-            if fact["workspace_id"] in (None, "", str(workspace_id))
+            if not fact["workspace_id"] or str(fact["workspace_id"]) in allowed
         ]
     return sorted(facts, key=lambda fact: (KIND_ORDER.index(fact["kind"]), fact["text"]))
 
@@ -584,6 +635,7 @@ def summary_for_prompt(
     *,
     limit_tokens: int = DEFAULT_SUMMARY_TOKENS,
     workspace_id: Optional[str] = None,
+    allowed_workspaces: Optional[Iterable[str]] = None,
 ) -> str:
     """:func:`self_model_summary` that never raises — the injection seam.
 
@@ -592,7 +644,10 @@ def summary_for_prompt(
     """
     try:
         return self_model_summary(
-            store, limit_tokens=limit_tokens, workspace_id=workspace_id
+            store,
+            limit_tokens=limit_tokens,
+            workspace_id=workspace_id,
+            allowed_workspaces=allowed_workspaces,
         )
     except Exception:  # noqa: BLE001 — see docstring
         logger.exception("self-model summary failed")

package/latticeai/__init__.py

@@ -1,3 +1,3 @@
 """Lattice AI - modular server package."""
 
-__version__ = "11.0.1"
+__version__ = "11.1.0"

package/latticeai/api/memory.py

@@ -3,17 +3,26 @@
 Exposes :class:`~latticeai.services.memory_service.MemoryService` so the /app
 Memory view can inspect every memory tier, recall across them, and run manager
 operations (prune / compact / rebuild / clear). Full paths in decorators.
+
+v11.1.0 adds the Self-Model surface (Track 4) on the same factory: the profile
+the Brain holds about its owner is *memory*, so it is read, edited and deleted
+here rather than behind a router of its own. Ownership is the whole point —
+extraction only ever proposes (``/self-model/propose`` →  Review Center →
+``/self-model/apply``), while the user's own edits and deletions write
+directly.
 """
 
 from __future__ import annotations
 
-from typing import Callable, List, Optional
+from typing import Any, Callable, List, Optional
 
 from fastapi import APIRouter, HTTPException, Request
 from pydantic import BaseModel
 
+from lattice_brain.self_model import SelfModelError
 from latticeai.core.messages import http_error, resolve_language
 from latticeai.services.memory_service import MemoryService
+from latticeai.services.self_model_service import SelfModelService
 
 
 class RecallRequest(BaseModel):
@@ -35,6 +44,49 @@ class ClearRequest(BaseModel):
     confirm: bool = False
 
 
+#: Self-Model failure codes → catalog ids. Brain Core raises codes (it cannot
+#: import the catalog); the answer a person reads is chosen here, in their
+#: language. An unknown code degrades to the generic entry rather than leaking
+#: an English developer sentence.
+SELF_MODEL_MESSAGES = {
+    "invalid_kind": "self_model.invalid_kind",
+    "text_required": "self_model.text_required",
+    "not_found": "self_model.not_found",
+    "not_self_model": "self_model.not_self_model",
+    "not_a_proposal": "self_model.not_a_proposal",
+    "empty_proposal": "self_model.empty_proposal",
+    "graph_unavailable": "self_model.graph_unavailable",
+    "queue_unavailable": "self_model.queue_unavailable",
+}
+
+
+def _self_model_error(exc: SelfModelError, request: Request) -> HTTPException:
+    status = 404 if exc.code == "not_found" else 400
+    message_id = SELF_MODEL_MESSAGES.get(exc.code, "self_model.invalid")
+    return http_error(status, message_id, resolve_language(request))
+
+
+class SelfModelFactRequest(BaseModel):
+    """A fact the user states about themselves (user-initiated direct write)."""
+
+    kind: str
+    text: str
+
+
+class SelfModelProposeRequest(BaseModel):
+    """Text to read for candidate facts. Output is proposals, never writes."""
+
+    text: str = ""
+    source: str = ""
+    max_proposals: int = 5
+
+
+class SelfModelApplyRequest(BaseModel):
+    """Approve one Self-Model proposal and write the fact it carries."""
+
+    item_id: str
+
+
 def create_memory_router(
     *,
     service: MemoryService,
@@ -44,8 +96,13 @@ def create_memory_router(
     gate_write: Callable[[Request], Optional[str]],
     append_audit_event: Callable[..., None],
     active_model_getter: Callable[[], str] | None = None,
+    self_model: Any = None,
 ) -> APIRouter:
     router = APIRouter()
+    # Derived from the memory service by default (graph + review queue), so the
+    # Self-Model routes exist on every build and report honestly when this
+    # Brain has no graph rather than disappearing from the API surface.
+    profile = self_model or SelfModelService(memory_service=service)
 
     @router.get("/api/memory/manager")
     async def memory_manager(request: Request):
@@ -140,4 +197,74 @@ def create_memory_router(
         append_audit_event("memory_clear", user_email=user, scope=req.scope)
         return result
 
+    # ── Self-Model (v11.1.0) ─────────────────────────────────────────────
+
+    @router.get("/api/memory/self-model")
+    async def self_model_profile(request: Request):
+        """What the Brain believes about its owner, and the injected summary."""
+        user = require_user(request)
+        scope = gate_read(request)
+        return profile.profile(user_email=user, workspace_id=scope)
+
+    @router.post("/api/memory/self-model")
+    async def self_model_upsert(req: SelfModelFactRequest, request: Request):
+        """Add or correct one fact directly — the user owns their profile."""
+        user = require_user(request)
+        scope = gate_write(request)
+        try:
+            fact = profile.upsert(kind=req.kind, text=req.text, workspace_id=scope)
+        except SelfModelError as exc:
+            raise _self_model_error(exc, request) from exc
+        append_audit_event(
+            "self_model_upsert", user_email=user, node_id=fact["id"], kind=fact["kind"]
+        )
+        return fact
+
+    @router.delete("/api/memory/self-model/{node_id}")
+    async def self_model_delete(node_id: str, request: Request):
+        """Forget one fact about the user, permanently."""
+        user = require_user(request)
+        gate_write(request)
+        try:
+            result = profile.delete(node_id)
+        except SelfModelError as exc:
+            raise _self_model_error(exc, request) from exc
+        append_audit_event("self_model_delete", user_email=user, node_id=node_id)
+        return result
+
+    @router.post("/api/memory/self-model/propose")
+    async def self_model_propose(req: SelfModelProposeRequest, request: Request):
+        """Read text for candidate facts; every hit becomes a review proposal."""
+        user = require_user(request)
+        scope = gate_write(request)
+        result = profile.propose(
+            req.text,
+            source=req.source or None,
+            user_email=user,
+            workspace_id=scope,
+            max_proposals=req.max_proposals,
+        )
+        append_audit_event(
+            "self_model_proposed",
+            user_email=user,
+            proposed=result.get("proposed_count", 0),
+        )
+        return result
+
+    @router.post("/api/memory/self-model/apply")
+    async def self_model_apply(req: SelfModelApplyRequest, request: Request):
+        """Approve a proposal and write the fact it carries into the graph."""
+        user = require_user(request)
+        scope = gate_write(request)
+        try:
+            result = profile.apply(req.item_id, workspace_id=scope)
+        except SelfModelError as exc:
+            raise _self_model_error(exc, request) from exc
+        except (KeyError, FileNotFoundError) as exc:
+            raise http_error(404, "review.item_not_found", resolve_language(request)) from exc
+        append_audit_event(
+            "self_model_applied", user_email=user, item_id=req.item_id
+        )
+        return result
+
     return router

package/latticeai/core/agent.py

@@ -62,6 +62,7 @@ from latticeai.core.agent_permission import (
     resolve_deps_mode,
 )
 from latticeai.core.agent_profiles import AgentProfile, profile_for_model
+from latticeai.core.agent_prompts import executor_prompt_for
 
 # The state vocabulary and the pure helpers live in sibling modules so this one
 # holds only the loop. They are re-exported (see ``__all__``) because callers —
@@ -646,7 +647,10 @@ class SingleAgentRuntime:
             + "\n".join(f"- {path}" for path in written)
         ) if written else ""
         return (
-            f"{d.executor_prompt}\n\n"
+            # 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"[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"

package/latticeai/core/agent_prompts.py

@@ -2,6 +2,8 @@
 
 from __future__ import annotations
 
+from typing import Any, Optional
+
 from latticeai.core.tool_registry import TOOL_CATALOG_BRIEF
 
 PLANNER_PROMPT = """You are the PLANNER role in Lattice AI's multi-role agent harness.
@@ -103,3 +105,67 @@ Rules:
 
 
 AGENT_SYSTEM_PROMPT = EXECUTOR_PROMPT
+
+
+# ── file-writing hints (v11.1.0) ────────────────────────────────────────────
+#
+# A 1–4B local model does not fail at *writing a file*; it fails at deciding
+# it is allowed to write one yet. The compact profile already gives that model
+# a shorter transcript and an earlier escalation; these hints give it the two
+# things the transcripts showed it missing most: a concrete order of
+# operations, and permission to write the file on the very next turn.
+#
+# The strings are deliberately additive — ``EXECUTOR_PROMPT`` is untouched, so
+# every caller that wants today's prompt keeps getting exactly today's prompt.
+
+FILE_TASK_HINTS = """
+FILE TASKS — how to actually finish one:
+- If the request names a file to create, your FIRST action is write_file with
+  the complete content. Do not read, list, or plan around it first.
+- args.path is a workspace-relative path (e.g. "report.md"), never absolute.
+- args.content is the WHOLE file, not a fragment and not a description of it.
+- After the write result appears in the transcript, verify once (read_file),
+  then finish with {"action": "final", ...}.
+"""
+
+COMPACT_FILE_TASK_HINTS = """
+FILE TASKS (short form):
+1. write_file {"path": "<name>", "content": "<the whole file>"}
+2. read_file to confirm it exists
+3. {"action": "final", "message": "..."}
+Write the file on your next turn. Do not explain first.
+"""
+
+
+def file_task_hints(profile: Any = None) -> str:
+    """The file-writing hints for a loop profile.
+
+    ``profile`` is an :class:`~latticeai.core.agent_profiles.AgentProfile`, its
+    name, or ``None``. The compact profile gets the numbered short form (small
+    models follow a list better than prose); everything else gets the standard
+    hints, so a strong model's prompt grows by four sentences and no rules.
+    """
+    name = getattr(profile, "name", profile)
+    if str(name or "").strip().lower() == "compact":
+        return COMPACT_FILE_TASK_HINTS.strip()
+    return FILE_TASK_HINTS.strip()
+
+
+def executor_prompt_for(
+    base: str = EXECUTOR_PROMPT,
+    *,
+    profile: Any = None,
+    self_model_summary: Optional[str] = None,
+) -> str:
+    """``base`` plus the file hints, and the Self-Model summary when there is one.
+
+    The injection rule is the same one the context builder follows: an empty
+    (or missing) Self-Model adds nothing at all — no header, no placeholder —
+    so a Brain that knows nothing about its owner produces the prompt it
+    always produced.
+    """
+    parts = [str(base or "").rstrip(), file_task_hints(profile)]
+    summary = str(self_model_summary or "").strip()
+    if summary:
+        parts.append(f"ABOUT THE USER (from their Brain — honour it, do not restate it):\n{summary}")
+    return "\n\n".join(parts)

package/latticeai/core/context_builder.py

@@ -27,6 +27,7 @@ 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.self_model import DEFAULT_SUMMARY_TOKENS, summary_for_prompt
 
 _CLEAN_RE = re.compile(r"\s+")
 
@@ -35,6 +36,20 @@ _CLEAN_RE = re.compile(r"\s+")
 # other on the same Brain.
 DEFAULT_DOCUMENT_CONTEXT_BUDGET = 2000
 
+# ── Self-Model injection (v11.1.0) ──────────────────────────────────────────
+# What the Brain knows about its owner rides along with the knowledge, so a
+# generated document sounds like the person who asked for it. Three rules keep
+# it from becoming another thing that can go wrong:
+#   1. an empty Self-Model injects *nothing* — no header, no blank section;
+#   2. the block never takes more than half the context budget, so the profile
+#      can never crowd out the knowledge the request is actually about;
+#   3. the returned contract is unchanged — same keys, same
+#      ``context_quality`` shape, one extra trace section only when a block
+#      was really injected.
+SELF_MODEL_SECTION_TITLE = "사용자 프로필"
+SELF_MODEL_TRACE_SOURCE = "self_model"
+SELF_MODEL_SECTION_HEADER = f"### 🙋 {SELF_MODEL_SECTION_TITLE}\n\n"
+
 
 def _clean(text: str, max_len: int = 700) -> str:
     return _CLEAN_RE.sub(" ", str(text or "")).strip()[:max_len]
@@ -72,6 +87,55 @@ def _fit_to_budget(context_md: str, budget: int) -> tuple:
     return head.rstrip(), True
 
 
+def _self_model_budget(budget: int, limit_tokens: int) -> int:
+    """Tokens the profile block may use — never more than half the budget."""
+    if budget <= 0:
+        return limit_tokens
+    return min(limit_tokens, budget // 2)
+
+
+def _self_model_block(
+    kg_store,
+    *,
+    enabled: bool,
+    budget: int,
+    limit_tokens: int,
+    allowed_workspaces,
+) -> str:
+    """Rendered profile section, or ``""`` when there is nothing to inject.
+
+    The section header is charged to the same allowance as the summary, so the
+    *rendered block* — not just its text — honours the ceiling.
+    """
+    allowance = _self_model_budget(budget, limit_tokens) - approx_tokens(
+        SELF_MODEL_SECTION_HEADER
+    )
+    if not enabled or allowance <= 0:
+        return ""
+    summary = summary_for_prompt(
+        kg_store, limit_tokens=allowance, allowed_workspaces=allowed_workspaces
+    )
+    if not summary:
+        return ""
+    return f"{SELF_MODEL_SECTION_HEADER}{summary}"
+
+
+def _with_self_model(block: str, context_md: str) -> str:
+    """Prepend the profile block to rendered knowledge (either may be empty)."""
+    return "\n\n".join(part for part in (block, context_md) if part)
+
+
+def _self_model_trace(block: str) -> List[Dict[str, Any]]:
+    if not block:
+        return []
+    return [{
+        "name": SELF_MODEL_SECTION_TITLE,
+        "source": SELF_MODEL_TRACE_SOURCE,
+        "approx_tokens": approx_tokens(block),
+        "provenance": [],
+    }]
+
+
 def retrieve_context_for_generation(
     kg_store,
     query: str,
@@ -81,6 +145,8 @@ def retrieve_context_for_generation(
     allowed_workspaces=None,
     include_legacy_global: bool = False,
     budget: int = DEFAULT_DOCUMENT_CONTEXT_BUDGET,
+    include_self_model: bool = True,
+    self_model_tokens: int = DEFAULT_SUMMARY_TOKENS,
 ) -> Dict[str, Any]:
     """Knowledge Graph에서 문서 생성에 필요한 컨텍스트를 검색·조합한다.
 
@@ -106,6 +172,21 @@ def retrieve_context_for_generation(
         if allowed_workspaces is not None
         else {}
     )
+    self_model_md = _self_model_block(
+        kg_store,
+        enabled=include_self_model,
+        budget=budget,
+        limit_tokens=self_model_tokens,
+        allowed_workspaces=allowed_workspaces,
+    )
+    # The profile's tokens come out of the same budget, so injecting it can
+    # never push the assembled context over the ceiling the caller asked for.
+    # The blank line that joins the two blocks is counted too — otherwise the
+    # assembled total lands one token over a tight budget.
+    knowledge_budget = budget
+    if self_model_md:
+        knowledge_budget -= approx_tokens(f"{self_model_md}\n\n")
+
     results = kg_store.search_for_document_generation(query, limit=max_results, **scope_kwargs)
     if not results:
         fallback_ctx = kg_store.context_for_query(
@@ -113,7 +194,7 @@ def retrieve_context_for_generation(
             limit=max_results,
             **scope_kwargs,
         )
-        fallback_ctx, trimmed = _fit_to_budget(fallback_ctx or "", budget)
+        fallback_ctx, trimmed = _fit_to_budget(fallback_ctx or "", knowledge_budget)
         # Lexical fallback: the hybrid document search found nothing, so the
         # signal says lexical_only — exactly what chat reports in the same
         # situation, never a quiet downgrade.
@@ -121,16 +202,17 @@ def retrieve_context_for_generation(
             "lexical_only" if fallback_ctx else "none",
             1 if fallback_ctx else 0,
         )
+        assembled = _with_self_model(self_model_md, fallback_ctx)
         return {
             "query": query,
-            "context_markdown": fallback_ctx,
+            "context_markdown": assembled,
             "sources": [],
             "stats": {"method": "fallback", "matches": 0, "budget_trimmed": trimmed},
             "context_quality": quality,
             "trace": {
                 "budget_approx_tokens": budget,
-                "used_approx_tokens": approx_tokens(fallback_ctx),
-                "sections": [{
+                "used_approx_tokens": approx_tokens(assembled),
+                "sections": _self_model_trace(self_model_md) + [{
                     "name": "Knowledge (fallback)",
                     "source": "knowledge",
                     "approx_tokens": approx_tokens(fallback_ctx),
@@ -154,11 +236,12 @@ def retrieve_context_for_generation(
     sections = _build_context_sections(results, extra_nodes_by_id, hop_data.get("edges", []))
     context_md = _render_markdown(query, sections)
     sources = _extract_sources(results)
-    context_md, trimmed = _fit_to_budget(context_md, budget)
+    context_md, trimmed = _fit_to_budget(context_md, knowledge_budget)
+    assembled = _with_self_model(self_model_md, context_md)
 
     return {
         "query": query,
-        "context_markdown": context_md,
+        "context_markdown": assembled,
         "sources": sources,
         "stats": {
             "method": "hybrid",
@@ -171,8 +254,8 @@ def retrieve_context_for_generation(
         "context_quality": context_quality_signal("hybrid", len(results)),
         "trace": {
             "budget_approx_tokens": budget,
-            "used_approx_tokens": approx_tokens(context_md),
-            "sections": [
+            "used_approx_tokens": approx_tokens(assembled),
+            "sections": _self_model_trace(self_model_md) + [
                 {
                     "name": section["title"],
                     "source": "knowledge",
@@ -199,6 +282,7 @@ def _build_context_sections(
 
     docs = [r for r in primary_results if r["type"] in (
         "Document", "File", "SlideDeck", "Spreadsheet", "CodeFile", "Image", "ImageText",
+        "Audio",
     )]
     if docs:
         sections.append({