code-context-control 2.53.0__tar.gz → 2.54.0__tar.gz

{code_context_control-2.53.0 → code_context_control-2.54.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-context-control
-Version: 2.53.0
+Version: 2.54.0
 Summary: Local code-intelligence layer for AI coding tools (Claude Code, Codex, Copilot, Cursor, Antigravity). Retrieve less, read less, edit safer — and version the configs that shape your agent (CLAUDE.md, skills, hooks, MCP).
 Author-email: Dimitri Tselenchuk <dtselenc@gmail.com>
 License-Expression: Apache-2.0

{code_context_control-2.53.0 → code_context_control-2.54.0}/cli/c3.py

@@ -92,7 +92,7 @@ console = Console() if HAS_RICH else None
 # Config
 CONFIG_DIR = ".c3"
 CONFIG_FILE = ".c3/config.json"
-__version__ = "2.53.0"
+__version__ = "2.54.0"
 
 
 def _command_deps() -> CommandDeps:
@@ -165,6 +165,7 @@ def _build_init_config(project_path: str) -> dict:
         "project_path": project_path,
         "version": __version__,
         "index_auto_update": True,
+        "index_max_files": 2000,
         "compression_mode": "smart",
         "mcp": {"mode": "direct"},
         "hybrid": deepcopy(HYBRID_DEFAULTS),
@@ -890,7 +891,7 @@ def _parse_cli_ide_arg(value: str) -> str:
     return normalized
 
 
-def _do_init(project_path: str, ide_name: str = None):
+def _do_init(project_path: str, ide_name: str = None, no_embed: bool = False):
     """Run the core init steps (shared by new install and re-init after clear/reset)."""
     config = _build_init_config(project_path)
     save_config(config, project_path)
@@ -898,10 +899,27 @@ def _do_init(project_path: str, ide_name: str = None):
     for subdir in _C3_INIT_SUBDIRS:
         (Path(project_path) / CONFIG_DIR / subdir).mkdir(parents=True, exist_ok=True)
 
+    import time as _t
+
+    from cli.progress import ProgressLine
+
     print("Building code index...")
+    _prog = ProgressLine()
+    _t0 = _t.perf_counter()
     indexer = CodeIndex(project_path)
-    result = indexer.build_index()
-    print(f"  Indexed {result['files_indexed']} files, {result['chunks_created']} chunks")
+    result = indexer.build_index(
+        on_progress=lambda entries, files, chunks: _prog.update(
+            f"  scanning: {entries:,} entries | {files:,} files | {chunks:,} chunks"))
+    _prog.done()
+    entries = result.get("entries_scanned", 0)
+    print(f"  Indexed {result['files_indexed']} files, {result['chunks_created']} chunks "
+          f"in {_t.perf_counter() - _t0:.1f}s ({entries:,} entries scanned)")
+    capped = result.get("files_capped", 0)
+    if capped:
+        total = result["files_indexed"] + capped
+        print(f"  [!] Indexed {result['files_indexed']} of {total} candidate files "
+              f"(cap: index_max_files={result.get('max_files')}).")
+        print("      Raise index_max_files in .c3/config.json for full coverage.")
 
     # Build embedding index if Ollama is available (non-blocking on failure)
     try:
@@ -912,13 +930,24 @@ def _do_init(project_path: str, ide_name: str = None):
         ollama = OllamaClient(ollama_url)
         embed_model = config.get("embed_model", "nomic-embed-text")
         ei = EmbeddingIndex(project_path, ollama, embed_model=embed_model)
-        if ei.ready:
+        if no_embed:
+            print("  Embedding index skipped (--no-embed)")
+        elif ei.probe()["ready"]:
+            # probe() initializes the lazy backends; checking .ready on a
+            # fresh instance is always False and silently skipped the build.
             print("Building embedding index...")
-            ei_result = ei.build(indexer)
+            _t0 = _t.perf_counter()
+            _eprog = ProgressLine()
+            ei_result = ei.build(
+                indexer,
+                on_progress=lambda done, total, chunks: _eprog.update(
+                    f"  embedding: file {done}/{total} | {chunks:,} chunks"))
+            _eprog.done()
             print(f"  Embedded {ei_result.get('chunks_embedded', 0)} chunks "
-                  f"({ei_result.get('files_processed', 0)} files)")
+                  f"({ei_result.get('files_processed', 0)} files) "
+                  f"in {_t.perf_counter() - _t0:.1f}s")
         else:
