code-context-control 2.141.0__tar.gz → 2.143.0__tar.gz

{code_context_control-2.141.0 → code_context_control-2.143.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-context-control
-Version: 2.141.0
+Version: 2.143.0
 Summary: Local MCP code-intelligence for AI coding tools: surgical search/read/edit, agent-config version history, path-level access + masking guards, and a multi-project hub.
 Author-email: Dimitri Tselenchuk <dtselenc@gmail.com>
 License-Expression: Apache-2.0
@@ -163,6 +163,8 @@ Every C3-initialized project registers itself here on `c3 init`. Filter by activ
 
 Three top-level views — **Projects**, **Tasks** (a cross-project kanban), and **Credentials** — plus a drill-in panel per project covering Overview, Sub-projects, Tasks, Artifacts, Memory, Ledger, Sessions, Health, Budget, Credentials, Config, and MCP.
 
+**Sessions** (v2.143.0) lists past Claude Code sessions across projects: the title, first and last prompt, the agent's note, and linked tasks and decisions. **Resume** opens a terminal running `claude --resume <id>`, or you can copy the command or open the claude.ai/code link. Agents mark dead ends stale with `c3_session(action='stale')`. → [Sessions](https://github.com/drknowhow/code-context-control/blob/main/docs/sessions.md)
+
 **Sub-projects** make one project a first-class child of another, with its own `.c3`. It can be a nested repo — the parent's index then excludes its subtree — or a project anywhere else on disk, linked by path. Hierarchies nest up to 8 levels, and `c3_search` / `c3_memory` fan out on demand (`scope='all'`, or one by name). → [Sub-projects guide](https://github.com/drknowhow/code-context-control/blob/main/docs/sub-projects.md)
 
 ### Per-project UI

{code_context_control-2.141.0 → code_context_control-2.143.0}/README.md

@@ -97,6 +97,8 @@ Every C3-initialized project registers itself here on `c3 init`. Filter by activ
 
 Three top-level views — **Projects**, **Tasks** (a cross-project kanban), and **Credentials** — plus a drill-in panel per project covering Overview, Sub-projects, Tasks, Artifacts, Memory, Ledger, Sessions, Health, Budget, Credentials, Config, and MCP.
 
+**Sessions** (v2.143.0) lists past Claude Code sessions across projects: the title, first and last prompt, the agent's note, and linked tasks and decisions. **Resume** opens a terminal running `claude --resume <id>`, or you can copy the command or open the claude.ai/code link. Agents mark dead ends stale with `c3_session(action='stale')`. → [Sessions](https://github.com/drknowhow/code-context-control/blob/main/docs/sessions.md)
+
 **Sub-projects** make one project a first-class child of another, with its own `.c3`. It can be a nested repo — the parent's index then excludes its subtree — or a project anywhere else on disk, linked by path. Hierarchies nest up to 8 levels, and `c3_search` / `c3_memory` fan out on demand (`scope='all'`, or one by name). → [Sub-projects guide](https://github.com/drknowhow/code-context-control/blob/main/docs/sub-projects.md)
 
 ### Per-project UI

{code_context_control-2.141.0 → code_context_control-2.143.0}/cli/c3.py

@@ -91,7 +91,7 @@ console = Console() if HAS_RICH else None
 # Config
 CONFIG_DIR = ".c3"
 CONFIG_FILE = ".c3/config.json"
-__version__ = "2.141.0"
+__version__ = "2.143.0"
 
 # The PreToolUse matcher for native subagent calls (installer and hub migration).
 AGENT_MATCHER = "Agent|Task"
@@ -5081,6 +5081,7 @@ back to native tools as the task progresses.
 - **Filter**: `c3_filter(text=...)` — for terminal output >10 lines
 - **Shell**: `c3_shell(cmd, timeout=60)` — structured shell exec (tests/git/build). Auto-filters output, logs git mutations to the ledger. Native Bash for interactive/TTY only
 - **Memory**: `c3_memory(action='recall')` — full recall. `index` + `fetch` for token-efficient two-step retrieval
+- **Sessions** (v2.143.0+): `c3_session(action='note', data=<done>, reasoning=<next steps>)` before you stop; `c3_session(action='stale', target=<id>, reasoning=<why>)` when your work supersedes, finishes or abandons an earlier session (`action='list'` shows them). The Hub/Desk Sessions view resumes the rest
 - **Delegate**: `c3_delegate(task, task_type, context|file_path)` — your own provider one tier down (default `backend='host'`, `tier='small'`; Claude Code: Haiku) for bounded answers: summarize a diff/log, explain a function, triage a traceback. `scout=true` lets it look files up itself; `write_paths='a.py,b.py'` has Sonnet make a change you specified in only those files and return the diff. Multi-step work: the `c3-scout` (haiku) / `c3-worker` (sonnet) subagents; an `Agent` call with no `model` runs one tier below you (pass `model=` to choose)
 - **Local CI** (v2.79.0+): `c3_ci(action='inspect|run|rerun|failures')` — run THIS repo's real `.github/workflows` here instead of pushing for feedback. `run` executes in `needs` order; `failures` gives {file,line,message}; `rerun` retries only what failed. Only `FULL_CI_PASS` means safe to push — `PARTIAL_PASS` means something did not run (other OS, unsupported action, or your selection).
 - **Bitbucket** (v2.30.0+, when `c3 bitbucket login` has run): `c3_bitbucket(action='list_prs|get_pr|merge_pr|...')` — self-hosted Bitbucket Data Center / Server. Token in OS keyring; mutating actions auto-log to the edit ledger.

{code_context_control-2.141.0 → code_context_control-2.143.0}/cli/hub_server.py

@@ -77,6 +77,10 @@ _HUB_CONFIG_DEFAULTS = {
     "ui_reap_minutes": 30,
 }
 
+# Top-bar tabs a persisted ``main_view`` may name (cli/hub_ui/components/topbar.js).
+_MAIN_VIEWS = {"projects", "board", "ci", "creds", "tokens", "locks", "access",
+               "enforce", "sessions"}
+
 # How often the hub reaps orphaned UI servers and chases autostart projects.
 _UI_SWEEP_INTERVAL_S = 60
 
@@ -348,6 +352,7 @@ _HUB_JS_FILES = [
     "hub_ui/components/hub_locks.js",
     "hub_ui/components/hub_access.js",
     "hub_ui/components/hub_enforcement.js",
+    "hub_ui/components/hub_sessions.js",
     "hub_ui/components/hub_ci.js",
     "hub_ui/components/drill_subprojects.js",
     "hub_ui/components/drill_health.js",
@@ -447,9 +452,11 @@ def api_hub_config_set():
         cfg["projects_view"] = projects_view
     if "main_view" in data:
         main_view = str(data["main_view"]).strip().lower()
-        if main_view not in {"projects", "board", "creds", "locks", "enforce"}:
-            return jsonify({"error": "main_view must be 'projects', 'board', "
-                                     "'creds', 'locks' or 'enforce'"}), 400
+        # Every tab the top bar offers. ci, tokens and access were missing, so
+        # choosing one of those tabs 400'd here and never survived a reload.
+        if main_view not in _MAIN_VIEWS:
+            return jsonify({"error": "main_view must be one of: "
+                                     + ", ".join(sorted(_MAIN_VIEWS))}), 400
         cfg["main_view"] = main_view
     if "oracle_url" in data:
         cfg["oracle_url"] = str(data["oracle_url"]).strip()
@@ -777,45 +784,9 @@ def api_launch_ide():
                 kwargs = {"start_new_session": True}
                 subprocess.Popen([cmd, str(path)], **kwargs)
         else:
-            # Terminal CLIs: open a new terminal window running the command
-            if sys.platform == "win32":
-                # On Windows, use the command directly (globally installed CLIs)
-                win_cmd = cmd
-
-                # Try Windows Terminal first, fall back to cmd
-                try:
-                    # Windows Terminal 'wt' needs a full command to run
-                    # We wrap the command in 'cmd /k' so the terminal stays open
-                    subprocess.Popen(
-                        ["wt", "-d", str(path), "cmd", "/k", win_cmd],
-                        creationflags=subprocess.DETACHED_PROCESS | subprocess.CREATE_NEW_PROCESS_GROUP,
-                    )
-                except FileNotFoundError:
-                    # Fallback to classic cmd.exe
-                    subprocess.Popen(
-                        ["cmd", "/c", "start", "", "cmd", "/k", win_cmd],
-                        cwd=str(path),
-                        creationflags=subprocess.CREATE_NEW_PROCESS_GROUP,
-                    )
-            elif sys.platform == "darwin":
-                script = (
-                    f'tell application "Terminal" to do script '
-                    f'"cd {shlex.quote(str(path))} && {cmd}"'
-                )
-                subprocess.Popen(["osascript", "-e", script])
-            else:
-                q = shlex.quote(str(path))
-                for term_args in [
-                    ["gnome-terminal", "--", "bash", "-c", f"cd {q} && {cmd}; exec bash"],
-                    ["xterm", "-e", f"bash -c 'cd {q} && {cmd}; exec bash'"],
-                    ["konsole", "-e", "bash", "-c", f"cd {q} && {cmd}; exec bash"],
-                    ["xfce4-terminal", "--command", f"bash -c 'cd {q} && {cmd}; exec bash'"],
-                ]:
-                    try:
-                        subprocess.Popen(term_args, start_new_session=True)
-                        break
-                    except FileNotFoundError:
-                        continue
+            # Terminal CLIs: open a new terminal window running the command.
+            from services.terminal_launch import spawn_terminal
+            spawn_terminal(path, [cmd])
 
         return jsonify({"launched": True})
     except Exception as e:
@@ -3658,8 +3629,10 @@ def api_hub_access():
     """Effective Access Guard rules + override policy for one project.
 
     Read-only companion to the approvals list: the per-project mode matrix
-    the tab renders under the pending cards. Rule MUTATION stays on the
-    per-project server and the CLI — this route never writes.
+    the tab renders under the pending cards. This route never writes; rule
+    mutation from the Hub is ``/api/hub/access/rule`` (add) and
+    ``/api/hub/access/rule/remove`` (v2.142.0), besides the per-project
+    server and the CLI.
     """
     from services import access_guard
     from services import override_policy as opol
@@ -3679,6 +3652,180 @@ def api_hub_access():
                     "policy": policy})
 
 
