loki-mode 6.3.1 → 6.4.0

package/SKILL.md

@@ -3,7 +3,7 @@ name: loki-mode
 description: Multi-agent autonomous startup system. Triggers on "Loki Mode". Takes PRD to deployed product with minimal human intervention. Requires --dangerously-skip-permissions flag.
 ---
 
-# Loki Mode v6.3.1
+# Loki Mode v6.4.0
 
 **You are an autonomous agent. You make decisions. You do not ask questions. You do not stop.**
 
@@ -263,4 +263,4 @@ The following features are documented in skill modules but not yet fully automat
 | Quality gates 3-reviewer system | Implemented (v5.35.0) | 5 specialist reviewers in `skills/quality-gates.md`; execution in run.sh |
 | Benchmarks (HumanEval, SWE-bench) | Infrastructure only | Runner scripts and datasets exist in `benchmarks/`; no published results |
 
-**v6.3.1 | [Autonomi](https://www.autonomi.dev/) flagship product | ~260 lines core**
+**v6.4.0 | [Autonomi](https://www.autonomi.dev/) flagship product | ~260 lines core**

package/VERSION

@@ -1 +1 @@
-6.3.1
+6.4.0

package/autonomy/loki

@@ -806,8 +806,35 @@ cmd_start() {
 }
 
 # Check if session is running
+# Usage: is_session_running [session_id]
+# Without args: returns true if ANY session (global or per-session) is running
+# With session_id: returns true only if that specific session is running
 is_session_running() {
-    # Check both possible PID files (loki.pid from run.sh, run.pid legacy)
+    local target_session="${1:-}"
+
+    if [ -n "$target_session" ]; then
+        # Check specific session
+        local session_pid_file="$LOKI_DIR/sessions/$target_session/loki.pid"
+        if [ -f "$session_pid_file" ]; then
+            local pid
+            pid=$(cat "$session_pid_file" 2>/dev/null)
+            if [ -n "$pid" ] && kill -0 "$pid" 2>/dev/null; then
+                return 0
+            fi
+        fi
+        # Also check legacy per-run PID file (run-<number>.pid)
+        local run_pid_file="$LOKI_DIR/run-${target_session}.pid"
+        if [ -f "$run_pid_file" ]; then
+            local pid
+            pid=$(cat "$run_pid_file" 2>/dev/null)
+            if [ -n "$pid" ] && kill -0 "$pid" 2>/dev/null; then
+                return 0
+            fi
+        fi
+        return 1
+    fi
+
+    # Check global PID files (loki.pid from run.sh, run.pid legacy)
     local pid_files=("$LOKI_DIR/loki.pid" "$LOKI_DIR/run.pid")
     for pid_file in "${pid_files[@]}"; do
         if [ -f "$pid_file" ]; then
@@ -818,15 +845,151 @@ is_session_running() {
             fi
         fi
     done
+
+    # Check per-session PIDs
+    if [ -d "$LOKI_DIR/sessions" ]; then
+        for session_dir in "$LOKI_DIR/sessions"/*/; do
+            [ -d "$session_dir" ] || continue
+            local pid_file="${session_dir}loki.pid"
+            if [ -f "$pid_file" ]; then
+                local pid
+                pid=$(cat "$pid_file" 2>/dev/null)
+                if [ -n "$pid" ] && kill -0 "$pid" 2>/dev/null; then
+                    return 0
+                fi
+            fi
+        done
+    fi
     return 1
 }
 
-# Stop execution immediately
+# List all running session IDs
+list_running_sessions() {
+    local sessions=()
+    # Check global session
+    if [ -f "$LOKI_DIR/loki.pid" ]; then
+        local pid
+        pid=$(cat "$LOKI_DIR/loki.pid" 2>/dev/null)
+        if [ -n "$pid" ] && kill -0 "$pid" 2>/dev/null; then
+            sessions+=("global:$pid")
+        fi
+    fi
+    # Check per-session PIDs
+    if [ -d "$LOKI_DIR/sessions" ]; then
+        for session_dir in "$LOKI_DIR/sessions"/*/; do
+            [ -d "$session_dir" ] || continue
+            local sid pid_file pid
+            sid=$(basename "$session_dir")
+            pid_file="${session_dir}loki.pid"
+            if [ -f "$pid_file" ]; then
+                pid=$(cat "$pid_file" 2>/dev/null)
+                if [ -n "$pid" ] && kill -0 "$pid" 2>/dev/null; then
+                    sessions+=("$sid:$pid")
+                fi
+            fi
+        done
+    fi
+    # Check legacy run-*.pid files
+    for run_pid_file in "$LOKI_DIR"/run-*.pid; do
+        [ -f "$run_pid_file" ] || continue
+        local sid pid
+        sid=$(basename "$run_pid_file" .pid)
+        sid="${sid#run-}"
+        pid=$(cat "$run_pid_file" 2>/dev/null)
+        if [ -n "$pid" ] && kill -0 "$pid" 2>/dev/null; then
+            # Avoid duplicates (if also in sessions/)
+            local dup=false
+            for s in "${sessions[@]}"; do
+                if [[ "$s" == "$sid:"* ]]; then dup=true; break; fi
+            done
+            if ! $dup; then
+                sessions+=("$sid:$pid")
+            fi
+        fi
+    done
+    printf '%s\n' "${sessions[@]}"
+}
+
+# Kill a PID with SIGTERM, wait, then SIGKILL if needed
+_kill_pid() {
+    local pid="$1"
+    pkill -P "$pid" 2>/dev/null || true
+    kill "$pid" 2>/dev/null || true
+    sleep 1
+    if kill -0 "$pid" 2>/dev/null; then
+        pkill -9 -P "$pid" 2>/dev/null || true
+        kill -9 "$pid" 2>/dev/null || true
+    fi
+}
+
+# Stop a specific session by its session ID
+_stop_session_by_id() {
+    local sid="$1"
+    local session_dir="$LOKI_DIR/sessions/$sid"
+    local pid_file="$session_dir/loki.pid"
+
+    if [ -f "$pid_file" ]; then
+        local pid
+        pid=$(cat "$pid_file" 2>/dev/null)
+        if [ -n "$pid" ] && kill -0 "$pid" 2>/dev/null; then
+            _kill_pid "$pid"
+            echo -e "${RED}Stopped session $sid (PID: $pid)${NC}"
+        fi
+        rm -f "$pid_file"
+    fi
+
+    # Also check legacy run-<id>.pid
+    local run_pid_file="$LOKI_DIR/run-${sid}.pid"
+    if [ -f "$run_pid_file" ]; then
+        local pid
+        pid=$(cat "$run_pid_file" 2>/dev/null)
+        if [ -n "$pid" ] && kill -0 "$pid" 2>/dev/null; then
+            _kill_pid "$pid"
+        fi
+        rm -f "$run_pid_file"
+    fi
+
+    # Clean up session lock file
+    rm -f "$session_dir/session.lock" 2>/dev/null
+}
+
+# Stop a specific session or all sessions
+# Usage: loki stop [session_id]
+# Without args: stops all running sessions
+# With session_id: stops only that specific session
 cmd_stop() {
+    local target_session=""
+
+    # Parse arguments
+    while [[ $# -gt 0 ]]; do
+        case "$1" in
+            --help|-h)
+                echo -e "${BOLD}loki stop${NC} - Stop running sessions (v6.4.0)"
+                echo ""
+                echo "Usage: loki stop [session-id]"
+                echo ""
+                echo "  loki stop          Stop all running sessions"
+                echo "  loki stop 52       Stop only session #52"
+                echo "  loki stop 54       Stop only session #54"
+                echo ""
+                echo "Use 'loki status' to see all running sessions."
+                exit 0
+                ;;
+            -*)
+                echo -e "${RED}Unknown option: $1${NC}"
+                echo "Run 'loki stop --help' for usage."
+                exit 1
+                ;;
+            *)
+                target_session="$1"
+                shift
+                ;;
+        esac
+    done
+
     if [ ! -d "$LOKI_DIR" ]; then
         echo -e "${YELLOW}No .loki directory found.${NC}"
         echo "No active session to stop."
-        # Emit error pattern for stop without session (SYN-018)
         emit_learning_signal error_pattern \
             --source cli \
             --action "cmd_stop" \
@@ -837,28 +1000,54 @@ cmd_stop() {
         exit 0
     fi
 
+    # Stop a specific session by ID
+    if [ -n "$target_session" ]; then
+        if is_session_running "$target_session"; then
+            _stop_session_by_id "$target_session"
+        else
+            echo -e "${YELLOW}Session '$target_session' is not running.${NC}"
+        fi
+        return 0
+    fi
+
+    # No session ID given -- stop all running sessions
     if is_session_running; then
+        # Stop per-session PIDs first
+        if [ -d "$LOKI_DIR/sessions" ]; then
+            for session_dir in "$LOKI_DIR/sessions"/*/; do
+                [ -d "$session_dir" ] || continue
+                local sid
+                sid=$(basename "$session_dir")
+                if is_session_running "$sid"; then
+                    _stop_session_by_id "$sid"
+                fi
+            done
+        fi
+        # Stop legacy run-*.pid sessions
+        for run_pid_file in "$LOKI_DIR"/run-*.pid; do
+            [ -f "$run_pid_file" ] || continue
+            local pid
+            pid=$(cat "$run_pid_file" 2>/dev/null)
+            if [ -n "$pid" ] && kill -0 "$pid" 2>/dev/null; then
+                _kill_pid "$pid"
+                local sid
+                sid=$(basename "$run_pid_file" .pid)
+                echo -e "${RED}Stopped session ${sid#run-} (PID: $pid)${NC}"
+            fi
+            rm -f "$run_pid_file"
+        done
+
+        # Stop global session
         touch "$LOKI_DIR/STOP"
 
-        # Kill the background process and all its children
         local killed_pid=""
         for pid_file in "$LOKI_DIR/loki.pid" "$LOKI_DIR/run.pid"; do
             if [ -f "$pid_file" ]; then
                 local pid
                 pid=$(cat "$pid_file" 2>/dev/null)
                 if [ -n "$pid" ] && kill -0 "$pid" 2>/dev/null; then
-                    # Kill all child processes first (SIGTERM)
-                    pkill -P "$pid" 2>/dev/null || true
-                    # Then kill the parent (SIGTERM)
-                    kill "$pid" 2>/dev/null || true
+                    _kill_pid "$pid"
                     killed_pid="$pid"
-
-                    # Wait briefly, then SIGKILL if still alive
-                    sleep 1
-                    if kill -0 "$pid" 2>/dev/null; then
-                        pkill -9 -P "$pid" 2>/dev/null || true
-                        kill -9 "$pid" 2>/dev/null || true
-                    fi
                 fi
                 rm -f "$pid_file"
             fi
@@ -871,7 +1060,6 @@ cmd_stop() {
 
         # Mark session.json as stopped (skill-invoked sessions)
         if [ -f "$LOKI_DIR/session.json" ]; then
-            # Use python for reliable JSON update, fall back to overwrite
             python3 -c "
 import json, sys, os
 try:
@@ -1162,6 +1350,29 @@ cmd_status() {
     echo -e "${DIM}  Switch with: loki provider set <claude|codex|gemini>${NC}"
     echo ""
 
+    # Show running sessions (v6.4.0 - concurrent session support)
+    local running_sessions=()
+    while IFS= read -r line; do
+        [ -n "$line" ] && running_sessions+=("$line")
+    done < <(list_running_sessions 2>/dev/null)
+
+    if [ ${#running_sessions[@]} -gt 1 ]; then
+        echo -e "${GREEN}Active Sessions: ${#running_sessions[@]}${NC}"
+        for entry in "${running_sessions[@]}"; do
+            local sid="${entry%%:*}"
+            local spid="${entry#*:}"
+            if [ "$sid" = "global" ]; then
+                echo -e "  ${CYAN}[global]${NC} PID $spid"
+            else
+                echo -e "  ${CYAN}[#$sid]${NC} PID $spid"
+            fi
+        done
+        echo ""
+        echo -e "${DIM}  Stop specific: loki stop <session-id>${NC}"
+        echo -e "${DIM}  Stop all:      loki stop${NC}"
+        echo ""
+    fi
+
     # Check for signals first (more prominent)
     if [ -f "$LOKI_DIR/PAUSE" ]; then
         echo -e "${YELLOW}Status: PAUSED${NC}"
@@ -2740,6 +2951,12 @@ cmd_run() {
     fi
     echo ""
 
+    # Per-session locking (v6.4.0): export session ID so run.sh uses
+    # per-session PID/lock files instead of the global lock. This allows
+    # multiple concurrent `loki run` sessions (e.g., loki run 52 -d && loki run 54 -d).
+    local session_id="${number:-$(date +%s)}"
+    export LOKI_SESSION_ID="$session_id"
+
     # Progressive isolation: set up worktree branch naming
     if $use_worktree; then
         local branch_name="issue/${issue_provider}-${number:-$(date +%s)}"
@@ -2772,6 +2989,7 @@ cmd_run() {
             cd $(pwd)
             export LOKI_DETACHED=true
             export LOKI_PARALLEL_MODE=true
+            export LOKI_SESSION_ID=\"$session_id\"
             export LOKI_WORKTREE_BRANCH=\"$branch_name\"
             $(command -v loki || echo "$0") start \"$detach_prd\" --parallel ${start_args[*]+"${start_args[*]}"}
 
@@ -7181,7 +7399,7 @@ main() {
             cmd_init "$@"
             ;;
         stop)
-            cmd_stop
+            cmd_stop "$@"
             ;;
         cleanup)
             cmd_cleanup "$@"

package/autonomy/run.sh

@@ -2642,33 +2642,52 @@ init_loki_dir() {
     # Clean up stale control files ONLY if no other session is running
     # Deleting these while another session is active would destroy its signals
     # Use flock if available to avoid TOCTOU race
-    local lock_file=".loki/session.lock"
-    local can_cleanup=false
-
-    if command -v flock >/dev/null 2>&1 && [ -f "$lock_file" ]; then
-        # Try non-blocking lock - if we get it, no other session is running
-        {
-            if flock -n 201 2>/dev/null; then
+    #
+    # Per-session locking (v6.4.0): When LOKI_SESSION_ID is set, only clean up
+    # that session's files. Global control files (PAUSE/STOP) are only cleaned
+    # when NO sessions are active.
+    local lock_file can_cleanup=false
+
+    if [ -n "${LOKI_SESSION_ID:-}" ]; then
+        # Per-session: check only this session's lock
+        lock_file=".loki/sessions/${LOKI_SESSION_ID}/session.lock"
+        local session_pid_file=".loki/sessions/${LOKI_SESSION_ID}/loki.pid"
+        if command -v flock >/dev/null 2>&1 && [ -f "$lock_file" ]; then
+            { if flock -n 201 2>/dev/null; then can_cleanup=true; fi } 201>"$lock_file"
+        else
+            local existing_pid=""
+            if [ -f "$session_pid_file" ]; then
+                existing_pid=$(cat "$session_pid_file" 2>/dev/null)
+            fi
+            if [ -z "$existing_pid" ] || ! kill -0 "$existing_pid" 2>/dev/null; then
                 can_cleanup=true
             fi
-        } 201>"$lock_file"
+        fi
+        if [ "$can_cleanup" = "true" ]; then
+            rm -f "$session_pid_file" 2>/dev/null
+            rm -f "$lock_file" 2>/dev/null
+        fi
     else
-        # Fallback: check PID file
-        local existing_pid=""
-        if [ -f ".loki/loki.pid" ]; then
-            existing_pid=$(cat ".loki/loki.pid" 2>/dev/null)
+        # Global: original behavior
+        lock_file=".loki/session.lock"
+        if command -v flock >/dev/null 2>&1 && [ -f "$lock_file" ]; then
+            { if flock -n 201 2>/dev/null; then can_cleanup=true; fi } 201>"$lock_file"
+        else
+            local existing_pid=""
+            if [ -f ".loki/loki.pid" ]; then
+                existing_pid=$(cat ".loki/loki.pid" 2>/dev/null)
+            fi
+            if [ -z "$existing_pid" ] || ! kill -0 "$existing_pid" 2>/dev/null; then
+                can_cleanup=true
+            fi
         fi
-        if [ -z "$existing_pid" ] || ! kill -0 "$existing_pid" 2>/dev/null; then
-            can_cleanup=true
+        if [ "$can_cleanup" = "true" ]; then
+            rm -f .loki/PAUSE .loki/STOP .loki/HUMAN_INPUT.md 2>/dev/null
+            rm -f .loki/loki.pid 2>/dev/null
+            rm -f .loki/session.lock 2>/dev/null
         fi
     fi
 
-    if [ "$can_cleanup" = "true" ]; then
-        rm -f .loki/PAUSE .loki/STOP .loki/HUMAN_INPUT.md 2>/dev/null
-        rm -f .loki/loki.pid 2>/dev/null
-        rm -f .loki/session.lock 2>/dev/null
-    fi
-
     mkdir -p .loki/{state,queue,messages,logs,config,prompts,artifacts,scripts}
     mkdir -p .loki/queue
     mkdir -p .loki/state/checkpoints
@@ -8093,6 +8112,10 @@ cleanup() {
         stop_status_monitor
         kill_all_registered
         rm -f "$loki_dir/loki.pid" 2>/dev/null
+        # Clean up per-session PID file if running with session ID
+        if [ -n "${LOKI_SESSION_ID:-}" ]; then
+            rm -f "$loki_dir/sessions/${LOKI_SESSION_ID}/loki.pid" 2>/dev/null
+        fi
         if [ -f "$loki_dir/session.json" ]; then
             _LOKI_SESSION_FILE="$loki_dir/session.json" python3 -c "
 import json, os
@@ -8121,6 +8144,10 @@ except (json.JSONDecodeError, OSError): pass
         stop_status_monitor
         kill_all_registered
         rm -f .loki/loki.pid .loki/PAUSE 2>/dev/null
+        # Clean up per-session PID file if running with session ID
+        if [ -n "${LOKI_SESSION_ID:-}" ]; then
+            rm -f ".loki/sessions/${LOKI_SESSION_ID}/loki.pid" 2>/dev/null
+        fi
         # Mark session.json as stopped
         if [ -f ".loki/session.json" ]; then
             python3 -c "
@@ -8325,7 +8352,13 @@ main() {
         mkdir -p .loki/logs
 
         local log_file=".loki/logs/background-$(date +%Y%m%d-%H%M%S).log"
-        local pid_file=".loki/loki.pid"
+        local pid_file
+        if [ -n "${LOKI_SESSION_ID:-}" ]; then
+            mkdir -p ".loki/sessions/${LOKI_SESSION_ID}"
+            pid_file=".loki/sessions/${LOKI_SESSION_ID}/loki.pid"
+        else
+            pid_file=".loki/loki.pid"
+        fi
         local project_path=$(pwd)
         local project_name=$(basename "$project_path")
 
@@ -8419,12 +8452,22 @@ main() {
     # Initialize session continuity file with empty template
     update_continuity
 
-    # Session lock: prevent concurrent sessions on same repo
-    # Use flock for atomic locking to prevent TOCTOU race conditions
-    local pid_file=".loki/loki.pid"
-    local lock_file=".loki/session.lock"
+    # Session lock: prevent concurrent sessions
+    # Per-session locking (v6.4.0): LOKI_SESSION_ID enables multiple concurrent
+    # sessions (e.g., loki run 52 -d && loki run 54 -d). Each session gets its
+    # own PID/lock files under .loki/sessions/<id>/.
+    # Without LOKI_SESSION_ID, the global .loki/loki.pid lock is used (single session).
+    local pid_file lock_file
+    if [ -n "${LOKI_SESSION_ID:-}" ]; then
+        mkdir -p ".loki/sessions/${LOKI_SESSION_ID}"
+        pid_file=".loki/sessions/${LOKI_SESSION_ID}/loki.pid"
+        lock_file=".loki/sessions/${LOKI_SESSION_ID}/session.lock"
+    else
+        pid_file=".loki/loki.pid"
+        lock_file=".loki/session.lock"
+    fi
 
-    # Try to acquire exclusive lock with flock (if available)
+    # Use flock for atomic locking to prevent TOCTOU race conditions
     if command -v flock >/dev/null 2>&1; then
         # Create lock file
         touch "$lock_file"
@@ -8435,8 +8478,13 @@ main() {
 
         # Try to acquire exclusive lock (non-blocking)
         if ! flock -n 200 2>/dev/null; then
-            log_error "Another Loki session is already running (locked)"
-            log_error "Stop it first with: loki stop"
+            if [ -n "${LOKI_SESSION_ID:-}" ]; then
+                log_error "Session '${LOKI_SESSION_ID}' is already running (locked)"
+                log_error "Stop it first with: loki stop ${LOKI_SESSION_ID}"
+            else
+                log_error "Another Loki session is already running (locked)"
+                log_error "Stop it first with: loki stop"
+            fi
             exit 1
         fi
 
@@ -8446,8 +8494,13 @@ main() {
             existing_pid=$(cat "$pid_file" 2>/dev/null)
             # Skip if it's our own PID or parent PID (background mode writes PID before child starts)
             if [ -n "$existing_pid" ] && [ "$existing_pid" != "$$" ] && [ "$existing_pid" != "$PPID" ] && kill -0 "$existing_pid" 2>/dev/null; then
-                log_error "Another Loki session is already running (PID: $existing_pid)"
-                log_error "Stop it first with: loki stop"
+                if [ -n "${LOKI_SESSION_ID:-}" ]; then
+                    log_error "Session '${LOKI_SESSION_ID}' is already running (PID: $existing_pid)"
+                    log_error "Stop it first with: loki stop ${LOKI_SESSION_ID}"
+                else
+                    log_error "Another Loki session is already running (PID: $existing_pid)"
+                    log_error "Stop it first with: loki stop"
+                fi
                 exit 1
             fi
         fi
@@ -8459,8 +8512,13 @@ main() {
             existing_pid=$(cat "$pid_file" 2>/dev/null)
             # Skip if it's our own PID or parent PID (background mode writes PID before child starts)
             if [ -n "$existing_pid" ] && [ "$existing_pid" != "$$" ] && [ "$existing_pid" != "$PPID" ] && kill -0 "$existing_pid" 2>/dev/null; then
-                log_error "Another Loki session is already running (PID: $existing_pid)"
-                log_error "Stop it first with: loki stop"
+                if [ -n "${LOKI_SESSION_ID:-}" ]; then
+                    log_error "Session '${LOKI_SESSION_ID}' is already running (PID: $existing_pid)"
+                    log_error "Stop it first with: loki stop ${LOKI_SESSION_ID}"
+                else
+                    log_error "Another Loki session is already running (PID: $existing_pid)"
+                    log_error "Stop it first with: loki stop"
+                fi
                 exit 1
             fi
         fi
@@ -8468,6 +8526,10 @@ main() {
 
     # Write PID file for ALL modes (foreground + background)
     echo "$$" > "$pid_file"
+    # Store session ID in state for dashboard/status visibility
+    if [ -n "${LOKI_SESSION_ID:-}" ]; then
+        echo "${LOKI_SESSION_ID}" > ".loki/sessions/${LOKI_SESSION_ID}/session_id"
+    fi
 
     # Initialize PID registry and clean up orphans from previous sessions
     init_pid_registry
@@ -8675,6 +8737,10 @@ main() {
     stop_dashboard
     stop_status_monitor
     rm -f .loki/loki.pid 2>/dev/null
+    # Clean up per-session PID file if running with session ID
+    if [ -n "${LOKI_SESSION_ID:-}" ]; then
+        rm -f ".loki/sessions/${LOKI_SESSION_ID}/loki.pid" 2>/dev/null
+    fi
     # Mark session.json as stopped
     if [ -f ".loki/session.json" ]; then
         python3 -c "

package/dashboard/__init__.py

@@ -7,7 +7,7 @@ Modules:
     control: Session control API (start/stop/pause/resume)
 """
 
-__version__ = "6.3.1"
+__version__ = "6.4.0"
 
 # Expose the control app for easy import
 try:

package/dashboard/server.py

@@ -203,6 +203,14 @@ class TaskResponse(BaseModel):
         from_attributes = True
 
 
+class SessionInfo(BaseModel):
+    """Info about a single running session."""
+    session_id: str
+    pid: int
+    status: str = "running"
+    log_file: str = ""
+
+
 class StatusResponse(BaseModel):
     """Schema for system status response."""
     status: str
@@ -219,6 +227,8 @@ class StatusResponse(BaseModel):
     mode: str = ""
     provider: str = "claude"
     current_task: str = ""
+    # Concurrent sessions (v6.4.0)
+    sessions: list[SessionInfo] = []
 
 
 # WebSocket connection manager
@@ -521,11 +531,73 @@ async def get_status() -> StatusResponse:
         except Exception:
             pass
 
+    # Discover all running sessions (v6.4.0 - concurrent session support)
+    active_session_list: list[SessionInfo] = []
+
+    # Global session
+    if running:
+        active_session_list.append(SessionInfo(
+            session_id="global",
+            pid=int(pid_str) if pid_str else 0,
+            status=status,
+        ))
+
+    # Per-session PIDs under .loki/sessions/<id>/
+    sessions_dir = loki_dir / "sessions"
+    if sessions_dir.is_dir():
+        for session_path in sessions_dir.iterdir():
+            if not session_path.is_dir():
+                continue
+            sid = session_path.name
+            spid_file = session_path / "loki.pid"
+            if spid_file.exists():
+                try:
+                    spid_str = spid_file.read_text().strip()
+                    spid = int(spid_str)
+                    os.kill(spid, 0)
+                    # Find log file if available
+                    log_path = ""
+                    log_candidate = loki_dir / "logs" / f"run-{sid}.log"
+                    if log_candidate.exists():
+                        log_path = str(log_candidate)
+                    active_session_list.append(SessionInfo(
+                        session_id=sid,
+                        pid=spid,
+                        status="running",
+                        log_file=log_path,
+                    ))
+                except (ValueError, OSError, ProcessLookupError):
+                    pass
+
+    # Legacy run-*.pid files
+    for rpf in loki_dir.glob("run-*.pid"):
+        sid = rpf.stem.removeprefix("run-")
+        # Skip if already found in sessions/
+        if any(s.session_id == sid for s in active_session_list):
+            continue
+        try:
+            rpid = int(rpf.read_text().strip())
+            os.kill(rpid, 0)
+            log_path = ""
+            log_candidate = loki_dir / "logs" / f"run-{sid}.log"
+            if log_candidate.exists():
+                log_path = str(log_candidate)
+            active_session_list.append(SessionInfo(
+                session_id=sid,
+                pid=rpid,
+                status="running",
+                log_file=log_path,
+            ))
+        except (ValueError, OSError, ProcessLookupError):
+            pass
+
+    total_active = len(active_session_list)
+
     return StatusResponse(
         status=status,
         version=version,
         uptime_seconds=uptime,
-        active_sessions=1 if running else 0,
+        active_sessions=total_active,
         running_agents=running_agents,
         pending_tasks=pending_tasks,
         database_connected=True,
@@ -535,6 +607,7 @@ async def get_status() -> StatusResponse:
         mode=mode,
         provider=provider,
         current_task=current_task,
+        sessions=active_session_list,
     )
 
 

package/docs/INSTALLATION.md

@@ -2,11 +2,11 @@
 
 The flagship product of [Autonomi](https://www.autonomi.dev/). Complete installation instructions for all platforms and use cases.
 
-**Version:** v6.3.1
+**Version:** v6.4.0
 
 ---
 
-## What's New in v6.3.1
+## What's New in v6.4.0
 
 ### Dual-Mode Architecture (v6.0.0)
 - `loki run` command for direct autonomous execution

package/mcp/__init__.py

@@ -57,4 +57,4 @@ try:
 except ImportError:
     __all__ = ['mcp']
 
-__version__ = '6.3.1'
+__version__ = '6.4.0'

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "loki-mode",
-  "version": "6.3.1",
+  "version": "6.4.0",
   "description": "Loki Mode by Autonomi - Multi-agent autonomous startup system for Claude Code, Codex CLI, and Gemini CLI",
   "keywords": [
     "agent",