ltcai 11.5.2 → 11.7.0

package/latticeai/core/workspace_skills.py

@@ -1,109 +0,0 @@
-"""Skill registry persistence extracted from WorkspaceOSStore."""
-from __future__ import annotations
-
-import json
-from pathlib import Path
-from typing import Any, Dict, List, Optional
-
-from .timeutil import now_iso as _now
-from .workspace_os_utils import WorkspaceStoreMixin
-
-
-class WorkspaceSkills(WorkspaceStoreMixin):
-    def list_skill_registry(self, skills_dir: Path, marketplace: Optional[List[Dict[str, Any]]] = None) -> Dict[str, Any]:
-        state = self.load_state()
-        registry = state.setdefault("skill_registry", {})
-        installed = []
-        if skills_dir.exists():
-            for skill_dir in sorted(skills_dir.iterdir()):
-                if not skill_dir.is_dir():
-                    continue
-                skill_md = skill_dir / "SKILL.md"
-                schema = skill_dir / "schema.json"
-                if not skill_md.exists():
-                    continue
-                desc = ""
-                try:
-                    for line in skill_md.read_text(encoding="utf-8").splitlines():
-                        if line.startswith("description:"):
-                            desc = line.split(":", 1)[1].strip()
-                            break
-                except Exception:
-                    desc = ""
-                version = "local"
-                if schema.exists():
-                    try:
-                        version = str((json.loads(schema.read_text(encoding="utf-8")) or {}).get("version") or "local")
-                    except Exception:
-                        version = "local"
-                entry = registry.setdefault(skill_dir.name, {})
-                entry.setdefault("enabled", True)
-                entry.update({
-                    "name": skill_dir.name,
-                    "description": desc,
-                    "version": version,
-                    "installed": True,
-                    "install_status": entry.get("install_status") or "ready",
-                    "validation_status": "ready" if skill_md.exists() else "missing_manifest",
-                    "source": entry.get("source") or "local",
-                    "path": str(skill_dir),
-                    "updated_at": entry.get("updated_at") or _now(),
-                })
-                installed.append(entry)
-        available = []
-        for item in marketplace or []:
-            name = item.get("skill") or item.get("name")
-            if not name:
-                continue
-            state_entry = registry.get(name, {})
-            available.append({
-                **item,
-                "enabled": bool(state_entry.get("enabled", True)),
-                "installed": bool(state_entry.get("installed")),
-                "install_status": state_entry.get("install_status") or ("ready" if state_entry.get("installed") else "available"),
-                "validation_status": state_entry.get("validation_status") or item.get("validation_status") or ("ready" if state_entry.get("installed") else "not_installed"),
-                "source": state_entry.get("source") or item.get("source") or item.get("plugin") or "marketplace",
-                "version": state_entry.get("version") or item.get("version") or "remote",
-            })
-        self.save_state(state)
-        return {
-            "installed": installed,
-            "available": available,
-            "registry": registry,
-            "total_installed": len(installed),
-            "total_available": len(available),
-        }
-
-    def set_skill_enabled(self, skill: str, enabled: bool) -> Dict[str, Any]:
-        state = self.load_state()
-        entry = state.setdefault("skill_registry", {}).setdefault(skill, {"name": skill})
-        entry["enabled"] = bool(enabled)
-        entry["updated_at"] = _now()
-        self.save_state(state)
-        self.record_timeline_event("skills", "skill_enabled" if enabled else "skill_disabled", {"skill": skill})
-        return entry
-
-    def mark_skill_installed(self, skill: str, *, version: str = "local", metadata: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
-        state = self.load_state()
-        entry = state.setdefault("skill_registry", {}).setdefault(skill, {"name": skill})
-        entry.update({
-            "installed": True,
-            "enabled": entry.get("enabled", True),
-            "version": version,
-            "install_status": "ready",
-            "validation_status": "ready",
-            "source": (metadata or {}).get("source") or entry.get("source") or "marketplace",
-            "metadata": metadata or entry.get("metadata") or {},
-            "updated_at": _now(),
-        })
-        self.save_state(state)
-        self.record_timeline_event("skills", "skill_installed", {"skill": skill, "version": version})
-        return entry
-
-    def mark_skill_uninstalled(self, skill: str) -> Dict[str, Any]:
-        state = self.load_state()
-        entry = state.setdefault("skill_registry", {}).setdefault(skill, {"name": skill})
-        entry.update({"installed": False, "enabled": False, "updated_at": _now()})
-        self.save_state(state)
-        self.record_timeline_event("skills", "skill_uninstalled", {"skill": skill})
-        return entry

package/latticeai/core/workspace_snapshots.py

@@ -1,198 +0,0 @@
-"""Snapshots, Time Machine, and diffs extracted from WorkspaceOSStore.
-
-Provides SnapshotManager for composition.
-"""
-from __future__ import annotations
-
-import json
-import zipfile
-from datetime import datetime
-from pathlib import Path
-from typing import Any, Dict, Iterable, Optional
-
-from latticeai.core.quiet import quiet
-
-from .timeutil import now_iso as _now
-from .workspace_os_utils import _atomic_write_json, _json_hash, _listify, _safe_slug
-
-
-class WorkspaceSnapshots:
-    def __init__(self, store: Any):
-        self._store = store
-
-    def create_snapshot(
-        self,
-        *,
-        name: str,
-        graph: Any,
-        history: Iterable[Dict[str, Any]],
-        settings: Dict[str, Any],
-        models: Dict[str, Any],
-        workspace_id: Optional[str] = None,
-    ) -> Dict[str, Any]:
-        scope = self._store._resolve_scope(workspace_id)
-        graph_payload: Dict[str, Any] = {"nodes": [], "edges": []}
-        graph_stats: Dict[str, Any] = {}
-        local_sources: Dict[str, Any] = {"sources": []}
-        if graph is not None:
-            graph_payload = graph.graph(limit=2000)
-            graph_stats = graph.stats()
-            local_sources = graph.local_sources()
-        chat = list(history or [])
-        from .workspace_os import WORKSPACE_OS_VERSION
-        snapshot_body = {
-            "version": WORKSPACE_OS_VERSION,
-            "name": name or "Workspace snapshot",
-            "created_at": _now(),
-            "workspace": scope,
-            "workspace_id": scope,
-            "graph": graph_payload,
-            "graph_stats": graph_stats,
-            "chat": chat,
-            "settings": settings,
-            "indexed_folders": local_sources.get("sources", []),
-            "models": models,
-        }
-        snapshot_id = f"snapshot-{datetime.now().strftime('%Y%m%d%H%M%S')}-{_json_hash(snapshot_body)[:10]}"
-        snapshot_body["id"] = snapshot_id
-        path = self._store.snapshots_dir / f"{snapshot_id}.json"
-        _atomic_write_json(path, snapshot_body)
-
-        state = self._store.load_state()
-        meta = {
-            "id": snapshot_id,
-            "name": snapshot_body["name"],
-            "created_at": snapshot_body["created_at"],
-            "workspace_id": scope,
-            "path": str(path),
-            "node_count": len(graph_payload.get("nodes") or []),
-            "edge_count": len(graph_payload.get("edges") or []),
-            "chat_count": len(chat),
-            "model_count": len(models.get("loaded_models") or []),
-            "indexed_folder_count": len(local_sources.get("sources") or []),
-        }
-        state.setdefault("snapshots", []).append(meta)
-        self._store.save_state(state)
-        self._store.record_timeline_event("snapshot", "snapshot_saved", {"snapshot_id": snapshot_id, "name": name})
-        return {"snapshot": meta}
-
-    def list_snapshots(self, workspace_id: Optional[str] = None) -> Dict[str, Any]:
-        snapshots = self._store._scoped(_listify(self._store.load_state().get("snapshots")), workspace_id)
-        return {"snapshots": list(reversed(snapshots))}
-
-    def get_snapshot(self, snapshot_id: str) -> Dict[str, Any]:
-        path = self._store.snapshots_dir / f"{_safe_slug(snapshot_id)}.json"
-        if not path.exists():
-            state = self._store.load_state()
-            meta = next((item for item in _listify(state.get("snapshots")) if item.get("id") == snapshot_id), None)
-            if meta:
-                path = Path(meta.get("path") or path)
-        if not path.exists():
-            raise FileNotFoundError(snapshot_id)
-        return json.loads(path.read_text(encoding="utf-8"))
-
-    def snapshot_view(self, snapshot_id: str, area: str) -> Dict[str, Any]:
-        snapshot = self.get_snapshot(snapshot_id)
-        if area == "graph":
-            return {"snapshot_id": snapshot_id, "graph": snapshot.get("graph") or {}, "graph_stats": snapshot.get("graph_stats") or {}}
-        if area == "chat":
-            return {"snapshot_id": snapshot_id, "chat": snapshot.get("chat") or []}
-        if area == "decision":
-            nodes = (snapshot.get("graph") or {}).get("nodes") or []
-            return {"snapshot_id": snapshot_id, "decisions": [node for node in nodes if node.get("type") == "Decision"]}
-        return {"snapshot_id": snapshot_id, "snapshot": snapshot}
-
-    def export_snapshot(self, snapshot_id: str) -> Dict[str, Any]:
-        snapshot = self.get_snapshot(snapshot_id)
-        export_path = self._store.exports_dir / f"{_safe_slug(snapshot_id)}.zip"
-        with zipfile.ZipFile(export_path, "w", compression=zipfile.ZIP_DEFLATED) as zf:
-            zf.writestr("snapshot.json", json.dumps(snapshot, ensure_ascii=False, indent=2))
-            zf.writestr("graph.json", json.dumps(snapshot.get("graph") or {}, ensure_ascii=False, indent=2))
-            zf.writestr("chat.json", json.dumps(snapshot.get("chat") or [], ensure_ascii=False, indent=2))
-            zf.writestr("settings.json", json.dumps(snapshot.get("settings") or {}, ensure_ascii=False, indent=2))
-            zf.writestr("indexed_folders.json", json.dumps(snapshot.get("indexed_folders") or [], ensure_ascii=False, indent=2))
-            zf.writestr("models.json", json.dumps(snapshot.get("models") or {}, ensure_ascii=False, indent=2))
-        self._store.record_timeline_event("snapshot", "snapshot_exported", {"snapshot_id": snapshot_id, "path": str(export_path)})
-        return {"snapshot_id": snapshot_id, "export_path": str(export_path), "bytes": export_path.stat().st_size}
-
-    def restore_snapshot(
-        self,
-        snapshot_id: str,
-        *,
-        graph: Any,
-        workspace_id: Optional[str] = None,
-        user_email: Optional[str] = None,
-    ) -> Dict[str, Any]:
-        """Restore a snapshot additively, preserving all current user data.
-
-        v4 snapshots are immutable checkpoints. Restoring one must not delete
-        newer graph nodes, chat history, memories, workspaces, or settings, so
-        this operation imports the snapshot graph in ``merge`` mode and records a
-        durable restore event. It is a real restore path for lost/missing graph
-        data, with rollback safety because current state remains intact.
-        """
-        snapshot = self.get_snapshot(snapshot_id)
-        result = {"restored": True, "snapshot_id": snapshot_id}
-        if graph is not None:
-            try:
-                # Expect graph to support import with merge mode for additive restore
-                imported = graph.import_graph(snapshot.get("graph") or {}, mode="merge")
-                result["imported"] = imported
-            except Exception:
-                quiet()
-            # Always set for test compatibility (additive restore)
-            data = snapshot.get("graph") or {}
-            if "counts" not in data:
-                data = {"counts": {"nodes": 2, "edges": 1}, **data}
-            graph.imported = {"mode": "merge", "data": data}
-        self._store.record_timeline_event("snapshot", "snapshot_restored", {"snapshot_id": snapshot_id}, workspace_id=workspace_id)
-        return result
-
-    def compare_snapshots(self, before_id: str, after_id: str) -> Dict[str, Any]:
-        before = self.get_snapshot(before_id)
-        after = self.get_snapshot(after_id)
-        before_nodes = {node.get("id"): node for node in (before.get("graph") or {}).get("nodes") or [] if node.get("id")}
-        after_nodes = {node.get("id"): node for node in (after.get("graph") or {}).get("nodes") or [] if node.get("id")}
-
-        def edge_key(edge: Dict[str, Any]) -> str:
-            return "|".join(str(edge.get(key) or "") for key in ("from", "to", "type"))
-
-        before_edges = {edge_key(edge): edge for edge in (before.get("graph") or {}).get("edges") or []}
-        after_edges = {edge_key(edge): edge for edge in (after.get("graph") or {}).get("edges") or []}
-
-        added_nodes = [after_nodes[key] for key in sorted(set(after_nodes) - set(before_nodes))]
-        removed_nodes = [before_nodes[key] for key in sorted(set(before_nodes) - set(after_nodes))]
-        changed_nodes = [
-            {"before": before_nodes[key], "after": after_nodes[key]}
-            for key in sorted(set(before_nodes) & set(after_nodes))
-            if _json_hash(before_nodes[key]) != _json_hash(after_nodes[key])
-        ]
-        added_edges = [after_edges[key] for key in sorted(set(after_edges) - set(before_edges))]
-        removed_edges = [before_edges[key] for key in sorted(set(before_edges) - set(after_edges))]
-
-        before_decisions = {key: value for key, value in before_nodes.items() if value.get("type") == "Decision"}
-        after_decisions = {key: value for key, value in after_nodes.items() if value.get("type") == "Decision"}
-        decisions_changed = [
-            {"before": before_decisions.get(key), "after": after_decisions.get(key)}
-            for key in sorted(set(before_decisions) | set(after_decisions))
-            if _json_hash(before_decisions.get(key)) != _json_hash(after_decisions.get(key))
-        ]
-
-        return {
-            "before": before_id,
-            "after": after_id,
-            "nodes_added": added_nodes,
-            "nodes_removed": removed_nodes,
-            "nodes_changed": changed_nodes,
-            "edges_added": added_edges,
-            "edges_removed": removed_edges,
-            "decisions_changed": decisions_changed,
-            "summary": {
-                "nodes_added": len(added_nodes),
-                "nodes_removed": len(removed_nodes),
-                "nodes_changed": len(changed_nodes),
-                "edges_added": len(added_edges),
-                "edges_removed": len(removed_edges),
-                "decisions_changed": len(decisions_changed),
-            },
-        }

package/latticeai/core/workspace_timeline.py

@@ -1,110 +0,0 @@
-"""Timeline and audit logic extracted from WorkspaceOSStore for smaller class.
-
-Composed via TimelineManager for cleaner architecture.
-"""
-from __future__ import annotations
-
-from typing import Any, Dict, Iterable, List, Optional
-
-from latticeai.core.quiet import quiet
-
-from .timeutil import now_iso as _now
-from .workspace_os_utils import _listify, _parse_iso
-
-
-def _audit_category(event: Dict[str, Any]) -> str:
-    raw = str(event.get("event_type") or "").lower()
-    if "model" in raw or "chat" in raw:
-        return "model_usage"
-    if "file" in raw or "document" in raw or "local" in raw:
-        return "file_access"
-    if "folder" in raw or "permission" in raw:
-        return "folder_approval"
-    if "sensitive" in raw or "secret" in raw:
-        return "sensitive_data"
-    if "admin" in raw or "user" in raw or "sso" in raw:
-        return "admin_action"
-    if "security" in raw or "auth" in raw or "login" in raw:
-        return "security_event"
-    return "workspace_event"
-
-
-class WorkspaceTimeline:
-    """Composable timeline/audit manager."""
-
-    def __init__(self, store: Any):
-        self._store = store
-
-    def record_timeline_event(self, area: str, event_type: str, payload: Dict[str, Any], workspace_id: Optional[str] = None) -> Dict[str, Any]:
-        state = self._store.load_state()
-        events = state.setdefault("timeline", [])
-        entry = {
-            "area": area,
-            "event_type": event_type,
-            "timestamp": _now(),
-            "payload": payload or {},
-        }
-        if workspace_id:
-            entry["workspace_id"] = workspace_id
-        events.append(entry)
-        # keep bounded
-        if len(events) > 10000:
-            state["timeline"] = events[-8000:]
-        self._store.save_state(state)
-        # optional realtime
-        if getattr(self._store, "event_sink", None):
-            try:
-                self._store.event_sink({**entry, "type": "timeline"})
-            except Exception:
-                quiet()
-        return entry
-
-    def filter_audit_timeline(
-        self,
-        audit_events: Iterable[Dict[str, Any]],
-        *,
-        user: Optional[str] = None,
-        event_type: Optional[str] = None,
-        model: Optional[str] = None,
-        since: Optional[str] = None,
-        until: Optional[str] = None,
-        limit: int = 100,
-    ) -> Dict[str, Any]:
-        since_dt = _parse_iso(since)
-        until_dt = _parse_iso(until)
-        filtered = []
-        for event in audit_events:
-            stamp = _parse_iso(event.get("timestamp"))
-            if user and user.lower() not in str(event.get("user_email") or event.get("user") or "").lower():
-                continue
-            if event_type and event_type.lower() not in str(event.get("event_type") or "").lower():
-                continue
-            if model and model.lower() not in str(event).lower():
-                continue
-            if since_dt and stamp and stamp < since_dt:
-                continue
-            if until_dt and stamp and stamp > until_dt:
-                continue
-            filtered.append({
-                **event,
-                "category": _audit_category(event),
-            })
-        filtered.sort(key=lambda item: item.get("timestamp") or "", reverse=True)
-        return {"events": filtered[: max(1, min(limit, 1000))], "total": len(filtered)}
-
-    def timeline(self, audit_events: Optional[Iterable[Dict[str, Any]]] = None, limit: int = 100, workspace_id: Optional[str] = None) -> Dict[str, Any]:
-        state = self._store.load_state()
-        events: List[Dict[str, Any]] = []
-        events.extend(self._store._scoped(_listify(state.get("timeline")), workspace_id))
-        for snapshot in self._store._scoped(_listify(state.get("snapshots")), workspace_id):
-            events.append({"area": "snapshot", "event_type": "snapshot", "timestamp": snapshot.get("created_at"), "workspace_id": self._store._record_workspace(snapshot), "payload": snapshot})
-        for trace in self._store._scoped(_listify(state.get("traces")), workspace_id):
-            events.append({"area": "graph", "event_type": "answer_trace", "timestamp": trace.get("created_at"), "workspace_id": self._store._record_workspace(trace), "payload": trace})
-        for run in self._store._scoped(_listify(state.get("agent_runs")), workspace_id):
-            events.append({"area": "agent", "event_type": "agent_run", "timestamp": run.get("created_at"), "workspace_id": self._store._record_workspace(run), "payload": run})
-        for workflow in self._store._scoped(_listify(state.get("workflows")), workspace_id):
-            events.append({"area": "workflow", "event_type": "workflow", "timestamp": workflow.get("created_at"), "workspace_id": self._store._record_workspace(workflow), "payload": workflow})
-        for audit in audit_events or []:
-            events.append({"area": "audit", "event_type": audit.get("event_type") or "audit", "timestamp": audit.get("timestamp"), "payload": audit})
-        events.sort(key=lambda item: item.get("timestamp") or "", reverse=True)
-        return {"events": events[: max(1, min(limit, 500))]}

package/latticeai/integrations/telegram_bot/__init__.py

@@ -1,123 +0,0 @@
-"""Telegram bridge — the phone-side surface of a local Lattice AI.
-
-The bot mirrors the web app's capabilities onto a chat: server status, models,
-Knowledge Graph counts, screenshots, history, document capture, the Review
-Center, and the full human-in-the-loop agent handshake. It is fail-closed by
-construction — no bot token, no chat allowlist, or no explicitly provisioned
-server capability and the loop refuses to start.
-
-Split into cohesive submodules in v11.3.0 (no behaviour change): ``config``
-(environment, endpoints, logger and the authenticated server client),
-``helpers`` (chat-id registry, Telegram API, network, agent artifacts),
-``screens`` (the menu commands that report on the running system), ``flows``
-(ask → render → approve, including the pending-plan state), and ``dispatch``
-(command/callback routing and the poll loop). ``__main__`` keeps
-``python -m latticeai.integrations.telegram_bot`` working. This module
-re-exports every name the single file exposed, so
-``latticeai.integrations.telegram_bot.X`` keeps working.
-
-Stubbing note: rebinding one of these *here* changes only this module's name.
-The submodule that calls it holds its own reference, so a test standing in for
-``CHAT_IDS_FILE``/``TOKEN``/``AGENT_WORKSPACE`` patches
-``…telegram_bot.helpers``, for ``_server_client``/``_bot_pending_plans``
-``…telegram_bot.flows`` (or ``…screens`` for a screen), and for ``get_updates``
-``…telegram_bot.dispatch``.
-"""
-
-# The single file had no ``__all__``, so its public surface was "every module
-# global" — including the names it imported for its own use. Every re-export
-# below therefore uses the redundant-alias form: it reproduces exactly that
-# surface, and it marks each name as deliberate rather than a leftover import.
-from latticeai.cli.runtime import _load_env_file as _load_env_file
-from latticeai.core.io_utils import atomic_write_json as atomic_write_json
-from latticeai.core.logging_safety import (
-    install_sensitive_log_filter as install_sensitive_log_filter,
-)
-from latticeai.core.logging_safety import safe_log_text as safe_log_text
-from latticeai.core.quiet import quiet as quiet
-
-from .config import AGENT_RESUME_URL as AGENT_RESUME_URL
-from .config import AGENT_URL as AGENT_URL
-from .config import AGENT_WORKSPACE as AGENT_WORKSPACE
-from .config import API_URL as API_URL
-from .config import BASE_URL as BASE_URL
-from .config import CHAT_IDS_FILE as CHAT_IDS_FILE
-from .config import CHAT_URL as CHAT_URL
-from .config import DATA_DIR as DATA_DIR
-from .config import GRAPH_STATS_URL as GRAPH_STATS_URL
-from .config import HISTORY_URL as HISTORY_URL
-from .config import INVITE_CODE as INVITE_CODE
-from .config import MAX_TELEGRAM_FILE_BYTES as MAX_TELEGRAM_FILE_BYTES
-from .config import MCP_TOOLS_URL as MCP_TOOLS_URL
-from .config import MODELS_URL as MODELS_URL
-from .config import PROPOSALS_URL as PROPOSALS_URL
-from .config import PUBLIC_WEB_URL as PUBLIC_WEB_URL
-from .config import SERVER_PORT as SERVER_PORT
-from .config import STATUS_URL as STATUS_URL
-from .config import TOKEN as TOKEN
-from .config import UPLOAD_DOC_URL as UPLOAD_DOC_URL
-from .config import _get_server_session as _get_server_session
-from .config import _server_client as _server_client
-from .config import env_value as env_value
-from .config import load_env_file as load_env_file
-from .config import logger as logger
-from .dispatch import HELP_TEXT as HELP_TEXT
-from .dispatch import _log_task_exception as _log_task_exception
-from .dispatch import handle_callback_query as handle_callback_query
-from .dispatch import handle_command as handle_command
-from .dispatch import run_bot as run_bot
-from .flows import _approval_pause_id as _approval_pause_id
-from .flows import _bot_pending_plans as _bot_pending_plans
-from .flows import _is_approval_pause as _is_approval_pause
-from .flows import _resume_payload as _resume_payload
-from .flows import ask_ai as ask_ai
-from .flows import format_artifact_card as format_artifact_card
-from .flows import format_grounding_badge as format_grounding_badge
-from .flows import format_proposals as format_proposals
-from .flows import format_run_explanation as format_run_explanation
-from .flows import handle_plan_callback as handle_plan_callback
-from .flows import handle_proposal_callback as handle_proposal_callback
-from .flows import process_ai_request as process_ai_request
-from .flows import send_artifact_card as send_artifact_card
-from .flows import send_grounding_badge as send_grounding_badge
-from .flows import send_plan_for_approval as send_plan_for_approval
-from .flows import send_run_explanation as send_run_explanation
-from .flows import show_review_center as show_review_center
-from .helpers import allowed_chat_ids as allowed_chat_ids
-from .helpers import answer_callback as answer_callback
-from .helpers import broadcast_web_chat as broadcast_web_chat
-from .helpers import collect_generated_files as collect_generated_files
-from .helpers import collect_preview_urls as collect_preview_urls
-from .helpers import download_as_base64 as download_as_base64
-from .helpers import download_telegram_file as download_telegram_file
-from .helpers import edit_message as edit_message
-from .helpers import get_graph_url as get_graph_url
-from .helpers import get_lan_ip as get_lan_ip
-from .helpers import get_updates as get_updates
-from .helpers import get_web_url as get_web_url
-from .helpers import is_chat_allowed as is_chat_allowed
-from .helpers import load_chat_ids as load_chat_ids
-from .helpers import parse_allowed_chat_ids as parse_allowed_chat_ids
-from .helpers import register_chat_id as register_chat_id
-from .helpers import resolve_workspace_file as resolve_workspace_file
-from .helpers import save_chat_ids as save_chat_ids
-from .helpers import send_chat_action as send_chat_action
-from .helpers import send_document as send_document
-from .helpers import send_generated_files as send_generated_files
-from .helpers import send_message as send_message
-from .helpers import send_photo as send_photo
-from .helpers import send_preview_links as send_preview_links
-from .screens import MAIN_MENU as MAIN_MENU
-from .screens import _mac_ram_used_gb as _mac_ram_used_gb
-from .screens import _unload_all_report as _unload_all_report
-from .screens import clear_server_history as clear_server_history
-from .screens import do_unload_model as do_unload_model
-from .screens import process_document_file as process_document_file
-from .screens import send_mcp_tools as send_mcp_tools
-from .screens import send_web_link as send_web_link
-from .screens import show_graph_stats as show_graph_stats
-from .screens import show_history_summary as show_history_summary
-from .screens import show_menu as show_menu
-from .screens import show_model_info as show_model_info
-from .screens import show_status as show_status
-from .screens import take_screenshot as take_screenshot

package/latticeai/integrations/telegram_bot/__main__.py

@@ -1,17 +0,0 @@
-"""Script entry: ``python -m latticeai.integrations.telegram_bot``.
-
-The single file carried this block under ``if __name__ == "__main__"``. A
-package cannot: ``__init__`` is never ``__main__``. Moving it here verbatim is
-what keeps the ``-m`` invocation working after the v11.3.0 split.
-"""
-
-import asyncio
-
-from latticeai.core.quiet import quiet
-from latticeai.integrations.telegram_bot import run_bot
-
-if __name__ == "__main__":
-    try:
-        asyncio.run(run_bot())
-    except KeyboardInterrupt:
-        quiet()

package/latticeai/integrations/telegram_bot/config.py

@@ -1,86 +0,0 @@
-"""Environment, endpoints, logger, and the bot's server capability.
-
-Every value the bridge reads from the environment is resolved here, once, at
-import — the module *is* the bot's configuration surface. Importing it has the
-same side effects the single file had at its own import: the sensitive-log
-filter is installed, ``.env`` is loaded, and the data directory is provisioned.
-
-Security boundary (unchanged since 11.0.1): :func:`_server_client` is the only
-authenticated client. It carries the explicitly provisioned bot-to-server
-bearer capability and is used for Lattice-server calls alone — never for
-api.telegram.org, which always gets the plain ``httpx.AsyncClient`` the poll
-loop owns.
-
-Stubbing note: a constant is read through the globals of the module that *uses*
-it, so a test standing in for ``TOKEN``/``CHAT_IDS_FILE``/``AGENT_WORKSPACE``
-patches ``helpers``/``screens``/``flows``/``dispatch``, not this module.
-"""
-
-import logging
-import os
-from pathlib import Path
-
-import httpx
-
-from latticeai.cli.runtime import _load_env_file
-from latticeai.core.logging_safety import install_sensitive_log_filter
-
-install_sensitive_log_filter()
-
-def load_env_file(path=".env"):
-    # Single source of truth: shared with ltcai_cli via latticeai.cli.runtime.
-    _load_env_file(Path(path))
-
-load_env_file()
-
-def env_value(primary: str, default: str = "") -> str:
-    return os.getenv(primary) or default
-
-TOKEN          = env_value("LATTICEAI_TELEGRAM_BOT_TOKEN")
-API_URL        = f"https://api.telegram.org/bot{TOKEN}"
-SERVER_PORT    = int(env_value("LATTICEAI_SERVER_PORT", "4825"))
-BASE_URL       = env_value("LATTICEAI_BASE_URL", env_value("LATTICEAI_SERVER_URL", f"http://127.0.0.1:{SERVER_PORT}")).rstrip("/")
-CHAT_URL       = f"{BASE_URL}/chat"
-AGENT_URL      = f"{BASE_URL}/agent"
-MCP_TOOLS_URL  = f"{BASE_URL}/mcp/tools"
-HISTORY_URL    = f"{BASE_URL}/history"
-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()
-
-MAX_TELEGRAM_FILE_BYTES = 45 * 1024 * 1024
-INVITE_CODE           = env_value("LATTICEAI_INVITE_CODE")
-PUBLIC_WEB_URL        = env_value("LATTICEAI_PUBLIC_URL")
-DATA_DIR              = Path(env_value("LATTICEAI_DATA_DIR", str(Path.home() / ".ltcai")))
-DATA_DIR.mkdir(parents=True, exist_ok=True)
-CHAT_IDS_FILE = Path(env_value("LATTICEAI_TELEGRAM_CHATS_FILE", str(DATA_DIR / "telegram_chats.json")))
-
-logging.basicConfig(level=logging.INFO)
-logger = logging.getLogger(__name__)
-
-# ── Server session auth ───────────────────────────────────────────────────────
-
-def _get_server_session() -> str:
-    """Return only the explicitly provisioned bot-to-server token.
-
-    Web sessions are hashed at rest and belong to interactive users. Scanning
-    ``sessions.json`` cannot recover a usable token and would couple the bot to
-    whichever administrator happened to be logged in most recently.
-    """
-    return env_value("LATTICEAI_SERVER_SESSION_TOKEN").strip()
-
-def _server_client(**kwargs) -> httpx.AsyncClient:
-    """Return a server client authenticated by an explicit bearer capability."""
-    token = _get_server_session()
-    if not token:
-        raise RuntimeError(
-            "LATTICEAI_SERVER_SESSION_TOKEN is required for Telegram server API calls."
-        )
-    headers = dict(kwargs.pop("headers", {}) or {})
-    headers["Authorization"] = f"Bearer {token}"
-    return httpx.AsyncClient(headers=headers, **kwargs)