attocode-code-intel 0.1.25__tar.gz → 0.1.27__tar.gz

{attocode_code_intel-0.1.25 → attocode_code_intel-0.1.27}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: attocode-code-intel
-Version: 0.1.25
+Version: 0.1.27
 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.27 fixes a dictionary-size error during symbol inspection when AST hydration changes the cache concurrently. Namespace resolution snapshots cached file membership; later changes appear in the next build. See the [release notes](https://github.com/eren23/attocode/blob/main/docs/intelligence-0.1.27.md).
+
+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.

{attocode_code_intel-0.1.25 → attocode_code_intel-0.1.27}/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.27 fixes a dictionary-size error during symbol inspection when AST hydration changes the cache concurrently. Namespace resolution snapshots cached file membership; later changes appear in the next build. See the [release notes](https://github.com/eren23/attocode/blob/main/docs/intelligence-0.1.27.md).
+
+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.

{attocode_code_intel-0.1.25 → attocode_code_intel-0.1.27}/pyproject.toml

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

{attocode_code_intel-0.1.25 → attocode_code_intel-0.1.27}/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.25"
+__version__ = "0.1.27"

{attocode_code_intel-0.1.25 → attocode_code_intel-0.1.27}/src/attocode_intel/_internal/integrations/context/module_resolution.py

@@ -165,7 +165,8 @@ class FileIndex(dict):
 
     def configure_namespaces(self, asts):
         self.namespace_files = defaultdict(lambda: defaultdict(dict))
-        for path, ast in asts.items():
+        # Hydration can change cache membership while namespace members are read.
+        for path, ast in asts.copy().items():
             names = {c.name for c in ast.classes} | {f.name for f in ast.functions}
             for namespace in ast.namespaces + ([c.name for c in ast.classes] if ast.language == "elixir" else []):
                 self.namespace_files[ast.language][namespace.replace('\\', '.')][path] = names

{attocode_code_intel-0.1.25 → attocode_code_intel-0.1.27}/src/attocode_intel/_internal/integrations/lsp/client.py

@@ -369,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:
@@ -933,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
 
@@ -957,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,
         )
 
@@ -968,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", {

{attocode_code_intel-0.1.25 → attocode_code_intel-0.1.27}/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)
@@ -146,7 +147,7 @@ class PrecisionSession:
                                     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
@@ -180,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.27/tests/test_namespace_snapshot.py

@@ -0,0 +1,60 @@
+"""Namespace reads keep stable membership while AST hydration publishes files."""
+from concurrent.futures import ThreadPoolExecutor
+from threading import Event
+from types import SimpleNamespace
+
+import pytest
+from attocode_intel._internal.integrations.context.module_resolution import FileIndex
+
+
+@pytest.mark.parametrize('mutation', ['grow', 'shrink'])
+def test_namespace_lookup_snapshots_cache_during_hydration(mutation):
+    reading, changed = Event(), Event()
+
+    def ast(name):
+        return SimpleNamespace(language='php', namespaces=[r'Acme\Core'],
+                               classes=[SimpleNamespace(name=name)],
+                               functions=[SimpleNamespace(name=name.lower())])
+
+    class FirstAST:
+        language = 'php'
+        namespaces = [r'Acme\Core']
+        functions = [SimpleNamespace(name='first')]
+
+        @property
+        def classes(self):
+            if not reading.is_set():
+                reading.set()
+                assert changed.wait(5), 'hydration did not publish its cache update'
+            return [SimpleNamespace(name='First')]
+
+    cache = {'first.php': FirstAST(), 'second.php': ast('Second')}
+    index = FileIndex({name: name for name in ('first.php', 'second.php', 'late.php')})
+
+    def hydrate():
+        try:
+            assert reading.wait(5), 'namespace traversal did not start'
+            if mutation == 'grow':
+                cache['late.php'] = ast('Late')
+            else:
+                del cache['second.php']
+        finally:
+            changed.set()
+
+    with ThreadPoolExecutor(max_workers=1) as pool:
+        publication = pool.submit(hydrate)
+        try:
+            index.configure_namespaces(cache)
+        finally:
+            reading.set()
+            publication.result(timeout=5)
+
+    assert index.namespace_candidates('php', r'Acme\Core\First') == ['first.php']
+    assert index.namespace_candidates('php', r'Acme\Core\first') == ['first.php']
+    assert index.namespace_candidates('php', r'Acme\Core\Second') == ['second.php']
+    assert index.namespace_candidates('php', r'Acme\Core\Late') == []
+
+    # The next build sees the new membership; the snapshot is local to one read.
+    index.configure_namespaces(cache)
+    assert index.namespace_candidates('php', r'Acme\Core\Late') == (['late.php'] if mutation == 'grow' else [])
+    assert index.namespace_candidates('php', r'Acme\Core\Second') == (['second.php'] if mutation == 'grow' else [])

