Refactor project structure and enhance functionality

- Update .gitignore to exclude model files and sensitive data.
- Modify Dockerfile to remove .env from the image for security.
- Revise README.md to clarify project purpose and deployment instructions.
- Implement main.py as the orchestrator for service management with detailed status endpoints.
- Create shared_state.py for managing shared variables between components.
- Refactor telegram_agent.py to improve message handling and initialization of components.

.gitignore

@@ -3,5 +3,7 @@
 .venv/
 __pycache__/
 *.pyc
+models/
+*.gguf
 .qwen
 

Dockerfile

@@ -20,6 +20,7 @@ RUN uv sync --frozen --no-dev
 
 # Copy application files
 COPY --chown=user . .
+RUN rm -f .env  # never include .env in Docker image (use HF Space secrets)
 
 # Run main.py
 CMD ["uv", "run", "main.py"]

README.md

@@ -7,10 +7,71 @@ sdk: docker
 pinned: false
 ---
 
-# Mann - Terminal Loading Animation
+# Mann — Jira Sprint Manager
 
-Infinite loading animation using tqdm, visible in Hugging Face Spaces logs.
+AI-powered Jira sprint management via Telegram. Uses a local LLM (Phi-4-mini) with MCP tools to interact with Jira.
 
-## Deployment
+## Architecture
 
-This space uses Docker. The loading animation runs continuously and can be viewed in the Space logs.
+```
+main.py (FastAPI orchestrator, port 7860)
+  ├── server.py       → Jira REST API (subprocess, port 8001)
+  ├── jira_mcp_server.py → MCP tool server (stdio)
+  └── telegram_agent.py  → Telegram bot + LLM (background thread)
+        ├── Phi-4-mini (llama-cpp) — loaded from HF cache
+        ├── sentence-transformers — local embeddings
+        └── Pinecone — conversation memory
+```
+
+## Endpoints
+
+| Method | Path | Description |
+|--------|------|-------------|
+| `POST` | `/start` | Trigger service startup |
+| `GET` | `/status` | Overall health of all services |
+| `GET` | `/status/server` | Jira REST API status |
+| `GET` | `/status/mcp` | MCP server + tool list |
+| `GET` | `/status/telegram` | Telegram bot + LLM status |
+| `*` | `/jira/*` | Proxy to Jira REST API |
+
+## Environment Variables
+
+Set these in HF Spaces → Settings → Repository secrets:
+
+| Variable | Description |
+|----------|-------------|
+| `JIRA_BASE_URL` | Your Jira instance URL (e.g. `https://your-domain.atlassian.net`) |
+| `JIRA_EMAIL` | Jira account email |
+| `JIRA_API_TOKEN` | Jira API token |
+| `JIRA_PROJECT_KEY` | Project key (default: `SCRUM`) |
+| `JIRA_BOARD_ID` | Board ID (default: `1`) |
+| `TELEGRAM_TOKEN` | Telegram bot token from @BotFather |
+| `PINECONE_API_KEY` | Pinecone API key for conversation memory |
+| `PINECONE_INDEX` | Pinecone index name (default: `jira-agent-memory`) |
+
+## Local Development
+
+```bash
+# Install dependencies
+uv sync
+
+# Set environment variables
+cp .env.example .env  # edit with your credentials
+
+# Run the unified orchestrator
+uv run main.py
+
+# Or run Telegram agent standalone (requires server.py already running)
+uv run telegram_agent.py
+```
+
+## HF Spaces Deployment
+
+1. Push code to this repo
+2. Set all environment variables in Space settings
+3. Space auto-starts via `Dockerfile` → `main.py`
+4. Check `/status` endpoint to verify all services are live
+
+## Model
+
+Phi-4-mini (Q4_K_M, ~2.2GB) is downloaded from HuggingFace to `~/.cache/huggingface` — this does **not** count against the 1GB app storage limit on HF Spaces.

main.py

@@ -1,40 +1,305 @@
+"""
+Unified Jira Sprint Manager — Orchestrator
+============================================
+Single entry point for HF Spaces. Starts all services and exposes status endpoints.
+
+Endpoints:
+  POST /start              — Start all services (server, MCP, Telegram bot)
+  GET  /status             — Overall health of all services
+  GET  /status/server      — Check if server.py (Jira REST API) is live
+  GET  /status/mcp         — Check if MCP server is live
+  GET  /status/telegram    — Check if Telegram bot + LLM are live
+
+  Plus all server.py routes mounted under /jira/*
+"""
+
+import os
+import sys
 import time
+import json
+import asyncio
 import threading
-import os
-from tqdm import tqdm
-from fastapi import FastAPI
+import subprocess
+import requests
+from contextlib import asynccontextmanager
+
+from fastapi import FastAPI, HTTPException
+from pydantic import BaseModel
 import uvicorn
 
