synap-git 1.2.3__tar.gz → 2.1.0__tar.gz

{synap_git-1.2.3 → synap_git-2.1.0}/CHANGELOG.md

@@ -5,6 +5,31 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [2.1.0] - 2026-05-29
+
+### Added
+- **CLI `search` command**: New user-facing command for executing hybrid structural searches directly from the terminal.
+- **`embed_provider` configuration**: Added explicit control over the vector embedding provider via `SYNAP_EMBED_PROVIDER` or `config.toml`.
+
+### Fixed
+- **CRITICAL: Metadata Nullability Bug**: Resolved a type mismatch in `CodeSymbol` where `metadata=None` caused background worker crashes. Enforced strict `dict` contract with `default_factory`.
+- **CRITICAL: Exception Swallowing**: Eradicated 26 instances of silent failure (`except Exception: pass`) across all core subsystems (API, Indexer, Storage, Retrieval, MCP, Providers). Replaced with structured, traceback-aware logging.
+- **CRITICAL: SQLite Schema Integrity**: Fixed `NOT NULL` constraint failure in `llm_calls` table by aligning schema with insertion logic and adding `cost_usd` support.
+- **HIGH: Repository-Local Logging**: Redirected daemon logs from a global shared directory to repository-local `.synap/logs` to prevent cross-repository log corruption and lock contention.
+- **HIGH: Rollback Atomicity**: Reordered `synap rollback` operations to ensure Git state is successfully restored before purging index checkpoints.
+- **MEDIUM: Provider Resiliency**: Added explicit handling for `NotImplementedError` in Anthropic and OpenRouter providers, preventing worker panics when embeddings are misconfigured.
+
+## [2.0.0] - 2026-05-29
+
+### Added
+- **.synapignore Support**: Implemented context-aware filtering to prevent traversing symlinks, binary files, and files listed in `.synapignore` or `.gitignore`.
+- **FTS5 Integration**: Shifted semantic full-text search directly to SQLite FTS5 with bounding limits (`LIMIT 50`) for `O(1)` lexical retrieval scaling on 10,000+ file monorepos.
+
+### Fixed
+- **LLM Hangs in Test Suite**: Isolated testing environment by strictly bypassing real LLM provider configs (`SYNAP_LLM_PROVIDER=""`) preventing test CI suite hangs.
+- **Repository Path Scoping in Hybrid Engine**: Fixed a bug where `repo_path` initialization mistakenly truncated the path to `/tmp` in tests, failing contextual snippet aggregation.
+- **Unbounded BM25 Expansion**: Bounded full-text search token extraction and BM25 results, preventing out-of-memory cascading in CTE traversal during monorepo indexing.
+
 ## [1.2.3] - 2026-05-28
 
 ### Added