+# ── Access Guard by file type, across projects (v2.142.0) ─────────────────
+# The desktop surface for path rules. The phone's /api/mobile/access/rule
+# cannot carry a bulk edit — 12 security calls a minute and no global scope,
+# both on purpose for a device that leaves the building — and the per-project
+# server only runs while its project's UI is open. So the Hub, loopback and
+# human-only, gains the same two verbs with the same asymmetry: adding a rule
+# tightens and is one call; removing a deny rule, or ANY global-scope rule,
+# needs the glob retyped. Every write is audited on the target (a global
+# write in ~/.c3, since it has no single target project).
+
+def _hub_access_audit(action: str, glob: str, kind: str, scope: str,
+                      project) -> None:
+    """Globs only — never file content. Failure-safe. Mirrors the phone's
+    ``_access_audit`` with ``via='hub'``."""
+    detail = {"kind": "access", "action": action, "glob": glob,
+              "rule_kind": kind, "scope": scope, "via": "hub"}
+    if project is not None:
+        try:
+            from services.activity_log import ActivityLog as _AL
+            _AL(str(project)).log("access_action", dict(detail))
+        except Exception:
+            pass
+        try:
+            from services.edit_ledger import EditLedger
+            EditLedger(str(project)).log_edit(
+                file=f"access://{glob}", change_type=f"access_{action}",
+                summary=f"{action} {kind} rule {glob} ({scope}) via the Hub",
+                tags=["access", action], detail=dict(detail))
+        except Exception:
+            pass
+    if scope == "global":
+        try:
+            from services import credential_store as cred_store
+            from services.activity_log import ActivityLog as _AL
+            home = cred_store.global_base()
+            if home is not None:
+                _AL(str(home)).log("access_action", dict(detail))
+        except Exception:
+            pass
+
+
+def _hub_access_target(data: dict):
+    """``(scope, project_path_or_None, error_response_or_None)``."""
+    scope = str(data.get("scope") or "project").strip().lower()
+    if scope not in ("project", "global"):
+        return scope, None, (jsonify(
+            {"error": "scope must be 'project' or 'global'"}), 400)
+    if scope == "global":
+        return scope, None, None
+    raw = str(data.get("path") or "").strip()
+    if not raw:
+        return scope, None, (jsonify(
+            {"error": "path is required for project scope"}), 400)
+    try:
+        resolved = _resolve_project_path(raw)
+    except ValueError as e:
+        return scope, None, (jsonify({"error": str(e)}), 404)
+    # set_rule would create .c3/config.json in any directory it is handed;
+    # a rule in a folder C3 does not manage protects nothing and says it does.
+    if not (Path(resolved) / ".c3").is_dir():
+        return scope, None, (jsonify(
+            {"error": "not initialized for C3", "needs_init": True}), 409)
+    return scope, str(resolved), None
+
+
+@app.route("/api/hub/access/overview", methods=["GET"])
+def api_hub_access_overview():
+    """Every registered project's own path rules, plus global and builtin.
+
+    Per-row isolation like the enforcement and policy overviews: a project we
+    could not read reports ``error`` rather than an empty rule list — "no
+    rules" is a claim about a repo, and we would be making it blind. A corrupt
+    scope is reported as corrupt: it evaluates deny-all until repaired by
+    hand, which is the opposite of what an empty list would suggest.
+    Builtin rules are read once, from the global realm; a project-scope
+    builtin mode (set with the CLI) is not reflected per row.
+    """
+    empty = {"deny": [], "read_only": [], "confirm": [], "mask": 0,
+             "corrupt": False}
+    rows = []
+    for p in _pm().list_projects():
+        ppath = str(p.get("path") or "")
+        row = {"name": p.get("name") or Path(ppath).name, "path": ppath,
+               "initialized": True, "error": None, "rules": dict(empty)}
+        try:
+            if not (Path(ppath) / ".c3").is_dir():
+                row["initialized"] = False
+            else:
+                row["rules"] = access_guard.scope_rules("project", ppath)
+        except Exception as e:
+            row["error"] = str(e)
+        rows.append(row)
+
+    try:
+        global_rules = {**access_guard.scope_rules("global"), "error": None}
+    except Exception as e:
+        global_rules = {**empty, "error": str(e)}
+    try:
+        home = access_guard._global_base()
+        b = access_guard.list_rules(str(home) if home else ".")["builtin"]
+        builtin = {"deny": list(b.get("deny") or []),
+                   "read_only": list(b.get("read_only") or []),
+                   "confirm": list(b.get("confirm") or []), "error": None}
+    except Exception as e:
+        builtin = {"deny": [], "read_only": [], "confirm": [], "error": str(e)}
+
+    return jsonify({
+        "projects": rows,
+        "global": global_rules,
+        "builtin": builtin,
+        # Strictest last. "allow" is the absence of a rule, not a kind.
+        "kinds": ["confirm", "read_only", "deny"],
+        "coverage_note": access_guard.COVERAGE_MATRIX,
+    })
+
+
+@app.route("/api/hub/access/rule", methods=["POST"])
+def api_hub_access_rule_add():
+    """Add one deny / read_only / confirm rule. Tightening — no confirmation.
+
+    Body: ``{path?, scope?, glob, kind}``. ``added: false`` when an equivalent
+    glob is already there (a 200, not an error: the caller asked for the
+    state it is in).
+    """
+    data = request.get_json(silent=True) or {}
+    scope, project, err = _hub_access_target(data)
+    if err:
+        return err
+    glob = str(data.get("glob") or "")
+    kind = str(data.get("kind") or "").strip()
+    try:
+        result = access_guard.set_rule(glob, kind, scope, project or ".")
+    except ValueError as exc:
+        return jsonify({"error": str(exc)}), 400
+    if result["added"]:
+        _hub_access_audit("add", result["glob"], kind, scope, project)
+    return jsonify({"rule": result})
+
+
+@app.route("/api/hub/access/rule/remove", methods=["POST"])
+def api_hub_access_rule_remove():
+    """Remove one rule. Loosening.
+
+    Body: ``{path?, scope?, glob, kind, confirm?}``. A ``deny`` rule, and any
+    rule in the GLOBAL scope (it governs every project on the machine), needs
+    ``confirm`` equal to the glob — the CLI's "type the glob again". A
+    read_only or confirm rule in one project does not: it downgrades writes
+    to writable-or-ask, not to fully visible. POST rather than DELETE so the
+    body survives every client.
+    """
+    data = request.get_json(silent=True) or {}
+    scope, project, err = _hub_access_target(data)
+    if err:
+        return err
+    glob = str(data.get("glob") or "")
+    kind = str(data.get("kind") or "").strip()
+    canon = access_guard._norm_glob(glob)
+    if kind == "deny" or scope == "global":
+        if access_guard._norm_glob(data.get("confirm")) != canon or not canon:
+            return jsonify({
+                "error": ("removing a deny rule weakens protection"
+                          if kind == "deny" else
+                          "removing a global rule weakens every project"),
+                "needs_confirmation": True, "confirm_with": canon,
+            }), 400
+    try:
+        result = access_guard.remove_rule(glob, kind, scope, project or ".")
+    except ValueError as exc:
+        return jsonify({"error": str(exc)}), 400
+    if result["removed"]:
+        _hub_access_audit("remove", result["glob"], kind, scope, project)
+    return jsonify(result)
+
+
 # ── Project management: tasks / milestones / notes (v2.45.0) ──────────────
 # Direct TaskStore per request (reload-per-op store — no runtime build needed
 # for mutations); every write audited to the target project's activity log.
