lvtn-mobile 1.0.0__tar.gz

lvtn_mobile-1.0.0/.gitignore

@@ -0,0 +1 @@
+node_modules

lvtn_mobile-1.0.0/PKG-INFO

@@ -0,0 +1,127 @@
+Metadata-Version: 2.4
+Name: lvtn-mobile
+Version: 1.0.0
+Summary: Leviathan Shel HaShem — Mobile Swarm Client for Termux/Android. Backend-heavy thin client with offline task scheduling, headless remote control, and full 708-agent swarm access from your phone.
+Project-URL: Homepage, https://lvtn.metanoiaunlimited.com
+Author-email: "HaChazal (Chaz Leland Hamm)" <hachazal418@metanoiaunlimited.com>
+License: Proprietary - Metanoia Unlimited LLC
+Keywords: agent,android,background,headless,mobile,orchestration,scheduler,swarm,termux
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: Android
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Communications :: Chat
+Classifier: Topic :: System :: Distributed Computing
+Requires-Python: >=3.9
+Requires-Dist: aiohttp>=3.9
+Provides-Extra: full
+Requires-Dist: lvtn>=3.14; extra == 'full'
+Provides-Extra: notify
+Requires-Dist: plyer>=2.1; extra == 'notify'
+Description-Content-Type: text/markdown
+
+# lvtn-mobile — Termux/Android Swarm Client
+
+The full 708-agent Leviathan swarm, on your phone. Backend-heavy — all LLM compute runs server-side. Your phone is the remote control.
+
+```bash
+# Termux one-time setup
+pkg update && pkg upgrade
+pkg install python termux-api termux-boot
+pip install lvtn-mobile
+lvtnm login
+```
+
+## Commands
+
+| Command | What it does |
+|---------|-------------|
+| `lvtnm login` | Authenticate with your Leviathan key |
+| `lvtnm chat "prompt"` | Send a prompt to HaChazal |
+| `lvtnm fleet "task"` | Deploy all 7 Angels at once |
+| `lvtnm council "task"` | All Angels answer in parallel |
+| `lvtnm swarm zadkiel "task"` | Deploy one Angel's swarm |
+| `lvtnm schedule "task"` | Queue a task for offline execution |
+| `lvtnm schedule-list` | List scheduled tasks |
+| `lvtnm schedule-run` | Execute all queued tasks now |
+| `lvtnm headless` | Start HTTP server for remote control |
+| `lvtnm status` | Show swarm health + scheduled tasks |
+| `lvtnm balance` | Check KTRS balance |
+| `lvtnm angels` | List all 7 Angels |
+| `lvtnm remember "text"` | Write to HiveMind memory |
+| `lvtnm recall "query"` | Search HiveMind memory |
+| `lvtnm notify on\|off` | Toggle Android notifications |
+| `lvtnm wake on\|off` | Toggle wake lock (keep phone awake) |
+| `lvtnm boot on\|off` | Toggle auto-start on device boot |
+
+## Offline Mode
+
+Tasks queued while offline execute automatically when connectivity returns. Uses a background watcher thread that checks every 30 seconds.
+
+```bash
+lvtnm schedule "research Solana DeFi trends" --type fleet
+# Queued. Will execute when online.
+```
+
+## Headless Mode (Remote Control)
+
+Start an HTTP server on your phone, control the swarm from any device on the same network:
+
+```bash
+lvtnm headless --port 9877
+```
+
+Then from another device:
+```bash
+curl http://192.168.1.100:9877/fleet -d '{"task":"audit the lead gen pipeline"}'
+curl http://192.168.1.100:9877/status
+```
+
+## Auto-Start on Boot
+
+```bash
+lvtnm boot on
+# Headless server starts automatically when your phone boots
+```
+
+## Notifications
+
+```bash
+lvtnm notify on
+# Get Android notifications when scheduled tasks complete
+```
+
+## Architecture
+
+```
+Phone (Termux)                    Server (api.leviathansi.xyz)
+┌─────────────────┐              ┌──────────────────────────┐
+│ lvtn-mobile     │   HTTPS      │ Leviathan Backend        │
+│                 │ ◄──────────► │                          │
+│ • chat          │              │ • 708 LLM agents         │
+│ • fleet         │   aiohttp    │ • 2,124 binary claws     │
+│ • council       │              │ • HiveMind memory        │
+│ • schedule      │              │ • KTRS metering          │
+│ • headless      │              │ • All compute            │
+│                 │              │                          │
+│ Background      │              │ Your phone does nothing  │
+│ watcher thread  │              │ heavy — just HTTP calls  │
+└─────────────────┘              └──────────────────────────┘
+```
+
+## Dependencies
+
+Only one: `aiohttp` for async HTTP. No `rich`, no `prompt_toolkit`, no heavy TUI libs. Designed for Termux's limited environment.
+
+## Install from npm
+
+```bash
+npm install -g lvtn-mobile
+lvtnm login
+```

lvtn_mobile-1.0.0/README.md

