@agentunion/kite 1.2.0 → 1.3.1

package/{core/launcher → launcher}/entry.py

@@ -1,19 +1,14 @@
 """
-Launcher — the core of Kite. Manages module lifecycle, exposes API, monitors processes.
+Launcher — the core of Kite. Manages module lifecycle, monitors processes.
 
 Thread model:
 - Main thread: asyncio event loop (process management + monitor loop)
-- API thread: independent thread running uvicorn + FastAPI
 - stdout threads: one daemon thread per child process (ProcessManager)
 - (Windows) keyboard listener thread: polls for 'q' key
 
-4-Phase startup:
-  Phase 1: Registry + Event Hub (parallel start) → Registry stdout port → stdin broadcast port to Event Hub
-           → API → register self + tokens → stdin launcher_ws_token to Event Hub
-           → stdout ws_endpoint → WS connect → module.ready
-  Phase 2: (reserved — Event Hub ready handled in Phase 1)
-  Phase 3: Registry delayed ready (Event Hub → Registry → Event Hub WS → module.ready)
-  Phase 4: start remaining enabled modules in topo order
+2-Phase startup:
+  Phase 1: Start Kernel → wait port → connect WS → register self → module.ready
+  Phase 2: start remaining enabled modules in topo order (each connects to Kernel WS)
 """
 
 import asyncio
@@ -26,10 +21,7 @@ import threading
 import time
 import uuid
 
-import httpx
-import uvicorn
 import websockets
-from fastapi import FastAPI, HTTPException
 
 from .module_scanner import ModuleScanner, ModuleInfo, LaunchConfig, _parse_frontmatter
 from .process_manager import ProcessManager
@@ -42,14 +34,14 @@ SHUTDOWN_TIMEOUT_PARTIAL = 3       # Graceful module ack'd but no ready
 SHUTDOWN_TIMEOUT_READY = 1         # Graceful module sent ready (cleanup done)
 SHUTDOWN_TIMEOUT_BULK = 3          # Bulk stop_all() safety net
 
-# Core module names that are started in Phase 1-2 (not Phase 4)
-CORE_MODULE_NAMES = {"registry", "event_hub"}
+# Core module names that are started in Phase 1 (not Phase 2)
+CORE_MODULE_NAMES = {"kernel"}
 
 WATCHDOG_MODULE_NAME = "watchdog"
 
 
 class Launcher:
-    """Kite system entry point. Starts Registry, manages modules, exposes API."""
+    """Kite system entry point. Starts Kernel, manages modules."""
 
     def __init__(self, kite_token: str):
         self.kite_token = kite_token
@@ -70,41 +62,41 @@ class Launcher:
             discovery=self._load_discovery(),
         )
 
-        self.registry_port: int = 0
-        self.api_port: int = 0
+        self.kernel_port: int = 0
         self.modules: dict[str, ModuleInfo] = {}
         self._shutdown_event = asyncio.Event()
         self._thread_shutdown = threading.Event()
         self._shutdown_complete = threading.Event()  # Set when normal shutdown finishes
-        self._api_server: uvicorn.Server | None = None
-        self._api_ready = threading.Event()
         self._module_tokens: dict[str, str] = {}  # module_name -> per-module token
 
         # Three-layer state model: desired_state per module
         self._desired_states: dict[str, str] = {}  # module_name -> "running" | "stopped"
 
-        # Event Hub WebSocket client
-        self._event_hub_ws_url: str = ""
-        self._launcher_ws_token: str = ""
+        # Kernel WebSocket client
         self._ws: object | None = None
         self._ws_task: asyncio.Task | None = None
+        self._ws_connected: asyncio.Event | None = None  # Created in _async_main, set when WS ready
         self._loop: asyncio.AbstractEventLoop | None = None
 
+        # JSON-RPC 2.0 infrastructure
+        self._rpc_waiters: dict[str, asyncio.Event] = {}   # rpc_id -> Event
+        self._rpc_results: dict[str, dict] = {}             # rpc_id -> response dict
+
         # Event waiters: {event_key: (asyncio.Event, data_dict)}
         self._event_waiters: dict[str, tuple[asyncio.Event, dict]] = {}
 
         # Module ready times: module_name -> seconds from start to ready
         self._ready_times: dict[str, float] = {}
 
-        # Shared HTTP client for Registry communication (lazy-init, reuses TCP connections)
-        self._http: httpx.AsyncClient | None = None
+        # Shutdown timing
+        self._shutdown_start_time: float = 0.0
 
         # Module exit reasons: module_name -> reason string (for modules that sent module.exiting)
         self._exit_reasons: dict[str, str] = {}
 
         # Graceful shutdown capability: module_name -> True if module declared support
-        # Registry and Event Hub default to True (they start before Watchdog can observe)
-        self._graceful_modules: dict[str, bool] = {"registry": True, "event_hub": True}
+        # Kernel defaults to True (it starts before Watchdog can observe)
+        self._graceful_modules: dict[str, bool] = {"kernel": True}
 
         # System-wide shutdown flag: prevents Watchdog restart during shutdown
         self._system_shutting_down = False
@@ -124,7 +116,6 @@ class Launcher:
         except Exception:
             pass
         os.environ["KITE_INSTANCE_SUFFIX"] = suffix
-        self._app = self._create_api_app()
 
     @staticmethod
     def _fmt_elapsed(seconds: float) -> str:
@@ -238,7 +229,9 @@ class Launcher:
         except KeyboardInterrupt:
             pass
         except RuntimeError as e:
-            print(f"[launcher] 启动失败: {e}")
+            # Don't print "启动失败" if user requested shutdown
+            if not self._thread_shutdown.is_set():
+                print(f"[launcher] 启动失败: {e}")
         finally:
             self._final_cleanup()
 
@@ -247,6 +240,7 @@ class Launcher:
         if self._thread_shutdown.is_set():
             return  # already shutting down
         print(f"[launcher] {reason or '收到关闭请求'}")
+        self._shutdown_start_time = time.monotonic()  # Record shutdown start time
         self._thread_shutdown.set()
         # Wake up asyncio event loop immediately (so _monitor_loop / wait_for exits)
         loop = self._loop
@@ -265,9 +259,9 @@ class Launcher:
             except Exception:
                 still = []
             if still:
-                print(f"[launcher] 关闭超时，以下模块仍在运行: {', '.join(still)}，强制退出")
+                print(f"\033[91m[launcher] 关闭超时，以下模块仍在运行: {', '.join(still)}，强制退出\033[0m")
             else:
-                print("[launcher] 关闭超时，强制退出")
+                print("\033[91m[launcher] 关闭超时，强制退出\033[0m")
             os._exit(1)
         threading.Thread(target=_force, daemon=True).start()
 
@@ -307,31 +301,34 @@ class Launcher:
             while not self._thread_shutdown.is_set():
                 if msvcrt.kbhit():
                     ch = msvcrt.getch()
-                    if ch in (b'q', b'Q'):
+                    if ch == b'\x1b':  # ESC - force exit immediately
+                        print("[launcher] ESC 强制退出")
+                        os._exit(0)
+                    elif ch in (b'q', b'Q'):  # q/Q - graceful shutdown
                         self._request_shutdown("收到退出请求，正在关闭...")
                         return
                 time.sleep(0.1)
         threading.Thread(target=_listen, daemon=True).start()
 
-    # ── Async main (4-Phase startup) ──
+    # ── Async main (2-Phase startup) ──
 
     async def _async_main(self):
-        """Full 4-phase startup sequence, then monitor loop."""
+        """Full 2-phase startup sequence, then monitor loop."""
         self._loop = asyncio.get_running_loop()
+        self._ws_connected = asyncio.Event()  # Create event in async context
         t_start = time.monotonic()
         self._start_unix = time.time()
         phase_times = {}
         G = "\033[32m"
         R = "\033[0m"
 
-        # Validate core modules exist (mechanism 12)
+        # Validate core modules exist
         self._validate_core_modules()
 
         # Cleanup leftovers from previous instances (current instance dir)
         local_cleaned = self.process_manager.cleanup_leftovers()
 
         # Cross-directory leftover cleanup (background, non-blocking)
