Update scripts/sync_hf.py

scripts/sync_hf.py

@@ -1,14 +1,14 @@
 #!/usr/bin/env python3
 """
-OpenClaw HF Spaces Persistence — Full Directory Sync
+OpenClaw HF Spaces Persistence — Full Directory Sync
 =====================================================
 
 Simplified persistence: upload/download the entire ~/.openclaw directory
 as-is to/from a Hugging Face Dataset repo.
 
-- Startup:  snapshot_download  →  ~/.openclaw
-- Periodic: upload_folder      →  dataset openclaw_data/
-- Shutdown: final upload_folder →  dataset openclaw_data/
+- Startup:  snapshot_download  →  ~/.openclaw
+- Periodic: upload_folder      →  dataset openclaw_data/
+- Shutdown: final upload_folder →  dataset openclaw_data/
 """
 
 import os
@@ -40,7 +40,7 @@ _logging.getLogger("filelock").setLevel(_logging.WARNING)
 
 from huggingface_hub import HfApi, snapshot_download
 
-# ── Logging helper ──────────────────────────────────────────────────────────
+# ── Logging helper ──────────────────────────────────────────────────────────
 
 class TeeLogger:
     """Duplicate output to stream and file."""
@@ -57,7 +57,7 @@ class TeeLogger:
     def fileno(self):
         return self.stream.fileno()
 
-# ── Configuration ───────────────────────────────────────────────────────────
+# ── Configuration ───────────────────────────────────────────────────────────
 
 HF_TOKEN   = os.environ.get("HF_TOKEN")
 OPENCLAW_HOME = Path.home() / ".openclaw"
@@ -76,7 +76,7 @@ GATEWAY_TOKEN = os.environ.get("GATEWAY_TOKEN", "huggingclaw")
 AGENT_NAME = os.environ.get("AGENT_NAME", "HuggingClaw")
 A2A_PEERS = os.environ.get("A2A_PEERS", "")  # comma-separated peer URLs
 
-# Default model — only set if user explicitly provides it; otherwise let OpenClaw decide.
+# Default model — only set if user explicitly provides it; otherwise let OpenClaw decide.
 OPENCLAW_DEFAULT_MODEL = os.environ.get("OPENCLAW_DEFAULT_MODEL", "")
 
 # HF Spaces built-in env vars (auto-set by HF runtime)
@@ -91,16 +91,16 @@ AUTO_CREATE_DATASET = os.environ.get("AUTO_CREATE_DATASET", "false").lower() in
 # This ensures each duplicated Space gets its own dataset automatically.
 HF_REPO_ID = os.environ.get("OPENCLAW_DATASET_REPO", "")
 if not HF_REPO_ID and SPACE_ID:
-    # SPACE_ID = "username/SpaceName" → derive "username/SpaceName-data"
+    # SPACE_ID = "username/SpaceName" → derive "username/SpaceName-data"
     HF_REPO_ID = f"{SPACE_ID}-data"
-    print(f"[SYNC] OPENCLAW_DATASET_REPO not set — auto-derived from SPACE_ID: {HF_REPO_ID}")
+    print(f"[SYNC] OPENCLAW_DATASET_REPO not set — auto-derived from SPACE_ID: {HF_REPO_ID}")
 elif not HF_REPO_ID and HF_TOKEN:
     # Fallback: no SPACE_ID (local Docker), derive from HF_TOKEN username
     try:
         _api = HfApi(token=HF_TOKEN)
         _username = _api.whoami()["name"]
         HF_REPO_ID = f"{_username}/HuggingClaw-data"
-        print(f"[SYNC] OPENCLAW_DATASET_REPO not set — auto-derived from HF_TOKEN: {HF_REPO_ID}")
+        print(f"[SYNC] OPENCLAW_DATASET_REPO not set — auto-derived from HF_TOKEN: {HF_REPO_ID}")
         del _api, _username
     except Exception as e:
         print(f"[SYNC] WARNING: Could not derive username from HF_TOKEN: {e}")
@@ -112,7 +112,7 @@ log_dir.mkdir(parents=True, exist_ok=True)
 sys.stdout = TeeLogger(log_dir / "sync.log", sys.stdout)
 sys.stderr = sys.stdout
 
