ltcai 9.9.4 → 9.9.9

package/latticeai/core/workspace_review_items.py

@@ -0,0 +1,107 @@
+"""Review-queue persistence extracted from WorkspaceOSStore (v9.9.6).
+
+Workspace-scoped suggestion inbox: automation/trigger runs write drafts here
+for the user to approve/dismiss/snooze. **Persistence only** — the transition
+policy lives in :mod:`latticeai.services.review_queue`.
+
+Behaviour-preserving move (review 2026-07-27 P2 #8 "대형 모듈 추가 분해 —
+동작 보존 이동 우선"): the store delegates the same method names to this
+collaborator, following the existing ``WorkspaceRuns`` / ``WorkspaceGraphTrace``
+pattern.
+"""
+from __future__ import annotations
+
+from typing import Any, Dict, List, Optional
+
+from .timeutil import now_iso as _now
+from .workspace_os_utils import _json_hash, _listify
+
+
+class WorkspaceReviewItems:
+    def __init__(self, store: Any):
+        self._store = store
+
+    def __getattr__(self, name: str) -> Any:
+        return getattr(self._store, name)
+
+    def create_review_item(
+        self,
+        *,
+        title: str,
+        summary: str = "",
+        source: str = "workflow_run",
+        kind: str = "suggestion",
+        payload: Optional[Dict[str, Any]] = None,
+        provenance: Optional[Dict[str, Any]] = None,
+        user_email: Optional[str] = None,
+        workspace_id: Optional[str] = None,
+    ) -> Dict[str, Any]:
+        if not str(title or "").strip():
+            raise ValueError("title is required")
+        state = self.load_state()
+        resolved_workspace = self._resolve_scope(workspace_id, state)
+        now = _now()
+        item = {
+            "id": f"review-{_json_hash([title, source, kind, user_email, now])[:16]}",
+            "status": "pending",
+            "title": title,
+            "summary": summary or "",
+            "source": source or "workflow_run",
+            "kind": kind or "suggestion",
+            "payload": dict(payload or {}),
+            "provenance": dict(provenance or {}),
+            "snoozed_until": None,
+            "user_email": user_email,
+            "workspace_id": resolved_workspace,
+            "created_at": now,
+            "updated_at": now,
+        }
+        state.setdefault("review_items", []).append(item)
+        self.save_state(state)
+        self.record_timeline_event(
+            "review", "review_item_created",
+            {"item_id": item["id"], "source": item["source"], "kind": item["kind"]},
+            workspace_id=resolved_workspace,
+        )
+        return item
+
+    def list_review_items(
+        self, *, workspace_id: Optional[str] = None, user_email: Optional[str] = None,
+        source: Optional[str] = None,
+    ) -> List[Dict[str, Any]]:
+        items = self._scoped(_listify(self.load_state().get("review_items")), workspace_id)
+        if user_email:
+            items = [item for item in items if item.get("user_email") in {None, user_email}]
+        if source:
+            items = [item for item in items if item.get("source") == source]
+        return list(reversed(items))
+
+    def get_review_item(self, item_id: str, *, workspace_id: Optional[str] = None) -> Dict[str, Any]:
+        item = next(
+            (it for it in _listify(self.load_state().get("review_items")) if it.get("id") == item_id),
+            None,
+        )
+        if item is None or (workspace_id and self._record_workspace(item) != str(workspace_id)):
+            raise FileNotFoundError(item_id)
+        return item
+
+    def update_review_item(
+        self, item_id: str, *, workspace_id: Optional[str] = None, **fields: Any,
+    ) -> Dict[str, Any]:
+        state = self.load_state()
+        item = next((it for it in _listify(state.get("review_items")) if it.get("id") == item_id), None)
+        if item is None or (workspace_id and self._record_workspace(item) != str(workspace_id)):
+            raise FileNotFoundError(item_id)
+        for key, value in fields.items():
+            item[key] = value
+        item["updated_at"] = _now()
+        self.save_state(state)
+        self.record_timeline_event(
+            "review", "review_item_updated",
+            {"item_id": item_id, "status": item.get("status")},
+            workspace_id=self._record_workspace(item),
+        )
+        return item
+
+
+__all__ = ["WorkspaceReviewItems"]

package/latticeai/integrations/telegram_bot.py

@@ -36,11 +36,13 @@ STATUS_URL     = f"{BASE_URL}/status"
 MODELS_URL     = f"{BASE_URL}/models"
 GRAPH_STATS_URL = f"{BASE_URL}/knowledge-graph/stats"
 UPLOAD_DOC_URL  = f"{BASE_URL}/upload/document"
+PROPOSALS_URL   = f"{BASE_URL}/api/proposals"
 
 AGENT_RESUME_URL      = f"{BASE_URL}/agent/resume"
 AGENT_WORKSPACE       = Path(env_value("LATTICEAI_AGENT_ROOT", "agent_workspace")).resolve()
 
-# Pending plan approvals: context_id → (chat_id, executing_model, reviewing_model)
+# Pending plan approvals keyed by run_id (or legacy context_id).
+# Values: chat_id, models, and the resume credentials (token and/or legacy).
 _bot_pending_plans: dict[str, dict] = {}
 MAX_TELEGRAM_FILE_BYTES = 45 * 1024 * 1024
 INVITE_CODE           = env_value("LATTICEAI_INVITE_CODE")
@@ -296,6 +298,9 @@ MAIN_MENU = {
             {"text": "🔗 웹 UI 열기",           "callback_data": "cmd:web"},
             {"text": "🔌 MCP 도구 목록",        "callback_data": "cmd:mcp"},
         ],
+        [
+            {"text": "🗂 변경 제안 검토",        "callback_data": "cmd:review"},
+        ],
     ]
 }
 
@@ -664,6 +669,176 @@ def collect_generated_files(agent_data):
             files.append((path, target))
     return files
 
+def format_grounding_badge(data, *, language: str = "ko") -> str:
+    """Answer-grounding badge line for a `/chat` reply (v9.9.7).
+
+    Telegram used to show only the answer text, so a reply the Brain could not
+    ground looked identical to one built on real sources. This renders exactly
+    the verdict the server issued — and reports an absent verdict as unknown
+    rather than promoting it to "근거 있음".
+    """
+    if not isinstance(data, dict):
+        return ""
+    grounding = data.get("grounding")
+    if not isinstance(grounding, dict):
+        return ""
+    status = str(grounding.get("status") or "")
+    if not status:
+        return ""
+    korean = not str(language or "ko").startswith("en")
+    cited = [
+        str(item.get("title") or "").strip()
+        for item in (grounding.get("cited") or [])
+        if isinstance(item, dict) and str(item.get("title") or "").strip()
+    ]
+    if status == "supported":
+        head = "✅ 근거 있음" if korean else "✅ grounded"
+        if cited:
+            head += " — " + ", ".join(cited[:3])
+        return head
+    if status in {"unsupported", "no_context"}:
+        head = "⚠️ 근거 없음" if korean else "⚠️ not grounded"
+        reason = str(grounding.get("reason") or "").strip()
+        return f"{head} — {reason}" if reason else head
+    return "❔ 근거 확인 불가" if korean else "❔ grounding unknown"
+
+
+async def send_grounding_badge(client, chat_id, data):
+    text = format_grounding_badge(data)
+    if text:
+        await send_message(client, chat_id, text)
+
+
+def format_proposals(payload) -> list:
+    """`GET /api/proposals` → ``[(item_id, label)]`` for the Review Center.
+
+    Rows without an id are dropped: an un-actionable row is worse than none.
+    """
+    root = payload if isinstance(payload, dict) else {}
+    rows = payload if isinstance(payload, list) else (root.get("items") or [])
+    out = []
+    for raw in rows if isinstance(rows, list) else []:
+        if not isinstance(raw, dict):
+            continue
+        item_id = str(raw.get("id") or "").strip()
+        if not item_id:
+            continue
+        body = raw.get("payload") if isinstance(raw.get("payload"), dict) else {}
+        provenance = raw.get("provenance") if isinstance(raw.get("provenance"), dict) else {}
+        path = str(body.get("path") or provenance.get("path") or "")
+        title = str(raw.get("title") or path or item_id)
+        change_class = str(body.get("change_class") or provenance.get("change_class") or "")
+        label = title if not change_class else f"{title} ({change_class})"
+        out.append((item_id, label))
+    return out
+
+
+async def show_review_center(client, chat_id):
+    """Review Center parity (v9.9.7): staged change proposals with inline
+    approve/reject, using the same `/api/proposals` surface as the web app."""
+    try:
+        async with _server_client() as sc:
+            res = await sc.get(PROPOSALS_URL, timeout=30.0)
+        if res.status_code != 200:
+            await send_message(client, chat_id, f"검토함을 불러오지 못했습니다 ({res.status_code})")
+            return
+        items = format_proposals(res.json())
+    except Exception as exc:
+        await send_message(client, chat_id, f"검토함 조회 실패: {exc}")
+        return
+    if not items:
+        await send_message(client, chat_id, "🗂 검토할 변경 제안이 없습니다.")
+        return
+    lines = ["🗂 변경 제안 (승인해야 적용됩니다)"]
+    keyboard = []
+    for item_id, label in items[:8]:
+        lines.append(f"- {label}")
+        keyboard.append([
+            {"text": f"✅ 승인 — {label}"[:64], "callback_data": f"proposal:approve:{item_id}"[:64]},
+            {"text": "❌ 거절"[:64], "callback_data": f"proposal:reject:{item_id}"[:64]},
+        ])
+    if len(items) > 8:
+        lines.append(f"… 외 {len(items) - 8}건")
+    await send_message(
+        client, chat_id, "\n".join(lines),
+        reply_markup={"inline_keyboard": keyboard},
+    )
+
+
+async def handle_proposal_callback(client, chat_id, data: str):
+    """Apply or reject one staged proposal.
+
+    A 409 means the target file changed since staging — nothing was written,
+    and the user is told exactly that instead of a silent retry.
+    """
+    try:
+        _, decision, item_id = data.split(":", 2)
+    except ValueError:
+        return
+    if not item_id:
+        return
+    suffix = "approve" if decision == "approve" else "reject"
+    url = f"{PROPOSALS_URL}/{item_id}/{suffix}"
+    try:
+        async with _server_client() as sc:
+            res = await sc.post(url, json={}, timeout=120.0)
+    except Exception as exc:
+        await send_message(client, chat_id, f"❌ 처리 실패: {exc}")
+        return
+    if res.status_code == 409:
+        await send_message(
+            client, chat_id,
+            "⚠️ 제안을 만든 뒤 파일이 바뀌어서 적용하지 않았습니다. 아무것도 쓰지 않았습니다.",
+        )
+        return
+    if res.status_code != 200:
+        await send_message(client, chat_id, f"❌ 서버 에러 ({res.status_code})")
+        return
+    if suffix == "approve":
+        try:
+            applied = res.json().get("path") or item_id
+        except Exception:
+            applied = item_id
+        await send_message(client, chat_id, f"✅ 적용했습니다: {applied}")
+    else:
+        await send_message(client, chat_id, "🚫 제안을 거절했습니다.")
+
+
+def format_run_explanation(agent_data, *, language: str = "ko") -> str:
+    """Plain-language outcome line for a finished agent run (v9.9.6).
+
+    Telegram used to show only the final message, so a NEEDS_REVIEW run read
+    exactly like a success. The server already computes the honest sentence
+    (`explanation`); this renders it. Returns "" when there is nothing to add
+    — a clean, verified run gets no extra noise.
+    """
+    if not isinstance(agent_data, dict):
+        return ""
+    explanation = agent_data.get("explanation")
+    if not isinstance(explanation, dict):
+        return ""
+    lang = "ko" if str(language or "ko").startswith("ko") else "en"
+
+    def pick(entry):
+        return str(entry.get(lang) or "") if isinstance(entry, dict) else ""
+
+    details = [pick(item) for item in explanation.get("details") or []]
+    details = [line for line in details if line]
+    if explanation.get("ok") and not details:
+        return ""
+    headline = pick(explanation.get("headline"))
+    marker = "✅" if explanation.get("ok") else "⚠️"
+    lines = [f"{marker} {headline}" if headline else marker]
+    lines.extend(f"· {line}" for line in details[:4])
+    return "\n".join(lines)
+
+
+async def send_run_explanation(client, chat_id, agent_data):
+    text = format_run_explanation(agent_data)
+    if text:
+        await send_message(client, chat_id, text)
+
+
 def collect_preview_urls(agent_data):
     urls, seen = [], set()
     for step in agent_data.get("steps", []):
@@ -711,35 +886,65 @@ async def send_generated_files(client, chat_id, generated_files):
 
 # ── Plan approval (Human-in-the-loop) ────────────────────────────────────────
 
+def _approval_pause_id(data: dict) -> str:
+    """Stable key for a paused plan: run_id preferred, legacy context_id fallback."""
+    return str(data.get("run_id") or data.get("context_id") or "")
+
+
+def _is_approval_pause(data: dict) -> bool:
+    status = str(data.get("status") or "")
+    return status in {"waiting_approval", "awaiting_approval"}
+
+
 async def send_plan_for_approval(client, chat_id, data: dict) -> None:
-    """Show the agent plan to the user and present Done/Cancel buttons."""
-    context_id = data.get("context_id", "")
-    plan = data.get("plan", {})
-    goal = plan.get("goal", "")
-    steps = plan.get("steps", [])
+    """Show the agent plan to the user and present Done/Cancel buttons.
+
+    Handles both the modern ``awaiting_approval`` (run_id + token) and the
+    legacy ``waiting_approval`` / ``context_id`` wire contracts (v9.9.5
+    SURFACE_PARITY — Telegram approval flow).
+    """
+    pause_id = _approval_pause_id(data)
+    if not pause_id:
+        await send_message(client, chat_id, "❌ 승인할 계획을 식별할 수 없습니다.")
+        return
+    plan = data.get("plan", {}) or {}
+    goal = plan.get("goal") or (data.get("approval") or {}).get("plan_summary") or ""
+    steps = plan.get("steps", []) or data.get("non_auto_steps") or []
     p_model = data.get("planning_model", "current")
     e_model = data.get("executing_model", "current")
     r_model = data.get("reviewing_model", "current")
+    approval = data.get("approval") or {}
+    expires_at = approval.get("expires_at")
 
     lines = ["📋 *플래닝 완료* — 실행 전 확인해주세요\n"]
     if goal:
         lines.append(f"*목표:* {goal}\n")
     for i, step in enumerate(steps, 1):
-        desc = step.get("description") or step.get("action") or str(step)
+        if isinstance(step, dict):
+            desc = step.get("description") or step.get("action") or str(step)
+        else:
+            desc = str(step)
         lines.append(f"{i}. {desc}")
     lines.append(f"\n🧠 플래닝: `{p_model}`")
     lines.append(f"⚙️ 실행: `{e_model}`")
     lines.append(f"🔍 검토: `{r_model}`")
+    if expires_at:
+        lines.append(f"⏳ 승인 만료: `{expires_at}`")
 
-    _bot_pending_plans[context_id] = {
+    _bot_pending_plans[pause_id] = {
         "chat_id": chat_id,
+        "run_id": data.get("run_id") or pause_id,
+        "context_id": data.get("context_id"),
+        "approval_token": approval.get("token"),
+        "legacy": data.get("status") == "waiting_approval" or bool(data.get("context_id")),
         "executing_model": data.get("executing_model"),
         "reviewing_model": data.get("reviewing_model"),
     }
 
+    # callback_data max 64 bytes — pause ids are token_urlsafe(16) (~22 chars).
     keyboard = {"inline_keyboard": [[
-        {"text": "✅ Done — 실행 시작", "callback_data": f"plan:approve:{context_id}"},
-        {"text": "❌ 취소", "callback_data": f"plan:cancel:{context_id}"},
+        {"text": "✅ Done — 실행 시작", "callback_data": f"plan:approve:{pause_id}"},
+        {"text": "❌ 취소", "callback_data": f"plan:cancel:{pause_id}"},
     ]]}
     await send_message(client, chat_id, "\n".join(lines), reply_markup=keyboard)
 
@@ -749,8 +954,8 @@ async def handle_plan_callback(client, chat_id, data: str) -> None:
     parts = data.split(":", 2)
     if len(parts) != 3:
         return
-    _, action, context_id = parts
-    pending = _bot_pending_plans.get(context_id)
+    _, action, pause_id = parts
+    pending = _bot_pending_plans.get(pause_id)
 
     # A callback is bound to the chat that received the plan. Even two allowed
     # chats cannot approve or cancel each other's plan by replaying callback
@@ -758,9 +963,19 @@ async def handle_plan_callback(client, chat_id, data: str) -> None:
     if pending and int(pending.get("chat_id")) != int(chat_id):
         await send_message(client, chat_id, "❌ 다른 채팅의 작업은 처리할 수 없습니다.")
         return
-    pending = _bot_pending_plans.pop(context_id, None)
+    pending = _bot_pending_plans.pop(pause_id, None)
 
-    if action == "cancel" or not pending:
+    if action == "cancel":
+        if pending:
+            try:
+                resume_body = _resume_payload(pending, approved=False)
+                async with _server_client() as sc:
+                    await sc.post(AGENT_RESUME_URL, json=resume_body, timeout=30.0)
+            except Exception as exc:  # noqa: BLE001 — cancel is best-effort
+                logger.warning("telegram cancel resume failed: %s", safe_log_text(exc))
+        await send_message(client, chat_id, "❌ 작업이 취소되었습니다.")
+        return
+    if not pending:
         await send_message(client, chat_id, "❌ 작업이 취소되었습니다.")
         return
 
@@ -769,22 +984,41 @@ async def handle_plan_callback(client, chat_id, data: str) -> None:
 
     try:
         async with _server_client() as sc:
-            res = await sc.post(AGENT_RESUME_URL, json={
-                "context_id": context_id,
-                "approved": True,
-                "executing_model": pending.get("executing_model"),
-                "reviewing_model": pending.get("reviewing_model"),
-            }, timeout=300.0)
+            res = await sc.post(
+                AGENT_RESUME_URL,
+                json=_resume_payload(pending, approved=True),
+                timeout=300.0,
+            )
         data_r = res.json() if res.status_code == 200 else {}
         ans = data_r.get("response", f"❌ 서버 에러 ({res.status_code})")
         await send_message(client, chat_id, str(ans))
         if isinstance(data_r, dict):
+            await send_run_explanation(client, chat_id, data_r)
             await send_generated_files(client, chat_id, collect_generated_files(data_r))
             await send_preview_links(client, chat_id, collect_preview_urls(data_r))
     except Exception as e:
         await send_message(client, chat_id, f"❌ 실행 중 오류: {e}")
 
 
+def _resume_payload(pending: dict, *, approved: bool) -> dict:
+    """Build /agent/resume body: token path preferred, else legacy context_id."""
+    body: dict = {
+        "approved": approved,
+        "executing_model": pending.get("executing_model"),
+        "reviewing_model": pending.get("reviewing_model"),
+    }
+    token = pending.get("approval_token")
+    run_id = pending.get("run_id")
+    # Unified durable store (9.9.5): token-gated resume works for both the
+    # modern awaiting_approval and the legacy human_in_loop pause.
+    if token and run_id:
+        body["run_id"] = run_id
+        body["approval_token"] = token
+        return body
+    body["context_id"] = pending.get("context_id") or run_id
+    return body
+
+
 # ── AI request task ───────────────────────────────────────────────────────────
 
 async def process_ai_request(client, chat_id, user_text, image_data=None):
@@ -794,8 +1028,8 @@ async def process_ai_request(client, chat_id, user_text, image_data=None):
         data  = await ask_ai(client, user_text, image_data, agent_mode=not image_data)
         logger.info("ask_ai 완료: chat_id=%s result_keys=%s", chat_id, list(data.keys()) if isinstance(data, dict) else type(data))
 
-        # Human-in-the-loop: show plan and wait for approval
-        if isinstance(data, dict) and data.get("status") == "waiting_approval":
+        # Approval pause (legacy waiting_approval or modern awaiting_approval)
+        if isinstance(data, dict) and _is_approval_pause(data):
             await send_plan_for_approval(client, chat_id, data)
             return
 
@@ -803,7 +1037,12 @@ async def process_ai_request(client, chat_id, user_text, image_data=None):
         if not ans or not str(ans).strip():
             ans = "⚠️ AI가 답변을 생성하지 못했습니다."
         await send_message(client, chat_id, str(ans))
+        if isinstance(data, dict):
+            # Recall parity (v9.9.7): the same grounding verdict the web app
+            # badges, never promoted when the server issued none.
+            await send_grounding_badge(client, chat_id, data)
         if not image_data and isinstance(data, dict):
+            await send_run_explanation(client, chat_id, data)
             await send_generated_files(client, chat_id, collect_generated_files(data))
             await send_preview_links(client, chat_id, collect_preview_urls(data))
     except Exception as e:
@@ -828,6 +1067,7 @@ HELP_TEXT = """\
 /clear [n] — 기록 정리 (마지막 n건 유지)
 /web — 웹 UI 링크
 /mcp — MCP 도구 목록
+/review — 변경 제안 검토함 (승인/거절)
 /help — 이 도움말
 
 /agent <작업> — 멀티 LLM 에이전트 (계획 확인 후 실행)
@@ -866,6 +1106,8 @@ async def handle_command(client, chat_id, command: str, args: str):
         await send_web_link(client, chat_id)
     elif cmd == "mcp":
         await send_mcp_tools(client, chat_id)
+    elif cmd in {"review", "proposals"}:
+        await show_review_center(client, chat_id)
     elif cmd in {"help", "h"}:
         await send_message(client, chat_id, HELP_TEXT)
     elif cmd == "agent":
@@ -887,7 +1129,7 @@ async def handle_command(client, chat_id, command: str, args: str):
         await send_chat_action(client, chat_id, "typing")
         data = await ask_ai(client, task_text, agent_mode=True,
                             executing_model=exec_model, reviewing_model=reviewing_model)
-        if isinstance(data, dict) and data.get("status") == "waiting_approval":
+        if isinstance(data, dict) and _is_approval_pause(data):
             await send_plan_for_approval(client, chat_id, data)
         else:
             ans = data.get("response", str(data)) if isinstance(data, dict) else str(data)
@@ -927,6 +1169,8 @@ async def handle_callback_query(client, callback_query):
         await send_web_link(client, chat_id)
     elif data == "cmd:mcp":
         await send_mcp_tools(client, chat_id)
+    elif data == "cmd:review":
+        await show_review_center(client, chat_id)
     elif data == "cmd:menu":
         await show_menu(client, chat_id)
     elif data.startswith("model:unload:"):
@@ -935,6 +1179,9 @@ async def handle_callback_query(client, callback_query):
     elif data.startswith("plan:"):
         task = asyncio.create_task(handle_plan_callback(client, chat_id, data))
         task.add_done_callback(_log_task_exception)
+    elif data.startswith("proposal:"):
+        task = asyncio.create_task(handle_proposal_callback(client, chat_id, data))
+        task.add_done_callback(_log_task_exception)
 
 # ── Main loop ─────────────────────────────────────────────────────────────────
 

package/latticeai/runtime/chat_wiring.py

@@ -4,6 +4,10 @@ from __future__ import annotations
 
 from typing import Any, Optional
 
+from latticeai.runtime.permission_mode_wiring import (
+    bind_dispatch_permission_mode,
+    resolve_active_permission_mode,
+)
 from latticeai.services.router_context import InteractionRouterContext, ToolRouterContext
 
 
@@ -19,6 +23,9 @@ def build_chat_agent_runtime_from_context(
     hooks: Any,
     brain_memory: Any,
 ) -> Any:
+    # Ensure dispatch + agent share the same autonomy dial before the runtime
+    # is constructed (process-wide service; data_dir refined later at router mount).
+    bind_dispatch_permission_mode()
     return build_agent_runtime(
         model_router=model_router,
         execute_tool=execute_tool,
@@ -28,6 +35,7 @@ def build_chat_agent_runtime_from_context(
         audit=audit,
         hooks=hooks,
         brain_memory=brain_memory,
+        permission_mode=resolve_active_permission_mode,
     )
 
 

package/latticeai/runtime/context_runtime.py

@@ -13,6 +13,7 @@ def build_context_runtime(
     gardener: Any,
     require_auth: bool,
     allowed_scopes_for_user: Callable[[Any], Any],
+    artifact_ledger: Any = None,
 ) -> Dict[str, Any]:
     """Construct search, brain memory, and context assembly services."""
 
@@ -41,15 +42,25 @@ def build_context_runtime(
                 allowed = allowed_scopes_for_user(user_email)
         return gardener.get_relevant_context(q, allowed_workspaces=allowed, **kw)
 
+    # Re-search loop (v9.9.6): files this conversation just produced are a
+    # deterministic context section, so "그 파일에 다크모드 넣어줘" works before
+    # asynchronous indexing catches up. Optional — absent ledger, absent section.
+    if artifact_ledger is None:
+        from latticeai.core.artifact_ledger import ArtifactLedger
+
+        artifact_ledger = ArtifactLedger()
+
     context_assembler = ContextAssembler(
         memory_recall=memory_service.recall,
         hybrid_search=scoped_hybrid_search,
         notes_context=scoped_notes_context,
+        recent_artifacts=artifact_ledger.recent,
     )
 
     return {
         "SEARCH_SERVICE": search_service,
         "BRAIN_MEMORY": brain_memory,
         "CONTEXT_ASSEMBLER": context_assembler,
+        "ARTIFACT_LEDGER": artifact_ledger,
         "_scoped_hybrid_search": scoped_hybrid_search,
     }