-            print("  Embedding index skipped (Ollama not available or model not pulled)")
+            print(f"  Embedding index skipped ({ei.unavailable_reason()})")
     except Exception:
         _log.debug("Embedding index build failed", exc_info=True)
 
@@ -926,15 +955,22 @@ def _do_init(project_path: str, ide_name: str = None):
     try:
         from services.doc_index import DocIndex
         print("Building doc index...")
+        _t0 = _t.perf_counter()
+        _dprog = ProgressLine()
         di = DocIndex(project_path)
-        di_result = di.build()
-        print(f"  Indexed {di_result['docs_indexed']} docs, {di_result['chunks_created']} chunks")
+        di_result = di.build(
+            on_progress=lambda done, total: _dprog.update(
+                f"  docs: {done}/{total}"))
+        _dprog.done()
+        print(f"  Indexed {di_result['docs_indexed']} docs, "
+              f"{di_result['chunks_created']} chunks in {_t.perf_counter() - _t0:.1f}s")
     except Exception:
         _log.debug("Doc index build failed", exc_info=True)
 
     print("Building compression dictionary...")
     protocol = CompressionProtocol(project_path)
-    new_terms = protocol.build_project_dictionary()
+    # Mine the in-memory index instead of re-reading the whole tree.
+    new_terms = protocol.build_project_dictionary(code_index=indexer)
     print(f"  Added {len(new_terms)} project-specific terms")
 
     from core.ide import detect_ide, load_ide_config
@@ -966,11 +1002,12 @@ def cmd_init(args):
     if requested_ide != "auto":
         requested_ide = normalize_ide_name(requested_ide)
     git_requested = getattr(args, "git", False)
+    no_embed = bool(getattr(args, "no_embed", False))
 
     # ── Brand-new install ──────────────────────────────────────
     if not c3_dir.exists() or not (c3_dir / "config.json").exists():
         print_header(f"Initializing C3 for: {project_path}")
-        _do_init(project_path, ide_name=requested_ide)
+        _do_init(project_path, ide_name=requested_ide, no_embed=no_embed)
         try:
             from services.project_manager import ProjectManager
             ProjectManager().add_project(project_path)
@@ -1123,7 +1160,7 @@ def cmd_init(args):
         ti_manifest = c3_dir / "transcript_index" / "manifest.json"
         if ti_manifest.exists():
             ti_manifest.write_text("{}", encoding="utf-8")
-        _do_init(project_path, ide_name=requested_ide)
+        _do_init(project_path, ide_name=requested_ide, no_embed=no_embed)
         if git_requested:
             _init_local_git_repo(project_path)
         _run_install_mcp(project_path, requested_ide, mcp_mode=getattr(args, "mcp_mode", "direct"), banner="Updating MCP tools...")
@@ -1152,7 +1189,7 @@ def cmd_init(args):
     # ── Non-interactive (--force) ──────────────────────────────
     if getattr(args, "force", False):
         print("\n[--force] Applying update...")
-        _do_init(project_path, ide_name=requested_ide)
+        _do_init(project_path, ide_name=requested_ide, no_embed=no_embed)
         if git_requested:
             _init_local_git_repo(project_path)
         _run_install_mcp(project_path, requested_ide, mcp_mode=getattr(args, "mcp_mode", "direct"), banner="Updating MCP tools...")
