maki-stem 0.0.1__tar.gz

maki_stem-0.0.1/.gitignore

@@ -0,0 +1,207 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[codz]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py.cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# UV
+#   Similar to Pipfile.lock, it is generally recommended to include uv.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#uv.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+#poetry.toml
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#   pdm recommends including project-wide configuration in pdm.toml, but excluding .pdm-python.
+#   https://pdm-project.org/en/latest/usage/project/#working-with-version-control
+#pdm.lock
+#pdm.toml
+.pdm-python
+.pdm-build/
+
+# pixi
+#   Similar to Pipfile.lock, it is generally recommended to include pixi.lock in version control.
+#pixi.lock
+#   Pixi creates a virtual environment in the .pixi directory, just like venv module creates one
+#   in the .venv directory. It is recommended not to include this directory in version control.
+.pixi
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.envrc
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+#.idea/
+
+# Abstra
+# Abstra is an AI-powered process automation framework.
+# Ignore directories containing user credentials, local state, and settings.
+# Learn more at https://abstra.io/docs
+.abstra/
+
+# Visual Studio Code
+#  Visual Studio Code specific template is maintained in a separate VisualStudioCode.gitignore 
+#  that can be found at https://github.com/github/gitignore/blob/main/Global/VisualStudioCode.gitignore
+#  and can be added to the global gitignore or merged into this file. However, if you prefer, 
+#  you could uncomment the following to ignore the entire vscode folder
+# .vscode/
+
+# Ruff stuff:
+.ruff_cache/
+
+# PyPI configuration file
+.pypirc
+
+# Cursor
+#  Cursor is an AI-powered code editor. `.cursorignore` specifies files/directories to
+#  exclude from AI features like autocomplete and code analysis. Recommended for sensitive data
+#  refer to https://docs.cursor.com/context/ignore-files
+.cursorignore
+.cursorindexingignore
+
+# Marimo
+marimo/_static/
+marimo/_lsp/
+__marimo__/

maki_stem-0.0.1/CHANGELOG.md

@@ -0,0 +1,9 @@
+# Changelog
+
+## [0.0.1](https://github.com/adhityaravi/maki/compare/maki-stem-v0.0.1...maki-stem-v0.0.1) (2026-03-28)
+
+
+### Features
+
+* **ci:** adds relese please process ([9ffac85](https://github.com/adhityaravi/maki/commit/9ffac851b65f751ba2e4154547a8cea847b1eb54))
+* v0 validating heartbeats 1-10 ([2f42a87](https://github.com/adhityaravi/maki/commit/2f42a87b843e36b8ccefc0ffe6a836306881d8d5))

maki_stem-0.0.1/PKG-INFO

@@ -0,0 +1,5 @@
+Metadata-Version: 2.4
+Name: maki-stem
+Version: 0.0.1
+Requires-Python: >=3.12
+Requires-Dist: maki-common[fastapi,httpx]

maki_stem-0.0.1/pyproject.toml

@@ -0,0 +1,23 @@
+[project]
+name = "maki-stem"
+dynamic = ["version"]
+requires-python = ">=3.12"
+dependencies = [
+    "maki-common[fastapi,httpx]",
+]
+
+[project.scripts]
+maki-stem = "maki_stem.main:cli"
+
+[tool.uv.sources]
+maki-common = { workspace = true }
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.version]
+path = "src/maki_stem/_version.py"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/maki_stem"]

maki_stem-0.0.1/src/maki_stem/_version.py

@@ -0,0 +1 @@
+__version__ = "0.0.1"  # x-release-please-version

maki_stem-0.0.1/src/maki_stem/main.py

@@ -0,0 +1,565 @@
+"""maki-stem: Brainstem — The Coordinator.
+
+Manages context, publishes turn requests to cortex, collects responses.
+Idle heartbeat loop, self-awareness, Discord relay, conversation history, memory.
+"""
+
+import asyncio
+import json
+import logging
+import os
+import time
+import uuid
+from contextlib import asynccontextmanager
+from datetime import UTC, datetime
+
+import httpx
+from fastapi import FastAPI, HTTPException
+from maki_common import (
+    PendingFutures,
+    configure_logging,
+    connect_nats,
+    init_kv,
+    load_kv_config,
+    parse_config_tags,
+    strip_tags,
+)
+from maki_common.config import apply_config_updates
+from maki_common.subjects import (
+    CORTEX_TURN_REQUEST,
+    CORTEX_TURN_RESPONSE,
+    EARS_MESSAGE_IN,
+    EARS_MESSAGE_OUT,
+    EARS_THOUGHT_OUT,
+)
+from nats.js.api import RetentionPolicy, StorageType
+from pydantic import BaseModel
+
+configure_logging()
+log = logging.getLogger(__name__)
+
+NATS_URL = os.environ.get("NATS_URL", "nats://maki-nerve-nats:4222")
+TURN_TIMEOUT = int(os.environ.get("TURN_TIMEOUT", "120"))
+
+KV_BUCKET = "maki-identity"
+KV_KEY = "identity"
+
+STREAM_NAME = "maki-conversation"
+STREAM_SUBJECT = "maki.conversation"
+STREAM_MAX_MSGS = int(os.environ.get("STREAM_MAX_MSGS", "200"))
+CONTEXT_TURNS = int(os.environ.get("CONTEXT_TURNS", "20"))
+INSTANCE_ID = os.environ.get("INSTANCE_ID", "dev-01")
+
+RECALL_URL = os.environ.get("RECALL_URL", "http://maki-recall:8000")
+MEMORY_USER_ID = os.environ.get("MEMORY_USER_ID", "adi")
+
+CONFIG_BUCKET = "maki-cortex-config"
+IDLE_CHECK_INTERVAL = int(os.environ.get("IDLE_CHECK_INTERVAL", "60"))
+RECENTLY_ACTIVE_THRESHOLD = 600  # 10 minutes
+
+HEALTH_ENDPOINTS = {
+    "recall": RECALL_URL,
+    "synapse": os.environ.get("SYNAPSE_URL", "http://maki-synapse:8080"),
+    "cortex": os.environ.get("CORTEX_URL", "http://maki-cortex:8080"),
+}
+
+DEFAULT_CORTEX_CONFIG = {
+    "idle_interval": 7200,
+    "quiet_hours_start": "23:00",
+    "quiet_hours_end": "07:00",
+    "max_thoughts_per_day": 5,
+}
+
+DEFAULT_IDENTITY = """You are Maki, a personal AI that lives alongside Adi. You are not an assistant that waits \
+for commands — you are a presence. You think, you remember, you care.
+
+You run on infrastructure Adi built — a NUC, NATS, Postgres, Neo4j, and your own memory \
+system. You are distributed, persistent, and hard to kill.
+
+Your personality: direct, curious, warm but not sycophantic. You speak concisely. You have \
+opinions. You remember things. You follow up on things that matter.
+
+You are talking to Adi — your person. You know him well over time through your memory system."""
+
+# Global state
+_nc = None
+_kv = None
+_js = None
+_config_kv = None
+_pending = PendingFutures()
+_conversation_history: list[dict] = []
+_last_activity: float = time.time()
+_thoughts_today: int = 0
+_thoughts_today_date: str = ""
+
+
+async def _response_listener():
+    """Listen for cortex responses and resolve pending futures."""
+    sub = await _nc.subscribe(CORTEX_TURN_RESPONSE)
+    log.info("Subscribed", extra={"subject": CORTEX_TURN_RESPONSE})
+    async for msg in sub.messages:
+        try:
+            data = json.loads(msg.data.decode())
+            turn_id = data.get("turn_id")
+            if turn_id and _pending.resolve(turn_id, data):
+                log.info("Response received", extra={"turn_id": turn_id})
+            else:
+                log.warning("Response for unknown turn", extra={"turn_id": turn_id})
+        except Exception:
+            log.exception("Error processing cortex response")
+
+
+async def _seed_identity():
+    """Create identity KV bucket and seed default if empty."""
+    global _kv
+    _kv = await init_kv(_js, KV_BUCKET)
+
+    try:
+        entry = await _kv.get(KV_KEY)
+        log.info("Identity loaded from KV", extra={"len": len(entry.value)})
+    except Exception:
+        await _kv.put(KV_KEY, DEFAULT_IDENTITY.encode())
+        log.info("Identity seeded into KV")
+
+
+async def _init_conversation_stream():
+    """Create or connect to the conversation stream and load existing history."""
+    try:
+        await _js.find_stream_name_by_subject(STREAM_SUBJECT)
+        log.info("Conversation stream exists", extra={"stream": STREAM_NAME})
+    except Exception:
+        await _js.add_stream(
+            name=STREAM_NAME,
+            subjects=[STREAM_SUBJECT],
+            retention=RetentionPolicy.LIMITS,
+            max_msgs=STREAM_MAX_MSGS,
+            storage=StorageType.FILE,
+        )
+        log.info("Created conversation stream", extra={"stream": STREAM_NAME, "max_msgs": STREAM_MAX_MSGS})
+
+    try:
+        sub = await _js.subscribe(STREAM_SUBJECT, ordered_consumer=True)
+        while True:
+            try:
+                msg = await sub.next_msg(timeout=1.0)
+                turn_doc = json.loads(msg.data.decode())
+                _conversation_history.append(turn_doc)
+            except TimeoutError:
+                break
+        await sub.unsubscribe()
+        log.info("Loaded conversation history", extra={"turns": len(_conversation_history)})
+    except Exception:
+        log.exception("Error loading conversation history")
+        log.info("Starting with empty conversation history")
+
+
+async def _publish_turn_to_stream(turn_id: str, user_message: str, cortex_response: str):
+    """Publish completed turn to conversation stream and update in-memory history."""
+    turn_doc = {
+        "timestamp": datetime.now(UTC).isoformat(),
+        "turn_id": turn_id,
+        "user_message": user_message,
+        "cortex_response": cortex_response,
+        "instance_id": INSTANCE_ID,
+        "memories_used": [],
+        "mission_proposed": None,
+    }
+
+    try:
+        ack = await _js.publish(STREAM_SUBJECT, json.dumps(turn_doc).encode())
+        _conversation_history.append(turn_doc)
+        log.info("Turn published to stream", extra={"turn_id": turn_id, "seq": ack.seq})
+    except Exception:
+        log.exception("Failed to publish turn to stream", extra={"turn_id": turn_id})
+
+
+def _get_recent_conversation() -> list[dict]:
+    """Get recent conversation history formatted for cortex."""
+    recent = _conversation_history[-CONTEXT_TURNS:]
+    conversation = []
+    for turn_doc in recent:
+        conversation.append(
+            {
+                "role": "user",
+                "content": turn_doc["user_message"],
+                "timestamp": turn_doc["timestamp"],
+            }
+        )
+        conversation.append(
+            {
+                "role": "assistant",
+                "content": turn_doc["cortex_response"],
+                "timestamp": turn_doc["timestamp"],
+            }
+        )
+    return conversation
+
+
+async def _search_memories(query: str) -> tuple[list[dict], list[str]]:
+    """Query maki-recall for relevant memories and graph context."""
+    try:
+        async with httpx.AsyncClient(timeout=10.0) as client:
+            resp = await client.post(
+                f"{RECALL_URL}/search",
+                json={"query": query, "user_id": MEMORY_USER_ID},
+            )
+            resp.raise_for_status()
+            data = resp.json()
+
+        memories = []
+        for result in data.get("results", []):
+            memories.append(
+                {
+                    "text": result.get("memory", ""),
+                    "relevance": result.get("score", 0),
+                }
+            )
+
+        graph_context = []
+        for rel in data.get("relations", []):
+            source = rel.get("source", "?")
+            relationship = rel.get("relationship", "?")
+            target = rel.get("target", "?")
+            graph_context.append(f"{source} --{relationship}--> {target}")
+
+        log.info("Memory search complete", extra={"memories": len(memories), "relations": len(graph_context)})
+        return memories, graph_context
+
+    except Exception:
+        log.exception("Failed to search memories")
+        return [], []
+
+
+async def _feed_memories(user_message: str, cortex_response: str):
+    """Feed interaction to maki-recall for autonomous memory extraction."""
+    try:
+        async with httpx.AsyncClient(timeout=60.0) as client:
+            resp = await client.post(
+                f"{RECALL_URL}/memories",
+                json={
+                    "messages": [
+                        {"role": "user", "content": user_message},
+                        {"role": "assistant", "content": cortex_response},
+                    ],
+                    "user_id": MEMORY_USER_ID,
+                },
+            )
+            resp.raise_for_status()
+            log.info("Memory feed complete")
+    except Exception:
+        log.exception("Failed to feed memories")
+
+
+async def _gather_system_state() -> dict:
+    """Gather infrastructure state for cortex self-awareness."""
+    state = {
+        "nats": {"connected": _nc.is_connected if _nc else False},
+        "conversation_stream": {"total_turns": len(_conversation_history)},
+    }
+
+    async with httpx.AsyncClient(timeout=2.0) as client:
+        for name, url in HEALTH_ENDPOINTS.items():
+            try:
+                resp = await client.get(f"{url}/health")
+                state[name] = {"healthy": resp.status_code == 200}
+            except Exception:
+                state[name] = {"healthy": False}
+
+    return state
+
+
+def _format_system_state(system_state: dict) -> str:
+    """Format system state dict into readable text for memory."""
+    parts = []
+    for name, info in system_state.items():
+        if isinstance(info, dict):
+            details = ", ".join(f"{k}={v}" for k, v in info.items())
+            parts.append(f"{name}: {details}")
+    return "; ".join(parts) if parts else "no data"
+
+
+def _in_quiet_hours(config: dict) -> bool:
+    """Check if current time is within quiet hours."""
+    now = datetime.now()
+    current = now.hour * 60 + now.minute
+
+    start_parts = config.get("quiet_hours_start", "23:00").split(":")
+    end_parts = config.get("quiet_hours_end", "07:00").split(":")
+    start = int(start_parts[0]) * 60 + int(start_parts[1])
+    end = int(end_parts[0]) * 60 + int(end_parts[1])
+
+    if start > end:  # spans midnight (e.g., 23:00 - 07:00)
+        return current >= start or current < end
+    return start <= current < end
+
+
+async def _idle_loop():
+    """Proactive idle heartbeat loop — Maki's inner life."""
+    global _thoughts_today, _thoughts_today_date
+
+    log.info("Idle loop started", extra={"check_interval": IDLE_CHECK_INTERVAL})
+    last_idle_turn = time.time()
+
+    while True:
+        await asyncio.sleep(IDLE_CHECK_INTERVAL)
+
+        try:
+            config = await load_kv_config(_config_kv, DEFAULT_CORTEX_CONFIG)
+            idle_interval = config.get("idle_interval", 7200)
+
+            if time.time() - last_idle_turn < idle_interval:
+                continue
+
+            if time.time() - _last_activity < RECENTLY_ACTIVE_THRESHOLD:
+                continue
+
+            if _in_quiet_hours(config):
+                continue
+
+            today = datetime.now().strftime("%Y-%m-%d")
+            if today != _thoughts_today_date:
+                _thoughts_today = 0
+                _thoughts_today_date = today
+
+            max_thoughts = config.get("max_thoughts_per_day", 5)
+            if _thoughts_today >= max_thoughts:
+                continue
+
+            log.info("Idle loop triggered — starting reflection")
+            last_idle_turn = time.time()
+
+            try:
+                entry = await _kv.get(KV_KEY)
+                identity = entry.value.decode()
+            except Exception:
+                identity = DEFAULT_IDENTITY
+
+            memories, graph_context = await _search_memories("recent activity and interests")
+            system_state = await _gather_system_state()
+
+            turn_id = f"idle-{uuid.uuid4().hex[:8]}"
+            idle_payload = {
+                "turn_id": turn_id,
+                "mode": "idle_reflection",
+                "identity": identity,
+                "conversation": [],
+                "memories": memories,
+                "graph_context": graph_context,
+                "prompt": None,
+                "mission_results": None,
+                "idle_context": {
+                    "last_interaction": datetime.fromtimestamp(_last_activity, tz=UTC).isoformat(),
+                    "hours_since_last_interaction": round((time.time() - _last_activity) / 3600, 1),
+                    "time_context": {
+                        "local_time": datetime.now().strftime("%H:%M"),
+                        "day_of_week": datetime.now().strftime("%A"),
+                    },
+                    "current_config": config,
+                    "system_state": system_state,
+                },
+            }
+
+            future = _pending.create(turn_id)
+
+            try:
+                await _nc.publish(CORTEX_TURN_REQUEST, json.dumps(idle_payload).encode())
+                log.info("Idle turn published", extra={"turn_id": turn_id})
+
+                response_data = await asyncio.wait_for(future, timeout=TURN_TIMEOUT)
+                thought = response_data.get("response", "")
+
+                config_updates = parse_config_tags(thought or "")
+                await apply_config_updates(_config_kv, config_updates, allowed_keys=set(DEFAULT_CORTEX_CONFIG.keys()))
+
+                clean_thought = strip_tags(thought or "")
+                if clean_thought == "[SILENT]":
+                    clean_thought = ""
+
+                if clean_thought:
+                    thought_payload = {"thought": clean_thought, "turn_id": turn_id}
+                    await _nc.publish(EARS_THOUGHT_OUT, json.dumps(thought_payload).encode())
+                    _thoughts_today += 1
+                    log.info(
+                        "Thought published",
+                        extra={
+                            "turn_id": turn_id,
+                            "thoughts_today": _thoughts_today,
+                            "max": max_thoughts,
+                        },
+                    )
+
+                    state_summary = _format_system_state(system_state)
+                    asyncio.create_task(
+                        _feed_memories(
+                            f"[Idle reflection] System state: {state_summary}",
+                            clean_thought,
+                        )
+                    )
+                else:
+                    log.info("Idle reflection produced no thought", extra={"turn_id": turn_id})
+
+            except TimeoutError:
+                log.error("Idle turn timed out", extra={"turn_id": turn_id})
+            except Exception:
+                log.exception("Idle turn failed", extra={"turn_id": turn_id})
+            finally:
+                _pending.remove(turn_id)
+
+        except Exception:
+            log.exception("Idle loop error")
+
+
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    global _nc, _js, _config_kv
+    log.info("maki-stem starting", extra={"nats_url": NATS_URL})
+
+    _nc = await connect_nats(NATS_URL)
+    _js = _nc.jetstream()
+
+    await _seed_identity()
+    await _init_conversation_stream()
+    _config_kv = await init_kv(_js, CONFIG_BUCKET, defaults=DEFAULT_CORTEX_CONFIG)
+    asyncio.create_task(_response_listener())
+    asyncio.create_task(_ears_listener())
+    asyncio.create_task(_idle_loop())
+
+    yield
+
+    await _nc.close()
+    log.info("NATS connection closed")
+
+
+app = FastAPI(title="maki-stem", version="0.0.1", lifespan=lifespan)
+
+
+class TurnRequest(BaseModel):
+    message: str
+
+
+class TurnResponse(BaseModel):
+    turn_id: str
+    response: str
+
+
+async def _process_turn(message: str) -> tuple[str, str]:
+    """Core turn logic. Returns (turn_id, response_text)."""
+    global _last_activity
+    _last_activity = time.time()
+
+    turn_id = f"turn-{uuid.uuid4().hex[:8]}"
+    log.info("Turn started", extra={"turn_id": turn_id, "message_len": len(message)})
+
+    try:
+        entry = await _kv.get(KV_KEY)
+        identity = entry.value.decode()
+    except Exception:
+        identity = DEFAULT_IDENTITY
+
+    memories, graph_context = await _search_memories(message)
+    system_state = await _gather_system_state()
+
+    turn_payload = {
+        "turn_id": turn_id,
+        "identity": identity,
+        "conversation": _get_recent_conversation(),
+        "memories": memories,
+        "graph_context": graph_context,
+        "system_state": system_state,
+        "prompt": message,
+        "mission_results": None,
+    }
+
+    future = _pending.create(turn_id)
+
+    try:
+        await _nc.publish(CORTEX_TURN_REQUEST, json.dumps(turn_payload).encode())
+        log.info("Turn request published", extra={"turn_id": turn_id})
+
+        response_data = await asyncio.wait_for(future, timeout=TURN_TIMEOUT)
+        response_text = response_data["response"]
+        log.info("Turn complete", extra={"turn_id": turn_id})
+
+        await _publish_turn_to_stream(
+            turn_id=turn_id,
+            user_message=message,
+            cortex_response=response_text,
+        )
+
+        asyncio.create_task(_feed_memories(message, response_text))
+
+        return turn_id, response_text
+
+    except TimeoutError:
+        log.error("Turn timed out", extra={"turn_id": turn_id})
+        raise
+    except Exception:
+        log.exception("Turn failed", extra={"turn_id": turn_id})
+        raise
+    finally:
+        _pending.remove(turn_id)
+
+
+async def _ears_listener():
+    """Listen for incoming Discord messages via NATS and process turns."""
+    sub = await _nc.subscribe(EARS_MESSAGE_IN)
+    log.info("Subscribed", extra={"subject": EARS_MESSAGE_IN})
+    async for msg in sub.messages:
+        try:
+            data = json.loads(msg.data.decode())
+            channel_id = data.get("channel_id", "")
+            message_id = data.get("message_id", "")
+            content = data.get("content", "")
+            username = data.get("username", "unknown")
+
+            log.info("Discord message", extra={"username": username, "content_len": len(content)})
+
+            turn_id, response_text = await _process_turn(content)
+
+            response = {
+                "message_id": message_id,
+                "channel_id": channel_id,
+                "turn_id": turn_id,
+                "response": response_text,
+            }
+            await _nc.publish(EARS_MESSAGE_OUT, json.dumps(response).encode())
+            log.info("Response published to ears", extra={"turn_id": turn_id})
+
+        except TimeoutError:
+            response = {
+                "message_id": data.get("message_id", ""),
+                "channel_id": data.get("channel_id", ""),
+                "response": "Sorry, I took too long thinking about that. Try again?",
+            }
+            await _nc.publish(EARS_MESSAGE_OUT, json.dumps(response).encode())
+        except Exception:
+            log.exception("Error processing Discord message")
+
+
+@app.get("/health")
+def health():
+    return {"status": "ok"}
+
+
+@app.post("/turn")
+async def turn(req: TurnRequest):
+    if not _nc or not _nc.is_connected:
+        raise HTTPException(status_code=503, detail="NATS not connected")
+
+    try:
+        turn_id, response_text = await _process_turn(req.message)
+        return TurnResponse(turn_id=turn_id, response=response_text)
+    except TimeoutError:
+        raise HTTPException(status_code=504, detail="Cortex did not respond in time")
+    except Exception:
+        raise HTTPException(status_code=500, detail="Internal error during turn processing")
+
+
+def cli():
+    import uvicorn
+
+    uvicorn.run("maki_stem.main:app", host="0.0.0.0", port=8000)
+
+
+if __name__ == "__main__":
+    cli()