-app = FastAPI()
+# ── Service state ─────────────────────────────────────────────────────────────
+class ServiceState:
+    def __init__(self):
+        self.server_started = False
+        self.server_process = None
+        self.telegram_started = False
+        self.all_started = False
+        self.error = None
+
+state = ServiceState()
+
+# ── Refs for status checking (set by telegram_agent) ─────────────────────────
+mcp_session_ref = None
+openai_tools_ref = None
+telegram_bot_ref = None
+llm_ref = None
+
+# ── Config ────────────────────────────────────────────────────────────────────
+SERVER_PORT = int(os.environ.get("SERVER_PORT", "8001"))
+MAIN_PORT = int(os.environ.get("PORT", "7860"))
+BASE_DIR = os.path.dirname(os.path.abspath(__file__))
+
+
+# ── Start server.py as subprocess ─────────────────────────────────────────────
+def start_jira_server():
+    """Launch server.py (FastAPI Jira REST API) as a background subprocess."""
+    server_script = os.path.join(BASE_DIR, "server.py")
+    if not os.path.exists(server_script):
+        state.error = f"server.py not found at {server_script}"
+        return False
+
+    print(f"\n[orchestrator] Starting Jira REST API server on port {SERVER_PORT}...")
+    env = {**os.environ, "PORT": str(SERVER_PORT)}
+    proc = subprocess.Popen(
+        [sys.executable, server_script],
+        env=env,
+        stdout=subprocess.PIPE,
+        stderr=subprocess.STDOUT,
+        text=True,
+    )
+    state.server_process = proc
+
+    # Wait for server to be ready
+    for attempt in range(30):
+        time.sleep(1)
+        poll = proc.poll()
+        if poll is not None:
+            state.error = f"server.py exited early (code={poll})"
+            if proc.stdout:
+                print(proc.stdout.read())
+            return False
+        try:
+            r = requests.get(f"http://localhost:{SERVER_PORT}/", timeout=2)
+            if r.status_code == 200:
+                state.server_started = True
+                print(f"[orchestrator] Jira REST API server is live on port {SERVER_PORT}")
+                return True
+        except requests.RequestException:
+            continue
+
+    state.error = "server.py failed to start within 30 seconds"
+    return False
+
 
-def loading_animation():
-    """Infinite loading animation running in background."""
+# ── Start Telegram + MCP in background thread ─────────────────────────────────
+def start_telegram_and_mcp():
+    """Run the Telegram agent + MCP server in a dedicated event loop."""
+    import shared_state
+    from telegram_agent import (
+        start_telegram_with_mcp, _init_telegram_bot, _init_llm,
+        _init_embedder, _init_pinecone, bot, llm,
+    )
+
+    # Initialize components to detect LLM
     try:
-        for i in tqdm(range(1000000), desc="Loading NINININININININ", unit="%", bar_format="{l_bar}{bar}| {n_fmt}/{total_fmt}"):
-            time.sleep(0.01)
-    except KeyboardInterrupt:
-        print("\nLoading interrupted!")
+        _init_embedder()
+        _init_llm()
+        _init_pinecone()
+        _init_telegram_bot()
+    except Exception as e:
+        state.error = f"Failed to init components: {str(e)}"
+        print(f"[orchestrator] ERROR: {state.error}")
+        return
 
-@app.get("/health")
-def health():
-    return {"status": "ok", "message": "Server is running"}
+    # Set refs
+    shared_state.llm_instance = llm
+    shared_state.telegram_bot = bot
 
+    # Run the MCP + Telegram loop
+    try:
+        asyncio.run(start_telegram_with_mcp())
+    except Exception as e:
+        state.error = f"Telegram/MCP failed: {str(e)}"
+        print(f"[orchestrator] ERROR: {state.error}")
 
-@app.get("/healthz")
-def healthz():
-    return {"status": "ok"}
 
+# ── Lifespan for async startup ───────────────────────────────────────────────
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    """Start all services on app startup."""
+    print("\n" + "=" * 60)
+    print("  Jira Sprint Manager — Unified Orchestrator")
+    print("=" * 60)
 
+    # 1. Start server.py
+    if not start_jira_server():
+        print(f"[orchestrator] ERROR: Failed to start server.py: {state.error}")
+    else:
+        # 2. Start Telegram + MCP in background thread
+        print("[orchestrator] Starting Telegram bot + MCP server...")
+        tg_thread = threading.Thread(target=start_telegram_and_mcp, daemon=True)
+        tg_thread.start()
+        state.telegram_started = True
+        state.all_started = True
 
-def main():
-    port = int(os.environ.get("PORT", "7860"))
+    yield
+
+    # Shutdown
+    print("\n[orchestrator] Shutting down...")
+    if state.server_process:
+        state.server_process.terminate()
+        state.server_process.wait(timeout=5)
+
+
+# ── FastAPI App ───────────────────────────────────────────────────────────────
+app = FastAPI(
+    title="Jira Sprint Manager",
+    description="Unified orchestrator for Jira Sprint Management (REST API + MCP + Telegram Bot)",
+    version="2.0.0",
+    lifespan=lifespan,
+)
+
+
+# ── Status Endpoints ─────────────────────────────────────────────────────────
+
+@app.get("/status/server")
+def status_server():
+    """Check if the Jira REST API server (server.py) is live."""
+    if not state.server_started:
+        return {"service": "jira_rest_api", "status": "down", "port": SERVER_PORT,
+                "error": state.error or "Not started yet"}
+    try:
+        r = requests.get(f"http://localhost:{SERVER_PORT}/", timeout=3)
+        return {"service": "jira_rest_api", "status": "live" if r.status_code == 200 else "degraded",
+                "port": SERVER_PORT, "response": r.json() if r.status_code == 200 else None}
+    except requests.RequestException as e:
+        return {"service": "jira_rest_api", "status": "unreachable", "port": SERVER_PORT, "error": str(e)}
+
+
+@app.get("/status/mcp")
+def status_mcp():
+    """Check if the MCP server is live and how many tools are available."""
+    import shared_state
+    tools = shared_state.openai_tools
+    session = shared_state.mcp_session
+
+    if session is None or tools is None:
+        return {"service": "mcp_server", "status": "down", "tools_count": 0,
+                "tools": [], "error": "MCP server not initialized"}
+    return {"service": "mcp_server", "status": "live", "tools_count": len(tools),
+            "tools": [t["function"]["name"] for t in tools]}
 
-    # Start loading animation in background thread
-    loading_thread = threading.Thread(target=loading_animation, daemon=True)
-    loading_thread.start()
 
-    # Start FastAPI server
+@app.get("/status/telegram")
+def status_telegram():
+    """Check if the Telegram bot is running and LLM is loaded."""
+    import shared_state
+    b = shared_state.telegram_bot
+    l = shared_state.llm_instance
+
+    bot_status = "live" if b is not None else "down"
+    llm_status = "loaded" if l is not None else "not_loaded"
+
+    model_path = os.environ.get("MODEL_PATH", os.path.join(BASE_DIR, "models", "microsoft_Phi-4-mini-instruct-Q4_K_M.gguf"))
+    model_exists = os.path.exists(model_path)
+
+    return {"service": "telegram_bot", "bot_status": bot_status, "llm_status": llm_status,
+            "model_path": model_path, "model_downloaded": model_exists}
+
+
+@app.get("/status")
+def status_all():
+    """Overall health check of all services."""
+    server = status_server()
+    mcp = status_mcp()
+    telegram = status_telegram()
+
+    all_up = (server.get("status") == "live" and mcp.get("status") == "live" and
+              telegram.get("bot_status") == "live" and telegram.get("llm_status") == "loaded")
+
+    return {
+        "overall_status": "healthy" if all_up else "partial" if state.all_started else "starting",
+        "services": {"jira_rest_api": server, "mcp_server": mcp, "telegram_bot": telegram},
+    }
+
+
+class StartRequest(BaseModel):
+    download_model: bool = True
+
+
+@app.post("/start")
+def start_services(req: StartRequest = None):
+    """
+    Manually trigger service startup (useful if lifespan didn't auto-start).
+    Returns immediately — services run in background.
+    """
+    if state.all_started:
+        return {"status": "already_started", "message": "All services are already running"}
+
+    # Start server.py
+    if not state.server_started:
+        if not start_jira_server():
+            raise HTTPException(status_code=500, detail=f"Failed to start server.py: {state.error}")
+
+    # Start Telegram + MCP
+    if not state.telegram_started:
+        tg_thread = threading.Thread(target=start_telegram_and_mcp, daemon=True)
+        tg_thread.start()
+        state.telegram_started = True
+        state.all_started = True
+
+    return {"status": "starting", "message": "Services starting. Poll /status to check progress."}
+
+
+# ── Proxy: Mount server.py routes under /jira/* ──────────────────────────────
+from fastapi import Request as FastAPIRequest
+from fastapi.responses import JSONResponse
+
+
+@app.api_route("/jira/{path:path}", methods=["GET", "POST", "PUT", "DELETE", "PATCH"])
+async def proxy_jira(path: str, request: FastAPIRequest):
+    """Proxy requests to the Jira REST API server."""
+    if not state.server_started:
+        raise HTTPException(status_code=503, detail="Jira REST API server not started")
+
+    body = await request.body() if request.method in ("POST", "PUT", "PATCH") else None
+
+    try:
+        r = requests.request(
+            method=request.method, url=f"http://localhost:{SERVER_PORT}/{path}",
+            headers={k: v for k, v in request.headers.items() if k.lower() != "host"},
+            params=dict(request.query_params), data=body, timeout=30,
+        )
+        return JSONResponse(content=r.json(), status_code=r.status_code)
+    except requests.RequestException as e:
+        raise HTTPException(status_code=502, detail=f"Failed to reach Jira server: {str(e)}")
+
+
+# ── Root ──────────────────────────────────────────────────────────────────────
+@app.get("/")
+def root():
+    return {
+        "service": "Jira Sprint Manager",
+        "version": "2.0.0",
+        "status": "healthy" if state.all_started else "starting",
+        "endpoints": {
+            "POST /start": "Start all services",
+            "GET /status": "Overall health check",
+            "GET /status/server": "Jira REST API status",
+            "GET /status/mcp": "MCP server status",
+            "GET /status/telegram": "Telegram bot + LLM status",
+            "GET/POST /jira/*": "Proxy to Jira REST API",
+        },
+    }
+
+
+# ── Main ──────────────────────────────────────────────────────────────────────
+def main():
+    port = int(os.environ.get("PORT", "7860"))
+    print(f"\n[orchestrator] Starting unified FastAPI server on port {port}")
+    print(f"[orchestrator] Jira REST API will run on port {SERVER_PORT}\n")
     uvicorn.run(app, host="0.0.0.0", port=port)
 
+
 if __name__ == "__main__":
     main()

shared_state.py

@@ -0,0 +1,8 @@
+"""
+Shared state between main.py and telegram_agent.py
+"""
+
+mcp_session = None
+openai_tools = None
+telegram_bot = None
+llm_instance = None

telegram_agent.py

@@ -8,19 +8,22 @@ Stack:
   Pinecone                      → stores every turn + tool call + tool result
   Telegram (pyTelegramBotAPI)   → chat interface
 