-        # run_in_executor returns a Future (not coroutine), so use ensure_future
         self._global_cleanup_task = asyncio.ensure_future(
             asyncio.get_running_loop().run_in_executor(
                 None, self.process_manager.cleanup_global_leftovers
@@ -339,23 +336,15 @@ class Launcher:
         )
 
         try:
-            # Phase 1+2: Registry + Event Hub parallel bootstrap
+            # Phase 1: Start Kernel + connect WS
             t0 = time.monotonic()
-            await self._phase1_parallel_bootstrap()
+            await self._phase1_start_kernel()
             elapsed_p1 = time.monotonic() - t0
-            phase_times["Phase 1+2: Registry + Event Hub (并行)"] = elapsed_p1
-            print(f"{G}[launcher] ✓ Phase 1+2 完成: Registry + Event Hub 已就绪 ({elapsed_p1:.2f}s){R}")
+            phase_times["Phase 1: Kernel"] = elapsed_p1
+            print(f"{G}[launcher] ✓ Phase 1 完成: Kernel 已就绪 ({elapsed_p1:.2f}s){R}")
             if self._shutdown_event.is_set(): return
 
-            # Phase 3: Wait for Registry delayed ready
-            t0 = time.monotonic()
-            await self._phase3_registry_ready()
-            elapsed = time.monotonic() - t0
-            phase_times["Phase 3: Registry 事件总线"] = elapsed
-            print(f"{G}[launcher] ✓ Phase 3 完成: Registry 已连接事件总线 ({elapsed:.2f}s){R}")
-            if self._shutdown_event.is_set(): return
-
-            # Initialize desired_state from config_state (needed before Phase 3.5)
+            # Initialize desired_state from config_state
             for name, info in self.modules.items():
                 if info.state == "enabled":
                     self._desired_states[name] = "running"
@@ -365,43 +354,26 @@ class Launcher:
             for cn in CORE_MODULE_NAMES:
                 self._desired_states[cn] = "running"
 
-            # Phase 3.5: Watchdog ready
-            # If started in parallel (Phase 1), just wait for module.ready
-            # Otherwise start it now (fallback)
+            # Phase 1.5: Watchdog
             watchdog_info = self.modules.get(WATCHDOG_MODULE_NAME)
             if watchdog_info and self._desired_states.get(WATCHDOG_MODULE_NAME) == "running":
                 t0 = time.monotonic()
-                if getattr(self, '_watchdog_parallel', False):
-                    print(f"[launcher] Phase 3.5: Watchdog 已并行启动，等待就绪...")
-                    ready = await self._wait_event("module.ready", "watchdog", timeout=15)
-                    elapsed = time.monotonic() - t0
-                    if ready and not ready.get("_exited"):
-                        self._graceful_modules["watchdog"] = bool(ready.get("graceful_shutdown"))
-                        self._ready_times["watchdog"] = elapsed
-                        print(f"[launcher] Watchdog 已就绪")
-                        self._log_lifecycle("started", "watchdog")
-                        await self._publish_event("module.started", {"module_id": "watchdog"})
-                        self.process_manager.close_stdio("watchdog")
-                    else:
-                        print(f"[launcher] 警告: Watchdog 在 15s 内未就绪")
-                else:
-                    print(f"[launcher] Phase 3.5: 启动 Watchdog...")
-                    await self._start_one_module(watchdog_info)
-                    elapsed = time.monotonic() - t0
-                print(f"{G}[launcher] ✓ Phase 3.5 完成: Watchdog ({elapsed:.2f}s){R}")
+                print(f"[launcher] Phase 1.5: 启动 Watchdog...")
+                await self._start_one_module(watchdog_info)
+                elapsed = time.monotonic() - t0
+                print(f"{G}[launcher] ✓ Phase 1.5 完成: Watchdog ({elapsed:.2f}s){R}")
                 if self._shutdown_event.is_set(): return
 
-            # Phase 4: Start remaining enabled modules
+            # Phase 2: Start remaining enabled modules
             t0 = time.monotonic()
-            await self._phase4_start_modules()
+            await self._phase2_start_modules()
             elapsed = time.monotonic() - t0
-            phase_times["Phase 4: Extensions"] = elapsed
-            print(f"{G}[launcher] ✓ Phase 4 完成: 扩展模块已启动 ({elapsed:.2f}s){R}")
+            phase_times["Phase 2: Extensions"] = elapsed
+            print(f"{G}[launcher] ✓ Phase 2 完成: 扩展模块已启动 ({elapsed:.2f}s){R}")
             if self._shutdown_event.is_set(): return
 
             # Post-startup
             self.process_manager.persist_records()
-            self._heartbeat_task = asyncio.create_task(self._heartbeat_loop())
 
             # Wait for global leftover cleanup to finish (non-blocking with timeout)
             global_cleaned = {}
@@ -433,7 +405,7 @@ class Launcher:
                 "startup_time": round(total_time, 2),
             })
 
-            print("[launcher] 进入监控循环 (按 Ctrl+C 或 'q' 退出)")
+            print("[launcher] 进入监控循环 (按 Ctrl+C 或 'q' 优雅退出，ESC 强制退出)")
             await self._monitor_loop()
         finally:
             try:
@@ -441,263 +413,110 @@ class Launcher:
             except Exception as e:
                 print(f"[launcher] 优雅关闭出错: {e}")
 
-    # ── Phase 1+2: Parallel bootstrap (Registry + Event Hub) ──
+    # ── Phase 1: Start Kernel ──
 
-    async def _phase1_parallel_bootstrap(self):
-        """Start Registry + Event Hub processes in parallel to overlap cold-start time.
+    async def _phase1_start_kernel(self):
+        """Start Kernel process, connect WS, register self, wait for module.ready.
 
         Flow:
-        1. Start Registry + Event Hub processes simultaneously
-        2. Wait for Registry to report port via stdout
-        3. Set KITE_REGISTRY_PORT env (for Phase 3.5/4 modules) + start API
-        4. Scan modules + register self & tokens (parallel)
-        5. Send launcher_ws_token + registry_port to Event Hub via stdin
-        6. Wait for Event Hub ws_endpoint → WS connect → module.ready
+        1. Start Kernel subprocess
+        2. Wait Kernel stdout port → set KITE_KERNEL_PORT env
+        3. Scan modules + connect WS + generate tokens (parallel)
+        4. Wait module.ready event from Kernel
         """
-        t_registry = time.monotonic()
+        t_kernel = time.monotonic()
 
-        # ── Step 1: Start both processes ──
-        registry_dir = os.path.join(os.environ["KITE_PROJECT"], "core", "registry")
-        registry_info = ModuleInfo(
-            name="registry",
-            display_name="Registry",
+        # ── Step 1: Start Kernel process ──
+        kernel_dir = os.path.join(os.environ["KITE_PROJECT"], "kernel")
+        kernel_info = ModuleInfo(
+            name="kernel",
+            display_name="Kernel",
             type="infrastructure",
             state="enabled",
             runtime="python",
             entry="entry.py",
-            module_dir=registry_dir,
+            module_dir=kernel_dir,
         )
-        boot_info_registry = {"token": self.kite_token}
-        self._log_lifecycle("starting", "registry")
-        ok = self.process_manager.start_module(registry_info, boot_info=boot_info_registry)
+        # Kernel does NOT receive boot_info via stdin
+        self._log_lifecycle("starting", "kernel")
+        ok = self.process_manager.start_module(kernel_info, boot_info=None)
         if not ok:
-            self._log_lifecycle("start_failed", "registry")
-            raise RuntimeError("启动 Registry 失败")
-
-        # Start Event Hub in parallel (before Registry port is known)
-        eh_dir = os.path.join(os.environ["KITE_PROJECT"], "core", "event_hub")
-        eh_info = ModuleInfo(
-            name="event_hub",
-            display_name="Event Hub",
-            type="infrastructure",
-            state="enabled",
-            runtime="python",
-            entry="entry.py",
-            module_dir=eh_dir,
-        )
-        # Generate Event Hub token early (will register to Registry once it's up)
-        eh_token = secrets.token_hex(32)
-        self._module_tokens["event_hub"] = eh_token
-        boot_info_eh = {"token": eh_token}
-        self._log_lifecycle("starting", "event_hub")
-        ok = self.process_manager.start_module(eh_info, boot_info=boot_info_eh)
-        if not ok:
-            self._log_lifecycle("start_failed", "event_hub")
-            raise RuntimeError("启动 Event Hub 失败")
-
-        # Start Watchdog in parallel (before Registry port is known)
-        # Watchdog will block on stdin waiting for registry_port
-        watchdog_dir = os.path.join(os.environ["KITE_PROJECT"], "extensions", "services", "watchdog")
-        watchdog_md = os.path.join(watchdog_dir, "module.md")
-        self._watchdog_parallel = False  # track whether watchdog was started in parallel
-        if os.path.isfile(watchdog_md):
-            wd_token = secrets.token_hex(32)
-            self._module_tokens["watchdog"] = wd_token
-            # Parse watchdog module.md for ModuleInfo
-            try:
-                with open(watchdog_md, "r", encoding="utf-8") as f:
-                    wd_fm = _parse_frontmatter(f.read())
-                wd_info = ModuleInfo(
-                    name="watchdog",
-                    display_name=wd_fm.get("display_name", "Watchdog"),
-                    type=wd_fm.get("type", "service"),
-                    state="enabled",
-                    runtime=wd_fm.get("runtime", "python"),
-                    entry=wd_fm.get("entry", "entry.py"),
-                    module_dir=watchdog_dir,
-                )
-                boot_info_wd = {"token": wd_token}
-                self._log_lifecycle("starting", "watchdog")
-                ok = self.process_manager.start_module(wd_info, boot_info=boot_info_wd)
-                if ok:
-                    self._watchdog_parallel = True
-                else:
-                    self._log_lifecycle("start_failed", "watchdog")
-                    print("[launcher] 警告: Watchdog 并行启动失败，将在 Phase 3.5 重试")
-            except Exception as e:
-                print(f"[launcher] 警告: Watchdog module.md 解析失败: {e}")
+            self._log_lifecycle("start_failed", "kernel")
+            raise RuntimeError("启动 Kernel 失败")
 
-        parallel_modules = "Registry + Event Hub" + (" + Watchdog" if self._watchdog_parallel else "")
-        print(f"[launcher] {parallel_modules} 进程已同时启动，等待 Registry 端口...")
+        print(f"[launcher] Kernel 进程已启动，等待 Kernel 端口...")
 
         # Persist immediately after starting core processes
         self.process_manager.persist_records()
 
-        # ── Step 2: Wait for Registry port ──
-        msg = await self._wait_kite_message("registry", "port", timeout=6)
-        if not msg or not msg.get("port"):
-            raise RuntimeError("致命错误: Registry 在 6s 内未报告端口")
-        self.registry_port = int(msg["port"])
-        self._ready_times["registry"] = time.monotonic() - t_registry
-        _wait_s = time.monotonic() - t_registry
-        print(f"[launcher] Registry 端口: {self.registry_port} (等待 {self._fmt_elapsed(_wait_s)})")
-
-        # ── Step 3: Set env + start API + immediately unblock Event Hub ──
-        os.environ["KITE_REGISTRY_PORT"] = str(self.registry_port)
-        self._start_api_thread()
-
-        # Send launcher_ws_token + registry_port to Event Hub ASAP (unblock it)
-        self._launcher_ws_token = secrets.token_hex(32)
-        self.process_manager.write_stdin("event_hub", {
-            "kite": "launcher_ws_token",
-            "launcher_ws_token": self._launcher_ws_token,
-        })
-        self.process_manager.write_stdin("event_hub", {
-            "kite": "registry_port",
-            "registry_port": self.registry_port,
-        })
-
-        # Send registry_port to Watchdog via stdin (if started in parallel)
-        # Watchdog will retry querying launcher.api_endpoint until it's available
-        if self.process_manager.is_running("watchdog"):
-            self.process_manager.write_stdin("watchdog", {
-                "kite": "registry_port",
-                "registry_port": self.registry_port,
-            })
-
-        # ── Step 4: Scan + register tokens ‖ wait for Event Hub ws_endpoint (parallel) ──
-        # Pre-register ws_endpoint waiter BEFORE gather to avoid race condition:
-        # module_scanner.scan() is synchronous and blocks the event loop,
-        # so the _wait_event_hub_endpoint coroutine wouldn't register its waiter in time.
-        ws_waiter_key = "event_hub:ws_endpoint"
-        ws_evt = threading.Event()
-        ws_data: dict = {}
-        self._msg_waiters[ws_waiter_key] = (ws_evt, ws_data)
-
-        async def _scan_and_register_tokens():
+        # ── Step 2: Wait for Kernel port + launcher_token ──
+        msg = await self._wait_kite_message("kernel", "port", timeout=6)
+        if self._thread_shutdown.is_set():
+            # User requested shutdown during startup
+            raise RuntimeError("启动被用户中断")
+        if not msg or not msg.get("port") or not msg.get("token"):
+            raise RuntimeError("致命错误: Kernel 在 6s 内未报告端口和 token")
+        self.kernel_port = int(msg["port"])
+        launcher_token = msg["token"]
+        self._module_tokens["launcher"] = launcher_token
+        _wait_s = time.monotonic() - t_kernel
+        print(f"[launcher] Kernel 端口: {self.kernel_port} (等待 {self._fmt_elapsed(_wait_s)})")
+
+        # ── Step 3: Set env (but don't send kernel_port to modules yet) ──
+        os.environ["KITE_KERNEL_PORT"] = str(self.kernel_port)
+
+        # ── Step 4: Scan modules + connect WS + generate tokens (parallel) ──
+        async def _scan_and_generate_tokens():
             t_scan = time.monotonic()
             self.modules = self.module_scanner.scan()
             for name, info in self.modules.items():
                 self._log_lifecycle("scanned", name, state=info.state, module_dir=info.module_dir)
             _scan_s = time.monotonic() - t_scan
             print(f"[launcher] 发现 {len(self.modules)} 个模块: {', '.join(self.modules.keys()) or '(无)'} (扫描 {self._fmt_elapsed(_scan_s)})")
-            t_reg = time.monotonic()
-            await self._register_module_tokens()
-            _reg_s = time.monotonic() - t_reg
-            print(f"[launcher] 令牌注册完成 ({self._fmt_elapsed(_reg_s)})")
-
-        async def _wait_event_hub_endpoint():
-            t_wait_eh = time.monotonic()
-            print("[launcher] 等待 Event Hub ws_endpoint...")
-            shutdown = self._thread_shutdown
-            def _wait():
-                deadline = time.monotonic() + 10
-                while time.monotonic() < deadline:
-                    if ws_evt.wait(timeout=0.5):
-                        return True
-                    if shutdown.is_set():
-                        return False
-                return False
-            got = await asyncio.get_running_loop().run_in_executor(None, _wait)
-            self._msg_waiters.pop(ws_waiter_key, None)
-            if not got or not ws_data.get("ws_endpoint"):
-                raise RuntimeError("致命错误: Event Hub 在 10s 内未报告 ws_endpoint")
-            self._event_hub_ws_url = ws_data["ws_endpoint"]
-            _eh_s = time.monotonic() - t_wait_eh
-            print(f"[launcher] Event Hub 已发现: {self._event_hub_ws_url} (等待 {self._fmt_elapsed(_eh_s)})")
-
-        # Run all three in parallel: register_self + scan_tokens + wait_event_hub
+            # Generate tokens via Kernel RPC (after WS connection is ready)
+            t_gen = time.monotonic()
+            await self._generate_module_tokens()
+            _gen_s = time.monotonic() - t_gen
+            print(f"[launcher] 令牌生成完成 ({self._fmt_elapsed(_gen_s)})")
+
+        async def _connect_kernel_ws():
+            t_ws = time.monotonic()
+            self._ws_task = asyncio.create_task(self._ws_loop())
+            # Wait for WebSocket connection to be established and ready
+            try:
+                await asyncio.wait_for(self._ws_connected.wait(), timeout=5)
+            except asyncio.TimeoutError:
+                print("[launcher] 警告: WebSocket 连接超时")
+                return
+
+            # Now wait for Kernel module.ready event
+            # (waiter is registered inside _ws_connect before _ws_receiver starts)
+            ready = await self._wait_event("module.ready", "kernel", timeout=15)
+            if ready:
+                self._graceful_modules["kernel"] = bool(ready.get("graceful_shutdown"))
+                print("[launcher] Kernel 已就绪")
+            else:
+                print("\033[91m[launcher] 警告: Kernel 在 15s 内未发送 module.ready\033[0m")
+            self._ready_times["kernel"] = time.monotonic() - t_ws
+
         await asyncio.gather(
-            self._register_self(),
-            _scan_and_register_tokens(),
-            _wait_event_hub_endpoint(),
+            _scan_and_generate_tokens(),
+            _connect_kernel_ws(),
         )
         if self._shutdown_event.is_set():
             return
 
-        # ── Step 5: WS connect → module.ready ──
-        t_eh = time.monotonic()
-        self._ws_task = asyncio.create_task(self._ws_loop())
-
-        # Wait for Event Hub module.ready (sent when Launcher connects)
-        ready = await self._wait_event("module.ready", "event_hub", timeout=15)
-        if ready:
-            self._graceful_modules["event_hub"] = bool(ready.get("graceful_shutdown"))
-            print("[launcher] Event Hub 已就绪")
-        else:
-            print("[launcher] 警告: Event Hub 在 15s 内未发送 module.ready")
-
-        self._ready_times["event_hub"] = time.monotonic() - t_eh
-        self._log_lifecycle("started", "event_hub")
-        await self._publish_event("module.started", {"module_id": "event_hub"})
-        self.process_manager.close_stdio("event_hub")
-
-        # Store eh_info in modules dict if not already present (from scan)
-        if "event_hub" not in self.modules:
-            self.modules["event_hub"] = eh_info
-
-    def _get_http(self) -> httpx.AsyncClient:
-        """Get shared HTTP client (lazy-init, reuses TCP connections to Registry)."""
-        if self._http is None or self._http.is_closed:
-            self._http = httpx.AsyncClient(timeout=5)
-        return self._http
-
-    async def _close_http(self):
-        """Close shared HTTP client."""
-        if self._http and not self._http.is_closed:
-            await self._http.aclose()
-            self._http = None
-
-    async def _register_self(self):
-        """Register Launcher itself to Registry."""
-        url = f"http://127.0.0.1:{self.registry_port}/modules"
-        headers = {"Authorization": f"Bearer {self.kite_token}"}
-        payload = {
-            "action": "register",
-            "module_id": "launcher",
-            "module_type": "infrastructure",
-            "name": "Launcher",
-            "api_endpoint": f"http://127.0.0.1:{self.api_port}",
-            "health_endpoint": "/launcher/modules",
-            "events_publish": {
-                "module.started": {},
-                "module.stopped": {},
-                "module.state_changed": {},
-            },
-            "events_subscribe": [">"],
-        }
-        try:
-            client = self._get_http()
-            resp = await client.post(url, json=payload, headers=headers)
-            if resp.status_code == 200:
-                print("[launcher] 已注册到 Registry")
-            else:
-                print(f"[launcher] 警告: Registry 注册返回 {resp.status_code}")
-        except Exception as e:
-            print(f"[launcher] 警告: 注册到 Registry 失败: {e}")
-
-    # ── (Phase 2 merged into _phase1_parallel_bootstrap) ──
+        self._log_lifecycle("started", "kernel")
+        await self._publish_event("module.started", {"module_id": "kernel"})
+        self.process_manager.close_stdio("kernel")
 
-    # ── Phase 3: Registry delayed ready ──
+        # Store kernel_info in modules dict if not already present (from scan)
+        if "kernel" not in self.modules:
+            self.modules["kernel"] = kernel_info
 
-    async def _phase3_registry_ready(self):
-        """Wait for Registry module.ready (triggered after Event Hub registers to Registry
-        and Registry connects to Event Hub WS)."""
-        print("[launcher] 等待 Registry 连接 Event Hub...")
-        ready = await self._wait_event("module.ready", "registry", timeout=12)
-        if ready:
-            self._graceful_modules["registry"] = bool(ready.get("graceful_shutdown"))
-            print("[launcher] Registry 事件总线连接完成")
-        else:
-            print("[launcher] 警告: Registry 在 12s 内未连接事件总线 (降级运行)")
+    # ── Phase 2: Start remaining modules ──
 
-        self._log_lifecycle("started", "registry")
-        await self._publish_event("module.started", {"module_id": "registry"})
-        self.process_manager.close_stdio("registry")
-
-    # ── Phase 4: Start remaining modules ──
-
-    async def _phase4_start_modules(self):
+    async def _phase2_start_modules(self):
         """Start enabled modules (excluding core) in dependency order."""
         to_start = [m for m in self.modules.values()
                      if self._desired_states.get(m.name) == "running"
@@ -735,10 +554,10 @@ class Launcher:
             else:
                 await asyncio.gather(*(self._start_one_module(info) for info in layer))
 
-    # ── Event Hub WebSocket connection ──
+    # ── Kernel WebSocket connection (JSON-RPC 2.0) ──
 
     async def _ws_loop(self):
-        """Connect to Event Hub, reconnect on failure."""
+        """Connect to Kernel, reconnect on failure."""
         while not self._thread_shutdown.is_set():
             try:
                 await self._ws_connect()
@@ -746,105 +565,327 @@ class Launcher:
                 return
             except Exception as e:
                 if not self._system_shutting_down:
-                    print(f"[launcher] Event Hub 连接错误: {e}")
+                    print(f"[launcher] Kernel 连接错误: {e}")
             self._ws = None
             await asyncio.sleep(5)
 
     async def _ws_connect(self):
-        """Single WebSocket session with launcher_ws_token auth."""
-        ws_url = f"{self._event_hub_ws_url}?token={self._launcher_ws_token}&id=launcher"
+        """Single WebSocket session with JSON-RPC 2.0 protocol."""
+        launcher_token = self._module_tokens.get("launcher", "")
+        ws_url = f"ws://127.0.0.1:{self.kernel_port}/ws?token={launcher_token}&id=launcher"
         t_ws_connect = time.monotonic()
         async with websockets.connect(ws_url, open_timeout=3, ping_interval=None, ping_timeout=None, close_timeout=10) as ws:
             self._ws = ws
             _ws_s = time.monotonic() - t_ws_connect
-            print(f"[launcher] 已连接到 Event Hub ({self._fmt_elapsed(_ws_s)})")
+            print(f"[launcher] 已连接到 Kernel ({self._fmt_elapsed(_ws_s)})")
 
-            # Subscribe to all events
-            await ws.send(json.dumps({
-                "type": "subscribe",
-                "events": [">"],
-            }))
+            # Start receive loop in background task BEFORE making any RPC calls
+            # This prevents deadlock where RPC waits for response but receive loop hasn't started
+            receiver_task = asyncio.create_task(self._ws_receiver(ws))
+
+            try:
+                # Register kernel module.ready waiter BEFORE subscribing to events
+                # This prevents race condition where event arrives before waiter is registered
+                ready_key = "module.ready:kernel"
+                ready_evt = asyncio.Event()
+                ready_data = {}
+                self._event_waiters[ready_key] = (ready_evt, ready_data)
+
+                # Subscribe to all events
+                await self._rpc_call(ws, "event.subscribe", {"events": [">"]})
+
+                # Register Launcher itself in the Registry
+                await self._rpc_call(ws, "registry.register", {
+                    "module_id": "launcher",
+                    "module_type": "infrastructure",
+                    "events_publish": {
+                        "module.started": {},
+                        "module.stopped": {},
+                        "module.state_changed": {},
+                    },
+                    "events_subscribe": [">"],
+                })
+                print("[launcher] 已注册到 Kernel")
+
+                # Signal that connection is ready (after subscription and registration)
+                if self._ws_connected:
+                    self._ws_connected.set()
+
+                # Wait for receiver task to complete (connection closed)
+                await receiver_task
+            except asyncio.CancelledError:
+                receiver_task.cancel()
+                raise
 
-            # Receive loop
+    async def _ws_receiver(self, ws):
+        """Receive loop: classify incoming messages."""
+        try:
             async for raw in ws:
                 try:
                     msg = json.loads(raw)
                 except (json.JSONDecodeError, TypeError):
                     continue
                 try:
-                    msg_type = msg.get("type", "")
-                    if msg_type == "event":
-                        source = msg.get("source", "unknown")
-                        event = msg.get("event", "")
-                        data = msg.get("data") if isinstance(msg.get("data"), dict) else {}
-                        # Trigger event waiters
-                        module_id = data.get("module_id", "")
-                        waiter_key = f"{event}:{module_id}"
-                        waiter = self._event_waiters.get(waiter_key)
-                        if waiter:
-                            waiter[1].update(data)
-                            waiter[0].set()
-                        # module.exiting also wakes module.ready waiter
-                        # (module won't send ready — no point waiting)
-                        if event == "module.exiting" and module_id:
-                            ready_key = f"module.ready:{module_id}"
-                            ready_waiter = self._event_waiters.get(ready_key)
-                            if ready_waiter:
-                                ready_waiter[1].update(data)
-                                ready_waiter[1]["_exited"] = True
-                                ready_waiter[0].set()
-                        # module.crash → print red crash summary (real-time notification)
-                        if event == "module.crash" and module_id:
-                            RED = "\033[91m"
-                            RESET = "\033[0m"
-                            exc_type = data.get("exception_type", "Unknown")
-                            preview = data.get("traceback_preview", "")
-                            severity = data.get("severity", "error")
-                            print(f"[launcher] {RED}模块 '{module_id}' 崩溃: "
-                                  f"{exc_type} — {preview}{RESET}")
-                            _suffix = os.environ.get("KITE_INSTANCE_SUFFIX", "")
-                            crash_log = os.path.join(
-                                os.environ.get("KITE_INSTANCE_DIR", ""),
-                                module_id, "log", f"crashes{_suffix}.jsonl"
-                            )
-                            print(f"[launcher] 崩溃日志: {crash_log}")
-                        ts = msg.get("timestamp", "")
-                        # Only log system events (module.*, watchdog.*) to avoid flooding
-                        # from benchmark/test traffic
-                        if not (event.startswith("module.") or event.startswith("watchdog.")):
-                            continue
-                        latency_str = ""
-                        if ts:
-                            try:
-                                from datetime import datetime, timezone
-                                sent = datetime.fromisoformat(ts)
-                                delay_ms = (datetime.now(timezone.utc) - sent).total_seconds() * 1000
-                                latency_str = f" ({delay_ms:.1f}ms)"
-                                local_ts = sent.astimezone().strftime("%H:%M:%S")
-                            except Exception:
-                                local_ts = ts[11:19] if len(ts) >= 19 else ts
-                            print(f"[{source}] {local_ts} {event}{latency_str}: {json.dumps(data, ensure_ascii=False)}")
-                        else:
-                            print(f"[{source}] {event}: {json.dumps(data, ensure_ascii=False)}")
-                    elif msg_type == "error":
-                        print(f"[launcher] Event Hub 错误: {msg.get('message')}")
+                    has_method = "method" in msg
+                    has_id = "id" in msg
+                    has_result = "result" in msg
+                    has_error = "error" in msg
+
+                    if has_method and not has_id:
+                        # Event Notification (no id)
+                        await self._handle_event_notification(msg)
+                    elif has_method and has_id:
+                        # Incoming RPC request (forwarded by Kernel)
+                        await self._handle_rpc_request(ws, msg)
+                    elif has_id and (has_result or has_error):
+                        # RPC response (to our own call)
+                        self._handle_rpc_response(msg)
                 except Exception as e:
-                    print(f"[launcher] 事件处理异常（已忽略）: {e}")
+                    print(f"[launcher] 消息处理异常（已忽略）: {e}")
+        except asyncio.CancelledError:
+            pass
+
+    # ── JSON-RPC 2.0 infrastructure ──
+
+    async def _rpc_call(self, ws, method: str, params: dict = None, timeout: float = 5) -> dict:
+        """Send a JSON-RPC 2.0 request and await the response."""
+        rpc_id = str(uuid.uuid4())
+        msg = {"jsonrpc": "2.0", "id": rpc_id, "method": method}
+        if params:
+            msg["params"] = params
+
+        evt = asyncio.Event()
+        self._rpc_waiters[rpc_id] = evt
+        self._rpc_results[rpc_id] = {}
+
+        try:
+            await ws.send(json.dumps(msg))
+            await asyncio.wait_for(evt.wait(), timeout=timeout)
+            return self._rpc_results.get(rpc_id, {})
+        except asyncio.TimeoutError:
+            print(f"[launcher] RPC 超时: {method}")
+            return {"error": {"code": -32002, "message": f"RPC timeout: {method}"}}
+        finally:
+            self._rpc_waiters.pop(rpc_id, None)
+            self._rpc_results.pop(rpc_id, None)
+
+    def _handle_rpc_response(self, msg: dict):
+        """Match an incoming RPC response to a pending waiter."""
+        rpc_id = msg.get("id", "")
+        waiter = self._rpc_waiters.get(rpc_id)
+        if waiter:
+            self._rpc_results[rpc_id] = msg
+            waiter.set()
+
+    async def _handle_event_notification(self, msg: dict):
+        """Handle an event notification (JSON-RPC 2.0 Notification with method='event')."""
+        params = msg.get("params", {})
+        source = params.get("source", "unknown")
+        event = params.get("event", "")
+        data = params.get("data") if isinstance(params.get("data"), dict) else {}
+        ts = params.get("timestamp", "")
+
+        # Trigger event waiters
+        module_id = data.get("module_id", "")
+        waiter_key = f"{event}:{module_id}"
+        waiter = self._event_waiters.get(waiter_key)
+        if waiter:
+            waiter[1].update(data)
+            waiter[0].set()
+
+        # module.exiting also wakes module.ready waiter
+        if event == "module.exiting" and module_id:
+            ready_key = f"module.ready:{module_id}"
+            ready_waiter = self._event_waiters.get(ready_key)
+            if ready_waiter:
+                ready_waiter[1].update(data)
+                ready_waiter[1]["_exited"] = True
+                ready_waiter[0].set()
+
+        # module.crash → print red crash summary
+        if event == "module.crash" and module_id:
+            RED = "\033[91m"
+            RESET = "\033[0m"
+            exc_type = data.get("exception_type", "Unknown")
+            preview = data.get("traceback_preview", "")
+            print(f"[launcher] {RED}模块 '{module_id}' 崩溃: {exc_type} — {preview}{RESET}")
+            _suffix = os.environ.get("KITE_INSTANCE_SUFFIX", "")
+            crash_log = os.path.join(
+                os.environ.get("KITE_INSTANCE_DIR", ""),
+                module_id, "log", f"crashes{_suffix}.jsonl"
+            )
+            print(f"[launcher] 崩溃日志: {crash_log}")
+
+        # Only log system events (module.*, watchdog.*) to avoid flooding
+        if not (event.startswith("module.") or event.startswith("watchdog.")):
+            return
+        latency_str = ""
+        if ts:
+            try:
+                from datetime import datetime, timezone
+                sent = datetime.fromisoformat(ts)
+                delay_ms = (datetime.now(timezone.utc) - sent).total_seconds() * 1000
+                latency_str = f" ({delay_ms:.1f}ms)"
+                local_ts = sent.astimezone().strftime("%H:%M:%S")
+            except Exception:
+                local_ts = ts[11:19] if len(ts) >= 19 else ts
+            print(f"[{source}] {local_ts} {event}{latency_str}: {json.dumps(data, ensure_ascii=False)}")
+        else:
+            print(f"[{source}] {event}: {json.dumps(data, ensure_ascii=False)}")
+
+    async def _handle_rpc_request(self, ws, msg: dict):
+        """Handle an incoming RPC request forwarded by Kernel (launcher.* methods)."""
+        rpc_id = msg.get("id", "")
+        method = msg.get("method", "")
+        params = msg.get("params", {})
+
+        handlers = {
+            "list_modules":   self._rpc_list_modules,
+            "start_module":   self._rpc_start_module,
+            "stop_module":    self._rpc_stop_module,
+            "restart_module": self._rpc_restart_module,
+            "rescan":         self._rpc_rescan,
+            "shutdown":       self._rpc_shutdown,
+        }
+        handler = handlers.get(method)
+        if handler:
+            try:
+                result = await handler(params)
+                await ws.send(json.dumps({"jsonrpc": "2.0", "id": rpc_id, "result": result}))
+            except Exception as e:
+                await ws.send(json.dumps({
+                    "jsonrpc": "2.0", "id": rpc_id,
+                    "error": {"code": -32603, "message": str(e)},
+                }))
+        else:
+            await ws.send(json.dumps({
+                "jsonrpc": "2.0", "id": rpc_id,
+                "error": {"code": -32601, "message": f"Method not found: {method}"},
+            }))
+
+    # ── Launcher RPC method handlers ──
+
+    async def _rpc_list_modules(self, params: dict) -> dict:
+        """List all modules and their current status."""
+        result = []
+        for name, info in self.modules.items():
+            running = self.process_manager.is_running(name)
+            rec = self.process_manager.get_record(name)
+            result.append({
+                "name": name,
+                "display_name": info.display_name,
+                "type": info.type,
+                "config_state": info.state,
+                "desired_state": self._desired_states.get(name, "stopped"),
+                "actual_state": f"running({rec.pid})" if running and rec else "stopped",
+                "pid": rec.pid if running and rec else None,
+                "monitor": info.monitor,
+            })
+        return {"modules": result}
+
+    async def _rpc_start_module(self, params: dict) -> dict:
+        """Start a module by name."""
+        name = params.get("name", "")
+        info = self.modules.get(name)
+        if not info:
+            raise RuntimeError(f"Module '{name}' not found")
+        if info.state == "disabled":
+            raise RuntimeError(f"Module '{name}' is disabled")
+
+        if name not in self._module_tokens:
+            self._module_tokens[name] = secrets.token_hex(32)
+            await self._register_new_tokens({name: self._module_tokens[name]})
+
+        token = self._module_tokens[name]
+        boot_info = {"token": token}
+        ok = self.process_manager.start_module(info, boot_info=boot_info)
+        if ok:
+            self._desired_states[name] = "running"
+            self.process_manager.persist_records()
+            rec = self.process_manager.get_record(name)
+            self._log_lifecycle("started", name, pid=rec.pid if rec else None, via="rpc")
+            await self._publish_event("module.started", {"module_id": name})
+            return {"status": "started", "name": name}
+        self._log_lifecycle("start_failed", name, via="rpc")
+        raise RuntimeError(f"Failed to start '{name}'")
+
+    async def _rpc_stop_module(self, params: dict) -> dict:
+        """Stop a module with graceful shutdown."""
+        name = params.get("name", "")
+        info = self.modules.get(name)
+        if not info:
+            raise RuntimeError(f"Module '{name}' not found")
+        reason = params.get("reason", "stop_requested")
+        self._desired_states[name] = "stopped"
+        await self._graceful_stop(name, reason)
+        self.process_manager.persist_records()
+        return {"status": "stopped", "name": name}
+
+    async def _rpc_restart_module(self, params: dict) -> dict:
+        """Restart a module (stop + start)."""
+        name = params.get("name", "")
+        info = self.modules.get(name)
+        if not info:
+            raise RuntimeError(f"Module '{name}' not found")
+        if info.state == "disabled":
+            raise RuntimeError(f"Module '{name}' is disabled")
+        reason = params.get("reason", "restart")
+        await self._graceful_stop(name, reason)
+        self._module_tokens[name] = secrets.token_hex(32)
+        await self._register_new_tokens({name: self._module_tokens[name]})
+        token = self._module_tokens[name]
+        boot_info = {"token": token}
+        ok = self.process_manager.start_module(info, boot_info=boot_info)
+        if ok:
+            self._desired_states[name] = "running"
+            self.process_manager.persist_records()
+            rec = self.process_manager.get_record(name)
+            self._log_lifecycle("started", name, pid=rec.pid if rec else None, via="rpc_restart")
+            await self._publish_event("module.started", {"module_id": name})
+            return {"status": "restarted", "name": name}
+        self._log_lifecycle("start_failed", name, via="rpc_restart")
+        raise RuntimeError(f"Failed to restart '{name}'")
+
+    async def _rpc_rescan(self, params: dict) -> dict:
+        """Rescan module directories for new/removed modules."""
+        old_names = set(self.modules.keys())
+        self.modules = self.module_scanner.scan()
+        new_names = set(self.modules.keys())
+        added = list(new_names - old_names)
+        removed = list(old_names - new_names)
+        for name in added:
+            info = self.modules[name]
+            self._log_lifecycle("scanned", name, state=info.state, module_dir=info.module_dir)
+            self._desired_states[name] = "running" if info.state == "enabled" else "stopped"
+        if added:
+            new_tokens = {}
+            for name in added:
+                self._module_tokens[name] = secrets.token_hex(32)
+                new_tokens[name] = self._module_tokens[name]
+            await self._register_new_tokens(new_tokens)
+        return {"added": added, "removed": removed, "total": len(self.modules)}
+
+    async def _rpc_shutdown(self, params: dict) -> dict:
+        """Shutdown the entire Kite system."""
+        reason = params.get("reason", "rpc_request")
+        self._request_shutdown(f"RPC shutdown request: {reason}")
+        return {"status": "shutting_down", "reason": reason}
+
+    # ── Event publishing via RPC ──
 
     async def _publish_event(self, event_type: str, data: dict):
-        """Publish an event to Event Hub via WebSocket. Uses create_task to avoid
-        deadlock with _ws_connect recv loop (websockets 15.x send can block when
-        incoming frames are pending and recv is held by async-for)."""
+        """Publish an event via RPC event.publish through Kernel WS."""
         if not self._ws:
             return
-        from datetime import datetime, timezone
         msg = json.dumps({
-            "type": "event",
-            "event_id": str(uuid.uuid4()),
-            "event": event_type,
-            "source": "launcher",
-            "timestamp": datetime.now(timezone.utc).isoformat(),
-            "data": data,
+            "jsonrpc": "2.0",
+            "id": str(uuid.uuid4()),
+            "method": "event.publish",
+            "params": {
+                "event_id": str(uuid.uuid4()),
+                "event": event_type,
+                "data": data,
+            },
         })
 
         async def _send():
@@ -855,14 +896,6 @@ class Launcher:
 
         asyncio.create_task(_send())
 
-    def _publish_event_threadsafe(self, event_type: str, data: dict):
-        """Publish event from non-async context (API thread). Fire-and-forget."""
-        if not self._ws or not self._loop:
-            return
-        asyncio.run_coroutine_threadsafe(
-            self._publish_event(event_type, data), self._loop,
-        )
-
     async def _wait_event(self, event_type: str, module_id: str, timeout: float) -> dict | None:
         """Wait for a specific event from a module. Returns data dict or None on timeout."""
         key = f"{event_type}:{module_id}"
@@ -892,12 +925,32 @@ class Launcher:
             })
             return
 
+        # Register waiters BEFORE sending shutdown event
+        ack_key = f"module.shutdown.ack:{name}"
+        ack_evt = asyncio.Event()
+        ack_data = {}
+        self._event_waiters[ack_key] = (ack_evt, ack_data)
+
+        ready_key = f"module.shutdown.ready:{name}"
+        ready_evt = asyncio.Event()
+        ready_data = {}
+        self._event_waiters[ready_key] = (ready_evt, ready_data)
+
         await self._publish_event("module.shutdown", {
             "module_id": name, "reason": reason, "timeout": timeout,
         })
 
-        ack = await self._wait_event("module.shutdown.ack", name, timeout=3)
+        # Wait for ack
+        try:
+            await asyncio.wait_for(ack_evt.wait(), timeout=3)
+            ack = ack_data
+        except asyncio.TimeoutError:
+            ack = None
+        finally:
+            self._event_waiters.pop(ack_key, None)
+
         if not ack:
+            self._event_waiters.pop(ready_key, None)
             self.process_manager.stop_module(name, timeout=SHUTDOWN_TIMEOUT_NON_GRACEFUL)
             await self._publish_event("module.stopped", {
                 "module_id": name,
@@ -906,7 +959,15 @@ class Launcher:
             return
 
         estimated = min(ack.get("estimated_cleanup", timeout), timeout)
-        ready = await self._wait_event("module.shutdown.ready", name, timeout=estimated)
+
+        # Wait for ready
+        try:
+            await asyncio.wait_for(ready_evt.wait(), timeout=estimated)
+            ready = ready_data
+        except asyncio.TimeoutError:
+            ready = None
+        finally:
+            self._event_waiters.pop(ready_key, None)
         if ready:
             self.process_manager.stop_module(name, timeout=SHUTDOWN_TIMEOUT_READY)
         else:
@@ -920,10 +981,10 @@ class Launcher:
 
     async def _graceful_shutdown_all(self):
         """Shut down all modules. Order:
-        1. Send shutdown to graceful modules (excl. Event Hub) — let them start cleanup
+        1. Send shutdown to graceful modules (excl. Kernel) — let them start cleanup
         2. Terminate non-graceful modules (fast, runs during graceful cleanup)
         3. Wait for graceful modules to exit (process monitoring)
-        4. Shut down Event Hub last (keeps event routing alive throughout)
+        4. Shut down Kernel last (keeps event routing alive throughout)
         """
         self._system_shutting_down = True
         running = [n for n in self.modules if self.process_manager.is_running(n)]
@@ -938,9 +999,9 @@ class Launcher:
         graceful = [n for n in running if self._graceful_modules.get(n)]
         non_graceful = [n for n in running if not self._graceful_modules.get(n)]
 
-        # Defer Event Hub — it must stay alive to route shutdown events
-        hub_deferred = "event_hub" in graceful
-        graceful_batch = [n for n in graceful if n != "event_hub"] if hub_deferred else graceful
+        # Defer Kernel — it must stay alive to route shutdown events
+        kernel_deferred = "kernel" in graceful
+        graceful_batch = [n for n in graceful if n != "kernel"] if kernel_deferred else graceful
 
         print(f"[launcher] 正在关闭 {len(running)} 个模块: {', '.join(running)}")
 
@@ -976,44 +1037,49 @@ class Launcher:
                     self.process_manager.stop_module(name, timeout=SHUTDOWN_TIMEOUT_PARTIAL)
                     self._log_lifecycle("stopped", name, reason="system_shutdown")
 
-        # Phase 4: All other modules exited — now shut down Event Hub
-        if hub_deferred and self.process_manager.is_running("event_hub"):
-            self._log_lifecycle("stopping", "event_hub", reason="system_shutdown")
-            await self._publish_event("module.shutdown", {
-                "module_id": "event_hub", "reason": "system_shutdown", "timeout": 5,
-            })
-            deadline = time.time() + 5
-            while time.time() < deadline:
-                if not self.process_manager.is_running("event_hub"):
-                    print("[launcher] Event Hub 已退出")
-                    break
-                await asyncio.sleep(0.5)
-            if self.process_manager.is_running("event_hub"):
-                self.process_manager.stop_module("event_hub", timeout=SHUTDOWN_TIMEOUT_PARTIAL)
-            self._log_lifecycle("stopped", "event_hub", reason="system_shutdown")
+        # Phase 4: All other modules exited — now shut down Kernel
+        if kernel_deferred and self.process_manager.is_running("kernel"):
+            self._log_lifecycle("stopping", "kernel", reason="system_shutdown")
+            print("[launcher] 正在关闭 Kernel...")
+
+            # Call kernel.shutdown RPC (not event)
+            rpc_sent = False
+            try:
+                if self._ws:
+                    await self._rpc_call(self._ws, "kernel.shutdown", {})
+                    print("[launcher] Kernel shutdown RPC 已发送")
+                    rpc_sent = True
+                else:
+                    print("[launcher] WebSocket 未连接，跳过 RPC 调用")
+            except Exception as e:
+                print(f"[launcher] Kernel shutdown RPC 失败: {e}")
+
+            # Wait for kernel to exit
+            if rpc_sent:
+                # RPC sent: wait up to 5s for graceful exit
+                proc = self.process_manager._processes.get("kernel")
+                if proc:
+                    try:
+                        loop = asyncio.get_event_loop()
+                        await asyncio.wait_for(
+                            loop.run_in_executor(None, proc.wait),
+                            timeout=5
+                        )
+                        print("[launcher] Kernel 已退出")
+                    except asyncio.TimeoutError:
+                        print("[launcher] Kernel 5秒内未退出，强制停止")
+                        self.process_manager.stop_module("kernel", timeout=SHUTDOWN_TIMEOUT_PARTIAL)
+            else:
+                # No RPC (WS not connected): use shorter timeout for terminate
+                self.process_manager.stop_module("kernel", timeout=2)
+
+            self._log_lifecycle("stopped", "kernel", reason="system_shutdown")
 
         # Final safety net
         try:
             self.process_manager.stop_all(timeout=SHUTDOWN_TIMEOUT_BULK)
         except Exception as e:
             print(f"[launcher] stop_all 出错: {e}")
-        await self._close_http()
-
-    # ── Heartbeat to Registry ──
-
-    async def _heartbeat_loop(self):
-        """Send heartbeat to Registry every 30 seconds."""
-        while not self._thread_shutdown.is_set():
-            await asyncio.sleep(30)
-            try:
-                client = self._get_http()
-                await client.post(
-                    f"http://127.0.0.1:{self.registry_port}/modules",
-                    json={"action": "heartbeat", "module_id": "launcher"},
-                    headers={"Authorization": f"Bearer {self.kite_token}"},
-                )
-            except Exception:
-                pass
 
     # ── Module startup ──
 
@@ -1080,7 +1146,7 @@ class Launcher:
         return layers
 
     async def _start_one_module(self, info: ModuleInfo):
-        """Start a single module: publish starting → start process → wait ready → started → close stdio."""
+        """Start a single module: publish starting → start process → send kernel_port → wait ready → started → close stdio."""
         self._log_lifecycle("starting", info.name)
         await self._publish_event("module.starting", {"module_id": info.name})
 
@@ -1092,13 +1158,32 @@ class Launcher:
             self._log_lifecycle("start_failed", info.name)
             return
 
+        # Register waiter BEFORE sending kernel_port
+        # This prevents race condition where module connects and sends module.ready before waiter is registered
+        ready_key = f"module.ready:{info.name}"
+        ready_evt = asyncio.Event()
+        ready_data = {}
+        self._event_waiters[ready_key] = (ready_evt, ready_data)
+
+        # Send kernel_port via stdin so module can connect to Kernel WS
+        self.process_manager.write_stdin(info.name, {
+            "kite": "kernel_port",
+            "kernel_port": self.kernel_port,
+        })
+
         # Persist immediately after starting to ensure PID is recorded
-        # (in case launcher crashes before Phase 4 completes)
         self.process_manager.persist_records()
 
         # Wait for module.ready or module.exiting (whichever comes first)
         timeout = info.launch.timeout
-        ready = await self._wait_event("module.ready", info.name, timeout=timeout)
+        try:
+            await asyncio.wait_for(ready_evt.wait(), timeout=timeout)
+            ready = ready_data
+        except asyncio.TimeoutError:
+            ready = None
+        finally:
+            self._event_waiters.pop(ready_key, None)
+
         elapsed = time.monotonic() - t0
         if ready and ready.get("_exited"):
             # Module sent module.exiting before ready — it chose to quit
@@ -1110,7 +1195,7 @@ class Launcher:
             self._ready_times[info.name] = elapsed
             print(f"[launcher] 模块 '{info.name}' 已就绪 ({elapsed:.2f}s)")
         else:
-            print(f"[launcher] 警告: '{info.name}' 在 {timeout}s 内未发送 module.ready")
+            print(f"\033[91m[launcher] 警告: '{info.name}' 在 {timeout}s 内未发送 module.ready\033[0m")
 
         rec = self.process_manager.get_record(info.name)
         self._log_lifecycle("started", info.name, pid=rec.pid if rec else None)
@@ -1118,87 +1203,74 @@ class Launcher:
         self.process_manager.close_stdio(info.name)
 
     async def _register_module_tokens(self):
-        """Generate per-module tokens and register the mapping to Registry."""
-        # Include all scanned modules + core modules
-        for name in self.modules:
-            if name not in self._module_tokens:
-                self._module_tokens[name] = secrets.token_hex(32)
-        # Ensure registry has a token
-        if "registry" not in self._module_tokens:
-            self._module_tokens["registry"] = secrets.token_hex(32)
+        """Generate per-module tokens and register the mapping to Kernel via RPC."""
+        # Include all scanned modules
+    async def _generate_module_tokens(self):
+        """Request Kernel to generate tokens for all scanned modules via RPC."""
+        # Collect module names that need tokens
+        module_names = [name for name in self.modules if name not in self._module_tokens]
+
+        if not module_names:
+            return
 
-        if not self._module_tokens:
+        # Wait for WebSocket connection to be ready
+        if self._ws_connected:
+            try:
+                await asyncio.wait_for(self._ws_connected.wait(), timeout=5)
+            except asyncio.TimeoutError:
+                print(f"[launcher] 警告: WebSocket 未就绪，无法生成令牌")
+                return
+        else:
+            print(f"[launcher] 警告: _ws_connected 未初始化")
             return
 
-        await self._register_tokens_to_registry(self._module_tokens)
+        # Call Kernel RPC to generate tokens
+        try:
+            result = await self._rpc_call(self._ws, "kernel.generate_tokens", {"modules": module_names})
+            if result.get("result", {}).get("ok"):
+                tokens = result["result"].get("tokens", {})
+                self._module_tokens.update(tokens)
+                print(f"[launcher] Kernel 已生成 {len(tokens)} 个模块令牌")
+            elif "error" in result:
+                print(f"[launcher] 警告: 令牌生成失败: {result['error'].get('message', '')}")
+        except Exception as e:
+            print(f"[launcher] 警告: 生成模块令牌失败: {e}")
 
-    async def _register_tokens_to_registry(self, tokens: dict):
-        """Register token mapping to Registry via POST /tokens."""
-        url = f"http://127.0.0.1:{self.registry_port}/tokens"
-        headers = {"Authorization": f"Bearer {self.kite_token}"}
+    async def _register_new_tokens(self, tokens: dict):
+        """Register new token mapping to Kernel via RPC kernel.register_tokens."""
+        if not self._ws or not tokens:
+            return
         try:
-            client = self._get_http()
-            resp = await client.post(url, json=tokens, headers=headers)
-            if resp.status_code == 200:
+            result = await self._rpc_call(self._ws, "kernel.register_tokens", tokens)
+            if result.get("result", {}).get("ok"):
                 print(f"[launcher] 已注册 {len(tokens)} 个模块令牌")
-            else:
-                print(f"[launcher] 警告: 令牌注册返回 {resp.status_code}")
+            elif "error" in result:
+                print(f"[launcher] 警告: 令牌注册失败: {result['error'].get('message', '')}")
         except Exception as e:
             print(f"[launcher] 警告: 注册模块令牌失败: {e}")
 
     # ── Validation ──
 
     def _validate_core_modules(self):
-        """Validate core modules exist (mechanism 12)."""
+        """Validate core modules exist."""
         project_root = os.environ["KITE_PROJECT"]
-        for name in ("registry", "event_hub"):
-            mod_dir = os.path.join(project_root, "core", name)
-            md_path = os.path.join(mod_dir, "module.md")
-            if not os.path.isdir(mod_dir):
-                print(f"[launcher] 致命: 核心模块 '{name}' 目录未找到: {mod_dir}")
-                sys.exit(1)
-            if not os.path.isfile(md_path):
-                print(f"[launcher] 致命: 核心模块 '{name}' 缺少 module.md: {md_path}")
-                sys.exit(1)
-            # Try to parse frontmatter
-            try:
-                with open(md_path, "r", encoding="utf-8") as f:
-                    fm = _parse_frontmatter(f.read())
-                if not fm:
-                    print(f"[launcher] 致命: 核心模块 '{name}' module.md 没有有效的 frontmatter")
-                    sys.exit(1)
-            except Exception as e:
-                print(f"[launcher] 致命: 核心模块 '{name}' module.md 解析错误: {e}")
+        mod_dir = os.path.join(project_root, "kernel")
+        md_path = os.path.join(mod_dir, "module.md")
+        if not os.path.isdir(mod_dir):
+            print(f"[launcher] 致命: 核心模块 'kernel' 目录未找到: {mod_dir}")
+            sys.exit(1)
+        if not os.path.isfile(md_path):
+            print(f"[launcher] 致命: 核心模块 'kernel' 缺少 module.md: {md_path}")
+            sys.exit(1)
+        try:
+            with open(md_path, "r", encoding="utf-8") as f:
+                fm = _parse_frontmatter(f.read())
+            if not fm:
+                print(f"[launcher] 致命: 核心模块 'kernel' module.md 没有有效的 frontmatter")
                 sys.exit(1)
-
-    # ── API thread ──
-
-    def _start_api_thread(self):
-        """Start the Launcher API server in a separate thread with OS-assigned port."""
-        self.api_port = self._get_free_port()
-        config = uvicorn.Config(
-            self._app,
-            host="127.0.0.1",
-            port=self.api_port,
-            log_level="warning",
-        )
-        self._api_server = uvicorn.Server(config)
-
-        def _run():
-            self._api_server.run()
-
-        t = threading.Thread(target=_run, daemon=True)
-        t.start()
-
-        deadline = time.time() + 5
-        while time.time() < deadline:
-            if self._api_server.started:
-                break
-            time.sleep(0.05)
-        else:
-            print("[launcher] 警告: API 服务器可能尚未完全就绪")
-
-        print(f"[launcher] API 服务器已启动，端口 {self.api_port}")
+        except Exception as e:
+            print(f"[launcher] 致命: 核心模块 'kernel' module.md 解析错误: {e}")
+            sys.exit(1)
 
     # ── Module crash summary ──
 
@@ -1296,29 +1368,23 @@ class Launcher:
                 pass
 
     async def _full_restart(self):
-        """Stop all modules, regenerate tokens, re-run Phase 1-4 (mechanism 10)."""
+        """Stop all modules, regenerate tokens, re-run Phase 1-2."""
         print("[launcher] 全量重启: 正在停止所有模块...")
 
         # Persist records before shutdown so cleanup_leftovers can find survivors
         self.process_manager.persist_records()
 
-        # Disconnect Event Hub WS
+        # Disconnect Kernel WS
         if self._ws_task:
             self._ws_task.cancel()
             self._ws_task = None
-        if hasattr(self, '_heartbeat_task') and self._heartbeat_task:
-            self._heartbeat_task.cancel()
-            self._heartbeat_task = None
         self._ws = None
-        self._event_hub_ws_url = ""
-        self._launcher_ws_token = ""
+        self._rpc_waiters.clear()
+        self._rpc_results.clear()
 
         await self._graceful_shutdown_all()
 
         # Cleanup any leftover processes that survived graceful shutdown.
-        # Note: _graceful_shutdown_all() clears _processes/_records dicts, but
-        # cleanup_leftovers() reads from processes.json (persisted above), so it can
-        # still find and kill survivors.
         self.process_manager.cleanup_leftovers()
 
         self._module_tokens.clear()
@@ -1327,13 +1393,11 @@ class Launcher:
         self.kite_token = secrets.token_hex(32)
         self.process_manager.kite_token = self.kite_token
 
-        print("[launcher] 全量重启: 重新执行 Phase 1-4...")
+        print("[launcher] 全量重启: 重新执行 Phase 1-2...")
         try:
-            await self._phase1_parallel_bootstrap()
-            await self._phase3_registry_ready()
-            await self._phase4_start_modules()
+            await self._phase1_start_kernel()
+            await self._phase2_start_modules()
             self.process_manager.persist_records()
-            self._heartbeat_task = asyncio.create_task(self._heartbeat_loop())
             print("[launcher] 全量重启完成，恢复监控循环")
             await self._monitor_loop()
         except Exception as e:
@@ -1342,14 +1406,12 @@ class Launcher:
     # ── Shutdown ──
 
     def _final_cleanup(self):
-        """Called on exit — stop all processes, stop API, clear records."""
+        """Called on exit — stop all processes, clear records."""
         try:
             print("[launcher] 正在执行最终清理...")
 
             if self._ws_task:
                 self._ws_task.cancel()
-            if hasattr(self, '_heartbeat_task') and self._heartbeat_task:
-                self._heartbeat_task.cancel()
 
             # Note: _graceful_shutdown_all() already called stop_all() in _async_main finally block.
             # This is just a safety check — should normally find nothing.
@@ -1361,9 +1423,6 @@ class Launcher:
             else:
                 print("[launcher] 无残留进程")
 
-            if self._api_server:
-                self._api_server.should_exit = True
-
             # Clear instance runtime files
             try:
                 os.remove(self.process_manager.records_path)
@@ -1374,7 +1433,13 @@ class Launcher:
         finally:
             # Signal the safety-net thread that normal shutdown has completed
             self._shutdown_complete.set()
-            print("[launcher] 再见。")
+
+            # Calculate and display shutdown time
+            if self._shutdown_start_time > 0:
+                shutdown_elapsed = time.monotonic() - self._shutdown_start_time
+                print(f"[launcher] 再见。(退出耗时: {shutdown_elapsed:.2f}s)")
+            else:
+                print("[launcher] 再见。")
 
             if IS_WINDOWS:
                 os._exit(0)
@@ -1403,11 +1468,8 @@ class Launcher:
             else:
                 stopped.append((name, info))
 
-        # Calculate kernel startup time (Phase 1+2+3)
-        kernel_time = 0
-        for phase_name in ["Phase 1+2: Registry + Event Hub (并行)", "Phase 3: Registry 事件总线"]:
-            if phase_name in phase_times:
-                kernel_time += phase_times[phase_name]
+        # Calculate kernel startup time (Phase 1)
+        kernel_time = phase_times.get("Phase 1: Kernel", 0)
 
         lines = [
             "",
@@ -1422,16 +1484,15 @@ class Launcher:
 
         # Kernel modules section
         lines.append(f"{G}    内核模块:{R}")
-        for phase_name in ["Phase 1+2: Registry + Event Hub (并行)", "Phase 3: Registry 事件总线"]:
-            if phase_name in phase_times:
-                elapsed = phase_times[phase_name]
-                lines.append(f"{G}      {phase_name:<26s} {elapsed:>6.2f}s{R}")
+        if "Phase 1: Kernel" in phase_times:
+            elapsed = phase_times["Phase 1: Kernel"]
+            lines.append(f"{G}      {'Phase 1: Kernel':<26s} {elapsed:>6.2f}s{R}")
 
         # Extension modules section
         lines.append(f"{G}    扩展模块:{R}")
-        if "Phase 4: Extensions" in phase_times:
-            elapsed = phase_times["Phase 4: Extensions"]
-            lines.append(f"{G}      {'Phase 4: Extensions':<26s} {elapsed:>6.2f}s{R}")
+        if "Phase 2: Extensions" in phase_times:
+            elapsed = phase_times["Phase 2: Extensions"]
+            lines.append(f"{G}      {'Phase 2: Extensions':<26s} {elapsed:>6.2f}s{R}")
 
         # Sort running modules by ready time
         running_sorted = sorted(running, key=lambda x: self._ready_times.get(x[0], float('inf')))
@@ -1471,12 +1532,21 @@ class Launcher:
                 es_str = f"{elapsed_from_start:.2f}s"
             else:
                 es_str = "—"
-            rows.append([label, str(rec.pid), time_str, es_str, f"[{info.type}]"])
+
+            # Check if module timed out (ready_t >= 15s for kernel, >= timeout for others)
+            is_timeout = False
+            if ready_t is not None:
+                if name == "kernel" and ready_t >= 15:
+                    is_timeout = True
+                elif name != "kernel" and ready_t >= 15:  # Default timeout for other modules
+                    is_timeout = True
+
+            rows.append([label, str(rec.pid), time_str, es_str, f"[{info.type}]", is_timeout])
 
         # Calculate column widths: max of header and all data display widths
         col_widths = [_dw(h) for h in headers]
         for row in rows:
-            for i, cell in enumerate(row):
+            for i, cell in enumerate(row[:5]):  # Only first 5 columns (exclude is_timeout flag)
                 col_widths[i] = max(col_widths[i], _dw(cell))
 
         # Render header
@@ -1489,14 +1559,19 @@ class Launcher:
         lines.append(f"{DIM}      {'  '.join(hdr_parts)}{R}")
 
         # Render data rows
+        RED = "\033[91m"
         for row in rows:
+            is_timeout = row[5]  # Last element is the timeout flag
             parts = []
-            for i, cell in enumerate(row):
+            for i, cell in enumerate(row[:5]):  # Only first 5 columns
                 if aligns[i] == 'left':
                     parts.append(_rpad(cell, col_widths[i]))
                 else:
                     parts.append(_lpad(cell, col_widths[i]))
-            lines.append(f"{G}    ✓ {'  '.join(parts)}{R}")
+            if is_timeout:
+                lines.append(f"{RED}    ✓ {'  '.join(parts)}{R}")
+            else:
+                lines.append(f"{G}    ✓ {'  '.join(parts)}{R}")
 
         # Exited modules (started but already quit)
         if exited:
@@ -1514,10 +1589,18 @@ class Launcher:
                 label = info.display_name or name
                 lines.append(f"{G}    - {label:<20s} ({info.state}){R}")
 
-        lines.append(f"{G}  Launcher API: http://127.0.0.1:{self.api_port}   实例: {self.instance_id}{R}")
+        lines.append(f"{G}  Kernel WS: ws://127.0.0.1:{self.kernel_port}/ws   实例: {self.instance_id}{R}")
 
-        # Query Registry for web module's access URL
-        web_url = await self._get_web_url()
+        # Query Kernel for web module's api_endpoint via RPC
+        web_url = ""
+        if self._ws:
+            try:
+                resp = await self._rpc_call(self._ws, "registry.get", {"path": "web.api_endpoint"}, timeout=3)
+                val = resp.get("result", {}).get("value")
+                if val and isinstance(val, str):
+                    web_url = val.replace("://127.0.0.1:", "://localhost:")
+            except Exception:
+                pass
         if web_url:
             lines.append(f"{B}  Web 管理后台: {web_url}{R}")
 
@@ -1572,29 +1655,11 @@ class Launcher:
 
         print("\n".join(lines))
 
-    async def _get_web_url(self) -> str:
-        """Query Registry for the web module's api_endpoint. Returns URL or empty string."""
-        try:
-            client = self._get_http()
-            resp = await client.get(
-                f"http://127.0.0.1:{self.registry_port}/get/web.api_endpoint",
-                headers={"Authorization": f"Bearer {self.kite_token}"},
-                timeout=3,
-            )
-            if resp.status_code == 200:
-                val = resp.json()
-                if val and isinstance(val, str):
-                    # Show localhost instead of 127.0.0.1 for friendliness
-                    return val.replace("://127.0.0.1:", "://localhost:")
-        except Exception:
-            pass
-        return ""
-
     # ── Utilities ──
 
     def _load_discovery(self) -> dict | None:
         """Read discovery config from launcher's own module.md."""
