codecortex 0.11.1__tar.gz → 0.12.0__tar.gz

{codecortex-0.11.1/src/codecortex.egg-info → codecortex-0.12.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codecortex
-Version: 0.11.1
+Version: 0.12.0
 Summary: Local-first, MCP-native code-intelligence server — graph, LSP, and semantic search behind one safe code.query tool for coding agents.
 Author: Shammai Hamilton
 License-Expression: MIT
@@ -110,7 +110,7 @@ The agent hands `result` straight to the model. If the graph backend isn't insta
 - **Degrades instead of breaking.** No graph backend installed? That engine returns `null` and the agent falls back to grep. The semantic engine needs nothing external, so codeintel is useful the moment it's installed and only gets sharper as you add backends.
 - **Fast on repeat, never stale.** A content-hash cache returns instantly for unchanged code and self-invalidates when a background reindex advances the index — answers stay both quick *and* fresh. The cache is bounded (LRU), so a long-running server holds steady memory.
 - **Concurrency-safe.** The HTTP transport handles requests on threads, so one slow query (an LSP session warming, a first-time index) can't block every other agent.
-- **Honest about its own health.** `codeintel doctor` reports exactly which engines are ready for a repo and the single command to fix each gap — no guessing why a query came back empty.
+- **Honest about its own health.** `codeintel doctor` answers three separate questions per engine — *installed?* *runnable?* *is this repo indexed?* — with the single command to fix each gap, so "installed" is never mistaken for "working". And a readiness claim is one a query can actually honor: install a missing backend mid-session and the running server picks it up on the next call, rather than reporting the engine healthy while quietly routing around it until you restart the host.
 
 ## Quickstart
 
@@ -144,10 +144,91 @@ pip install -e .
 Register with your AI agent(s), then query:
 
 ```bash
-codeintel install            # registers with Claude, Codex, Gemini, Zed
+codeintel install            # registers with the agents you actually have installed
 codeintel query --op search --target "authentication middleware"
 ```
 
+### Enable native Codex integration
+
+`codeintel` is an MCP server, so Codex can call its tools directly rather than invoking the CLI.
+After installing the package, explicitly register it with Codex:
+
+```bash
+codeintel install --agent codex
+```
+
+This safely adds a `[mcp_servers.codeintel]` entry to `~/.codex/config.toml` (or `$CODEX_HOME/config.toml`
+when that is set) without changing your other Codex settings. Registration is deliberately opt-in:
+installing a Python package should not silently modify an agent's configuration. Start a new Codex
+task (or restart Codex) after registration; the refreshed task will have native `code.query`,
+`code.status`, `code.doctor`, and `code.map` MCP tools available.
+
+For a fully prepared local setup, run:
+
+```bash
+codeintel setup --all /path/to/your/project && codeintel install --agent codex
+```
+
+### Enable native Claude Code integration
+
+After installing the package, explicitly register it with Claude Code:
+
+```bash
+codeintel install --agent claude
+```
+
+This adds the `codeintel` MCP server to `~/.claude.json` (or `$CLAUDE_CONFIG_DIR/.claude.json`)
+while preserving your existing configuration — that is the file Claude Code reads for user-scope
+MCP servers, and you can confirm the entry with `claude mcp list`. Start a new Claude Code session
+after registration so it can load the native `code.query`, `code.status`, `code.doctor`, and
+`code.map` MCP tools.
+
+> **Upgrading from ≤ 0.11.1?** Earlier versions wrote this block to `~/.claude/settings.json`,
+> which Claude Code ignores for MCP registration — so codeintel never actually loaded. Re-run
+> `codeintel install --agent claude`; it registers in the right place and points out the stale
+> entry so you can delete it.
+
+For a fully prepared local setup, run:
+
+```bash
+codeintel setup --all /path/to/your/project && codeintel install --agent claude
+```
+
+### Registration is verified, not assumed
+
+**It only touches agents you have.** `codeintel install` defaults to `--agent auto`: it registers
+the hosts whose config root already exists on this machine and *names the ones it skipped*.
+Installing a Python package should not create `~/.gemini/` and `~/.config/zed/` for someone who has
+neither. Force a specific host with `--agent claude|codex|gemini|zed`, or every supported host with
+`--agent all`.
+
+**It registers an absolute path.** The bare name `codeintel` is resolved by the *host*, not by the
+shell you ran `install` in — and a GUI-launched desktop agent does not source your shell profile, so
+a command your terminal finds is routinely invisible to the app. That is the one failure a handshake
+run in your terminal cannot catch, because it inherits the PATH that works. Pass
+`--relative-command` for the bare name. If a later upgrade moves the binary, re-running
+`codeintel install` repairs the stale path in place, leaving the rest of your config untouched.
+
+Then it launches the exact command it registered and drives a real MCP handshake —
+`initialize` → `tools/list` — and reports what came back:
+
+```text
+v claude: registered at /Users/you/.claude.json
+
+v verified: codeintel 0.11.2 — 4 tools (code.query, code.status, code.doctor, code.map)
+```
+
+If the command is not on `PATH`, or the server fails to start, install says so and exits non-zero
+instead of reporting a success your agent cannot use. Pass `--no-verify` to skip the handshake.
+
+The same principle gates releases. Because every result is a safe envelope with `ok: true` and the
+CLI never throws, an exit-code smoke test passes against a build that boots cleanly and answers
+nothing — so **[`scripts/release_canary.py`](scripts/release_canary.py)** runs before every publish
+against the built wheel in a clean environment: it registers Codex and Claude Code into a throwaway
+`HOME`, launches the command those config files name, and asserts on the **answer text** of a real
+`code.query` over a fixture repo. A release that writes a config no host reads, or that returns
+`ok: true` with nothing in it, fails there instead of on your machine.
+
 ## How it works
 
 A `Gateway` receives every query and dispatches it to one of three providers — graph (structural relationships), LSP (precise symbol resolution), or semantic (embedding-based search) — based on the operation type. Each provider is fully isolated: if it is unavailable or raises an exception, the gateway catches it and returns a safe-null envelope. The caller always gets a well-formed response with no exception to catch.
@@ -203,7 +284,7 @@ Full system docs live in [`docs/`](docs/) — start with the index:
 
 | Command | Purpose |
 |---|---|
-| `codeintel install [--agent claude\|codex\|gemini\|zed\|all]` | Register codeintel with AI agent(s) |
+| `codeintel install [--agent auto\|claude\|codex\|gemini\|zed\|all] [--no-verify] [--relative-command]` | Register codeintel with the agents installed on this machine (`auto`, the default), then prove it by completing a real MCP handshake against the registered command |
 | `codeintel setup [project_root] [--all] [--index] [--warm] [--install-uv] [--install-deps] [--json]` | Prepare backends + index this repo (`--all` = one command: do everything automatable, idempotent); ends with a health report + **Next:** steps |
 | `codeintel index [project_root]` | Index a project for semantic search |
 | `codeintel serve` | Start the MCP server (stdio transport) |
@@ -271,7 +352,7 @@ Register codeintel as an MCP server (`codeintel install`) and the agent gets fou
 | MCP tool | HTTP equivalent | Purpose |
 |---|---|---|
 | `code.query` | `POST /code/query` | The main call — search, trace, understand (the `op` table above) |
-| `code.status` | `GET /code/status` | Which engines are live + whether an index exists |
+| `code.status` | `GET /code/status` | Per-engine `installed` / `runnable` / `repo_indexed`, probed against the live engines a query actually hits |
 | `code.doctor` | `POST /code/doctor` | Per-engine health + repo index status, with a fix for each gap |
 | `code.map` | — | Generate/refresh `CODE_INTEL.md`, a static orientation file for hosts without MCP |
 
@@ -328,5 +409,16 @@ docker build -t codeintel . && docker run -p 127.0.0.1:8766:8766 \
 git clone https://github.com/hamilton-sky/codeintel.git
 cd codeintel
 pip install -e .[dev]
-pytest tests/ -q            # full suite (~15s — includes live graph/LSP backend tests)
+pytest tests/ -q            # ~390 tests, ~35s (live graph/LSP backend tests skip when absent)
+```
+
+**Release gate.** The unit suite runs against the source tree, so it cannot see a packaging break, a
+missing entry point, a host config written where nobody reads it, or a server that boots and answers
+nothing. Run the canary against the built wheel in a clean environment — the same check CI runs
+before publishing:
+
+```bash
+python -m build && python -m venv /tmp/canary && /tmp/canary/bin/python -m pip install dist/*.whl && /tmp/canary/bin/python scripts/release_canary.py
 ```
+
+It exits non-zero on the first failed check and cleans up the temporary `HOME` it installs into.

{codecortex-0.11.1 → codecortex-0.12.0}/README.md

@@ -76,7 +76,7 @@ The agent hands `result` straight to the model. If the graph backend isn't insta
 - **Degrades instead of breaking.** No graph backend installed? That engine returns `null` and the agent falls back to grep. The semantic engine needs nothing external, so codeintel is useful the moment it's installed and only gets sharper as you add backends.
 - **Fast on repeat, never stale.** A content-hash cache returns instantly for unchanged code and self-invalidates when a background reindex advances the index — answers stay both quick *and* fresh. The cache is bounded (LRU), so a long-running server holds steady memory.
 - **Concurrency-safe.** The HTTP transport handles requests on threads, so one slow query (an LSP session warming, a first-time index) can't block every other agent.
-- **Honest about its own health.** `codeintel doctor` reports exactly which engines are ready for a repo and the single command to fix each gap — no guessing why a query came back empty.
+- **Honest about its own health.** `codeintel doctor` answers three separate questions per engine — *installed?* *runnable?* *is this repo indexed?* — with the single command to fix each gap, so "installed" is never mistaken for "working". And a readiness claim is one a query can actually honor: install a missing backend mid-session and the running server picks it up on the next call, rather than reporting the engine healthy while quietly routing around it until you restart the host.
 
 ## Quickstart
 
@@ -110,10 +110,91 @@ pip install -e .
 Register with your AI agent(s), then query:
 
 ```bash
-codeintel install            # registers with Claude, Codex, Gemini, Zed
+codeintel install            # registers with the agents you actually have installed
 codeintel query --op search --target "authentication middleware"
 ```
 
+### Enable native Codex integration
+
+`codeintel` is an MCP server, so Codex can call its tools directly rather than invoking the CLI.
+After installing the package, explicitly register it with Codex:
+
+```bash
+codeintel install --agent codex
+```
+
+This safely adds a `[mcp_servers.codeintel]` entry to `~/.codex/config.toml` (or `$CODEX_HOME/config.toml`
+when that is set) without changing your other Codex settings. Registration is deliberately opt-in:
+installing a Python package should not silently modify an agent's configuration. Start a new Codex
+task (or restart Codex) after registration; the refreshed task will have native `code.query`,
+`code.status`, `code.doctor`, and `code.map` MCP tools available.
+
+For a fully prepared local setup, run:
+
+```bash
+codeintel setup --all /path/to/your/project && codeintel install --agent codex
+```
+
+### Enable native Claude Code integration
+
+After installing the package, explicitly register it with Claude Code:
+
+```bash
+codeintel install --agent claude
+```
+
+This adds the `codeintel` MCP server to `~/.claude.json` (or `$CLAUDE_CONFIG_DIR/.claude.json`)
+while preserving your existing configuration — that is the file Claude Code reads for user-scope
+MCP servers, and you can confirm the entry with `claude mcp list`. Start a new Claude Code session
+after registration so it can load the native `code.query`, `code.status`, `code.doctor`, and
+`code.map` MCP tools.
+
+> **Upgrading from ≤ 0.11.1?** Earlier versions wrote this block to `~/.claude/settings.json`,
+> which Claude Code ignores for MCP registration — so codeintel never actually loaded. Re-run
+> `codeintel install --agent claude`; it registers in the right place and points out the stale
+> entry so you can delete it.
+
+For a fully prepared local setup, run:
+
+```bash
+codeintel setup --all /path/to/your/project && codeintel install --agent claude
+```
+
+### Registration is verified, not assumed
+
+**It only touches agents you have.** `codeintel install` defaults to `--agent auto`: it registers
+the hosts whose config root already exists on this machine and *names the ones it skipped*.
+Installing a Python package should not create `~/.gemini/` and `~/.config/zed/` for someone who has
+neither. Force a specific host with `--agent claude|codex|gemini|zed`, or every supported host with
+`--agent all`.
+
+**It registers an absolute path.** The bare name `codeintel` is resolved by the *host*, not by the
+shell you ran `install` in — and a GUI-launched desktop agent does not source your shell profile, so
+a command your terminal finds is routinely invisible to the app. That is the one failure a handshake
+run in your terminal cannot catch, because it inherits the PATH that works. Pass
+`--relative-command` for the bare name. If a later upgrade moves the binary, re-running
+`codeintel install` repairs the stale path in place, leaving the rest of your config untouched.
+
+Then it launches the exact command it registered and drives a real MCP handshake —
+`initialize` → `tools/list` — and reports what came back:
+
+```text
+v claude: registered at /Users/you/.claude.json
+
+v verified: codeintel 0.11.2 — 4 tools (code.query, code.status, code.doctor, code.map)
+```
+
+If the command is not on `PATH`, or the server fails to start, install says so and exits non-zero
+instead of reporting a success your agent cannot use. Pass `--no-verify` to skip the handshake.
+
+The same principle gates releases. Because every result is a safe envelope with `ok: true` and the
+CLI never throws, an exit-code smoke test passes against a build that boots cleanly and answers
+nothing — so **[`scripts/release_canary.py`](scripts/release_canary.py)** runs before every publish
+against the built wheel in a clean environment: it registers Codex and Claude Code into a throwaway
+`HOME`, launches the command those config files name, and asserts on the **answer text** of a real
+`code.query` over a fixture repo. A release that writes a config no host reads, or that returns
+`ok: true` with nothing in it, fails there instead of on your machine.
+
 ## How it works
 
 A `Gateway` receives every query and dispatches it to one of three providers — graph (structural relationships), LSP (precise symbol resolution), or semantic (embedding-based search) — based on the operation type. Each provider is fully isolated: if it is unavailable or raises an exception, the gateway catches it and returns a safe-null envelope. The caller always gets a well-formed response with no exception to catch.
@@ -169,7 +250,7 @@ Full system docs live in [`docs/`](docs/) — start with the index:
 
 | Command | Purpose |
 |---|---|
-| `codeintel install [--agent claude\|codex\|gemini\|zed\|all]` | Register codeintel with AI agent(s) |
+| `codeintel install [--agent auto\|claude\|codex\|gemini\|zed\|all] [--no-verify] [--relative-command]` | Register codeintel with the agents installed on this machine (`auto`, the default), then prove it by completing a real MCP handshake against the registered command |
 | `codeintel setup [project_root] [--all] [--index] [--warm] [--install-uv] [--install-deps] [--json]` | Prepare backends + index this repo (`--all` = one command: do everything automatable, idempotent); ends with a health report + **Next:** steps |
 | `codeintel index [project_root]` | Index a project for semantic search |
 | `codeintel serve` | Start the MCP server (stdio transport) |
@@ -237,7 +318,7 @@ Register codeintel as an MCP server (`codeintel install`) and the agent gets fou
 | MCP tool | HTTP equivalent | Purpose |
 |---|---|---|
 | `code.query` | `POST /code/query` | The main call — search, trace, understand (the `op` table above) |
-| `code.status` | `GET /code/status` | Which engines are live + whether an index exists |
+| `code.status` | `GET /code/status` | Per-engine `installed` / `runnable` / `repo_indexed`, probed against the live engines a query actually hits |
 | `code.doctor` | `POST /code/doctor` | Per-engine health + repo index status, with a fix for each gap |
 | `code.map` | — | Generate/refresh `CODE_INTEL.md`, a static orientation file for hosts without MCP |
 
@@ -294,5 +375,16 @@ docker build -t codeintel . && docker run -p 127.0.0.1:8766:8766 \
 git clone https://github.com/hamilton-sky/codeintel.git
 cd codeintel
 pip install -e .[dev]
-pytest tests/ -q            # full suite (~15s — includes live graph/LSP backend tests)
+pytest tests/ -q            # ~390 tests, ~35s (live graph/LSP backend tests skip when absent)
+```
+
+**Release gate.** The unit suite runs against the source tree, so it cannot see a packaging break, a
+missing entry point, a host config written where nobody reads it, or a server that boots and answers
+nothing. Run the canary against the built wheel in a clean environment — the same check CI runs
+before publishing:
+
+```bash
+python -m build && python -m venv /tmp/canary && /tmp/canary/bin/python -m pip install dist/*.whl && /tmp/canary/bin/python scripts/release_canary.py
 ```
+
+It exits non-zero on the first failed check and cleans up the temporary `HOME` it installs into.

{codecortex-0.11.1 → codecortex-0.12.0/src/codecortex.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codecortex
-Version: 0.11.1
+Version: 0.12.0
 Summary: Local-first, MCP-native code-intelligence server — graph, LSP, and semantic search behind one safe code.query tool for coding agents.
 Author: Shammai Hamilton
 License-Expression: MIT
@@ -110,7 +110,7 @@ The agent hands `result` straight to the model. If the graph backend isn't insta
 - **Degrades instead of breaking.** No graph backend installed? That engine returns `null` and the agent falls back to grep. The semantic engine needs nothing external, so codeintel is useful the moment it's installed and only gets sharper as you add backends.
 - **Fast on repeat, never stale.** A content-hash cache returns instantly for unchanged code and self-invalidates when a background reindex advances the index — answers stay both quick *and* fresh. The cache is bounded (LRU), so a long-running server holds steady memory.
 - **Concurrency-safe.** The HTTP transport handles requests on threads, so one slow query (an LSP session warming, a first-time index) can't block every other agent.
-- **Honest about its own health.** `codeintel doctor` reports exactly which engines are ready for a repo and the single command to fix each gap — no guessing why a query came back empty.
+- **Honest about its own health.** `codeintel doctor` answers three separate questions per engine — *installed?* *runnable?* *is this repo indexed?* — with the single command to fix each gap, so "installed" is never mistaken for "working". And a readiness claim is one a query can actually honor: install a missing backend mid-session and the running server picks it up on the next call, rather than reporting the engine healthy while quietly routing around it until you restart the host.
 
 ## Quickstart
 
@@ -144,10 +144,91 @@ pip install -e .
 Register with your AI agent(s), then query:
 
 ```bash
-codeintel install            # registers with Claude, Codex, Gemini, Zed
+codeintel install            # registers with the agents you actually have installed
 codeintel query --op search --target "authentication middleware"
 ```
 
+### Enable native Codex integration
+
+`codeintel` is an MCP server, so Codex can call its tools directly rather than invoking the CLI.
+After installing the package, explicitly register it with Codex:
+
+```bash
+codeintel install --agent codex
+```
+
+This safely adds a `[mcp_servers.codeintel]` entry to `~/.codex/config.toml` (or `$CODEX_HOME/config.toml`
+when that is set) without changing your other Codex settings. Registration is deliberately opt-in:
+installing a Python package should not silently modify an agent's configuration. Start a new Codex
+task (or restart Codex) after registration; the refreshed task will have native `code.query`,
+`code.status`, `code.doctor`, and `code.map` MCP tools available.
+
+For a fully prepared local setup, run:
+
+```bash
+codeintel setup --all /path/to/your/project && codeintel install --agent codex
+```
+
+### Enable native Claude Code integration
+
+After installing the package, explicitly register it with Claude Code:
+
+```bash
+codeintel install --agent claude
+```
+
+This adds the `codeintel` MCP server to `~/.claude.json` (or `$CLAUDE_CONFIG_DIR/.claude.json`)
+while preserving your existing configuration — that is the file Claude Code reads for user-scope
+MCP servers, and you can confirm the entry with `claude mcp list`. Start a new Claude Code session
+after registration so it can load the native `code.query`, `code.status`, `code.doctor`, and
+`code.map` MCP tools.
+
+> **Upgrading from ≤ 0.11.1?** Earlier versions wrote this block to `~/.claude/settings.json`,
+> which Claude Code ignores for MCP registration — so codeintel never actually loaded. Re-run
+> `codeintel install --agent claude`; it registers in the right place and points out the stale
+> entry so you can delete it.
+
+For a fully prepared local setup, run:
+
+```bash
+codeintel setup --all /path/to/your/project && codeintel install --agent claude
+```
+
+### Registration is verified, not assumed
+
+**It only touches agents you have.** `codeintel install` defaults to `--agent auto`: it registers
+the hosts whose config root already exists on this machine and *names the ones it skipped*.
+Installing a Python package should not create `~/.gemini/` and `~/.config/zed/` for someone who has
+neither. Force a specific host with `--agent claude|codex|gemini|zed`, or every supported host with
+`--agent all`.
+
+**It registers an absolute path.** The bare name `codeintel` is resolved by the *host*, not by the
+shell you ran `install` in — and a GUI-launched desktop agent does not source your shell profile, so
+a command your terminal finds is routinely invisible to the app. That is the one failure a handshake
+run in your terminal cannot catch, because it inherits the PATH that works. Pass
+`--relative-command` for the bare name. If a later upgrade moves the binary, re-running
+`codeintel install` repairs the stale path in place, leaving the rest of your config untouched.
+
+Then it launches the exact command it registered and drives a real MCP handshake —
+`initialize` → `tools/list` — and reports what came back:
+
+```text
+v claude: registered at /Users/you/.claude.json
+
+v verified: codeintel 0.11.2 — 4 tools (code.query, code.status, code.doctor, code.map)
+```
+
+If the command is not on `PATH`, or the server fails to start, install says so and exits non-zero
+instead of reporting a success your agent cannot use. Pass `--no-verify` to skip the handshake.
+
+The same principle gates releases. Because every result is a safe envelope with `ok: true` and the
+CLI never throws, an exit-code smoke test passes against a build that boots cleanly and answers
+nothing — so **[`scripts/release_canary.py`](scripts/release_canary.py)** runs before every publish
+against the built wheel in a clean environment: it registers Codex and Claude Code into a throwaway
+`HOME`, launches the command those config files name, and asserts on the **answer text** of a real
+`code.query` over a fixture repo. A release that writes a config no host reads, or that returns
+`ok: true` with nothing in it, fails there instead of on your machine.
+
 ## How it works
 
 A `Gateway` receives every query and dispatches it to one of three providers — graph (structural relationships), LSP (precise symbol resolution), or semantic (embedding-based search) — based on the operation type. Each provider is fully isolated: if it is unavailable or raises an exception, the gateway catches it and returns a safe-null envelope. The caller always gets a well-formed response with no exception to catch.
@@ -203,7 +284,7 @@ Full system docs live in [`docs/`](docs/) — start with the index:
 
 | Command | Purpose |
 |---|---|
-| `codeintel install [--agent claude\|codex\|gemini\|zed\|all]` | Register codeintel with AI agent(s) |
+| `codeintel install [--agent auto\|claude\|codex\|gemini\|zed\|all] [--no-verify] [--relative-command]` | Register codeintel with the agents installed on this machine (`auto`, the default), then prove it by completing a real MCP handshake against the registered command |
 | `codeintel setup [project_root] [--all] [--index] [--warm] [--install-uv] [--install-deps] [--json]` | Prepare backends + index this repo (`--all` = one command: do everything automatable, idempotent); ends with a health report + **Next:** steps |
 | `codeintel index [project_root]` | Index a project for semantic search |
 | `codeintel serve` | Start the MCP server (stdio transport) |
@@ -271,7 +352,7 @@ Register codeintel as an MCP server (`codeintel install`) and the agent gets fou
 | MCP tool | HTTP equivalent | Purpose |
 |---|---|---|
 | `code.query` | `POST /code/query` | The main call — search, trace, understand (the `op` table above) |
-| `code.status` | `GET /code/status` | Which engines are live + whether an index exists |
+| `code.status` | `GET /code/status` | Per-engine `installed` / `runnable` / `repo_indexed`, probed against the live engines a query actually hits |
 | `code.doctor` | `POST /code/doctor` | Per-engine health + repo index status, with a fix for each gap |
 | `code.map` | — | Generate/refresh `CODE_INTEL.md`, a static orientation file for hosts without MCP |
 
@@ -328,5 +409,16 @@ docker build -t codeintel . && docker run -p 127.0.0.1:8766:8766 \
 git clone https://github.com/hamilton-sky/codeintel.git
 cd codeintel
 pip install -e .[dev]
-pytest tests/ -q            # full suite (~15s — includes live graph/LSP backend tests)
+pytest tests/ -q            # ~390 tests, ~35s (live graph/LSP backend tests skip when absent)
+```
+
+**Release gate.** The unit suite runs against the source tree, so it cannot see a packaging break, a
+missing entry point, a host config written where nobody reads it, or a server that boots and answers
+nothing. Run the canary against the built wheel in a clean environment — the same check CI runs
+before publishing:
+
+```bash
+python -m build && python -m venv /tmp/canary && /tmp/canary/bin/python -m pip install dist/*.whl && /tmp/canary/bin/python scripts/release_canary.py
 ```
+
+It exits non-zero on the first failed check and cleans up the temporary `HOME` it installs into.

{codecortex-0.11.1 → codecortex-0.12.0}/src/codecortex.egg-info/SOURCES.txt

@@ -31,6 +31,7 @@ src/codeintel/searcher.py
 src/codeintel/semantic_db.py
 src/codeintel/server.py
 src/codeintel/term.py
+src/codeintel/verify.py
 src/codeintel/providers/__init__.py
 src/codeintel/providers/graph.py
 src/codeintel/providers/lsp.py
@@ -43,6 +44,7 @@ tests/test_chunking.py
 tests/test_config.py
 tests/test_doctor.py
 tests/test_e2e.py
+tests/test_engine_adoption.py
 tests/test_enterprise.py
 tests/test_gateway.py
 tests/test_graph_provider.py
@@ -57,6 +59,7 @@ tests/test_integration.py
 tests/test_lsp_provider.py
 tests/test_lsp_real.py
 tests/test_mapper.py
+tests/test_mcp_handshake.py
 tests/test_mcp_server.py
 tests/test_model_dimension.py
 tests/test_never_raise.py
@@ -67,4 +70,6 @@ tests/test_rerank.py
 tests/test_reset.py
 tests/test_semantic_provider.py
 tests/test_term.py
-tests/test_treesitter.py
+tests/test_treesitter.py
+tests/test_verify.py
+tests/test_verify_call.py

codecortex-0.12.0/src/codeintel/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.12.0"

{codecortex-0.11.1 → codecortex-0.12.0}/src/codeintel/__main__.py

@@ -57,9 +57,21 @@ def main() -> None:
     install_parser = subparsers.add_parser("install", help="Register codeintel with AI agents")
     install_parser.add_argument(
         "--agent",
-        choices=["claude", "codex", "gemini", "zed", "all"],
-        default="all",
-        help="Agent to register with (default: all)",
+        choices=["auto", "claude", "codex", "gemini", "zed", "all"],
+        default="auto",
+        help="Agent to register with (default: auto — only agents installed on this machine; "
+             "`all` forces every supported agent)",
+    )
+    install_parser.add_argument(
+        "--no-verify",
+        action="store_true",
+        help="Skip the post-registration MCP handshake (verification is on by default)",
+    )
+    install_parser.add_argument(
+        "--relative-command",
+        action="store_true",
+        help="Register the bare `codeintel` name instead of its absolute path (the absolute path "
+             "is the default because a GUI-launched agent does not inherit your shell's PATH)",
     )
 
     # map subcommand
@@ -275,11 +287,18 @@ def main() -> None:
             project_root = args.project_root or os.getcwd()
             status = server.code_status_handler({"project_root": project_root})
 
+            # "available" alone was the misleading word: it meant "a binary is on PATH", which is
+            # not the same as runnable, and not the same as usable on THIS repo. Say which.
+            _READY = {"ok": "ready", "warn": "installed (not verified)", "fail": "unavailable"}
+            readiness = status.get("readiness") or {}
             print("Engine status:")
             for engine in ["graph", "lsp", "semantic"]:
-                available = status.get(engine, False)
-                state = "available" if available else "unavailable"
-                print(f"  {engine:<10} {state}")
+                entry = readiness.get(engine) or {}
+                state = _READY.get(entry.get("status"), "unavailable")
+                detail = entry.get("detail") or ""
+                print(f"  {engine:<10} {state:<26} {detail}")
+            if status.get("healthy") is False:
+                print("\n  run `codeintel doctor` for the fix for each gap")
 
             from codeintel.config import load_config
             from codeintel.semantic_db import default_db_path
@@ -382,16 +401,27 @@ def main() -> None:
         from codeintel.installer import Installer
 
         installer = Installer()
-        if args.agent == "all":
-            results = installer.register_all()
+        do_verify = not args.no_verify
+        absolute = not args.relative_command
+        skipped: list[str] = []
+        if args.agent == "auto":
+            results, skipped = installer.register_detected(verify=do_verify, absolute=absolute)
+            if not results:
+                print("No supported agent found on this machine "
+                      f"(looked for: {', '.join(skipped)}).")
+                print("  Install one, or force registration with "
+                      "`codeintel install --agent <name>`.")
+                sys.exit(1)
+        elif args.agent == "all":
+            results = installer.register_all(verify=do_verify, absolute=absolute)
         else:
-            results = [installer.register(args.agent)]
+            results = installer.register_many([args.agent], verify=do_verify, absolute=absolute)
 
         any_ok = False
+        legacy_paths: list[str] = []
+        verdict = None
         for r in results:
-            agent = r["agent"]
-            path = r["path"]
-            action = r["action"]
+            agent, path, action = r["agent"], r["path"], r["action"]
             if action == "registered":
                 print(f"v {agent}: registered at {path}")
                 any_ok = True
@@ -400,7 +430,32 @@ def main() -> None:
                 any_ok = True
             else:
                 print(f"x {agent}: failed — {r['reason']}")
-
+            if r.get("legacy"):
+                legacy_paths.append(r["legacy"])
+            verdict = r.get("verified") or verdict
+
+        # A written config file proves nothing about whether the host can launch the server —
+        # so say what the handshake actually found, and fail loudly when it did not happen.
+        if verdict is not None:
+            if verdict.get("ok"):
+                print(f"\nv verified: {verdict.get('detail', '')}")
+            else:
+                print(f"\nx NOT verified: {verdict.get('detail', '')}")
+                print("  The config was written, but your agent will not be able to use it "
+                      "until this is resolved.")
+                any_ok = False
+
+        for legacy in dict.fromkeys(legacy_paths):
+            print(f"\n! stale entry: {legacy} has an `mcpServers.codeintel` block that this host "
+                  f"does NOT read (an older codeintel wrote it). Safe to delete by hand.")
+
+        # Name what was skipped: silence about an untouched host reads as "unsupported" rather
+        # than "you don't have it installed".
+        if skipped:
+            print(f"\n- skipped (not installed here): {', '.join(skipped)}"
+                  f"\n  register anyway with `codeintel install --agent <name>`")
+
+        print("\n  Start a new agent session to pick up the tools.")
         sys.exit(0 if any_ok else 1)
 
     elif args.command == "gen-token":

{codecortex-0.11.1 → codecortex-0.12.0}/src/codeintel/cache.py

@@ -77,3 +77,10 @@ class ContentHashCache:
             self._store.move_to_end(key)  # most-recently-used
             while len(self._store) > self._max_entries:
                 self._store.popitem(last=False)  # evict least-recently-used
+
+    def clear(self) -> None:
+        """Drop every entry. For events that change what an engine *can* answer rather than what
+        the content says — the freshness token and the content hash can't see those. Currently:
+        a new engine being attached to the gateway mid-process (see ``Gateway.adopt_provider``)."""
+        with self._lock:
+            self._store.clear()