@@ -1176,7 +1213,7 @@ def cmd_init(args):
 
     if selected.startswith("Update"):
         print()
-        _do_init(project_path, ide_name=requested_ide)
+        _do_init(project_path, ide_name=requested_ide, no_embed=no_embed)
         if git_requested:
             _init_local_git_repo(project_path)
         _prompt_install_mcp(project_path, requested_ide, default_mode=getattr(args, "mcp_mode", "direct"), banner="Updating MCP tools...")
@@ -1192,7 +1229,7 @@ def cmd_init(args):
                 shutil.rmtree(target)
                 print(f"  Removed .c3/{subdir}/")
         print()
-        _do_init(project_path, ide_name=requested_ide)
+        _do_init(project_path, ide_name=requested_ide, no_embed=no_embed)
         if git_requested:
             _init_local_git_repo(project_path)
         _prompt_install_mcp(project_path, requested_ide, default_mode=getattr(args, "mcp_mode", "direct"), banner="Updating MCP tools...")
@@ -1209,7 +1246,7 @@ def cmd_init(args):
         shutil.rmtree(c3_dir)
         print("  Deleted .c3/")
         print()
-        _do_init(project_path, ide_name=requested_ide)
+        _do_init(project_path, ide_name=requested_ide, no_embed=no_embed)
         if git_requested:
             _init_local_git_repo(project_path)
         _prompt_install_mcp(project_path, requested_ide, default_mode=getattr(args, "mcp_mode", "direct"), banner="Re-installing MCP tools...")

{code_context_control-2.53.0 → code_context_control-2.54.0}/cli/commands/parser.py

@@ -24,6 +24,7 @@ def build_parser(version: str, parse_cli_ide_arg):
     p_init.add_argument("--ide", default="auto", type=parse_cli_ide_arg, metavar="{auto,claude,vscode,cursor,codex,antigravity}", help="Target IDE for MCP config (default: auto-detect)")
     p_init.add_argument("--mcp-mode", choices=["direct", "proxy"], default="direct", help="Default MCP mode if install is selected during init (default: direct)")
     p_init.add_argument("--git", action="store_true", help="Initialize a local Git repository during init/update")
+    p_init.add_argument("--no-embed", action="store_true", help="Skip building the semantic embedding index during init")
     p_init.add_argument("--permissions", choices=["read-only", "c3-strict", "standard", "permissive"], default=None, help="Apply Claude Code permission tier (Claude Code only, used with --force)")
     p_init.add_argument("--include-mcp-wildcard", action="store_true", help="Add mcp__* wildcard so non-C3 MCP servers don't prompt per-call")
 

{code_context_control-2.53.0 → code_context_control-2.54.0}/cli/hub_server.py

@@ -1027,8 +1027,10 @@ def api_run_component():
             ollama = OllamaClient(ollama_url)
             embed_model = cfg.get("embed_model", "nomic-embed-text")
             ei = EmbeddingIndex(resolved, ollama, embed_model=embed_model)
-            if not ei.ready:
-                return jsonify({"success": True, "output": "Embedding index skipped (Ollama not available or model not pulled)."})
+            # probe() initializes lazy backends; a fresh instance's .ready
+            # is always False and would skip the build unconditionally.
+            if not ei.probe()["ready"]:
+                return jsonify({"success": True, "output": f"Embedding index skipped ({ei.unavailable_reason()})."})
             indexer = CodeIndex(resolved)
             if not indexer.chunks:
                 indexer._load_index()

code_context_control-2.54.0/cli/progress.py

