@@ -428,6 +428,96 @@ All output flows through `LeapConsole`, ensuring consistent theming. All input f
 
 ---
 
+## External Platform Integration (Gateway)
+
+LeapFlow can connect to external messaging platforms — **Feishu (Lark)**, **DingTalk**, **Telegram**, and more — turning any IM channel into a natural-language interface to the agent. Platforms are integrated through a declarative **manifest** system and configured via a conversational setup flow, with no source-code changes required.
+
+### Design Highlights
+
+| Aspect | Approach |
+|--------|----------|
+| **Config-as-Conversation** | Say *"connect to Feishu"* in the REPL. The agent walks you through credential setup in 1–2 turns — no config files to edit by hand. |
+| **Declarative Manifests** | Each platform is defined by a YAML manifest (credentials, setup guide, adapter module). Add a new platform by dropping a `.yaml` file. |
+| **Credential Security** | Secrets are encrypted at rest (Fernet AES-128-CBC), never appear in LLM context or logs, and can be overridden via environment variables (`LEAPFLOW_<PLATFORM>_<KEY>`). |
+| **Lazy Loading** | Platform SDK dependencies are imported only when a platform is first connected, keeping CLI startup instant. |
+| **Adapter Protocol** | Platform adapters implement a simple Python `Protocol` — `connect()`, `disconnect()`, `send()`, `on_message` callback — extensible via `PlatformAdapterMixin` for graceful degradation. |
+
+### Quick Start
+
+```
+❯ connect to Telegram
+# Agent shows setup steps, asks for Bot Token
+❯ <paste your bot token>
+# Agent validates, encrypts, connects — done.
+```
+
+Or use the `/gateway` slash command to check connection status:
+
+```
+❯ /gateway
+┌── Gateway ─────────────────────┐
+│ Connected                      │
+│   ● Telegram (5m 32s)          │
+│ Available                      │
+│   飞书, DingTalk, Webhook      │
+│                                │
+│ Say "connect to <platform>"    │
+│ to set up a new integration.   │
+└────────────────────────────────┘
+```
+
+### Adding a Custom Platform
+
+1. Create a YAML manifest in `~/.leapflow/profiles/<profile>/gateway/manifests/`:
+
+```yaml
+platform_id: my_platform
+display_name: My Platform
+category: im
+
+credentials:
+  - key: api_key
+    label: API Key
+    required: true
+    secret: true
+
+setup_guide:
+  summary_en: "Provide your API key to connect."
+
+adapter:
+  module: my_package.adapter
+  class: MyAdapter
+  dependencies: [my-sdk]
+```
+
+2. Implement the adapter:
+
+```python
+from leapflow.gateway.protocol import PlatformAdapter
+
+class MyAdapter:
+    def __init__(self, api_key: str, **kwargs): ...
+    async def connect(self, *, is_reconnect: bool = False) -> None: ...
+    async def send(self, target, content) -> SendResult: ...
+    async def disconnect(self) -> None: ...
+```
+
+3. Say *"connect to my_platform"* in the REPL — the agent handles the rest.
+
+### Environment Variable Overrides
+
+For deployment environments (CI/CD, containers), set credentials as environment variables instead of interactive configuration:
+
+```bash
+export LEAPFLOW_TELEGRAM_BOT_TOKEN=your_token_here
+export LEAPFLOW_FEISHU_APP_ID=cli_xxx
+export LEAPFLOW_FEISHU_APP_SECRET=xxx
+```
+
+Environment variables take precedence over values stored in `gateway.yaml`.
+
+---
+
 ## Workflow Copilot (Preview)
 
 LeapFlow includes a **Workflow Copilot** that predicts your next action and offers proactive suggestions — like GitHub Copilot, but for any workflow on your computer.
@@ -641,6 +731,7 @@ uv run pytest -k "test_world_model" -q            # By keyword
 | `engine/` | Session orchestration and ReAct execution loop |
 | `memory/` | Three-tier event-driven memory (working → episodic → long-term) |
 | `platform/` | Platform adaptation layer — protocol abstraction for pluggable execution backends |
