zwarm 1.3.10__py3-none-any.whl → 2.0.0__py3-none-any.whl

zwarm/tools/delegation.py

@@ -1,20 +1,23 @@
 """
 Delegation tools for the orchestrator.
 
-These are the core tools that orchestrators use to delegate work to executors:
-- delegate: Start a new session with an executor
-- converse: Continue a sync conversation
-- check_session: Check status of an async session
-- end_session: End a session
-
-Sessions are also registered with CodexSessionManager for unified visibility
-in `zwarm interactive`.
+These are the core tools that orchestrators use to delegate work to executors.
+They use the SAME CodexSessionManager that `zwarm interactive` uses - no special
+MCP integration, no separate code path.
+
+The orchestrator LLM has access to the exact same tools a human would use.
+
+Tools:
+- delegate: Start a new codex session
+- converse: Continue a conversation (inject follow-up message)
+- check_session: Check status of a session
+- end_session: End/kill a session
+- list_sessions: List all sessions
 """
 
 from __future__ import annotations
 
-import asyncio
-from datetime import datetime
+import time
 from pathlib import Path
 from typing import TYPE_CHECKING, Any, Literal
 
@@ -25,103 +28,44 @@ if TYPE_CHECKING:
 
 
 def _get_session_manager(orchestrator: "Orchestrator"):
-    """Get or create the CodexSessionManager for unified session tracking."""
+    """
+    Get the CodexSessionManager - the SINGLE source of truth for sessions.
+
+    Both `zwarm interactive` and `zwarm orchestrate` use the same session manager.
+    The orchestrator is just another user that happens to be an LLM.
+    """
     if not hasattr(orchestrator, "_session_manager"):
         from zwarm.sessions import CodexSessionManager
         orchestrator._session_manager = CodexSessionManager(orchestrator.working_dir / ".zwarm")
     return orchestrator._session_manager
 
 
-def _register_session_for_visibility(
-    orchestrator: "Orchestrator",
-    session_id: str,
-    task: str,
-    adapter: str,
-    model: str,
-    working_dir: Path,
-    status: str = "running",
-    pid: int | None = None,
-):
-    """
-    Register an orchestrator session with CodexSessionManager for visibility.
-
-    This allows `zwarm interactive` to show orchestrator-delegated sessions
-    in its unified dashboard.
+def _wait_for_completion(manager, session_id: str, timeout: float = 300.0, poll_interval: float = 1.0) -> bool:
     """
-    from zwarm.sessions import CodexSession, SessionStatus, SessionMessage
-
-    manager = _get_session_manager(orchestrator)
-    now = datetime.now().isoformat()
-
-    # Map status
-    status_map = {
-        "running": SessionStatus.RUNNING,
-        "active": SessionStatus.RUNNING,
-        "completed": SessionStatus.COMPLETED,
-        "failed": SessionStatus.FAILED,
-    }
-
-    session = CodexSession(
-        id=session_id,
-        task=task,
-        status=status_map.get(status, SessionStatus.RUNNING),
-        working_dir=working_dir,
-        created_at=now,
-        updated_at=now,
-        model=model or "unknown",
-        pid=pid,
-        source=f"orchestrator:{orchestrator.instance_id or 'unknown'}",
-        adapter=adapter,
-        messages=[SessionMessage(role="user", content=task, timestamp=now)],
-    )
-
-    # Save to disk
-    manager._save_session(session)
-    return session
-
+    Wait for a session to complete.
 
-def _update_session_visibility(
-    orchestrator: "Orchestrator",
-    session_id: str,
-    status: str | None = None,
-    messages: list | None = None,
-    token_usage: dict | None = None,
-    error: str | None = None,
-):
-    """Update a session's visibility record."""
-    manager = _get_session_manager(orchestrator)
-    session = manager._load_session(session_id)
-
-    if not session:
-        return
-
-    from zwarm.sessions import SessionStatus, SessionMessage
-
-    if status:
-        status_map = {
-            "running": SessionStatus.RUNNING,
-            "active": SessionStatus.RUNNING,
-            "completed": SessionStatus.COMPLETED,
-            "failed": SessionStatus.FAILED,
-        }
-        session.status = status_map.get(status, session.status)
+    Args:
+        manager: CodexSessionManager
+        session_id: Session to wait for
+        timeout: Max seconds to wait
+        poll_interval: Seconds between polls
 
-    if messages:
-        for msg in messages:
-            if hasattr(msg, "role") and hasattr(msg, "content"):
-                session.messages.append(SessionMessage(
-                    role=msg.role,
-                    content=msg.content,
-                    timestamp=datetime.now().isoformat(),
-                ))
+    Returns:
+        True if completed, False if timed out
+    """
+    start = time.time()
+    while time.time() - start < timeout:
+        session = manager.get_session(session_id)
+        if not session:
+            return False
 
-    if token_usage:
-        session.token_usage = token_usage
+        # Check if process is still running
+        if not session.is_running:
+            return True
 
-    if error:
-        session.error = error
+        time.sleep(poll_interval)
 
-    manager._save_session(session)
+    return False
 
 
 def _truncate(text: str, max_len: int = 200) -> str:
@@ -131,9 +75,9 @@ def _truncate(text: str, max_len: int = 200) -> str:
     return text[:max_len - 3] + "..."
 
 
-def _format_session_header(session_id: str, adapter: str, mode: str) -> str:
+def _format_session_header(session) -> str:
     """Format a nice session header."""
-    return f"[{session_id[:8]}] {adapter} ({mode})"
+    return f"[{session.short_id}] codex ({session.status.value})"
 
 
 def _validate_working_dir(
@@ -200,30 +144,27 @@ def delegate(
     self: "Orchestrator",
     task: str,
     mode: Literal["sync", "async"] = "sync",
-    adapter: str | None = None,
     model: str | None = None,
     working_dir: str | None = None,
 ) -> dict[str, Any]:
     """
-    Delegate work to an executor agent.
+    Delegate work to a Codex agent.
 
-    Use this to assign coding tasks to an executor. Two modes available:
+    This spawns a codex session - the exact same way `zwarm interactive` does.
+    Two modes available:
 
-    **sync** (default): Start a conversation with the executor.
-    You can iteratively refine requirements using converse().
-    Best for: ambiguous tasks, complex requirements, tasks needing guidance.
+    **sync** (default): Wait for codex to complete, then return the response.
+    Best for: most tasks - you get the full response immediately.
 
     **async**: Fire-and-forget execution.
     Check progress later with check_session().
-    Best for: clear self-contained tasks, parallel work.
+    Best for: long-running tasks, parallel work.
 
     Args:
         task: Clear description of what to do. Be specific about requirements.
-        mode: "sync" for conversational, "async" for fire-and-forget.
-        adapter: Which executor adapter to use (default: config setting).
-        model: Model override for the executor.
-        working_dir: Directory for the executor to work in (default: orchestrator's dir).
-                    NOTE: May be restricted by orchestrator.allowed_dirs config.
+        mode: "sync" to wait for completion, "async" for fire-and-forget.
+        model: Model override (default: gpt-5.1-codex-mini).
+        working_dir: Directory for codex to work in (default: orchestrator's dir).
 
     Returns:
         {session_id, status, response (if sync)}
@@ -232,7 +173,7 @@ def delegate(
         delegate(task="Add a logout button to the navbar", mode="sync")
         # Then use converse() to refine: "Also add a confirmation dialog"
     """
-    # Validate working directory against allowed_dirs config
+    # Validate working directory
     effective_dir, dir_error = _validate_working_dir(
         working_dir,
         self.working_dir,
@@ -246,92 +187,69 @@ def delegate(
             "hint": "Use the default working directory or ask user to update allowed_dirs config",
         }
 
-    # Get adapter (use default from config if not specified)
-    adapter_name = adapter or self.config.executor.adapter
-    executor = self._get_adapter(adapter_name)
-
-    # Run async start_session
-    session = asyncio.run(
-        executor.start_session(
-            task=task,
-            working_dir=effective_dir,
-            mode=mode,
-            model=model or self.config.executor.model,
-            sandbox=self.config.executor.sandbox,
-        )
-    )
+    # Get the session manager (same one zwarm interactive uses)
+    manager = _get_session_manager(self)
 
-    # Track session
-    self._sessions[session.id] = session
-    self.state.add_session(session)
+    # Determine model
+    effective_model = model or self.config.executor.model or "gpt-5.1-codex-mini"
 
-    # Register for unified visibility in zwarm interactive
-    _register_session_for_visibility(
-        orchestrator=self,
-        session_id=session.id,
+    # Determine sandbox mode
+    sandbox = self.config.executor.sandbox or "workspace-write"
+
+    # Start the session using CodexSessionManager
+    # This is the SAME method that `zwarm interactive` uses
+    session = manager.start_session(
         task=task,
-        adapter=adapter_name,
-        model=model or self.config.executor.model,
         working_dir=effective_dir,
-        status="running" if mode == "async" else "active",
-        pid=getattr(session, "process", None) and session.process.pid,
+        model=effective_model,
+        sandbox=sandbox,
+        source=f"orchestrator:{self.instance_id or 'default'}",
+        adapter="codex",
     )
 
-    # Log events
-    from zwarm.core.models import event_session_started, event_message_sent, Message
-    self.state.log_event(event_session_started(session))
-    self.state.log_event(event_message_sent(session, Message(role="user", content=task)))
-
-    # Get response for sync mode
-    response_text = ""
-    if mode == "sync" and session.messages:
-        response_text = session.messages[-1].content
-        # Log the assistant response too
-        self.state.log_event(event_message_sent(
-            session,
-            Message(role="assistant", content=response_text)
-        ))
-
-    # Log delegation result for debugging
-    from zwarm.core.models import Event
-    self.state.log_event(Event(
-        kind="delegation_result",
-        payload={
-            "session_id": session.id,
-            "mode": mode,
-            "adapter": adapter_name,
-            "response_length": len(response_text),
-            "response_preview": response_text[:500] if response_text else "(empty)",
-            "message_count": len(session.messages),
-        },
-    ))
+    # For sync mode, wait for completion
+    if mode == "sync":
+        completed = _wait_for_completion(
+            manager,
+            session.id,
+            timeout=self.config.executor.timeout or 300.0,
+        )
 
-    # Build nice result
-    header = _format_session_header(session.id, adapter_name, mode)
+        # Refresh session to get updated status and messages
+        session = manager.get_session(session.id)
+
+        if not completed:
+            return {
+                "success": False,
+                "session_id": session.id,
+                "status": "timeout",
+                "error": "Session timed out waiting for codex to complete",
+                "hint": "Use check_session() to monitor progress, or use async mode for long tasks",
+            }
+
+        # Get the response from messages
+        response_text = ""
+        messages = manager.get_messages(session.id)
+        for msg in messages:
+            if msg.role == "assistant":
+                response_text = msg.content
+                break  # Take first assistant message
 
-    if mode == "sync":
-        result = {
+        return {
             "success": True,
-            "session": header,
+            "session": _format_session_header(session),
             "session_id": session.id,
-            "status": "active",
+            "status": session.status.value,
             "task": _truncate(task, 100),
-            "response": response_text,
+            "response": response_text or "(no response captured)",
             "tokens": session.token_usage.get("total_tokens", 0),
-            "hint": "Use converse(session_id, message) to continue this conversation",
+            "hint": "Use converse(session_id, message) to send follow-up messages",
         }
-        # Warn if no conversation ID - converse() won't work
-        if not session.conversation_id:
-            result["warning"] = "no_conversation_id"
-            result["hint"] = (
-                "WARNING: MCP didn't return a conversation ID. "
-                "You cannot use converse() - send all instructions upfront or use async mode."
-            )
-        return result
     else:
+        # Async mode - return immediately
         return {
             "success": True,
-            "session": header,
+            "session": _format_session_header(session),
             "session_id": session.id,
             "status": "running",
             "task": _truncate(task, 100),
@@ -344,28 +262,41 @@ def converse(
     self: "Orchestrator",
     session_id: str,
     message: str,
+    wait: bool = True,
 ) -> dict[str, Any]:
     """
-    Continue a sync conversation with an executor.
+    Continue a conversation with a codex session.
+
+    This injects a follow-up message into the session, providing the
+    conversation history as context. Like chatting with a developer.
 
-    Use this to iteratively refine requirements, ask for changes,
-    or guide the executor step-by-step. Like chatting with a developer.
+    Two modes:
+    - **wait=True** (default): Wait for codex to respond before returning.
+    - **wait=False**: Fire-and-forget. Message sent, codex runs in background.
+      Use check_session() later to see the response.
 
     Args:
         session_id: The session to continue (from delegate() result).
-        message: Your next message to the executor.
+        message: Your next message to codex.
+        wait: If True, wait for response. If False, return immediately.
 
     Returns:
-        {session_id, response, turn}
+        {session_id, response (if wait=True), turn}
 
-    Example:
+    Example (sync):
         result = delegate(task="Add user authentication")
-        # Executor responds with initial plan
-        converse(session_id=result["session_id"], message="Use JWT, not sessions")
-        # Executor adjusts approach
-        converse(session_id=result["session_id"], message="Now add tests")
+        converse(session_id=result["session_id"], message="Use JWT")
+        # Returns with response
+
+    Example (async - managing multiple sessions):
+        converse(session_id="abc123", message="Add tests", wait=False)
+        converse(session_id="def456", message="Fix bug", wait=False)
+        # Both running in parallel, check later with check_session()
     """
-    session = self._sessions.get(session_id)
+    manager = _get_session_manager(self)
+
+    # Get current session
+    session = manager.get_session(session_id)
     if not session:
         return {
             "success": False,
@@ -373,91 +304,84 @@ def converse(
             "hint": "Use list_sessions() to see available sessions",
         }
 
-    if session.mode.value != "sync":
+    # Check if session is in a conversable state
+    from zwarm.sessions import SessionStatus
+    if session.status == SessionStatus.RUNNING:
         return {
             "success": False,
-            "error": "Cannot converse with async session",
-            "hint": "Use check_session() for async sessions instead",
+            "error": "Session is still running",
+            "hint": "Wait for the current task to complete, or use check_session() to monitor",
         }
 
-    if session.status.value != "active":
+    if session.status == SessionStatus.KILLED:
         return {
             "success": False,
-            "error": f"Session is {session.status.value}, not active",
+            "error": "Session was killed",
             "hint": "Start a new session with delegate()",
         }
 
-    # Check for stale/missing conversation_id (common after resume)
-    if not session.conversation_id:
+    # Inject the follow-up message
+    # This uses CodexSessionManager.inject_message() which:
+    # 1. Builds context from previous messages
+    # 2. Starts a new turn with the context + new message (background process)
+    updated_session = manager.inject_message(session_id, message)
+
+    if not updated_session:
         return {
             "success": False,
-            "error": "Session has no conversation ID (likely stale after resume)",
-            "hint": (
-                "This session's conversation was lost (MCP server restarted). "
-                "Use end_session() to close it, then delegate() a new task."
-            ),
+            "error": "Failed to inject message",
             "session_id": session_id,
         }
 
-    # Get adapter and send message
-    executor = self._get_adapter(session.adapter)
-    try:
-        response = asyncio.run(
-            executor.send_message(session, message)
-        )
-    except Exception as e:
+    if not wait:
+        # Async mode - return immediately
         return {
-            "success": False,
-            "error": str(e),
+            "success": True,
+            "session": _format_session_header(updated_session),
             "session_id": session_id,
+            "turn": updated_session.turn,
+            "status": "running",
+            "you_said": _truncate(message, 100),
+            "hint": "Use check_session(session_id) to see the response when ready",
         }
 
-    # Update state
-    self.state.update_session(session)
-
-    # Update visibility record
-    from zwarm.core.models import Message
-    _update_session_visibility(
-        orchestrator=self,
-        session_id=session_id,
-        messages=[Message(role="user", content=message), Message(role="assistant", content=response)],
-        token_usage=session.token_usage,
+    # Sync mode - wait for completion
+    completed = _wait_for_completion(
+        manager,
+        session_id,
+        timeout=self.config.executor.timeout or 300.0,
     )
 
-    # Log both messages
-    from zwarm.core.models import event_message_sent
-    self.state.log_event(event_message_sent(session, Message(role="user", content=message)))
-    self.state.log_event(event_message_sent(session, Message(role="assistant", content=response)))
+    # Refresh session
+    session = manager.get_session(session_id)
 
-    # Calculate turn number
-    turn = len([m for m in session.messages if m.role == "user"])
-    header = _format_session_header(session.id, session.adapter, session.mode.value)
+    if not completed:
+        return {
+            "success": False,
+            "session_id": session_id,
+            "status": "timeout",
+            "error": "Session timed out waiting for response",
+            "hint": "Use check_session() to monitor progress",
+        }
 
-    # Check for conversation loss (indicated by error in response)
-    conversation_lost = (
-        "[ERROR] Conversation lost" in response
-        or session.conversation_id is None
-    )
+    # Get the response (last assistant message)
+    response_text = ""
+    messages = manager.get_messages(session_id)
+    for msg in reversed(messages):
+        if msg.role == "assistant":
+            response_text = msg.content
+            break
 
-    result = {
+    return {
         "success": True,
-        "session": header,
+        "session": _format_session_header(session),
         "session_id": session_id,
-        "turn": turn,
+        "turn": session.turn,
         "you_said": _truncate(message, 100),
-        "response": response,
+        "response": response_text or "(no response captured)",
         "tokens": session.token_usage.get("total_tokens", 0),
     }
 
-    if conversation_lost:
-        result["warning"] = "conversation_lost"
-        result["hint"] = (
-            "The MCP server lost this conversation. You should end_session() "
-            "and delegate() a new task with the full context."
-        )
-
-    return result
-
 
 @weaveTool
 def check_session(
@@ -467,16 +391,20 @@ def check_session(
     """
     Check the status of a session.
 
-    For async sessions: Check if the executor has finished.
-    For sync sessions: Get current status and message count.
+    Use this to:
+    - Check if an async session has finished
+    - Get current status and message count
+    - View the latest response
 
     Args:
         session_id: The session to check.
 
     Returns:
-        {session_id, status, ...}
+        {session_id, status, messages, response}
     """
-    session = self._sessions.get(session_id)
+    manager = _get_session_manager(self)
+
+    session = manager.get_session(session_id)
     if not session:
         return {
             "success": False,
@@ -484,33 +412,65 @@ def check_session(
             "hint": "Use list_sessions() to see available sessions",
         }
 
-    executor = self._get_adapter(session.adapter)
-    status = asyncio.run(
-        executor.check_status(session)
-    )
+    # Get latest response
+    response_text = ""
+    messages = manager.get_messages(session_id)
+    for msg in reversed(messages):
+        if msg.role == "assistant":
+            response_text = msg.content
+            break
+
+    return {
+        "success": True,
+        "session": _format_session_header(session),
+        "session_id": session_id,
+        "status": session.status.value,
+        "is_running": session.is_running,
+        "turn": session.turn,
+        "message_count": len(messages),
+        "task": _truncate(session.task, 80),
+        "response": _truncate(response_text, 500) if response_text else "(no response yet)",
+        "tokens": session.token_usage.get("total_tokens", 0),
+        "runtime": session.runtime,
+    }
 
-    # Update state if status changed
-    self.state.update_session(session)
 
-    # Sync visibility record
-    _update_session_visibility(
-        orchestrator=self,
-        session_id=session_id,
-        status=session.status.value,
-        token_usage=session.token_usage,
-    )
+@weaveTool
+def peek_session(
+    self: "Orchestrator",
+    session_id: str,
+) -> dict[str, Any]:
+    """
+    Quick peek at a session - minimal info for fast polling.
+
+    Returns just status and latest message. Use check_session() for full details.
+
+    Args:
+        session_id: The session to peek at.
+
+    Returns:
+        {session_id, status, latest_message}
+    """
+    manager = _get_session_manager(self)
+
+    session = manager.get_session(session_id)
+    if not session:
+        return {"success": False, "error": f"Unknown session: {session_id}"}
 
-    header = _format_session_header(session.id, session.adapter, session.mode.value)
+    # Get latest assistant message only
+    latest = ""
+    messages = manager.get_messages(session_id)
+    for msg in reversed(messages):
+        if msg.role == "assistant":
+            latest = msg.content.replace("\n", " ")
+            break
 
     return {
         "success": True,
-        "session": header,
-        "session_id": session_id,
-        "mode": session.mode.value,
+        "session_id": session.short_id,
         "status": session.status.value,
-        "messages": len(session.messages),
-        "task": _truncate(session.task_description, 80),
-        **status,
+        "is_running": session.status.value == "running",
+        "latest_message": _truncate(latest, 150) if latest else None,
     }
 
 
@@ -518,72 +478,65 @@ def check_session(
 def end_session(
     self: "Orchestrator",
     session_id: str,
-    verdict: Literal["completed", "failed", "cancelled"] = "completed",
-    summary: str | None = None,
+    reason: str | None = None,
+    delete: bool = False,
 ) -> dict[str, Any]:
     """
-    End a session with a verdict.
+    End/kill a session.
 
     Call this when:
-    - Task is done (verdict="completed")
-    - Task failed and you're giving up (verdict="failed")
-    - You want to stop early (verdict="cancelled")
+    - You want to stop a running session
+    - Clean up a completed session
+    - Cancel a task
 
     Args:
         session_id: The session to end.
-        verdict: How the session ended.
-        summary: Optional summary of what was accomplished.
+        reason: Optional reason for ending.
+        delete: If True, delete session entirely (removes from list_sessions).
 
     Returns:
-        {session_id, status, summary}
+        {session_id, status}
     """
-    session = self._sessions.get(session_id)
+    manager = _get_session_manager(self)
+
+    session = manager.get_session(session_id)
     if not session:
         return {
             "success": False,
             "error": f"Unknown session: {session_id}",
         }
 
-    # Stop the session if still running
-    if session.status.value == "active":
-        executor = self._get_adapter(session.adapter)
-        if verdict == "completed":
-            session.complete(summary)
-        else:
-            asyncio.run(executor.stop(session))
-            if verdict == "failed":
-                session.fail(summary)
-            else:
-                session.fail(f"Cancelled: {summary}" if summary else "Cancelled")
-
-    # Update state
-    self.state.update_session(session)
-
-    # Update visibility record
-    _update_session_visibility(
-        orchestrator=self,
-        session_id=session_id,
-        status=verdict,
-        token_usage=session.token_usage,
-        error=summary if verdict == "failed" else None,
-    )
+    # If delete requested, remove entirely
+    if delete:
+        deleted = manager.delete_session(session_id)
+        return {
+            "success": deleted,
+            "session_id": session_id,
+            "status": "deleted",
+            "reason": reason or "deleted by orchestrator",
+        }
 
-    # Log event
-    from zwarm.core.models import event_session_completed
-    self.state.log_event(event_session_completed(session))
+    # Kill if still running
+    if session.is_running:
+        killed = manager.kill_session(session_id)
+        if not killed:
+            return {
+                "success": False,
+                "error": "Failed to kill session",
+                "session_id": session_id,
+            }
 
-    header = _format_session_header(session.id, session.adapter, session.mode.value)
-    verdict_icon = {"completed": "✓", "failed": "✗", "cancelled": "○"}.get(verdict, "?")
+        # Refresh
+        session = manager.get_session(session_id)
 
     return {
         "success": True,
-        "session": header,
+        "session": _format_session_header(session),
         "session_id": session_id,
-        "verdict": f"{verdict_icon} {verdict}",
-        "summary": session.exit_message or "(no summary)",
-        "total_turns": len([m for m in session.messages if m.role == "user"]),
-        "total_tokens": session.token_usage.get("total_tokens", 0),
-        "token_usage": session.token_usage,
+        "status": session.status.value,
+        "reason": reason or "ended by orchestrator",
+        "turn": session.turn,
+        "tokens": session.token_usage.get("total_tokens", 0),
     }
 
 
@@ -595,36 +548,115 @@ def list_sessions(
     """
     List all sessions, optionally filtered by status.
 
+    Returns rich information about each session including:
+    - Status (running/completed/failed)
+    - Last update time (for detecting changes)
+    - Last message preview (quick peek at response)
+    - Whether it's recently updated (needs_attention flag)
+
+    Use this to monitor multiple parallel sessions and see which
+    ones have new responses.
+
     Args:
-        status: Filter by status ("active", "completed", "failed").
+        status: Filter by status ("running", "completed", "failed", "killed").
 
     Returns:
-        {sessions: [...], count}
+        {sessions: [...], count, running, completed, needs_attention}
     """
-    sessions = self.state.list_sessions(status=status)
+    from datetime import datetime
+
+    manager = _get_session_manager(self)
+
+    # Map string status to enum
+    from zwarm.sessions import SessionStatus
+    status_filter = None
+    if status:
+        status_map = {
+            "running": SessionStatus.RUNNING,
+            "completed": SessionStatus.COMPLETED,
+            "failed": SessionStatus.FAILED,
+            "killed": SessionStatus.KILLED,
+            "pending": SessionStatus.PENDING,
+        }
+        status_filter = status_map.get(status.lower())
+
+    sessions = manager.list_sessions(status=status_filter)
+
+    def time_ago(iso_str: str) -> tuple[str, float]:
+        """Convert ISO timestamp to ('Xm ago', seconds)."""
+        try:
+            dt = datetime.fromisoformat(iso_str)
+            delta = datetime.now() - dt
+            secs = delta.total_seconds()
+            if secs < 60:
+                return f"{int(secs)}s ago", secs
+            elif secs < 3600:
+                return f"{int(secs/60)}m ago", secs
+            elif secs < 86400:
+                return f"{secs/3600:.1f}h ago", secs
+            else:
+                return f"{secs/86400:.1f}d ago", secs
+        except:
+            return "?", 999999
 
     session_list = []
+    needs_attention_count = 0
+
     for s in sessions:
         status_icon = {
-            "active": "●",
+            "running": "●",
             "completed": "✓",
             "failed": "✗",
+            "killed": "○",
+            "pending": "◌",
         }.get(s.status.value, "?")
 
+        updated_str, updated_secs = time_ago(s.updated_at)
+
+        # Get last assistant message
+        messages = manager.get_messages(s.id)
+        last_message = ""
+        for msg in reversed(messages):
+            if msg.role == "assistant":
+                last_message = msg.content.replace("\n", " ")
+                break
+
+        # Flag sessions that need attention:
+        # - Recently completed (< 60s)
+        # - Failed
+        is_recent = updated_secs < 60
+        needs_attention = (
+            (s.status == SessionStatus.COMPLETED and is_recent) or
+            s.status == SessionStatus.FAILED
+        )
+        if needs_attention:
+            needs_attention_count += 1
+
         session_list.append({
-            "id": s.id[:8] + "...",
+            "id": s.short_id,
             "full_id": s.id,
             "status": f"{status_icon} {s.status.value}",
-            "adapter": s.adapter,
-            "mode": s.mode.value,
-            "task": _truncate(s.task_description, 60),
-            "turns": len([m for m in s.messages if m.role == "user"]),
+            "is_running": s.status == SessionStatus.RUNNING,
+            "task": _truncate(s.task, 50),
+            "turn": s.turn,
+            "updated": updated_str,
+            "updated_secs": int(updated_secs),
+            "last_message": _truncate(last_message, 100) if last_message else "(no response yet)",
+            "needs_attention": needs_attention,
             "tokens": s.token_usage.get("total_tokens", 0),
         })
 
+    # Summary counts
+    running_count = sum(1 for s in sessions if s.status == SessionStatus.RUNNING)
+    completed_count = sum(1 for s in sessions if s.status == SessionStatus.COMPLETED)
+
     return {
         "success": True,
         "sessions": session_list,
         "count": len(sessions),
+        "running": running_count,
+        "completed": completed_count,
+        "needs_attention": needs_attention_count,
         "filter": status or "all",
+        "hint": "Sessions with needs_attention=True have new responses to review" if needs_attention_count else None,
     }