@@ -0,0 +1,49 @@
+"""
+Single-line TTY progress for long CLI phases (index/embedding builds).
+
+Quiet when stdout is piped - CI logs and command substitutions see only
+the final summary lines, never carriage-return spam.
+"""
+import sys
+import time
+
+
+class ProgressLine:
+    """Rewrites one status line in place; time-throttled; TTY-only."""
+
+    def __init__(self, stream=None, min_interval: float = 0.1):
+        self.stream = stream if stream is not None else sys.stdout
+        self.min_interval = min_interval
+        self._last = 0.0
+        self._width = 0
+        try:
+            self._tty = bool(self.stream.isatty())
+        except Exception:
+            self._tty = False
+
+    def update(self, text: str) -> None:
+        if not self._tty:
+            return
+        now = time.monotonic()
+        if now - self._last < self.min_interval:
+            return
+        self._last = now
+        pad = ' ' * max(0, self._width - len(text))
+        try:
+            self.stream.write('\r' + text + pad)
+            self.stream.flush()
+        except Exception:
+            self._tty = False
+            return
+        self._width = len(text)
+
+    def done(self) -> None:
+        """Clear the in-place line so the following prints start clean."""
+        if not self._tty or not self._width:
+            return
+        try:
+            self.stream.write('\r' + ' ' * self._width + '\r')
+            self.stream.flush()
+        except Exception:
+            pass
+        self._width = 0

{code_context_control-2.53.0 → code_context_control-2.54.0}/code_context_control.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: code-context-control
-Version: 2.53.0
+Version: 2.54.0
 Summary: Local code-intelligence layer for AI coding tools (Claude Code, Codex, Copilot, Cursor, Antigravity). Retrieve less, read less, edit safer — and version the configs that shape your agent (CLAUDE.md, skills, hooks, MCP).
 Author-email: Dimitri Tselenchuk <dtselenc@gmail.com>
 License-Expression: Apache-2.0

{code_context_control-2.53.0 → code_context_control-2.54.0}/code_context_control.egg-info/SOURCES.txt

@@ -25,6 +25,7 @@ cli/hub_server.py
 cli/hub_ui.html
 cli/mcp_proxy.py
 cli/mcp_server.py
+cli/progress.py
 cli/server.py
 cli/ui.html
 cli/ui_legacy.html
@@ -196,6 +197,7 @@ services/retention.py
 services/retrieval_broker.py
 services/router.py
 services/runtime.py
+services/scanner.py
 services/session_benchmark.py
 services/session_manager.py
 services/session_preloader.py
@@ -248,6 +250,7 @@ tests/test_hook_state.py
 tests/test_hook_utf8_stdio.py
 tests/test_hub_inspect_api.py
 tests/test_hub_server_smoke.py
+tests/test_init_scan.py
 tests/test_install_mcp_entrypoint.py
 tests/test_lazy_store_init.py
 tests/test_mcp_host_guard.py

{code_context_control-2.53.0 → code_context_control-2.54.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "code-context-control"
-version = "2.53.0"
+version = "2.54.0"
 description = "Local code-intelligence layer for AI coding tools (Claude Code, Codex, Copilot, Cursor, Antigravity). Retrieve less, read less, edit safer — and version the configs that shape your agent (CLAUDE.md, skills, hooks, MCP)."
 readme = "README.md"
 requires-python = ">=3.10"

{code_context_control-2.53.0 → code_context_control-2.54.0}/services/compressor.py

@@ -709,27 +709,19 @@ class CodeCompressor:
                        '.css', '.html', '.json', '.yaml', '.yml', '.md'}
         allowed = set(extensions) if extensions else default_exts
 
-        # Skip common non-essential dirs
-        skip_dirs = {'node_modules', '.git', '__pycache__', '.c3', 'venv',
-                    'env', '.venv', 'dist', 'build', '.next', '.cache'}
-
         results = []
         total_original = 0
         total_compressed = 0
         skipped_protected = []
 
-        files = sorted(dirpath.rglob('*'))[:max_files * 3]  # Pre-limit
-        count = 0
+        # Pruned walk (shared SKIP_DIRS) - never descends into
+        # node_modules/.git/etc., stops as soon as the cap is reached.
+        from services.scanner import iter_files
 
