coderadar-rs 0.7.0__tar.gz → 0.7.2__tar.gz

{coderadar_rs-0.7.0 → coderadar_rs-0.7.2}/Cargo.lock

@@ -445,7 +445,7 @@ checksum = "773648b94d0e5d620f64f280777445740e61fe701025087ec8b57f45c791888b"
 
 [[package]]
 name = "core_indexer"
-version = "0.7.0"
+version = "0.7.2"
 dependencies = [
  "crossbeam-channel",
  "dashmap",

{coderadar_rs-0.7.0 → coderadar_rs-0.7.2}/Cargo.toml

@@ -3,6 +3,6 @@ members = ["core_indexer"]
 resolver = "2"
 
 [workspace.package]
-version = "0.7.0"
+version = "0.7.2"
 edition = "2021"
 license = "MIT"

{coderadar_rs-0.7.0 → coderadar_rs-0.7.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: coderadar-rs
-Version: 0.7.0
+Version: 0.7.2
 Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: MIT License
@@ -32,7 +32,7 @@ License: MIT
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown; charset=UTF-8; variant=GFM
 
-# CodeRadar v0.7.0
+# CodeRadar v0.7.2
 
 [![CI](https://github.com/opticsWolf/coderadar/actions/workflows/ci.yml/badge.svg)](https://github.com/opticsWolf/coderadar/actions/workflows/ci.yml)
 [![PyPI](https://img.shields.io/pypi/v/coderadar-rs?label=pypi)](https://pypi.org/project/coderadar-rs/)
@@ -88,8 +88,8 @@ Rust Core (ProjectedGraph, Tree-sitter 41-lang, Parallel Extraction,
 | Metric | Value |
 |--------|-------|
 | **Languages indexed** | 41 (12 Tier 1, 29 Tier 2, 330+ Tier 3) |
-| **Tests** | 857 (250 Rust + 607 Python) |
-| **MCP Tools** | 18 (explore, search, node, affected, resolve, query, search_similar, module_children, as_of, traverse, get_smells, replace_body, update_signature, rename, create_entity, compute_embeddings, reindex, update_file) |
+| **Tests** | 883 (250 Rust + 633 Python) |
+| **MCP Tools** | 19 (explore, search, node, affected, resolve, query, search_similar, module_children, as_of, traverse, get_smells, replace_body, update_signature, rename, create_entity, compute_embeddings, reindex, update_file, set_project) |
 | **Query surface** | Pest structural + Macrame agent traversals + vector search |
 | **Frameworks** | Django, Flask, FastAPI, Go, Actix, Express, Spring Boot, Laravel, ASP.NET, Rails, NestJS, Vue Router, React Router |
 | **Agents** | MCP server over stdio — finds the project root, indexes in the background, and exits with its client |
@@ -209,9 +209,15 @@ not assume the cwd is the project:
 - **Saying where it looked.** A "no index" reply names the directory being
   served and how that directory was chosen, so an agent pointed at the wrong
   project can say so.
-- **One project per server.** Every tool takes an optional `project_path`; a
-  path that is not the served root is refused with the reason, not quietly
-  answered from the wrong codebase.
+- **One project at a time.** Every tool takes an optional `project_path`; a path
+  inside the served project (a file, a subdirectory, or the root itself) is
+  accepted via nearest-marker resolution; another project is refused with the
+  reason, not quietly answered from the wrong codebase.
+- **Switching projects without restarting.** `codegraph_set_project` re-runs
+  startup against a new root from inside a tool call: that project's config
+  and mutation policy take effect, indexing restarts in the background, and an
+  explicit switch outranks the client's declared workspace for the rest of the
+  connection.
 - **Not outliving the client.** Handshake timeout, parent-process watchdog, and
   teardown when stdin closes.
 
@@ -259,6 +265,29 @@ CodeRadar detects and extracts framework-specific patterns that tree-sitter can'
 
 Framework edges are registered in the Rust graph — agents can trace from URL patterns to handler functions via `callers_of()` / `callees_of()`.
 
+## v0.7.2 Feature Highlights
+
+- **Runtime project switching** — the new `codegraph_set_project` MCP tool
+  (19 total) re-runs startup against a new root from inside a tool call:
+  that project's `.coderadar.toml` config and mutation policy take effect,
+  indexing restarts in the background, and an explicit switch outranks the
+  client's declared workspace for the rest of the connection. Unmarked roots
+  require `confirm=true`; switching to the current root is a no-op that says
+  so.
+- **`project_path` reads like agents mean it** — a file, subdirectory, or
+  root inside the served project is accepted via nearest-marker walk-up
+  (`resolve_selector`), replacing a byte-exact root comparison that refused
+  editor-tab paths and explored directories. Windows drive-letter casing can
+  no longer split one directory in two.
+- **Refusals name the way out** — "wrong project" replies point at
+  `codegraph_set_project` instead of telling the agent to edit mcp.json and
+  restart the server.
+- **One writable project at a time, unchanged** — mutation confinement
+  follows the switched root automatically: `analyze(root)` re-tightens
+  `INDEXED_ROOT`, so policy, stale-write hashes and rollback need no
+  redesign. E2E tests prove an escape-path mutation into the previous
+  project never touches disk.
+
 ## v0.7.0 Feature Highlights
 
 The v0.7 improvement plan, start to finish — write-path correctness, temporal
@@ -456,7 +485,7 @@ py_agent/src/coderadar/    # Python layer
     lsp/                   # Persistent LSP warm pool
     mutation/              # Tool router for LLM
     mcp/                   # MCP server
-      server.py            #   18 tools + guidance
+      server.py            #   19 tools + guidance
       roots.py             #   project-root ladder and marker walk-up
       startup.py           #   background index, ensure_ready()
       lazy.py              #   roots/list retry on the first tool call
@@ -465,7 +494,7 @@ py_agent/src/coderadar/    # Python layer
     visualizers/           # Mermaid + Graphviz (SCC cycle highlighting)
 
 docs/                      # Specifications + code review + performance roadmap
-tests/                     # 607 Python tests (E2E, mutation E2E, MCP, smells,
+tests/                     # 633 Python tests (E2E, mutation E2E, MCP, smells,
                            #   framework resolvers, ingest parity, benchmarks)
   mcp/                     # Root resolution, background init, lifecycle, project_path
 ```

{coderadar_rs-0.7.0 → coderadar_rs-0.7.2}/README.md

@@ -1,4 +1,4 @@
-# CodeRadar v0.7.0
+# CodeRadar v0.7.2
 
 [![CI](https://github.com/opticsWolf/coderadar/actions/workflows/ci.yml/badge.svg)](https://github.com/opticsWolf/coderadar/actions/workflows/ci.yml)
 [![PyPI](https://img.shields.io/pypi/v/coderadar-rs?label=pypi)](https://pypi.org/project/coderadar-rs/)
@@ -54,8 +54,8 @@ Rust Core (ProjectedGraph, Tree-sitter 41-lang, Parallel Extraction,
 | Metric | Value |
 |--------|-------|
 | **Languages indexed** | 41 (12 Tier 1, 29 Tier 2, 330+ Tier 3) |
-| **Tests** | 857 (250 Rust + 607 Python) |
-| **MCP Tools** | 18 (explore, search, node, affected, resolve, query, search_similar, module_children, as_of, traverse, get_smells, replace_body, update_signature, rename, create_entity, compute_embeddings, reindex, update_file) |
+| **Tests** | 883 (250 Rust + 633 Python) |
+| **MCP Tools** | 19 (explore, search, node, affected, resolve, query, search_similar, module_children, as_of, traverse, get_smells, replace_body, update_signature, rename, create_entity, compute_embeddings, reindex, update_file, set_project) |
 | **Query surface** | Pest structural + Macrame agent traversals + vector search |
 | **Frameworks** | Django, Flask, FastAPI, Go, Actix, Express, Spring Boot, Laravel, ASP.NET, Rails, NestJS, Vue Router, React Router |
 | **Agents** | MCP server over stdio — finds the project root, indexes in the background, and exits with its client |
@@ -175,9 +175,15 @@ not assume the cwd is the project:
 - **Saying where it looked.** A "no index" reply names the directory being
   served and how that directory was chosen, so an agent pointed at the wrong
   project can say so.
-- **One project per server.** Every tool takes an optional `project_path`; a
-  path that is not the served root is refused with the reason, not quietly
-  answered from the wrong codebase.
+- **One project at a time.** Every tool takes an optional `project_path`; a path
+  inside the served project (a file, a subdirectory, or the root itself) is
+  accepted via nearest-marker resolution; another project is refused with the
+  reason, not quietly answered from the wrong codebase.
+- **Switching projects without restarting.** `codegraph_set_project` re-runs
+  startup against a new root from inside a tool call: that project's config
+  and mutation policy take effect, indexing restarts in the background, and an
+  explicit switch outranks the client's declared workspace for the rest of the
+  connection.
 - **Not outliving the client.** Handshake timeout, parent-process watchdog, and
   teardown when stdin closes.
 
@@ -225,6 +231,29 @@ CodeRadar detects and extracts framework-specific patterns that tree-sitter can'
 
 Framework edges are registered in the Rust graph — agents can trace from URL patterns to handler functions via `callers_of()` / `callees_of()`.
 
+## v0.7.2 Feature Highlights
+
+- **Runtime project switching** — the new `codegraph_set_project` MCP tool
+  (19 total) re-runs startup against a new root from inside a tool call:
+  that project's `.coderadar.toml` config and mutation policy take effect,
+  indexing restarts in the background, and an explicit switch outranks the
+  client's declared workspace for the rest of the connection. Unmarked roots
+  require `confirm=true`; switching to the current root is a no-op that says
+  so.
+- **`project_path` reads like agents mean it** — a file, subdirectory, or
+  root inside the served project is accepted via nearest-marker walk-up
+  (`resolve_selector`), replacing a byte-exact root comparison that refused
+  editor-tab paths and explored directories. Windows drive-letter casing can
+  no longer split one directory in two.
+- **Refusals name the way out** — "wrong project" replies point at
+  `codegraph_set_project` instead of telling the agent to edit mcp.json and
+  restart the server.
+- **One writable project at a time, unchanged** — mutation confinement
+  follows the switched root automatically: `analyze(root)` re-tightens
+  `INDEXED_ROOT`, so policy, stale-write hashes and rollback need no
+  redesign. E2E tests prove an escape-path mutation into the previous
+  project never touches disk.
+
 ## v0.7.0 Feature Highlights
 
 The v0.7 improvement plan, start to finish — write-path correctness, temporal
@@ -422,7 +451,7 @@ py_agent/src/coderadar/    # Python layer
     lsp/                   # Persistent LSP warm pool
     mutation/              # Tool router for LLM
     mcp/                   # MCP server
-      server.py            #   18 tools + guidance
+      server.py            #   19 tools + guidance
       roots.py             #   project-root ladder and marker walk-up
       startup.py           #   background index, ensure_ready()
       lazy.py              #   roots/list retry on the first tool call
@@ -431,7 +460,7 @@ py_agent/src/coderadar/    # Python layer
     visualizers/           # Mermaid + Graphviz (SCC cycle highlighting)
 
 docs/                      # Specifications + code review + performance roadmap
-tests/                     # 607 Python tests (E2E, mutation E2E, MCP, smells,
+tests/                     # 633 Python tests (E2E, mutation E2E, MCP, smells,
                            #   framework resolvers, ingest parity, benchmarks)
   mcp/                     # Root resolution, background init, lifecycle, project_path
 ```

{coderadar_rs-0.7.0 → coderadar_rs-0.7.2}/core_indexer/src/lib.rs

@@ -1580,6 +1580,17 @@ fn graph_stats(py: Python<'_>) -> PyResult<PyObject> {
         // Unix seconds of the last projection commit; 0.0 means never indexed.
         // The MCP staleness banner reads this.
         dict.set_item("indexed_at", graph.indexed_at())?;
+        // Where the loaded graph was walked from. Callers compare it against
+        // their own cwd: a graph belongs to one directory, and reusing dir
+        // A's graph to answer about dir B is how stale, wrong-tree answers
+        // look exactly like fresh ones.
+        dict.set_item(
+            "indexed_root",
+            INDEXED_ROOT
+                .read()
+                .clone()
+                .map(|p| p.to_string_lossy().into_owned()),
+        )?;
         Ok(dict.into())
     })
 }

{coderadar_rs-0.7.0 → coderadar_rs-0.7.2}/py_agent/src/coderadar/__init__.py

@@ -14,6 +14,11 @@ v3.6 Architecture:
 
 from __future__ import annotations
 
+#: The single version constant. pyproject.toml, Cargo.toml and this value
+#: move together on a release; the CLI banner, the MCP handshake and the
+#: tests read from here so no string is hardcoded twice.
+__version__ = "0.7.2"
+
 import json
 from pathlib import Path
 from typing import Any, Dict, Iterator, List, Literal, Optional, Union

{coderadar_rs-0.7.0 → coderadar_rs-0.7.2}/py_agent/src/coderadar/cli.py

@@ -11,6 +11,8 @@ import click
 from rich.console import Console
 from rich.table import Table
 
+from . import __version__
+
 console = Console()
 
 
@@ -125,25 +127,36 @@ def _ensure_graph(path: str = "."):
     — advice the user had just taken. Cross-process cold start from the
     Macrame ledger (`load_snapshot`) is Phase 3B; until then the honest
     behaviour is to index here rather than to send the user in a circle.
+
+    A loaded graph is only reused when it belongs to *this* directory: the
+    core records the root each index walked, and a graph from somewhere else
+    answers every question about this tree wrongly while looking completely
+    healthy. Different root — or no graph — means index here.
     """
     import coderadar
     from coderadar._core import graph_stats
 
     graph = coderadar.CodeGraph()
     try:
-        graph_stats()
-        return graph
+        stats = graph_stats()
+        root = stats.get("indexed_root")
+        if root:
+            # std::fs::canonicalize emits Windows verbatim paths (\\?\C:\…);
+            # pathlib compares them as a different directory, so strip first.
+            root_str = str(root).removeprefix("\\\\?\\")
+            if Path(root_str).resolve() == Path(path).resolve():
+                return graph
     except RuntimeError:
         pass
 
     _activate(path)
-    console.print("[dim]No graph in this process — indexing first...[/dim]")
+    console.print("[dim]No graph for this directory — indexing...[/dim]")
     coderadar.analyze(path)
     return graph
 
 
 @click.group()
-@click.version_option(version="0.7.0", prog_name="coderadar",
+@click.version_option(version=__version__, prog_name="coderadar",
                       message="coderadar %(version)s (spec v3.6)")
 def main():
     """CodeRadar — live semantic graph of your codebase.
@@ -672,7 +685,7 @@ def serve(project_path: str | None):
     """Start the CodeRadar MCP server over stdio.
 
     Connect an MCP client (Claude Code, Cursor, etc.) to this server to get
-    code intelligence over the indexed project — 18 tools covering search,
+    code intelligence over the indexed project — 19 tools covering search,
     exploration, structural and temporal queries, code smells, and the
     plan/review/apply mutation pipeline.
 

{coderadar_rs-0.7.0 → coderadar_rs-0.7.2}/py_agent/src/coderadar/mcp/lazy.py

@@ -74,6 +74,20 @@ class LazyRootRetry:
 
     # ── action ───────────────────────────────────────────────────────────
 
+    def mark_user_chosen(self, resolved: ResolvedRoot) -> None:
+        """Record an explicit ``codegraph_set_project`` choice.
+
+        An explicit tool call is the strongest signal there is — stronger
+        than a marker found at startup, and much stronger than the client's
+        declared workspace. The retry is marked attempted so the lazy
+        roots/list dance can never fire again: an agent that named the
+        project it wants does not want middleware second-guessing that with
+        whatever the host happens to declare as its workspace root.
+        """
+        with self._lock:
+            self._attempted = True
+            self.resolved = resolved
+
     async def attempt(self, session: Any) -> bool:
         """Ask, re-resolve, and move if the answer is better. Returns whether
         anything changed."""

{coderadar_rs-0.7.0 → coderadar_rs-0.7.2}/py_agent/src/coderadar/mcp/roots.py

@@ -42,6 +42,8 @@ MARKERS = (".coderadar", ".coderadar.toml")
 CLIENT_ROOT = "client root"
 PATH_FLAG = "--path"
 CWD = "cwd"
+#: Source name for a root named by a tool call's ``project_path`` argument.
+PROJECT_PATH = "project_path"
 
 
 @dataclass(frozen=True)
@@ -220,6 +222,32 @@ def resolve_from_client_roots(uris: Iterable[str]) -> Optional[ResolvedRoot]:
     return None
 
 
+def resolve_selector(project_path: str) -> Optional[ResolvedRoot]:
+    """Resolve a tool call's ``project_path`` argument the way agents mean it.
+
+    Agents rarely pass a project *root*: they pass a source file they can see
+    in an editor, a subdirectory they explored earlier, or a path with a
+    trailing component that only looks redundant. All of them mean "the
+    project this thing belongs to", which is exactly what the walk-up finds —
+    the same rule the startup ladder applies to its own candidates. A bare
+    directory with no marker anywhere above it is still answered, but with
+    ``marker=None`` so the caller says out loud that nothing confirmed it.
+
+    Returns None only when no part of the path names a usable directory —
+    the same rule ``_canonical`` applies for the ladder: a nonexistent name
+    under a real directory is read as a file of that directory, but a path
+    whose every component is missing is a caller error worth naming, not a
+    project to guess about.
+    """
+    resolved = _canonical(Path(project_path))
+    if resolved is None:
+        return None
+    marker = find_marker(resolved)
+    if marker is not None:
+        return ResolvedRoot(path=marker.parent, source=PROJECT_PATH, marker=marker)
+    return ResolvedRoot(path=resolved, source=PROJECT_PATH, marker=None)
+
+
 def adopt_project_root(resolved: ResolvedRoot) -> Path:
     """Make the resolved root the process cwd, and report the old one.
 

{coderadar_rs-0.7.0 → coderadar_rs-0.7.2}/py_agent/src/coderadar/mcp/server.py

@@ -21,6 +21,7 @@ import functools
 import re
 import os
 from collections import deque
+from pathlib import Path
 from typing import Any, Literal, Optional
 
 from mcp.server import MCPServer
@@ -115,15 +116,19 @@ After editing code, use the mutation pipeline to keep the graph in sync:
 - **When a file is flagged "⚠ changed on disk after index sync"**, Read those specific files for accurate content. Every file NOT flagged is fresh — still trust codegraph.
 - **If a project isn't indexed**, stop calling codegraph tools for that project and use built-in tools. Indexing is the user's decision — mention `coderadar init` if it comes up, but don't run it yourself.
 
-## One project per server
+## One project at a time
 
-This server serves a single project — the one named in the "no index" and
-"wrong project" messages. Every tool takes an optional `project_path`; pass
-it when you are working across repositories and want to be told, rather than
-quietly answered from the wrong one. A `project_path` that names the served
-project is accepted; anything else is refused with the reason. To work on a
-second project, start a second server with `coderadar mcp serve --path
-<project root>`.
+This server serves a single project at a time — the one named in the "no
+index" and "wrong project" messages. Every tool takes an optional
+`project_path`; pass it when you want to be told, rather than quietly
+answered from the wrong one. A `project_path` inside the served project (a
+file, a subdirectory, or the root itself) is accepted; another project is
+refused with the reason.
+
+To work on a different project, call `codegraph_set_project` with any path
+inside it — this server switches there, re-reads that project's config and
+re-indexes in the background. Switching is wholesale: after it, earlier
+event ids from the previous project are no longer valid.
 
 If a tool reports that indexing is still in progress, that is not an error —
 the first index walks every source file. Retry in a few seconds rather than
@@ -140,9 +145,11 @@ def create_server(graph: Any) -> MCPServer:
     Every tool is a plain, type-hinted Python function; MCPServer derives
     JSON Schema and routing from the function signature.
     """
+    from coderadar import __version__
+
     mcp = MCPServer(
         "CodeRadar",
-        version="0.7.0",
+        version=__version__,
         instructions=SERVER_INSTRUCTIONS,
     )
 
@@ -698,6 +705,31 @@ def create_server(graph: Any) -> MCPServer:
 
         return _update_file(graph, file_path, content)
 
+    # ── codegraph_set_project — switch the served project ───────────
+
+    @mcp.tool(
+        description=(
+            "Switch this server to a different project. All other tools then "
+            "verify their project_path against this root. Pass any directory, "
+            "subdirectory or file inside the target project — the nearest "
+            ".coderadar marker at or above it defines the root; pass "
+            "confirm=true only if the directory has no marker and you want it "
+            "served anyway. Config and mutation policy are re-read from the "
+            "new project, and indexing restarts in the background. Switching "
+            "replaces the graph wholesale: calls racing a switch get the old "
+            "or new answer, never a mix."
+        ),
+        annotations={
+            "read_only_hint": False,
+            "destructive_hint": False,
+            "idempotent_hint": False,
+            "open_world_hint": True,
+        },
+    )
+    def codegraph_set_project(project_path: str, confirm: bool = False) -> str:
+        """Switch the served project."""
+        return _set_project(project_path, confirm)
+
     return mcp
 
 
@@ -962,6 +994,19 @@ def _trim_to_char_budget(body_lines: list[str], max_chars: int) -> list[str]:
 
 # ── Tool Implementations ─────────────────────────────────────────────────
 
+def _served_root() -> Path:
+    """The root this server currently serves.
+
+    The lazy retry handle holds it once startup ran; a directly constructed
+    server (tests, embedders) falls back to the process cwd, by the same
+    reasoning that made serve chdir onto the root.
+    """
+    from coderadar.mcp import lazy
+
+    retry = lazy.current()
+    return retry.resolved.path if retry is not None else Path.cwd().resolve()
+
+
 def _wrong_project(project_path: Optional[str]) -> Optional[str]:
     """Answer honestly when a tool is asked about a project we are not serving.
 
@@ -970,39 +1015,44 @@ def _wrong_project(project_path: Optional[str]) -> Optional[str]:
     question nobody asked — about the wrong codebase, with no sign that
     anything went wrong.
 
-    This build cannot serve more than one project: the core keeps a single
-    GLOBAL_GRAPH and `analyze` replaces it wholesale rather than merging. So
-    a matching path is accepted and anything else is refused with the reason
-    and the workaround, rather than quietly answered.
+    This build serves one project at a time: the core keeps a single
+    GLOBAL_GRAPH and `analyze` replaces it wholesale rather than merging. But
+    the argument is read the way agents mean it: the selector walks up from
+    whatever was passed — a file, a subdirectory, or the root itself — to the
+    nearest `.coderadar` marker, so anything inside the served project is
+    accepted. Only a path that lands in some other project is refused, with
+    the reason and the way out rather than a quietly wrong answer.
 
     Returns None when the call may proceed, or the message to return instead.
     """
     if not project_path:
         return None
 
-    from pathlib import Path
-
     from coderadar.mcp import lazy
+    from coderadar.mcp.roots import resolve_selector
 
-    try:
-        asked = Path(project_path).expanduser().resolve()
-    except (OSError, RuntimeError):
-        asked = Path(project_path)
+    selected = resolve_selector(project_path)
+    if selected is None:
+        return (
+            f"`{project_path}` names no readable directory, so no project "
+            "can be selected from it. Pass a directory (or any file inside "
+            "one) and retry."
+        )
 
-    retry = lazy.current()
-    served = retry.resolved.path if retry is not None else Path.cwd().resolve()
-    if asked == served:
+    served = _served_root()
+    # Windows paths keep their drive-letter casing through resolve(); compare
+    # case-insensitively so D:/User and d:/user are one directory everywhere.
+    if os.path.normcase(str(selected.path)) == os.path.normcase(str(served)):
         return None
 
     return (
         f"This server is serving `{served}` and cannot answer for "
-        f"`{asked}`.\n\n"
-        "One project per server in this build: the index is a single "
-        "in-process graph, and pointing it elsewhere would replace the "
-        "project every other open tool call is about.\n\n"
-        "Start a second server for that project with "
-        "`coderadar mcp serve --path <project root>`, or drop the "
-        "`project_path` argument to ask about the one being served."
+        f"`{selected.path}`.\n\n"
+        "One project at a time in this build: the index is a single "
+        "in-process graph. To ask about that other project instead, call "
+        f"`codegraph_set_project` with `{selected.path}` — this server "
+        "switches there and re-indexes. Or drop the `project_path` argument "
+        f"to keep asking about `{served}`."
     )
 
 
@@ -1042,7 +1092,8 @@ def _no_index_message() -> str:
             "Nothing on disk confirmed that directory as a project root — no "
             "`.coderadar/` or `.coderadar.toml` was found at or above it.",
             "",
-            "If that is the wrong project, restart the server with "
+            "If that is the wrong project, call `codegraph_set_project` with "
+            "the right directory to switch this server there, restart with "
             "`coderadar mcp serve --path <project root>`, or run "
             "`coderadar init` in the right directory so it can be found "
             "automatically.",
@@ -1052,6 +1103,105 @@ def _no_index_message() -> str:
     return "\n".join(lines)
 
 
+def _set_project(project_path: str, confirm: bool = False) -> str:
+    """Switch the served project, and say what happened.
+
+    One project at a time is the shape of the core — a single GLOBAL_GRAPH
+    that `analyze` replaces wholesale — so switching means re-running the
+    whole start-up sequence against the new root: config in, process moved,
+    index restarted. Every step already exists from launch; this orders them
+    for a tool call instead.
+
+    The order matters. Config first, so `[mutation]` policy and excludes are
+    read from the *new* project before anything walks it; chdir second, so
+    entity ids and every cwd-relative helper agree with the root; restart
+    last, so the generation bump cannot race the config swap.
+
+    An explicit tool call outranks everything: the lazy roots/list retry is
+    retired for the rest of the connection, because an agent that named the
+    project it wants must not be second-guessed by whatever the host declares
+    as its workspace.
+    """
+    from coderadar.config import activate_config
+    from coderadar.mcp import lazy, startup
+    from coderadar.mcp.roots import adopt_project_root, resolve_selector
+
+    selected = resolve_selector(project_path)
+    if selected is None:
+        return (
+            f"`{project_path}` names no readable directory, so no project "
+            "can be selected from it. Pass a directory (or any file inside "
+            "one) and retry."
+        )
+
+    if not selected.confirmed and not confirm:
+        return (
+            f"No `.coderadar/` or `.coderadar.toml` was found at or above "
+            f"`{selected.path}`, so nothing confirms that directory as a "
+            "project root.\n\n"
+            "Run `coderadar init` there if it should be one, or re-call "
+            "with confirm=true to serve it anyway (unmarked roots are "
+            "served as bare guesses, same as at startup)."
+        )
+
+    # Already there? Say so rather than silently re-indexing the same tree.
+    served_now = _served_root()
+    if os.path.normcase(str(selected.path)) == os.path.normcase(str(served_now)):
+        return (
+            f"Already serving `{selected.path}` — nothing to switch. Use "
+            "`codegraph_reindex` to refresh the index."
+        )
+
+    lines = [f"Switched to `{selected.path}`"]
+    if selected.confirmed:
+        lines[0] += f" (marker {selected.marker.name})"
+    else:
+        lines[0] += " — unconfirmed: no marker found, serving on your say-so"
+
+    # 1. Config from the NEW project, before anything reads it.
+    try:
+        activated = activate_config(selected.path)
+        if activated.ignored:
+            lines.append(
+                f"Config: {len(activated.ignored)} setting(s) with no "
+                f"consumer were ignored ({', '.join(activated.ignored[:3])}" +
+                (", ..." if len(activated.ignored) > 3 else "") + ")."
+            )
+    except Exception as exc:  # noqa: BLE001 — a broken config must not strand the server on the old project
+        lines.append(
+            f"WARNING: config not applied ({type(exc).__name__}: {exc}) — "
+            "this project runs on defaults, including default mutation "
+            "policy."
+        )
+        structlog.get_logger(__name__).warning(
+            "mcp.set_project.config_failed", root=str(selected.path),
+            error=str(exc))
+
+    # 2. Move the process: entity ids and cwd-relative helpers follow.
+    adopt_project_root(selected)
+
+    # 3. Re-index in the background; ensure_ready makes callers wait or
+    #    report progress, never answer from the old graph.
+    index = startup.current()
+    if index is not None:
+        index.restart(".")
+        lines.append("Indexing restarted in the background — tool calls "
+                     "will wait for it or report progress.")
+    else:
+        lines.append("No background index handle in this process — call "
+                     "`codegraph_reindex` to build the new graph.")
+
+    # 4. The explicit choice outranks the client's workspace forever after.
+    retry = lazy.current()
+    if retry is not None:
+        retry.mark_user_chosen(selected)
+
+    structlog.get_logger(__name__).info(
+        "mcp.project.switched", to=str(selected.path),
+        confirmed=selected.confirmed)
+    return "\n".join(lines)
+
+
 NO_EXTENSION_MESSAGE = (
     "The CodeRadar native extension is not available in this environment, so "
     "no code intelligence can be served.\n\n"

{coderadar_rs-0.7.0 → coderadar_rs-0.7.2}/py_agent/src/coderadar/query/cache.py

@@ -29,7 +29,10 @@ class QueryCache:
         entry = self._cache.get(key)
         if entry is None:
             return None
-        if time.monotonic() - entry.timestamp > self._ttl_seconds:
+        # >=, not >: a ttl of 0 means "never valid", and on Windows two
+        # monotonic() reads around a set() can be equal — a strict compare
+        # made ttl=0 entries immortal there while Linux timers masked it.
+        if time.monotonic() - entry.timestamp >= self._ttl_seconds:
             del self._cache[key]
             return None
         return entry.value
@@ -45,9 +48,10 @@ class QueryCache:
 
     def prune_expired(self) -> int:
         now = time.monotonic()
+        # Same >= as get(): ttl=0 expires everything, deterministically.
         expired = [
             k for k, v in self._cache.items()
-            if now - v.timestamp > self._ttl_seconds
+            if now - v.timestamp >= self._ttl_seconds
         ]
         for k in expired:
             del self._cache[k]