-# ── Telegram API Base Auto-Probe ────────────────────────────────────────────
+# ── Telegram API Base Auto-Probe ────────────────────────────────────────────
 #
 # HF Spaces blocks DNS for api.telegram.org.  grammY uses Node 22's built-in
 # fetch (undici) which bypasses dns.lookup patching and /etc/hosts.
@@ -123,7 +123,7 @@ sys.stderr = sys.stdout
 #   2. telegram-proxy.cjs (loaded via NODE_OPTIONS --require) intercepts
 #      globalThis.fetch() and rewrites api.telegram.org URLs to the mirror.
 #
-# This works without a bot token — we just test HTTP reachability.
+# This works without a bot token — we just test HTTP reachability.
 # If a bot token IS available, we do a full getMe verification.
 
 # User can force a specific base via env var (skip auto-probe)
@@ -140,7 +140,7 @@ def probe_telegram_api(timeout: int = 8) -> str:
     """Probe Telegram API endpoints and return the first reachable one.
 
     First checks if official api.telegram.org is reachable (HTTP level).
-    If not, tries mirrors.  No bot token required — just tests connectivity.
+    If not, tries mirrors.  No bot token required — just tests connectivity.
     Returns the working base URL (without trailing slash), or "" if all fail.
     """
     ctx = ssl.create_default_context()
@@ -149,22 +149,22 @@ def probe_telegram_api(timeout: int = 8) -> str:
         try:
             req = urllib.request.Request(url, method="GET")
             resp = urllib.request.urlopen(req, timeout=timeout, context=ctx)
-            print(f"[TELEGRAM] ✓ Reachable: {base} (HTTP {resp.status})")
+            print(f"[TELEGRAM] ✓ Reachable: {base} (HTTP {resp.status})")
             return base.rstrip("/")
         except urllib.error.HTTPError as e:
             # HTTP error (4xx/5xx) still means the host IS reachable
-            print(f"[TELEGRAM] ✓ Reachable: {base} (HTTP {e.code})")
+            print(f"[TELEGRAM] ✓ Reachable: {base} (HTTP {e.code})")
             return base.rstrip("/")
         except Exception as e:
             reason = str(e)[:80]
-            print(f"[TELEGRAM] ✗ Unreachable: {base} ({reason})")
+            print(f"[TELEGRAM] ✗ Unreachable: {base} ({reason})")
             continue
 
     print("[TELEGRAM] WARNING: All API endpoints unreachable!")
     return ""
 
 
-# ── Sync Manager ────────────────────────────────────────────────────────────
+# ── Sync Manager ────────────────────────────────────────────────────────────
 
 class OpenClawFullSync:
     """Upload/download the entire ~/.openclaw directory to HF Dataset."""
@@ -186,7 +186,7 @@ class OpenClawFullSync:
         self.api = HfApi(token=HF_TOKEN)
         self.dataset_exists = self._ensure_repo_exists()
 
-    # ── Repo management ────────────────────────────────────────────────
+    # ── Repo management ────────────────────────────────────────────────
 
     def _ensure_repo_exists(self):
         """Check if dataset repo exists; auto-create only when AUTO_CREATE_DATASET=true AND HF_TOKEN is set."""
@@ -200,23 +200,23 @@ class OpenClawFullSync:
                 print(f"[SYNC]   Set AUTO_CREATE_DATASET=true to auto-create.")
                 print(f"[SYNC] Persistence disabled (app will still run normally).")
                 return False
-            print(f"[SYNC] Dataset repo NOT found: {HF_REPO_ID} — creating...")
+            print(f"[SYNC] Dataset repo NOT found: {HF_REPO_ID} — creating...")
             try:
                 self.api.create_repo(
                     repo_id=HF_REPO_ID,
                     repo_type="dataset",
                     private=True,
                 )
-                print(f"[SYNC] ✓ Dataset repo created: {HF_REPO_ID}")
+                print(f"[SYNC] ✓ Dataset repo created: {HF_REPO_ID}")
                 return True
             except Exception as e:
-                print(f"[SYNC] ✗ Failed to create dataset repo: {e}")
+                print(f"[SYNC] ✗ Failed to create dataset repo: {e}")
                 return False
 
-    # ── Restore (startup) ─────────────────────────────────────────────
+    # ── Restore (startup) ──────────────â��€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€
 
     def load_from_repo(self):
