code-context-control 2.30.0__tar.gz → 2.32.2__tar.gz

{code_context_control-2.30.0/code_context_control.egg-info → code_context_control-2.32.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-context-control
-Version: 2.30.0
+Version: 2.32.2
 Summary: Local code-intelligence layer for AI coding tools (Claude Code, Codex, Gemini, Copilot). Retrieve less, read less, edit safer.
 Author-email: Dimitri Tselenchuk <dtselenc@gmail.com>
 License-Expression: Apache-2.0
@@ -228,7 +228,7 @@ Per-project knobs for everything: budget thresholds, feature flag mode, edit led
 
 ## The MCP tool suite
 
-C3 exposes 15 tools as a native MCP server. Your IDE calls them directly:
+C3 exposes 16 tools as a native MCP server. Your IDE calls them directly:
 
 | Tool | What it does |
 |---|---|
@@ -247,8 +247,9 @@ C3 exposes 15 tools as a native MCP server. Your IDE calls them directly:
 | `c3_agent` | Multi-step agentic workflows (review, investigate, refactor) |
 | `c3_edits` | Edit-ledger queries + version diffs + restore points |
 | `c3_bitbucket` | Bitbucket Data Center integration — PRs, branches, builds, repo admin (v2.30.0) |
+| `c3_project` | Cross-project — discover & operate on other c3-installed projects; guarded writes (v2.31.0) |
 
-Every tool is **read-only safe in plan mode** (except `c3_edit`, `c3_shell`, and write actions on `c3_bitbucket`).
+Every tool is **read-only safe in plan mode** (except `c3_edit`, `c3_shell`, and write actions on `c3_bitbucket` / `c3_project`).
 
 ### Bitbucket Data Center / Server (v2.30.0)
 
@@ -280,6 +281,34 @@ to the C3 edit ledger so the audit trail covers platform-side changes too.
 The **Hub UI** (per-project) gains a "Bitbucket" tab with sub-views for
 Overview / Pull Requests / Branches / Activity / Admin.
 
+### Oracle Discovery API (v2.32.0)
+
+The **Oracle** is C3's optional cross-project memory agent (a local web app). As of
+v2.32.0 it can expose C3's cross-project code & memory intelligence as **tools for an
+external LLM** — point Claude (or any function-calling model) at a running Oracle and
+it can discover your projects and search code, memory, and the cross-project graph
+across all of them.
+
+Two transports share one tool core:
+
+- **MCP** (streamable HTTP/SSE) at `http://127.0.0.1:3332/mcp` — native for Claude
+  Code / Claude Desktop / any MCP client.
+- **OpenAPI REST** at `http://127.0.0.1:3331/api/discovery` — for any LLM with
+  function-calling (fetch `/openapi.json` to auto-register the tools).
+
+```bash
+# Start the Oracle (serves the REST + MCP discovery endpoints)
+python oracle/oracle_server.py --no-browser
+
+# Print the Bearer token + a ready-to-paste .mcp.json snippet
+c3 oracle api info
+```
+
+Only **read** and **safe-action** tools are exposed (no code editing); requests need a
+**Bearer token** (stored in the OS keyring) and both servers bind `127.0.0.1` by
+default. Generate, rotate, and copy the token from the dashboard's **Settings →
+Discovery API** tab. See the [Oracle Discovery API guide](oracle-guide/discovery-api.md).
+
 ---
 
 ## Tiered local AI (optional)
@@ -354,6 +383,7 @@ The author may introduce a paid offering or relicense future major versions; no
 
 - **PyPI:** https://pypi.org/project/code-context-control/
 - **Changelog:** [`CHANGELOG.md`](CHANGELOG.md)
+- **Oracle Discovery API:** [`oracle-guide/discovery-api.md`](oracle-guide/discovery-api.md)
 - **Security policy:** [`SECURITY.md`](SECURITY.md)
 - **Licensing FAQ:** [`LICENSING.md`](LICENSING.md)
 - **Issues:** https://github.com/drknowhow/code-context-control/issues

{code_context_control-2.30.0 → code_context_control-2.32.2}/README.md

@@ -166,7 +166,7 @@ Per-project knobs for everything: budget thresholds, feature flag mode, edit led
 
 ## The MCP tool suite
 
-C3 exposes 15 tools as a native MCP server. Your IDE calls them directly:
+C3 exposes 16 tools as a native MCP server. Your IDE calls them directly:
 
 | Tool | What it does |
 |---|---|
@@ -185,8 +185,9 @@ C3 exposes 15 tools as a native MCP server. Your IDE calls them directly:
 | `c3_agent` | Multi-step agentic workflows (review, investigate, refactor) |
 | `c3_edits` | Edit-ledger queries + version diffs + restore points |
 | `c3_bitbucket` | Bitbucket Data Center integration — PRs, branches, builds, repo admin (v2.30.0) |
+| `c3_project` | Cross-project — discover & operate on other c3-installed projects; guarded writes (v2.31.0) |
 
-Every tool is **read-only safe in plan mode** (except `c3_edit`, `c3_shell`, and write actions on `c3_bitbucket`).
+Every tool is **read-only safe in plan mode** (except `c3_edit`, `c3_shell`, and write actions on `c3_bitbucket` / `c3_project`).
 
 ### Bitbucket Data Center / Server (v2.30.0)
 
@@ -218,6 +219,34 @@ to the C3 edit ledger so the audit trail covers platform-side changes too.
 The **Hub UI** (per-project) gains a "Bitbucket" tab with sub-views for
 Overview / Pull Requests / Branches / Activity / Admin.
 
+### Oracle Discovery API (v2.32.0)
+
+The **Oracle** is C3's optional cross-project memory agent (a local web app). As of
+v2.32.0 it can expose C3's cross-project code & memory intelligence as **tools for an
+external LLM** — point Claude (or any function-calling model) at a running Oracle and
+it can discover your projects and search code, memory, and the cross-project graph
+across all of them.
+
+Two transports share one tool core:
+
+- **MCP** (streamable HTTP/SSE) at `http://127.0.0.1:3332/mcp` — native for Claude
+  Code / Claude Desktop / any MCP client.
+- **OpenAPI REST** at `http://127.0.0.1:3331/api/discovery` — for any LLM with
+  function-calling (fetch `/openapi.json` to auto-register the tools).
+
+```bash
+# Start the Oracle (serves the REST + MCP discovery endpoints)
+python oracle/oracle_server.py --no-browser
+
+# Print the Bearer token + a ready-to-paste .mcp.json snippet
+c3 oracle api info
+```
+
+Only **read** and **safe-action** tools are exposed (no code editing); requests need a
+**Bearer token** (stored in the OS keyring) and both servers bind `127.0.0.1` by
+default. Generate, rotate, and copy the token from the dashboard's **Settings →
+Discovery API** tab. See the [Oracle Discovery API guide](oracle-guide/discovery-api.md).
+
 ---
 
 ## Tiered local AI (optional)
@@ -292,6 +321,7 @@ The author may introduce a paid offering or relicense future major versions; no
 
 - **PyPI:** https://pypi.org/project/code-context-control/
 - **Changelog:** [`CHANGELOG.md`](CHANGELOG.md)
+- **Oracle Discovery API:** [`oracle-guide/discovery-api.md`](oracle-guide/discovery-api.md)
 - **Security policy:** [`SECURITY.md`](SECURITY.md)
 - **Licensing FAQ:** [`LICENSING.md`](LICENSING.md)
 - **Issues:** https://github.com/drknowhow/code-context-control/issues

{code_context_control-2.30.0 → code_context_control-2.32.2}/cli/c3.py

@@ -85,7 +85,7 @@ console = Console() if HAS_RICH else None
 # Config
 CONFIG_DIR = ".c3"
 CONFIG_FILE = ".c3/config.json"
-__version__ = "2.30.0"
+__version__ = "2.32.2"
 
 
 def _command_deps() -> CommandDeps:
@@ -239,6 +239,7 @@ _C3_MCP_ALLOW = [
     "mcp__c3__c3_memory", "mcp__c3__c3_validate", "mcp__c3__c3_edit",
     "mcp__c3__c3_agent", "mcp__c3__c3_delegate", "mcp__c3__c3_edits",
     "mcp__c3__c3_impact", "mcp__c3__c3_shell", "mcp__c3__c3_bitbucket",
+    "mcp__c3__c3_project",
 ]
 
 # Obsolete MCP tool names from earlier C3 versions. `c3 permissions clean`
@@ -4492,6 +4493,7 @@ back to native tools as the task progresses.
 - **Memory**: `c3_memory(action='recall')` — full recall. `index` + `fetch` for token-efficient two-step retrieval
 - **Delegate**: `c3_delegate(task, backend='ollama|codex|gemini|claude|auto')` — offload to other models
 - **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.
+- **Cross-project** (v2.31.0+): `c3_project(action='list|scan|search|read|edit|...', project='<name|path>')` — discover and operate on OTHER c3-installed projects. Reads run freely; writes (edit/shell/memory) need `allow_write=true`.
 
 ## Self-Check
 If you haven't called a c3_* tool in several turns during active development, re-engage
@@ -5556,6 +5558,60 @@ def _bb_cmd_set_default(args, project_path: str) -> None:
     print(f"[OK] Default repo: {args.project}/{args.repo}")
 
 
+def cmd_oracle(args):
+    """Oracle Discovery API key + connection management."""
+    sub = getattr(args, "oracle_cmd", None)
+    if sub != "api":
+        print("Usage: c3 oracle api {info,key,rotate,clear}")
+        return
+
+    from oracle.config import load_config
+    from oracle.mcp_oracle import mcp_url
+    from oracle.services import api_auth
+
+    action = getattr(args, "action", "info") or "info"
+
+    if action == "rotate":
+        print("Rotated. New Discovery API key:")
+        print(f"  {api_auth.rotate()}")
+        return
+    if action == "clear":
+        removed = api_auth.clear()
+        print("Discovery API key cleared." if removed else "No stored Discovery API key to clear.")
+        return
+
+    key = api_auth.get_or_create_key()
+    if action == "key":
+        print(key)
+        return
+
+    cfg = load_config()
+    host = cfg.get("bind_host", "127.0.0.1")
+    disp_host = "127.0.0.1" if host in ("0.0.0.0", "") else host
+    rest_port = getattr(args, "port", None) or cfg.get("port", 3331)
+    mcp_port = getattr(args, "mcp_port", None) or cfg.get("mcp_port", 3332)
+    rest_base = f"http://{disp_host}:{rest_port}/api/discovery"
+    url = mcp_url(host, mcp_port)
+
+    print("[oracle:api]")
+    print(f"  REST base : {rest_base}")
+    print(f"  OpenAPI   : {rest_base}/openapi.json")
+    print(f"  MCP URL   : {url}")
+    print(f"  Auth      : Bearer {key}")
+    print()
+    print("  Claude .mcp.json entry:")
+    snippet = {
+        "mcpServers": {
+            "c3-oracle": {
+                "type": "http",
+                "url": url,
+                "headers": {"Authorization": f"Bearer {key}"},
+            }
+        }
+    }
+    print(json.dumps(snippet, indent=2))
+
+
 def cmd_projects(args):
     """Manage the global C3 project registry."""
     from services.project_manager import ProjectManager
@@ -6308,6 +6364,7 @@ def main():
         "projects": cmd_projects,
         "hub": cmd_hub,
         "bitbucket": cmd_bitbucket,
+        "oracle": cmd_oracle,
     }
 
     cmd_func = commands.get(args.command)

