loki-mode 7.7.28 → 7.7.29

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.29
 
 **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.29 | [Autonomi](https://www.autonomi.dev/) flagship product | ~260 lines core**

package/VERSION

@@ -1 +1 @@
-7.7.28
+7.7.29

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
@@ -1896,17 +1903,23 @@ except (json.JSONDecodeError, OSError): pass
         # 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. Check BOTH the project-local in-build
+        # dashboard (.loki/dashboard) and the standalone one
+        # (~/.loki/dashboard) so cleanup never leaves an orphan regardless of
+        # which path started it.
+        local _dash_pidf
+        for _dash_pidf in "$LOKI_DIR/dashboard/dashboard.pid" "${HOME}/.loki/dashboard/dashboard.pid"; 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
@@ -2536,15 +2549,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 +3327,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 +3590,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 +7853,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 +7895,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 +7918,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 +7959,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,47 @@ 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
+}
+# 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}

package/dashboard/__init__.py

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

package/dashboard/server.py

@@ -2140,6 +2140,71 @@ async def clear_focus():
     return {"project_dir": None, "loki_dir": str(_get_loki_dir())}
 
 
+@app.get("/api/running-projects")
+async def list_running_projects():
+    """List registered projects enriched with live status for the dashboard
+    project switcher (v7.7.29 multi-project support).
+
+    NOTE: deliberately NOT under /api/projects/* because /api/projects/{id}
+    (int path param) would shadow a /api/projects/running literal and 422.
+
+    Returns every registered project (from ~/.loki/dashboard/projects.json,
+    populated by `loki start`), each annotated with:
+      - running: whether the recorded orchestrator pid is still alive
+      - is_active: whether it is the currently focused project
+    Live-vs-stale is derived from pid liveness, which is robust even when a
+    session is hard-killed (no exit hook fires). Never raises: registry
+    problems degrade to an empty list.
+    """
+    out = []
+    try:
+        projects = registry.list_projects(include_inactive=True)
+    except Exception:
+        projects = []
+    active = _active_project_dir
+    for p in projects:
+        path = p.get("path", "")
+        pid = p.get("pid")
+        running = False
+        if isinstance(pid, int) and pid > 0:
+            try:
+                os.kill(pid, 0)
+                running = True  # signal 0 delivered -> pid alive
+            except PermissionError:
+                running = True  # pid exists but owned by another user
+            except (ProcessLookupError, OSError):
+                running = False  # ESRCH -> dead
+        # A project is also "live" if its .loki/session.json says running.
+        if not running and path:
+            try:
+                sess = _Path(path) / ".loki" / "session.json"
+                if sess.is_file():
+                    import json as _json
+                    s = _json.loads(sess.read_text())
+                    running = s.get("status") == "running"
+            except Exception:
+                pass
+        # Compare via realpath: /api/focus resolves symlinks (e.g. macOS
+        # /tmp -> /private/tmp) while the registry stores abspath, so a plain
+        # abspath compare would never match a focused symlinked project.
+        is_active = False
+        if active and path:
+            try:
+                is_active = os.path.realpath(active) == os.path.realpath(path)
+            except OSError:
+                is_active = os.path.abspath(active) == os.path.abspath(path)
+        out.append({
+            "id": p.get("id"),
+            "name": p.get("name") or (os.path.basename(path) if path else "project"),
+            "path": path,
+            "port": p.get("port"),
+            "status": p.get("status"),
+            "running": running,
+            "is_active": is_active,
+        })
+    return {"projects": out, "active_project_dir": active}
+
+
 # =============================================================================
 # Enterprise Features (Optional - enabled via environment variables)
 # =============================================================================

package/dashboard/static/index.html

@@ -285,6 +285,25 @@
       box-shadow: 0 0 0 3px var(--loki-accent-glow);
     }
 
+    /* v7.7.29 multi-project switcher */
+    .project-switcher {
+      margin-left: 14px;
+      padding: 5px 10px;
+      background: var(--loki-bg-primary);
+      border: 1px solid var(--loki-border);
+      border-radius: 6px;
+      font-size: 12px;
+      font-family: 'Inter', system-ui, sans-serif;
+      color: var(--loki-text-primary);
+      cursor: pointer;
+      max-width: 280px;
+    }
+    .project-switcher:focus {
+      outline: none;
+      border-color: var(--loki-accent);
+      box-shadow: 0 0 0 3px var(--loki-accent-glow);
+    }
+
     /* Main Content */
     .main-content {
       padding: 28px 32px;
@@ -532,6 +551,11 @@
         </button>
         <span class="logo-brand">Loki Mode</span>
         <span class="logo-subtitle">powered by Autonomi</span>
+        <!-- v7.7.29 multi-project switcher: lists projects running loki in
+             different folders and switches which one the dashboard shows. -->
+        <select class="project-switcher" id="project-switcher" title="Switch project" aria-label="Switch project">
+          <option value="">All projects (current dir)</option>
+        </select>
       </div>
 
       <nav class="nav-links">
@@ -13373,6 +13397,49 @@ document.addEventListener('DOMContentLoaded', function() {
   var initResult = LokiDashboard.init({ autoDetectContext: true });
   console.log('Loki Dashboard initialized:', initResult);
 
+  // v7.7.29 multi-project switcher: populate from /api/running-projects and
+  // switch the focused project via /api/focus. Fully best-effort; if the
+  // endpoint is unavailable the dropdown simply stays at "All projects".
+  (function initProjectSwitcher() {
+    var sel = document.getElementById('project-switcher');
+    if (!sel) return;
+    function refresh() {
+      fetch('/api/running-projects')
+        .then(function(r){ return r.ok ? r.json() : null; })
+        .then(function(data){
+          if (!data || !Array.isArray(data.projects)) return;
+          var current = sel.value;
+          // Rebuild options: keep the "All projects" default first.
+          sel.innerHTML = '';
+          var optAll = document.createElement('option');
+          optAll.value = ''; optAll.textContent = 'All projects (current dir)';
+          sel.appendChild(optAll);
+          data.projects.forEach(function(p){
+            var o = document.createElement('option');
+            o.value = p.path || '';
+            var dot = p.running ? '* ' : '';   // running marker (ASCII)
+            o.textContent = dot + (p.name || p.path || 'project');
+            if (p.is_active) o.selected = true;
+            sel.appendChild(o);
+          });
+          if (!data.active_project_dir && current === '') sel.value = '';
+        })
+        .catch(function(){ /* offline / no endpoint: leave as-is */ });
+    }
+    sel.addEventListener('change', function(){
+      var dir = sel.value;
+      var req = dir
+        ? fetch('/api/focus', { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ project_dir: dir }) })
+        : fetch('/api/focus', { method: 'DELETE' });
+      req.then(function(){
+        // Reload so every panel re-fetches against the newly focused project.
+        window.location.reload();
+      }).catch(function(){ /* ignore */ });
+    });
+    refresh();
+    setInterval(refresh, 15000);
+  })();
+
   // Theme toggle functionality
   var themeToggle = document.getElementById('theme-toggle');
   var themeLabel = document.getElementById('theme-label');

package/docs/INSTALLATION.md

@@ -2,7 +2,7 @@
 
 The flagship product of [Autonomi](https://www.autonomi.dev/). Complete installation instructions for all platforms and use cases.
 
-**Version:** v7.7.28
+**Version:** v7.7.29
 
 ---