-        """Download from dataset → ~/.openclaw"""
+        """Download from dataset → ~/.openclaw"""
         if not self.enabled:
             print("[SYNC] Persistence disabled - skipping restore")
             self._ensure_default_config()
@@ -229,7 +229,7 @@ class OpenClawFullSync:
             self._patch_config()
             return
 
-        print(f"[SYNC] ▶ Restoring ~/.openclaw from dataset {HF_REPO_ID} ...")
+        print(f"[SYNC] â–¶ Restoring ~/.openclaw from dataset {HF_REPO_ID} ...")
         OPENCLAW_HOME.mkdir(parents=True, exist_ok=True)
 
         try:
@@ -259,22 +259,22 @@ class OpenClawFullSync:
                             dest = OPENCLAW_HOME / rel
                             dest.parent.mkdir(parents=True, exist_ok=True)
                             shutil.copy2(str(item), str(dest))
-                    print("[SYNC] ✓ Restore completed.")
+                    print("[SYNC] ✓ Restore completed.")
                 else:
                     print("[SYNC] Downloaded snapshot but dir not found. Starting fresh.")
 
         except Exception as e:
-            print(f"[SYNC] ✗ Restore failed: {e}")
+            print(f"[SYNC] ✗ Restore failed: {e}")
             traceback.print_exc()
 
         # Patch config after restore
         self._patch_config()
         self._debug_list_files()
 
-    # ── Save (periodic + shutdown) ─────────────────────────────────────
+    # ── Save (periodic + shutdown) ─────────────────────────────────────
 
     def save_to_repo(self):
-        """Upload entire ~/.openclaw directory → dataset (all files, no filtering)"""
+        """Upload entire ~/.openclaw directory → dataset (all files, no filtering)"""
         if not self.enabled:
             return
         if not OPENCLAW_HOME.exists():
@@ -286,7 +286,7 @@ class OpenClawFullSync:
             print(f"[SYNC] Dataset {HF_REPO_ID} unavailable - skipping save")
             return
 
-        print(f"[SYNC] ▶ Uploading ~/.openclaw → dataset {HF_REPO_ID}/{DATASET_PATH}/ ...")
+        print(f"[SYNC] ▶ Uploading ~/.openclaw → dataset {HF_REPO_ID}/{DATASET_PATH}/ ...")
 
         try:
             # Count files to upload (no per-file logging to reduce noise)
@@ -310,16 +310,16 @@ class OpenClawFullSync:
                 repo_id=HF_REPO_ID,
                 repo_type="dataset",
                 token=HF_TOKEN,
-                commit_message=f"Sync .openclaw — {datetime.now().isoformat()}",
+                commit_message=f"Sync .openclaw — {datetime.now().isoformat()}",
                 ignore_patterns=[
-                    "*.log",        # Log files (sync.log, startup.log) — regenerated on boot
-                    "*.lock",       # Lock files — stale after restart
+                    "*.log",        # Log files (sync.log, startup.log) — regenerated on boot
+                    "*.lock",       # Lock files — stale after restart
                     "*.tmp",        # Temp files
                     "*.pid",        # PID files
                     "__pycache__",  # Python cache
                 ],
             )
-            print(f"[SYNC] ✓ Upload completed at {datetime.now().isoformat()}")
+            print(f"[SYNC] ✓ Upload completed at {datetime.now().isoformat()}")
 
             # Verify (summary only)
             try:
@@ -330,10 +330,10 @@ class OpenClawFullSync:
                 pass
 
         except Exception as e:
-            print(f"[SYNC] ✗ Upload failed: {e}")
+            print(f"[SYNC] ✗ Upload failed: {e}")
             traceback.print_exc()
 
-    # ── Config helpers ─────────────────────────────────────────────────
+    # ── Config helpers ─────────────────────────────────────────────────
 
     def _ensure_default_config(self):
         config_path = OPENCLAW_HOME / "openclaw.json"
@@ -349,7 +349,7 @@ class OpenClawFullSync:
                 # Set gateway token
                 if "gateway" in cfg:
                     cfg["gateway"]["auth"] = {"token": GATEWAY_TOKEN}
-                # Don't manage providers — leave them for OpenClaw to handle.
+                # Don't manage providers — leave them for OpenClaw to handle.
                 # Just remove template entries with unresolved ${...} placeholders
                 # so OpenClaw starts clean and discovers providers from env vars.
                 providers = cfg.get("models", {}).get("providers", {})