{code_context_control-2.30.0 → code_context_control-2.32.2}/cli/commands/parser.py

@@ -322,4 +322,25 @@ def build_parser(version: str, parse_cli_ide_arg):
     bb_default.add_argument("--repo", required=True, help="Repository slug")
     bb_default.add_argument("project_path", nargs="?", default=".")
 
+    # ── Oracle Discovery API (v2.32.0) ──────────────────────────────────
+    p_oracle = subparsers.add_parser(
+        "oracle",
+        help="Oracle Discovery API key + connection management",
+    )
+    or_subs = p_oracle.add_subparsers(dest="oracle_cmd")
+    or_api = or_subs.add_parser(
+        "api",
+        help="Show connection info / manage the Discovery API key",
+    )
+    or_api.add_argument(
+        "action",
+        nargs="?",
+        default="info",
+        choices=["info", "key", "rotate", "clear"],
+        help="info (default): print REST+MCP URLs and a .mcp.json snippet; "
+             "key: print the token; rotate: replace it; clear: delete it",
+    )
+    or_api.add_argument("--port", type=int, default=None, help="Override REST port in printed info")
+    or_api.add_argument("--mcp-port", type=int, default=None, help="Override MCP port in printed info")
+
     return parser

{code_context_control-2.30.0 → code_context_control-2.32.2}/cli/docs.html

