opencode-agent-hub 1.3.3__tar.gz → 1.4.1__tar.gz

{opencode_agent_hub-1.3.3 → opencode_agent_hub-1.4.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: opencode-agent-hub
-Version: 1.3.3
+Version: 1.4.1
 Summary: Multi-agent coordination daemon and tools for OpenCode
 Project-URL: Homepage, https://github.com/xnoto/opencode-agent-hub
 Project-URL: Repository, https://github.com/xnoto/opencode-agent-hub

{opencode_agent_hub-1.3.3 → opencode_agent_hub-1.4.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "opencode-agent-hub"
-version = "1.3.3"
+version = "1.4.1"
 description = "Multi-agent coordination daemon and tools for OpenCode"
 readme = "README.md"
 license = "MIT"

{opencode_agent_hub-1.3.3 → opencode_agent_hub-1.4.1}/src/opencode_agent_hub/__init__.py

@@ -8,4 +8,4 @@ from importlib.metadata import PackageNotFoundError, version
 try:
     __version__ = version("opencode-agent-hub")
 except PackageNotFoundError:  # pragma: no cover - fallback for dev
-    __version__ = "1.3.3"
+    __version__ = "1.4.1"

{opencode_agent_hub-1.3.3 → opencode_agent_hub-1.4.1}/src/opencode_agent_hub/daemon.py

@@ -532,6 +532,7 @@ _sessions_cache_lock = threading.Lock()
 class InjectionTask:
     session_id: str
     text: str
+    agent: str | None = None
 
 
 @dataclass
@@ -1867,6 +1868,13 @@ def start_coordinator() -> bool:
         COORDINATOR_SESSION_ID = session_id
         ORIENTED_SESSIONS.add(session_id)
 
+        # Log the coordinator's agent if we can detect it
+        coordinator_agent_name = get_agent_from_session_messages(session_id)
+        if coordinator_agent_name:
+            log.info(f"Coordinator is using agent: {coordinator_agent_name}")
+        else:
+            log.info("Coordinator agent not yet detected (will be logged after first message)")
+
         # Register coordinator as an agent so other agents can message it
         coordinator_agent = {
             "id": "coordinator",
@@ -1972,14 +1980,15 @@ def notify_coordinator_new_agent(agent_id: str, directory: str) -> None:
 
     before_ms = int(time.time() * 1000)
     notification = f"NEW_AGENT: {agent_id} at {directory}"
-    inject_message(COORDINATOR_SESSION_ID, notification)
+    # Notification to coordinator should use coordinator's own agent
+    inject_message(COORDINATOR_SESSION_ID, notification, agent="coordinator")
     log.info(f"Notified coordinator of new agent: {agent_id}")
 
     if not _wait_for_coordinator_activity(COORDINATOR_SESSION_ID, before_ms, timeout_seconds=5):
         log.warning(
             f"Coordinator showed no activity after NEW_AGENT {agent_id}; retrying notification once"
         )
-        inject_message(COORDINATOR_SESSION_ID, notification)
+        inject_message(COORDINATOR_SESSION_ID, notification, agent="coordinator")
 
 
 def poll_coordinator_cost() -> None:
@@ -2012,6 +2021,14 @@ def poll_coordinator_cost() -> None:
     if not isinstance(messages, list):
         return
 
+    # Log the coordinator's current agent from most recent message
+    if messages:
+        most_recent = messages[-1]  # Messages are in chronological order
+        info = most_recent.get("info", {})
+        agent = info.get("agent")
+        if agent:
+            log.debug(f"Coordinator using agent: {agent}")
+
     # Sum token usage from all assistant messages
     total_input = 0
     total_output = 0
@@ -2180,16 +2197,24 @@ def find_sessions_for_agent(agent: dict, sessions: list[dict]) -> list[dict]:
     return [matching[0]]
 
 
-def inject_message_sync(session_id: str, text: str) -> bool:
+def inject_message_sync(session_id: str, text: str, agent: str | None = None) -> bool:
     """Inject message into OpenCode session (synchronous, with retries).
 
     Uses /prompt_async endpoint which triggers LLM invocation even when idle.
     The /message endpoint with noReply:false only adds to context without
     actually invoking the LLM when the session is idle.
+
+    Args:
+        session_id: Target session ID
+        text: Message text to inject
+        agent: Optional agent ID to use for handling this message. When provided,
+               OpenCode will use this agent instead of the default.
     """
-    payload = {
+    payload: dict[str, Any] = {
         "parts": [{"type": "text", "text": text}],
     }
+    if agent:
+        payload["agent"] = agent
 
     for attempt in range(INJECTION_RETRIES):
         try:
@@ -2202,7 +2227,10 @@ def inject_message_sync(session_id: str, text: str) -> bool:
             )
             # prompt_async returns 204 No Content on success
             if resp.status_code in (200, 204):
-                log.info(f"Injected message into session {session_id[:8]}... (prompt_async)")
+                agent_info = f" [agent={agent}]" if agent else ""
+                log.info(
+                    f"Injected message into session {session_id[:8]}... (prompt_async){agent_info}"
+                )
                 metrics.inc("agent_hub_injections_total")
                 return True
             else:
@@ -2219,9 +2247,15 @@ def inject_message_sync(session_id: str, text: str) -> bool:
     return False
 
 
-def inject_message(session_id: str, text: str) -> None:
-    """Queue message for async injection (non-blocking)."""
-    _injection_queue.put(InjectionTask(session_id=session_id, text=text))
+def inject_message(session_id: str, text: str, agent: str | None = None) -> None:
+    """Queue message for async injection (non-blocking).
+
+    Args:
+        session_id: Target session ID
+        text: Message text to inject
+        agent: Optional agent ID to use for handling this message
+    """
+    _injection_queue.put(InjectionTask(session_id=session_id, text=text, agent=agent))
 
 
 def injection_worker(shutdown_event: threading.Event) -> None:
@@ -2233,7 +2267,7 @@ def injection_worker(shutdown_event: threading.Event) -> None:
             continue
 
         try:
-            inject_message_sync(task.session_id, task.text)
+            inject_message_sync(task.session_id, task.text, task.agent)
         except Exception as e:
             log.error(f"Injection worker error: {e}")
         finally:
@@ -2371,6 +2405,47 @@ def generate_agent_id_for_session(session: dict[str, Any]) -> str:
     return f"session-{session_id[:12]}" if session_id else "unknown-session"
 
 
+def get_agent_from_session_messages(session_id: str) -> str | None:
+    """Get the current agent for a session from the most recent message.
+
+    Queries the OpenCode SQLite database to find the agent used in the
+    most recent message for this session. This reflects the actual running
+    agent, not just the configured default.
+
+    Args:
+        session_id: The session ID to look up
+
+    Returns:
+        The agent name (e.g., "kimi", "claude", " coordinator") or None
+    """
+    if not session_id or not OPENCODE_DB_PATH.exists():
+        return None
+
+    try:
+        conn = sqlite3.connect(f"file:{OPENCODE_DB_PATH}?mode=ro", uri=True, timeout=5)
+        conn.row_factory = sqlite3.Row
+        try:
+            # Get the most recent message for this session
+            row = conn.execute(
+                "SELECT data FROM message WHERE session_id = ? ORDER BY time_created DESC LIMIT 1",
+                (session_id,),
+            ).fetchone()
+
+            if row and row["data"]:
+                msg_data = json.loads(row["data"])
+                # Agent is stored in the message data
+                agent = msg_data.get("agent")
+                if isinstance(agent, str) and agent:
+                    log.debug(f"Detected agent '{agent}' from session {session_id[:12]}")
+                    return agent
+        finally:
+            conn.close()
+    except (sqlite3.Error, json.JSONDecodeError, OSError) as e:
+        log.debug(f"Failed to get agent from session messages: {e}")
+
+    return None
+
+
 def get_or_create_agent_for_session(
     session: dict[str, Any], agents: dict[str, dict[str, Any]]
 ) -> dict[str, Any]:
@@ -2380,11 +2455,10 @@ def get_or_create_agent_for_session(
     identity per session, allowing multiple TUI sessions in the same directory
     to have separate agent identities.
 
-    The agent ID is derived from the session's slug (if available) or session ID,
-    ensuring uniqueness across all sessions.
+    The agent ID is derived from the session's actual running agent (queried
+    from the SQLite database), or falls back to the session slug/ID.
     """
     session_id = cast(str, session.get("id", ""))
-    directory = cast(str, session.get("directory", ""))
 
     # Check if we already have a mapping for this session
     if session_id in SESSION_AGENTS:
@@ -2392,8 +2466,12 @@ def get_or_create_agent_for_session(
         if agent_id in agents:
             return agents[agent_id]
 
-    # Generate unique agent ID from session
-    agent_id = generate_agent_id_for_session(session)
+    directory = cast(str, session.get("directory", ""))
+
+    # Try to get the actual agent from the session's most recent message
+    detected_agent = get_agent_from_session_messages(session_id)
+    # Use detected agent, or fall back to session slug/ID
+    agent_id = detected_agent or generate_agent_id_for_session(session)
 
     # Handle conflicts by appending session ID fragment
     if agent_id in agents and agents[agent_id].get("sessionId") != session_id:
@@ -2519,7 +2597,8 @@ def orient_session(
 
     # Inject minimal orientation to the agent
     orientation = format_orientation(agent, all_agents)
-    inject_message(session_id, orientation)
+    # Orientation comes from the daemon, use the target agent's ID as context
+    inject_message(session_id, orientation, agent=agent_id)
 
     # Notify coordinator of new agent (coordinator will reach out to capture task)
     notify_coordinator_new_agent(cast(str, agent_id), cast(str, directory))
@@ -2593,7 +2672,7 @@ def check_orientation_retries(agents: dict[str, dict[str, Any]]) -> None:
             agent or {"id": agent_id, "projectPath": ""},
             agents,
         )
-        inject_message(session_id, orientation)
+        inject_message(session_id, orientation, agent=agent_id)
         pending["retries"] = retries + 1
         pending["oriented_at"] = now  # Reset timer for next retry window
         metrics.inc("agent_hub_orientation_retries_total")
@@ -2795,9 +2874,13 @@ def process_message_file(path: Path, agents: dict[str, dict[str, Any]]) -> None:
         )
         if matching_sessions:
             notification = format_notification(msg, cast(str, agent["id"]))
+            # Use the target agent's ID so the message is handled by their configured agent
+            target_agent_id = cast(str, agent["id"])
             for session in matching_sessions:
-                log.info(f"Injecting message into session {session['id']} for agent {agent['id']}")
-                inject_message(cast(str, session["id"]), notification)
+                log.info(
+                    f"Injecting message into session {session['id']} for agent {target_agent_id}"
+                )
+                inject_message(cast(str, session["id"]), notification, agent=target_agent_id)
                 delivered = True
         else:
             log.info(f"No session found for agent {agent['id']}")
@@ -3115,6 +3198,7 @@ Examples:
     log.info(f"Watching agents: {AGENTS_DIR}")
     log.info(f"OpenCode API: {OPENCODE_URL}")
     log.info(f"Message TTL: {MESSAGE_TTL_SECONDS}s, GC interval: {GC_INTERVAL_SECONDS}s")
+    log.info("Agent detection: enabled (detects agent from session messages)")
     if COORDINATOR_ENABLED:
         log.info(f"Coordinator: enabled, dir={COORDINATOR_DIR}")
     else:

opencode_agent_hub-1.4.1/tests/test_agent_detection.py

@@ -0,0 +1,426 @@
+"""Tests for agent detection from SQLite database."""
+
+import json
+import sqlite3
+import tempfile
+from pathlib import Path
+from unittest import mock
+
+
+def test_get_agent_from_session_messages_returns_agent() -> None:
+    """Verify agent is extracted from most recent message."""
+    from opencode_agent_hub import daemon
+
+    with tempfile.TemporaryDirectory() as tmpdir:
+        # Create a test database
+        db_path = Path(tmpdir) / "opencode.db"
+        conn = sqlite3.connect(str(db_path))
+        conn.execute("""
+            CREATE TABLE message (
+                id TEXT PRIMARY KEY,
+                session_id TEXT NOT NULL,
+                time_created INTEGER NOT NULL,
+                data TEXT NOT NULL
+            )
+        """)
+
+        # Insert a message with agent
+        message_data = json.dumps(
+            {"role": "assistant", "agent": "claude", "modelID": "claude-3-sonnet"}
+        )
+        conn.execute(
+            "INSERT INTO message VALUES (?, ?, ?, ?)",
+            ("msg_123", "ses_test", 1700000000000, message_data),
+        )
+        conn.commit()
+        conn.close()
+
+        # Mock the database path
+        original_path = daemon.OPENCODE_DB_PATH
+        daemon.OPENCODE_DB_PATH = db_path
+
+        try:
+            agent = daemon.get_agent_from_session_messages("ses_test")
+            assert agent == "claude"
+        finally:
+            daemon.OPENCODE_DB_PATH = original_path
+
+
+def test_get_agent_from_session_messages_no_messages() -> None:
+    """Verify None returned when session has no messages."""
+    from opencode_agent_hub import daemon
+
+    with tempfile.TemporaryDirectory() as tmpdir:
+        db_path = Path(tmpdir) / "opencode.db"
+        conn = sqlite3.connect(str(db_path))
+        conn.execute("""
+            CREATE TABLE message (
+                id TEXT PRIMARY KEY,
+                session_id TEXT NOT NULL,
+                time_created INTEGER NOT NULL,
+                data TEXT NOT NULL
+            )
+        """)
+        conn.commit()
+        conn.close()
+
+        original_path = daemon.OPENCODE_DB_PATH
+        daemon.OPENCODE_DB_PATH = db_path
+
+        try:
+            agent = daemon.get_agent_from_session_messages("ses_empty")
+            assert agent is None
+        finally:
+            daemon.OPENCODE_DB_PATH = original_path
+
+
+def test_get_agent_from_session_messages_db_missing() -> None:
+    """Verify None returned when database doesn't exist."""
+    from opencode_agent_hub import daemon
+
+    original_path = daemon.OPENCODE_DB_PATH
+    daemon.OPENCODE_DB_PATH = Path("/nonexistent/opencode.db")
+
+    try:
+        agent = daemon.get_agent_from_session_messages("ses_test")
+        assert agent is None
+    finally:
+        daemon.OPENCODE_DB_PATH = original_path
+
+
+def test_get_agent_from_session_messages_missing_agent_field() -> None:
+    """Verify None returned when message has no agent field."""
+    from opencode_agent_hub import daemon
+
+    with tempfile.TemporaryDirectory() as tmpdir:
+        db_path = Path(tmpdir) / "opencode.db"
+        conn = sqlite3.connect(str(db_path))
+        conn.execute("""
+            CREATE TABLE message (
+                id TEXT PRIMARY KEY,
+                session_id TEXT NOT NULL,
+                time_created INTEGER NOT NULL,
+                data TEXT NOT NULL
+            )
+        """)
+
+        # Insert message without agent field
+        message_data = json.dumps({"role": "user", "content": "hello"})
+        conn.execute(
+            "INSERT INTO message VALUES (?, ?, ?, ?)",
+            ("msg_123", "ses_test", 1700000000000, message_data),
+        )
+        conn.commit()
+        conn.close()
+
+        original_path = daemon.OPENCODE_DB_PATH
+        daemon.OPENCODE_DB_PATH = db_path
+
+        try:
+            agent = daemon.get_agent_from_session_messages("ses_test")
+            assert agent is None
+        finally:
+            daemon.OPENCODE_DB_PATH = original_path
+
+
+def test_get_agent_from_session_messages_uses_most_recent() -> None:
+    """Verify agent from most recent message is returned."""
+    from opencode_agent_hub import daemon
+
+    with tempfile.TemporaryDirectory() as tmpdir:
+        db_path = Path(tmpdir) / "opencode.db"
+        conn = sqlite3.connect(str(db_path))
+        conn.execute("""
+            CREATE TABLE message (
+                id TEXT PRIMARY KEY,
+                session_id TEXT NOT NULL,
+                time_created INTEGER NOT NULL,
+                data TEXT NOT NULL
+            )
+        """)
+
+        # Insert older message with different agent
+        old_message = json.dumps({"role": "assistant", "agent": "gpt-4"})
+        conn.execute(
+            "INSERT INTO message VALUES (?, ?, ?, ?)",
+            ("msg_old", "ses_test", 1700000000000, old_message),
+        )
+
+        # Insert newer message with different agent
+        new_message = json.dumps({"role": "assistant", "agent": "kimi"})
+        conn.execute(
+            "INSERT INTO message VALUES (?, ?, ?, ?)",
+            ("msg_new", "ses_test", 1700000001000, new_message),
+        )
+
+        conn.commit()
+        conn.close()
+
+        original_path = daemon.OPENCODE_DB_PATH
+        daemon.OPENCODE_DB_PATH = db_path
+
+        try:
+            agent = daemon.get_agent_from_session_messages("ses_test")
+            assert agent == "kimi"  # Should return newest, not oldest
+        finally:
+            daemon.OPENCODE_DB_PATH = original_path
+
+
+def test_get_agent_from_session_messages_invalid_json() -> None:
+    """Verify None returned when message data is invalid JSON."""
+    from opencode_agent_hub import daemon
+
+    with tempfile.TemporaryDirectory() as tmpdir:
+        db_path = Path(tmpdir) / "opencode.db"
+        conn = sqlite3.connect(str(db_path))
+        conn.execute("""
+            CREATE TABLE message (
+                id TEXT PRIMARY KEY,
+                session_id TEXT NOT NULL,
+                time_created INTEGER NOT NULL,
+                data TEXT NOT NULL
+            )
+        """)
+
+        # Insert message with invalid JSON
+        conn.execute(
+            "INSERT INTO message VALUES (?, ?, ?, ?)",
+            ("msg_123", "ses_test", 1700000000000, "not valid json"),
+        )
+        conn.commit()
+        conn.close()
+
+        original_path = daemon.OPENCODE_DB_PATH
+        daemon.OPENCODE_DB_PATH = db_path
+
+        try:
+            agent = daemon.get_agent_from_session_messages("ses_test")
+            assert agent is None
+        finally:
+            daemon.OPENCODE_DB_PATH = original_path
+
+
+def test_get_agent_from_session_messages_agent_not_string() -> None:
+    """Verify None returned when agent is not a string."""
+    from opencode_agent_hub import daemon
+
+    with tempfile.TemporaryDirectory() as tmpdir:
+        db_path = Path(tmpdir) / "opencode.db"
+        conn = sqlite3.connect(str(db_path))
+        conn.execute("""
+            CREATE TABLE message (
+                id TEXT PRIMARY KEY,
+                session_id TEXT NOT NULL,
+                time_created INTEGER NOT NULL,
+                data TEXT NOT NULL
+            )
+        """)
+
+        # Insert message with agent as object (not string)
+        message_data = json.dumps({"role": "assistant", "agent": {"name": "kimi"}})
+        conn.execute(
+            "INSERT INTO message VALUES (?, ?, ?, ?)",
+            ("msg_123", "ses_test", 1700000000000, message_data),
+        )
+        conn.commit()
+        conn.close()
+
+        original_path = daemon.OPENCODE_DB_PATH
+        daemon.OPENCODE_DB_PATH = db_path
+
+        try:
+            agent = daemon.get_agent_from_session_messages("ses_test")
+            assert agent is None
+        finally:
+            daemon.OPENCODE_DB_PATH = original_path
+
+
+def test_get_agent_from_session_messages_empty_string() -> None:
+    """Verify None returned when agent is empty string."""
+    from opencode_agent_hub import daemon
+
+    with tempfile.TemporaryDirectory() as tmpdir:
+        db_path = Path(tmpdir) / "opencode.db"
+        conn = sqlite3.connect(str(db_path))
+        conn.execute("""
+            CREATE TABLE message (
+                id TEXT PRIMARY KEY,
+                session_id TEXT NOT NULL,
+                time_created INTEGER NOT NULL,
+                data TEXT NOT NULL
+            )
+        """)
+
+        # Insert message with empty agent string
+        message_data = json.dumps({"role": "assistant", "agent": ""})
+        conn.execute(
+            "INSERT INTO message VALUES (?, ?, ?, ?)",
+            ("msg_123", "ses_test", 1700000000000, message_data),
+        )
+        conn.commit()
+        conn.close()
+
+        original_path = daemon.OPENCODE_DB_PATH
+        daemon.OPENCODE_DB_PATH = db_path
+
+        try:
+            agent = daemon.get_agent_from_session_messages("ses_test")
+            assert agent is None
+        finally:
+            daemon.OPENCODE_DB_PATH = original_path
+
+
+def test_get_agent_from_session_messages_null() -> None:
+    """Verify None returned when agent is null."""
+    from opencode_agent_hub import daemon
+
+    with tempfile.TemporaryDirectory() as tmpdir:
+        db_path = Path(tmpdir) / "opencode.db"
+        conn = sqlite3.connect(str(db_path))
+        conn.execute("""
+            CREATE TABLE message (
+                id TEXT PRIMARY KEY,
+                session_id TEXT NOT NULL,
+                time_created INTEGER NOT NULL,
+                data TEXT NOT NULL
+            )
+        """)
+
+        # Insert message with null agent
+        message_data = json.dumps({"role": "assistant", "agent": None})
+        conn.execute(
+            "INSERT INTO message VALUES (?, ?, ?, ?)",
+            ("msg_123", "ses_test", 1700000000000, message_data),
+        )
+        conn.commit()
+        conn.close()
+
+        original_path = daemon.OPENCODE_DB_PATH
+        daemon.OPENCODE_DB_PATH = db_path
+
+        try:
+            agent = daemon.get_agent_from_session_messages("ses_test")
+            assert agent is None
+        finally:
+            daemon.OPENCODE_DB_PATH = original_path
+
+
+def test_get_agent_from_session_messages_db_locked() -> None:
+    """Verify None returned gracefully when database is locked."""
+    from opencode_agent_hub import daemon
+
+    # Mock sqlite3.connect to raise OperationalError
+    with mock.patch("sqlite3.connect", side_effect=sqlite3.OperationalError("database is locked")):
+        agent = daemon.get_agent_from_session_messages("ses_test")
+        assert agent is None
+
+
+def test_get_or_create_agent_uses_detected_agent_from_db() -> None:
+    """Verify agent from database is used when available."""
+    from opencode_agent_hub import daemon
+
+    with tempfile.TemporaryDirectory() as tmpdir:
+        # Set up test database with agent
+        db_path = Path(tmpdir) / "opencode.db"
+        conn = sqlite3.connect(str(db_path))
+        conn.execute("""
+            CREATE TABLE message (
+                id TEXT PRIMARY KEY,
+                session_id TEXT NOT NULL,
+                time_created INTEGER NOT NULL,
+                data TEXT NOT NULL
+            )
+        """)
+        message_data = json.dumps({"role": "assistant", "agent": "custom-agent"})
+        conn.execute(
+            "INSERT INTO message VALUES (?, ?, ?, ?)",
+            ("msg_123", "ses_test123", 1700000000000, message_data),
+        )
+        conn.commit()
+        conn.close()
+
+        original_path = daemon.OPENCODE_DB_PATH
+        daemon.OPENCODE_DB_PATH = db_path
+        daemon.SESSION_AGENTS = {}
+
+        try:
+            session = {
+                "id": "ses_test123",
+                "slug": "test-slug",
+                "directory": "/home/user/project",
+            }
+            agents: dict[str, dict] = {}
+
+            agent = daemon.get_or_create_agent_for_session(session, agents)
+
+            # Should use detected agent, not slug
+            assert agent["id"] == "custom-agent"
+            assert agent["sessionId"] == "ses_test123"
+        finally:
+            daemon.OPENCODE_DB_PATH = original_path
+            daemon.SESSION_AGENTS = {}
+
+
+def test_get_or_create_agent_falls_back_to_slug_when_no_db_agent() -> None:
+    """Verify slug is used when no agent in database."""
+    from opencode_agent_hub import daemon
+
+    with tempfile.TemporaryDirectory() as tmpdir:
+        # Empty database - no messages
+        db_path = Path(tmpdir) / "opencode.db"
+        conn = sqlite3.connect(str(db_path))
+        conn.execute("""
+            CREATE TABLE message (
+                id TEXT PRIMARY KEY,
+                session_id TEXT NOT NULL,
+                time_created INTEGER NOT NULL,
+                data TEXT NOT NULL
+            )
+        """)
+        conn.commit()
+        conn.close()
+
+        original_path = daemon.OPENCODE_DB_PATH
+        daemon.OPENCODE_DB_PATH = db_path
+        daemon.SESSION_AGENTS = {}
+
+        try:
+            session = {
+                "id": "ses_test456",
+                "slug": "fallback-slug",
+                "directory": "/home/user/project",
+            }
+            agents: dict[str, dict] = {}
+
+            agent = daemon.get_or_create_agent_for_session(session, agents)
+
+            # Should fall back to slug
+            assert agent["id"] == "fallback-slug"
+        finally:
+            daemon.OPENCODE_DB_PATH = original_path
+            daemon.SESSION_AGENTS = {}
+
+
+def test_get_or_create_agent_falls_back_when_db_missing() -> None:
+    """Verify slug is used when database doesn't exist."""
+    from opencode_agent_hub import daemon
+
+    original_path = daemon.OPENCODE_DB_PATH
+    daemon.OPENCODE_DB_PATH = Path("/nonexistent/opencode.db")
+    daemon.SESSION_AGENTS = {}
+
+    try:
+        session = {
+            "id": "ses_test789",
+            "slug": "no-db-slug",
+            "directory": "/home/user/project",
+        }
+        agents: dict[str, dict] = {}
+
+        agent = daemon.get_or_create_agent_for_session(session, agents)
+
+        # Should fall back to slug
+        assert agent["id"] == "no-db-slug"
+    finally:
+        daemon.OPENCODE_DB_PATH = original_path
+        daemon.SESSION_AGENTS = {}