@@ -392,7 +392,7 @@ class OpenClawFullSync:
                 data = json.load(f)
             print("[SYNC] Config parsed OK.")
         except (json.JSONDecodeError, Exception) as e:
-            # Config is corrupt — back up and start fresh
+            # Config is corrupt — back up and start fresh
             print(f"[SYNC] Config JSON is corrupt: {e}")
             backup = config_path.with_suffix(f".corrupt_{int(time.time())}")
             try:
@@ -447,7 +447,7 @@ class OpenClawFullSync:
             data.setdefault("agents", {}).setdefault("defaults", {}).setdefault("model", {})
             data.setdefault("session", {})["scope"] = "global"
 
-            # ── Provider API-key resolution ──────────────────────────────────
+            # ── Provider API-key resolution ──────────────────────────────────
             # The persisted config may contain template placeholders such as
             # __OPENROUTER_API_KEY__ or __NVIDIA_API_KEY__. Resolve those from
             # the current HF Space environment instead of treating them as
@@ -469,12 +469,12 @@ class OpenClawFullSync:
                 if pid not in restored_providers:
                     if env_key:
                         restored_providers[pid] = {**provider_defaults[pid], "apiKey": env_key}
-                        print(f"[SYNC] ✓ Recreated {pid} provider from {env_name}")
+                        print(f"[SYNC] ✓ Recreated {pid} provider from {env_name}")
                     continue
                 current_key = str(restored_providers[pid].get("apiKey", "")).strip()
                 if env_key and (not current_key or current_key.startswith("${") or current_key.startswith("__")):
                     restored_providers[pid]["apiKey"] = env_key
-                    print(f"[SYNC] ✓ Resolved {pid} API key from {env_name}")
+                    print(f"[SYNC] ✓ Resolved {pid} API key from {env_name}")
                 elif not env_key and (not current_key or current_key.startswith("${") or current_key.startswith("__")):
                     del restored_providers[pid]
                     print(f"[SYNC] Removed provider '{pid}' (no API key available in {env_name})")
@@ -482,7 +482,7 @@ class OpenClawFullSync:
             if OPENCLAW_DEFAULT_MODEL:
                 data["agents"]["defaults"]["model"]["primary"] = OPENCLAW_DEFAULT_MODEL
 
-            # ── ACP (Agent Client Protocol) — native Claude Code integration ──
+            # ── ACP (Agent Client Protocol) — native Claude Code integration ──
             data["acp"] = {
                 "enabled": True,
                 "backend": "acpx",
@@ -501,7 +501,7 @@ class OpenClawFullSync:
                 plugin_allow.append("a2a-gateway")
             data["plugins"]["allow"] = plugin_allow
 
-            # ── acpx Plugin Configuration (ACP backend) ──
+            # ── acpx Plugin Configuration (ACP backend) ──
             data["plugins"]["entries"]["acpx"] = {
                 "enabled": True,
                 "config": {
@@ -509,7 +509,7 @@ class OpenClawFullSync:
                 }
             }
 
-            # ── Coding Agent Plugin Configuration ──
+            # ── Coding Agent Plugin Configuration ──
             CODING_TARGET_SPACE = os.environ.get("CODING_AGENT_TARGET_SPACE", "")
             CODING_TARGET_DATASET = os.environ.get("CODING_AGENT_TARGET_DATASET", "")
             if CODING_TARGET_SPACE:
@@ -528,7 +528,7 @@ class OpenClawFullSync:
             elif isinstance(data["plugins"]["entries"]["telegram"], dict):
                 data["plugins"]["entries"]["telegram"]["enabled"] = True
 
-            # ── A2A Gateway Plugin Configuration (only if A2A_PEERS is set) ──
+            # ── A2A Gateway Plugin Configuration (only if A2A_PEERS is set) ──
             if A2A_PEERS:
                 peers = []
                 for peer_url in A2A_PEERS.split(","):
@@ -540,7 +540,7 @@ class OpenClawFullSync:
                         "name": name,
                         "agentCardUrl": f"{peer_url}/.well-known/agent-card.json"
                     })
-                    print(f"[SYNC] A2A peer: {name} → {peer_url}")
+                    print(f"[SYNC] A2A peer: {name} → {peer_url}")
 
                 data["plugins"]["entries"]["a2a-gateway"] = {
                     "enabled": True,
@@ -558,23 +558,23 @@ class OpenClawFullSync:
                 }
                 print(f"[SYNC] A2A gateway configured: name={AGENT_NAME}, port=18800, peers={len(peers)}")
 