@@ -1148,7 +1148,7 @@ python cli/c3.py install-mcp . gemini</code></pre>
 
       <!-- ─── MCP Tools ───────────────────── -->
       <h2 id="mcp-tools">MCP Tools Reference</h2>
-      <p>C3 exposes 15 MCP tools. All core tools work without Ollama; delegate requires it. The Bitbucket integration is optional and activated via <code>c3 bitbucket login</code>.</p>
+      <p>C3 exposes 16 MCP tools. All core tools work without Ollama; delegate requires it. The Bitbucket integration is optional and activated via <code>c3 bitbucket login</code>.</p>
 
       <h3>Discovery &amp; Compression</h3>
       <table>

{code_context_control-2.30.0 → code_context_control-2.32.2}/cli/mcp_server.py

@@ -699,6 +699,65 @@ async def c3_bitbucket(
     )
 
 
+@mcp.tool()
+async def c3_project(
+    action: str,
+    project: str = "",
+    query: str = "",
+    file_path: str = "",
+    symbols: Any = None,
+    lines: Any = None,
+    mode: str = "map",
+    view: str = "health",
+    top_k: int = 5,
+    max_tokens: int = 1200,
+    search_action: str = "code",
+    mem_action: str = "recall",
+    fact: str = "",
+    category: str = "",
+    fact_id: str = "",
+    edits_action: str = "history",
+    file: str = "",
+    tag: str = "",
+    limit: int = 50,
+    target: str = "",
+    old_string: str = "",
+    new_string: str = "",
+    summary: str = "",
+    edits: str = "",
+    replace_all: bool = False,
+    tags: str = "",
+    cmd: str = "",
+    timeout: int = 60,
+    scan_roots: str = "",
+    allow_write: bool = False,
+    ctx: Context = None,
+) -> str:
+    """CROSS-PROJECT — run C3 against OTHER c3-installed projects (read-only safe in plan mode).
+    Discover: list (registry), scan (registry+filesystem), info, register, unregister.
+    Read    : search, read, compress, status, memory, impact, edits, validate, filter.
+    Write   : edit, shell, memory(add/update/delete) — require allow_write=true; logged to that project's ledger.
+    project = registered name OR absolute path (.c3 required). list/scan need no project.
+    search_action/mem_action/edits_action pick the sub-op for those verbs."""
+    svc = _svc(ctx)
+
+    def finalize(fname, fargs, fresp, fsumm, **kw):
+        return _finalize_response(ctx, fname, fargs, fresp, fsumm, **kw)
+
+    from cli.tools.project import handle_project
+    return await asyncio.to_thread(
+        handle_project, action, svc, finalize,
+        project=project, query=query, file_path=file_path, symbols=symbols,
+        lines=lines, mode=mode, view=view, top_k=top_k, max_tokens=max_tokens,
+        search_action=search_action, mem_action=mem_action, fact=fact,
+        category=category, fact_id=fact_id, edits_action=edits_action, file=file,
+        tag=tag, limit=limit, target=target, old_string=old_string,
+        new_string=new_string, summary=summary, edits=edits,
+        replace_all=replace_all, tags=tags, cmd=cmd, timeout=timeout,
+        scan_roots=scan_roots, allow_write=allow_write,
+    )
+
+
 def main() -> None:
     """Entry-point for the ``c3-mcp`` console script."""
     from services import error_reporting

