attocode-code-intel 0.1.16__tar.gz → 0.1.18__tar.gz

{attocode_code_intel-0.1.16 → attocode_code_intel-0.1.18}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: attocode-code-intel
-Version: 0.1.16
+Version: 0.1.18
 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
@@ -151,7 +151,11 @@ tests, such as `_test.dart` and Perl `.t` scripts and `t/` modules. Version
 0.1.12 makes `doctor --client claude` read the local-scope entry that
 `claude mcp add` writes to `~/.claude.json`. Version 0.1.13 fills compact search
 pages within their budget, offers bounded deeper searches, and repairs stale
-navigation indexes after successful restart parsing. Version 0.1.16 stabilizes tied symbol pages and reduces the Docker image while
+navigation indexes after successful restart parsing. Version 0.1.18 restores the ready phase after a failed snapshot load is followed by a complete fallback rebuild. Incomplete recovery stays guarded.
+
+Version 0.1.17 lets a later explicit inspection retry a failed selected-file parse
+after a one-second cooldown, preserving immediate-repeat and source guards.
+Version 0.1.16 stabilizes tied symbol pages and reduces the Docker image while
 preserving runtime contracts. It adds bounded online maintenance evidence; the
 preview and restart experiments did not justify product changes.
 Version 0.1.15 adds parser ownership by thread, one language-server stderr

{attocode_code_intel-0.1.16 → attocode_code_intel-0.1.18}/README.md

@@ -38,7 +38,11 @@ tests, such as `_test.dart` and Perl `.t` scripts and `t/` modules. Version
 0.1.12 makes `doctor --client claude` read the local-scope entry that
 `claude mcp add` writes to `~/.claude.json`. Version 0.1.13 fills compact search
 pages within their budget, offers bounded deeper searches, and repairs stale
-navigation indexes after successful restart parsing. Version 0.1.16 stabilizes tied symbol pages and reduces the Docker image while
+navigation indexes after successful restart parsing. Version 0.1.18 restores the ready phase after a failed snapshot load is followed by a complete fallback rebuild. Incomplete recovery stays guarded.
+
+Version 0.1.17 lets a later explicit inspection retry a failed selected-file parse
+after a one-second cooldown, preserving immediate-repeat and source guards.
+Version 0.1.16 stabilizes tied symbol pages and reduces the Docker image while
 preserving runtime contracts. It adds bounded online maintenance evidence; the
 preview and restart experiments did not justify product changes.
 Version 0.1.15 adds parser ownership by thread, one language-server stderr

{attocode_code_intel-0.1.16 → attocode_code_intel-0.1.18}/pyproject.toml

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

{attocode_code_intel-0.1.16 → attocode_code_intel-0.1.18}/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.16"
+__version__ = "0.1.18"

{attocode_code_intel-0.1.16 → attocode_code_intel-0.1.18}/src/attocode_intel/_internal/integrations/context/ast_service.py

@@ -21,6 +21,7 @@ import re
 import sqlite3
 import threading
 from pathlib import Path
+from time import monotonic as _parse_recovery_now
 from types import SimpleNamespace
 from typing import Any
 
@@ -59,6 +60,7 @@ _instances: dict[str, ASTService] = {}
 # Default location for the persistent index
 _INDEX_DIR = ".attocode/index"
 _INDEX_DB = "symbols.db"
+_PARSE_RECOVERY_COOLDOWN_SECONDS = 1.0
 
 
 class ASTService:
@@ -99,6 +101,7 @@ class ASTService:
         self._last_snapshot_repair = None
         self._parse_lock = threading.RLock()
         self._parse_recovery_attempts = {}
+        self._parse_recovery_retry_after = {}
 
     @classmethod
     def get_instance(cls, root_dir: str) -> ASTService:
@@ -468,6 +471,9 @@ class ASTService:
                 for target in targets:
                     self._index.add_file_dependency(src, target)
             state.dep_graph_files = len(dep_graph.forward)
+        if is_full_parse and state.parsed_files == state.reference_indexed_files == source_count:
+            # A failed restore can reset the phase before the full rebuild.
+            state.phase = "ready"
         self._initialized = True
         return state
 
