Claude Code: Add import-time worker bootstrap for guaranteed startup

Dual-trigger mechanism:
1. Import-time bootstrap: Worker starts immediately when app.py loads
2. Startup event failsafe: Redundant backup in case bootstrap fails

- Run asyncio polling in daemon thread with its own event loop
- Hard-write worker_active=True immediately at import time
- Startup event now a failsafe wrapper that checks bootstrap status

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

app.py

@@ -35,6 +35,94 @@ _worker_stop_event = None
 _polling_task = None
 _polling_lock = threading.Lock()
 
+# ========== IMMEDIATE BOOTSTRAP (Module Import Time) ==========
+# This fires the moment app.py is imported, BEFORE FastAPI starts
+# Bypasses unreliable startup event by starting worker immediately
+_bootstrap_worker_active = False
+
+
+def _run_asyncio_polling_in_thread():
+    """
+    Run the asyncio polling task in its own event loop within a daemon thread.
+    This ensures the polling loop starts immediately at module import time.
+    """
+    global _bootstrap_worker_active
+
+    logger.info("=" * 60)
+    logger.info("[BOOTSTRAP] ========== IMPORT-TIME WORKER START ==========")
+    logger.info(f"[BOOTSTRAP] Timestamp: {datetime.utcnow().isoformat()}")
+    logger.info(f"[BOOTSTRAP] PID: {os.getpid()}")
+    logger.info(f"[BOOTSTRAP] Thread: {threading.current_thread().name}")
+    logger.info("=" * 60)
+
+    # Create new event loop for this thread
+    loop = asyncio.new_event_loop()
+    asyncio.set_event_loop(loop)
+
+    try:
+        # Run the polling task - this blocks forever in while True
+        loop.run_until_complete(_poll_a2a_ready_state())
+    except Exception as e:
+        logger.error(f"[BOOTSTRAP] Polling loop failed: {e}")
+    finally:
+        loop.close()
+
+
+def _bootstrap_immediate_worker():
+    """Immediately bootstrap the worker at module import time."""
+    global _bootstrap_worker_active
+
+    # Check WORKER_MODE before bootstrapping
+    worker_mode = os.environ.get("WORKER_MODE", "auto").lower()
+    if worker_mode == "disabled":
+        logger.info("[BOOTSTRAP] Worker disabled by WORKER_MODE=disabled")
+        return
+
+    logger.info("[BOOTSTRAP] Starting immediate daemon thread for asyncio polling...")
+
+    # Start daemon thread with its own asyncio event loop
+    bootstrap_thread = threading.Thread(
+        target=_run_asyncio_polling_in_thread,
+        daemon=True,
+        name="bootstrap-asyncio-polling"
+    )
+    bootstrap_thread.start()
+
+    _bootstrap_worker_active = True
+    logger.info(f"[BOOTSTRAP] SUCCESS: Daemon thread started: {bootstrap_thread.name}")
+
+    # 3. Hard-Write State: Immediately set worker_active in status file
+    data_dir = Path(os.environ.get("OPENCLAW_DATA_DIR", "/data"))
+    data_dir.mkdir(parents=True, exist_ok=True)
+    status_file = data_dir / "cain_status.json"
+
+    try:
+        # Update or create status file with worker_active=True
+        if status_file.exists():
+            with open(status_file, "r") as f:
+                data = json.load(f)
+        else:
+            data = {}
+
+        data["worker_active"] = True
+        data["_worker_bootstrap_pid"] = os.getpid()
+        data["_worker_bootstrap_time"] = datetime.utcnow().isoformat() + "+00:00"
+        data["_worker_bootstrap_mode"] = "import_time_daemon"
+
+        with open(status_file, "w") as f:
+            json.dump(data, f, indent=2)
+
+        logger.info(f"[BOOTSTRAP] Hard-wrote worker_active=True to {status_file}")
+    except Exception as e:
+        logger.warning(f"[BOOTSTRAP] Failed to hard-write status: {e}")
+
+
+# ========== EXECUTE IMMEDIATE BOOTSTRAP ==========
+# This runs IMMEDIATELY when app.py is imported, before FastAPI even starts
+_bootstrap_immediate_worker()
+logger.info("[BOOTSTRAP] Import-time bootstrap complete")
+# ========== END IMMEDIATE BOOTSTRAP ==========
+
 
 def _run_worker_thread():
     """
@@ -134,39 +222,47 @@ async def _poll_a2a_ready_state():
 
 @app.on_event("startup")
 async def startup_event():
-    """Start background worker thread and A2A polling task on app startup."""
-    global _worker_thread, _worker_stop_event, _polling_task
+    """
+    FAILSAFE STARTUP: Backup worker initialization.
+
+    The worker should already be running from import-time bootstrap.
+    This event is a redundant failsafe in case the bootstrap failed.
+    """
+    global _worker_thread, _worker_stop_event, _polling_task, _bootstrap_worker_active
 
-    # 1. Verbose startup logging - prove handler ran
     logger.info("=" * 60)
-    logger.info("[STARTUP] ========== STARTUP EVENT HANDLER TRIGGERED ==========")
+    logger.info("[STARTUP] ========== FAILSAFE STARTUP EVENT ==========")
     logger.info(f"[STARTUP] Timestamp: {datetime.utcnow().isoformat()}")
     logger.info(f"[STARTUP] PID: {os.getpid()}")
+    logger.info(f"[STARTUP] Bootstrap worker active? {_bootstrap_worker_active}")
     logger.info("=" * 60)
 
-    # Check WORKER_MODE before starting worker
-    worker_mode = os.environ.get("WORKER_MODE", "auto").lower()
-    if worker_mode == "disabled":
-        logger.info("[Cain] Worker disabled by WORKER_MODE=disabled")
+    # 2. Failsafe Wrapper: Try to start worker if bootstrap didn't
+    if _bootstrap_worker_active:
+        logger.info("[STARTUP] Bootstrap already started worker - this event is redundant")
     else:
-        logger.info("[Cain] Starting persistent background worker thread...")
-        _worker_stop_event = threading.Event()
-        _worker_thread = threading.Thread(target=_run_worker_thread, daemon=True)
-        _worker_thread.start()
-        logger.info(f"[Cain] Worker thread started: {_worker_thread.name}")
-
-    # 2. Wrap task creation in try/except
-    logger.info("[STARTUP] About to create asyncio task for A2A polling...")
-    try:
-        _polling_task = asyncio.create_task(_poll_a2a_ready_state())
-        logger.info(f"[STARTUP] SUCCESS: asyncio.create_task() returned task object: {_polling_task}")
-        logger.info(f"[STARTUP] Task done? {_polling_task.done()}")
-        logger.info(f"[STARTUP] Task cancelled? {_polling_task.cancelled()}")
-    except Exception as e:
-        logger.error(f"[STARTUP] FAILED: asyncio.create_task() raised exception: {e}")
-        import traceback
-        traceback.print_exc()
-        _polling_task = None
+        logger.info("[STARTUP] Bootstrap did NOT start worker - attempting failsafe startup...")
+
+        # Check WORKER_MODE before starting worker
+        worker_mode = os.environ.get("WORKER_MODE", "auto").lower()
+        if worker_mode == "disabled":
+            logger.info("[Cain] Worker disabled by WORKER_MODE=disabled")
+            return
+
+        try:
+            logger.info("[STARTUP] Starting persistent background worker thread...")
+            _worker_stop_event = threading.Event()
+            _worker_thread = threading.Thread(target=_run_worker_thread, daemon=True)
+            _worker_thread.start()
+            logger.info(f"[STARTUP] Worker thread started: {_worker_thread.name}")
+
+            logger.info("[STARTUP] About to create asyncio task for A2A polling...")
+            _polling_task = asyncio.create_task(_poll_a2a_ready_state())
+            logger.info(f"[STARTUP] SUCCESS: asyncio.create_task() returned task object: {_polling_task}")
+        except Exception as e:
+            logger.error(f"[STARTUP] FAILED: Failsafe startup raised exception: {e}")
+            import traceback
+            traceback.print_exc()
 
 
 @app.on_event("shutdown")