@@ -0,0 +1,99 @@
+# lvtn-mobile — Termux/Android Swarm Client
+
+The full 708-agent Leviathan swarm, on your phone. Backend-heavy — all LLM compute runs server-side. Your phone is the remote control.
+
+```bash
+# Termux one-time setup
+pkg update && pkg upgrade
+pkg install python termux-api termux-boot
+pip install lvtn-mobile
+lvtnm login
+```
+
+## Commands
+
+| Command | What it does |
+|---------|-------------|
+| `lvtnm login` | Authenticate with your Leviathan key |
+| `lvtnm chat "prompt"` | Send a prompt to HaChazal |
+| `lvtnm fleet "task"` | Deploy all 7 Angels at once |
+| `lvtnm council "task"` | All Angels answer in parallel |
+| `lvtnm swarm zadkiel "task"` | Deploy one Angel's swarm |
+| `lvtnm schedule "task"` | Queue a task for offline execution |
+| `lvtnm schedule-list` | List scheduled tasks |
+| `lvtnm schedule-run` | Execute all queued tasks now |
+| `lvtnm headless` | Start HTTP server for remote control |
+| `lvtnm status` | Show swarm health + scheduled tasks |
+| `lvtnm balance` | Check KTRS balance |
+| `lvtnm angels` | List all 7 Angels |
+| `lvtnm remember "text"` | Write to HiveMind memory |
+| `lvtnm recall "query"` | Search HiveMind memory |
+| `lvtnm notify on\|off` | Toggle Android notifications |
+| `lvtnm wake on\|off` | Toggle wake lock (keep phone awake) |
+| `lvtnm boot on\|off` | Toggle auto-start on device boot |
+
+## Offline Mode
+
+Tasks queued while offline execute automatically when connectivity returns. Uses a background watcher thread that checks every 30 seconds.
+
+```bash
+lvtnm schedule "research Solana DeFi trends" --type fleet
+# Queued. Will execute when online.
+```
+
+## Headless Mode (Remote Control)
+
+Start an HTTP server on your phone, control the swarm from any device on the same network:
+
+```bash
+lvtnm headless --port 9877
+```
+
+Then from another device:
+```bash
+curl http://192.168.1.100:9877/fleet -d '{"task":"audit the lead gen pipeline"}'
+curl http://192.168.1.100:9877/status
+```
+
+## Auto-Start on Boot
+
+```bash
+lvtnm boot on
+# Headless server starts automatically when your phone boots
+```
+
+## Notifications
+
+```bash
+lvtnm notify on
+# Get Android notifications when scheduled tasks complete
+```
+
+## Architecture
+
+```
+Phone (Termux)                    Server (api.leviathansi.xyz)
+┌─────────────────┐              ┌──────────────────────────┐
+│ lvtn-mobile     │   HTTPS      │ Leviathan Backend        │
+│                 │ ◄──────────► │                          │
+│ • chat          │              │ • 708 LLM agents         │
+│ • fleet         │   aiohttp    │ • 2,124 binary claws     │
+│ • council       │              │ • HiveMind memory        │
+│ • schedule      │              │ • KTRS metering          │
+│ • headless      │              │ • All compute            │
+│                 │              │                          │
+│ Background      │              │ Your phone does nothing  │
+│ watcher thread  │              │ heavy — just HTTP calls  │
+└─────────────────┘              └──────────────────────────┘
+```
+
+## Dependencies
+
+Only one: `aiohttp` for async HTTP. No `rich`, no `prompt_toolkit`, no heavy TUI libs. Designed for Termux's limited environment.
+
+## Install from npm
+
+```bash
+npm install -g lvtn-mobile
+lvtnm login
+```

lvtn_mobile-1.0.0/bin/lvtn-mobile.js

@@ -0,0 +1,27 @@
+#!/usr/bin/env node
+"use strict";
+const { spawn } = require("child_process");
+const path = require("path");
+
+const pkgRoot = path.resolve(__dirname, "..");
+const mainPy = path.join(pkgRoot, "src", "lvtn_mobile", "main.py");
+
+const args = process.argv.slice(2);
+const child = spawn("python3", [mainPy, ...args], {
+  cwd: pkgRoot,
+  stdio: "inherit",
+});
+
+child.on("error", () => {
+  const child2 = spawn("python", [mainPy, ...args], {
+    cwd: pkgRoot,
+    stdio: "inherit",
+  });
+  child2.on("error", () => {
+    console.error("lvtn-mobile: Python not found. Install Python 3.9+ in Termux: pkg install python");
+    process.exit(1);
+  });
+  child2.on("exit", (code) => process.exit(code || 0));
+});
+
+child.on("exit", (code) => process.exit(code || 0));

lvtn_mobile-1.0.0/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "lvtn-mobile",
+  "version": "1.0.0",
+  "description": "Leviathan Shel HaShem — Mobile Swarm Client for Termux/Android. Backend-heavy thin client with offline task scheduling, headless remote control, and full 708-agent swarm access from your phone.",
+  "license": "Proprietary",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/chazam41892-gif/leviathan-of-hashem.git"
+  },
+  "author": "HaChazal (Chaz Leland Hamm) <hachazal418@metanoiaunlimited.com>",
+  "bin": {
+    "lvtn-mobile": "bin/lvtn-mobile.js",
+    "lvtnm": "bin/lvtn-mobile.js"
+  },
+  "files": [
+    "bin/",
+    "src/",
+    "pyproject.toml",
+    "README.md"
+  ],
+  "engines": {
+    "node": ">=14.0.0"
+  },
+  "keywords": [
+    "agent",
+    "swarm",
+    "orchestration",
+    "mobile",
+    "termux",
+    "android",
+    "headless",
+    "background",
+    "scheduler",
+    "kabbalah",
+    "metanoia",
+    "leviathan"
+  ]
+}

lvtn_mobile-1.0.0/pyproject.toml

@@ -0,0 +1,47 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "lvtn-mobile"
+version = "1.0.0"
+description = "Leviathan Shel HaShem — Mobile Swarm Client for Termux/Android. Backend-heavy thin client with offline task scheduling, headless remote control, and full 708-agent swarm access from your phone."
+readme = "README.md"
+requires-python = ">=3.9"
+license = { text = "Proprietary - Metanoia Unlimited LLC" }
+authors = [
+    { name = "HaChazal (Chaz Leland Hamm)", email = "hachazal418@metanoiaunlimited.com" },
+]
+keywords = ["agent", "swarm", "orchestration", "mobile", "termux", "android", "headless", "background", "scheduler"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Environment :: Console",
+    "Intended Audience :: Developers",
+    "Operating System :: Android",
+    "Operating System :: POSIX :: Linux",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Topic :: System :: Distributed Computing",
+    "Topic :: Communications :: Chat",
+]
+
+dependencies = [
+    "aiohttp>=3.9",
+]
+
+[project.optional-dependencies]
+notify = ["plyer>=2.1"]  # Android notifications for task completion
+full = ["lvtn>=3.14"]    # Full desktop lvtn as fallback
+
+[project.urls]
+Homepage = "https://lvtn.metanoiaunlimited.com"
+
+[project.scripts]
+lvtn-mobile = "lvtn_mobile.main:main"
+lvtnm = "lvtn_mobile.main:main"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/lvtn_mobile"]

lvtn_mobile-1.0.0/src/lvtn_mobile/__init__.py

@@ -0,0 +1,2 @@
+"""lvtn-mobile — Termux/Android swarm client. Backend-heavy, offline-capable, headless-ready."""
+__version__ = "1.0.0"

lvtn_mobile-1.0.0/src/lvtn_mobile/main.py