@@ -657,11 +663,13 @@ class ASTService:
             return True
 
     def recover_failed_file(self, rel_path: str) -> bool:
-        """Retry one degraded selected file once for this source/parser identity.
+        """Retry a degraded selected file on a later explicit inspection.
 
         Reuse the completed-index repair path so callers and persisted navigation
         are reconciled before publishing the replacement AST. Partial hydration
         keeps its normal path; a later request may recover after it completes.
+        Repeated requests share a cooldown for the same source/parser identity;
+        a transient second parse failure must not prevent recovery indefinitely.
         """
         from .ast_snapshot import parser_identity
         from .index_repair import repair_index
@@ -684,20 +692,25 @@ class ASTService:
                 if digest != previous.content_sha256:
                     return False
                 key = (digest, parser_identity(previous.language))
-                if self._parse_recovery_attempts.get(rel_path) == key:
+                if (self._parse_recovery_attempts.get(rel_path) == key
+                        and _parse_recovery_now() < self._parse_recovery_retry_after.get(rel_path, 0)):
                     return False
                 self._parse_recovery_attempts[rel_path] = key
-                parsed = parse_file(str(path))
-                if parsed.parse_failures or parsed.parsing_tier == 'minimal':
-                    return False
-                if hashlib.sha256(path.read_text(encoding='utf-8', errors='replace').encode()).hexdigest() != digest:
-                    return False
-                if self._snapshot_identity() != identity:
-                    return False
-                asts = dict(self._ast_cache)
-                asts[rel_path] = parsed
-                self._last_snapshot_repair = repair_index(self, asts, identity, {rel_path})
-                return True
+                try:
+                    parsed = parse_file(str(path))
+                    if parsed.parse_failures or parsed.parsing_tier == 'minimal':
+                        return False
+                    if hashlib.sha256(path.read_text(encoding='utf-8', errors='replace').encode()).hexdigest() != digest:
+                        return False
+                    if self._snapshot_identity() != identity:
+                        return False
+                    asts = dict(self._ast_cache)
+                    asts[rel_path] = parsed
+                    self._last_snapshot_repair = repair_index(self, asts, identity, {rel_path})
+                    return True
+                finally:
+                    self._parse_recovery_retry_after[rel_path] = (
+                        _parse_recovery_now() + _PARSE_RECOVERY_COOLDOWN_SECONDS)
             except (OSError, ValueError, sqlite3.Error):
                 logger.debug('Cannot recover selected parse for %s', rel_path, exc_info=True)
                 return False
@@ -911,6 +924,7 @@ class ASTService:
         # Handle deletion
         if not Path(abs_path).exists():
             self._parse_recovery_attempts.pop(rel, None)
+            self._parse_recovery_retry_after.pop(rel, None)
             self._index.remove_file(rel)
             old_ast = self._ast_cache.pop(rel, None)
             if old_ast is None:

attocode_code_intel-0.1.18/tests/test_experiment_readiness.py

@@ -0,0 +1,128 @@
+"""Full navigation readiness is independent of body-index readiness."""
+import asyncio
+import json
+import threading
+from types import SimpleNamespace
+
+import pytest
+
+from eval.quality.experiment_evidence import Journal
+from eval.quality.readiness import coverage_ready, wait_ready
+
+
+@pytest.mark.parametrize(
+    "change", ["phase", "parsed", "references", "truncated", "rounded", "bool", "zero"]
+)
+def test_readiness_requires_exact_completed_counts(change):
+    c = {
+        "phase": "ready",
+        "total_files": 1001,
+        "parsed_files": 1001,
+        "reference_indexed_files": 1001,
+        "discovery_truncated": False,
+    }
+    assert coverage_ready(c)
+    if change == "phase":
+        c["phase"] = "hydrating"
+    if change == "parsed":
+        c["parsed_files"] = 1000
+    if change == "references":
+        c["reference_indexed_files"] = 1000
+    if change == "truncated":
+        c["discovery_truncated"] = True
+    if change == "rounded":
+        c.update(parsed_files=1000, parse_coverage=1.0)
+    if change == "bool":
+        c["reference_indexed_files"] = True
+    if change == "zero":
+        c["total_files"] = 0
+    assert not coverage_ready(c)
+
+
+@pytest.mark.asyncio
+async def test_initialization_and_every_readiness_response_are_retained_before_inspection(tmp_path):
+    journal = Journal(tmp_path / "journal", 8192)
+    calls = []
+
+    class Gateway:
+        async def execute(self, name, args):
+            calls.append(name)
+            data = {
+                "capabilities": {
+                    "coverage": {
+                        "phase": "ready",
+                        "total_files": 1,
+                        "parsed_files": 1,
+                        "reference_indexed_files": 1,
+                        "discovery_truncated": False,
+                    }
+                }
+            }
+            return SimpleNamespace(
+                isError=False,
+                structuredContent=data,
+                model_dump=lambda **kw: {"content": [], "structuredContent": data},
+            )
+
+    result = await wait_ready(Gateway(), journal)
+    assert calls == ["search_symbols", "capabilities"] and result["polls"] == 1
+    events = [json.loads(line) for line in (journal.root / "events.jsonl").read_text().splitlines()]
+    assert [e["request"]["event"] for e in events] == ["readiness_initialize", "readiness_poll"]
+    assert all((journal.root / e["response"]["path"]).is_file() for e in events)
+
+
+@pytest.mark.asyncio
+async def test_navigation_barrier_waits_for_delayed_real_reference_hydration(tmp_path, monkeypatch):
+    from attocode_intel._internal.integrations.context import ast_service as module
+    from attocode_intel.gateway import OperationGateway
+
+    workspace = tmp_path / 'source'
+    workspace.mkdir()
+    for n in range(4):
+        (workspace / f'unit{n}.py').write_text(f'def unit{n}():\n    return {n}\n')
+    release = threading.Event()
+    entered = threading.Event()
+    original = module.ASTService._run_hydration
+
+    def delayed(service):
+        entered.set()
+        if not release.wait(timeout=5):
+            raise AssertionError('controlled hydration was never released')
+        return original(service)
+
+    monkeypatch.setattr(module, 'skeleton_budget', lambda tier, count: 1)
+    monkeypatch.setattr(module.ASTService, '_run_hydration', delayed)
+    gateway = OperationGateway(str(workspace), 'daily', watch=False)
+    try:
+        journal = Journal(tmp_path / 'capture', 1024 * 1024)
+        initialize = await gateway.execute('search_symbols', {'name': '__delayed_fixture_initialize__'})
+        journal.response({'event': 'control_initialize'}, initialize.model_dump(mode='json'))
+        assert not initialize.isError and entered.wait(timeout=1)
+        before = await gateway.execute('capabilities', {})
+        journal.response({'event': 'control_before'}, before.model_dump(mode='json'))
+        partial = before.structuredContent['capabilities']['coverage']
+        assert partial['phase'] == 'hydrating' and partial['total_files'] == 4
+        assert partial['reference_indexed_files'] < partial['total_files']
+        assert not coverage_ready(partial)
+        raw_response = journal.response
+        observed = []
+
+        def retain_then_release(request, value):
+            ref = raw_response(request, value)
+            if request['event'] == 'readiness_poll':
+                c = value['structuredContent']['capabilities']['coverage']
+                observed.append(c)
+                if len(observed) == 1:
+                    assert not coverage_ready(c)
+                    release.set()
+            return ref
+
+        monkeypatch.setattr(journal, 'response', retain_then_release)
+        admitted = await asyncio.wait_for(wait_ready(gateway, journal), timeout=5)
+        assert len(observed) >= 2 and admitted['polls'] == len(observed)
+        assert coverage_ready(observed[-1]) and observed[-1]['reference_indexed_files'] == 4
+        events = [json.loads(line) for line in (journal.root / 'events.jsonl').read_text().splitlines()]
+        assert all((journal.root / event['response']['path']).is_file() for event in events)
+    finally:
+        release.set()
+        await gateway.close()

attocode_code_intel-0.1.18/tests/test_fixture_source_alias.py

@@ -0,0 +1,46 @@
+"""Captured aliases must resolve to pinned content without touching the host."""
+import pytest
+
+from eval.quality.fixture_identity import source_entry
+
+
+def test_alias_and_nested_alias_resolve_to_the_original_content_entry():
+    body = {'kind': 'file', 'bytes': 5, 'sha256': 'a' * 64}
+    inventory = {'AGENTS.md': body, 'CLAUDE.md': {'kind': 'symlink', 'target': 'AGENTS.md'},
+                 'docs/link': {'kind': 'symlink', 'target': '../CLAUDE.md'},
+                 'source': {'kind': 'symlink', 'target': 'real'}, 'real/main.py': body}
+    assert source_entry(inventory, 'CLAUDE.md') is body
+    assert source_entry(inventory, 'docs/link') is body
+    assert source_entry(inventory, 'source/main.py') is body
+    assert source_entry(inventory, 'AGENTS.md') is body
+
+
+@pytest.mark.parametrize('target', ['/etc/passwd', '../../outside', 'missing', 'link'])
+def test_external_missing_and_cyclic_source_aliases_are_rejected(target):
+    with pytest.raises(ValueError):
+        source_entry({'link': {'kind': 'symlink', 'target': target}}, 'link')
+
+
+def test_alias_chain_and_path_growth_are_bounded():
+    inventory = {f'link{n}': {'kind': 'symlink', 'target': f'link{n + 1}'} for n in range(42)}
+    inventory['link42'] = {'kind': 'file', 'bytes': 0, 'sha256': 'a' * 64}
+    with pytest.raises(ValueError, match='forty'):
+        source_entry(inventory, 'link0')
+    with pytest.raises(ValueError, match='invalid|oversized'):
+        source_entry({'link': {'kind': 'symlink', 'target': 'long/' * 1000}}, 'link')
+
+
+def test_parent_components_are_interpreted_after_directory_alias_expansion():
+    wanted = {'kind': 'file', 'bytes': 1, 'sha256': 'a' * 64}
+    unrelated = {'kind': 'file', 'bytes': 1, 'sha256': 'b' * 64}
+    inventory = {'dir': {'kind': 'symlink', 'target': 'real/nested'},
+                 'link': {'kind': 'symlink', 'target': 'dir/../module.py'},
+                 'real/nested/marker': wanted, 'real/module.py': wanted, 'module.py': unrelated}
+    assert source_entry(inventory, 'link') is wanted
+
+
+@pytest.mark.parametrize('target', ['missing/../file', 'file/../file', 'file/.'])
+def test_alias_cannot_skip_missing_directories_or_walk_through_files(target):
+    with pytest.raises(ValueError):
+        source_entry({'link': {'kind': 'symlink', 'target': target},
+                      'file': {'kind': 'file', 'bytes': 1, 'sha256': 'a' * 64}}, 'link')

{attocode_code_intel-0.1.16 → attocode_code_intel-0.1.18}/tests/test_parse_recovery.py

@@ -89,6 +89,70 @@ def test_failed_selected_recovery_is_not_repeated_for_same_source(tmp_path):
         service._get_ast_service()._store.close()
 
 
+def test_failed_selected_recovery_retries_after_cooldown_without_edit(tmp_path, monkeypatch):
+    service, ast = degraded_service(tmp_path)
+    clock = [100.0]
+    monkeypatch.setattr(ast_service, '_parse_recovery_now', lambda: clock[0], raising=False)
+    original = ast_service.parse_file
+    try:
+        with patch.object(ast_service, 'parse_file', wraps=original) as parse:
+            with patch.object(ts_parser, 'PARSE_TIMEOUT_MICROS', 1):
+                assert inspect_symbol_data(service, 'target', 'sample.lua')['status'] == 'not_found'
+            assert inspect_symbol_data(service, 'target', 'sample.lua')['status'] == 'not_found'
+            clock[0] = 100.999
+            assert inspect_symbol_data(service, 'target', 'sample.lua')['status'] == 'not_found'
+            assert parse.call_count == 1
+            clock[0] = 101.0
+            recovered = inspect_symbol_data(service, 'target', 'sample.lua')
+            assert recovered['status'] == 'found'
+            assert any(row['line'] == 10002 for row in recovered['references'])
+            assert parse.call_count == 2
+            assert inspect_symbol_data(service, 'target', 'sample.lua')['status'] == 'found'
+            assert parse.call_count == 2
+    finally:
+        ast.stop_hydration()
+        ast._store.close()
+
+
+def test_persistent_selected_parse_failure_is_limited_to_one_attempt_per_cooldown(tmp_path, monkeypatch):
+    service, ast = degraded_service(tmp_path)
+    clock = [100.0]
+    monkeypatch.setattr(ast_service, '_parse_recovery_now', lambda: clock[0], raising=False)
+    try:
+        with patch.object(ast_service, 'parse_file', return_value=ast._ast_cache['sample.lua']) as parse:
+            for _ in range(3):
+                assert inspect_symbol_data(service, 'target', 'sample.lua')['status'] == 'not_found'
+            assert parse.call_count == 1
+            clock[0] = 101.0
+            assert inspect_symbol_data(service, 'target', 'sample.lua')['status'] == 'not_found'
+            assert parse.call_count == 2
+            for _ in range(3):
+                assert inspect_symbol_data(service, 'target', 'sample.lua')['status'] == 'not_found'
+            assert parse.call_count == 2
+    finally:
+        ast.stop_hydration()
+        ast._store.close()
+
+
+def test_expired_parse_recovery_cooldown_cannot_bless_an_unrelated_edit(tmp_path, monkeypatch):
+    other = tmp_path / 'other.py'
+    other.write_text('def before(): return 1\n')
+    service, ast = degraded_service(tmp_path)
+    clock = [100.0]
+    monkeypatch.setattr(ast_service, '_parse_recovery_now', lambda: clock[0], raising=False)
+    try:
+        with patch.object(ast_service, 'parse_file', return_value=ast._ast_cache['sample.lua']) as parse:
+            assert inspect_symbol_data(service, 'target', 'sample.lua')['status'] == 'not_found'
+            assert parse.call_count == 1
+            other.write_text('def after(): return 2\n')
+            clock[0] = 101.0
+            assert inspect_symbol_data(service, 'target', 'sample.lua')['status'] == 'not_found'
+            assert parse.call_count == 1
+    finally:
+        ast.stop_hydration()
+        ast._store.close()
+
+
 def test_new_parser_generation_permits_a_new_bounded_attempt(tmp_path):
     from attocode_intel._internal.integrations.context import ast_snapshot
 

{attocode_code_intel-0.1.16 → attocode_code_intel-0.1.18}/tests/test_preview_admission.py

@@ -52,12 +52,15 @@ def test_actual_inventory_matches_committed_blobs_and_link_targets(tmp_path):
     assert source_manifest(root) == pinned_manifest(cache, {'entries': entries})
 
 
-def capture(tmp_path):
+def capture(tmp_path, *, alias=False):
     root, evidence = tmp_path / 'work', tmp_path / 'evidence'
     root.mkdir()
     (root / 'test.py').write_bytes(b'alpha\n')
+    selected = 'alias.py' if alias else 'test.py'
+    if alias:
+        (root / 'alias.py').symlink_to('test.py')
     spec = {'id': 'toy', 'questions': [{'id': 'q', 'query': 'alpha', 'kind': 'behavior',
-            'split': 'development', 'file': 'test.py', 'anchors': [{'line': 1, 'quote': 'alpha'}]}]}
+            'split': 'development', 'file': selected, 'anchors': [{'line': 1, 'quote': 'alpha'}]}]}
     design = {'rounds': [['baseline', 'candidate']], 'requests': {'depths': [5], 'budgets': [2000],
               'scoped_depth': 5, 'scoped_budget': 2000}}
     journal = Journal(evidence / 'journal', 128 * 1024)
@@ -66,10 +69,10 @@ def capture(tmp_path):
     from eval.quality.preview_experiment import page_identity
     pages = []
     for arm in design['rounds'][0]:
-        for scope in ('', 'test.py'):
-            hit = {'file_path': 'test.py', 'name': 'alpha', 'chunk_type': 'function', 'score': 1,
+        for scope in ('', selected):
+            hit = {'file_path': selected, 'name': 'alpha', 'chunk_type': 'function', 'score': 1,
                    'line': 1, 'end_line': 1, 'snippet_start_line': 1, 'snippet_end_line': 1, 'snippet': 'alpha'}
-            identity = ['test.py', 'alpha', 'function', 1, 1]
+            identity = [selected, 'alpha', 'function', 1, 1]
             policy = {'producer': 'body_index', 'errors': 'replace', 'newlines': 'universal',
                       'source_sha256': hashlib.sha256(b'alpha\n').hexdigest()}
             journal.response({'event': 'source_lineage', 'identity': identity}, policy)
@@ -115,3 +118,8 @@ def test_raw_capture_damage_is_incomplete_before_next_worker(tmp_path, damage):
         row['arguments']['query'] = 'beta'
     with pytest.raises((ValueError, FileNotFoundError)):
         admit_worker(evidence, root, spec, design, observation)
+
+
+def test_source_alias_hash_is_checked_against_its_pinned_target(tmp_path):
+    root, evidence, spec, design, observation = capture(tmp_path, alias=True)
+    assert admit_worker(evidence, root, spec, design, observation) == observation

attocode_code_intel-0.1.18/tests/test_recovery_readiness.py

@@ -0,0 +1,157 @@
+"""A completed snapshot fallback must publish its reconstructed readiness."""
+
+import json
+import sqlite3
+from contextlib import nullcontext
+from dataclasses import asdict
+from unittest.mock import patch
+
+import pytest
+from attocode_intel._internal.integrations.context import ast_service
+from attocode_intel._internal.integrations.context.ast_service import ASTService
+from attocode_intel._internal.integrations.context.index_store import SNAPSHOT_KEY, IndexStore
+from attocode_intel.service import CodeIntelService
+
+from eval.quality.readiness import coverage_ready
+
+
+def close(service):
+    service.stop_hydration()
+    service._store.close()
+
+
+def seed(root):
+    (root / 'helper.py').write_text('def helper():\n    return 1\n')
+    (root / 'caller.py').write_text('from helper import helper\ndef caller():\n    return helper()\n')
+    (root / 'empty.py').write_text('# intentionally no definitions\n')
+    service = ASTService(str(root))
+    assert service.initialize_skeleton().phase == 'ready'
+    return service
+
+
+def navigation(service):
+    index = service._index
+    return {
+        'asts': {p: asdict(ast) for p, ast in service._ast_cache.items()},
+        'definitions': {p: [asdict(v) for v in values] for p, values in index.definitions.items()},
+        'references': {p: [asdict(v) for v in values] for p, values in index.references.items()},
+        'dependencies': index.file_dependencies,
+        'calls': index.call_edges,
+        'callers': index.callers_of,
+        'stats': service._store.stats(),
+    }
+
+
+@pytest.mark.parametrize('fault', ['sqlite', 'malformed', 'shape'])
+def test_recovered_snapshot_publishes_ready(tmp_path, fault):
+    first = seed(tmp_path)
+    expected = navigation(first)
+    if fault != 'sqlite':
+        first._store.set_meta(SNAPSHOT_KEY, '{bad json' if fault == 'malformed' else 'null')
+    close(first)
+    second = ASTService(str(tmp_path))
+    failure = patch.object(IndexStore, 'load_symbols', side_effect=sqlite3.DatabaseError('read failed')) if fault == 'sqlite' else nullcontext()
+    try:
+        with failure, patch.object(second, '_index_references', wraps=second._index_references) as extracted:
+            state = second.initialize_skeleton()
+        assert extracted.call_count == state.total_files == state.parsed_files == state.reference_indexed_files == 3
+        assert navigation(second) == expected
+        assert json.loads(second._store.get_meta(SNAPSHOT_KEY))['parsed'] == sorted(expected['asts'])
+        coverage = second.hydration_snapshot()
+        assert coverage['parse_coverage'] == coverage['reference_coverage'] == 1.0
+        assert state.phase == coverage['phase'] == 'ready', 'completed snapshot fallback still reports skeleton'
+        assert coverage_ready(coverage)
+    finally:
+        close(second)
+    third = ASTService(str(tmp_path))
+    try:
+        with patch.object(third, '_index_references', side_effect=AssertionError('reparsed healthy recovery')):
+            assert third.initialize_skeleton().phase == 'ready'
+        assert navigation(third) == expected
+    finally:
+        close(third)
+
+
+@pytest.mark.parametrize('partial', ['budget', 'parse'])
+def test_partial_snapshot_fallback_stays_skeleton(tmp_path, monkeypatch, partial):
+    first = seed(tmp_path)
+    close(first)
+    if partial == 'budget':
+        monkeypatch.setattr(ast_service, 'skeleton_budget', lambda *_: 1)
+    second = ASTService(str(tmp_path))
+    original = ast_service.parse_file
+
+    def parse(path):
+        if partial == 'parse' and str(path).endswith('/caller.py'):
+            raise OSError('source read failed')
+        return original(path)
+
+    try:
+        with (patch.object(IndexStore, 'load_symbols', side_effect=sqlite3.DatabaseError('read failed')),
+              patch.object(ast_service, 'parse_file', parse)):
+            state = second.initialize_skeleton()
+        assert state.parsed_files < state.total_files
+        assert state.phase == second.hydration_snapshot()['phase'] == 'skeleton'
+        assert not coverage_ready(second.hydration_snapshot())
+        assert not second._store.get_meta(SNAPSHOT_KEY)
+    finally:
+        close(second)
+
+
+def test_minimal_initialization_keeps_its_skeleton(tmp_path):
+    first = seed(tmp_path)
+    close(first)
+    second = ASTService(str(tmp_path))
+    try:
+        with patch.object(IndexStore, 'load_symbols', side_effect=AssertionError('minimal loaded snapshot')):
+            state = second.initialize_skeleton(indexing_depth='minimal')
+        assert state.phase == 'skeleton' and state.parsed_files == state.reference_indexed_files == 0
+        assert not coverage_ready(second.hydration_snapshot())
+    finally:
+        close(second)
+
+
+def test_empty_fallback_publishes_completed_empty_state(tmp_path):
+    service = ASTService(str(tmp_path))
+    service._store.set_meta(SNAPSHOT_KEY, 'null')
+    try:
+        state = service.initialize_skeleton()
+        assert state.total_files == state.parsed_files == state.reference_indexed_files == 0
+        assert state.phase == 'ready'
+        assert service._store.get_meta(SNAPSHOT_KEY)
+        assert not coverage_ready(service.hydration_snapshot())  # experiment barrier requires a nonempty fixture
+    finally:
+        close(service)
+
+
+def test_interrupted_fallback_does_not_publish_ready(tmp_path):
+    first = seed(tmp_path)
+    close(first)
+    second = ASTService(str(tmp_path))
+    try:
+        with (patch.object(IndexStore, 'load_symbols', side_effect=sqlite3.DatabaseError('read failed')),
+              patch.object(IndexStore, 'save_files_batch', side_effect=OSError('write interrupted')),
+              pytest.raises(OSError, match='write interrupted')):
+            second.initialize_skeleton()
+        assert second._hydration_state.phase == 'skeleton'
+        assert not second.initialized and not second._store.get_meta(SNAPSHOT_KEY)
+    finally:
+        close(second)
+
+
+def test_service_uses_completed_recovery_without_background_hydration(tmp_path):
+    first = seed(tmp_path)
+    close(first)
+    ast = ASTService(str(tmp_path))
+    service = CodeIntelService(str(tmp_path))
+    try:
+        # Suppress the real background thread so it cannot hide the returned phase.
+        with (patch.object(ASTService, 'get_instance', return_value=ast),
+              patch.object(IndexStore, 'load_symbols', side_effect=sqlite3.DatabaseError('read failed')),
+              patch.object(ASTService, 'start_hydration') as background):
+            restored = service._get_ast_service()
+        assert restored is ast and coverage_ready(restored.hydration_snapshot())
+        assert background.call_count == 0
+        assert ast._index.get_references('helper')
+    finally:
+        close(ast)