{synap_git-1.2.3 → synap_git-2.1.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: synap-git
-Version: 1.2.3
+Version: 2.1.0
 Summary: Persistent structural context infrastructure for AI coding agents.
 Project-URL: Homepage, https://github.com/saahilpal/synap-git
 Project-URL: Repository, https://github.com/saahilpal/synap-git
@@ -52,10 +52,10 @@ Description-Content-Type: text/markdown
 
 Local Git-aware structural context engine for AI coding agents.
 
-[![CI Status](https://github.com/saahilpal/synap-git/actions/workflows/ci.yml/badge.svg)](https://github.com/saahilpal/synap-git/actions)
-[![Version](https://img.shields.io/pypi/v/synap-git?color=3b82f6)](https://img.shields.io/project/synap-git/)
-[![Python Version](https://img.shields.io/pypi/pyversions/synap-git)](https://img.shields.io/project/synap-git/)
-[![License](https://img.shields.io/github/license/saahilpal/synap-git?color=cbd5e1)](LICENSE.md)
+[![CI Status](https://github.com/saahilpal/synapse/actions/workflows/ci.yml/badge.svg)](https://github.com/saahilpal/synapse/actions)
+[![Version](https://img.shields.io/pypi/v/synap-git?color=3b82f6)](https://pypi.org/project/synap-git/)
+[![Python Version](https://img.shields.io/pypi/pyversions/synap-git)](https://pypi.org/project/synap-git/)
+[![License](https://img.shields.io/github/license/saahilpal/synapse?color=cbd5e1)](LICENSE.md)
 
 ## The Problem
 

{synap_git-1.2.3 → synap_git-2.1.0}/README.md

@@ -2,10 +2,10 @@
 
 Local Git-aware structural context engine for AI coding agents.
 
-[![CI Status](https://github.com/saahilpal/synap-git/actions/workflows/ci.yml/badge.svg)](https://github.com/saahilpal/synap-git/actions)
-[![Version](https://img.shields.io/pypi/v/synap-git?color=3b82f6)](https://img.shields.io/project/synap-git/)
-[![Python Version](https://img.shields.io/pypi/pyversions/synap-git)](https://img.shields.io/project/synap-git/)
-[![License](https://img.shields.io/github/license/saahilpal/synap-git?color=cbd5e1)](LICENSE.md)
+[![CI Status](https://github.com/saahilpal/synapse/actions/workflows/ci.yml/badge.svg)](https://github.com/saahilpal/synapse/actions)
+[![Version](https://img.shields.io/pypi/v/synap-git?color=3b82f6)](https://pypi.org/project/synap-git/)
+[![Python Version](https://img.shields.io/pypi/pyversions/synap-git)](https://pypi.org/project/synap-git/)
+[![License](https://img.shields.io/github/license/saahilpal/synapse?color=cbd5e1)](LICENSE.md)
 
 ## The Problem
 

{synap_git-1.2.3 → synap_git-2.1.0}/src/synap_git/__init__.py

@@ -2,4 +2,4 @@
 
 __all__ = ["__version__"]
 
-__version__ = "1.2.3"
+__version__ = "2.1.0"

{synap_git-1.2.3 → synap_git-2.1.0}/src/synap_git/api/app.py

@@ -101,8 +101,10 @@ def create_app(runtime: SynapRuntime) -> FastAPI:
             target = target[:-3]
         try:
             await asyncio.to_thread(runtime.wiki.ensure_wiki_page, target)
-        except Exception:
-            pass
+        except Exception as e:
+            import structlog
+
+            structlog.get_logger().error("suppressed_error_caught", error=str(e), exc_info=True)
 
         wiki_path = runtime.wiki.wiki_dir / f"{target}.md"
         exists = await asyncio.to_thread(wiki_path.exists)

{synap_git-1.2.3 → synap_git-2.1.0}/src/synap_git/cli/main.py

@@ -642,8 +642,10 @@ def start(
                 return
             else:
                 pid_file.unlink()
-        except Exception:
-            pass
+        except Exception as e:
+            import structlog
+
+            structlog.get_logger().error("suppressed_error_caught", error=str(e), exc_info=True)
 
     # 2. Spawn detached daemon process
     cmd = [sys.executable, "-m", "synap_git.cli", "daemon-run", abs_path.as_posix()]
@@ -782,8 +784,10 @@ def stop(
                 os.waitpid(pid, os.WNOHANG)
             except (ChildProcessError, OSError):
                 pass
-        except Exception:
-            pass
+        except Exception as e:
+            import structlog
+
+            structlog.get_logger().error("suppressed_error_caught", error=str(e), exc_info=True)
         success = not _is_process_running(pid)
 
     # Clean up lockfiles
@@ -895,6 +899,7 @@ def status(
 
 @app.command()
 def logs(
+    path: Annotated[str, typer.Argument(help="Repository path.")] = ".",
     tail: Annotated[
         bool, typer.Option("--tail", "-t", help="Stream new log entries in real-time.")
     ] = False,
@@ -906,7 +911,9 @@ def logs(
     """View and tail Synap runtime logs."""
     import time
 
-    log_dir = Path("~/.config/synap/logs").expanduser()
+    settings = _settings(path)
+    log_dir = settings.log_path
+    assert log_dir is not None
     log_file = log_dir / "daemon.log"
 
     if not log_file.exists():
@@ -938,6 +945,32 @@ def logs(
         console.print(f"[red]Error reading logs: {e}[/red]")
 
 
+@app.command()
+def search(
+    query: Annotated[str, typer.Argument(help="Search query.")],
+    path: Annotated[str, typer.Option("--path", "-p", help="Repository path.")] = ".",
+    max_tokens: Annotated[
+        int, typer.Option("--max-tokens", help="Maximum context window tokens.")
+    ] = 4000,
+) -> None:
+    """Execute a hybrid structural search across the repository."""
+    settings = _settings(path)
+    runtime = SynapRuntime(settings)
+
+    with Progress(
+        SpinnerColumn(),
+        TextColumn("[progress.description]{task.description}"),
+        transient=True,
+    ) as progress:
+        progress.add_task(description="Retrieving context...", total=None)
+        answer, context, _ = runtime.query_hybrid(query, max_tokens=max_tokens)
+
+    console.print("\n[bold cyan]Hybrid Retrieval Results[/bold cyan]")
+    console.print("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━")
+    console.print(answer)
+    console.print("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━")
+
+
 @app.command()
 def update() -> None:
     """Check for updates and upgrade the Synap runtime."""
@@ -1179,16 +1212,6 @@ def rollback(
         if not typer.confirm("\nProceed?", default=False):
             raise typer.Abort()
 
-    # Clear current checkpoint
-    try:
-        with runtime.store.connect() as conn:
-            conn.execute(
-                "DELETE FROM checkpoints WHERE branch = ?",
-                (runtime.git.state().effective_branch,),
-            )
-    except Exception:
-        pass
-
     # git checkout
     try:
         subprocess.check_call(  # noqa: S603
@@ -1199,6 +1222,18 @@ def rollback(
         console.print(f"[red]✗ Git checkout failed: {e}[/red]")
         raise typer.Abort()
 
+    # Clear current checkpoint
+    try:
+        with runtime.store.connect() as conn:
+            conn.execute(
+                "DELETE FROM checkpoints WHERE branch = ?",
+                (runtime.git.state().effective_branch,),
+            )
+    except Exception as e:
+        import structlog
+
+        structlog.get_logger().error("suppressed_error_caught", error=str(e), exc_info=True)
+
     runtime.bootstrap(force=True)
     console.print(f"[green]✓ Rolled back successfully to {selected_commit}[/green]")
 
@@ -1264,8 +1299,10 @@ def repair(
     console.print("[3/3] Regenerating wiki from last known state")
     try:
         runtime.wiki.generate_project_wiki()
-    except Exception:
-        pass
+    except Exception as e:
+        import structlog
+
+        structlog.get_logger().error("suppressed_error_caught", error=str(e), exc_info=True)
 
     status_info = runtime.status()
     console.print(f"\n[green]✓ Recovery complete. {status_info.files} files restored.[/green]")

{synap_git-1.2.3 → synap_git-2.1.0}/src/synap_git/config.py

@@ -92,7 +92,9 @@ class SynapSettings(BaseSettings):
                     if line.strip().startswith(f"{key}="):
                         return line.split("=", 1)[1].strip().strip("\"'")
         except Exception:
-            pass
+            import structlog
+
+            structlog.get_logger(__name__).exception("fallback_credential_lookup_failed", key=key)
         return None
 
     @property

{synap_git-1.2.3 → synap_git-2.1.0}/src/synap_git/diagnostics/logger.py

@@ -22,7 +22,6 @@ class TraceResult:
 
 def configure_logging(settings: SynapSettings) -> None:
     from logging.handlers import RotatingFileHandler
-    from pathlib import Path
 
     timestamper = structlog.processors.TimeStamper(fmt="iso", utc=True)
     shared_processors: list[structlog.typing.Processor] = [
@@ -38,7 +37,8 @@ def configure_logging(settings: SynapSettings) -> None:
     else:
         renderer = structlog.dev.ConsoleRenderer(colors=False)
 
-    log_dir = Path("~/.config/synap/logs").expanduser()
+    log_dir = settings.log_path
+    assert log_dir is not None
     log_dir.mkdir(parents=True, exist_ok=True)
     log_file = log_dir / "daemon.log"
 

{synap_git-1.2.3 → synap_git-2.1.0}/src/synap_git/git/state.py

@@ -128,8 +128,10 @@ class GitRepository:
                         break
                 if is_revert:
                     return GitChange(kind=GitChangeKind.REVERT, previous=previous, current=current)
-            except Exception:
-                pass
+            except Exception as e:
+                import structlog
+
+                structlog.get_logger().error("suppressed_error_caught", error=str(e), exc_info=True)
 
             if len(current.commit_parent_hashes) > 1:
                 return GitChange(kind=GitChangeKind.MERGE, previous=previous, current=current)

{synap_git-1.2.3 → synap_git-2.1.0}/src/synap_git/indexer/daemon.py

@@ -244,16 +244,20 @@ class RuntimeDaemon:
         if heartbeat_file.exists():
             try:
                 heartbeat_file.unlink()
-            except Exception:
-                pass
+            except Exception as e:
+                import structlog
+
+                structlog.get_logger().error("suppressed_error_caught", error=str(e), exc_info=True)
 
         # Cleanup process PID lockfile as well
         pid_file = self.settings.repository_path / ".synap" / "daemon.pid"
         if pid_file.exists():
             try:
                 pid_file.unlink()
-            except Exception:
-                pass
+            except Exception as e:
+                import structlog
+
+                structlog.get_logger().error("suppressed_error_caught", error=str(e), exc_info=True)
 
     async def _poll_git_loop(self) -> None:
         while not self._stop_event.is_set():

{synap_git-1.2.3 → synap_git-2.1.0}/src/synap_git/indexer/engine.py

@@ -69,6 +69,7 @@ class SynapRuntime:
         self.parser_registry = CodeParserRegistry()
         self.llm_provider = get_llm_provider(settings)
         self.retrieval_engine = HybridRetrievalEngine(
+            repo_path=self.settings.repository_path,
             store=self.store,
             llm_provider=self.llm_provider,
             trace_store=self.trace_store,
@@ -140,8 +141,10 @@ class SynapRuntime:
                 if change.kind == "revert":
                     self.handle_revert(prev, git_state)
                     return git_state.head_commit
-            except Exception:
-                pass
+            except Exception as e:
+                import structlog
+
+                structlog.get_logger().error("suppressed_error_caught", error=str(e), exc_info=True)
 
         return self.index_repository(git_state=git_state, force=force)
 
@@ -244,6 +247,53 @@ class SynapRuntime:
 
         return commit
 
+    def _schedule_embedding(
+        self, file_id: str, symbols: list[dict[str, Any]], content_hash: str
+    ) -> None:
+        provider = self.llm_provider
+        if not provider:
+            return
+
+        def _worker() -> None:
+            import structlog
+
+            logger = structlog.get_logger()
+            try:
+                batches = [symbols[i : i + 50] for i in range(0, len(symbols), 50)]
+                model_name = getattr(provider, "default_model", "unknown")
+                for batch in batches:
+                    for sym in batch:
+                        try:
+                            # Avoid re-embedding if unchanged?
+                            text = (
+                                sym["name"] + " " + (sym.get("metadata") or {}).get("docstring", "")
+                            )
+                            vector = provider.embed(text)
+                            self.store.put_embedding(
+                                sym["symbol_id"], model_name, "1.0", "1.0", vector, content_hash
+                            )
+                        except NotImplementedError as e:
+                            logger.warning(
+                                "embedding_not_supported_by_provider",
+                                error=str(e),
+                                suggestion="Configure SYNAP_EMBED_PROVIDER=ollama or openai.",
+                            )
+                            return  # Stop attempting batch if not supported
+                        except Exception as e:
+                            logger.warning("background_embed_failed_for_symbol", error=str(e))
+            except Exception as e:
+                logger.warning("background_embed_failed", error=str(e))
+
+        try:
+            import asyncio
+
+            loop = asyncio.get_running_loop()
+            loop.create_task(asyncio.to_thread(_worker))
+        except RuntimeError:
+            import threading
+
+            threading.Thread(target=_worker, daemon=True).start()
+
     def _first_run_index(self, git_state: GitState) -> str | None:
         self.logger.info("first_run_indexing_started", branch=git_state.effective_branch)
         import time
@@ -254,16 +304,9 @@ class SynapRuntime:
             repository_path=self.settings.repository_path,
             max_file_bytes=self.settings.max_file_bytes,
         )
-        scan = scanner.scan()
-
-        files_to_parse = []
-        for file_info in scan.files:
-            files_to_parse.append((file_info.path, file_info.relative_path, file_info.content))
-
-        num_files = len(files_to_parse)
+        num_files = scanner.count_files()
         chunk_size = 500
         parsed_results = []
-
         # Parallel parsing using ProcessPoolExecutor
         import multiprocessing
         from concurrent.futures import ProcessPoolExecutor
@@ -301,16 +344,22 @@ class SynapRuntime:
                 task = progress.add_task("[yellow]Parsing codebase...[/yellow]", total=num_files)
 
                 with ProcessPoolExecutor(max_workers=num_workers) as executor:
-                    for chunk_idx in range(0, num_files, chunk_size):
-                        chunk = files_to_parse[chunk_idx : chunk_idx + chunk_size]
+                    from itertools import islice
+
+                    file_iterator = scanner.scan()
+                    while True:
+                        chunk_files = list(islice(file_iterator, chunk_size))
+                        if not chunk_files:
+                            break
+
+                        file_info_map = {f.relative_path: f for f in chunk_files}
+                        chunk = [(f.path, f.relative_path, f.content) for f in chunk_files]
                         futures = [executor.submit(_parse_worker, item) for item in chunk]
                         chunk_results = [f.result() for f in futures]
 
                         for res in chunk_results:
                             rel_path = res["path"]
-                            matching_info = next(
-                                (f for f in scan.files if f.relative_path == rel_path), None
-                            )
+                            matching_info = file_info_map.get(rel_path)
                             git_oid = matching_info.git_oid if matching_info else ""
                             content_hash = matching_info.content_hash if matching_info else ""
 
@@ -328,6 +377,7 @@ class SynapRuntime:
                                 language=res["language"],
                                 symbols=res["symbols"],
                             )
+                            self._schedule_embedding(file_id_hash, res["symbols"], content_hash)
                             self.store.enqueue_wiki(rel_path)
                             parsed_results.append((file_id_hash, rel_path, res["imports"]))
 
@@ -336,20 +386,26 @@ class SynapRuntime:
                             self._resolve_and_insert_edges(parsed_results)
                             parsed_results.clear()
 
-                        progress.advance(task, len(chunk))
+                        progress.advance(task, len(chunk_files))
                         del chunk_results
         else:
             with ProcessPoolExecutor(max_workers=num_workers) as executor:
-                for chunk_idx in range(0, num_files, chunk_size):
-                    chunk = files_to_parse[chunk_idx : chunk_idx + chunk_size]
+                from itertools import islice
+
+                file_iterator = scanner.scan()
+                while True:
+                    chunk_files = list(islice(file_iterator, chunk_size))
+                    if not chunk_files:
+                        break
+
+                    file_info_map = {f.relative_path: f for f in chunk_files}
+                    chunk = [(f.path, f.relative_path, f.content) for f in chunk_files]
                     futures = [executor.submit(_parse_worker, item) for item in chunk]
                     chunk_results = [f.result() for f in futures]
 
                     for res in chunk_results:
                         rel_path = res["path"]
-                        matching_info = next(
-                            (f for f in scan.files if f.relative_path == rel_path), None
-                        )
+                        matching_info = file_info_map.get(rel_path)
                         git_oid = matching_info.git_oid if matching_info else ""
                         content_hash = matching_info.content_hash if matching_info else ""
 
@@ -367,6 +423,7 @@ class SynapRuntime:
                             language=res["language"],
                             symbols=res["symbols"],
                         )
+                        self._schedule_embedding(file_id_hash, res["symbols"], content_hash)
                         self.store.enqueue_wiki(rel_path)
                         parsed_results.append((file_id_hash, rel_path, res["imports"]))
 
@@ -426,6 +483,7 @@ class SynapRuntime:
 
         added_or_modified = []
         deleted = []
+        renames = []
         for line in res.stdout.splitlines():
             if not line.strip():
                 continue
@@ -433,13 +491,41 @@ class SynapRuntime:
             if len(parts) >= 2:
                 status = parts[0]
                 if status.startswith("R"):
-                    deleted.append(parts[1])
+                    renames.append((parts[1], parts[2]))
                     added_or_modified.append(parts[2])
                 elif status == "D":
                     deleted.append(parts[1])
                 else:
                     added_or_modified.append(parts[1])
 
+        import hashlib
+
+        # Apply renames to preserve identity
+        with self.store.connect() as conn:
+            for old_path, new_path in renames:
+                file_row = conn.execute(
+                    "SELECT file_id, content_hash FROM files WHERE path = ?", (old_path,)
+                ).fetchone()
+                if file_row:
+                    old_file_id = file_row["file_id"]
+                    content_hash = file_row["content_hash"]
+                    new_file_id = hashlib.sha256(
+                        (new_path + content_hash).encode("utf-8")
+                    ).hexdigest()
+
+                    conn.execute("PRAGMA foreign_keys=OFF")
+                    try:
+                        conn.execute(
+                            "UPDATE files SET file_id = ?, path = ? WHERE file_id = ?",
+                            (new_file_id, new_path, old_file_id),
+                        )
+                        conn.execute(
+                            "UPDATE symbols SET file_id = ? WHERE file_id = ?",
+                            (new_file_id, old_file_id),
+                        )
+                    finally:
+                        conn.execute("PRAGMA foreign_keys=ON")
+
         # Filter added/modified files
         scanner = RepositoryScanner(
             repository_path=self.settings.repository_path,
@@ -549,6 +635,7 @@ class SynapRuntime:
                 language=parse_result.language,
                 symbols=symbols_list,
             )
+            self._schedule_embedding(file_id_hash, symbols_list, content_hash)
 
             self.store.set_wiki_status(rel_path, None, "stale")
             self.store.enqueue_wiki(rel_path)
@@ -600,8 +687,12 @@ class SynapRuntime:
                         candidate_rel = (target_dir / "/".join(parts)).as_posix()
                         for ext in [".py", ".ts", ".go", ".rs"]:
                             candidate_paths.add(f"{candidate_rel}{ext}")
-                    except Exception:
-                        pass
+                    except Exception as e:
+                        import structlog
+
+                        structlog.get_logger().error(
+                            "suppressed_error_caught", error=str(e), exc_info=True
+                        )
                 else:
                     module_keys.add(module_part)
                 fts_names.add(target_name)
@@ -667,8 +758,12 @@ class SynapRuntime:
                                 if cand_path in path_to_file_id:
                                     target_file_id = path_to_file_id[cand_path]
                                     break
-                        except Exception:
-                            pass
+                        except Exception as e:
+                            import structlog
+
+                            structlog.get_logger().error(
+                                "suppressed_error_caught", error=str(e), exc_info=True
+                            )
                     else:
                         target_file_id = module_key_to_file_id.get(module_part)
 
@@ -701,11 +796,23 @@ class SynapRuntime:
                     for row in rows:
                         fts_symbols_by_name.setdefault(row["name"], []).append(dict(row))
 
+            target_symbols_dict: dict[str, dict[str, list[dict[str, Any]]]] = {}
+            for t_file_id, syms in target_symbols_by_file.items():
+                name_map: dict[str, Any] = {}
+                for sym in syms:
+                    name_map.setdefault(sym["name"], []).append(sym)
+                target_symbols_dict[t_file_id] = name_map
+
             for file_id, rel_path, imports in parsed_results:
                 file_symbols = file_symbols_map.get(file_id, [])
                 current_path = Path(rel_path)
+                edges_added_for_file = 0
+                max_edges_per_file = 1000
 
                 for imp in imports:
+                    if edges_added_for_file >= max_edges_per_file:
+                        break
+
                     target_file_id = None
                     if ":" in imp:
                         module_part, target_name = imp.split(":", 1)
@@ -723,20 +830,36 @@ class SynapRuntime:
                                 if cand_path in path_to_file_id:
                                     target_file_id = path_to_file_id[cand_path]
                                     break
-                        except Exception:
-                            pass
+                        except Exception as e:
+                            import structlog
+
+                            structlog.get_logger().error(
+                                "suppressed_error_caught", error=str(e), exc_info=True
+                            )
                     else:
                         target_file_id = module_key_to_file_id.get(module_part)
 
+                        # Fuzzy fallback
+                        if not target_file_id:
+                            for mk, fid in module_key_to_file_id.items():
+                                if mk.endswith(module_part) or mk.endswith(f".{module_part}"):
+                                    target_file_id = fid
+                                    break
+
                     target_symbols = []
                     if target_file_id:
-                        all_target_syms = target_symbols_by_file.get(target_file_id, [])
-                        target_symbols = [ts for ts in all_target_syms if ts["name"] == target_name]
+                        target_symbols = target_symbols_dict.get(target_file_id, {}).get(
+                            target_name, []
+                        )
                     else:
                         target_symbols = fts_symbols_by_name.get(target_name, [])
 
                     for ts in target_symbols:
+                        if edges_added_for_file >= max_edges_per_file:
+                            break
                         for fs in file_symbols:
+                            if edges_added_for_file >= max_edges_per_file:
+                                break
                             if fs["symbol_id"] == ts["symbol_id"]:
                                 continue
                             edge_id = stable_hash(
@@ -747,6 +870,7 @@ class SynapRuntime:
                                 }
                             )
                             edges_to_insert.append((edge_id, fs["symbol_id"], ts["symbol_id"]))
+                            edges_added_for_file += 1
 
             if edges_to_insert:
                 conn.executemany(
@@ -787,8 +911,10 @@ class SynapRuntime:
         is_dirty = False
         try:
             is_dirty = self.git.state().is_dirty
-        except Exception:
-            pass
+        except Exception as e:
+            import structlog
+
+            structlog.get_logger().error("suppressed_error_caught", error=str(e), exc_info=True)
         return self.retrieval_engine.retrieve(query, max_tokens=max_tokens, is_dirty=is_dirty)
 
     def doctor(self, *, auto_recover: bool = False) -> dict[str, Any]: