ltcai 6.2.0 → 6.3.1

package/latticeai/app_factory.py

@@ -18,8 +18,14 @@ import threading
 from typing import TYPE_CHECKING, Any, Dict, List, Optional
 
 from latticeai.runtime.app_context_runtime import build_app_context
+from latticeai.runtime.access_runtime import build_access_runtime
 from latticeai.runtime.bootstrap import build_session_runtime
 from latticeai.runtime.brain_runtime import build_brain_runtime
+from latticeai.runtime.chat_wiring import (
+    build_chat_agent_runtime_from_context,
+    build_interaction_contexts,
+    maybe_build_telegram_chat_mirror,
+)
 from latticeai.runtime.config_runtime import build_config_runtime
 from latticeai.runtime.context_runtime import build_context_runtime
 from latticeai.runtime.hooks_runtime import (
@@ -28,12 +34,16 @@ from latticeai.runtime.hooks_runtime import (
     build_hooks_runtime,
 )
 from latticeai.runtime.lifespan_runtime import build_lifespan_runtime
+from latticeai.runtime.model_wiring import (
+    configure_model_runtime_from_context,
+    register_model_runtime_routers,
+)
 from latticeai.runtime.platform_services_runtime import (
     build_brain_network,
-    build_model_service,
 )
 from latticeai.runtime.platform_runtime_wiring import build_platform_automation_runtime
 from latticeai.runtime.persistence_runtime import build_persistence_runtime
+from latticeai.runtime.review_wiring import build_review_run_now_runner
 from latticeai.runtime.router_registration import (
     build_auth_admin_security_router_bundle,
     build_static_routes_bundle,
@@ -44,8 +54,8 @@ from latticeai.runtime.router_registration import (
     register_review_and_brain_tail_routers,
 )
 from latticeai.runtime.security_runtime import build_security_runtime
+from latticeai.runtime.tail_wiring import register_tail_runtime_routers
 from latticeai.runtime.web_runtime import build_web_runtime
-from latticeai.services.router_context import InteractionRouterContext, ToolRouterContext
 
 if TYPE_CHECKING:  # imports for annotations only — keep module import light
     from fastapi import FastAPI
@@ -113,12 +123,11 @@ def _build(config: "Optional[Config]" = None) -> Dict[str, Any]:
     from latticeai.core.enterprise import (
         capability_registry,
     )
-    from latticeai.core.policy import normalize_role, policy_matrix, require_capability
+    from latticeai.core.policy import policy_matrix
     from latticeai.core.users import (
         ensure_user_identity,
         load_users_file,
         migrate_knowledge_graph_identity,
-        normalize_email,
         save_users_file,
         user_id_for_email as _user_id_for_email,
     )
@@ -804,42 +813,21 @@ def _build(config: "Optional[Config]" = None) -> Dict[str, Any]:
     def clear_conversation(conversation_id: str, started_at: Optional[str] = None) -> Dict:
         return CONVERSATIONS.clear_conversation(conversation_id, started_at=started_at)
 
-    def get_user_role(email: str, users: Optional[Dict] = None) -> str:
-        users = users or load_users()
-        identity = str(email or "")
-        normalized_email = normalize_email(identity)
-        user = users.get(normalized_email) or users.get(identity) or next(
-            (
-                item for item in users.values()
-                if isinstance(item, dict) and item.get("id") == identity
-            ),
-            {},
-        )
-        if isinstance(user, dict) and user.get("role"):
-            return normalize_role(user["role"])
-        admin_emails = {normalize_email(item) for item in CONFIG.admin_emails}
-        if normalized_email in admin_emails:
-            return "admin"
-        first_email = next(iter(users), None)
-        return "admin" if first_email == normalized_email else "user"
-
-    def _extract_bearer_token(request: Request) -> Optional[str]:
-        auth = request.headers.get("Authorization", "")
-        if auth.startswith("Bearer "):
-            return auth[7:].strip()
-        return request.cookies.get("session_token")
-
-    def get_current_user(request: Request) -> Optional[str]:
-        token = _extract_bearer_token(request)
-        if token:
-            return get_session_email(token)
-        return None
-
-    def require_user(request: Request) -> str:
-        email = get_current_user(request)
-        if REQUIRE_AUTH and not email:
-            raise HTTPException(status_code=401, detail="인증이 필요합니다.")
-        return email or ""
+    _access_runtime = build_access_runtime(
+        config=CONFIG,
+        require_auth=REQUIRE_AUTH,
+        http_exception=HTTPException,
+        request_type=Request,
+        load_users=load_users,
+        get_session_email=get_session_email,
+        user_id_for_email=_user_id_for_email,
+    )
+    get_user_role = _access_runtime["get_user_role"]
+    _extract_bearer_token = _access_runtime["_extract_bearer_token"]
+    get_current_user = _access_runtime["get_current_user"]
+    require_user = _access_runtime["require_user"]
+    require_admin = _access_runtime["require_admin"]
+    public_user = _access_runtime["public_user"]
 
 
     # ── Rate limiting & file validation — delegated to latticeai.core.security ────
@@ -908,35 +896,6 @@ def _build(config: "Optional[Config]" = None) -> Dict[str, Any]:
             raise HTTPException(status_code=403, detail="승인된 파일 내용과 요청 내용이 다릅니다.")
 
 
-    def require_admin(request: Request) -> tuple[str, Dict]:
-        users = load_users()
-        if not REQUIRE_AUTH:
-            return "", users
-        token = _extract_bearer_token(request)
-        if token:
-            email = get_session_email(token)
-            if email:
-                role = get_user_role(email, users)
-                try:
-                    require_capability(role, "admin:users")
-                    return email, users
-                except PermissionError:
-                    pass
-        raise HTTPException(status_code=403, detail="관리자 권한이 필요합니다.")
-
-    def public_user(email: str, user: Dict, users: Dict) -> Dict:
-        role = get_user_role(email, users)
-        user_id = user.get("id") or _user_id_for_email(users, email)
-        return {
-            "id": user_id,
-            "email": email,
-            "identity": user_id,
-            "name": user.get("name", ""),
-            "nickname": user.get("nickname", ""),
-            "role": role,
-            "disabled": bool(user.get("disabled", False)),
-        }
-
     def get_history_user(email: Optional[str], nickname: Optional[str] = None) -> Dict:
         if not email:
             return {"user_email": None, "user_nickname": nickname or None}
@@ -1089,7 +1048,8 @@ def _build(config: "Optional[Config]" = None) -> Dict[str, Any]:
     OPEN_REGISTRATION = CONFIG.open_registration
     INVITE_CODE = CONFIG.invite_code
     INVITE_GATE_ENABLED = CONFIG.invite_gate_enabled
-    configure_model_runtime(
+    configure_model_runtime_from_context(
+        configure_model_runtime=configure_model_runtime,
         router=router,
         APP_MODE=APP_MODE,
         DEFAULT_HOST=DEFAULT_HOST,
@@ -1236,12 +1196,10 @@ def _build(config: "Optional[Config]" = None) -> Dict[str, Any]:
     # ── Telegram chat mirror: registered only when ENABLE_TELEGRAM is truthy.
     # latticeai.api.chat no longer imports telegram_bot (a 45KB module that
     # mutates os.environ at import); it calls this injected callback instead.
-    on_chat_message = None
-    if ENABLE_TELEGRAM:
-        def _telegram_chat_mirror(role: str, text: str, source: Optional[str] = None) -> None:
-            from latticeai.integrations.telegram_bot import broadcast_web_chat
-            _spawn(broadcast_web_chat(role, text), name="telegram_broadcast")
-        on_chat_message = _telegram_chat_mirror
+    on_chat_message = maybe_build_telegram_chat_mirror(
+        enable_telegram=ENABLE_TELEGRAM,
+        spawn=_spawn,
+    )
 
     def _recent_chat_context(
         limit: int = 10,
@@ -1257,7 +1215,8 @@ def _build(config: "Optional[Config]" = None) -> Dict[str, Any]:
             conversation_id=conversation_id,
         )
 
-    CHAT_AGENT_RUNTIME = build_agent_runtime(
+    CHAT_AGENT_RUNTIME = build_chat_agent_runtime_from_context(
+        build_agent_runtime=build_agent_runtime,
         model_router=router,
         execute_tool=execute_tool,
         recent_chat_context=_recent_chat_context,
@@ -1404,22 +1363,19 @@ def _build(config: "Optional[Config]" = None) -> Dict[str, Any]:
     # ── Health / status / engine-summary router (latticeai.api.health, v1.2.0) ───
     # /health, /mode, /runtime_features, /engines(GET) now live in the health router.
     # Heavier engine mutation endpoints remain below in server_app.
-    MODEL_SERVICE = build_model_service(
+    MODEL_SERVICE = register_model_runtime_routers(
+        app=app,
+        create_health_router=create_health_router,
+        create_models_router=create_models_router,
+        register_health_and_model_routers=register_health_and_model_routers,
         model_router=router,
         runtime_features=runtime_features,
-        is_public=IS_PUBLIC_MODE,
-    )
-    register_health_and_model_routers(
-        app,
-        create_health_router=create_health_router,
-        model_service=MODEL_SERVICE,
+        is_public_mode=IS_PUBLIC_MODE,
         engine_status=engine_status,
         get_current_user=get_current_user,
         require_auth=REQUIRE_AUTH,
         app_version=APP_VERSION,
         app_mode=APP_MODE,
-        create_models_router=create_models_router,
-        model_router=router,
         require_user=require_user,
         load_users=load_users,
         get_user_role=get_user_role,
@@ -1438,7 +1394,6 @@ def _build(config: "Optional[Config]" = None) -> Dict[str, Any]:
         engine_model_catalog=ENGINE_MODEL_CATALOG,
         model_engine_aliases=MODEL_ENGINE_ALIASES,
         cloud_verify_ttl_seconds=CLOUD_VERIFY_TTL_SECONDS,
-        is_public_mode=IS_PUBLIC_MODE,
         allow_local_models=ALLOW_LOCAL_MODELS,
     )
 
@@ -1461,7 +1416,7 @@ def _build(config: "Optional[Config]" = None) -> Dict[str, Any]:
             return None
         return PLATFORM.allowed_scopes(user)
 
-    tool_router_context = ToolRouterContext(
+    tool_router_context, interaction_router_context = build_interaction_contexts(
         config=CONFIG,
         ingestion_pipeline=INGESTION_PIPELINE,
         data_dir=DATA_DIR,
@@ -1485,15 +1440,10 @@ def _build(config: "Optional[Config]" = None) -> Dict[str, Any]:
         install_mcp=install_mcp,
         mcp_public_item=mcp_public_item,
         hooks=HOOKS_REGISTRY,
-    )
-    interaction_router_context = InteractionRouterContext(
         chat_context=context,
         search_service=SEARCH_SERVICE,
         allowed_workspaces_for=_allowed_workspaces_for,
-        require_user=require_user,
         embedding_info=_embedding_info,
-        tool_context=tool_router_context,
-        hooks=HOOKS_REGISTRY,
         agent_registry=AGENT_REGISTRY,
         memory_service=MEMORY_SERVICE,
         platform=PLATFORM,
@@ -1510,25 +1460,17 @@ def _build(config: "Optional[Config]" = None) -> Dict[str, Any]:
     )
 
     from latticeai.api.review_queue import create_review_queue_router
+    run_review_item = build_review_run_now_runner(PLATFORM, HTTPException)
 
-    def _run_review_item(item, *, user_email, scope):
-        """run_now: re-execute the suggestion's source workflow (preview/regenerate)."""
-        wf_id = (item.get("payload") or {}).get("workflow_id") or (item.get("provenance") or {}).get("workflow_id")
-        if not wf_id:
-            raise HTTPException(status_code=409, detail="review item has no workflow to run")
-        return PLATFORM.run_workflow_by_id(
-            wf_id, user_email, scope, with_agent=False,
-            inputs={"__review_item__": item.get("id")},
-        )
-
-    BRAIN_NETWORK = register_review_and_brain_tail_routers(
-        app,
+    BRAIN_NETWORK = register_tail_runtime_routers(
+        app=app,
         create_review_queue_router=create_review_queue_router,
+        register_review_and_brain_tail_routers=register_review_and_brain_tail_routers,
         review_queue=REVIEW_QUEUE,
         require_user=require_user,
         gate_read=PLATFORM.gate_read,
         gate_write=PLATFORM.gate_write,
-        run_review_item=_run_review_item,
+        run_review_item=run_review_item,
         append_audit_event=append_audit_event,
         create_browser_router=create_browser_router,
         ingestion_pipeline=INGESTION_PIPELINE,

package/latticeai/core/marketplace.py

@@ -11,7 +11,7 @@ from copy import deepcopy
 from typing import Any, Dict, List, Optional
 
 
-MARKETPLACE_VERSION = "6.2.0"
+MARKETPLACE_VERSION = "6.3.1"
 TEMPLATE_KINDS = ("plugin", "workflow", "agent")
 
 

package/latticeai/core/workspace_os.py

@@ -19,7 +19,7 @@ from pathlib import Path
 from typing import Any, Callable, Dict, Iterable, List, Optional
 
 
-WORKSPACE_OS_VERSION = "6.2.0"
+WORKSPACE_OS_VERSION = "6.3.1"
 
 # Workspace types separate single-user Personal workspaces from shared
 # Organization workspaces. Both keep the same local-first JSON store; the type

package/latticeai/runtime/access_runtime.py

@@ -0,0 +1,97 @@
+"""Access-control helper closures for the app factory."""
+
+from __future__ import annotations
+
+from typing import Any, Callable, Dict, Optional
+
+
+def build_access_runtime(
+    *,
+    config: Any,
+    require_auth: bool,
+    http_exception: Any,
+    request_type: Any,
+    load_users: Callable[[], Dict],
+    get_session_email: Callable[[str], Optional[str]],
+    user_id_for_email: Callable[[Dict, str], str],
+) -> Dict[str, Any]:
+    """Build user/admin access helpers without changing legacy call signatures."""
+
+    from latticeai.core.policy import normalize_role, require_capability
+    from latticeai.core.users import normalize_email
+
+    def get_user_role(email: str, users: Optional[Dict] = None) -> str:
+        users = users or load_users()
+        identity = str(email or "")
+        normalized_email = normalize_email(identity)
+        user = users.get(normalized_email) or users.get(identity) or next(
+            (
+                item
+                for item in users.values()
+                if isinstance(item, dict) and item.get("id") == identity
+            ),
+            {},
+        )
+        if isinstance(user, dict) and user.get("role"):
+            return normalize_role(user["role"])
+        admin_emails = {normalize_email(item) for item in config.admin_emails}
+        if normalized_email in admin_emails:
+            return "admin"
+        first_email = next(iter(users), None)
+        return "admin" if first_email == normalized_email else "user"
+
+    def extract_bearer_token(request: request_type) -> Optional[str]:
+        auth = request.headers.get("Authorization", "")
+        if auth.startswith("Bearer "):
+            return auth[7:].strip()
+        return request.cookies.get("session_token")
+
+    def get_current_user(request: request_type) -> Optional[str]:
+        token = extract_bearer_token(request)
+        if token:
+            return get_session_email(token)
+        return None
+
+    def require_user(request: request_type) -> str:
+        email = get_current_user(request)
+        if require_auth and not email:
+            raise http_exception(status_code=401, detail="인증이 필요합니다.")
+        return email or ""
+
+    def require_admin(request: request_type) -> tuple[str, Dict]:
+        users = load_users()
+        if not require_auth:
+            return "", users
+        token = extract_bearer_token(request)
+        if token:
+            email = get_session_email(token)
+            if email:
+                role = get_user_role(email, users)
+                try:
+                    require_capability(role, "admin:users")
+                    return email, users
+                except PermissionError:
+                    pass
+        raise http_exception(status_code=403, detail="관리자 권한이 필요합니다.")
+
+    def public_user(email: str, user: Dict, users: Dict) -> Dict:
+        role = get_user_role(email, users)
+        user_id = user.get("id") or user_id_for_email(users, email)
+        return {
+            "id": user_id,
+            "email": email,
+            "identity": user_id,
+            "name": user.get("name", ""),
+            "nickname": user.get("nickname", ""),
+            "role": role,
+            "disabled": bool(user.get("disabled", False)),
+        }
+
+    return {
+        "get_user_role": get_user_role,
+        "_extract_bearer_token": extract_bearer_token,
+        "get_current_user": get_current_user,
+        "require_user": require_user,
+        "require_admin": require_admin,
+        "public_user": public_user,
+    }

package/latticeai/runtime/chat_wiring.py

@@ -0,0 +1,119 @@
+"""Chat and interaction wiring seam for ``latticeai.app_factory``."""
+
+from __future__ import annotations
+
+from typing import Any, Optional
+
+from latticeai.services.router_context import InteractionRouterContext, ToolRouterContext
+
+
+def build_chat_agent_runtime_from_context(
+    *,
+    build_agent_runtime: Any,
+    model_router: Any,
+    execute_tool: Any,
+    recent_chat_context: Any,
+    clear_history: Any,
+    knowledge_save: Any,
+    audit: Any,
+    hooks: Any,
+    brain_memory: Any,
+) -> Any:
+    return build_agent_runtime(
+        model_router=model_router,
+        execute_tool=execute_tool,
+        recent_chat_context=recent_chat_context,
+        clear_history=clear_history,
+        knowledge_save=knowledge_save,
+        audit=audit,
+        hooks=hooks,
+        brain_memory=brain_memory,
+    )
+
+
+def build_interaction_contexts(
+    *,
+    config: Any,
+    ingestion_pipeline: Any,
+    data_dir: Any,
+    static_dir: Any,
+    model_router: Any,
+    require_user: Any,
+    require_admin: Any,
+    get_current_user: Any,
+    clear_history: Any,
+    append_audit_event: Any,
+    enforce_rate_limit: Any,
+    bytes_match_extension: Any,
+    classify_sensitive_message: Any,
+    save_to_history: Any,
+    enable_graph: bool,
+    knowledge_graph: Any,
+    require_graph: Any,
+    local_kg_watcher: Any,
+    load_mcp_installs: Any,
+    recommend_mcps: Any,
+    install_mcp: Any,
+    mcp_public_item: Any,
+    hooks: Any,
+    chat_context: Any,
+    search_service: Any,
+    allowed_workspaces_for: Any,
+    embedding_info: Any,
+    agent_registry: Any,
+    memory_service: Any,
+    platform: Any,
+) -> tuple[ToolRouterContext, InteractionRouterContext]:
+    tool_router_context = ToolRouterContext(
+        config=config,
+        ingestion_pipeline=ingestion_pipeline,
+        data_dir=data_dir,
+        static_dir=static_dir,
+        model_router=model_router,
+        require_user=require_user,
+        require_admin=require_admin,
+        get_current_user=get_current_user,
+        clear_history=clear_history,
+        append_audit_event=append_audit_event,
+        enforce_rate_limit=enforce_rate_limit,
+        bytes_match_extension=bytes_match_extension,
+        classify_sensitive_message=classify_sensitive_message,
+        save_to_history=save_to_history,
+        enable_graph=enable_graph,
+        knowledge_graph=knowledge_graph,
+        require_graph=require_graph,
+        local_kg_watcher=local_kg_watcher,
+        load_mcp_installs=load_mcp_installs,
+        recommend_mcps=recommend_mcps,
+        install_mcp=install_mcp,
+        mcp_public_item=mcp_public_item,
+        hooks=hooks,
+    )
+    interaction_router_context = InteractionRouterContext(
+        chat_context=chat_context,
+        search_service=search_service,
+        allowed_workspaces_for=allowed_workspaces_for,
+        require_user=require_user,
+        embedding_info=embedding_info,
+        tool_context=tool_router_context,
+        hooks=hooks,
+        agent_registry=agent_registry,
+        memory_service=memory_service,
+        platform=platform,
+    )
+    return tool_router_context, interaction_router_context
+
+
+def maybe_build_telegram_chat_mirror(
+    *,
+    enable_telegram: bool,
+    spawn: Any,
+) -> Optional[Any]:
+    if not enable_telegram:
+        return None
+
+    def telegram_chat_mirror(role: str, text: str, source: Optional[str] = None) -> None:
+        from latticeai.integrations.telegram_bot import broadcast_web_chat
+        spawn(broadcast_web_chat(role, text), name="telegram_broadcast")
+
+    return telegram_chat_mirror

package/latticeai/runtime/model_wiring.py

@@ -0,0 +1,40 @@
+"""Model/runtime wiring seam for ``latticeai.app_factory``."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from latticeai.runtime.platform_services_runtime import build_model_service
+
+
+def configure_model_runtime_from_context(**kwargs: Any) -> None:
+    configure_model_runtime = kwargs.pop("configure_model_runtime")
+    configure_model_runtime(**kwargs)
+
+
+def register_model_runtime_routers(
+    *,
+    app: Any,
+    create_health_router: Any,
+    create_models_router: Any,
+    register_health_and_model_routers: Any,
+    model_router: Any,
+    runtime_features: Any,
+    is_public_mode: bool,
+    **kwargs: Any,
+) -> Any:
+    model_service = build_model_service(
+        model_router=model_router,
+        runtime_features=runtime_features,
+        is_public=is_public_mode,
+    )
+    register_health_and_model_routers(
+        app,
+        create_health_router=create_health_router,
+        model_service=model_service,
+        create_models_router=create_models_router,
+        model_router=model_router,
+        is_public_mode=is_public_mode,
+        **kwargs,
+    )
+    return model_service

package/latticeai/runtime/platform_runtime_wiring.py

@@ -9,9 +9,6 @@ from __future__ import annotations
 
 from typing import Any, Callable, Dict
 
-from latticeai.runtime.automation_runtime import build_automation_runtime
-from latticeai.services.platform_runtime import PlatformRuntime
-
 
 def build_platform_automation_runtime(
     *,
@@ -34,6 +31,8 @@ def build_platform_automation_runtime(
     ``app_factory._build`` so ``dict(locals())`` continues to expose the legacy
     ``server_app`` compatibility surface.
     """
+    from latticeai.runtime.automation_runtime import build_automation_runtime
+    from latticeai.services.platform_runtime import PlatformRuntime
 
     def _llm_generate_sync(
         message: str,

package/latticeai/runtime/review_wiring.py

@@ -0,0 +1,37 @@
+"""Review Center runtime wiring helpers."""
+
+from __future__ import annotations
+
+from typing import Any, Callable, Dict, Optional
+
+
+def build_review_run_now_runner(platform: Any, http_exception: type[Exception]) -> Callable[..., Any]:
+    """Build the Review Center run-now runner used by the API router.
+
+    The runner preserves the public contract: "Run now" previews/regenerates the
+    source workflow, records a fresh run id, and leaves approval status unchanged.
+    """
+
+    def run_review_item(
+        item: Dict[str, Any],
+        *,
+        user_email: Optional[str],
+        scope: Optional[str],
+    ) -> Any:
+        payload = item.get("payload") or {}
+        provenance = item.get("provenance") or {}
+        workflow_id = payload.get("workflow_id") or provenance.get("workflow_id")
+        if not workflow_id:
+            raise http_exception(status_code=409, detail="review item has no workflow to run")
+        return platform.run_workflow_by_id(
+            workflow_id,
+            user_email,
+            scope,
+            with_agent=False,
+            inputs={"__review_item__": item.get("id")},
+        )
+
+    return run_review_item
+
+
+__all__ = ["build_review_run_now_runner"]

package/latticeai/runtime/tail_wiring.py

@@ -0,0 +1,21 @@
+"""Review, browser, portability, network, garden, and setup tail wiring."""
+
+from __future__ import annotations
+
+from typing import Any
+
+
+def register_tail_runtime_routers(
+    *,
+    app: Any,
+    create_review_queue_router: Any,
+    register_review_and_brain_tail_routers: Any,
+    build_brain_network: Any,
+    **kwargs: Any,
+) -> Any:
+    return register_review_and_brain_tail_routers(
+        app,
+        create_review_queue_router=create_review_queue_router,
+        build_brain_network=build_brain_network,
+        **kwargs,
+    )

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ltcai",
-  "version": "6.2.0",
+  "version": "6.3.1",
   "description": "Lattice AI — local-first Digital Brain that keeps your knowledge durable across any AI model.",
   "homepage": "https://github.com/TaeSooPark-PTS/LatticeAI#readme",
   "repository": {
@@ -23,7 +23,7 @@
     "build:assets": "vite build && node scripts/build_frontend_assets.mjs",
     "build:python": "node scripts/run_python.mjs -m build",
     "check:python": "node scripts/run_python.mjs scripts/check_python.py",
-    "lint": "node --check tests/visual/mock_server.cjs && node --check tests/visual/v3.spec.js && npm run lint:frontend",
+    "lint": "node --check tests/visual/mock_server.cjs && node --check tests/visual/v3.spec.js && npm run lint:frontend && node scripts/check_i18n_literals.mjs",
     "lint:frontend": "node scripts/lint_frontend.mjs",
     "docs:check-links": "node scripts/check_markdown_links.mjs",
     "typecheck": "npm run typecheck:frontend && cd vscode-extension && npm run build",