codecortex 0.16.0__tar.gz → 0.17.0__tar.gz

{codecortex-0.16.0/src/codecortex.egg-info → codecortex-0.17.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codecortex
-Version: 0.16.0
+Version: 0.17.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
@@ -279,7 +279,7 @@ Then it launches the exact command it registered and drives a real MCP handshake
 ```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)
+v verified: codeintel 0.16.0 — 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
@@ -407,7 +407,7 @@ Full system docs live in [`docs/`](docs/) — start with the index:
 | `codeintel reset [project_root] [--all] [--yes] [--json]` | Clear the semantic index (this repo, or `--all`) to recover from a corrupt/stale DB |
 | `codeintel gen-token` | Print a secure random bearer token (for `serve-http` / RBAC `auth.toml`) |
 
-Human-facing commands (`doctor`, `status`, `query`, `setup`, `reset`) honor `--no-color` / `NO_COLOR` and `--ascii`, and auto-degrade to plain text when piped.
+Human-facing commands (`doctor`, `setup`, `prompt`, `reset`) honor `--no-color` / `NO_COLOR` and `--ascii`, and auto-degrade to plain text when piped.
 
 **Exit codes**, so a `make` target or CI step can gate on `$?`:
 
@@ -617,7 +617,7 @@ git clone https://github.com/hamilton-sky/codeintel.git
 cd codeintel
 pip install -e .[dev]
 
-pytest tests/ -q            # ~620 tests, ~30s; fails under 83% coverage
+pytest tests/ -q            # ~740 tests, ~30s; fails under 83% coverage
 ruff check src tests        # lint
 mypy                        # types (src/ only)
 ```

{codecortex-0.16.0 → codecortex-0.17.0}/README.md

@@ -242,7 +242,7 @@ Then it launches the exact command it registered and drives a real MCP handshake
 ```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)
+v verified: codeintel 0.16.0 — 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
@@ -370,7 +370,7 @@ Full system docs live in [`docs/`](docs/) — start with the index:
 | `codeintel reset [project_root] [--all] [--yes] [--json]` | Clear the semantic index (this repo, or `--all`) to recover from a corrupt/stale DB |
 | `codeintel gen-token` | Print a secure random bearer token (for `serve-http` / RBAC `auth.toml`) |
 
-Human-facing commands (`doctor`, `status`, `query`, `setup`, `reset`) honor `--no-color` / `NO_COLOR` and `--ascii`, and auto-degrade to plain text when piped.
+Human-facing commands (`doctor`, `setup`, `prompt`, `reset`) honor `--no-color` / `NO_COLOR` and `--ascii`, and auto-degrade to plain text when piped.
 
 **Exit codes**, so a `make` target or CI step can gate on `$?`:
 
@@ -580,7 +580,7 @@ git clone https://github.com/hamilton-sky/codeintel.git
 cd codeintel
 pip install -e .[dev]
 
-pytest tests/ -q            # ~620 tests, ~30s; fails under 83% coverage
+pytest tests/ -q            # ~740 tests, ~30s; fails under 83% coverage
 ruff check src tests        # lint
 mypy                        # types (src/ only)
 ```

{codecortex-0.16.0 → codecortex-0.17.0/src/codecortex.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codecortex
-Version: 0.16.0
+Version: 0.17.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
@@ -279,7 +279,7 @@ Then it launches the exact command it registered and drives a real MCP handshake
 ```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)
+v verified: codeintel 0.16.0 — 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
@@ -407,7 +407,7 @@ Full system docs live in [`docs/`](docs/) — start with the index:
 | `codeintel reset [project_root] [--all] [--yes] [--json]` | Clear the semantic index (this repo, or `--all`) to recover from a corrupt/stale DB |
 | `codeintel gen-token` | Print a secure random bearer token (for `serve-http` / RBAC `auth.toml`) |
 
-Human-facing commands (`doctor`, `status`, `query`, `setup`, `reset`) honor `--no-color` / `NO_COLOR` and `--ascii`, and auto-degrade to plain text when piped.
+Human-facing commands (`doctor`, `setup`, `prompt`, `reset`) honor `--no-color` / `NO_COLOR` and `--ascii`, and auto-degrade to plain text when piped.
 
 **Exit codes**, so a `make` target or CI step can gate on `$?`:
 
@@ -617,7 +617,7 @@ git clone https://github.com/hamilton-sky/codeintel.git
 cd codeintel
 pip install -e .[dev]
 
-pytest tests/ -q            # ~620 tests, ~30s; fails under 83% coverage
+pytest tests/ -q            # ~740 tests, ~30s; fails under 83% coverage
 ruff check src tests        # lint
 mypy                        # types (src/ only)
 ```

{codecortex-0.16.0 → codecortex-0.17.0}/src/codecortex.egg-info/SOURCES.txt

@@ -31,6 +31,7 @@ src/codeintel/metrics.py
 src/codeintel/onboarding.py
 src/codeintel/outcome.py
 src/codeintel/policy.py
+src/codeintel/progress.py
 src/codeintel/provider.py
 src/codeintel/py.typed
 src/codeintel/redact.py
@@ -89,6 +90,8 @@ tests/test_hardening.py
 tests/test_http_auth.py
 tests/test_http_server.py
 tests/test_incompleteness.py
+tests/test_index_progress.py
+tests/test_indexer_binary.py
 tests/test_installer.py
 tests/test_integration.py
 tests/test_loc_census.py

codecortex-0.17.0/src/codeintel/__init__.py

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

{codecortex-0.16.0 → codecortex-0.17.0}/src/codeintel/__main__.py

@@ -131,13 +131,19 @@ def main() -> None:
     subparsers.add_parser("serve", help="Start the MCP server")
 
     # index subcommand
-    index_parser = subparsers.add_parser("index", help="Index a project for semantic search")
+    index_parser = subparsers.add_parser(
+        "index", parents=[color_parent],
+        help="Index a project for semantic search")
     index_parser.add_argument(
         "project_root",
         nargs="?",
         default=None,
         help="Project root directory (default: cwd)",
     )
+    index_parser.add_argument(
+        "--quiet", "-q", action="store_true",
+        help="Suppress the live progress display and header; keep only the result line",
+    )
 
     # query subcommand
     query_parser = subparsers.add_parser("query", help="Query the code intelligence engine")

codecortex-0.17.0/src/codeintel/commands/index.py

@@ -0,0 +1,144 @@
+"""`codeintel index` — build the semantic index, then best-effort refresh the graph and the map."""
+
+import logging
+import os
+from typing import Any
+
+from codeintel.commands._common import resolve_root
+
+
+class _ProgressLogBridge(logging.Handler):
+    """Routes WARNING+ log records from the indexer to a live progress counter's ``notice()``, so a
+    per-file skip warning prints as a clean permanent line ABOVE the redrawing status line instead
+    of colliding with it (``0 chunksskipping …``). Installed only for a live (TTY) run and removed
+    the moment indexing returns — a non-TTY has no live line to protect, and the warnings keep their
+    normal stderr path there."""
+
+    def __init__(self, counter: Any) -> None:
+        super().__init__(level=logging.WARNING)
+        self._counter = counter
+
+    def emit(self, record: logging.LogRecord) -> None:
+        try:
+            self._counter.notice(record.getMessage())
+        except Exception:
+            pass
+
+
+def run(args: Any) -> int:
+    import sys
+
+    import codeintel.term as term
+    from codeintel.config import load_config
+    from codeintel.indexer import Indexer
+    from codeintel.semantic_db import SemanticDb, default_db_path
+
+    project_root = resolve_root(args)
+    # Validate before doing anything. `codeintel index /typo/path` walked nothing, found nothing,
+    # and printed "Nothing new to index" at exit 0 — indistinguishable from a correct incremental
+    # run, which is the worst possible response to a mistyped path in a script.
+    if not os.path.isdir(project_root):
+        print(f"index failed: not a directory: {project_root}")
+        return 1
+
+    # A console bound to the CURRENT stdout (honouring --no-color/--ascii/NO_COLOR), so progress is
+    # captured under test and routed correctly whether or not main() already ran configure(). The
+    # LiveCounter auto-goes silent on a non-TTY; --quiet suppresses it (and the header) outright.
+    console = term.Console(
+        stream=sys.stdout,
+        no_color=getattr(args, "no_color", False),
+        ascii_mode=(True if getattr(args, "ascii", False) else None),
+    )
+    quiet = getattr(args, "quiet", False)
+    counter = None if quiet else term.LiveCounter(console)
+
+    failed = False
+    # Wrap the whole semantic pass so a setup failure (e.g. an unresolvable home dir →
+    # Path.home() raising) degrades with a message, like every other subcommand, not a traceback.
+    try:
+        cfg = load_config(project_root)
+        if not quiet:
+            # One dim header naming the model + chunk strategy: it says WHAT is running (and that it
+            # is all local), and on a cold cache it pre-explains the model-download stall.
+            strat = str(cfg.get("chunk_strategy", "syntax"))
+            strat_label = "def-aligned" if strat == "syntax" else "line-window"
+            model = str(cfg.get("model") or "BAAI/bge-small-en-v1.5")
+            sep = "." if console.ascii else "·"
+            print(console.header("index", project_root))
+            print(f"  {console.dim(f'{model} {sep} {strat_label} chunks')}")
+            print()
+        db_path = default_db_path(str(cfg.get("model") or ""))
+        os.makedirs(os.path.dirname(db_path), exist_ok=True)
+        db = SemanticDb(db_path)
+        # While a live status line is on screen, the indexer's skip WARNINGs must not print raw to
+        # the terminal (they land mid-line). Route them through the counter's notice() for the span
+        # of the index pass only; a non-TTY needs no bridge (its status lines end in \n).
+        bridge = _ProgressLogBridge(counter) if (counter is not None and counter.live) else None
+        idx_logger = logging.getLogger("codeintel")
+        try:
+            db.init()
+            if bridge is not None:
+                idx_logger.addHandler(bridge)
+            try:
+                count = Indexer(
+                    db,
+                    model_name=str(cfg.get("model") or "BAAI/bge-small-en-v1.5"),
+                    window=int(cfg.get("window", 20)),
+                    stride=int(cfg.get("stride", 10)),
+                    max_chunks=int(cfg.get("max_chunks", 500)),
+                    max_total_chunks=int(cfg.get("max_total_chunks", 100000)),
+                    chunk_strategy=str(cfg.get("chunk_strategy", "syntax")),
+                    progress=counter,
+                ).index(project_root)
+            finally:
+                if bridge is not None:
+                    idx_logger.removeHandler(bridge)
+            # Seal the live line before the plain summary: commit the ✓ row on real work, else erase
+            # it so "Nothing new" / the failure message stands on its own clean line.
+            if counter:
+                counter.finish(commit=count > 0)
+            if count > 0:
+                print(f"Indexed {count} chunks")
+            elif count < 0:
+                # Indexer.index() returns -1 for an unrecoverable failure. `> 0` sent that into
+                # the "Nothing new to index" branch, so a total failure read as a clean no-op.
+                print("index failed — the indexer could not complete (see the warnings above)")
+                failed = True
+            else:
+                print("Nothing new to index")
+        finally:
+            db.close()
+    except Exception as exc:
+        if counter:
+            counter.finish(commit=False)
+        print(f"index failed: {exc}")
+        failed = True
+
+    # best-effort graph reindex — an opaque subprocess, so a ticking elapsed heartbeat is the honest
+    # fidelity (no counts cross the boundary): the number keeps moving so a minute-long reindex never
+    # reads as a hang, but we never fabricate a percentage we can't see.
+    import shutil
+
+    if shutil.which("codebase-memory-mcp"):
+        beat = None if quiet else term.LiveHeartbeat(console, "graph reindex").start()
+        try:
+            from codeintel.reindexer import Reindexer
+
+            Reindexer()._graph_reindex(project_root)
+            if beat:
+                beat.stop("ok")
+        except Exception:
+            if beat:
+                beat.stop("warn", "skipped")
+
+    # best-effort map refresh after index (fast, kept silent — not worth a checklist row)
+    try:
+        from codeintel.mapper import MapGenerator
+        from codeintel.providers.graph import GraphProvider
+
+        gen = MapGenerator(GraphProvider())
+        gen.write(project_root, gen.generate(project_root))
+    except Exception:
+        pass
+
+    return 1 if failed else 0

{codecortex-0.16.0 → codecortex-0.17.0}/src/codeintel/commands/reset.py

@@ -1,4 +1,4 @@
-"""`codeintel reset` — clear the semantic index (recover from a corrupt/stale DB)."""
+"""`codeintel reset` — clear a repo's index (semantic + graph), or the whole cache with --all."""
 
 import sys
 from typing import Any
@@ -18,7 +18,7 @@ def run(args: Any) -> int:
             return 1
         target = "ALL projects" if args.all else project_root
         count = preview.get("count", 0)
-        ans = input(f"Reset semantic index for {target} ({count} entries)? [y/N] ").strip().lower()
+        ans = input(f"Reset index for {target} ({count} entries)? [y/N] ").strip().lower()
         if ans not in ("y", "yes"):
             print("aborted")
             return 0

{codecortex-0.16.0 → codecortex-0.17.0}/src/codeintel/gateway.py

@@ -24,7 +24,6 @@ _AUTO_ENGINE: dict[str, str] = {
     "overview": "graph",
     "changed": "graph",
     "changes": "graph",
-    "deadcode": "graph",
     "hotspots": "graph",
     "symbol": "lsp",
     "search": "semantic",
@@ -33,8 +32,9 @@ _AUTO_ENGINE: dict[str, str] = {
 
 # Ops whose answer depends on live, unhashable state (the git worktree) rather than the indexed
 # content the cache key is built from — caching them would serve a stale answer within a freshness
-# generation. `changed` reads uncommitted edits; `deadcode`/`hotspots` are pure functions of the
-# index and stay cached (correctly keyed by the freshness generation).
+# generation. `changed` reads uncommitted edits; `hotspots` is a pure function of the index and
+# stays cached (correctly keyed by the freshness generation). A retired/unknown op falls through
+# to the graph engine (the `_AUTO_ENGINE.get(op, "graph")` default), which safe-nulls it.
 _UNCACHED_OPS: frozenset[str] = frozenset({"changed", "changes"})
 
 # Engines whose slot can be filled after construction (see `Gateway.adopt_provider`).

{codecortex-0.16.0 → codecortex-0.17.0}/src/codeintel/indexer.py

@@ -10,6 +10,7 @@ from pathlib import Path
 from typing import TYPE_CHECKING
 
 from codeintel.containment import contained_path, real_root
+from codeintel.progress import ProgressSink, _Guard
 from codeintel.source_kind import (
     CODE_EXTS,
     load_gitattributes_globs,
@@ -170,6 +171,20 @@ def _looks_binary(path) -> bool:
         return True                        # unreadable → treat as unindexable rather than crash
 
 
+def _nul_byte_line(path) -> int | None:
+    """1-based line of the first NUL byte within the sniff window, or None. Turns the bare "looks
+    binary" skip into a message that points at the exact spot — a raw NUL in a source file is almost
+    always a deliberate separator (`.join('\\0')`, a composite key) saved as a byte instead of an
+    escape, and naming the line is the difference between a fixable warning and a puzzle."""
+    try:
+        with open(path, "rb") as fh:
+            head = fh.read(_BINARY_SNIFF_BYTES)
+    except OSError:
+        return None
+    i = head.find(b"\x00")
+    return None if i < 0 else head.count(b"\n", 0, i) + 1
+
+
 class Indexer:
     def __init__(
         self,
@@ -181,9 +196,14 @@ class Indexer:
         max_total_chunks: int = 100000,
         chunk_strategy: str = "syntax",
         max_chunk_lines: int | None = None,
+        progress: ProgressSink | None = None,
     ) -> None:
         self.db = db
         self.model_name = model_name
+        # Optional live-progress sink. Wrapped once in _Guard so every emit below is null-safe and
+        # never-raise: with the default None it is a no-op (the MCP server and Reindexer get silence
+        # and pay nothing), and a misbehaving sink can never abort a pass or change the count.
+        self._progress = _Guard(progress)
         # Coerce the numeric knobs defensively: the 4 production call sites pass config-validated
         # values, but a direct caller must not be able to set a stride/window that raises in
         # range() or silently drops regions (mirrors config._coerce's _POSITIVE_INTS clamp).
@@ -356,7 +376,13 @@ class Indexer:
                 # garbage — 196KB of /dev/urandom produced 162 chunks — which then competed for
                 # rank against real code in every search.
                 if _looks_binary(candidate):
-                    logger.warning("skipping %s — looks binary despite its extension", candidate)
+                    line = _nul_byte_line(candidate)
+                    where = f" at line {line}" if line else ""
+                    logger.warning(
+                        "skipping %s — contains a null byte%s, so it reads as binary (the rule git "
+                        "uses too). If that null is intentional (e.g. a key/join separator), write "
+                        "it as the `\\0` escape instead of a raw byte and re-run index.",
+                        candidate, where)
                     continue
                 # Last resort, and the only check that catches a bundle whose directory and
                 # filename both look ordinary. One 6.7MB minified chunk contributes hundreds of
@@ -648,6 +674,7 @@ class Indexer:
         reconcile each fully-processed file (dropping rows for chunks it no longer produces)."""
         conn = self.db.conn()
         new_chunks: list[tuple[str, str, str, int, str]] = []
+        files_seen = 0
 
         for filepath in self._walk_files(root):
             if len(new_chunks) >= self.max_total_chunks:
@@ -657,6 +684,10 @@ class Indexer:
                     self.max_total_chunks,
                 )
                 break
+            files_seen += 1
+            # A tick per file guarantees liveness even across a run of files that `continue` below
+            # (vanished / unreadable), which is exactly when a lone final tick would look stuck.
+            self._progress.scan(files_seen, len(new_chunks))
             try:
                 with open(filepath, encoding="utf-8", errors="replace") as f:
                     lines = f.readlines()
@@ -685,17 +716,25 @@ class Indexer:
                 # out of scope for the indexer.
                 self.db.delete_file_orphans(project_root_real, rel_path, keep_ids)
 
+        # One final tick with the true totals so the committed scan line is accurate (the per-file
+        # ticks lag by the current file's chunks). The renderer records this even when throttled.
+        self._progress.scan(files_seen, len(new_chunks))
         return new_chunks
 
     def _embed_and_write(
         self, new_chunks: list[tuple[str, str, str, int, str]], project_root_real: str
     ) -> int:
+        total = len(new_chunks)
+        # Signal the model-load BEFORE materialising the embedder: on a cold cache _get_embedder()
+        # downloads the model (minutes), a distinct stall the scan counter can't cover.
+        self._progress.load_model()
         embedder = self._get_embedder()  # may raise → propagates to index() → returns -1
         conn = self.db.conn()
         embedded_count = 0
         batch_size = 32
+        self._progress.embed(0, total)  # land on 0% the instant the model is ready
 
-        for i in range(0, len(new_chunks), batch_size):
+        for i in range(0, total, batch_size):
             batch = new_chunks[i: i + batch_size]
             texts = [c[1] for c in batch]
 
@@ -744,6 +783,10 @@ class Indexer:
             except Exception as exc:
                 logger.warning("commit failed after batch %d: %s", i // batch_size, exc)
 
+            # Report POSITION, not embedded_count: a skipped/failed batch still advanced the work,
+            # and a bar that stalls on a `continue` is a lie. Always lands on total at the last batch.
+            self._progress.embed(min(i + batch_size, total), total)
+
         return embedded_count
 
     def _index(self, project_root: str) -> int:

codecortex-0.17.0/src/codeintel/progress.py

@@ -0,0 +1,78 @@
+"""The progress-reporting seam for indexing.
+
+This is a deliberately tiny, dependency-free contract that lets the indexer say *how far it is*
+without knowing anything about terminals, TTYs, or ANSI. The renderer that turns these calls into
+a live line (``term.LiveCounter``) lives on the far side of this line: it never sees a chunk, and
+the indexer never sees an escape byte. Neither imports the other — the renderer merely *matches*
+``ProgressSink``'s shape.
+
+The never-raise guarantee for progress lives in exactly ONE place — ``_Guard``. The indexer calls
+the guard's methods unguarded, so a broken, slow, or half-written sink can never abort an index
+pass or change the count it returns. That single-choke-point is the whole reason this module exists
+rather than the indexer poking a console directly.
+"""
+from __future__ import annotations
+
+from typing import Protocol, runtime_checkable
+
+
+@runtime_checkable
+class ProgressSink(Protocol):
+    """What the indexer emits while it works. Three calls, because the phases genuinely differ:
+
+    * ``scan`` — the file walk. The file list is a generator, so there is no total; this is a
+      running count only (files seen, chunks collected so far).
+    * ``load_model`` — a bare marker fired just before the embedding model is materialised. On a
+      cold cache that step downloads hundreds of MB and is a *separate* multi-minute stall that
+      precedes the first batch; without its own signal it reads as a fresh hang the moment the scan
+      counter stops moving.
+    * ``embed`` — the batch loop. The total is known up front (``len(new_chunks)``), so this is a
+      real ``done``/``total`` and can drive a true percentage.
+
+    Implementations should not raise, but they are not trusted to honour that: every call the
+    indexer makes is routed through :class:`_Guard`.
+    """
+
+    def scan(self, files: int, chunks: int) -> None: ...
+    def load_model(self) -> None: ...
+    def embed(self, done: int, total: int) -> None: ...
+
+
+class _Guard:
+    """Null-safe, never-raise adapter around an optional :class:`ProgressSink`.
+
+    ``Indexer`` holds one of these instead of the raw sink and calls it directly. When the sink is
+    ``None`` (the default — the MCP server, ``Reindexer``, and every test that doesn't opt in) each
+    method is a no-op; when it is present, any exception it throws is swallowed here. This is the
+    only spot the contract "progress can never break indexing" is enforced, so it is the only spot
+    that needs a test to prove it.
+    """
+
+    __slots__ = ("_sink",)
+
+    def __init__(self, sink: ProgressSink | None) -> None:
+        self._sink = sink
+
+    def scan(self, files: int, chunks: int) -> None:
+        if self._sink is None:
+            return
+        try:
+            self._sink.scan(files, chunks)
+        except Exception:
+            pass
+
+    def load_model(self) -> None:
+        if self._sink is None:
+            return
+        try:
+            self._sink.load_model()
+        except Exception:
+            pass
+
+    def embed(self, done: int, total: int) -> None:
+        if self._sink is None:
+            return
+        try:
+            self._sink.embed(done, total)
+        except Exception:
+            pass

{codecortex-0.16.0 → codecortex-0.17.0}/src/codeintel/reset.py

@@ -8,6 +8,7 @@ from __future__ import annotations
 import glob
 import logging
 import os
+import re
 import sqlite3
 
 import sqlite_vec
@@ -159,6 +160,44 @@ def _reset_graph_cache(apply: bool) -> dict:
     return {"count": count, "corrupt": corrupt}
 
 
+def _graph_slug(canonical_root: str) -> str:
+    """The stem the graph backend gives a project's cache file: every run of non-alphanumeric
+    characters collapses to a single ``-``, with the ends trimmed. So ``/Users/me/aws-resource-tools``
+    → ``Users-me-aws-resource-tools`` and ``/tmp/-Weird/repo`` → ``tmp-Weird-repo`` (NOT
+    ``tmp--Weird-repo`` — a naive ``/``→``-`` replace leaves a double dash and misses the file,
+    silently leaking the graph index a scoped reset was meant to remove). Verified against real
+    on-disk caches. The collapse also flattens away every path separator, so the target can never
+    escape the cache directory."""
+    return re.sub(r"[^A-Za-z0-9]+", "-", canonical_root).strip("-")
+
+
+def _reset_graph_project(project_root: str, apply: bool) -> dict:
+    """Remove ONE project's graph index — the per-project sqlite the backend names ``<slug>.db`` (see
+    :func:`_graph_slug`), plus its ``-wal``/``-shm``/``.corrupt`` siblings.
+
+    This is the graph half of a *scoped* reset. Without it, ``reset <repo>`` cleared only the
+    semantic side and left the repo listed and queryable in the graph engine — so "start as if never
+    indexed" was true only for ``--all``. ``list_projects`` enumerates these files (``_config.db`` is
+    key/value config, not a registry), so deleting them is exactly what makes one project vanish.
+    Pure file removal like ``_reset_graph_cache``: it works with the backend down and never hangs."""
+    directory = _graph_cache_dir()
+    slug = _graph_slug(os.path.realpath(str(project_root)))
+    found = 0
+    removed = 0
+    for suffix in (".db", ".db-wal", ".db-shm", ".db.corrupt"):
+        path = os.path.join(directory, slug + suffix)
+        if not os.path.isfile(path):
+            continue
+        found += 1
+        if apply:
+            try:
+                os.remove(path)
+                removed += 1
+            except Exception:
+                pass
+    return {"slug": slug, "found": found, "removed": removed}
+
+
 def _looks_unreadable(exc: Exception) -> bool:
     """Whether *exc* means "this file is not a usable sqlite cache" (as opposed to e.g. a lock)."""
     text = f"{type(exc).__name__}: {exc}".lower()
@@ -220,15 +259,22 @@ def run_reset(
         real = os.path.realpath(str(project_root))
         results = [_reset_scoped(project_root, p, apply) for p in files]
         count = sum(r["count"] for r in results)
+        # The graph half of a scoped reset — the piece that was missing, so `reset <repo>` now clears
+        # BOTH engines and the repo is genuinely "never indexed", matching what `--all` does globally.
+        graph = _reset_graph_project(project_root, apply)
         verb = "removed" if apply else "found"
         # Surface per-file trouble instead of summing counts and synthesizing a success line —
         # discarding these is what made a failed reset indistinguishable from a clean one.
         problems = [r["detail"] for r in results if r.get("error") or r.get("recovered") is not None]
-        detail = f"{verb} {count} indexed chunk(s) for this project"
+        detail = f"{verb} {count} indexed chunk(s)"
+        if graph["found"]:
+            detail += " and the graph index" if apply else " and a graph index"
+        detail += " for this project"
         if problems:
             detail = "\n".join([*problems, detail])
         return {"ok": True, "mode": "scoped", "target": real, "count": count, "applied": bool(apply),
                 "detail": detail,
+                "graph_found": graph["found"], "graph_removed": graph["removed"],
                 "failed": any(r.get("error") for r in results)}
     except Exception as exc:
         return {"ok": True, "applied": apply, "detail": f"reset-error: {type(exc).__name__}: {exc}"}