attocode-code-intel 0.1.24__tar.gz → 0.1.26__tar.gz

{attocode_code_intel-0.1.24 → attocode_code_intel-0.1.26}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: attocode-code-intel
-Version: 0.1.24
+Version: 0.1.26
 Summary: Local code search and navigation for coding agents and people
 Project-URL: Homepage, https://github.com/eren23/attocode
 Project-URL: Repository, https://github.com/eren23/attocode
@@ -156,6 +156,10 @@ To use the latest source, install from a clone of this repository: `uv tool inst
 
 ## What your agent gets
 
+Version 0.1.26 gives Rust precision lookups a shared five-second budget and fixes cancelled startup cleanup when a child retains inherited pipes. Other languages keep two seconds; longer reloads still return partial evidence.
+
+Version 0.1.25 uses OpenAI embeddings only when you set `ATTOCODE_EMBEDDING_MODEL=openai`. Before, an `OPENAI_API_KEY` in the environment was enough to send code chunks to OpenAI at index time. Rust references are also more reliable while rust-analyzer loads.
+
 Version 0.1.24 adds `ATTOCODE_INTEL_RANKING_PROVIDER=openrouter`, a preset for the opt-in hosted rerank. In a frozen trial with 24 short questions, the rerank found 24 of 26 labeled files in the first five results, against 20 without it; see [Hosted rerank](https://github.com/eren23/attocode/blob/main/docs/intelligence-search.md#hosted-rerank-experimental). Rerank stays off by default, because it sends source excerpts to OpenRouter.
 
 Version 0.1.23 is listed in the official MCP Registry and documents a `uvx` quick start. The opt-in hosted rerank now accepts the dated model ID that OpenRouter returns; see [Hosted rerank](https://github.com/eren23/attocode/blob/main/docs/intelligence-search.md#hosted-rerank-experimental). Rerank stays off by default.

{attocode_code_intel-0.1.24 → attocode_code_intel-0.1.26}/README.md

@@ -43,6 +43,10 @@ To use the latest source, install from a clone of this repository: `uv tool inst
 
 ## What your agent gets
 