-Run order:
-  Terminal 1:  python jira_mcp_server.py      (keep running)
-  Terminal 2:  python telegram_agent.py       (Telegram bot)
+Can be run standalone:
+  python telegram_agent.py
+
+Or imported by main.py orchestrator:
+  from telegram_agent import start_telegram_with_mcp
+  asyncio.run(start_telegram_with_mcp())
 """
 
 import os
 import sys
 import json
 import uuid
-import time
 import asyncio
 import datetime
 import threading
+from typing import Optional
 from llama_cpp import Llama
 from sentence_transformers import SentenceTransformer
 from pinecone import Pinecone, ServerlessSpec
@@ -35,106 +38,96 @@ load_dotenv()
 TELEGRAM_TOKEN = os.environ.get("TELEGRAM_TOKEN")
 PINECONE_API_KEY = os.environ.get("PINECONE_API_KEY")
 PINECONE_INDEX   = os.environ.get("PINECONE_INDEX", "jira-agent-memory")
-
 MCP_SERVER_SCRIPT = os.path.join(os.path.dirname(__file__), "jira_mcp_server.py")
-
 EMBED_DIM = 768
-
 MODEL_PATH = os.path.join(os.path.dirname(__file__), "models", "microsoft_Phi-4-mini-instruct-Q4_K_M.gguf")
 
-if not TELEGRAM_TOKEN:
-    raise ValueError("Missing required environment variable: TELEGRAM_TOKEN")
-if not PINECONE_API_KEY:
-    raise ValueError("Missing required environment variable: PINECONE_API_KEY")
+# ── Globals (lazy-initialized) ────────────────────────────────────────────────
+bot: Optional[telebot.TeleBot] = None
+llm: Optional[Llama] = None
+pine_index = None
+_embedder = None
+user_sessions = {}
+loop_ref = None
+mcp_session_ref = None
+openai_tools_ref = None
+
 
-# ── Telegram bot ─────────────────────────────────────────────────────────────
-bot = telebot.TeleBot(TELEGRAM_TOKEN, parse_mode=None)
+# ── Lazy initializers ────────────────────────────────────────────────────────
+def _init_telegram_bot():
+    global bot
+    if bot is not None:
+        return bot
+    if not TELEGRAM_TOKEN:
+        raise ValueError("Missing TELEGRAM_TOKEN")
+    bot = telebot.TeleBot(TELEGRAM_TOKEN, parse_mode=None)
+    return bot
 
-# Per-user conversation state: {chat_id: {"session": ClientSession, "openai_tools": [...], "messages": [...]}}
-user_sessions = {}
-loop_ref = None  # will hold the asyncio event loop
 
-# ── local embedder ────────────────────────────────────────────────────────────
-print("  Loading embedding model...")
-_embedder = SentenceTransformer("BAAI/bge-base-en-v1.5", device="cpu")
-print("  Embedding model ready.\n")
+def _init_embedder():
+    global _embedder
+    if _embedder is not None:
+        return _embedder
+    print("  Loading embedding model...")
+    _embedder = SentenceTransformer("BAAI/bge-base-en-v1.5", device="cpu")
+    print("  Embedding model ready.\n")
+    return _embedder
+
 
 def embed(text: str) -> list[float]:
     vec = _embedder.encode(text[:8000], normalize_embeddings=True)
     return vec.tolist()
 
-# ── local model loader ───────────────────────────────────────────────────────
-if not os.path.exists(MODEL_PATH):
-    print(f"  Model not found at {MODEL_PATH}")
-    print("  Downloading from HuggingFace (bartowski/Phi-4-mini-instruct-GGUF)...\n")
-    print("  This is ~2.2 GB — may take a few minutes depending on your connection.\n")
-    models_dir = os.path.dirname(MODEL_PATH)
-    os.makedirs(models_dir, exist_ok=True)
+
+def _init_llm() -> Llama:
+    global llm
+    if llm is not None:
+        return llm
+
+    # Download to HF cache (does NOT count against HF Spaces 1GB app storage)
+    # The cache lives at ~/.cache/huggingface which is on a separate volume
     from huggingface_hub import hf_hub_download
-    downloaded_path = hf_hub_download(
+    print("  Resolving model from HuggingFace cache...\n")
+    cached_path = hf_hub_download(
         repo_id="bartowski/Phi-4-mini-instruct-GGUF",
         filename="Phi-4-mini-instruct-Q4_K_M.gguf",
-        local_dir=models_dir,
-        local_dir_use_symlinks=False,
-    )
-    # Move to expected path if needed
-    if downloaded_path != MODEL_PATH and not os.path.exists(MODEL_PATH):
-        import shutil
-        shutil.move(downloaded_path, MODEL_PATH)
-    print("\n  Download complete.\n")
-
-print("  Loading local model...")
-print(f"  Model: {MODEL_PATH}")
-print("  This may take 10-30 seconds on first run...\n")
-
-llm = Llama(
-    model_path=MODEL_PATH,
-    n_ctx=8192,
-    n_threads=4,
-    n_batch=512,
-    n_gpu_layers=0,
-    verbose=False,
-    temperature=0.2,
-)
-print("  Model loaded successfully.\n")
-
-# ── pinecone ──────────────────────────────────────────────────────────────────
-pc = Pinecone(api_key=PINECONE_API_KEY)
-existing = [i.name for i in pc.list_indexes()]
-if PINECONE_INDEX not in existing:
-    print(f"  Creating Pinecone index '{PINECONE_INDEX}' (dim={EMBED_DIM})...")
-    pc.create_index(
-        name=PINECONE_INDEX,
-        dimension=EMBED_DIM,
-        metric="cosine",
-        spec=ServerlessSpec(cloud="aws", region="us-east-1"),
     )
-    print("  Index created.\n")
-
-pine_index = pc.Index(PINECONE_INDEX)
+    print(f"  Model cached at: {cached_path}")
+    print(f"  Loading model...\n")
 
-
-def store(user_input: str, agent_reply: str, tool_name: str,
-          tool_args: dict, tool_result: dict):
-    doc = (
-        f"User: {user_input}\n"
-        f"Agent: {agent_reply}\n"
-        f"Tool called: {tool_name}\n"
-        f"Tool args: {json.dumps(tool_args)}\n"
-        f"Tool result: {json.dumps(tool_result)}"
+    llm = Llama(
+        model_path=cached_path, n_ctx=8192, n_threads=4, n_batch=512,
+        n_gpu_layers=0, verbose=False, temperature=0.2,
     )
+    print("  Model loaded.\n")
+    return llm
+
+
+def _init_pinecone():
+    global pine_index
+    if pine_index is not None:
+        return pine_index
+    if not PINECONE_API_KEY:
+        raise ValueError("Missing PINECONE_API_KEY")
+    pc = Pinecone(api_key=PINECONE_API_KEY)
+    existing = [i.name for i in pc.list_indexes()]
+    if PINECONE_INDEX not in existing:
+        print(f"  Creating Pinecone index '{PINECONE_INDEX}'...")
+        pc.create_index(name=PINECONE_INDEX, dimension=EMBED_DIM, metric="cosine",
+                        spec=ServerlessSpec(cloud="aws", region="us-east-1"))
+        print("  Index created.\n")
+    pine_index = pc.Index(PINECONE_INDEX)
+    return pine_index
+
+
+def store(user_input, agent_reply, tool_name, tool_args, tool_result):
+    doc = f"User: {user_input}\nAgent: {agent_reply}\nTool: {tool_name}\nArgs: {json.dumps(tool_args)}\nResult: {json.dumps(tool_result)}"
     pine_index.upsert(vectors=[{
-        "id": str(uuid.uuid4()),
-        "values": embed(doc),
-        "metadata": {
-            "doc": doc,
-            "user_input": user_input,
-            "agent_reply": agent_reply,
-            "tool_name": tool_name,
-            "tool_args": json.dumps(tool_args),
-            "tool_result": json.dumps(tool_result),
-            "timestamp": datetime.datetime.utcnow().isoformat(),
-        },
+        "id": str(uuid.uuid4()), "values": embed(doc),
+        "metadata": {"doc": doc, "user_input": user_input, "agent_reply": agent_reply,
+                      "tool_name": tool_name, "tool_args": json.dumps(tool_args),
+                      "tool_result": json.dumps(tool_result),
+                      "timestamp": datetime.datetime.utcnow().isoformat()},
     }])
 
 
@@ -143,213 +136,116 @@ def recall(user_input: str, top_k: int = 2) -> str:
     total = stats.get("total_vector_count", 0)
     if total == 0:
         return ""
-    results = pine_index.query(
-        vector=embed(user_input),
-        top_k=min(top_k, total),
-        include_metadata=True,
-    )
-    matches = results.get("matches", [])
-    if not matches:
-        return ""
-    chunks = [
-        f"[past interaction]\n{m['metadata'].get('user_input', '')} → {m['metadata'].get('tool_name', 'no tool')}"
-        for m in matches if m.get('score', 0) > 0.5
-    ]
-    if not chunks:
-        return ""
-    return "\nRECENT SIMILAR REQUESTS (for context only, do NOT reuse old data):\n" + "\n---\n".join(chunks) + "\n"
+    results = pine_index.query(vector=embed(user_input), top_k=min(top_k, total), include_metadata=True)
+    chunks = [f"[past]\n{m['metadata'].get('user_input','')} → {m['metadata'].get('tool_name','')}"
+              for m in results.get("matches", []) if m.get('score', 0) > 0.5]
+    return "\nRECENT SIMILAR (context only):\n" + "\n---\n".join(chunks) + "\n" if chunks else ""
 
 
-def mcp_tools_to_openai_schema(mcp_tools) -> list[dict]:
-    tools = []
-    for t in mcp_tools:
-        tools.append({
-            "type": "function",
-            "function": {
-                "name": t.name,
-                "description": t.description or "",
-                "parameters": t.inputSchema or {"type": "object", "properties": {}},
-            },
-        })
-    return tools
+def mcp_tools_to_openai_schema(mcp_tools):
+    return [{"type": "function", "function": {"name": t.name, "description": t.description or "",
+             "parameters": t.inputSchema or {"type": "object", "properties": {}}}} for t in mcp_tools]
 
 
-# ── agent turn (returns final reply string) ───────────────────────────────────
+# ── Agent turn ────────────────────────────────────��───────────────────────────
 async def agent_turn_async(session, openai_tools, user_input: str, chat_id: int) -> str:
-    """Run one full agent turn. Returns the final reply for the user."""
-
     memory_block = recall(user_input)
-
     tool_descriptions = ""
     for t in openai_tools:
-        params = t["function"].get("parameters", {})
-        req = params.get("required", [])
-        props = params.get("properties", {})
-        param_str = ", ".join([f"{k}" + (" (required)" if k in req else "") for k in props.keys()]) if props else "none"
-        tool_descriptions += f"- {t['function']['name']}: {t['function']['description']} | params: {param_str}\n"
-
-    tool_descriptions += """
-IMPORTANT: For add_issues_to_sprint, sprint_id must be a NUMBER (integer), NOT "current".
-If you don't know the sprint_id, first call get_active_sprint to find the sprint ID, then use that number.
-"""
-
-    system_prompt = f"""You are an intelligent Jira Sprint Management AI Agent.
-
-You have these tools available to you. To call a tool, respond with ONLY a JSON object in this exact format:
-{{"tool": "<tool_name>", "arguments": {{"<param>": "<value>"}}}}
-
-Available tools:
-{tool_descriptions}
-
-RULES:
-1. For ANY query about Jira data, you MUST call one of the tools above by responding with JSON.
-2. Do NOT make up Jira data. Only report what the tool returns.
-3. If the user asks for something that doesn't need a tool (e.g. greeting), just respond normally.
-4. After the tool result comes back, summarize it concisely for the user.
-5. Be concise.
+        p = t["function"].get("parameters", {})
+        req = p.get("required", [])
+        props = p.get("properties", {})
+        ps = ", ".join(f"{k}" + (" (required)" if k in req else "") for k in props) if props else "none"
+        tool_descriptions += f"- {t['function']['name']}: {t['function']['description']} | {ps}\n"
+    tool_descriptions += "\nIMPORTANT: For add_issues_to_sprint, sprint_id must be a NUMBER, NOT 'current'.\n"
+
+    system_prompt = (
+        f"You are an intelligent Jira Sprint Management AI Agent.\n\n"
+        f"Available tools:\n{tool_descriptions}\n"
+        f"To call a tool, respond with ONLY JSON: {{\"tool\": \"<name>\", \"arguments\": {{...}}}}\n\n"
+        f"RULES:\n1. Call tools for Jira data queries.\n2. Don't make up data.\n"
+        f"3. Normal replies for greetings.\n4. Summarize tool results concisely.\n\n{memory_block}"
+    )
 
-{memory_block}"""
+    messages = [{"role": "system", "content": system_prompt}, {"role": "user", "content": user_input}]
+    user_sessions.setdefault(chat_id, {"messages": []})
+    clean = [m for m in user_sessions[chat_id]["messages"] if m["role"] in ("user", "assistant")]
+    messages.extend(clean[-6:])
 
     final_reply = ""
-    tool_calls_parsed = []
     all_results = []
-
-    # Build messages for this turn (do NOT pollute with old internal tool messages)
-    messages = [
-        {"role": "system", "content": system_prompt},
-        {"role": "user",   "content": user_input},
-    ]
-    # Add clean conversation history (only user/assistant exchanges, max 6 turns)
-    user_sessions.setdefault(chat_id, {"messages": []})
-    clean_history = []
-    for m in user_sessions[chat_id]["messages"]:
-        if m["role"] in ("user", "assistant"):
-            clean_history.append(m)
-    messages.extend(clean_history[-6:])
-
-    tool_name   = "none"
-    tool_args   = {}
-    tool_result = {}
-    final_reply = ""
     tool_calls_parsed = []
-    all_results = []
 
-    max_tool_rounds = 5
-    for _ in range(max_tool_rounds):
+    for _ in range(5):
         try:
-            response = llm.create_chat_completion(
-                messages=messages,
-                max_tokens=1024,
-                temperature=0.2,
-                top_p=0.9,
-            )
-
-            choice = response['choices'][0]
-            message = choice['message']
-            response_text = message.get("content", "")
-
-            # Strip <think> blocks
+            response = llm.create_chat_completion(messages=messages, max_tokens=1024, temperature=0.2, top_p=0.9)
+            response_text = response['choices'][0]['message'].get("content", "")
             if "<think>" in response_text and "</think>" in response_text:
-                response_text = response_text[response_text.rfind("</think>") + len("</think>"):].strip()
+                response_text = response_text[response_text.rfind("</think>") + 8:].strip()
 
-            # Parse ONE or MORE JSON tool calls
+            # Parse JSON tool calls
             tool_calls_parsed = []
             remaining = response_text
             while True:
-                json_start = remaining.find("{")
-                if json_start < 0:
+                j = remaining.find("{")
+                if j < 0:
                     break
-                remaining = remaining[json_start:]
-                depth = 0
-                json_end = -1
+                remaining = remaining[j:]
+                depth, end = 0, -1
                 for i, ch in enumerate(remaining):
-                    if ch == "{":
-                        depth += 1
+                    if ch == "{": depth += 1
                     elif ch == "}":
                         depth -= 1
                         if depth == 0:
-                            json_end = i + 1
+                            end = i + 1
                             break
-                if json_end < 0:
+                if end < 0:
                     break
                 try:
-                    parsed = json.loads(remaining[:json_end])
+                    parsed = json.loads(remaining[:end])
                     if "tool" in parsed:
                         tool_calls_parsed.append(parsed)
                 except json.JSONDecodeError:
                     pass
-                remaining = remaining[json_end:]
+                remaining = remaining[end:]
 
-            # Model wants to call tools
             if tool_calls_parsed:
                 all_results = []
                 for tc in tool_calls_parsed:
-                    tool_name = tc.get("tool", "unknown")
-                    tool_args = tc.get("arguments", {})
-
-                    print(f"\n  → MCP tool: {tool_name}({json.dumps(tool_args)})")
-
-                    result = await session.call_tool(tool_name, arguments=tool_args)
-
-                    if result.content and len(result.content) > 0:
-                        raw_result = result.content[0].text if hasattr(result.content[0], "text") else str(result.content[0])
-                        try:
-                            tool_result = json.loads(raw_result)
-                        except json.JSONDecodeError:
-                            tool_result = {"raw": raw_result}
-                    else:
-                        tool_result = {}
-
-                    print(f"     result: {json.dumps(tool_result, indent=2)}\n")
-                    all_results.append((tool_name, tool_result))
-
-                messages.append({
-                    "role": "assistant",
-                    "content": response_text,
-                })
-
-                results_text_parts = []
-                for tn, tr in all_results:
-                    results_text_parts.append(f"Tool {tn} returned: {json.dumps(tr)}")
-
-                has_sprint_id_error = any(
-                    "sprint_id" in json.dumps(tr).lower() and ("integer" in json.dumps(tr).lower() or "int_parsing" in json.dumps(tr).lower())
-                    for _, tr in all_results
-                )
-                if has_sprint_id_error:
-                    messages.append({
-                        "role": "user",
-                        "content": f"{' | '.join(results_text_parts)}\n\nThe sprint_id must be a number. First call get_active_sprint to find the current sprint ID, then use that number.",
-                    })
+                    tname, targs = tc.get("tool", "unknown"), tc.get("arguments", {})
+                    print(f"\n  → MCP: {tname}({json.dumps(targs)})")
+                    result = await session.call_tool(tname, arguments=targs)
+                    raw = result.content[0].text if result.content and hasattr(result.content[0], "text") else str(result.content[0]) if result.content else "{}"
+                    try:
+                        tresult = json.loads(raw)
+                    except json.JSONDecodeError:
+                        tresult = {"raw": raw}
+                    print(f"     ← {json.dumps(tresult, indent=2)}\n")
+                    all_results.append((tname, tresult))
+
+                messages.append({"role": "assistant", "content": response_text})
+                parts = [f"Tool {tn} returned: {json.dumps(tr)}" for tn, tr in all_results]
+                sprint_err = any("sprint_id" in json.dumps(tr).lower() and ("integer" in json.dumps(tr).lower() or "int_parsing" in json.dumps(tr).lower()) for _, tr in all_results)
+                if sprint_err:
+                    messages.append({"role": "user", "content": f"{' | '.join(parts)}\n\nsprint_id must be a number. Call get_active_sprint first."})
                 else:
-                    messages.append({
-                        "role": "user",
-                        "content": f"{' | '.join(results_text_parts)}\n\nNow summarize the results for the user concisely.",
-                    })
-
-            # Model gave final text answer
+                    messages.append({"role": "user", "content": f"{' | '.join(parts)}\n\nSummarize concisely."})
             else:
                 final_reply = response_text
                 print(f"\n  Agent: {final_reply}\n")
                 break
-
         except Exception as e:
-            err = str(e).lower()
-            if "out of memory" in err:
-                print("  Memory error...\n")
-                return "Sorry, I ran into a memory error. Please try again."
-            print(f"  Model Error: {str(e)[:300]}\n")
-            return f"Sorry, I ran into an error: {str(e)[:200]}"
-
-    # Store in Pinecone
+            if "out of memory" in str(e).lower():
+                return "Sorry, memory error. Try again."
+            return f"Error: {str(e)[:200]}"
+
+    # Pinecone store
     if all_results:
-        last_tool_name, last_tool_res = all_results[-1]
-        last_tool_args_dict = tool_calls_parsed[-1].get("arguments", {}) if tool_calls_parsed else {}
-        store(user_input, final_reply, last_tool_name, last_tool_args_dict, last_tool_res)
+        store(user_input, final_reply, all_results[-1][0], tool_calls_parsed[-1].get("arguments", {}), all_results[-1][1])
     else:
         store(user_input, final_reply, "none", {}, {})
 
-    # Save conversation history (keep last 10 turns)
+    # Save history
     user_sessions[chat_id]["messages"].append({"role": "user", "content": user_input})
     user_sessions[chat_id]["messages"].append({"role": "assistant", "content": final_reply})
     if len(user_sessions[chat_id]["messages"]) > 20:
@@ -359,121 +255,87 @@ RULES:
 
 
 # ── Telegram handlers ─────────────────────────────────────────────────────────
-@bot.message_handler(commands=['start'])
-def cmd_start(message):
-    name = message.from_user.first_name or "there"
-    bot.reply_to(message,
-        f"Hey {name}! 👋\n\n"
-        f"I'm your Jira Sprint Manager. I can help you:\n"
-        f"• View the backlog\n"
-        f"• Check active sprint progress\n"
-        f"• Create stories/tasks\n"
-        f"• Move issues between sprints\n"
-        f"• Transition issue status (To Do → In Progress → Testing → Done)\n"
-        f"• Close & rollover sprints\n\n"
-        f"Just ask me anything!"
-    )
-
-
-@bot.message_handler(commands=['memory'])
-def cmd_memory(message):
-    """Search Pinecone memory."""
-    parts = message.text.split(None, 1)
-    if len(parts) < 2:
-        bot.reply_to(message, "Usage: /memory <search query>")
-        return
-    query = parts[1]
-    result = recall(query, top_k=5)
-    if result:
-        # Truncate if too long for Telegram
-        reply = result[:4000]
-        bot.reply_to(message, reply)
-    else:
-        bot.reply_to(message, "Nothing found in memory.")
-
-
-@bot.message_handler(func=lambda m: True)
-def handle_message(message):
-    """Handle all other messages — run the agent."""
-    user_input = message.text.strip()
-    chat_id = message.chat.id
-    username = message.from_user.first_name or message.from_user.username or "User"
-
-    if not user_input:
-        return
-
-    # Log user message to terminal for debugging
-    print(f"\n{'='*50}")
-    print(f"  Telegram [{username}]: {user_input}")
-    print(f"{'='*50}\n")
-
-    # Show "typing" indicator
-    bot.send_chat_action(chat_id, "typing")
-
-    # Schedule the async agent turn on the event loop
-    future = asyncio.run_coroutine_threadsafe(
-        agent_turn_async(mcp_session_ref, openai_tools_ref, user_input, chat_id),
-        loop_ref,
-    )
-    reply = future.result(timeout=120)  # wait up to 2 minutes
-
-    # Send reply (split if too long for Telegram's 4096 char limit)
-    chunks = [reply[i:i+4000] for i in range(0, len(reply), 4000)] if reply else ["..."]
-    for chunk in chunks:
-        bot.send_message(chat_id, chunk)
-
-
-# ── main entry: start MCP + Telegram ─────────────────────────────────────────
-mcp_session_ref = None
-openai_tools_ref = None
-
-async def main_async():
+def _register_handlers():
+    @bot.message_handler(commands=['start'])
+    def cmd_start(message):
+        name = message.from_user.first_name or "there"
+        bot.reply_to(message, f"Hey {name}! 👋\n\nI'm your Jira Sprint Manager. Ask me anything about sprints, backlog, or issues!")
+
+    @bot.message_handler(commands=['memory'])
+    def cmd_memory(message):
+        parts = message.text.split(None, 1)
+        if len(parts) < 2:
+            bot.reply_to(message, "Usage: /memory <query>")
+            return
+        result = recall(parts[1], top_k=5)
+        bot.reply_to(message, result[:4000] if result else "Nothing found.")
+
+    @bot.message_handler(func=lambda m: True)
+    def handle_message(message):
+        user_input = message.text.strip()
+        if not user_input:
+            return
+        print(f"\n{'='*50}\n  Telegram [{message.from_user.first_name}]: {user_input}\n{'='*50}\n")
+        bot.send_chat_action(message.chat.id, "typing")
+        future = asyncio.run_coroutine_threadsafe(
+            agent_turn_async(mcp_session_ref, openai_tools_ref, user_input, message.chat.id), loop_ref)
+        reply = future.result(timeout=120)
+        for chunk in [reply[i:i+4000] for i in range(0, len(reply), 4000)] if reply else ["..."]:
+            bot.send_message(message.chat.id, chunk)
+
+
+# ── Main entry: start MCP + Telegram (callable by orchestrator) ───────────────
+async def start_telegram_with_mcp():
+    """Initialize all components and start the Telegram bot with MCP."""
     global mcp_session_ref, openai_tools_ref, loop_ref
     loop_ref = asyncio.get_event_loop()
 
-    server_params = StdioServerParameters(
-        command=sys.executable,
-        args=[MCP_SERVER_SCRIPT],
-        env={**os.environ},
-    )
+    # Lazy init all components
+    _init_telegram_bot()
+    _init_embedder()
+    _init_llm()
+    _init_pinecone()
+    _register_handlers()
+
+    server_params = StdioServerParameters(command=sys.executable, args=[MCP_SERVER_SCRIPT], env={**os.environ})
 
     async with stdio_client(server_params) as (read, write):
         async with ClientSession(read, write) as session:
             await session.initialize()
-
-            tools_response = await session.list_tools()
-            mcp_tools    = tools_response.tools
+            tools_resp = await session.list_tools()
+            mcp_tools = tools_resp.tools
             openai_tools = mcp_tools_to_openai_schema(mcp_tools)
 
-            # Store refs for the Telegram thread
+            # Update refs for status checking
+            import shared_state
+            shared_state.mcp_session = session
+            shared_state.openai_tools = openai_tools
+            shared_state.telegram_bot = bot
+            shared_state.llm_instance = llm
             mcp_session_ref = session
             openai_tools_ref = openai_tools
 
             stats = pine_index.describe_index_stats()
-            total = stats.get("total_vector_count", 0)
-
             print("=" * 60)
-            print("  Jira Agent (Telegram + MCP)  |  Phi-4-Mini (local)")
-            print(f"  MCP tools  |  {[t.name for t in mcp_tools]}")
-            print(f"  Memory     |  {total} interactions in Pinecone")
+            print(f"  Telegram + MCP | Tools: {[t.name for t in mcp_tools]}")
+            print(f"  Memory: {stats.get('total_vector_count', 0)} vectors")
             print("=" * 60 + "\n")
 
-            # Start Telegram bot in a background thread
             def run_telegram():
-                print("  Telegram bot started.\n")
+                print("  Telegram bot running.\n")
                 bot.infinity_polling()
 
-            telegram_thread = threading.Thread(target=run_telegram, daemon=True)
-            telegram_thread.start()
+            t = threading.Thread(target=run_telegram, daemon=True)
+            t.start()
 
-            # Keep the asyncio loop alive
             try:
                 while True:
                     await asyncio.sleep(1)
             except (KeyboardInterrupt, SystemExit):
-                print("\nShutting down...")
+                print("\nShutting down Telegram...")
                 bot.stop_polling()
 
 
+# ── Standalone run ────────────────────────────────────────────────────────────
 if __name__ == "__main__":
-    asyncio.run(main_async())
+    asyncio.run(start_telegram_with_mcp())