loki-mode 7.7.28 → 7.7.30

package/SKILL.md

@@ -3,7 +3,7 @@ name: loki-mode
 description: Autonomous spec-to-product system. Triggers on "Loki Mode". Takes a spec (PRD, GitHub issue, OpenAPI doc, etc.) to deployed product via the RARV-C closure loop, with minimal human intervention. Provider-agnostic. Requires --dangerously-skip-permissions flag.
 ---
 
-# Loki Mode v7.7.28
+# Loki Mode v7.7.30
 
 **You are an autonomous agent. You make decisions. You do not ask questions. You do not stop.**
 
@@ -381,4 +381,4 @@ See `CHANGELOG.md` entries [7.5.7], [7.5.8], [7.5.13] for the per-fix list and r
 
 ---
 
-**v7.7.28 | [Autonomi](https://www.autonomi.dev/) flagship product | ~260 lines core**
+**v7.7.30 | [Autonomi](https://www.autonomi.dev/) flagship product | ~260 lines core**

package/VERSION

@@ -1 +1 @@
-7.7.28
+7.7.30

package/autonomy/loki

@@ -1593,12 +1593,19 @@ cmd_start() {
         exit 1
     fi
 
-    # --api flag: start the dashboard API server in background before the build
+    # --api flag: start the dashboard API server before the build.
+    # cmd_dashboard_start already daemonizes the server (nohup ... &) and runs
+    # its own readiness probe, so run it in a contained SUBSHELL (not a
+    # double-background) and surface the outcome. The old
+    # `cmd_dashboard_start 2>/dev/null &` swallowed all output AND double-
+    # backgrounded the already-daemonized server, so a port-in-use or startup
+    # failure was invisible and the user got no dashboard and no error. The
+    # subshell also contains cmd_dashboard_start's internal `exit 1` so a
+    # dashboard failure can never abort the build.
     if [ "${LOKI_START_API:-false}" = "true" ]; then
         local dash_port="${LOKI_DASHBOARD_PORT:-57374}"
         echo -e "${GREEN}Starting dashboard API on port $dash_port...${NC}"
-        cmd_dashboard_start 2>/dev/null &
-        sleep 2
+        ( cmd_dashboard_start ) || echo -e "${YELLOW}Dashboard API did not start (see message above); continuing the build without it.${NC}"
     fi
 
     # Phase F (v7.5.23): cross-project context discovery. Walks ONE parent
@@ -1774,22 +1781,33 @@ _stop_session_by_id() {
 # With session_id: stops only that specific session
 cmd_stop() {
     local target_session=""
+    local stop_all=false
 
     # Parse arguments
     while [[ $# -gt 0 ]]; do
         case "$1" in
             --help|-h)
-                echo -e "${BOLD}loki stop${NC} - Stop running sessions (v6.4.0)"
+                echo -e "${BOLD}loki stop${NC} - Stop running sessions (v7.7.30)"
                 echo ""
-                echo "Usage: loki stop [session-id]"
+                echo "Usage: loki stop [session-id] [--all]"
                 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 "  loki stop          Stop ONLY the current folder's session."
+                echo "                     Other folders keep running. Marks this"
+                echo "                     project stopped in the dashboard registry."
+                echo "  loki stop 52       Stop only session #52 in this folder."
+                echo "  loki stop --all    Stop EVERY loki runner on this machine"
+                echo "                     (legacy machine-wide behavior)."
                 echo ""
-                echo "Use 'loki status' to see all running sessions."
+                echo "The shared dashboard stays up if other projects are still"
+                echo "running; it is stopped only when no project remains (or --all)."
+                echo ""
+                echo "Use 'loki status' to see this folder's sessions."
                 exit 0
                 ;;
+            --all)
+                stop_all=true
+                shift
+                ;;
             -*)
                 echo -e "${RED}Unknown option: $1${NC}"
                 echo "Run 'loki stop --help' for usage."
@@ -1869,11 +1887,6 @@ cmd_stop() {
             fi
         done
 
-        # Also kill any orphaned loki-run temp scripts (SIGTERM then SIGKILL)
-        pkill -f "loki-run-" 2>/dev/null || true
-        sleep 0.5
-        pkill -9 -f "loki-run-" 2>/dev/null || true
-
         # Mark session.json as stopped (skill-invoked sessions)
         # BUG-ST-008: Atomic session.json update via temp file + mv (matches run.sh)
         if [ -f "$LOKI_DIR/session.json" ]; then
@@ -1893,20 +1906,80 @@ except (json.JSONDecodeError, OSError): pass
 " 2>/dev/null || true
         fi
 
+        # v7.7.30: mark THIS project stopped in the shared dashboard registry
+        # so the multi-project switcher reflects it. Best-effort, never fatal.
+        # Honors LOKI_SKIP_PROJECT_REGISTRY (matches run.sh registration).
+        if [ -z "${LOKI_SKIP_PROJECT_REGISTRY:-}" ] && command -v python3 >/dev/null 2>&1; then
+            LOKI_REG_TARGET="$(pwd)" LOKI_REG_SKILL="${SKILL_DIR:-$PROJECT_DIR}" \
+            python3 - <<'PYSTOP' >/dev/null 2>&1 || true
+import os, sys
+sys.path.insert(0, os.environ.get("LOKI_REG_SKILL", "."))
+try:
+    from dashboard import registry
+    registry.mark_project_stopped(os.path.abspath(os.environ["LOKI_REG_TARGET"]))
+except Exception:
+    pass
+PYSTOP
+        fi
+
         # Clean up control files
         rm -f "$LOKI_DIR/STOP" "$LOKI_DIR/PAUSE" "$LOKI_DIR/PAUSED.md" 2>/dev/null
 
-        # Kill dashboard if running
-        if [ -f "$LOKI_DIR/dashboard/dashboard.pid" ]; then
-            local dash_pid
-            dash_pid=$(cat "$LOKI_DIR/dashboard/dashboard.pid" 2>/dev/null)
-            if [ -n "$dash_pid" ] && kill -0 "$dash_pid" 2>/dev/null; then
-                kill "$dash_pid" 2>/dev/null || true
-                sleep 0.5
-                kill -9 "$dash_pid" 2>/dev/null || true
+        # Kill dashboard if running.
+        # v7.7.30: the project-local dashboard (.loki/dashboard) belongs solely
+        # to this folder and is ALWAYS killed. The shared standalone dashboard
+        # (~/.loki/dashboard) is killed ONLY when no OTHER registered project is
+        # still running, so we never tear down a dashboard other folders need.
+        # For --all, the shared dashboard is always killed (tear everything down).
+        local _kill_shared_dash=false
+        if [ "$stop_all" = true ]; then
+            _kill_shared_dash=true
+        elif command -v python3 >/dev/null 2>&1; then
+            # Query the registry (after mark_project_stopped excluded this
+            # project) for any OTHER project whose pid is still alive.
+            local _dash_decision
+            _dash_decision=$(LOKI_REG_SKILL="${SKILL_DIR:-$PROJECT_DIR}" \
+                python3 - <<'PYDASH' 2>/dev/null || true
+import os, sys
+sys.path.insert(0, os.environ.get("LOKI_REG_SKILL", "."))
+try:
+    from dashboard import registry
+    alive = 0
+    for p in registry.list_projects(include_inactive=True):
+        pid = p.get("pid")
+        if isinstance(pid, int) and pid > 0:
+            try:
+                os.kill(pid, 0)
+                alive += 1
+            except OSError:
+                pass
+    print("CLEAR" if alive == 0 else "KEEP")
+except Exception:
+    print("CLEAR")
+PYDASH
+            )
+            [ "$_dash_decision" = "CLEAR" ] && _kill_shared_dash=true
+        else
+            # python3 unavailable: fall back to legacy behavior (kill shared)
+            # to avoid leaking the shared dashboard on minimal systems.
+            _kill_shared_dash=true
+        fi
+
+        local _dash_pidf
+        local _dash_targets=("$LOKI_DIR/dashboard/dashboard.pid")
+        [ "$_kill_shared_dash" = true ] && _dash_targets+=("${HOME}/.loki/dashboard/dashboard.pid")
+        for _dash_pidf in "${_dash_targets[@]}"; do
+            if [ -f "$_dash_pidf" ]; then
+                local dash_pid
+                dash_pid=$(cat "$_dash_pidf" 2>/dev/null)
+                if [ -n "$dash_pid" ] && kill -0 "$dash_pid" 2>/dev/null; then
+                    kill "$dash_pid" 2>/dev/null || true
+                    sleep 0.5
+                    kill -9 "$dash_pid" 2>/dev/null || true
+                fi
+                rm -f "$_dash_pidf"
             fi
-            rm -f "$LOKI_DIR/dashboard/dashboard.pid"
-        fi
+        done
 
         # Kill any remaining registered processes (2s graceful window matches run.sh)
         if [ -d "$LOKI_DIR/pids" ]; then
@@ -1954,6 +2027,16 @@ except (json.JSONDecodeError, OSError): pass
             echo "Start a session with: loki start"
         fi
     fi
+
+    # v7.7.30: --all preserves the legacy machine-wide kill. It runs even when
+    # the current folder has no live session (the "clean everything" use case),
+    # reaping every folder's orphaned loki-run-* temp script (SIGTERM, SIGKILL).
+    if [ "$stop_all" = true ]; then
+        pkill -f "loki-run-" 2>/dev/null || true
+        sleep 0.5
+        pkill -9 -f "loki-run-" 2>/dev/null || true
+        echo -e "${RED}--all: signalled all loki-run-* processes on this machine.${NC}"
+    fi
 }
 
 # Kill orphaned processes from crashed sessions
@@ -2536,15 +2619,33 @@ if os.path.isfile(session_file):
 else:
     result['elapsed_time'] = 0
 
-# Dashboard URL
-dashboard_pid_file = os.path.join(loki_dir, 'dashboard', 'dashboard.pid')
+# Dashboard URL. Check both the project-local in-build dashboard and the
+# standalone dashboard (~/.loki/dashboard) and honor saved scheme/host/port
+# side-files, so --json reports the right URL regardless of which started it.
+_dash_candidates = [
+    os.path.join(loki_dir, 'dashboard', 'dashboard.pid'),
+    os.path.expanduser(os.path.join('~', '.loki', 'dashboard', 'dashboard.pid')),
+]
+dashboard_pid_file = next((p for p in _dash_candidates if os.path.isfile(p)), _dash_candidates[0])
 dashboard_url = None
 if os.path.isfile(dashboard_pid_file):
     try:
         with open(dashboard_pid_file) as f:
             dpid = int(f.read().strip())
         os.kill(dpid, 0)
-        dashboard_url = 'http://127.0.0.1:' + dashboard_port + '/'
+        _dd = os.path.dirname(dashboard_pid_file)
+        def _side(name, default):
+            p = os.path.join(_dd, name)
+            try:
+                return open(p).read().strip() if os.path.isfile(p) else default
+            except OSError:
+                return default
+        _scheme = _side('scheme', 'http')
+        _host = _side('host', '127.0.0.1')
+        _port = _side('port', str(dashboard_port))
+        if _host == '0.0.0.0':
+            _host = '127.0.0.1'
+        dashboard_url = _scheme + '://' + _host + ':' + _port + '/'
     except (ProcessLookupError, PermissionError, ValueError, Exception):
         pass
 result['dashboard_url'] = dashboard_url
@@ -3296,11 +3397,24 @@ cmd_provider_models() {
     done
 }
 
-# Dashboard server management - project-local, unified with run.sh
-DASHBOARD_PID_DIR="${LOKI_DIR}/dashboard"
+# Standalone dashboard server management (`loki dashboard`).
+# State lives at a FIXED, machine-global ~/.loki/dashboard so that
+# stop|status|open find the running server from ANY working directory.
+# (The relative ${LOKI_DIR}/dashboard path made these commands silently
+# fail from a different cwd than `start`, orphaning the server.) The
+# separate in-build dashboard started by run.sh during `loki start` stays
+# project-local and is unaffected by this constant.
+DASHBOARD_PID_DIR="${HOME}/.loki/dashboard"
 DASHBOARD_PID_FILE="${DASHBOARD_PID_DIR}/dashboard.pid"
 DASHBOARD_DEFAULT_PORT=57374
-DASHBOARD_DEFAULT_HOST="127.0.0.1"
+# Default bind host: 0.0.0.0 inside a container (so a -p port map reaches
+# the server; 127.0.0.1 would be unreachable from the host), else loopback
+# for host safety. Detect Docker via /.dockerenv or LOKI_SANDBOX_MODE.
+if [ -f /.dockerenv ] || [ "${LOKI_SANDBOX_MODE:-}" = "true" ] || [ -n "${LOKI_IN_CONTAINER:-}" ]; then
+    DASHBOARD_DEFAULT_HOST="0.0.0.0"
+else
+    DASHBOARD_DEFAULT_HOST="127.0.0.1"
+fi
 
 cmd_dashboard() {
     local subcommand="${1:-}"
@@ -3546,12 +3660,19 @@ cmd_dashboard_start() {
     echo "$host" > "${DASHBOARD_PID_DIR}/host"
     echo "$url_scheme" > "${DASHBOARD_PID_DIR}/scheme"
 
-    # Wait for dashboard HTTP endpoint to become ready (up to 10 seconds)
+    # Wait for the dashboard to become ready (up to 10 seconds). Probe the
+    # UNAUTHENTICATED /health endpoint over the ACTUAL scheme: /api/status
+    # 401s under LOKI_ENTERPRISE_AUTH, and the scheme is https when TLS is on,
+    # so the old hardcoded http://.../api/status probe always failed against a
+    # healthy TLS or auth-enabled server. Use a loopback-reachable host when
+    # bound to 0.0.0.0, and -k to tolerate self-signed certs.
+    local health_host="$host"; [ "$health_host" = "0.0.0.0" ] && health_host="127.0.0.1"
+    local health_curl_opts="-sf"; [ "$url_scheme" = "https" ] && health_curl_opts="-sfk"
     local health_retries=20
     local health_interval=0.5
     local health_ok=false
     while [[ $health_retries -gt 0 ]]; do
-        if curl -sf "http://${host}:${port}/api/status" >/dev/null 2>&1; then
+        if curl $health_curl_opts "${url_scheme}://${health_host}:${port}/health" >/dev/null 2>&1; then
             health_ok=true
             break
         fi
@@ -7802,11 +7923,37 @@ cmd_logs() {
     fi
 }
 
-# API server management (delegates to unified FastAPI dashboard server)
+# API server management (delegates to unified FastAPI dashboard server).
+# Shares the SAME machine-global PID/control dir as `loki dashboard`
+# ($DASHBOARD_PID_DIR = ~/.loki/dashboard) so the two commands never fight
+# over the port and so stop/status/open are consistent across both. Parses
+# --host/--port, guards a busy port, computes the TLS scheme, and persists
+# host/port/scheme side-files like cmd_dashboard_start does.
 cmd_api() {
     local subcommand="${1:-help}"
-    local port="${LOKI_DASHBOARD_PORT:-57374}"
-    local pid_file="$LOKI_DIR/dashboard/dashboard.pid"
+    shift || true
+    local port="${LOKI_DASHBOARD_PORT:-$DASHBOARD_DEFAULT_PORT}"
+    local host="${LOKI_DASHBOARD_HOST:-$DASHBOARD_DEFAULT_HOST}"
+    local pid_file="$DASHBOARD_PID_FILE"
+
+    # Parse --host/--port (the old code ignored them, so `loki serve --port X`
+    # silently bound 57374 and `--host 0.0.0.0` was dropped).
+    while [ $# -gt 0 ]; do
+        case "$1" in
+            --port) port="${2:-$port}"; shift 2 ;;
+            --port=*) port="${1#*=}"; shift ;;
+            --host) host="${2:-$host}"; shift 2 ;;
+            --host=*) host="${1#*=}"; shift ;;
+            *) shift ;;
+        esac
+    done
+
+    local scheme="http"
+    if [ -n "${LOKI_TLS_CERT:-}" ] && [ -n "${LOKI_TLS_KEY:-}" ]; then
+        scheme="https"
+    fi
+    # Loopback-reachable host for printed URLs when bound to 0.0.0.0.
+    local url_host="$host"; [ "$url_host" = "0.0.0.0" ] && url_host="127.0.0.1"
 
     case "$subcommand" in
         start)
@@ -7818,12 +7965,20 @@ cmd_api() {
 
             # Check if already running
             if [ -f "$pid_file" ]; then
-                local existing_pid=$(cat "$pid_file")
-                if kill -0 "$existing_pid" 2>/dev/null; then
+                local existing_pid=$(cat "$pid_file" 2>/dev/null)
+                if [ -n "$existing_pid" ] && kill -0 "$existing_pid" 2>/dev/null; then
                     echo -e "${YELLOW}Dashboard server already running (PID: $existing_pid)${NC}"
-                    echo "URL: http://localhost:$port"
+                    echo "URL: ${scheme}://${url_host}:$port"
                     exit 0
                 fi
+                rm -f "$pid_file"
+            fi
+
+            # Refuse a busy port instead of writing a bogus PID.
+            if command -v lsof &> /dev/null && lsof -i ":$port" &> /dev/null; then
+                echo -e "${RED}Error: Port $port is already in use${NC}"
+                echo "Stop the other server or set LOKI_DASHBOARD_PORT / --port to a free port."
+                exit 1
             fi
 
             # Ensure dashboard Python dependencies
@@ -7833,20 +7988,24 @@ cmd_api() {
             fi
             local api_python="$DASHBOARD_PYTHON"
 
-            # Start server
-            mkdir -p "$LOKI_DIR/logs" "$LOKI_DIR/dashboard"
-            local host="${LOKI_DASHBOARD_HOST:-127.0.0.1}"
+            # Start server. Persist host/port/scheme so status/open are accurate.
+            mkdir -p "$LOKI_DIR/logs" "$DASHBOARD_PID_DIR"
             local uvicorn_args=("--host" "$host" "--port" "$port")
-            if [ -n "${LOKI_TLS_CERT:-}" ] && [ -n "${LOKI_TLS_KEY:-}" ]; then
+            if [ "$scheme" = "https" ]; then
                 uvicorn_args+=("--ssl-certfile" "${LOKI_TLS_CERT}" "--ssl-keyfile" "${LOKI_TLS_KEY}")
             fi
-            LOKI_DIR="$LOKI_DIR" PYTHONPATH="$SKILL_DIR" nohup "$api_python" -m uvicorn dashboard.server:app "${uvicorn_args[@]}" > "$LOKI_DIR/logs/api.log" 2>&1 &
+            LOKI_DIR="$LOKI_DIR" LOKI_SKILL_DIR="$SKILL_DIR" PYTHONPATH="$SKILL_DIR" \
+                LOKI_DASHBOARD_HOST="$host" LOKI_DASHBOARD_PORT="$port" \
+                nohup "$api_python" -m uvicorn dashboard.server:app "${uvicorn_args[@]}" > "$LOKI_DIR/logs/api.log" 2>&1 &
             local new_pid=$!
             echo "$new_pid" > "$pid_file"
+            echo "$port" > "${DASHBOARD_PID_DIR}/port"
+            echo "$host" > "${DASHBOARD_PID_DIR}/host"
+            echo "$scheme" > "${DASHBOARD_PID_DIR}/scheme"
 
             echo -e "${GREEN}Dashboard server started${NC}"
             echo "  PID:  $new_pid"
-            echo "  URL:  http://localhost:$port"
+            echo "  URL:  ${scheme}://${url_host}:$port"
             echo "  Logs: $LOKI_DIR/logs/api.log"
             ;;
 
@@ -7870,15 +8029,22 @@ cmd_api() {
             if [ -f "$pid_file" ]; then
                 local pid=$(cat "$pid_file")
                 if kill -0 "$pid" 2>/dev/null; then
+                    # Prefer persisted side-files for the real bind.
+                    local s_scheme="$scheme" s_host="$url_host" s_port="$port"
+                    [ -f "${DASHBOARD_PID_DIR}/scheme" ] && s_scheme="$(cat "${DASHBOARD_PID_DIR}/scheme" 2>/dev/null)"
+                    [ -f "${DASHBOARD_PID_DIR}/host" ] && s_host="$(cat "${DASHBOARD_PID_DIR}/host" 2>/dev/null)"
+                    [ -f "${DASHBOARD_PID_DIR}/port" ] && s_port="$(cat "${DASHBOARD_PID_DIR}/port" 2>/dev/null)"
+                    [ "$s_host" = "0.0.0.0" ] && s_host="127.0.0.1"
                     echo -e "${GREEN}Dashboard server running${NC}"
                     echo "  PID:  $pid"
-                    echo "  URL:  http://localhost:$port"
+                    echo "  URL:  ${s_scheme}://${s_host}:${s_port}"
 
-                    # Try to fetch status
+                    # Try to fetch status (best-effort; may 401 under auth)
                     if command -v curl &> /dev/null; then
                         echo ""
                         echo -e "${CYAN}Status:${NC}"
-                        curl -s "http://localhost:$port/api/status" 2>/dev/null | jq . 2>/dev/null || true
+                        local _k=""; [ "$s_scheme" = "https" ] && _k="-k"
+                        curl -s $_k "${s_scheme}://${s_host}:${s_port}/api/status" 2>/dev/null | jq . 2>/dev/null || true
                     fi
                 else
                     echo -e "${YELLOW}Dashboard server not running (stale PID file)${NC}"

package/autonomy/run.sh

@@ -752,6 +752,117 @@ TARGET_DIR="${LOKI_TARGET_DIR:-$(pwd)}"
 PARALLEL_BLOG=${LOKI_PARALLEL_BLOG:-false}
 AUTO_MERGE=${LOKI_AUTO_MERGE:-true}
 
+# Multi-project registry (v7.7.29): register this running project in the
+# machine-global registry (~/.loki/dashboard/projects.json) so the dashboard
+# can list and switch between projects running in different folders. Records
+# the absolute path, pid, port, and status. Fully non-blocking and
+# failure-swallowed: registry problems must never affect a build. Marked
+# inactive again on exit via the trap below.
+loki_register_running_project() {
+    local _status="${1:-running}"
+    [ -n "${LOKI_SKIP_PROJECT_REGISTRY:-}" ] && return 0
+    command -v python3 >/dev/null 2>&1 || return 0
+    local _skill="${LOKI_SKILL_DIR:-${PROJECT_DIR:-$SCRIPT_DIR/..}}"
+    LOKI_REG_TARGET="$TARGET_DIR" LOKI_REG_SKILL="$_skill" \
+    LOKI_REG_PID="$$" LOKI_REG_PORT="${LOKI_DASHBOARD_PORT:-57374}" \
+    LOKI_REG_STATUS="$_status" \
+    python3 - <<'PYREG' >/dev/null 2>&1 || true
+import os, sys
+sys.path.insert(0, os.environ.get("LOKI_REG_SKILL", "."))
+try:
+    from dashboard import registry
+    target = os.path.abspath(os.environ["LOKI_REG_TARGET"])
+    entry = registry.register_project(target)
+    # Enrich with runtime fields the dashboard switcher uses.
+    reg = registry._load_registry()
+    pid = entry.get("id") or registry._generate_project_id(target)
+    if pid in reg.get("projects", {}):
+        reg["projects"][pid]["pid"] = int(os.environ.get("LOKI_REG_PID", "0") or 0)
+        reg["projects"][pid]["port"] = int(os.environ.get("LOKI_REG_PORT", "57374") or 57374)
+        reg["projects"][pid]["status"] = os.environ.get("LOKI_REG_STATUS", "running")
+        registry._save_registry(reg)
+except Exception:
+    pass
+PYREG
+}
+
+# v7.7.30: deliberate-exit teardown for the shared dashboard + registry.
+# Marks THIS project (abspath of TARGET_DIR) stopped in the machine-global
+# registry, then decides whether the shared standalone dashboard at
+# ~/.loki/dashboard/dashboard.pid should be killed. The shared dashboard is
+# killed ONLY when no other registered project still has a live pid (CLEAR);
+# if any other project is still running (KEEP) it is left up. NEVER uses a
+# blanket pkill and NEVER touches another folder's pids. Best-effort and
+# failure-swallowed: teardown bookkeeping must never block a clean exit.
+loki_mark_project_stopped_and_maybe_kill_shared_dashboard() {
+    local _skill="${LOKI_SKILL_DIR:-${PROJECT_DIR:-$SCRIPT_DIR/..}}"
+    local _shared_pidfile="${HOME}/.loki/dashboard/dashboard.pid"
+    local _decision="CLEAR"
+
+    if [ -z "${LOKI_SKIP_PROJECT_REGISTRY:-}" ] && command -v python3 >/dev/null 2>&1; then
+        # (a) Mark this project stopped in the shared registry.
+        LOKI_REG_TARGET="$TARGET_DIR" LOKI_REG_SKILL="$_skill" \
+        python3 - <<'PYSTOP' >/dev/null 2>&1 || true
+import os, sys
+sys.path.insert(0, os.environ.get("LOKI_REG_SKILL", "."))
+try:
+    from dashboard import registry
+    registry.mark_project_stopped(os.path.abspath(os.environ["LOKI_REG_TARGET"]))
+except Exception:
+    pass
+PYSTOP
+        # (b) CLEAR/KEEP check: any OTHER project still alive keeps the
+        # shared dashboard up (this project is already marked stopped above).
+        _decision="$(LOKI_REG_SKILL="$_skill" python3 - <<'PYCHECK' 2>/dev/null || echo CLEAR
+import os, sys
+sys.path.insert(0, os.environ.get("LOKI_REG_SKILL", "."))
+try:
+    from dashboard import registry
+    alive = 0
+    for p in registry.list_projects(include_inactive=True):
+        pid = p.get("pid")
+        if isinstance(pid, int) and pid > 0:
+            try:
+                os.kill(pid, 0)
+                alive += 1
+            except OSError:
+                pass
+    print("CLEAR" if alive == 0 else "KEEP")
+except Exception:
+    print("CLEAR")
+PYCHECK
+)"
+    fi
+
+    # (c) Only tear down the SHARED dashboard when no other project remains
+    # (CLEAR), or when python3 was unavailable (legacy fallback: avoid leaking
+    # the shared dashboard on minimal systems).
+    if [ "$_decision" = "CLEAR" ]; then
+        if [ -f "$_shared_pidfile" ]; then
+            local _shared_pid
+            _shared_pid=$(cat "$_shared_pidfile" 2>/dev/null)
+            if [ -n "$_shared_pid" ]; then
+                kill "$_shared_pid" 2>/dev/null || true
+                sleep 0.5
+                kill -9 "$_shared_pid" 2>/dev/null || true
+            fi
+            rm -f "$_shared_pidfile" 2>/dev/null || true
+        fi
+        # (d) Defense-in-depth: reclaim the dashboard port only in the CLEAR
+        # case, so we never kill a shared dashboard another project owns.
+        if command -v lsof >/dev/null 2>&1; then
+            lsof -ti:"${DASHBOARD_PORT:-57374}" -sTCP:LISTEN 2>/dev/null | xargs kill 2>/dev/null || true
+        fi
+    fi
+}
+# Register as running now. We deliberately do NOT install an EXIT trap to
+# flip it to idle: a top-level EXIT trap here would be clobbered by the
+# lock-release EXIT trap installed later in the main path (and could
+# interfere with it). Instead the dashboard determines live vs stale by
+# checking whether the recorded pid is still alive (registry stores pid),
+# which is robust even on hard kills where a trap would never fire.
+loki_register_running_project running
+
 # Complexity Tiers (Auto-Claude pattern)
 # auto = detect from PRD/codebase, simple = 3 phases, standard = 6 phases, complex = 8 phases
 COMPLEXITY_TIER=${LOKI_COMPLEXITY:-auto}
@@ -12233,6 +12344,13 @@ cleanup() {
             app_runner_cleanup
         fi
         stop_status_monitor
+        # v7.7.30: tear down this project's dashboard contribution on a
+        # deliberate STOP-file exit. stop_dashboard handles the project-local
+        # dashboard (.loki/dashboard/dashboard.pid); the helper marks this
+        # project stopped in the registry and kills the shared dashboard only
+        # when no other project is still running.
+        stop_dashboard
+        loki_mark_project_stopped_and_maybe_kill_shared_dashboard
         kill_all_registered
         rm -f "$loki_dir/loki.pid" 2>/dev/null
         # Clean up per-session PID file if running with session ID
@@ -12274,6 +12392,13 @@ except (json.JSONDecodeError, OSError): pass
             app_runner_cleanup
         fi
         stop_status_monitor
+        # v7.7.30: tear down this project's dashboard contribution on a
+        # deliberate double-Ctrl+C exit. stop_dashboard handles the
+        # project-local dashboard; the helper marks this project stopped in
+        # the registry and kills the shared dashboard only when no other
+        # project is still running.
+        stop_dashboard
+        loki_mark_project_stopped_and_maybe_kill_shared_dashboard
         kill_all_registered
         rm -f "$loki_dir/loki.pid" "$loki_dir/PAUSE" 2>/dev/null
         # UT2-13: Clear cli-provider marker on session end.

package/dashboard/__init__.py

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

package/dashboard/registry.py

@@ -189,6 +189,40 @@ def update_last_accessed(identifier: str) -> Optional[dict]:
     return None
 
 
+def mark_project_stopped(identifier: str) -> Optional[dict]:
+    """
+    Mark a project's runtime status as stopped and clear its live pid.
+
+    Used when a session ends (loki stop, dashboard per-project stop, or a
+    graceful Ctrl+C teardown) so the multi-project switcher reflects the
+    project as not-running immediately, without waiting for pid-liveness to
+    catch up. The entry is intentionally kept (not unregistered) so the
+    project stays selectable and re-registers cleanly on the next loki start.
+
+    Args:
+        identifier: Project ID, path, or alias
+
+    Returns:
+        The updated project entry, or None if no matching project was found.
+        Idempotent: marking an already-stopped project is a no-op that still
+        returns the entry.
+    """
+    registry = _load_registry()
+
+    for pid_key, project in registry["projects"].items():
+        if (
+            pid_key == identifier
+            or project["path"] == identifier
+            or project.get("alias") == identifier
+        ):
+            project["status"] = "stopped"
+            project["pid"] = None
+            project["updated_at"] = datetime.now(timezone.utc).isoformat()
+            _save_registry(registry)
+            return project
+    return None
+
+
 def check_project_health(identifier: str) -> dict:
     """
     Check the health status of a project.