-        md_path = os.path.join(os.environ["KITE_PROJECT"], "core", "launcher", "module.md")
+        md_path = os.path.join(os.environ["KITE_PROJECT"], "launcher", "module.md")
         try:
             with open(md_path, "r", encoding="utf-8") as f:
                 fm = _parse_frontmatter(f.read())
@@ -1617,214 +1682,6 @@ class Launcher:
         except Exception:
             pass
 
-    @staticmethod
-    def _get_free_port() -> int:
-        """Get a free port assigned by the OS (bind to port 0)."""
-        import socket
-        with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
-            s.bind(("127.0.0.1", 0))
-            return s.getsockname()[1]
-
-    # ── API app ──
-
-    def _create_api_app(self) -> FastAPI:
-        """Create the FastAPI app with Launcher management routes."""
-        from fastapi import Request, HTTPException
-        app = FastAPI(title="Kite Launcher", docs_url=None, redoc_url=None)
-        launcher = self
-
-        def _require_auth(request: Request):
-            """Verify Bearer token and IP whitelist. Raise 401/403 on failure."""
-            # IP whitelist: only allow 127.0.0.1
-            client_host = request.client.host if request.client else None
-            if client_host not in ("127.0.0.1", "::1", "localhost"):
-                raise HTTPException(status_code=403, detail="Access denied: only localhost allowed")
-
-            # Bearer token verification
-            auth = request.headers.get("Authorization", "")
-            if not auth.startswith("Bearer "):
-                raise HTTPException(status_code=401, detail="Missing or invalid Authorization header")
-            token = auth[7:].strip()
-            if token != launcher.kite_token:
-                raise HTTPException(status_code=401, detail="Invalid token")
-
-        @app.get("/launcher/modules")
-        async def list_modules(request: Request):
-            """List all modules and their current status."""
-            _require_auth(request)
-            result = []
-            for name, info in launcher.modules.items():
-                running = launcher.process_manager.is_running(name)
-                rec = launcher.process_manager.get_record(name)
-                result.append({
-                    "name": name,
-                    "display_name": info.display_name,
-                    "type": info.type,
-                    "config_state": info.state,
-                    "desired_state": launcher._desired_states.get(name, "stopped"),
-                    "actual_state": f"running({rec.pid})" if running and rec else "stopped",
-                    "pid": rec.pid if running and rec else None,
-                    "monitor": info.monitor,
-                })
-            return result
-
-        @app.post("/launcher/modules/{name}/start")
-        async def start_module(name: str, request: Request):
-            """Start a module by name."""
-            _require_auth(request)
-            info = launcher.modules.get(name)
-            if not info:
-                raise HTTPException(404, f"Module '{name}' not found")
-            if info.state == "disabled":
-                raise HTTPException(403, f"Module '{name}' is disabled")
-
-            if name not in launcher._module_tokens:
-                launcher._module_tokens[name] = secrets.token_hex(32)
-                try:
-                    client = launcher._get_http()
-                    await client.post(
-                        f"http://127.0.0.1:{launcher.registry_port}/tokens",
-                        json={name: launcher._module_tokens[name]},
-                        headers={"Authorization": f"Bearer {launcher.kite_token}"},
-                    )
-                except Exception as e:
-                    print(f"[launcher] 警告: 注册 {name} 的令牌失败: {e}")
-
-            token = launcher._module_tokens[name]
-            boot_info = {"token": token}
-            ok = launcher.process_manager.start_module(info, boot_info=boot_info)
-            if ok:
-                launcher._desired_states[name] = "running"
-                launcher.process_manager.persist_records()
-                rec = launcher.process_manager.get_record(name)
-                launcher._log_lifecycle("started", name, pid=rec.pid if rec else None, via="api")
-                launcher._publish_event_threadsafe("module.started", {"module_id": name})
-                return {"status": "started", "name": name}
-            launcher._log_lifecycle("start_failed", name, via="api")
-            raise HTTPException(500, f"Failed to start '{name}'")
-
-        @app.post("/launcher/modules/{name}/stop")
-        async def stop_module(name: str, request: Request, body: dict = None):
-            """Stop a module with graceful shutdown."""
-            _require_auth(request)
-            info = launcher.modules.get(name)
-            if not info:
-                raise HTTPException(404, f"Module '{name}' not found")
-            reason = (body or {}).get("reason", "stop_requested")
-            launcher._desired_states[name] = "stopped"
-            await launcher._graceful_stop(name, reason)
-            launcher.process_manager.persist_records()
-            return {"status": "stopped", "name": name}
-
-        @app.post("/launcher/modules/{name}/restart")
-        async def restart_module(name: str, request: Request, body: dict = None):
-            """Restart a module (stop + start)."""
-            _require_auth(request)
-            info = launcher.modules.get(name)
-            if not info:
-                raise HTTPException(404, f"Module '{name}' not found")
-            if info.state == "disabled":
-                raise HTTPException(403, f"Module '{name}' is disabled")
-            reason = (body or {}).get("reason", "restart")
-            await launcher._graceful_stop(name, reason)
-            launcher._module_tokens[name] = secrets.token_hex(32)
-            try:
-                client = launcher._get_http()
-                await client.post(
-                    f"http://127.0.0.1:{launcher.registry_port}/tokens",
-                    json={name: launcher._module_tokens[name]},
-                    headers={"Authorization": f"Bearer {launcher.kite_token}"},
-                )
-            except Exception:
-                pass
-            token = launcher._module_tokens[name]
-            boot_info = {"token": token}
-            ok = launcher.process_manager.start_module(info, boot_info=boot_info)
-            if ok:
-                launcher._desired_states[name] = "running"
-                launcher.process_manager.persist_records()
-                rec = launcher.process_manager.get_record(name)
-                launcher._log_lifecycle("started", name, pid=rec.pid if rec else None, via="restart_api")
-                launcher._publish_event_threadsafe("module.started", {"module_id": name})
-                return {"status": "restarted", "name": name}
-            launcher._log_lifecycle("start_failed", name, via="restart_api")
-            raise HTTPException(500, f"Failed to restart '{name}'")
-
-        @app.post("/launcher/rescan")
-        async def rescan_modules(request: Request):
-            """Rescan module directories for new/removed modules."""
-            _require_auth(request)
-            old_names = set(launcher.modules.keys())
-            launcher.modules = launcher.module_scanner.scan()
-            new_names = set(launcher.modules.keys())
-            added = list(new_names - old_names)
-            removed = list(old_names - new_names)
-            for name in added:
-                info = launcher.modules[name]
-                launcher._log_lifecycle("scanned", name, state=info.state, module_dir=info.module_dir)
-            for name in added:
-                info = launcher.modules[name]
-                launcher._desired_states[name] = "running" if info.state == "enabled" else "stopped"
-            if added:
-                new_tokens = {}
-                for name in added:
-                    launcher._module_tokens[name] = secrets.token_hex(32)
-                    new_tokens[name] = launcher._module_tokens[name]
-                try:
-                    client = launcher._get_http()
-                    await client.post(
-                        f"http://127.0.0.1:{launcher.registry_port}/tokens",
-                        json=new_tokens,
-                        headers={"Authorization": f"Bearer {launcher.kite_token}"},
-                    )
-                except Exception:
-                    pass
-            return {"added": added, "removed": removed, "total": len(launcher.modules)}
-
-        @app.post("/launcher/shutdown")
-        async def shutdown_launcher(request: Request, body: dict = None):
-            """Shutdown the entire Kite system (equivalent to Ctrl+C)."""
-            _require_auth(request)
-            reason = (body or {}).get("reason", "api_request")
-            launcher._request_shutdown(f"API shutdown request: {reason}")
-            return {"status": "shutting_down", "reason": reason}
-
-        @app.put("/launcher/modules/{name}/state")
-        async def update_state(name: str, request: Request, body: dict):
-            """Update module state (enabled/manual/disabled). Writes to module.md."""
-            _require_auth(request)
-            info = launcher.modules.get(name)
-            if not info:
-                raise HTTPException(404, f"Module '{name}' not found")
-
-            new_state = body.get("state", "")
-            if new_state not in ("enabled", "manual", "disabled"):
-                raise HTTPException(400, "state must be enabled, manual, or disabled")
-
-            if info.is_core() and new_state == "disabled":
-                raise HTTPException(403, "Core modules cannot be disabled")
-
-            old_state = info.state
-            info.state = new_state
-
-            if new_state == "enabled":
-                launcher._desired_states[name] = "running"
-            else:
-                launcher._desired_states[name] = "stopped"
-
-            _update_module_md_state(info.module_dir, new_state)
-            launcher._publish_event_threadsafe("module.state_changed", {
-                "module_id": name,
-                "old_state": old_state,
-                "new_state": new_state,
-            })
-            return {
-                "name": name,
-                "old_state": old_state,
-                "new_state": new_state,
-            }
-
-        return app
 
 
 def _update_module_md_state(module_dir: str, new_state: str):
@@ -1850,3 +1707,72 @@ def _update_module_md_state(module_dir: str, new_state: str):
             f.write(updated)
     except Exception as e:
         print(f"[launcher] 警告: 更新 module.md 状态失败: {e}")
+
+
+def start_launcher():
+    """Entry point called from main.py. Sets up environment and starts launcher."""
+    # Load .env (development convenience)
+    try:
+        from dotenv import load_dotenv
+        load_dotenv()
+    except ImportError:
+        pass
+
+    # Resolve project root
+    project_root = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+
+    # Home base for Kite data
+    home = os.environ.get("HOME") or os.environ.get("USERPROFILE") or os.path.expanduser("~")
+    kite_home = os.path.join(home, ".kite")
+
+    # Set KITE_* defaults
+    defaults = {
+        "KITE_PROJECT": project_root,
+        "KITE_CWD": os.getcwd(),
+        "KITE_WORKSPACE": os.path.join(kite_home, "workspace"),
+        "KITE_DATA": os.path.join(kite_home, "data"),
+        "KITE_MODULES": os.path.join(kite_home, "modules"),
+        "KITE_REPO": os.path.join(kite_home, "repo"),
+        "KITE_ENV": "development",
+    }
+    for key, value in defaults.items():
+        if not os.environ.get(key):
+            os.environ[key] = value
+
+    # Parse CLI args
+    if "--debug" in sys.argv:
+        os.environ["KITE_DEBUG"] = "1"
+        sys.argv.remove("--debug")
+
+    # Setup logging
+    from .logging_setup import (
+        setup_timestamped_print,
+        init_log_files,
+        setup_exception_hooks,
+        reset_time_baseline,
+        write_crash_handled
+    )
+    setup_timestamped_print()
+    reset_time_baseline()
+
+    print("[launcher] Kite 启动中...")
+
+    # Create and run launcher
+    token = secrets.token_hex(32)
+    launcher = Launcher(kite_token=token)
+    print("[launcher] 启动器实例已创建")
+
+    # Initialize log files (KITE_MODULE_DATA is now set)
+    init_log_files()
+    setup_exception_hooks()
+
+    log_dir = os.path.join(os.environ.get("KITE_MODULE_DATA", ""), "log")
+    suffix = launcher.process_manager.instance_suffix
+    latest_log = os.path.join(log_dir, f"latest{suffix}.log")
+    print(f"[launcher] 日志: {latest_log}")
+
+    try:
+        launcher.run()
+    except Exception as e:
+        write_crash_handled(type(e), e, e.__traceback__)
+        sys.exit(1)