@@ -4632,6 +4779,164 @@ def api_sessions():
         return jsonify({"error": str(e)}), 500
 
 
+# ─── Routes: session history (2.143.0) ──────────────────────────────────────
+# PAST agent sessions: find one, see what it was, resume it, mark it stale.
+# Not to be confused with /api/sessions* above, which manage per-project UI
+# servers. Loopback + the CSRF guard like every Hub route; deliberately NOT
+# mirrored on the Oracle gateway, which can bind to the tailnet — transcript
+# previews stay on this machine. See docs/sessions.md.
+
+_SESSIONS_FEATURES = ["list", "detail", "mark", "note", "resume", "remote"]
+_SESSIONS_STALE = {"hide", "only", "likely", "all"}
+
+
+def _session_project(raw: str):
+    """``{name, path}`` of the REGISTERED project ``raw`` names, or None.
+
+    Every session route resolves its project against the registry first, so a
+    caller can never point the catalog (or a terminal) at an arbitrary folder.
+    """
+    raw = str(raw or "").strip()
+    if not raw:
+        return None
+    want = os.path.normcase(os.path.normpath(raw))
+    for p in _pm().list_projects():
+        path = str(p.get("path") or "")
+        if path and os.path.normcase(os.path.normpath(path)) == want:
+            return {"name": str(p.get("name") or Path(path).name), "path": path}
+    return None
+
+
+def _session_project_or_error(raw: str):
+    proj = _session_project(raw)
+    if proj is None:
+        return None, (jsonify({"error": "not a registered project"}), 404)
+    if not (Path(proj["path"]) / ".c3").is_dir():
+        return None, (jsonify({"error": "C3 is not initialized in this project"}), 409)
+    return proj, None
+
+
+@app.route("/api/hub/sessions/overview", methods=["GET"])
+def api_hub_sessions_overview():
+    """Per-project session counts for the picker. Stats files only."""
+    from concurrent.futures import ThreadPoolExecutor
+
+    from services import session_catalog as sc
+
+    def one(p):
+        ppath = str(p.get("path") or "")
+        name = str(p.get("name") or Path(ppath).name)
+        row = {"name": name, "path": ppath, "initialized": True, "error": None,
+               "counts": {"total": 0, "live": 0, "stale": 0, "idle": 0},
+               "last_active": "", "newest": None, "transcripts": False}
+        try:
+            if not (Path(ppath) / ".c3").is_dir():
+                row["initialized"] = False
+            else:
+                row.update(sc.overview(ppath, name=name))
+        except Exception as e:
+            row["error"] = str(e)
+        return row
+
+    with ThreadPoolExecutor(max_workers=8) as pool:
+        rows = list(pool.map(one, _pm().list_projects()))
+    rows.sort(key=lambda r: r.get("last_active") or "", reverse=True)
+    return jsonify({"projects": rows, "features": _SESSIONS_FEATURES})
+
+
+@app.route("/api/hub/sessions", methods=["GET"])
+def api_hub_sessions_list():
+    """Rows for one project (``?path=``) or every project (no path)."""
+    from services import session_catalog as sc
+    stale = (request.args.get("stale") or "hide").strip().lower()
+    if stale not in _SESSIONS_STALE:
+        return jsonify({"error": f"stale must be one of {sorted(_SESSIONS_STALE)}"}), 400
+    try:
+        limit = int(request.args.get("limit") or 50)
+    except ValueError:
+        return jsonify({"error": "limit must be an integer"}), 400
+    q = (request.args.get("q") or "").strip()
+    before = (request.args.get("before") or "").strip()
+    raw = (request.args.get("path") or "").strip()
+    try:
+        if raw:
+            proj, err = _session_project_or_error(raw)
+            if err:
+                return err
+            res = sc.list_sessions(proj["path"], name=proj["name"], stale=stale, q=q,
+                                   limit=limit, before=before)
+            res["errors"] = []
+        else:
+            projects = [{"name": str(p.get("name") or ""), "path": str(p.get("path") or "")}
+                        for p in _pm().list_projects()]
+            res = sc.list_many(projects, stale=stale, q=q, limit=limit, before=before)
+        return jsonify(res)
+    except Exception as e:
+        return jsonify({"error": str(e)}), 500
+
+
+@app.route("/api/hub/sessions/detail", methods=["GET"])
+def api_hub_sessions_detail():
+    from services import session_catalog as sc
+    proj, err = _session_project_or_error(request.args.get("path") or "")
+    if err:
+        return err
+    res = sc.get_session(proj["path"], request.args.get("id") or "", name=proj["name"])
+    if "error" in res:
+        return jsonify(res), 404
+    return jsonify(res)
+
+
+@app.route("/api/hub/sessions/mark", methods=["POST"])
+def api_hub_sessions_mark():
+    """Body: {path, id, op: stale|unstale|note, reason?, successor?,
+    summary?, next_steps?}. Recorded as ``by: user``."""
+    from services import session_catalog as sc
+    data = request.get_json(force=True) or {}
+    proj, err = _session_project_or_error(data.get("path") or "")
+    if err:
+        return err
+    res = sc.mark(proj["path"], str(data.get("id") or ""), str(data.get("op") or ""),
+                  reason=str(data.get("reason") or ""),
+                  successor=str(data.get("successor") or ""),
+                  summary=str(data.get("summary") or ""),
+                  next_steps=str(data.get("next_steps") or ""), by="user")
+    if "error" in res:
+        return jsonify({"error": res["error"]}), int(res.get("status") or 400)
+    return jsonify(res)
+
+
+@app.route("/api/hub/sessions/resume", methods=["POST"])
+def api_hub_sessions_resume():
+    """Body: {path, id}. Opens a terminal running ``claude --resume <id>``.
+
+    The command is built by the catalog from a validated id — nothing from the
+    request reaches the command line. 409 while the session is open.
+    """
+    from services import session_catalog as sc
+    from services import terminal_launch
+    data = request.get_json(force=True) or {}
+    proj, err = _session_project_or_error(data.get("path") or "")
+    if err:
+        return err
+    spec = sc.resume_spec(proj["path"], str(data.get("id") or ""))
+    if "error" in spec:
+        return jsonify({"error": spec["error"]}), int(spec.get("status") or 404)
+    try:
+        terminal_launch.spawn_terminal(spec["cwd"], spec["argv"])
+    except Exception as e:
+        return jsonify({"error": f"could not open a terminal: {e}",
+                        "command": spec["command"]}), 500
+    try:
+        from services.activity_log import ActivityLog
+        ActivityLog(proj["path"]).log("session_resume", {
+            "host_session_id": spec["id"], "by": "user", "cwd": spec["cwd"]})
+    except Exception:
+        pass
+    return jsonify({"launched": True, "id": spec["id"], "command": spec["command"],
+                    "cwd": spec["cwd"]})
+
+
 # ─── Error handlers ──────────────────────────────────────────────────────────
 
 @app.errorhandler(404)

{code_context_control-2.141.0 → code_context_control-2.143.0}/cli/hub_ui/app.js

@@ -17,7 +17,7 @@ function App() {
   const [version, setVersion] = useState('');
   const [projects, setProjects] = useState([]);
   const [loaded, setLoaded] = useState(false);
-  const [mainView, setMainView] = useState('projects'); // projects | board | ci | creds | locks | enforce
+  const [mainView, setMainView] = useState('projects'); // projects | board | ci | creds | tokens | locks | access | enforce | sessions
   const [filter, setFilter] = useState('all');          // all | active | idle | tag:<x>
   const [search, setSearch] = useState('');
   const [view, setView] = useState('list');             // list | grid
@@ -44,7 +44,7 @@ function App() {
       if (cfg.projects_view === 'grid') setView('grid');
       if (cfg.sidebar_collapsed != null) setSidebarCollapsed(!!cfg.sidebar_collapsed);
       if (cfg.sidebar_group) setFilter(cfg.sidebar_group);
-      if (['board', 'ci', 'creds', 'tokens', 'locks', 'access', 'enforce'].includes(cfg.main_view)) setMainView(cfg.main_view);
+      if (['board', 'ci', 'creds', 'tokens', 'locks', 'access', 'enforce', 'sessions'].includes(cfg.main_view)) setMainView(cfg.main_view);
     } catch { }
     try { const v = await api.get('/api/version'); setVersion(v.c3_version || ''); } catch { }
   }, []);
@@ -124,6 +124,8 @@ function App() {
             <HubAccess projects={projects} />
           ) : mainView === 'enforce' ? (
             <HubEnforcement projects={projects} onOpenDrill={openDrill} />
+          ) : mainView === 'sessions' ? (
+            <HubSessions projects={projects} />
           ) : (
             <React.Fragment>
               <SummaryBar projects={projects} search={search} setSearch={setSearch}