+| `gateway/` | External platform integration — declarative manifests, credential vault, adapter lifecycle |
 | `hub/` | Multi-source skill hub (ModelScope, GitHub, local) |
 
 <details>
@@ -665,6 +756,7 @@ uv run pytest -k "test_world_model" -q            # By keyword
 | Tools | `src/leapflow/tools/` | registry, builtins | Built-in tool definitions for the ReAct loop |
 | CLI | `src/leapflow/cli/` | cli, commands/, banner | Argument parsing, subcommand dispatch, interactive REPL |
 | Storage | `src/leapflow/storage/` | duckdb, skill_library | DuckDB-backed persistent storage for skills, trajectories, audit |
+| Gateway | `src/leapflow/gateway/` | server, manifest, protocol, credential_vault | External platform integration — manifest discovery, adapter lifecycle, credential encryption |
 | Execution Backend | external (pluggable) | — | OS interaction: screen capture, AX tree, input injection (default: `cua-driver` via MCP) |
 
 </details>
@@ -678,6 +770,7 @@ uv run pytest -k "test_world_model" -q            # By keyword
 | `PredictorLayer` | `copilot/types.py` | Prediction algorithm interface (predict, on_feedback, priority, timeout) |
 | `SignalChannel` | `copilot/types.py` | Dynamically registerable signal source (start, stop, subscribe) |
 | `HintRenderer` | `copilot/types.py` | Ghost-hint display abstraction (show, dismiss, is_visible) |
+| `PlatformAdapter` | `gateway/protocol.py` | External platform adapter contract (connect, disconnect, send, on_message) |
 
 **Core Data Types:**
 
 
@@ -38,6 +38,7 @@
     "hub_push": "hub",
     "hub_pull": "hub",
     "hub_search": "hub",
+    "gateway_connect": "gateway",
 }
 
 
@@ -87,6 +88,7 @@ def display_rich_banner(
     skills: Optional[Sequence[Any]] = None,
     context_length: int = 0,
     mcp_tools: int = 0,
+    gateway_connected: Sequence[str] = (),
     show_welcome: bool = True,
 ) -> None:
     """Print the full-width Rich banner panel with tools/skills catalog."""
@@ -160,6 +162,14 @@ def display_rich_banner(
                 names_str = names_str[:49] + "…"
             right_lines.append(f"[{_DIM_GOLD}]{cat}:[/] [{_CREAM}]{names_str}[/]")
 
+    if gateway_connected:
+        right_lines.append("")
+        right_lines.append(f"[bold {_AMBER}]Gateway[/]")
+        names_str = ", ".join(gateway_connected)
+        if len(names_str) > 52:
+            names_str = names_str[:49] + "…"
+        right_lines.append(f"[green]●[/] [{_CREAM}]{names_str}[/]")
+
     if not tool_defs and not skills:
         right_lines.append(f"[{_WARM_GRAY}]No tools or skills loaded[/]")
 
@@ -173,6 +183,8 @@ def display_rich_banner(
         summary_parts.append(f"{skill_count} skills")
     if mcp_tools:
         summary_parts.append(f"{mcp_tools} mcp")
+    if gateway_connected:
+        summary_parts.append(f"{len(gateway_connected)} gateway")
     summary_parts.append("/help for commands")
     right_lines.append("")
     right_lines.append(f"[{_WARM_GRAY}]{' · '.join(summary_parts)}[/]")
 
@@ -40,6 +40,7 @@ async def cmd_interactive(ctx: "Context") -> int:
         handle_usage,
         handle_model,
         handle_clear,
+        handle_gateway,
     )
     from leapflow.utils.terminal_io import TerminalIOProvider
     from leapflow.engine.session import SessionMode
@@ -131,6 +132,18 @@ def _update_status() -> None:
         else ctx.settings.llm_context_length
     )
 
+    def _gateway_connected_names() -> list[str]:
+        gw = getattr(ctx, "gateway_server", None)
+        if gw is None:
+            return []
+        return [
+            (gw.manifests[s.platform_id].display_name
+             if s.platform_id in gw.manifests
+             else s.platform_id)
+            for s in gw.platform_status()
+            if s.connected
+        ]
+
     def _render_banner() -> None:
         display_rich_banner(
             model=ctx.settings.llm_model,
@@ -141,6 +154,7 @@ def _render_banner() -> None:
             skills=all_skills,
             context_length=ctx_len,
             mcp_tools=mcp_count,
+            gateway_connected=_gateway_connected_names(),
         )
 
     # ── Stream response ──────────────────────────────────────────────
@@ -246,6 +260,10 @@ async def handle_input(text: str) -> None:
                 handle_tools(ctx, console, cmd_args)
                 return
 
+            if canonical == "gateway":
+                handle_gateway(ctx, console, cmd_args)
+                return
+
             if canonical == "usage":
                 handle_usage(ctx, console, cmd_args)
                 return
 
@@ -66,6 +66,9 @@ class CommandDef:
     CommandDef("shortcut add", "Add a quick-reply shortcut", "Shortcuts", args_hint="<pattern> = <reply>"),
     CommandDef("shortcut remove", "Remove a shortcut", "Shortcuts", args_hint="<pattern>"),
 
+    # Gateway
+    CommandDef("gateway", "Show connected platforms and gateway status", "Gateway"),
+
     # Scheduler
     CommandDef("arm", "Schedule a skill for timed execution", "Scheduler", args_hint="<skill> <cron>"),
     CommandDef("tasks", "List scheduled tasks", "Scheduler"),
 
@@ -67,6 +67,20 @@ def handle_status(ctx: "Context", console: "LeapConsole", args: str) -> None:
     info.append("Mode:      ", style="dim")
     info.append(f"{mode}\n")
 
+    gw = getattr(ctx, "gateway_server", None)
+    if gw is not None:
+        statuses = gw.platform_status()
+        connected = [s for s in statuses if s.connected]
+        info.append("Gateway:   ", style="dim")
+        if connected:
+            names = []
+            for s in connected:
+                m = gw.manifests.get(s.platform_id)
+                names.append(m.display_name if m else s.platform_id)
+            info.append(f"{', '.join(names)}\n", style="green")
+        else:
+            info.append("no connections\n", style="dim")
+
     console.print(Panel(
         info,
         title="[bold cyan]LeapFlow Status[/]",
@@ -172,6 +186,67 @@ def handle_model(ctx: "Context", console: "LeapConsole", args: str) -> None:
     console.system(f"  Example: LEAPFLOW_LLM_MODEL={model_arg} leap")
 
 
+def handle_gateway(ctx: "Context", console: "LeapConsole", args: str) -> None:
+    """Display gateway status: connected platforms, available integrations."""
+    from rich.panel import Panel
+    from rich.text import Text
+
+    gw = getattr(ctx, "gateway_server", None)
+    if gw is None:
+        console.warning("Gateway not initialised.")
+        return
+
+    statuses = gw.platform_status()
+    if not statuses:
+        console.system("No platform manifests discovered.")
+        return
+
+    info = Text()
+    connected = [s for s in statuses if s.connected]
+    configured = [s for s in statuses if not s.connected and s.error == "configured but not connected"]
+    available = [s for s in statuses if not s.connected and not s.error]
+
+    import time
+
+    if connected:
+        info.append("Connected\n", style="bold green")
+        for s in connected:
+            m = gw.manifests.get(s.platform_id)
+            name = m.display_name if m else s.platform_id
+            uptime = ""
+            if s.connected_since > 0:
+                secs = int(time.time() - s.connected_since)
+                if secs < 60:
+                    uptime = f" ({secs}s)"
+                elif secs < 3600:
+                    uptime = f" ({secs // 60}m)"
+                else:
+                    uptime = f" ({secs // 3600}h {(secs % 3600) // 60}m)"
+            info.append(f"  ● {name}{uptime}\n", style="green")
+
+    if configured:
+        info.append("Configured (not connected)\n", style="bold yellow")
+        for s in configured:
+            m = gw.manifests.get(s.platform_id)
+            name = m.display_name if m else s.platform_id
+            info.append(f"  ○ {name}\n", style="yellow")
+
+    if available:
+        info.append("Available\n", style="bold dim")
+        names = [gw.manifests[s.platform_id].display_name for s in available if s.platform_id in gw.manifests]
+        info.append(f"  {', '.join(names)}\n", style="dim")
+
+    info.append("\n", style="dim")
+    info.append('Say "connect to <platform>" to set up a new integration.', style="dim italic")
+
+    console.print(Panel(
+        info,
+        title="[bold cyan]Gateway[/]",
+        border_style="bright_black",
+        padding=(0, 2),
+    ))
+
+
 def handle_clear(ctx: "Context", console: "LeapConsole", args: str) -> None:
     """Clear the terminal screen."""
     os.system("cls" if os.name == "nt" else "clear")
@@ -1078,6 +1078,17 @@ async def _copilot_on_idle(duration_ms: int) -> None:
         from leapflow.tools.registry_bootstrap import set_memory_manager
         set_memory_manager(self.memory)
 
+        # ── Gateway server (late-bound tool wiring) ──
+        from leapflow.gateway.server import GatewayServer
+        from leapflow.tools.registry_bootstrap import set_gateway_server
+
+        self.gateway_server = GatewayServer(
+            settings.profile_dir,
+            extra_manifest_dirs=[settings.profile_dir / "gateway" / "manifests"],
+        )
+        self.gateway_server.discover_manifests()
+        set_gateway_server(self.gateway_server)
+
         # ── Build CompressorConfig with LLM callbacks ──
         from leapflow.engine.context_compressor import CompressorConfig
 
@@ -1845,6 +1856,14 @@ async def cleanup(self) -> None:
                 except Exception:
                     pass
 
+        # Stop gateway server
+        gw = getattr(self, "gateway_server", None)
+        if gw is not None:
+            try:
+                await gw.stop()
+            except Exception:
+                logger.debug("GatewayServer stop failed", exc_info=True)
+
         # Cancel engine if running
         if self.engine is not None:
             self.engine.cancel()
 
@@ -50,6 +50,8 @@ def _expand_path(value: str) -> Path:
     "cache/frames",
     "cache/video",
     "run",
+    "gateway",
+    "gateway/manifests",
 ]
 
 
 
@@ -174,6 +174,25 @@ async def shutdown(self) -> None:
         """Graceful shutdown."""
         ...
 
+    # ── Gateway ──────────────────────────────────────────────────────
+
+    async def gateway_connect(
+        self,
+        platform: str,
+        credentials: Dict[str, str],
+        options: Optional[Dict[str, Any]] = None,
+    ) -> Dict[str, Any]:
+        """Connect a platform via the gateway."""
+        ...
+
+    async def gateway_disconnect(self, platform: str) -> Dict[str, Any]:
+        """Disconnect a platform."""
+        ...
+
+    async def gateway_status(self) -> List[Dict[str, Any]]:
+        """Return status of all gateway platforms."""
+        ...
+
 
 # ══════════════════════════════════════════════════════════════════════
 # Method registry — maps JSON-RPC method names to LeapService methods
@@ -191,4 +210,7 @@ async def shutdown(self) -> None:
     "scheduler.arm": "scheduler_arm",
     "daemon.status": "status",
     "daemon.shutdown": "shutdown",
+    "gateway.connect": "gateway_connect",
+    "gateway.disconnect": "gateway_disconnect",
+    "gateway.status": "gateway_status",
 }
Original file line number	Diff line number	Diff line change
`@@ -50,6 +50,8 @@ def _expand_path(value: str) -> Path:`
`50`	`50`	`"cache/frames",`
`51`	`51`	`"cache/video",`
`52`	`52`	`"run",`
	`53`	`+ "gateway",`
	`54`	`+ "gateway/manifests",`
`53`	`55`	`]`
`54`	`56`
`55`	`57`