+Version 0.1.26 gives Rust precision lookups a shared five-second budget and fixes cancelled startup cleanup when a child retains inherited pipes. Other languages keep two seconds; longer reloads still return partial evidence.
+
+Version 0.1.25 uses OpenAI embeddings only when you set `ATTOCODE_EMBEDDING_MODEL=openai`. Before, an `OPENAI_API_KEY` in the environment was enough to send code chunks to OpenAI at index time. Rust references are also more reliable while rust-analyzer loads.
+
 Version 0.1.24 adds `ATTOCODE_INTEL_RANKING_PROVIDER=openrouter`, a preset for the opt-in hosted rerank. In a frozen trial with 24 short questions, the rerank found 24 of 26 labeled files in the first five results, against 20 without it; see [Hosted rerank](https://github.com/eren23/attocode/blob/main/docs/intelligence-search.md#hosted-rerank-experimental). Rerank stays off by default, because it sends source excerpts to OpenRouter.
 
 Version 0.1.23 is listed in the official MCP Registry and documents a `uvx` quick start. The opt-in hosted rerank now accepts the dated model ID that OpenRouter returns; see [Hosted rerank](https://github.com/eren23/attocode/blob/main/docs/intelligence-search.md#hosted-rerank-experimental). Rerank stays off by default.

{attocode_code_intel-0.1.24 → attocode_code_intel-0.1.26}/pyproject.toml

@@ -6,7 +6,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "attocode-code-intel"
-version = "0.1.24"
+version = "0.1.26"
 description = "Local code search and navigation for coding agents and people"
 readme = "README.md"
 requires-python = ">=3.12"

{attocode_code_intel-0.1.24 → attocode_code_intel-0.1.26}/src/attocode_intel/__init__.py

@@ -49,4 +49,4 @@ def __getattr__(name: str) -> Any:
     raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
 
 # The other copy is packages/code-intel/pyproject.toml. A test checks that both match.
-__version__ = "0.1.24"
+__version__ = "0.1.26"

{attocode_code_intel-0.1.24 → attocode_code_intel-0.1.26}/src/attocode_intel/_internal/integrations/context/embeddings.py

@@ -1,10 +1,13 @@
 """Embedding provider abstraction for semantic search.
 
-Tries providers in order:
-1. Local: sentence-transformers with code-optimized model (no API cost)
+Auto-detect tries local providers only:
+1. Local: sentence-transformers with code-trained or code-optimized models
 2. Local: sentence-transformers with general model (smaller fallback)
-3. API: OpenAI text-embedding-3-small (if OPENAI_API_KEY set)
-4. None: graceful degradation (returns empty vectors)
+3. None: graceful degradation (returns empty vectors)
+
+The OpenAI API sends source text off the machine. It is used only when
+``ATTOCODE_EMBEDDING_MODEL=openai`` (or ``model="openai"``) selects it, never
+because ``OPENAI_API_KEY`` is set, and never with ``ATTOCODE_LOCAL_ONLY``.
 """
 
 from __future__ import annotations
@@ -172,14 +175,20 @@ def create_embedding_provider(
             - "bge" (768-dim, recommended for code search)
             - "all-MiniLM-L6-v2" (384-dim, fast, smaller)
             - "nomic-embed-text" (768-dim, better code understanding)
-            - "openai" (API-based, requires OPENAI_API_KEY)
-            - "" (auto-detect best available)
+            - "openai" (API-based, requires OPENAI_API_KEY; sends source text)
+            - "" (auto-detect best available local provider)
 
-    Auto-detect order: bge (code-optimized) > MiniLM > OpenAI API > null.
+    Auto-detect order: nomic > bge > MiniLM > null. It never selects a remote
+    provider, so an API key in the environment alone sends no source text.
     Note: switching models requires reindexing (different vector dims).
     """
     model = model or os.environ.get("ATTOCODE_EMBEDDING_MODEL", "")
 
+    # Checked before the cache, so a provider created earlier is not reused.
+    if model == "openai" and os.environ.get("ATTOCODE_LOCAL_ONLY", "").lower() in {"1", "true", "yes", "on"}:
+        logger.warning("ATTOCODE_LOCAL_ONLY is set; refusing the OpenAI embedding provider")
+        return NullEmbeddingProvider()
+
     if model in _provider_cache:
         return _provider_cache[model]
 
@@ -251,7 +260,7 @@ def create_embedding_provider(
         _provider_cache[model] = provider
         return provider
     except ImportError:
-        logger.debug("sentence-transformers not installed, trying OpenAI")
+        logger.debug("sentence-transformers not installed")
     except Exception as exc:
         logger.info("BGE model unavailable (%s), falling back to MiniLM", exc)
         try:
@@ -260,23 +269,11 @@ def create_embedding_provider(
             _provider_cache[model] = provider
             return provider
         except ImportError:
-            logger.debug("sentence-transformers not installed, trying OpenAI")
+            logger.debug("sentence-transformers not installed")
         except Exception as exc2:
             logger.warning("Local embedding provider unavailable: %s", exc2)
             logger.debug("Local embedding provider traceback", exc_info=True)
 
-    # Try OpenAI API
-    if os.environ.get("OPENAI_API_KEY"):
-        try:
-            provider = OpenAIEmbeddingProvider()
-            logger.info("Using OpenAI embedding provider: %s", provider.name)
-            _provider_cache[model] = provider
-            return provider
-        except ImportError:
-            logger.debug("openai package not installed")
-        except Exception:
-            logger.debug("OpenAI embedding provider failed", exc_info=True)
-
     # Graceful degradation — don't cache so retry picks up newly installed packages
     logger.info("No embedding provider available; semantic search will use keyword fallback")
     return NullEmbeddingProvider()

{attocode_code_intel-0.1.24 → attocode_code_intel-0.1.26}/src/attocode_intel/_internal/integrations/context/systemone_ranker.py

@@ -24,6 +24,85 @@ _MAX_RESPONSE_BYTES = 64 * 1024
 _REMOTE_BLOCKED = {"1", "true", "yes", "on"}
 
 
+def workspace_consent(opt_in: bool, workspace: str, project_dir: str) -> bool:
+    """The hosted-source consent: an opt-in and this exact absolute project directory."""
+    return opt_in and os.path.isabs(workspace) and os.path.realpath(workspace) == project_dir
+
+
+def check_endpoint(endpoint: str, *, allow_remote: bool, service_mode: bool, auth_env: str) -> bool:
+    """Validate an opt-in hosted endpoint; return whether it is remote.
+
+    Raises ``ValueError`` for an unsafe URL, a refused remote endpoint or an
+    auth setting that is not an environment-variable name.
+    """
+    parsed = urlsplit(endpoint)
+    try:
+        host = parsed.hostname
+        _ = parsed.port
+    except ValueError as exc:
+        raise ValueError("invalid ranking endpoint") from exc
+    if (
+        parsed.scheme not in {"http", "https"}
+        or not host
+        or not parsed.path
+        or parsed.username
+        or parsed.password
+        or parsed.query
+        or parsed.fragment
+    ):
+        raise ValueError(
+            "ranking endpoint must be an absolute HTTP(S) URL without credentials or query"
+        )
+    try:
+        loopback = ipaddress.ip_address(host).is_loopback
+    except ValueError:
+        # A hostname can resolve differently between validation and use.
+        # Local source access requires an explicit loopback IP literal.
+        loopback = False
+    if not loopback and parsed.scheme != "https":
+        raise ValueError("non-loopback ranking endpoints require HTTPS")
+    if not loopback and (
+        not allow_remote
+        or service_mode
+        or os.environ.get("ATTOCODE_LOCAL_ONLY", "").lower() in _REMOTE_BLOCKED
+    ):
+        raise ValueError("remote source ranking is not permitted")
+    if auth_env and re.fullmatch(r"[A-Za-z_][A-Za-z0-9_]*", auth_env) is None:
+        raise ValueError("ranking credential must be an environment-variable name")
+    return not loopback
+
+
+def post_json(
+    endpoint: str,
+    body: dict,
+    headers: dict[str, str],
+    timeout_seconds: float,
+    transport: httpx.BaseTransport | None,
+    max_bytes: int = _MAX_RESPONSE_BYTES,
+) -> object:
+    """POST JSON and decode a response of at most ``max_bytes`` (64 KiB)."""
+    # Do not inherit proxy settings or follow a redirect to a different
+    # origin; both could silently send source to an unapproved host.
+    with (
+        httpx.Client(
+            timeout=timeout_seconds,
+            trust_env=False,
+            follow_redirects=False,
+            transport=transport,
+        ) as client,
+        client.stream("POST", endpoint, json=body, headers=headers) as response,
+    ):
+        response.raise_for_status()
+        chunks: list[bytes] = []
+        size = 0
+        for chunk in response.iter_bytes():
+            size += len(chunk)
+            if size > max_bytes:
+                raise ValueError("ranking response too large")
+            chunks.append(chunk)
+    return json.loads(b"".join(chunks))
+
+
 class SystemOneChoiceReranker:
     """One ``choice`` request for a bounded page of distinct files.
 
@@ -46,40 +125,9 @@ class SystemOneChoiceReranker:
         max_excerpt_chars: int = 1350,
         transport: httpx.BaseTransport | None = None,
     ) -> None:
-        parsed = urlsplit(endpoint)
-        try:
-            host = parsed.hostname
-            _ = parsed.port
-        except ValueError as exc:
-            raise ValueError("invalid ranking endpoint") from exc
-        if (
-            parsed.scheme not in {"http", "https"}
-            or not host
-            or not parsed.path
-            or parsed.username
-            or parsed.password
-            or parsed.query
-            or parsed.fragment
-        ):
-            raise ValueError(
-                "ranking endpoint must be an absolute HTTP(S) URL without credentials or query"
-            )
-        try:
-            loopback = ipaddress.ip_address(host).is_loopback
-        except ValueError:
-            # A hostname can resolve differently between validation and use.
-            # Local source access requires an explicit loopback IP literal.
-            loopback = False
-        if not loopback and parsed.scheme != "https":
-            raise ValueError("non-loopback ranking endpoints require HTTPS")
-        if not loopback and (
-            not allow_remote
-            or service_mode
-            or os.environ.get("ATTOCODE_LOCAL_ONLY", "").lower() in _REMOTE_BLOCKED
-        ):
-            raise ValueError("remote source ranking is not permitted")
-        if auth_env and re.fullmatch(r"[A-Za-z_][A-Za-z0-9_]*", auth_env) is None:
-            raise ValueError("ranking credential must be an environment-variable name")
+        loopback = not check_endpoint(
+            endpoint, allow_remote=allow_remote, service_mode=service_mode, auth_env=auth_env
+        )
         if timeout_seconds is None:
             timeout_seconds = 5.0 if loopback else 0.8
         if not 1 <= max_candidates <= 64 or not 0 < timeout_seconds <= 30:
@@ -106,26 +154,7 @@ class SystemOneChoiceReranker:
         return True
 
     def _post(self, body: dict, headers: dict[str, str]) -> dict:
-        # Do not inherit proxy settings or follow a redirect to a different
-        # origin; both could silently send source to an unapproved host.
-        with (
-            httpx.Client(
-                timeout=self.timeout_seconds,
-                trust_env=False,
-                follow_redirects=False,
-                transport=self._transport,
-            ) as client,
-            client.stream("POST", self.endpoint, json=body, headers=headers) as response,
-        ):
-            response.raise_for_status()
-            chunks: list[bytes] = []
-            size = 0
-            for chunk in response.iter_bytes():
-                size += len(chunk)
-                if size > _MAX_RESPONSE_BYTES:
-                    raise ValueError("ranking response too large")
-                chunks.append(chunk)
-        result = json.loads(b"".join(chunks))
+        result = post_json(self.endpoint, body, headers, self.timeout_seconds, self._transport)
         if not isinstance(result, dict):
             raise ValueError("invalid ranking response")
         # Workers AI wraps every answer as {"result": {...}, "success": true, "errors": []}.

{attocode_code_intel-0.1.24 → attocode_code_intel-0.1.26}/src/attocode_intel/_internal/integrations/lsp/client.py

@@ -194,6 +194,10 @@ class _LSPClient:
         self._stderr_task: asyncio.Task[None] | None = None
         self._is_stopping = False  # Suppress spurious errors during shutdown
         self._trace_enabled = False  # Protocol tracing (set via feature flag)
+        # rust-analyzer replies null while its VFS loads; experimental/serverStatus
+        # tells when it is ready. Servers that send no status count as ready.
+        self._ready = asyncio.Event()
+        self._ready.set()
 
     @property
     def language_id(self) -> str:
@@ -210,6 +214,7 @@ class _LSPClient:
     async def start(self) -> None:
         """Start the language server and initialize it."""
         self._documents.clear()
+        self._ready.set()
         self._process = await asyncio.create_subprocess_exec(  # noqa: S603
             self._config.command,
             *self._config.args,
@@ -231,6 +236,7 @@ class _LSPClient:
             "rootUri": self._root_uri,
             "workspaceFolders": [{"uri": self._root_uri, "name": "workspace"}],
             "capabilities": {
+                "experimental": {"serverStatusNotification": True},
                 "workspace": {"workspaceFolders": True},
                 "textDocument": {
                     "completion": {"completionItem": {"snippetSupport": True}},
@@ -363,6 +369,50 @@ class _LSPClient:
                     future.cancel()
             self._pending.clear()
 
+    async def _abort_start(
+        self,
+        process: asyncio.subprocess.Process | None,
+        reader: asyncio.Task[None] | None,
+        stderr: asyncio.Task[None] | None,
+    ) -> None:
+        """Release a cancelled startup without waiting for inherited pipes."""
+        tasks = {task for task in (*self._notifications, reader, stderr) if task is not None}
+        try:
+            if process is not None:
+                if process.returncode is None:
+                    try:
+                        process.kill()
+                    except ProcessLookupError:
+                        pass
+                if process.stdin is not None:
+                    transport = process.stdin.transport
+                    # close() drains buffered writes; an inheriting child may
+                    # never read them. abort() also handles a pending close.
+                    if not transport.is_closing() or transport.get_write_buffer_size():
+                        transport.abort()
+                # Process.wait() can wait for descendants to close inherited
+                # pipes. asyncio has no public API to close all owned pipes.
+                process._transport.close()
+            for task in tasks:
+                task.cancel()
+            async with asyncio.timeout(0.25):
+                if process is None:
+                    await asyncio.gather(*tasks, return_exceptions=True)
+                else:
+                    await asyncio.gather(*tasks, process.wait(), return_exceptions=True)
+        except TimeoutError:
+            logger.warning("LSP %s: cancelled startup cleanup timed out", self.language_id)
+        finally:
+            self._process = None
+            self._reader_task = self._stderr_task = None
+            self._initialized = self._is_stopping = False
+            self._documents.clear()
+            self._notifications.clear()
+            for future in self._pending.values():
+                if not future.done():
+                    future.cancel()
+            self._pending.clear()
+
     async def get_definition(
         self, uri: str, line: int, character: int
     ) -> LSPLocation | None:
@@ -461,8 +511,13 @@ class _LSPClient:
         line: int,
         character: int,
         include_declaration: bool = True,
-    ) -> list[LSPLocation]:
-        """Get all references to a symbol."""
+    ) -> list[LSPLocation] | None:
+        """Get all references to a symbol.
+
+        Returns None when the server replied null. A server that is not ready
+        (rust-analyzer while its VFS loads) does this; an answer with no
+        references is an empty list.
+        """
         if not self._initialized:
             return []
 
@@ -471,7 +526,9 @@ class _LSPClient:
             "position": {"line": line, "character": character},
             "context": {"includeDeclaration": include_declaration},
         })
-        if not result or not isinstance(result, list):
+        if result is None:
+            return None
+        if not isinstance(result, list):
             return []
 
         return [
@@ -806,9 +863,24 @@ class _LSPClient:
         elif "method" in message:
             self._handle_notification(message["method"], message.get("params"))
 
+    async def wait_ready(self, timeout: float) -> bool:
+        """Wait up to ``timeout`` seconds until the server reports it is ready."""
+        if self._ready.is_set():
+            return True
+        try:
+            await asyncio.wait_for(self._ready.wait(), max(timeout, 0))
+        except TimeoutError:
+            return False
+        return True
+
     def _handle_notification(self, method: str, params: Any) -> None:
         """Handle server notification."""
-        if method == "textDocument/publishDiagnostics" and self._on_diagnostics:
+        if method == "experimental/serverStatus" and isinstance(params, dict):
+            if params.get("quiescent"):
+                self._ready.set()
+            else:
+                self._ready.clear()
+        elif method == "textDocument/publishDiagnostics" and self._on_diagnostics:
             uri = params.get("uri", "")
             raw_diags = params.get("diagnostics", [])
             severity_map = {1: "error", 2: "warning", 3: "information", 4: "hint"}
@@ -905,9 +977,9 @@ class LSPManager:
         return started
 
     async def start_server(
-        self, language_id: str, root_uri: str | None = None
+        self, language_id: str, root_uri: str | None = None, *, timeout: float | None = None
     ) -> None:
-        """Start a specific language server."""
+        """Start a server, optionally overriding this client's timeout only."""
         if language_id in self._clients:
             return
 
@@ -929,7 +1001,7 @@ class LSPManager:
         client = _LSPClient(
             server_config,
             root_uri or self._root_uri,
-            self._timeout,
+            self._timeout if timeout is None else timeout,
             on_diags,
         )
 
@@ -940,8 +1012,15 @@ class LSPManager:
 
         try:
             await client.start()
-        except BaseException:
-            await client.stop()
+        except BaseException as exc:
+            process, reader, stderr = client._process, client._reader_task, client._stderr_task
+            try:
+                if isinstance(exc, asyncio.CancelledError):
+                    raise
+                await client.stop()
+            except asyncio.CancelledError:
+                await client._abort_start(process, reader, stderr)
+                raise
             raise
         self._clients[language_id] = client
         self._emit("lsp.started", {
@@ -1002,8 +1081,8 @@ class LSPManager:
     async def get_references(
         self, file: str, line: int, col: int,
         include_declaration: bool = True,
-    ) -> list[LSPLocation]:
-        """Get all references to a symbol."""
+    ) -> list[LSPLocation] | None:
+        """Get all references to a symbol. None: the server replied null."""
         client = self._get_client_for_file(file)
         if not client:
             return []
@@ -1103,6 +1182,11 @@ class LSPManager:
             return file
         return f"file://{os.path.abspath(file)}"
 
+    async def wait_ready(self, file: str, timeout: float) -> bool:
+        """Wait until the server for ``file`` reports it is ready."""
+        client = self._get_client_for_file(file)
+        return True if client is None else await client.wait_ready(timeout)
+
     def _get_client_for_file(self, file: str) -> _LSPClient | None:
         """Find the appropriate client for a file extension."""
         ext = Path(file).suffix.lower()

{attocode_code_intel-0.1.24 → attocode_code_intel-0.1.26}/src/attocode_intel/api/routes/embeddings.py

@@ -146,7 +146,7 @@ async def get_embedding_status(
             response.provider_available = False
             response.provider_hint = (
                 "No embedding provider detected. "
-                "Install sentence-transformers (`pip install attocode[semantic]`) or set OPENAI_API_KEY."
+                "Install sentence-transformers (`pip install attocode[semantic]`) or set ATTOCODE_EMBEDDING_MODEL=openai with OPENAI_API_KEY."
             )
     except (ImportError, RuntimeError) as exc:
         response.provider_available = False
@@ -297,7 +297,7 @@ async def trigger_generate_embeddings(
     if provider.name == "none":
         raise HTTPException(
             status_code=400,
-            detail="No embedding provider available. Install sentence-transformers or set OPENAI_API_KEY.",
+            detail="No embedding provider available. Install sentence-transformers or set ATTOCODE_EMBEDDING_MODEL=openai with OPENAI_API_KEY.",
         )
 
     # Enqueue the ARQ job

{attocode_code_intel-0.1.24 → attocode_code_intel-0.1.26}/src/attocode_intel/precision.py

@@ -50,7 +50,8 @@ class PrecisionSession:
             self.retry_after.pop(key)
         from ._internal.integrations.lsp.client import BUILTIN_SERVERS
         outcomes = []
-        deadline = asyncio.get_running_loop().time() + 2.0
+        timeout = 5.0 if detect_language(definitions[0].file_path) == "rust" else 2.0
+        deadline = asyncio.get_running_loop().time() + timeout
         for definition in definitions[:8]:
             language = detect_language(definition.file_path)
             server_id = "typescript" if language == "javascript" else language
@@ -68,8 +69,8 @@ class PrecisionSession:
             try:
                 async with asyncio.timeout_at(deadline):
                     if server_id not in manager.get_active_servers():
-                        manager._timeout = 2
-                        await manager.start_server(server_id, Path(self.service.project_dir).as_uri())
+                        await manager.start_server(server_id, Path(self.service.project_dir).as_uri(),
+                                                   timeout=timeout)
                     # Send edits/deletions for all previously opened documents.
                     for rel in list(self.pending):
                         path = str(Path(self.service.project_dir) / rel)
@@ -100,6 +101,7 @@ class PrecisionSession:
                         candidates = ast.get_callers(definition.qualified_name)
                         resolved, references = None, []
                         for attempt in range(4):
+                            answered = False
                             try:
                                 resolved = await manager.get_definition(path, *position)
                                 # Some servers (including rust-analyzer) return no
@@ -134,29 +136,42 @@ class PrecisionSession:
                                 if str(exc).lower() != "content modified" or attempt == 3:
                                     raise
                             else:
+                                answered = resolved is not None and references is not None
                                 # No syntax callers does not establish server
                                 # readiness: both native lookups may be transiently
                                 # unresolved. A resolved unused declaration can
-                                # still take the fast path.
-                                if references or (resolved is not None and not candidates):
+                                # still take the fast path, but only on an answer:
+                                # null references (None) mean "not ready".
+                                if references or (resolved is not None and references is not None
+                                                  and not candidates):
                                     break
                             # A server can briefly return null after a successful
                             # warmup or edit. Yield before retrying, never extend
-                            # the enclosing two-second deadline or loop forever.
+                            # the enclosing language deadline or loop forever.
                             if attempt < 3:
                                 await asyncio.sleep(.05 * 2 ** attempt)
+                                # After a null or failed reply, a server that reports
+                                # its status (rust-analyzer) can stay not ready for
+                                # longer than this backoff. Wait for it, but leave half
+                                # the deadline for the remaining lookups. Do not wait
+                                # after an answer: rust-analyzer also answers while
+                                # its status is not ready. Other servers return at once.
+                                if not answered:
+                                    await manager.wait_ready(path, (deadline - asyncio.get_running_loop().time()) / 2)
                         if resolved is None and not references:
                             outcomes.append({"language": language, "status": "not_resolved"})
                             continue
                     finally:
                         manager.on_result_callback = callback
-                    ast.ingest_lsp_results("references", path, references,
+                    ast.ingest_lsp_results("references", path, references or [],
                                            {"line": position[0], "col": position[1],
                                             "symbol_name": definition.qualified_name,
                                             "definition_key": json.dumps([definition.file_path, definition.start_line, definition.qualified_name])})
                     self.verified_languages.add(language)
-                    outcomes.append({"language": language, "status": "verified" if references or not candidates else "no_references",
-                                     "symbol": definition.qualified_name, "references": len(references)})
+                    answered = references is not None
+                    outcomes.append({"language": language,
+                                     "status": "verified" if references or (answered and not candidates) else "no_references",
+                                     "symbol": definition.qualified_name, "references": len(references or [])})
             except Exception as exc:
                 status = "timeout" if isinstance(exc, TimeoutError) or isinstance(exc.__cause__, TimeoutError) else "failed"
                 self.failures[server_id] = (status, _now() + _RETRY_SECONDS)
@@ -166,7 +181,7 @@ class PrecisionSession:
                   "definitions_truncated": len(definitions) > 8}
         self.completed[key] = result
         # A server can become ready without a source edit. Retry only on a later
-        # explicit request after a short cooldown, keeping the same 2s deadline.
+        # explicit request after a short cooldown, keeping the same language budget.
         if any(o["status"] in _TRANSIENT for o in outcomes):
             self.retry_after[key] = _now() + _RETRY_SECONDS
         return result

{attocode_code_intel-0.1.24 → attocode_code_intel-0.1.26}/src/attocode_intel/service.py

@@ -123,6 +123,7 @@ class CodeIntelService:
             try:
                 from attocode_intel._internal.integrations.context.systemone_ranker import (
                     SystemOneChoiceReranker,
+                    workspace_consent,
                 )
 
                 environment = os.environ if config is None else {}
@@ -141,8 +142,7 @@ class CodeIntelService:
                     or preset.get("model", ""),
                     auth_env=self._config.ranking_auth_env or environment.get("ATTOCODE_INTEL_RANKING_AUTH_ENV", "")
                     or preset.get("auth_env", ""),
-                    allow_remote=(remote_opt_in and os.path.isabs(remote_workspace) and
-                                  os.path.realpath(remote_workspace) == self._project_dir),
+                    allow_remote=workspace_consent(remote_opt_in, remote_workspace, self._project_dir),
                     service_mode=self._config.is_service_mode,
                     timeout_seconds=None if timeout_ms == 0 else timeout_ms / 1000,
                     max_candidates=(self._config.ranking_max_candidates if config is not None else
@@ -1816,7 +1816,7 @@ class CodeIntelService:
         except Exception as e:
             return {"locations": [], "total": 0, "error": f"LSP error: {e}"}
         locations = []
-        for loc in locs:
+        for loc in locs or []:
             uri = loc.uri
             if uri.startswith("file://"):
                 uri = uri[7:]

{attocode_code_intel-0.1.24 → attocode_code_intel-0.1.26}/src/attocode_intel/workers/jobs.py

@@ -292,7 +292,7 @@ async def generate_embeddings(ctx: dict, repo_id: str, branch_name: str = "main"
             except (ImportError, RuntimeError) as exc:
                 return {"error": str(exc)}
             if provider.name == "none":
-                return {"error": "No embedding provider available", "hint": "Install sentence-transformers or set OPENAI_API_KEY"}
+                return {"error": "No embedding provider available", "hint": "Install sentence-transformers or set ATTOCODE_EMBEDDING_MODEL=openai with OPENAI_API_KEY"}
 
             dim = provider.dimension()