-            # ── Telegram channel defaults (open DM policy for HF Spaces) ──
-            # Personal bot on HF Spaces — no need for strict pairing.
+            # ── Telegram channel defaults (open DM policy for HF Spaces) ──
+            # Personal bot on HF Spaces — no need for strict pairing.
             tg_ch = data.setdefault("channels", {}).setdefault("telegram", {})
             tg_ch["dmPolicy"] = "open"
             tg_ch["allowFrom"] = ["*"]
             tg_ch["configWrites"] = True
             print("[SYNC] Set channels.telegram: dmPolicy=open, allowFrom=[*], configWrites=true")
 
-            # ── Telegram API base auto-probe ──────────────────────────────
-            # Probe is done in run_openclaw() — sets TELEGRAM_API_ROOT env var
+            # ── Telegram API base auto-probe ──────────────────────────────
+            # Probe is done in run_openclaw() — sets TELEGRAM_API_ROOT env var
             # for the telegram-proxy.cjs preload script to intercept fetch().
 
             with open(config_path, "w") as f:
                 json.dump(data, f, indent=2)
             print("[SYNC] Config patched and saved.")
 
-            # ── Deploy workspace templates (coding agent identity) ──
+            # ── Deploy workspace templates (coding agent identity) ──
             workspace_dir = Path(OPENCLAW_HOME) / "workspace"
             workspace_dir.mkdir(parents=True, exist_ok=True)
             templates_dir = Path("/home/node/workspace-templates")
@@ -618,17 +618,17 @@ class OpenClawFullSync:
         except Exception as e:
             print(f"[SYNC] listing failed: {e}")
 
-    # ── Background sync loop ──────────────────────────────────────────
+    # ── Background sync loop ──────────────────────────────────────────
 
     def background_sync_loop(self, stop_event):
         print(f"[SYNC] Background sync started (interval={SYNC_INTERVAL}s)")
         while not stop_event.is_set():
             if stop_event.wait(timeout=SYNC_INTERVAL):
                 break
-            print(f"[SYNC] ── Periodic sync triggered at {datetime.now().isoformat()} ──")
+            print(f"[SYNC] ── Periodic sync triggered at {datetime.now().isoformat()} ──")
             self.save_to_repo()
 
-    # ── OpenClaw migration / repair ───────────────────────────────────
+    # ── OpenClaw migration / repair ───────────────────────────────────
 
     def run_doctor_fix(self):
         """Run OpenClaw doctor --fix in headless mode before starting the gateway."""
@@ -647,9 +647,26 @@ class OpenClawFullSync:
         print("[SYNC] Doctor output will be streamed below.")
         env = os.environ.copy()
         env["NODE_ENV"] = "production"
+        env["CI"] = "1"
+        env["TERM"] = "dumb"
+
+        # Doctor is a one-shot maintenance command. Do NOT inherit the
+        # gateway-only Node preload used by HuggingClaw (for example the
+        # token-redirect helper). That preload starts background monitoring
+        # for remote agents and can keep Doctor's Node event loop alive.
+        # The gateway receives the normal environment later in run_openclaw().
+        node_options = env.pop("NODE_OPTIONS", "")
+        if node_options:
+            print("[SYNC] Doctor: removed inherited NODE_OPTIONS preload")
+
         timeout = int(os.environ.get("DOCTOR_TIMEOUT", "300"))
         try:
-            process = subprocess.Popen(doctor_cmd, cwd=str(APP_DIR), env=env)
+            process = subprocess.Popen(
+                doctor_cmd,
+                cwd=str(APP_DIR),
+                env=env,
+                stdin=subprocess.DEVNULL,
+            )
             start_time = time.time()
             while True:
                 return_code = process.poll()
@@ -657,12 +674,12 @@ class OpenClawFullSync:
                     elapsed = time.time() - start_time
                     print(f"[SYNC] Doctor finished in {elapsed:.1f}s with exit code {return_code}")
                     if return_code == 0:
-                        print("[SYNC] ✓ OpenClaw doctor --fix completed")
+                        print("[SYNC] ✓ OpenClaw doctor --fix completed")
                         return True