-        for fpath in files:
+        count = 0
+        for fpath in iter_files(dirpath, exts={e.lower() for e in allowed}):
             if count >= max_files:
                 break
-            if not fpath.is_file():
-                continue
-            if fpath.suffix.lower() not in allowed:
-                continue
-            if any(skip in fpath.parts for skip in skip_dirs):
-                continue
             if self.is_protected_file(fpath):
                 skipped_protected.append(self._relative_to_project(fpath))
                 continue

{code_context_control-2.53.0 → code_context_control-2.54.0}/services/doc_index.py

@@ -92,15 +92,26 @@ class DocIndex:
 
     # --- Build ---
 
-    def build(self, force: bool = False) -> dict:
-        """Build or incrementally update the doc index."""
+    def build(self, force: bool = False, on_progress=None) -> dict:
+        """Build or incrementally update the doc index.
+
+        on_progress: callable(files_done, files_total), invoked per file.
+        """
         stats = {"docs_indexed": 0, "chunks_created": 0, "skipped": 0}
 
         files_to_index = self._discover_files()
         old_hashes = dict(self._file_hashes)
         new_hashes = {}
+        files_total = len(files_to_index)
+        files_done = 0
 
         for rel_path, fpath in files_to_index:
+            files_done += 1
+            if on_progress is not None:
+                try:
+                    on_progress(files_done, files_total)
+                except Exception:
+                    pass
             try:
                 content = fpath.read_text(errors="replace")
             except Exception:
@@ -154,12 +165,6 @@ class DocIndex:
 
     def _discover_files(self) -> list[tuple[str, Path]]:
         """Find all doc, config, and code files to index."""
-        skip_dirs = {
-            "node_modules", ".git", "__pycache__", ".c3", "venv",
-            "env", ".venv", "dist", "build", ".next", ".cache",
-            "coverage", ".pytest_cache",
-        }
-
         # Designated sub-projects keep their own doc index.
         try:
             from services.subprojects import make_excluder
@@ -170,15 +175,14 @@ class DocIndex:
 
         files = []
 
-        # Markdown docs
-        for ext in ("*.md", "*.mdx", "*.rst", "*.adoc"):
-            for fpath in self.project_path.rglob(ext):
-                if any(skip in fpath.parts for skip in skip_dirs):
-                    continue
-                if _sub_excluded(fpath):
-                    continue
-                rel = str(fpath.relative_to(self.project_path))
-                files.append((rel, fpath))
+        # Markdown docs - one pruned walk instead of four full rglob passes
+        from services.scanner import iter_files
+        for fpath in iter_files(self.project_path,
+                                exts={".md", ".mdx", ".rst", ".adoc"}):
+            if _sub_excluded(fpath):
+                continue
+            rel = str(fpath.relative_to(self.project_path))
+            files.append((rel, fpath))
 
         # Config files at project root
         for pattern in _CONFIG_PATTERNS:

{code_context_control-2.53.0 → code_context_control-2.54.0}/services/embedding_index.py

@@ -39,6 +39,8 @@ class EmbeddingIndex:
         self._collection = None
         self._available = False
         self._ollama_ok = False
+        self._ollama_up = False
+        self._model_ok = False
         self._file_hashes: dict[str, str] = {}  # doc_id -> content hash
         self._lock = threading.Lock()
         self._chunk_map: dict[str, dict] = {}  # chunk_id -> metadata
@@ -101,18 +103,47 @@ class EmbeddingIndex:
             self._available = False
 
         try:
-            self._ollama_ok = (
-                self.ollama.is_available(timeout=2)
-                and self.ollama.has_model(self.embed_model)
+            self._ollama_up = self.ollama.is_available(timeout=2)
+            self._model_ok = (
+                self._ollama_up and self.ollama.has_model(self.embed_model)
             )
         except Exception:
-            self._ollama_ok = False
+            self._ollama_up = False
+            self._model_ok = False
+        self._ollama_ok = self._ollama_up and self._model_ok
 
     @property
     def ready(self) -> bool:
         """True when both chromadb and Ollama embeddings are available."""
         return self._available and self._ollama_ok
 
+    def probe(self) -> dict:
+        """Explicitly initialize backends and report readiness.
+
+        ``ready`` alone never triggers backend init (status reporters must
+        stay cheap for build_runtime/MCP handshake), so gating a build on a
+        fresh instance's ``ready`` always skipped. Init/CLI flows call this
+        instead: it pays the one-time backend cost, then reports truthfully.
+        """
+        self._ensure_ready()
+        return {
+            "ready": self.ready,
+            "chromadb": self._available,
+            "ollama": self._ollama_up,
+            "model": self._model_ok,
+        }
+
+    def unavailable_reason(self) -> str:
+        """Human-readable reason ``ready`` is False (after probe/init)."""
+        if not self._available:
+            return "chromadb not installed"
+        if not self._ollama_up:
+            return "Ollama not reachable"
+        if not self._model_ok:
+            return (f"embed model '{self.embed_model}' not pulled "
+                    f"(run: ollama pull {self.embed_model})")
+        return ""
+
     # ── Hash tracking ─────────────────────────────────────
 
     def _load_hashes(self):
@@ -138,12 +169,14 @@ class EmbeddingIndex:
 
     # ── Build / Update ────────────────────────────────────
 
-    def build(self, code_index, force: bool = False) -> dict:
+    def build(self, code_index, force: bool = False, on_progress=None) -> dict:
         """Build or incrementally update the embedding index from CodeIndex chunks.
 
         Args:
             code_index: A CodeIndex instance with populated chunks/documents.
             force: If True, re-embed all files regardless of hash.
+            on_progress: callable(files_done, files_total, chunks_embedded),
+                invoked per file (skipped files count as done).
 
         Returns:
             Stats dict with files_processed, chunks_embedded, chunks_skipped, etc.
@@ -170,6 +203,15 @@ class EmbeddingIndex:
         files_skipped = 0
         errors = 0
         stale_ids = []
+        files_total = len(chunks_by_file)
+
+        def _report():
+            if on_progress is not None:
+                try:
+                    on_progress(files_processed + files_skipped, files_total,
+                                chunks_embedded)
+                except Exception:
+                    pass
 
         with self._lock:
             # Detect deleted files — remove their embeddings
@@ -187,6 +229,7 @@ class EmbeddingIndex:
                 if not force and self._file_hashes.get(doc_id) == new_hash:
                     files_skipped += 1
                     chunks_skipped += len(file_chunks)
+                    _report()
                     continue
 
                 # Remove old chunks for this file before re-embedding
@@ -237,6 +280,7 @@ class EmbeddingIndex:
 
                 self._file_hashes[doc_id] = new_hash
                 files_processed += 1
+                _report()
 
             self._save_hashes()
 

{code_context_control-2.53.0 → code_context_control-2.54.0}/services/indexer.py

@@ -13,6 +13,7 @@ from collections import Counter, OrderedDict
 from pathlib import Path
 
 from core import count_tokens
+from services.scanner import SKIP_DIRS, iter_files
 
 
 class CodeIndex:
@@ -37,10 +38,8 @@ class CodeIndex:
         self._cooccurrence = {}   # term -> {term: count} for auto-synonyms
         self._file_mtimes = {}    # doc_id -> mtime for recency bias
 
-        # Config
-        self.skip_dirs = {'node_modules', '.git', '__pycache__', '.c3', 'venv',
-                         'env', '.venv', 'dist', 'build', '.next', '.cache',
-                         'coverage', '.pytest_cache'}
+        # Config - shared pruned-walk skip set (services/scanner.py)
+        self.skip_dirs = set(SKIP_DIRS)
         self.code_exts = {
             # Python
             '.py', '.pyi', '.pyx',
@@ -87,8 +86,31 @@ class CodeIndex:
             self.exclude_prefixes = []
             self._is_excluded = None
 
-    def build_index(self, max_files: int = 500) -> dict:
-        """Build the full code index."""
+    _DEFAULT_MAX_FILES = 2000
+
+    def _configured_max_files(self) -> int:
+        """``index_max_files`` from .c3/config.json; default 2000."""
+        try:
+            cfg = json.loads((self.project_path / '.c3' / 'config.json')
+                             .read_text(encoding='utf-8'))
+            val = int(cfg.get('index_max_files', self._DEFAULT_MAX_FILES))
+            return val if val > 0 else self._DEFAULT_MAX_FILES
+        except Exception:
+            return self._DEFAULT_MAX_FILES
+
+    def build_index(self, max_files: int = None, on_progress=None) -> dict:
+        """Build the full code index.
+
+        max_files: cap on files indexed. None reads ``index_max_files``
+            from .c3/config.json (default 2000). Traversal continues past
+            the cap only to count what was left out, so callers can report
+            "indexed N of M" instead of silently truncating.
+        on_progress: callable(entries_seen, files_indexed, chunks_created),
+            invoked during the scan (directory granularity plus per file).
+        """
+        if max_files is None:
+            max_files = self._configured_max_files()
+
         self.documents = {}
         self.chunks = {}
         self.symbols = {}
@@ -96,24 +118,35 @@ class CodeIndex:
 
         files_indexed = 0
         chunks_created = 0
+        files_capped = 0
+        scan_stats = {"entries": 0}
 
-        for fpath in sorted(self.project_path.rglob('*')):
-            if files_indexed >= max_files:
-                break
-            if not fpath.is_file():
-                continue
-            if fpath.suffix.lower() not in self.code_exts:
-                continue
-            if any(skip in fpath.parts for skip in self.skip_dirs):
-                continue
-            if self.exclude_prefixes:
+        def _report(entries_seen=None, _yielded=None):
+            if entries_seen is not None:
+                scan_stats["entries"] = entries_seen
+            if on_progress is not None:
                 try:
-                    if self._is_excluded(fpath.relative_to(self.project_path).parts,
-                                         self.exclude_prefixes):
-                        continue
-                except ValueError:
+                    on_progress(scan_stats["entries"], files_indexed,
+                                chunks_created)
+                except Exception:
                     pass
 
+        exclude_parts = None
+        if self.exclude_prefixes and self._is_excluded is not None:
+            def exclude_parts(parts, _c=self._is_excluded,
+                              _p=self.exclude_prefixes):
+                return _c(parts, _p)
+
+        for fpath in iter_files(self.project_path, exts=self.code_exts,
+                                skip_dirs=self.skip_dirs,
+                                exclude_parts=exclude_parts,
+                                on_progress=_report):
+            if files_indexed >= max_files:
+                # Walk on (cheap after pruning) to count coverage;
+                # reading and chunking stop at the cap.
+                files_capped += 1
+                continue
+
             try:
                 content = fpath.read_text(errors='replace')
             except Exception:
@@ -150,6 +183,7 @@ class CodeIndex:
                 pass
 
             files_indexed += 1
+            _report()
 
         # Build TF-IDF and co-occurrence synonyms
         self._build_tfidf()
@@ -162,7 +196,10 @@ class CodeIndex:
             "files_indexed": files_indexed,
             "chunks_created": chunks_created,
             "unique_symbols": len(self.symbols),
-            "index_path": str(self.index_dir)
+            "index_path": str(self.index_dir),
+            "entries_scanned": scan_stats["entries"],
+            "files_capped": files_capped,
+            "max_files": max_files,
         }
 
     def _chunk_file(self, content: str, ext: str, doc_id: str) -> list: