ltcai 2.0.0 → 2.2.0

package/docs/architecture.md

@@ -1,156 +1,148 @@
-# Lattice AI — 아키텍처
-
-## 전체 구조
-
-```
-┌─────────────────────────────────────────────────────────┐
-│                    클라이언트 레이어                      │
-│  웹 UI (chat.html)  │  VS Code 확장  │  Telegram 봇     │
-└──────────────────────────┬──────────────────────────────┘
-                           │ HTTP / SSE
-┌──────────────────────────▼──────────────────────────────┐
-│               server.py — FastAPI (port 4825)            │
-│                                                          │
-│  /chat  /agent  /models  /tools/*  /mcp/*  /garden      │
-│  /account  /admin  /auth/sso  /knowledge-graph  /graph   │
-└────┬──────────┬──────────┬──────────┬───────────────────┘
-     │          │          │          │
-     ▼          ▼          ▼          ▼
-llm_router  tools.py  knowledge_  p_reinforce
-  .py               graph.py      .py
-     │
-     ├── MLX (mlx_lm / mlx_vlm)   ← Apple Silicon 로컬
-     ├── OpenAI SDK                ← openai / groq / together / openrouter
-     └── Ollama / vLLM REST        ← 로컬 서버 연동
+# Lattice AI Architecture
+
+Lattice AI v2.2.0 is a local-first **AI Knowledge OS**. The architecture is
+organized around one durable center: the Knowledge Graph. Models, tools,
+agents, workflows, and UI modes are replaceable layers that operate on top of
+the graph.
+
+## Architecture Goals
+
+- Keep user knowledge local-first by default.
+- Treat multimodal input as the normal path, not an add-on.
+- Preserve evidence, decisions, files, artifacts, and work history.
+- Keep models replaceable and policy-governed.
+- Explain risk and source facts instead of hiding capability.
+- Keep basic and advanced modes feature-equivalent.
+- Keep admin-only capabilities explicit and auditable.
+
+## System View
+
+```mermaid
+flowchart TD
+    User["User files, screenshots, chats, notes, code, work logs"]
+    Ingestion["Multimodal ingestion"]
+    Extract["Entity, relation, evidence extraction"]
+    Graph["Knowledge Graph"]
+    Context["Graph context builder"]
+    Models["Multimodal model runtime"]
+    Agents["Agent runtime and workflows"]
+    Outputs["Advice, analysis, documents, automation"]
+    Admin["Admin policy and audit"]
+
+    User --> Ingestion
+    Ingestion --> Extract
+    Extract --> Graph
+    Graph --> Context
+    Context --> Models
+    Models --> Agents
+    Agents --> Outputs
+    Admin --> Models
+    Admin --> Graph
 ```
 
-## 파일별 역할
-
-| 파일 | 역할 |
-|------|------|
-| `server.py` | FastAPI 앱, 모든 HTTP 엔드포인트, 인증/세션/CORS/rate limit |
-| `ltcai_cli.py` | CLI 엔트리포인트 (`LTCAI` 명령), `doctor` 서브커맨드, uvicorn 실행 |
-| `llm_router.py` | 로컬(MLX/Ollama) ↔ 클라우드(OpenAI/Groq/…) 라우팅, 스트리밍 SSE |
-| `tools.py` | 에이전트 도구 구현: read_file, edit_file, grep, run_command, todo_write/read, 스크린샷 등 |
-| `knowledge_graph.py` | SQLite 지식 그래프 (노드/엣지/청크), Graph RAG 컨텍스트 주입 |
-| `p_reinforce.py` | P-Reinforce 지식 정원 엔진, `~/.ltcai-brain/` 분류 저장 |
-| `telegram_bot.py` | 로컬 AI Telegram 미러 봇 |
-| `codex_telegram_bot.py` | 클라우드 Codex Telegram 봇 (GPT + GitHub 이슈) |
-| `vscode-extension/` | TypeScript VS Code 확장 |
-| `static/` | 웹 UI HTML (chat, account, admin, graph), PWA manifest/SW |
-| `bin/ltcai.js` | npm CLI 엔트리포인트 (Python 환경 자동 부트스트랩) |
-
-## 데이터 흐름
-
-### 채팅 요청
+## Durable Core
 
-```
-브라우저 → POST /chat
-  → server.py: 인증 확인, rate limit
-  → llm_router.py: 모델 선택 (로컬/클라우드)
-  → knowledge_graph.py: Graph RAG 컨텍스트 조회 + 주입
-  → LLM 스트리밍 응답 (SSE)
-  → knowledge_graph.py: 메시지/응답 인제스트
-```
+The Knowledge Graph stores the durable user and organization memory:
 
-### 에이전트 요청
+- files and document evidence
+- images and screenshots
+- conversations and notes
+- user decisions
+- work history
+- generated artifacts
+- agent and workflow events
 
-```
-브라우저/VS Code → POST /agent
-  → server.py: 인증 확인, rate limit (6/분)
-  → llm_router.py: Discover→Plan→Implement→Verify 루프 (max 25스텝)
-  → tools.py: read_file / edit_file / grep / run_command / todo_*
-  → 각 스텝 결과 스트리밍
-```
+The LLM is not the product core. It is an execution worker that can be replaced
+when hardware, policy, or user preference changes.
 
-### 문서 업로드
+## Multimodal Ingestion
 
-```
-브라우저 → POST /upload
-  → server.py: magic-number 검증, rate limit (12/분)
-  → tools.py: PDF/DOCX/XLSX/PPTX 파싱
-  → knowledge_graph.py: Chunk/Page/Sheet/Slide 노드 인제스트
-  → blob 저장: ~/.ltcai/knowledge_graph_blobs/
-```
+Lattice AI assumes users will provide source material directly. The expected
+input set includes:
 
-## 데이터 저장소
+- PDF
+- Word
+- Excel
+- PowerPoint
+- images
+- screenshots
+- chat history
+- notes
+- web content
+- code
+- work logs
 
-```
-~/.ltcai/
-├── users.json                   # 사용자 계정 (scrypt 해시)
-├── sessions.json                # 세션 토큰 (24h TTL)
-├── chat_history.json            # 채팅 히스토리
-├── knowledge_graph.sqlite       # Graph RAG SQLite DB
-├── knowledge_graph_blobs/       # 원본 업로드 파일
-├── mcp_installs.json            # MCP 서버 설치 목록
-└── todos.json                   # 에이전트 TODO 리스트
-
-~/.ltcai-brain/
-├── INDEX.md
-├── 00_Raw/
-├── 10_Wiki/
-├── 20_Skills/
-├── 30_Projects/
-└── 40_Log/
-```
-
-## 인증 흐름
-
-```
-POST /login (username + password)
-  → scrypt 검증
-  → 세션 토큰 생성 (UUID, 24h TTL)
-  → Set-Cookie: session=<token>; HttpOnly; SameSite=Lax
-
-모든 민감 엔드포인트:
-  → _require_auth(): 쿠키 검증 → User 반환 또는 401
-```
-
-SSO (OIDC):
-
-```
-GET /auth/sso/login → 리디렉션 (Entra ID / Okta)
-GET /auth/sso/callback?code=... → 토큰 교환 → 세션 생성
-```
+The architecture must not ask users to convert these to plain text before AI can
+work on them.
 
-## MCP 연동
+## Model Runtime Policy
 
-`/mcp/tools` — 에이전트 도구 카탈로그를 MCP 형식으로 노출  
-Claude Desktop / Cursor의 MCP 설정에 `http://localhost:4825/mcp` 추가 시 직접 도구 사용 가능.
+Local recommended models must be multimodal. The v2.2 local runtime policy is:
 
-자세한 내용: [mcp-tools.md](mcp-tools.md)
+- macOS Apple Silicon: MLX-VLM first
+- Windows: llama.cpp multimodal path, with LM Studio as a user-friendly option
+- Linux: llama.cpp or vLLM multimodal path depending on GPU support
+- Ollama: kept as an option, not the default priority
 
----
+The removed path is the old text-only MLX-LM recommendation route. Low-spec
+machines use smaller or quantized multimodal models.
 
-## PPT 명세와의 정렬 (2026-05 추가)
+## Model Source Disclosure
 
-`lattice_ai_full_spec.pptx` (UI 명세서) 에 맞춰 세 가지 보강 모듈이 추가됐다.
-어떤 슬라이드가 어떤 파일에 매핑되는지 한눈에:
+Model catalog entries carry source disclosure fields:
 
-| PPT 슬라이드 | 의미 | 구현 파일 |
-|--------------|------|-----------|
-| 14 (세 가지 약속) | Cross-platform · Auto-setup · Graph 원칙 | (전체 아키텍처) |
-| 15·19 (크로스플랫폼·디자인 토큰) | 공유 토큰 = 단일 진실 근원 | [`static/css/tokens.css`](../static/css/tokens.css) |
-| 16·17 (자동 환경 매트릭스·5단계) | OS·HW 감지 → 모델 추천 → 설치 → 검증 → 프리셋 | [`auto_setup.py`](../auto_setup.py) |
-| 20·21·22 (KG 노드·엣지·데이터 모델) | 10 NodeType / 12 EdgeType + embedding + confidence | [`kg_schema.py`](../kg_schema.py), [`docs/kg-schema.md`](kg-schema.md) |
-| 24 (통합 아키텍처) | 6 레이어 (UI / Logic / AI Core / KG / Storage / Auto-Setup) | 이 문서 + 위 파일들 |
+1. `source_country`
+2. `source_company`
+3. `execution_method`
+4. `internet_requirement`
+5. `model_name`
 
-### 신규 모듈 빠른 참조
+These are first-class model facts, not advanced-only metadata.
 
-```bash
-# 자동 환경 세팅 5단계
-python3 auto_setup.py probe          # ① 시스템 감지
-python3 auto_setup.py recommend      # ② 모델 추천
-python3 auto_setup.py plan           # ③ 설치 계획 (실행 안 함)
-python3 auto_setup.py plan --apply   # ③ 실제 설치 (위험)
-python3 auto_setup.py verify         # ④ 검증
-python3 auto_setup.py preset         # ⑤ 프리셋
-python3 auto_setup.py all            # 전체 흐름
+## Recommendation Flow
 
-# KG v2 스키마
-python3 kg_schema.py init  ~/.ltcai/kg_v2.db
-python3 kg_schema.py migrate ~/.ltcai/knowledge_graph.db    # legacy → v2
-python3 kg_schema.py stats ~/.ltcai/knowledge_graph.db
+```text
+hardware scan
+  -> CPU/GPU/RAM/disk/OS analysis
+  -> multimodal model shortlist
+  -> same-family old generation removal
+  -> source disclosure
+  -> recommendation reason
+  -> download/install/load/verify
 ```
 
-전체 명세 ↔ 구현 매핑은 [`spec-vs-impl.md`](spec-vs-impl.md) 참고.
+The current default recommendation family is Gemma 4. Qwen3-VL and Llama 4
+remain current multimodal alternatives.
+
+## Modes
+
+Basic mode and advanced mode have the same feature access.
+
+- Basic mode uses plain language and source facts.
+- Advanced mode adds execution, memory, quantization, and load/unload detail.
+- Admin mode adds actual authority: user management, permissions, audit logs,
+  organization policy, security policy, sensitive-data monitoring, model approval
+  policy, and Private VPC.
+
+## Main Modules
+
+| Module | Responsibility |
+| --- | --- |
+| `latticeai/services/model_catalog.py` | Multimodal model catalog, source metadata, aliases |
+| `latticeai/services/model_recommendation.py` | Hardware-aware multimodal recommendation |
+| `latticeai/services/model_runtime.py` | Download, load, server, and runtime orchestration |
+| `llm_router.py` | MLX-VLM and OpenAI-compatible model routing |
+| `knowledge_graph.py` | Graph storage, extraction, local folder graph RAG |
+| `latticeai/core/context_builder.py` | Graph context for generation |
+| `latticeai/core/workspace_os.py` | Workspace state, timeline, snapshots, memory |
+| `latticeai/core/multi_agent.py` | Planner/executor/reviewer/researcher orchestration |
+| `latticeai/core/workflow_engine.py` | Workflow definitions and run history |
+| `latticeai/core/plugins.py` | Plugin manifest, registry, permission boundary |
+| `latticeai/core/security.py` | Local security primitives |
+
+## Compatibility
+
+v2.2.0 preserves the additive Workspace OS and API compatibility posture from
+v2.x. Existing graph/workspace data is migrated non-destructively. The release
+does remove current recommendation entries for old or text-only model paths, but
+it does not destructively mutate existing user graph data.

package/docs/kg-schema.md

@@ -56,7 +56,7 @@ Edge {
   weight       float [0..1]    // 관계의 ‘강도’
   confidence   float [0..1]    // 추출/추론의 ‘신뢰도’
   evidence     string[]        // 근거 (메시지/청크 ID 리스트)
-  created_by   string          // extractor:llm-gemma-3-12b | rule:regex | user
+  created_by   string          // extractor:llm-gemma-4-12b | rule:regex | user
   created_at   ISO8601 UTC
 }
 ```
@@ -106,7 +106,7 @@ Edge {
     "weight":     0.82,
     "confidence": 0.91,
     "evidence":   ["chunk:01HX7K…#p3", "chunk:01HX7K…#p11"],
-    "created_by": "extractor:llm-gemma-3-12b"
+    "created_by": "extractor:llm-gemma-4-12b"
   }
 }
 ```
@@ -197,7 +197,7 @@ store.upsert_edge(Edge(
     type=EdgeType.MENTIONS,
     weight=0.82, confidence=0.91,
     evidence=["chunk:01HX7K…#p3"],
-    created_by="extractor:llm-gemma-3-12b",
+    created_by="extractor:llm-gemma-4-12b",
 ))
 
 # 이웃 탐색

package/docs/public-deploy.md

@@ -131,7 +131,6 @@ yourdomain.com {
 openai:gpt-4o-mini
 openai:gpt-4o
 openrouter:openai/gpt-4o-mini
-groq:llama-3.1-8b-instant
-groq:llama-3.3-70b-versatile
-together:meta-llama/Llama-3.3-70B-Instruct-Turbo
+openrouter:qwen/qwen3-vl-235b-a22b-instruct
+together:Qwen/Qwen3-VL-32B-Instruct
 ```

package/knowledge_graph.py

@@ -523,7 +523,7 @@ def _extract_concepts_rules(text: str, limit: int = 12) -> List[str]:
     2. Multi-word proper nouns (Lattice AI, GPT-4o, Claude Sonnet)
     3. Single capitalized proper nouns not at sentence start (Claude, Python, FastAPI)
     4. Korean compound technical terms (멀티모달, 에이전트, 그래프RAG)