attocode_code_intel-0.1.27/tests/test_precision_budget.py

@@ -0,0 +1,264 @@
+"""Rust reloads get more time without extending other languages or retry deadlines."""
+import sys
+import time
+
+import pytest
+from attocode_intel._internal.integrations.lsp.client import (
+    BUILTIN_SERVERS,
+    LSPConfig,
+    LSPManager,
+    LanguageServerConfig,
+)
+from attocode_intel.gateway import OperationGateway
+from test_precision_protocol import SERVER
+from test_precision_recovery import _status_server
+
+
+def _gateway(tmp_path, monkeypatch, source, language='rust'):
+    extension = '.rs' if language == 'rust' else '.py'
+    if language == 'rust':
+        source = (source.replace("'helper.py'", "'helper.rs'")
+                  .replace("'caller.py'", "'caller.rs'")
+                  .replace("'character': 4", "'character': 7"))
+    script = tmp_path / 'server.py'
+    script.write_text(source)
+    monkeypatch.setitem(BUILTIN_SERVERS, language, LanguageServerConfig(
+        command=sys.executable, args=[str(script)], extensions=[extension], language_id=language))
+    monkeypatch.setenv('ATTOCODE_INTEL_PRECISION', 'auto')
+    root = tmp_path / 'project'
+    root.mkdir()
+    if language == 'rust':
+        (root / 'helper.rs').write_text('pub fn helper() -> i32 { 1 }\npub fn local() -> i32 { helper() }\n')
+        (root / 'caller.rs').write_text('use crate::helper::helper;\npub fn caller() -> i32 { helper() }\n')
+    else:
+        (root / 'helper.py').write_text('def helper(): return 1\nhelper()\n')
+        (root / 'caller.py').write_text('from helper import helper\nhelper()\n')
+    return OperationGateway(str(root), 'daily', watch=False), root, extension
+
+
+async def _inspect(gateway, extension='.rs'):
+    response = await gateway.execute('inspect_symbol', {
+        'symbol_name': 'helper', 'file_path': 'helper' + extension, 'line': 1})
+    assert not response.isError
+    return response.structuredContent
+
+
+@pytest.mark.parametrize('delay', ['initialize', 'definition', 'readiness'])
+async def test_rust_recovers_from_a_two_and_a_half_second_delay(tmp_path, monkeypatch, delay):
+    if delay == 'readiness':
+        source = _status_server(2.5)
+    elif delay == 'initialize':
+        source = SERVER.replace("        send({'jsonrpc':'2.0','id':pending_init,",
+                                "        __import__('time').sleep(2.5)\n        send({'jsonrpc':'2.0','id':pending_init,")
+    else:
+        source = SERVER.replace('    result = None',
+                                "    if method == 'textDocument/definition': __import__('time').sleep(2.5)\n    result = None")
+    gateway, _root, _extension = _gateway(tmp_path, monkeypatch, source)
+    try:
+        result = await _inspect(gateway)
+        assert result['metadata']['analysis']['precision']['status'] == 'verified', result
+        assert any(r['file_path'] == 'caller.rs' and r['line'] == 2 and r['source'] == 'lsp'
+                   for r in result['data']['references'])
+    finally:
+        await gateway.close()
+
+
+async def test_running_rust_server_can_reload_after_an_edit(tmp_path, monkeypatch):
+    source = (_status_server(2.5)
+              .replace('ready = status = False', 'ready = status = reloading = False')
+              .replace('threading.Timer(2.5, become_ready)', 'threading.Timer(2.5 if reloading else 0, become_ready)')
+              .replace("    if 'id' not in msg:", """
+    if method == 'textDocument/didChange':
+        ready = False
+        timer = None
+        reloading = True
+        if status:
+            send({'jsonrpc':'2.0','method':'experimental/serverStatus','params':{'health':'ok','quiescent':False}})
+    if 'id' not in msg:"""))
+    gateway, root, _extension = _gateway(tmp_path, monkeypatch, source)
+    try:
+        first = await _inspect(gateway)
+        assert first['metadata']['analysis']['precision']['status'] == 'verified'
+        process = next(iter(gateway._stores.values()))['service']._lsp_manager._clients['rust']._process
+        # The selected document is already open. Editing it guarantees didChange
+        # and a reload even if the server answered before caller priming was needed.
+        helper = root / 'helper.rs'
+        helper.write_text(helper.read_text() + '\n')
+        (root / 'caller.rs').write_text('use crate::helper::helper;\n\npub fn caller() -> i32 { helper() }\n')
+        started = time.monotonic()
+        changed = await _inspect(gateway)
+        assert 2.0 <= time.monotonic() - started < 5.8  # The reload really happened.
+        assert changed['metadata']['analysis']['precision']['status'] == 'verified', changed
+        assert any(r['file_path'] == 'caller.rs' and r['line'] == 3 and r['source'] == 'lsp'
+                   for r in changed['data']['references'])
+        assert not any(r['file_path'] == 'caller.rs' and r['line'] == 2
+                       for r in changed['data']['references'])
+        assert next(iter(gateway._stores.values()))['service']._lsp_manager._clients['rust']._process is process
+    finally:
+        await gateway.close()
+    assert process.returncode == 0
+
+
+@pytest.mark.parametrize('language, upper', [('rust', 5.8), ('python', 2.8)])
+async def test_hung_initialization_is_reaped_within_the_precision_budget(tmp_path, monkeypatch, language, upper):
+    import asyncio
+
+    processes = []
+    spawn = asyncio.create_subprocess_exec
+
+    async def record_process(*args, **kwargs):
+        process = await spawn(*args, **kwargs)
+        processes.append(process)
+        return process
+
+    monkeypatch.setattr(asyncio, 'create_subprocess_exec', record_process)
+    source = SERVER.replace("    if method == 'initialize':",
+                            "    if method == 'initialize':\n        __import__('time').sleep(60)")
+    gateway, _root, extension = _gateway(tmp_path, monkeypatch, source, language)
+    try:
+        await gateway.execute('symbols', {'path': 'helper' + extension})
+        started = time.monotonic()
+        result = await _inspect(gateway, extension)
+        assert time.monotonic() - started < upper
+        assert result['metadata']['analysis']['precision']['queries'][0]['status'] == 'timeout'
+        assert result['data']['references']
+        assert len(processes) == 1 and processes[0].returncode is not None
+    finally:
+        await gateway.close()
+
+
+@pytest.mark.parametrize('language, lower, upper', [('rust', 4.5, 5.8), ('python', 1.5, 2.8)])
+async def test_unresponsive_server_is_bounded_and_preserves_syntax(tmp_path, monkeypatch, language, lower, upper):
+    source = SERVER.replace('    result = None',
+                            "    if method == 'textDocument/definition': continue\n    result = None")
+    gateway, _root, extension = _gateway(tmp_path, monkeypatch, source, language)
+    try:
+        # Index before timing the enrichment rather than timing native parser startup.
+        await gateway.execute('symbols', {'path': 'helper' + extension})
+        started = time.monotonic()
+        result = await _inspect(gateway, extension)
+        assert lower <= time.monotonic() - started < upper
+        precision = result['metadata']['analysis']['precision']
+        assert precision['status'] == 'partial'
+        assert precision['queries'][0]['status'] == 'timeout'
+        assert any(r['file_path'] == 'helper' + extension for r in result['data']['references'])
+    finally:
+        await gateway.close()
+
+
+@pytest.mark.parametrize('mode', ['inherited_output', 'startup_error', 'buffered_stdin'])
+async def test_cancelled_startup_releases_pipes_held_by_a_child(tmp_path, monkeypatch, mode):
+    import asyncio
+
+    release = tmp_path / 'release-child'
+    exited = tmp_path / 'child-exited'
+    child_pid = tmp_path / 'child-pid'
+    child_source = f'''
+import os, time
+from pathlib import Path
+Path({str(child_pid)!r}).write_text(str(os.getpid()))
+deadline = time.monotonic() + 12
+while time.monotonic() < deadline and not Path({str(release)!r}).exists():
+    time.sleep(.02)
+Path({str(exited)!r}).touch()
+'''
+    initialize = f'''
+    if method == 'initialize':
+        import subprocess
+        subprocess.Popen([sys.executable, '-c', {child_source!r}])
+        if {mode!r} == 'buffered_stdin':
+            send({{'jsonrpc':'2.0','id':'large-config','method':'workspace/configuration',
+                  'params':{{'items':[{{}}] * 32768}}}})
+        if {mode!r} == 'startup_error':
+            send({{'jsonrpc':'2.0','id':msg['id'],'error':{{'code':-32603,'message':'initialization failed'}}}})
+        __import__('time').sleep(60)
+'''
+    source = SERVER.replace("    if method == 'initialize':", initialize)
+    processes = []
+    spawn = asyncio.create_subprocess_exec
+
+    async def record_process(*args, **kwargs):
+        process = await spawn(*args, **kwargs)
+        processes.append(process)
+        return process
+
+    monkeypatch.setattr(asyncio, 'create_subprocess_exec', record_process)
+    gateway, _root, _extension = _gateway(tmp_path, monkeypatch, source)
+    inspection = None
+    try:
+        await gateway.execute('symbols', {'path': 'helper.rs'})
+        started = time.monotonic()
+        inspection = asyncio.create_task(_inspect(gateway))
+        if mode == 'buffered_stdin':
+            # A real workspace/configuration response fills the inherited stdin.
+            # Ordinary StreamWriter.close() would try to drain it indefinitely.
+            async with asyncio.timeout(3):
+                while not processes or not processes[0].stdin.transport.get_write_buffer_size():
+                    await asyncio.sleep(.02)
+        result = await inspection
+        assert time.monotonic() - started < 5.8
+        assert child_pid.exists() and not exited.exists(), 'Child must still hold the inherited pipes'
+        assert processes[0].returncode is not None
+        assert result['metadata']['analysis']['precision']['queries'][0]['status'] == 'timeout'
+        assert result['data']['references']
+        async with asyncio.timeout(1):
+            response = await gateway.execute('search_symbols', {'name': 'helper'})
+        assert not response.isError  # The workspace worker remains usable.
+    finally:
+        # The fixture, rather than production code, owns the surviving grandchild.
+        release.touch()
+        if inspection is not None and not inspection.done():
+            await asyncio.wait_for(inspection, 8)
+        for process in processes:
+            if process.returncode is None:
+                process.kill()
+            if process.stdin and not process.stdin.is_closing():
+                process.stdin.transport.abort()
+            process._transport.close()
+            await asyncio.wait_for(process.wait(), 1)
+        if child_pid.exists():
+            async with asyncio.timeout(2):
+                while not exited.exists():
+                    await asyncio.sleep(.02)
+        await gateway.close()
+
+
+async def test_rust_startup_and_lookup_share_one_five_second_deadline(tmp_path, monkeypatch):
+    source = (SERVER.replace("        send({'jsonrpc':'2.0','id':pending_init,",
+                             "        __import__('time').sleep(2.5)\n        send({'jsonrpc':'2.0','id':pending_init,")
+              .replace('    result = None',
+                       "    if method == 'textDocument/references': __import__('time').sleep(2.8)\n    result = None"))
+    gateway, _root, _extension = _gateway(tmp_path, monkeypatch, source)
+    try:
+        await gateway.execute('symbols', {'path': 'helper.rs'})
+        started = time.monotonic()
+        result = await _inspect(gateway)
+        assert 4.5 <= time.monotonic() - started < 5.8
+        assert result['metadata']['analysis']['precision']['queries'][0]['status'] == 'timeout'
+        assert result['data']['references']
+    finally:
+        await gateway.close()
+
+
+async def test_client_timeout_override_does_not_leak_to_other_servers(tmp_path, monkeypatch):
+    # Both peers use the same framed protocol; only their timeout policies differ.
+    script = tmp_path / 'server.py'
+    script.write_text(SERVER.replace('    result = None',
+                                   "    if method == 'test/delayed': __import__('time').sleep(0.4)\n    result = None"))
+    for language in ('rust', 'python'):
+        monkeypatch.setitem(BUILTIN_SERVERS, language, LanguageServerConfig(
+            command=sys.executable, args=[str(script)], language_id=language))
+    manager = LSPManager(LSPConfig(timeout=0.25))
+    try:
+        await manager.start_server('rust', tmp_path.as_uri(), timeout=5.0)
+        await manager.start_server('python', tmp_path.as_uri())
+        for language, succeeds in [('rust', True), ('python', False)]:
+            client = manager._clients[language]
+            if succeeds:
+                assert await client._request('test/delayed', {}) is None
+            else:
+                from attocode_intel._internal.errors import ToolError
+                with pytest.raises(ToolError, match='timed out'):
+                    await client._request('test/delayed', {})
+    finally:
+        await manager.stop_all()

{attocode_code_intel-0.1.25 → attocode_code_intel-0.1.27}/tests/test_quality_evidence.py

@@ -208,6 +208,59 @@ def test_interrupted_pack_preserves_completed_checks_and_stops_its_worker(tmp_pa
     assert result['status'] == 'incomplete'
     assert result['checks'][0]['name'] == 'source'
     assert child.poll() is not None
+    assert result['worker_limit_seconds'] == .5
+    assert result['worker_seconds'] >= result['worker_wait_seconds'] >= .5
+
+
+@pytest.mark.parametrize('exit_code,checkpointed', [(0, True), (7, True), (0, False)])
+def test_pack_reports_parent_worker_lifetime_and_separate_wait_budget(tmp_path, monkeypatch, exit_code, checkpointed):
+    import subprocess
+    import time
+
+    from eval.quality import corpus
+
+    original_launch, original_stop = subprocess.Popen, corpus.stop_group
+    boundaries = {}
+    children = []
+    checkpoint = {'checks': [{'name': 'source', 'outcome': 'passed'}], 'retrieval': [],
+                  'worker_seconds': 999, 'worker_wait_seconds': 999, 'worker_limit_seconds': 999}
+
+    def launch(command, **kwargs):
+        boundaries['launch'] = time.monotonic()
+        time.sleep(.05)
+        program = (
+            'import json,pathlib,sys,time; '
+            'pathlib.Path(sys.argv[1]).write_text(sys.argv[2]) if sys.argv[3] == "yes" else None; '
+            'time.sleep(.05); sys.exit(int(sys.argv[4]))'
+        )
+        child = original_launch([sys.executable, '-c', program, str(tmp_path / 'worker.json'),
+                                 json.dumps(checkpoint), 'yes' if checkpointed else 'no', str(exit_code)], **kwargs)
+        children.append(child)
+        return child
+
+    def stop(child):
+        original_stop(child)
+        time.sleep(.05)
+        boundaries['cleanup'] = time.monotonic()
+
+    monkeypatch.setattr(corpus.subprocess, 'Popen', launch)
+    monkeypatch.setattr(corpus, 'stop_group', stop)
+    monkeypatch.setattr(corpus, 'PACK_SECONDS', 10)
+    started = time.monotonic()
+    result = corpus.evaluate_isolated(tmp_path, {'id': 'fixture'}, tmp_path)
+    elapsed = time.monotonic() - started
+
+    assert boundaries['cleanup'] - boundaries['launch'] <= result['worker_seconds'] <= elapsed
+    assert 0 < result['worker_wait_seconds'] <= result['worker_seconds'] - .1
+    assert result['worker_limit_seconds'] == 10
+    assert children[0].poll() is not None
+    assert result['checks'] == (checkpoint['checks'] if checkpointed else [])
+    assert result['retrieval'] == []
+    if exit_code or not checkpointed:
+        assert result['status'] == 'incomplete'
+        assert 'Workflow worker failed' in result['error']
+    else:
+        assert 'error' not in result and result.get('status') != 'incomplete'
 
 
 def test_resume_refuses_changed_inputs_and_missing_question_observations():