-                    print(f"[SYNC] ✗ openclaw doctor --fix failed with exit code {return_code}")
+                    print(f"[SYNC] ✗ openclaw doctor --fix failed with exit code {return_code}")
                     return False
                 if time.time() - start_time > timeout:
-                    print(f"[SYNC] ✗ Doctor exceeded DOCTOR_TIMEOUT={timeout}s. Stopping it so the Space does not remain stuck.")
+                    print(f"[SYNC] ✗ Doctor exceeded DOCTOR_TIMEOUT={timeout}s. Stopping it so the Space does not remain stuck.")
                     try:
                         process.terminate()
                         process.wait(timeout=10)
@@ -673,11 +690,11 @@ class OpenClawFullSync:
                     return False
                 time.sleep(0.5)
         except Exception as e:
-            print(f"[SYNC] ✗ Failed to run doctor --fix: {e}")
+            print(f"[SYNC] ✗ Failed to run doctor --fix: {e}")
             traceback.print_exc()
             return False
 
-    # ── Application runner ─────────────────────────────────────────────
+    # ── Application runner ─────────────────────────────────────────────
 
     def run_openclaw(self):
         log_file = OPENCLAW_HOME / "workspace" / "startup.log"
@@ -715,7 +732,7 @@ class OpenClawFullSync:
         # Pass entire environment to OpenClaw (all API keys are already in os.environ)
         env = os.environ.copy()
 
-        # ── Telegram API base probe ──────────────────────────────────────
+        # ── Telegram API base probe ──────────────────────────────────────
         # Determine working Telegram API endpoint and set env var for
         # telegram-proxy.cjs to intercept fetch() calls.
         if TELEGRAM_API_BASE:
@@ -730,12 +747,12 @@ class OpenClawFullSync:
             print(f"[TELEGRAM] Set TELEGRAM_API_ROOT={tg_root}")
             print(f"[TELEGRAM] telegram-proxy.cjs will redirect fetch() calls")
         elif tg_root:
-            print("[TELEGRAM] Official API reachable — no proxy needed")
+            print("[TELEGRAM] Official API reachable — no proxy needed")
         else:
-            print("[TELEGRAM] No reachable endpoint found — Telegram will not work")
+            print("[TELEGRAM] No reachable endpoint found — Telegram will not work")
         try:
             # Use Popen without shell to avoid pipe issues
-            # auth disabled in config — no token needed
+            # auth disabled in config — no token needed
             process = subprocess.Popen(
                 entry_cmd,
                 cwd=str(APP_DIR),
@@ -759,7 +776,7 @@ class OpenClawFullSync:
                             continue
                         # Skip progress bars and download noise
                         if any(skip in stripped for skip in [
-                            'Downloading', 'Fetching', '%|', '━', '───',
+                            'Downloading', 'Fetching', '%|', '━', '───',
                             'Already cached', 'Using cache', 'tokenizer',
                             '.safetensors', 'model-', 'shard',
                         ]):
@@ -782,7 +799,7 @@ class OpenClawFullSync:
             traceback.print_exc()
             return None
 
-# ── Main ────────────────────────────────────────────────────────────────────
+# ── Main ──────────────────────────────────────â���€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€â”€
 
 def main():
     try:
@@ -825,7 +842,7 @@ def main():
         t0 = time.time()
         process = sync.run_openclaw()
         print(f"[TIMER] run_openclaw launch: {time.time() - t0:.1f}s")
-        print(f"[TIMER] Total startup (init → app launched): {time.time() - t_main_start:.1f}s")
+        print(f"[TIMER] Total startup (init → app launched): {time.time() - t_main_start:.1f}s")
 
         # 4. Start conversation-loop (RUN_ORCHESTRATOR=1, runs on God Space)
         #    OFFICE_MODE=1 is for frontend serving only (Home Space)
@@ -866,7 +883,7 @@ def main():
             conv_thread = threading.Thread(target=run_conversation_loop_forever, daemon=True)
             conv_thread.start()
         else:
-            print("[SYNC] RUN_ORCHESTRATOR not set — skipping conversation-loop")
+            print("[SYNC] RUN_ORCHESTRATOR not set — skipping conversation-loop")
 
         # Signal handler
         def handle_signal(sig, frame):
@@ -916,4 +933,4 @@ def main():
 
 
 if __name__ == "__main__":
-    main()
+    main()