code_context_control-2.32.2/cli/tools/project.py

@@ -0,0 +1,287 @@
+"""c3_project tool -- run C3 against OTHER c3-installed projects.
+
+Discovery and read ops run freely against any registered/.c3 project. Write ops
+(``edit``, ``shell``, and memory mutations) require ``allow_write=True`` and are
+recorded on the *target* project (its edit ledger + activity log), so a foreign
+mutation leaves an audit trail in the project it touched.
+
+The heavy lifting reuses the existing per-tool handlers unchanged -- only the
+``svc`` (a ``C3Runtime``) differs, supplied by the shared foreign-runtime cache.
+"""
+from __future__ import annotations
+
+import asyncio
+from pathlib import Path
+
+from services.project_runtime import (
+    discover_projects,
+    resolve_project,
+    shared_cache,
+)
+
+# Memory sub-actions that mutate the target project's fact store.
+_MEMORY_WRITE = {"add", "update", "delete", "consolidate", "consolidate_deep", "ground"}
+# Dispatch verbs that mutate the target project.
+_WRITE_OPS = {"edit", "shell"}
+_DISCOVERY_OPS = {"list", "scan", "info", "register", "unregister"}
+_READ_OPS = {
+    "search", "read", "compress", "status", "memory",
+    "impact", "edits", "validate", "filter",
+}
+
+
+def _foreign_finalize(_name, _args, resp, _summ="", **_kw):
+    """No-op finalize for proxied calls.
+
+    The home session's finalize wraps the whole ``c3_project`` response, so the
+    inner handlers must not also charge budget / log against either session.
+    """
+    return resp
+
+
+def _foreign_facts(*_a, **_kw):
+    return ""
+
+
+def _runtime_for(path: str):
+    """Indirection point (monkeypatched in tests) -> foreign ``C3Runtime``."""
+    return shared_cache().get(path)
+
+
+# ── Discovery renderers ────────────────────────────────────────────────────
+
+
+def _render_discovery(scan_roots_csv: str, do_scan: bool) -> str:
+    roots = [r.strip() for r in (scan_roots_csv or "").split(",") if r.strip()] or None
+    data = discover_projects(scan_roots=roots, scan=do_scan)
+    reg = data["registered"]
+    unreg = data["unregistered"]
+
+    out = [f"Registered C3 projects ({len(reg)}):"]
+    if not reg:
+        out.append("  (none -- c3_project(action='register', project='<path>') to add one)")
+    for p in reg:
+        flag = "" if p["accessible"] else "  [MISSING]"
+        out.append(f"  - {p['name']:<28} {p['ide']:<12} {p['path']}{flag}")
+
+    if do_scan:
+        out.append("")
+        out.append(f"Unregistered .c3 projects found nearby ({len(unreg)}):")
+        if not unreg:
+            out.append("  (none found near registered projects)")
+        for p in unreg:
+            out.append(f"  - {p['name']:<28} {'':<12} {p['path']}")
+        if unreg:
+            out.append("")
+            out.append("Register one: c3_project(action='register', project='<path>')")
+    return "\n".join(out)
+
+
+def _render_info(project: str) -> str:
+    try:
+        resolved = resolve_project(project)
+    except ValueError as e:
+        return f"[c3_project:error] {e}"
+    p = Path(resolved["path"])
+    out = [
+        f"Project: {resolved['name']}",
+        f"  path        : {resolved['path']}",
+        f"  .c3 present : {(p / '.c3').is_dir()}",
+        f"  accessible  : {p.is_dir()}",
+    ]
+    try:
+        from services.project_manager import ProjectManager
+
+        details = ProjectManager().get_project_details(resolved["path"]) or {}
+        for key in ("ide", "c3_version", "facts_count", "last_session", "active"):
+            if key in details and details[key] not in (None, ""):
+                out.append(f"  {key:<11} : {details[key]}")
+    except Exception:
+        pass
+    return "\n".join(out)
+
+
+def _do_register(project: str) -> str:
+    if not (project or "").strip():
+        return "[c3_project:error] register requires project='<path>'."
+    path = Path(project).expanduser()
+    if not path.exists():
+        return f"[c3_project:error] Path does not exist: {project}"
+    if not (path / ".c3").is_dir():
+        return (
+            f"[c3_project:error] No .c3 directory in {path}. "
+            "Run 'c3 init' there first."
+        )
+    from services.project_manager import ProjectManager
+
+    entry = ProjectManager().add_project(str(path.resolve()))
+    return f"Registered: {entry['name']}  ({entry['path']})"
+
+
+def _do_unregister(project: str) -> str:
+    try:
+        resolved = resolve_project(project)
+    except ValueError as e:
+        return f"[c3_project:error] {e}"
+    from services.project_manager import ProjectManager
+
+    removed = ProjectManager().remove_project(resolved["path"])
+    return (
+        f"Unregistered: {resolved['name']}"
+        if removed
+        else f"Not in registry: {resolved['name']}"
+    )
+
+
+# ── Proxied op dispatch ────────────────────────────────────────────────────
+
+
+def _proxy(action, fsvc, *, query, file_path, symbols, lines, mode, view, top_k,
+           max_tokens, search_action, mem_action, fact, category, fact_id,
+           edits_action, file, tag, limit, target, old_string, new_string,
+           summary, edits, replace_all, tags, cmd, timeout, project_path):
+    if action == "search":
+        from cli.tools.search import handle_search
+
+        return handle_search(query, search_action, top_k, max_tokens,
+                             fsvc, _foreign_finalize, _foreign_facts)
+    if action == "read":
+        from cli.tools.read import handle_read
+
+        return handle_read(file_path, symbols=symbols, lines=lines,
+                           svc=fsvc, finalize=_foreign_finalize)
+    if action == "compress":
+        from cli.tools.compress import handle_compress
+
+        return handle_compress(file_path, mode, fsvc, _foreign_finalize, _foreign_facts)
+    if action == "status":
+        from cli.tools.status import handle_status
+
+        return handle_status(view, False, fsvc, _foreign_finalize)
+    if action == "memory":
+        from cli.tools.memory import handle_memory
+
+        return handle_memory(mem_action, query, fact, category, top_k,
+                            fsvc, _foreign_finalize, fact_id=fact_id)
+    if action == "impact":
+        from cli.tools.impact import handle_impact
+
+        imode = mode if mode in ("symbol", "unstaged") else "symbol"
+        return handle_impact(target, file_path, imode, fsvc, _foreign_finalize)
+    if action == "edits":
+        from cli.tools.edits import handle_edits
+
+        return handle_edits(edits_action, file, "", "", "", tags, limit, "", "",
+                           tag, fsvc, _foreign_finalize)
+    if action == "validate":
+        from cli.tools.validate import handle_validate
+
+        return asyncio.run(handle_validate(file_path, fsvc, _foreign_finalize))
+    if action == "filter":
+        from cli.tools.filter import handle_filter
+
+        return handle_filter(file_path, "", query, 100, "smart", False,
+                           fsvc, _foreign_finalize)
+    if action == "edit":
+        from cli.tools.edit import handle_edit
+
+        return handle_edit(file_path, old_string, new_string, summary, tags,
+                          replace_all, fsvc, _foreign_finalize, edits)
+    if action == "shell":
+        from cli.tools.shell import handle_shell
+
+        return asyncio.run(handle_shell(cmd, project_path, timeout, True, True,
+                                       fsvc, _foreign_finalize))
+    return f"[c3_project:error] Unhandled op '{action}'."
+
+
+# ── Entry point ────────────────────────────────────────────────────────────
+
+
+def handle_project(action, svc, finalize, *, project="", query="", file_path="",
+                   symbols=None, lines=None, mode="map", view="health", top_k=5,
+                   max_tokens=1200, search_action="code", mem_action="recall",
+                   fact="", category="", fact_id="", edits_action="history",
+                   file="", tag="", limit=50, target="", old_string="",
+                   new_string="", summary="", edits="", replace_all=False,
+                   tags="", cmd="", timeout=60, scan_roots="", allow_write=False):
+    action = (action or "").strip().lower()
+
+    def done(resp, summ="ok"):
+        return finalize("c3_project", {"action": action, "project": project},
+                        resp, summ)
+
+    if not action:
+        return done(
+            "[c3_project:error] action required. "
+            f"Discovery: {', '.join(sorted(_DISCOVERY_OPS))}. "
+            f"Read: {', '.join(sorted(_READ_OPS))}. "
+            f"Write (allow_write=true): {', '.join(sorted(_WRITE_OPS))}.",
+            "error")
+
+    # ── Discovery (no foreign runtime needed) ──────────────────────────
+    if action in ("list", "scan"):
+        return done(_render_discovery(scan_roots, action == "scan"), f"{action} projects")
+    if action == "info":
+        return done(_render_info(project), "project info")
+    if action == "register":
+        return done(_do_register(project), "register project")
+    if action == "unregister":
+        return done(_do_unregister(project), "unregister project")
+
+    if action not in _READ_OPS and action not in _WRITE_OPS:
+        return done(
+            f"[c3_project:error] Unknown action '{action}'. "
+            f"Discovery: {', '.join(sorted(_DISCOVERY_OPS))}. "
+            f"Read: {', '.join(sorted(_READ_OPS))}. "
+            f"Write (allow_write=true): {', '.join(sorted(_WRITE_OPS))}.",
+            "error")
+
+    # ── Write guard ────────────────────────────────────────────────────
+    is_write = action in _WRITE_OPS or (
+        action == "memory" and (mem_action or "").lower() in _MEMORY_WRITE
+    )
+    if is_write and not allow_write:
+        label = action + (f"/{mem_action}" if action == "memory" else "")
+        return done(
+            f"[c3_project:blocked] '{label}' would modify project '{project}'. "
+            "Re-run with allow_write=true to proceed.",
+            "blocked")
+
+    # ── Resolve + borrow the foreign runtime ───────────────────────────
+    try:
+        resolved = resolve_project(project)
+    except ValueError as e:
+        return done(f"[c3_project:error] {e}", "error")
+    try:
+        fsvc = _runtime_for(resolved["path"])
+    except Exception as e:
+        return done(
+            f"[c3_project:error] Could not load '{resolved['name']}': {e}", "error")
+
+    banner = f"[c3_project:{resolved['name']}] {action}\n"
+    try:
+        body = _proxy(
+            action, fsvc, query=query, file_path=file_path, symbols=symbols,
+            lines=lines, mode=mode, view=view, top_k=top_k, max_tokens=max_tokens,
+            search_action=search_action, mem_action=mem_action, fact=fact,
+            category=category, fact_id=fact_id, edits_action=edits_action,
+            file=file, tag=tag, limit=limit, target=target, old_string=old_string,
+            new_string=new_string, summary=summary, edits=edits,
+            replace_all=replace_all, tags=tags, cmd=cmd, timeout=timeout,
+            project_path=resolved["path"],
+        )
+    except Exception as e:
+        return done(f"{banner}[error] {type(e).__name__}: {e}", "error")
+
+    # Audit foreign mutations on the target project itself.
+    if is_write and getattr(fsvc, "activity_log", None):
+        try:
+            fsvc.activity_log.log("cross_project_write", {
+                "action": action,
+                "from_project": getattr(svc, "project_path", ""),
+            })
+        except Exception:
+            pass
+
+    return done(banner + (body or ""), f"{action} on {resolved['name']}")