-    5. Hyphenated / versioned identifiers (gpt-4o, mlx-lm, llama-3.3)
+    5. Hyphenated / versioned identifiers (gpt-4o, mlx-vlm, gemma-4)
     """
     text = str(text or "")
     seen: dict = {}  # concept_lower → original form
@@ -586,7 +586,7 @@ def _extract_concepts_rules(text: str, limit: int = 12) -> List[str]:
             if len(m) >= 3 or cnt >= 2:
                 _add(m)
 
-    # 6. Hyphenated / versioned identifiers (gpt-4o, llama-3.3, mlx-lm)
+    # 6. Hyphenated / versioned identifiers (gpt-4o, gemma-4, mlx-vlm)
     for m in re.findall(r'\b([a-zA-Z][a-zA-Z0-9]*(?:-[a-zA-Z0-9.]+)+)\b', text):
         if len(m) >= 4:
             _add(m)

package/latticeai/__init__.py

@@ -1,3 +1,3 @@
 """Lattice AI - modular server package."""
 
-__version__ = "2.0.0"
+__version__ = "2.2.0"

package/latticeai/api/agents.py

@@ -1,4 +1,4 @@
-"""Multi-Agent Runtime 2.0 API router (v2.0).
+"""Multi-Agent Runtime API router (v2).
 
 Exposes the built-in agent roles and an orchestrated run endpoint that connects
 to Workspace, Memory, Knowledge Graph, Workflow runs, and the Timeline. Paths
@@ -22,6 +22,12 @@ class AgentRunRequest(BaseModel):
     max_retries: int = 2
 
 
+class MemorySnapshotRequest(BaseModel):
+    label: str = "agent memory snapshot"
+    reason: str = ""
+    memory_ids: List[str] = []
+
+
 def create_agents_router(
     *,
     store,
@@ -66,6 +72,49 @@ def create_agents_router(
         scope = gate_read(request)
         return store.list_agents(workspace_id=scope)
 
+    @router.get("/agents/api/handoffs")
+    async def agent_handoffs(request: Request, run_id: str = ""):
+        require_user(request)
+        scope = gate_read(request)
+        return store.list_handoffs(workspace_id=scope, run_id=run_id or None)
+
+    @router.get("/agents/api/runs/{run_id}")
+    async def agent_run_detail(run_id: str, request: Request):
+        require_user(request)
+        scope = gate_read(request)
+        try:
+            return {"run": store.get_agent_run(run_id, workspace_id=scope)}
+        except FileNotFoundError as exc:
+            raise HTTPException(status_code=404, detail=f"Agent run not found: {run_id}") from exc
+
+    @router.get("/agents/api/runs/{run_id}/replay")
+    async def agent_run_replay(run_id: str, request: Request):
+        require_user(request)
+        scope = gate_read(request)
+        try:
+            return {"replay": store.replay_agent_run(run_id, workspace_id=scope)}
+        except FileNotFoundError as exc:
+            raise HTTPException(status_code=404, detail=f"Agent run not found: {run_id}") from exc
+
+    @router.get("/agents/api/memory/snapshots")
+    async def agent_memory_snapshots(request: Request, limit: int = 50):
+        require_user(request)
+        scope = gate_read(request)
+        return store.list_memory_snapshots(workspace_id=scope, limit=limit)
+
+    @router.post("/agents/api/memory/snapshots")
+    async def agent_memory_snapshot(req: MemorySnapshotRequest, request: Request):
+        current_user = require_user(request)
+        scope = gate_write(request)
+        snapshot = store.create_memory_snapshot(
+            label=req.label,
+            reason=req.reason,
+            memory_ids=req.memory_ids or None,
+            user_email=current_user or None,
+            workspace_id=scope,
+        )
+        return {"snapshot": snapshot}
+
     @router.post("/agents/api/run")
     async def agent_run(req: AgentRunRequest, request: Request):
         current_user = require_user(request)
@@ -88,6 +137,13 @@ def create_agents_router(
             output_text=result.output,
             timeline=result.timeline,
             relationships=[ROLE_AGENT_IDS.get(r, f"agent:{r}") for r in result.roles_run],
+            handoffs=result.handoffs,
+            context_packets=result.context_packets,
+            plan=result.plan,
+            plan_review=result.plan_review,
+            review_history=result.review_history,
+            retry_history=result.retry_history,
+            memory_snapshots=result.memory_snapshots,
             user_email=current_user or None,
             graph=workspace_graph(),
             workspace_id=scope,

package/latticeai/api/marketplace.py

@@ -0,0 +1,81 @@
+"""Marketplace foundation API (local templates only)."""
+
+from __future__ import annotations
+
+from typing import Any, Callable, Dict, Optional
+
+from fastapi import APIRouter, HTTPException, Request
+from pydantic import BaseModel
+
+
+class TemplateImportRequest(BaseModel):
+    data: Dict[str, Any] = {}
+
+
+class TemplateInstallRequest(BaseModel):
+    data: Dict[str, Any] = {}
+
+
+def create_marketplace_router(
+    *,
+    store,
+    catalog,
+    require_user: Callable[[Request], str],
+    gate_read: Callable[[Request], Optional[str]],
+    gate_write: Callable[[Request], Optional[str]],
+    workspace_graph: Callable[[], Any],
+) -> APIRouter:
+    from latticeai.core.marketplace import MarketplaceError
+
+    router = APIRouter()
+
+    @router.get("/marketplace/templates")
+    async def list_templates(request: Request, kind: Optional[str] = None):
+        require_user(request)
+        gate_read(request)
+        try:
+            return catalog.list_templates(kind=kind)
+        except MarketplaceError as exc:
+            raise HTTPException(status_code=400, detail=str(exc)) from exc
+
+    @router.get("/marketplace/templates/{kind}/{template_id}/export")
+    async def export_template(kind: str, template_id: str, request: Request):
+        require_user(request)
+        gate_read(request)
+        try:
+            return catalog.export_template(kind, template_id)
+        except MarketplaceError as exc:
+            raise HTTPException(status_code=404, detail=str(exc)) from exc
+
+    @router.post("/marketplace/templates/import")
+    async def import_template(req: TemplateImportRequest, request: Request):
+        require_user(request)
+        gate_read(request)
+        try:
+            return {"template": catalog.import_template(req.data)}
+        except MarketplaceError as exc:
+            raise HTTPException(status_code=400, detail=str(exc)) from exc
+
+    @router.post("/marketplace/templates/install")
+    async def install_template(req: TemplateInstallRequest, request: Request):
+        user = require_user(request)
+        scope = gate_write(request)
+        try:
+            installed = catalog.install_template(
+                req.data,
+                store=store,
+                user_email=user or None,
+                workspace_id=scope,
+                graph=workspace_graph(),
+            )
+        except MarketplaceError as exc:
+            raise HTTPException(status_code=400, detail=str(exc)) from exc
+        return {"installed": installed}
+
+    @router.get("/marketplace/templates/registry")
+    async def template_registry(request: Request):
+        require_user(request)
+        gate_read(request)
+        return {"registry": store.list_template_registry()}
+
+    return router

package/latticeai/api/models.py

@@ -100,9 +100,17 @@ def create_models_router(
             base = {
                 "id": item["id"],
                 "name": item["name"],
+                "model_name": item.get("model_name") or item.get("name"),
                 "tag": item["tag"],
                 "size": item["size"],
                 "display_name": item.get("name") or item.get("id"),
+                "modality": item.get("modality") or "multimodal",
+                "source_country": item.get("source_country"),
+                "source_company": item.get("source_company"),
+                "execution_method": item.get("execution_method"),
+                "run_location": item.get("run_location"),
+                "internet_requirement": item.get("internet_requirement"),
+                "source_display_order": item.get("source_display_order"),
             }
             short_id = str(item["id"]).lower()
             aliases = MODEL_ENGINE_ALIASES.get(short_id) or {}

package/latticeai/api/plugins.py

@@ -1,4 +1,4 @@
-"""Plugin SDK API router (v2.0).
+"""Plugin SDK API router (v2).
 
 Surfaces the :class:`latticeai.core.plugins.PluginRegistry` over HTTP using the
 same router-factory convention as the rest of ``latticeai.api`` (server_app

package/latticeai/api/realtime.py

@@ -1,4 +1,4 @@
-"""Realtime Collaboration API router (v2.0).
+"""Realtime Collaboration API router (v2).
 
 Server-Sent-Events stream + presence + activity feed over
 :class:`latticeai.core.realtime.RealtimeBus`. Workspace isolation is enforced by

package/latticeai/api/workflow_designer.py

@@ -1,4 +1,4 @@
-"""Workflow Designer API router (v2.0).
+"""Workflow Designer API router (v2).
 
 Create / edit / validate / execute / inspect / export / import workflows plus
 run history, layered on :mod:`latticeai.core.workflow_engine` and the existing
@@ -174,6 +174,15 @@ def create_workflow_designer_router(
         scope = gate_read(request)
         return store.list_workflow_runs(limit=limit, workspace_id=scope)
 
+    @router.get("/workflows/api/runs/{run_id}/replay")
+    async def workflow_run_replay(run_id: str, request: Request):
+        require_user(request)
+        scope = gate_read(request)
+        try:
+            return {"replay": store.replay_workflow_run(run_id, workspace_id=scope)}
+        except FileNotFoundError as exc:
+            raise HTTPException(status_code=404, detail=f"Workflow run not found: {run_id}") from exc
+
     @router.get("/workflows/api/export/{workflow_id}")
     async def export_definition(workflow_id: str, request: Request):
         require_user(request)

package/latticeai/core/config.py

@@ -131,7 +131,7 @@ class Config:
         admin_emails = [item.strip().lower() for item in _value(env, "LATTICEAI_ADMIN_EMAILS", "").split(",") if item.strip()]
 
         public_model = _value(env, "LATTICEAI_PUBLIC_MODEL", _value(env, "LATTICEAI_DEFAULT_MODEL", "openai:gpt-4o-mini"))
-        local_model = _value(env, "LATTICEAI_LOCAL_MODEL", "mlx-community/gemma-4-26b-a4b-it-4bit")
+        local_model = _value(env, "LATTICEAI_LOCAL_MODEL", "mlx-community/gemma-4-12b-it-4bit")
 
         data_dir = Path(_value(env, "LATTICEAI_DATA_DIR", str(Path.home() / ".ltcai")))
         static_dir = Path(_value(env, "LATTICEAI_STATIC_DIR", str(base_dir / "static")))

package/latticeai/core/graph_curator.py

@@ -231,9 +231,9 @@ def extract_topic_candidates(
 
 DEFAULT_ALIAS_GROUPS: List[List[str]] = [
     ["lattice ai", "latticeai", "래티스 ai", "래티스ai", "내 앱", "내 ai"],
-    ["gpt-oss", "gpt oss", "openai gpt-oss"],
+    ["gemma-4", "gemma 4", "google gemma"],
     ["gemma 4", "gemma4", "google gemma 4"],
-    ["llama 3", "llama3", "meta llama 3"],
+    ["llama 4", "llama4", "meta llama 4", "llama scout"],
 ]