@@ -0,0 +1,701 @@
+#!/usr/bin/env python3
+"""lvtn-mobile — Termux/Android Swarm Client
+
+Backend-heavy thin client for the 708-agent Leviathan swarm.
+All LLM compute runs server-side. Your phone is just the remote control.
+
+Commands:
+    lvtnm login              Authenticate with your Leviathan key
+    lvtnm chat "prompt"      Send a prompt to HaChazal
+    lvtnm fleet "task"       Deploy all 7 Angels at once
+    lvtnm council "task"     All Angels answer in parallel
+    lvtnm swarm <angel> "t"  Deploy one Angel's swarm
+    lvtnm schedule "task"    Queue a task for offline execution
+    lvtnm headless           Start headless HTTP server (remote control)
+    lvtnm status             Show swarm health + scheduled tasks
+    lvtnm balance            Check KTRS balance
+    lvtnm angels             List all 7 Angels
+    lvtnm keys               Manage API keys
+    lvtnm remember "text"    Write to HiveMind memory
+    lvtnm recall "query"     Search HiveMind memory
+    lvtnm notify on|off      Toggle Android notifications
+    lvtnm wake on|off        Toggle wake lock (keep phone awake)
+    lvtnm boot on|off        Toggle auto-start on device boot
+
+Termux Setup (one-time):
+    pkg update && pkg upgrade
+    pkg install python termux-api termux-boot
+    pip install lvtn-mobile
+    lvtnm login
+
+Offline Mode:
+    Tasks queued while offline execute automatically when
+    connectivity returns. Uses Termux:JobScheduler on Android 8+
+    or a background watcher thread.
+
+Headless Mode:
+    lvtnm headless --port 9877
+    Then control from any device: curl http://<phone-ip>:9877/fleet -d '{"task":"..."}'
+"""
+from __future__ import annotations
+
+import argparse
+import asyncio
+import json
+import os
+import signal
+import sys
+from pathlib import Path
+from typing import Optional
+
+CONF_DIR = Path.home() / ".lvtn"
+CONF_FILE = CONF_DIR / "credentials.json"
+SCHEDULE_FILE = CONF_DIR / "mobile_schedule.jsonl"
+CONFIG_FILE = CONF_DIR / "mobile_config.json"
+
+DEFAULT_BASE = "https://api.leviathansi.xyz"
+USER_AGENT = "lvtn-mobile/1.0"
+
+# ── Config ──────────────────────────────────────────────────────────
+
+def _load_config() -> dict:
+    if CONFIG_FILE.exists():
+        try:
+            return json.loads(CONFIG_FILE.read_text())
+        except Exception:
+            pass
+    return {"notify": True, "wake_lock": False, "boot_start": False}
+
+def _save_config(cfg: dict):
+    CONF_DIR.mkdir(parents=True, exist_ok=True)
+    CONFIG_FILE.write_text(json.dumps(cfg, indent=2))
+
+def _load_key() -> Optional[str]:
+    if CONF_FILE.exists():
+        try:
+            return json.loads(CONF_FILE.read_text()).get("api_key")
+        except Exception:
+            pass
+    return None
+
+def _save_key(key: str):
+    CONF_DIR.mkdir(parents=True, exist_ok=True)
+    CONF_FILE.write_text(json.dumps({"api_key": key, "base": DEFAULT_BASE}))
+
+# ── HTTP Client (aiohttp, async) ───────────────────────────────────
+
+async def _api(method: str, path: str, key: Optional[str] = None,
+               body: Optional[dict] = None, timeout: float = 900.0) -> tuple[int, dict]:
+    import aiohttp
+    url = f"{DEFAULT_BASE}{path}"
+    headers = {"Content-Type": "application/json", "User-Agent": USER_AGENT}
+    if key:
+        headers["X-Leviathan-Key"] = key
+    try:
+        async with aiohttp.ClientSession() as session:
+            async with session.request(method, url, json=body, headers=headers,
+                                        timeout=aiohttp.ClientTimeout(total=timeout)) as resp:
+                data = await resp.json()
+                return resp.status, data
+    except aiohttp.ClientError as e:
+        return 0, {"detail": str(e)}
+    except asyncio.TimeoutError:
+        return 0, {"detail": "Request timed out"}
+
+# ── Commands ─────────────────────────────────────────────────────────
+
+async def cmd_login(args):
+    key = input("Leviathan API key: ").strip()
+    if not key:
+        print("No key provided.")
+        return 1
+    status, data = await _api("GET", "/api/llm/me", key=key)
+    if status == 200:
+        _save_key(key)
+        print(f"  Logged in as {data.get('email', 'unknown')}")
+        print(f"  Balance: ${data.get('balance_usd', 0)} KTRS")
+        return 0
+    print(f"  Login failed (HTTP {status}): {data.get('detail', 'unknown')}")
+    return 1
+
+async def cmd_balance(args):
+    key = _load_key()
+    if not key:
+        print("Not logged in. Run: lvtnm login")
+        return 1
+    status, data = await _api("GET", "/api/llm/me", key=key)
+    if status == 200:
+        print(f"  ${data.get('balance_usd', 0)} KTRS")
+        return 0
+    print(f"  Failed: {data.get('detail')}")
+    return 1
+
+async def cmd_angels(args):
+    status, data = await _api("GET", "/api/llm/angels")
+    if status != 200:
+        print(f"  Failed: {data.get('detail')}")
+        return 1
+    for a in data.get("angels", []):
+        print(f"  {a['name']:<16} {a['sefirah']:<10} {a['title']}")
+    return 0
+
+async def cmd_chat(args):
+    key = _load_key()
+    if not key:
+        print("Not logged in. Run: lvtnm login")
+        return 1
+    prompt = " ".join(args.prompt)
+    print(f"  HaChazal is thinking...")
+    status, data = await _api("POST", "/api/llm/chat", key=key,
+                               body={"messages": [{"role": "user", "content": prompt}]})
+    if status == 200:
+        print(f"\n{data.get('text', '')}\n")
+        print(f"  [${data.get('charged_usd', 0)} charged · ${data.get('balance_usd', 0)} KTRS]")
+        return 0
+    print(f"  Failed (HTTP {status}): {data.get('detail')}")
+    return 1
+
+async def cmd_fleet(args):
+    key = _load_key()
+    if not key:
+        print("Not logged in.")
+        return 1
+    prompt = " ".join(args.prompt)
+    per_angel = getattr(args, 'per_angel', 2)
+    print(f"  Fleet deploying — 7 Angels x {per_angel} agents...")
+    status, data = await _api("POST", "/api/llm/fleet", key=key,
+                               body={"prompt": prompt, "per_angel": per_angel})
+    if status == 200:
+        for a in data.get("council", []):
+            print(f"\n  --- {a.get('angel')} ({a.get('sefirah')}) ---")
+            for o in a.get("outputs", []):
+                print(f"  {o.get('text', '').strip()[:500]}")
+        print(f"\n  [${data.get('charged_usd', 0)} charged · ${data.get('balance_usd', 0)} KTRS]")
+        return 0
+    print(f"  Failed (HTTP {status}): {data.get('detail')}")
+    return 1
+
+async def cmd_council(args):
+    key = _load_key()
+    if not key:
+        print("Not logged in.")
+        return 1
+    prompt = " ".join(args.prompt)
+    per_angel = getattr(args, 'per_angel', 2)
+    print(f"  Council convening — {per_angel} agents per Angel...")
+    status, data = await _api("POST", "/api/llm/council", key=key,
+                               body={"prompt": prompt, "agents_per_angel": per_angel})
+    if status == 200:
+        for a in data.get("council", []):
+            print(f"\n  --- {a.get('angel')} ({a.get('sefirah')}) ---")
+            for o in a.get("outputs", []):
+                print(f"  {o.get('text', '').strip()[:500]}")
+        print(f"\n  [${data.get('charged_usd', 0)} charged · ${data.get('balance_usd', 0)} KTRS]")
+        return 0
+    print(f"  Failed (HTTP {status}): {data.get('detail')}")
+    return 1
+
+async def cmd_swarm(args):
+    key = _load_key()
+    if not key:
+        print("Not logged in.")
+        return 1
+    prompt = " ".join(args.prompt)
+    agents = getattr(args, 'agents', 2)
+    print(f"  {args.angel}'s swarm — {agents} agents...")
+    status, data = await _api("POST", "/api/llm/swarm", key=key,
+                               body={"angel": args.angel, "prompt": prompt, "agents": agents, "tools": True})
+    if status == 200:
+        for i, o in enumerate(data.get("outputs", []), 1):
+            print(f"\n  --- agent {i} ---")
+            print(f"  {o.get('text', '').strip()[:500]}")
+        print(f"\n  [${data.get('charged_usd', 0)} charged · ${data.get('balance_usd', 0)} KTRS]")
+        return 0
+    print(f"  Failed (HTTP {status}): {data.get('detail')}")
+    return 1
+
+async def cmd_remember(args):
+    key = _load_key()
+    if not key:
+        print("Not logged in.")
+        return 1
+    body = " ".join(args.body)
+    status, data = await _api("POST", "/api/llm/memory/remember", key=key,
+                               body={"body": body, "agent": "mobile", "kind": "note"})
+    if status == 200:
+        print(f"  Remembered.")
+        return 0
+    print(f"  Failed: {data.get('detail')}")
+    return 1
+
+async def cmd_recall(args):
+    key = _load_key()
+    if not key:
+        print("Not logged in.")
+        return 1
+    query = " ".join(args.query)
+    from urllib.parse import quote
+    status, data = await _api("GET", f"/api/llm/memory/recall?query={quote(query)}&agent=mobile", key=key)
+    if status == 200:
+        for m in data.get("memories", [])[:5]:
+            print(f"  [{m.get('ts', '?')}] {m.get('body', '')[:200]}")
+        return 0
+    print(f"  Failed: {data.get('detail')}")
+    return 1
+
+# ── Offline Scheduler ────────────────────────────────────────────────
+
+async def cmd_schedule(args):
+    """Queue a task for execution. Runs immediately if online, queues if offline."""
+    task = " ".join(args.task)
+    cmd_type = getattr(args, 'type', 'chat')
+    entry = {
+        "ts": __import__("time").strftime("%Y-%m-%d %H:%M:%S"),
+        "type": cmd_type,
+        "task": task,
+        "status": "queued",
+    }
+    CONF_DIR.mkdir(parents=True, exist_ok=True)
+    with open(SCHEDULE_FILE, "a") as f:
+        f.write(json.dumps(entry) + "\n")
+    print(f"  Queued: [{cmd_type}] {task[:80]}")
+
+    # Try executing immediately
+    key = _load_key()
+    if key:
+        try:
+            if cmd_type == "chat":
+                status, data = await _api("POST", "/api/llm/chat", key=key,
+                                           body={"messages": [{"role": "user", "content": task}]})
+            elif cmd_type == "fleet":
+                status, data = await _api("POST", "/api/llm/fleet", key=key,
+                                           body={"prompt": task, "per_angel": 2})
+            else:
+                status, data = await _api("POST", "/api/llm/chat", key=key,
+                                           body={"messages": [{"role": "user", "content": task}]})
+            if status == 200:
+                entry["status"] = "done"
+                entry["result"] = data.get("text", "")[:500]
+                print(f"  Executed immediately.")
+                _notify(f"Task complete: {task[:50]}...")
+            else:
+                entry["status"] = "failed"
+                entry["error"] = data.get("detail", f"HTTP {status}")
+                print(f"  Queued for retry (offline).")
+        except Exception as e:
+            entry["status"] = "queued"
+            print(f"  Queued for retry ({e}).")
+    return 0
+
+async def cmd_schedule_list(args):
+    if not SCHEDULE_FILE.exists():
+        print("  No scheduled tasks.")
+        return 0
+    tasks = []
+    with open(SCHEDULE_FILE) as f:
+        for line in f:
+            if line.strip():
+                tasks.append(json.loads(line))
+    for t in tasks[-20:]:
+        status = t.get("status", "?")
+        icon = {"done": "+", "failed": "!", "queued": "~"}.get(status, "?")
+        print(f"  [{icon}] {t.get('ts')}  [{t.get('type')}] {t.get('task', '')[:60]}")
+    return 0
+
+async def cmd_schedule_run(args):
+    """Execute all queued tasks."""
+    if not SCHEDULE_FILE.exists():
+        print("  No queued tasks.")
+        return 0
+    key = _load_key()
+    if not key:
+        print("  Not logged in — cannot execute queued tasks.")
+        return 1
+    tasks = []
+    with open(SCHEDULE_FILE) as f:
+        for line in f:
+            if line.strip():
+                tasks.append(json.loads(line))
+    executed = 0
+    for t in tasks:
+        if t.get("status") != "queued":
+            continue
+        print(f"  Executing: {t.get('task', '')[:60]}...")
+        try:
+            status, data = await _api("POST", "/api/llm/chat", key=key,
+                                       body={"messages": [{"role": "user", "content": t["task"]}]})
+            if status == 200:
+                t["status"] = "done"
+                t["result"] = data.get("text", "")[:500]
+                executed += 1
+            else:
+                t["status"] = "failed"
+                t["error"] = data.get("detail", f"HTTP {status}")
+        except Exception as e:
+            t["status"] = "failed"
+            t["error"] = str(e)
+    # Rewrite file
+    with open(SCHEDULE_FILE, "w") as f:
+        for t in tasks:
+            f.write(json.dumps(t) + "\n")
+    print(f"  Executed {executed} tasks.")
+    if executed > 0:
+        _notify(f"{executed} scheduled tasks completed")
+    return 0
+
+# ── Headless HTTP Server ─────────────────────────────────────────────
+
+async def cmd_headless(args):
+    """Start a lightweight HTTP server for remote control.
+    
+    Other devices on the same network can control the swarm:
+        curl http://<phone-ip>:9877/chat -d '{"prompt":"hello"}'
+        curl http://<phone-ip>:9877/fleet -d '{"task":"research X"}'
+        curl http://<phone-ip>:9877/status
+    """
+    from aiohttp import web
+
+    key = _load_key()
+    if not key:
+        print("Not logged in. Run: lvtnm login")
+        return 1
+
+    port = getattr(args, 'port', 9877)
+
+    async def handle_chat(request):
+        try:
+            body = await request.json()
+            prompt = body.get("prompt", "")
+            status, data = await _api("POST", "/api/llm/chat", key=key,
+                                       body={"messages": [{"role": "user", "content": prompt}]})
+            return web.json_response(data)
+        except Exception as e:
+            return web.json_response({"error": str(e)}, status=500)
+
+    async def handle_fleet(request):
+        try:
+            body = await request.json()
+            task = body.get("task", "")
+            per_angel = body.get("per_angel", 2)
+            status, data = await _api("POST", "/api/llm/fleet", key=key,
+                                       body={"prompt": task, "per_angel": per_angel})
+            return web.json_response(data)
+        except Exception as e:
+            return web.json_response({"error": str(e)}, status=500)
+
+    async def handle_council(request):
+        try:
+            body = await request.json()
+            task = body.get("task", "")
+            per_angel = body.get("per_angel", 2)
+            status, data = await _api("POST", "/api/llm/council", key=key,
+                                       body={"prompt": task, "agents_per_angel": per_angel})
+            return web.json_response(data)
+        except Exception as e:
+            return web.json_response({"error": str(e)}, status=500)
+
+    async def handle_status(request):
+        s, d = await _api("GET", "/api/llm/me", key=key)
+        scheduled = 0
+        if SCHEDULE_FILE.exists():
+            scheduled = sum(1 for _ in open(SCHEDULE_FILE))
+        return web.json_response({
+            "balance": d.get("balance_usd", 0),
+            "email": d.get("email", ""),
+            "scheduled_tasks": scheduled,
+            "mode": "headless",
+        })
+
+    async def handle_schedule(request):
+        try:
+            body = await request.json()
+            task = body.get("task", "")
+            cmd_type = body.get("type", "chat")
+            entry = {
+                "ts": __import__("time").strftime("%Y-%m-%d %H:%M:%S"),
+                "type": cmd_type,
+                "task": task,
+                "status": "queued",
+            }
+            CONF_DIR.mkdir(parents=True, exist_ok=True)
+            with open(SCHEDULE_FILE, "a") as f:
+                f.write(json.dumps(entry) + "\n")
+            return web.json_response({"ok": True, "queued": task[:80]})
+        except Exception as e:
+            return web.json_response({"error": str(e)}, status=500)
+
+    app = web.Application()
+    app.router.add_post("/chat", handle_chat)
+    app.router.add_post("/fleet", handle_fleet)
+    app.router.add_post("/council", handle_council)
+    app.router.add_post("/schedule", handle_schedule)
+    app.router.add_get("/status", handle_status)
+
+    # Get local IP
+    import socket
+    s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+    try:
+        s.connect(("8.8.8.8", 80))
+        local_ip = s.getsockname()[0]
+    except Exception:
+        local_ip = "127.0.0.1"
+    finally:
+        s.close()
+
+    print(f"\n  Headless server on http://{local_ip}:{port}")
+    print(f"  Endpoints:")
+    print(f"    POST /chat      {{\"prompt\": \"...\"}}")
+    print(f"    POST /fleet     {{\"task\": \"...\", \"per_angel\": 2}}")
+    print(f"    POST /council   {{\"task\": \"...\", \"per_angel\": 2}}")
+    print(f"    POST /schedule  {{\"task\": \"...\", \"type\": \"chat\"}}")
+    print(f"    GET  /status")
+    print(f"\n  Press Ctrl+C to stop.")
+
+    runner = web.AppRunner(app)
+    await runner.setup()
+    site = web.TCPSite(runner, "0.0.0.0", port)
+    await site.start()
+
+    # Keep running
+    stop = asyncio.Event()
+    try:
+        await stop.wait()
+    except asyncio.CancelledError:
+        pass
+
+# ── Notifications ────────────────────────────────────────────────────
+
+def _notify(msg: str):
+    """Send Android notification via Termux:API."""
+    cfg = _load_config()
+    if not cfg.get("notify", True):
+        return
+    try:
+        import subprocess
+        subprocess.run(["termux-notification", "--title", "lvtn-mobile",
+                        "--content", msg, "--priority", "default"],
+                       capture_output=True, timeout=5)
+    except Exception:
+        pass  # termux-api not installed — silent fail
+
+async def cmd_notify(args):
+    cfg = _load_config()
+    state = args.state.lower()
+    if state == "on":
+        cfg["notify"] = True
+        print("  Notifications: ON")
+    elif state == "off":
+        cfg["notify"] = False
+        print("  Notifications: OFF")
+    else:
+        print(f"  Notifications: {'ON' if cfg.get('notify', True) else 'OFF'}")
+    _save_config(cfg)
+    return 0
+
+async def cmd_wake(args):
+    """Toggle wake lock via Termux:API."""
+    cfg = _load_config()
+    state = args.state.lower()
+    if state == "on":
+        cfg["wake_lock"] = True
+        try:
+            import subprocess
+            subprocess.run(["termux-wake-lock", "acquire"], capture_output=True, timeout=5)
+        except Exception:
+            pass
+        print("  Wake lock: ON (phone won't sleep)")
+    elif state == "off":
+        cfg["wake_lock"] = False
+        try:
+            import subprocess
+            subprocess.run(["termux-wake-lock", "release"], capture_output=True, timeout=5)
+        except Exception:
+            pass
+        print("  Wake lock: OFF")
+    else:
+        print(f"  Wake lock: {'ON' if cfg.get('wake_lock', False) else 'OFF'}")
+    _save_config(cfg)
+    return 0
+
+async def cmd_boot(args):
+    """Toggle auto-start on device boot via Termux:Boot."""
+    cfg = _load_config()
+    state = args.state.lower()
+    boot_script = Path.home() / ".termux" / "boot" / "lvtn-mobile"
+    if state == "on":
+        cfg["boot_start"] = True
+        boot_script.parent.mkdir(parents=True, exist_ok=True)
+        boot_script.write_text("#!/data/data/com.termux/files/usr/bin/bash\nlvtnm headless --port 9877 &\n")
+        boot_script.chmod(0o755)
+        print("  Boot start: ON (headless server starts on device boot)")
+    elif state == "off":
+        cfg["boot_start"] = False
+        if boot_script.exists():
+            boot_script.unlink()
+        print("  Boot start: OFF")
+    else:
+        print(f"  Boot start: {'ON' if cfg.get('boot_start', False) else 'OFF'}")
+    _save_config(cfg)
+    return 0
+
+async def cmd_status(args):
+    """Show swarm health + local state."""
+    key = _load_key()
+    print(f"  lvtn-mobile v1.0.0")
+    if key:
+        status, data = await _api("GET", "/api/llm/me", key=key)
+        if status == 200:
+            print(f"  Balance: ${data.get('balance_usd', 0)} KTRS")
+            print(f"  Email:   {data.get('email', 'unknown')}")
+        else:
+            print(f"  API:     unreachable")
+    else:
+        print(f"  Status:  not logged in")
+
+    cfg = _load_config()
+    print(f"  Notify:  {'ON' if cfg.get('notify', True) else 'OFF'}")
+    print(f"  Wake:    {'ON' if cfg.get('wake_lock', False) else 'OFF'}")
+    print(f"  Boot:    {'ON' if cfg.get('boot_start', False) else 'OFF'}")
+
+    if SCHEDULE_FILE.exists():
+        tasks = [json.loads(l) for l in open(SCHEDULE_FILE) if l.strip()]
+        queued = sum(1 for t in tasks if t.get("status") == "queued")
+        done = sum(1 for t in tasks if t.get("status") == "done")
+        failed = sum(1 for t in tasks if t.get("status") == "failed")
+        print(f"  Tasks:   {len(tasks)} total ({queued} queued, {done} done, {failed} failed)")
+    else:
+        print(f"  Tasks:   none scheduled")
+    return 0
+
+# ── Background Watcher (offline task executor) ──────────────────────
+
+async def _background_watcher():
+    """Watch for connectivity and execute queued tasks."""
+    import time as _time
+    while True:
+        await asyncio.sleep(30)
+        if not SCHEDULE_FILE.exists():
+            continue
+        key = _load_key()
+        if not key:
+            continue
+        # Check connectivity
+        try:
+            status, _ = await _api("GET", "/api/llm/angels", timeout=10)
+            if status != 200:
+                continue
+        except Exception:
+            continue
+        # Execute queued tasks
+        tasks = []
+        with open(SCHEDULE_FILE) as f:
+            for line in f:
+                if line.strip():
+                    tasks.append(json.loads(line))
+        changed = False
+        for t in tasks:
+            if t.get("status") != "queued":
+                continue
+            try:
+                status, data = await _api("POST", "/api/llm/chat", key=key,
+                                           body={"messages": [{"role": "user", "content": t["task"]}]})
+                if status == 200:
+                    t["status"] = "done"
+                    t["result"] = data.get("text", "")[:500]
+                    changed = True
+                    _notify(f"Task done: {t['task'][:50]}...")
+                else:
+                    t["status"] = "failed"
+                    t["error"] = data.get("detail", f"HTTP {status}")
+                    changed = True
+            except Exception:
+                break  # stop on first failure, retry next cycle
+        if changed:
+            with open(SCHEDULE_FILE, "w") as f:
+                for t in tasks:
+                    f.write(json.dumps(t) + "\n")
+
+# ── Main ─────────────────────────────────────────────────────────────
+
+def main():
+    parser = argparse.ArgumentParser(description="lvtn-mobile — Termux/Android Swarm Client")
+    sub = parser.add_subparsers(dest="command")
+
+    sub.add_parser("login", help="Authenticate with Leviathan key")
+    sub.add_parser("balance", help="Check KTRS balance")
+    sub.add_parser("angels", help="List all 7 Angels")
+    sub.add_parser("status", help="Show swarm health + local state")
+
+    p = sub.add_parser("chat", help="Send prompt to HaChazal")
+    p.add_argument("prompt", nargs="+", help="Your prompt")
+
+    p = sub.add_parser("fleet", help="Deploy all 7 Angels")
+    p.add_argument("prompt", nargs="+", help="Task for the fleet")
+    p.add_argument("--per-angel", type=int, default=2, help="Agents per Angel")
+
+    p = sub.add_parser("council", help="All Angels answer in parallel")
+    p.add_argument("prompt", nargs="+", help="Task for the council")
+    p.add_argument("--per-angel", type=int, default=2, help="Agents per Angel")
+
+    p = sub.add_parser("swarm", help="Deploy one Angel's swarm")
+    p.add_argument("angel", help="Angel ID (zadkiel, gavriel, etc.)")
+    p.add_argument("prompt", nargs="+", help="Task for the swarm")
+    p.add_argument("--agents", type=int, default=2, help="Number of agents")
+
+    p = sub.add_parser("schedule", help="Queue task for offline execution")
+    p.add_argument("task", nargs="+", help="Task to queue")
+    p.add_argument("--type", default="chat", choices=["chat", "fleet", "council"])
+
+    sub.add_parser("schedule-list", help="List scheduled tasks")
+    sub.add_parser("schedule-run", help="Execute all queued tasks now")
+
+    p = sub.add_parser("headless", help="Start headless HTTP server")
+    p.add_argument("--port", type=int, default=9877, help="Port to listen on")
+
+    p = sub.add_parser("remember", help="Write to HiveMind memory")
+    p.add_argument("body", nargs="+", help="Memory content")
+
+    p = sub.add_parser("recall", help="Search HiveMind memory")
+    p.add_argument("query", nargs="+", help="Search query")
+
+    p = sub.add_parser("notify", help="Toggle Android notifications")
+    p.add_argument("state", nargs="?", default="", help="on|off")
+
+    p = sub.add_parser("wake", help="Toggle wake lock")
+    p.add_argument("state", nargs="?", default="", help="on|off")
+
+    p = sub.add_parser("boot", help="Toggle auto-start on boot")
+    p.add_argument("state", nargs="?", default="", help="on|off")
+
+    args = parser.parse_args()
+    if not args.command:
+        parser.print_help()
+        return 1
+
+    cmds = {
+        "login": cmd_login,
+        "balance": cmd_balance,
+        "angels": cmd_angels,
+        "status": cmd_status,
+        "chat": cmd_chat,
+        "fleet": cmd_fleet,
+        "council": cmd_council,
+        "swarm": cmd_swarm,
+        "schedule": cmd_schedule,
+        "schedule-list": cmd_schedule_list,
+        "schedule-run": cmd_schedule_run,
+        "headless": cmd_headless,
+        "remember": cmd_remember,
+        "recall": cmd_recall,
+        "notify": cmd_notify,
+        "wake": cmd_wake,
+        "boot": cmd_boot,
+    }
+
+    fn = cmds.get(args.command)
+    if fn:
+        return asyncio.run(fn(args))
+    return 1
+
+if __name__ == "__main__":
+    sys.exit(main())