python-delphi-lsp 2.0.5__py3-none-any.whl → 2.1.0__py3-none-any.whl

delphi_lsp/_version.py

@@ -1 +1 @@
-__version__ = "2.0.5"
+__version__ = "2.1.0"

delphi_lsp/agent_cache.py

@@ -6,6 +6,7 @@ import argparse
 import contextlib
 import hmac
 import json
+import math
 import os
 from pathlib import Path
 import secrets
@@ -26,13 +27,15 @@ from .agent_protocol import AgentProtocolError
 
 DEFAULT_MAX_MEMORY_BYTES = 512 * 1024**2
 WARNING_THRESHOLD_PERCENT = 80
-DAEMON_SCHEMA = 1
+DAEMON_SCHEMA = 2
 DEFAULT_IDLE_TIMEOUT = 1800
+DEFAULT_STARTUP_TIMEOUT = 120.0
 _MAX_MESSAGE_BYTES = 1024 * 1024
 _CONNECTION_TIMEOUT = 2.0
 _MEMORY_SIZE = re.compile(r"^(?P<count>[1-9][0-9]*)(?P<suffix>[KMG]?)$", re.IGNORECASE)
 _STARTUP_DIAGNOSTIC_BYTES = 16 * 1024
 _STARTUP_TOKEN_RE = re.compile(r"(?i)(token\b[^\n\r]*?:?\s*['\"]?[A-Za-z0-9_-]+['\"]?|\b[a-zA-Z0-9_-]{32,})")
+_START_LOCK_INCOMPLETE_GRACE_SECONDS = 1.0
 
 
 def estimate_deep_size(value: object) -> int:
@@ -72,6 +75,7 @@ class CacheStats:
     rebuilds: int = 0
     invalidations: int = 0
     evictions: int = 0
+    parallel_fallbacks: int = 0
 
 
 @dataclass(frozen=True)
@@ -232,6 +236,7 @@ class CacheMetadata:
     version: str
     project_file: str
     max_memory_bytes: int
+    workers: int
     idle_timeout: int
     started_at: float
 
@@ -291,7 +296,7 @@ def _write_metadata(metadata: CacheMetadata) -> None:
             os.unlink(temporary)
 
 
-def _read_metadata(root: str | Path) -> CacheMetadata | None:
+def _read_metadata_record(root: str | Path) -> object | None:
     path = _safe_metadata_path(root)
     if not path.exists():
         return None
@@ -309,15 +314,36 @@ def _read_metadata(root: str | Path) -> CacheMetadata | None:
         raise
     except (OSError, ValueError, UnicodeError):
         return None
+    return raw
+
+
+def _read_metadata(root: str | Path) -> CacheMetadata | None:
+    raw = _read_metadata_record(root)
     required = {field.name for field in fields(CacheMetadata)}
     if not isinstance(raw, dict) or set(raw) != required:
         return None
-    values = tuple(raw[name] for name in ("schema", "root", "pid", "port", "token", "version", "project_file", "max_memory_bytes", "idle_timeout", "started_at"))
+    values = tuple(
+        raw[name]
+        for name in (
+            "schema",
+            "root",
+            "pid",
+            "port",
+            "token",
+            "version",
+            "project_file",
+            "max_memory_bytes",
+            "workers",
+            "idle_timeout",
+            "started_at",
+        )
+    )
     if (type(values[0]) is not int or values[0] != DAEMON_SCHEMA or not isinstance(values[1], str)
             or type(values[2]) is not int or values[2] <= 0 or type(values[3]) is not int or not 0 < values[3] < 65536
             or not isinstance(values[4], str) or len(values[4]) < 32 or not isinstance(values[5], str)
             or not isinstance(values[6], str) or type(values[7]) is not int or values[7] <= 0
-            or type(values[8]) is not int or values[8] <= 0 or type(values[9]) not in (int, float)):
+            or type(values[8]) is not int or not 0 <= values[8] <= 32
+            or type(values[9]) is not int or values[9] <= 0 or type(values[10]) not in (int, float)):
         return None
     canonical = str(Path(root).resolve())
     if values[1] != canonical:
@@ -325,15 +351,56 @@ def _read_metadata(root: str | Path) -> CacheMetadata | None:
     return CacheMetadata(*values)
 
 
+def _remove_incompatible_metadata_if_stale(root: str | Path) -> None:
+    path = _safe_metadata_path(root)
+    if not path.exists():
+        return
+    raw = _read_metadata_record(root)
+    canonical = str(Path(root).resolve())
+    pid = raw.get("pid") if isinstance(raw, dict) and raw.get("root") == canonical else None
+    if type(pid) is int and pid > 0 and _pid_alive(pid):
+        raise CacheClientError("unavailable", "Live cache daemon is unavailable.")
+    with contextlib.suppress(FileNotFoundError):
+        path.unlink()
+
+
+def _metadata_is_owned(metadata: CacheMetadata) -> bool:
+    current = _read_metadata(metadata.root)
+    return current is not None and current.pid == metadata.pid and hmac.compare_digest(current.token, metadata.token)
+
+
 def _remove_metadata_if_owned(metadata: CacheMetadata) -> None:
     path = _safe_metadata_path(metadata.root)
-    current = _read_metadata(metadata.root)
-    if current is not None and current.pid == metadata.pid and hmac.compare_digest(current.token, metadata.token):
+    if _metadata_is_owned(metadata):
         with contextlib.suppress(FileNotFoundError):
             path.unlink()
 
 
+def _windows_pid_alive(pid: int) -> bool:
+    import ctypes
+    from ctypes import wintypes
+
+    synchronize = 0x00100000
+    wait_timeout = 0x00000102
+    kernel32 = ctypes.windll.kernel32
+    kernel32.OpenProcess.argtypes = (wintypes.DWORD, wintypes.BOOL, wintypes.DWORD)
+    kernel32.OpenProcess.restype = wintypes.HANDLE
+    kernel32.WaitForSingleObject.argtypes = (wintypes.HANDLE, wintypes.DWORD)
+    kernel32.WaitForSingleObject.restype = wintypes.DWORD
+    kernel32.CloseHandle.argtypes = (wintypes.HANDLE,)
+    kernel32.CloseHandle.restype = wintypes.BOOL
+    handle = kernel32.OpenProcess(synchronize, False, pid)
+    if not handle:
+        return False
+    try:
+        return kernel32.WaitForSingleObject(handle, 0) == wait_timeout
+    finally:
+        kernel32.CloseHandle(handle)
+
+
 def _pid_alive(pid: int) -> bool:
+    if os.name == "nt":
+        return _windows_pid_alive(pid)
     try:
         os.kill(pid, 0)
     except OSError:
@@ -341,15 +408,41 @@ def _pid_alive(pid: int) -> bool:
     return True
 
 
+def _reap_child_if_exited(pid: int) -> bool:
+    waitpid = getattr(os, "waitpid", None)
+    nohang = getattr(os, "WNOHANG", None)
+    if not callable(waitpid) or nohang is None:
+        return False
+    try:
+        return waitpid(pid, nohang)[0] == pid
+    except (ChildProcessError, OSError):
+        return False
+
+
 def _start_lock_path(root: str | Path) -> Path:
     return _safe_metadata_path(root, create=True).with_name("start.lock")
 
 
+def _start_lock_is_stale(path: Path) -> bool:
+    try:
+        age = max(0.0, time.time() - path.stat().st_mtime)
+    except OSError:
+        return True
+    try:
+        record = json.loads(path.read_text(encoding="utf-8"))
+    except (OSError, ValueError, UnicodeError):
+        return age >= _START_LOCK_INCOMPLETE_GRACE_SECONDS
+    owner = record.get("pid") if isinstance(record, dict) else None
+    if type(owner) is int and owner > 0:
+        return not _pid_alive(owner)
+    return age >= _START_LOCK_INCOMPLETE_GRACE_SECONDS
+
+
 @contextlib.contextmanager
-def _start_lock(root: str | Path):
+def _start_lock(root: str | Path, timeout: float):
     path = _start_lock_path(root)
     token = secrets.token_urlsafe(24)
-    deadline = time.monotonic() + 10
+    deadline = time.monotonic() + timeout
     while True:
         try:
             descriptor = os.open(path, os.O_WRONLY | os.O_CREAT | os.O_EXCL, 0o600)
@@ -361,14 +454,7 @@ def _start_lock(root: str | Path):
                 os.close(descriptor)
             break
         except FileExistsError:
-            try:
-                record = json.loads(path.read_text(encoding="utf-8"))
-                owner = record.get("pid") if isinstance(record, dict) else None
-                started = record.get("started_at") if isinstance(record, dict) else None
-                stale = type(owner) is not int or not _pid_alive(owner) or type(started) not in (int, float) or time.time() - started > 30
-            except (OSError, ValueError, UnicodeError):
-                stale = True
-            if stale:
+            if _start_lock_is_stale(path):
                 with contextlib.suppress(FileNotFoundError):
                     path.unlink()
                 continue
@@ -450,7 +536,12 @@ def _read_startup_tail(diagnostics: object, *, max_bytes: int = _STARTUP_DIAGNOS
 class _CacheService:
     def __init__(self, metadata: CacheMetadata) -> None:
         self.metadata = metadata
-        self.context = AgentContext.open(metadata.root, metadata.project_file or None)
+        self.context = AgentContext.open(
+            metadata.root,
+            metadata.project_file or None,
+            workers=metadata.workers,
+            worker_memory_budget_bytes=metadata.max_memory_bytes,
+        )
         self.budget = CacheBudget(metadata.max_memory_bytes)
         self.stats = CacheStats()
         self.lock = threading.Lock()
@@ -459,9 +550,11 @@ class _CacheService:
         self.cache_state = "warming"
         self.last_revision = self.context.workspace.workspace_revision
         self.last_budget = BudgetResult(0, 0.0, 0.0, False, False, False)
+        self.prewarm_seconds = 0.0
         self.shutdown = threading.Event()
 
     def prewarm(self) -> None:
+        started = time.monotonic()
         try:
             self.context.handle({"action": "find", "query": "", "max_items": 1, "max_chars": 256})
             self.last_revision = self.context.workspace.workspace_revision
@@ -478,6 +571,8 @@ class _CacheService:
         if self.last_budget.compacted:
             self.stats.evictions += 1
             self.cache_state = "compact"
+        self.prewarm_seconds = time.monotonic() - started
+        self.stats.parallel_fallbacks = self.context.parallel_stats.fallbacks
 
     def request(self, request: dict[str, object]) -> CacheClientResponse:
         with self.lock:
@@ -506,6 +601,7 @@ class _CacheService:
                 self.stats.warm_hits += 1
             else:
                 self.stats.rebuilds += 1
+                self.stats.parallel_fallbacks += self.context.parallel_stats.fallbacks
             if before != after:
                 self.stats.invalidations += 1
             self.last_budget = self.budget.enforce(
@@ -539,6 +635,12 @@ class _CacheService:
             "warning_active": self.last_budget.warning_active, "warning_threshold_percent": WARNING_THRESHOLD_PERCENT,
             "cache_state": self.cache_state, "requests": self.stats.requests, "warm_hits": self.stats.warm_hits,
             "rebuilds": self.stats.rebuilds, "invalidations": self.stats.invalidations, "evictions": self.stats.evictions,
+            "workers_configured": "auto" if self.metadata.workers == 0 else self.metadata.workers,
+            "workers_effective": self.context.parallel_stats.effective_workers,
+            "parallel_files_completed": self.context.parallel_stats.files_completed,
+            "prewarm_seconds": self.prewarm_seconds,
+            "parallel_seconds": self.context.parallel_stats.elapsed_seconds,
+            "parallel_fallbacks": self.stats.parallel_fallbacks,
             "idle_timeout": self.metadata.idle_timeout, "idle_remaining": max(0.0, self.metadata.idle_timeout - idle),
             "workspace_revision": self.context.workspace.workspace_revision,
         }
@@ -562,14 +664,33 @@ def _serve_connection(connection: socket.socket, service: _CacheService) -> None
         connection.sendall(json.dumps(response, separators=(",", ":")).encode("utf-8") + b"\n")
 
 
-def run_cache_daemon(root: str | Path, *, project_file: str = "", max_memory_bytes: int = DEFAULT_MAX_MEMORY_BYTES, idle_timeout: int = DEFAULT_IDLE_TIMEOUT) -> None:
+def run_cache_daemon(
+    root: str | Path,
+    *,
+    project_file: str = "",
+    max_memory_bytes: int = DEFAULT_MAX_MEMORY_BYTES,
+    workers: int = 0,
+    idle_timeout: int = DEFAULT_IDLE_TIMEOUT,
+) -> None:
     canonical = str(Path(root).resolve())
     listener = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
     listener.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
     listener.bind(("127.0.0.1", 0))
     listener.listen(16)
     listener.settimeout(0.25)
-    metadata = CacheMetadata(DAEMON_SCHEMA, canonical, os.getpid(), listener.getsockname()[1], secrets.token_urlsafe(32), __version__, project_file, max_memory_bytes, idle_timeout, time.time())
+    metadata = CacheMetadata(
+        DAEMON_SCHEMA,
+        canonical,
+        os.getpid(),
+        listener.getsockname()[1],
+        secrets.token_urlsafe(32),
+        __version__,
+        project_file,
+        max_memory_bytes,
+        workers,
+        idle_timeout,
+        time.time(),
+    )
     try:
         service = _CacheService(metadata)
         service.prewarm()
@@ -587,7 +708,15 @@ def run_cache_daemon(root: str | Path, *, project_file: str = "", max_memory_byt
         _remove_metadata_if_owned(metadata)
 
 
-def _start_cache_unlocked(root: str | Path, *, project_file: str | Path | None = None, max_memory_bytes: int = DEFAULT_MAX_MEMORY_BYTES, idle_timeout: int = DEFAULT_IDLE_TIMEOUT) -> CacheMetadata:
+def _start_cache_unlocked(
+    root: str | Path,
+    *,
+    project_file: str | Path | None = None,
+    max_memory_bytes: int = DEFAULT_MAX_MEMORY_BYTES,
+    workers: int = 0,
+    idle_timeout: int = DEFAULT_IDLE_TIMEOUT,
+    startup_timeout: float = DEFAULT_STARTUP_TIMEOUT,
+) -> CacheMetadata:
     canonical = str(Path(root).resolve())
     project = str((Path(canonical) / project_file).resolve()) if project_file and not Path(project_file).is_absolute() else (str(Path(project_file).resolve()) if project_file else "")
     existing = _read_metadata(canonical)
@@ -596,12 +725,32 @@ def _start_cache_unlocked(root: str | Path, *, project_file: str | Path | None =
             _client_exchange(existing, {"action": "status", "_startup_probe": True})
         except CacheClientError as error:
             raise CacheClientError("unavailable", "Live cache daemon is unavailable.") from error
-        if (existing.project_file, existing.max_memory_bytes, existing.idle_timeout) != (project, max_memory_bytes, idle_timeout):
+        if (existing.project_file, existing.max_memory_bytes, existing.workers, existing.idle_timeout) != (
+            project,
+            max_memory_bytes,
+            workers,
+            idle_timeout,
+        ):
             raise CacheClientError("configuration_conflict", "A live cache daemon has conflicting configuration.")
         return existing
     if existing:
         _remove_metadata_if_owned(existing)
-    command = [sys.executable, "-m", "delphi_lsp.agent_cache", "serve", "--root", canonical, "--max-memory", str(max_memory_bytes), "--idle-timeout", str(idle_timeout)]
+    else:
+        _remove_incompatible_metadata_if_stale(canonical)
+    command = [
+        sys.executable,
+        "-m",
+        "delphi_lsp.agent_cache",
+        "serve",
+        "--root",
+        canonical,
+        "--max-memory",
+        str(max_memory_bytes),
+        "--workers",
+        str(workers),
+        "--idle-timeout",
+        str(idle_timeout),
+    ]
     if project:
         command.extend(("--project-file", project))
     options: dict[str, object] = {"stdin": subprocess.DEVNULL, "stdout": subprocess.DEVNULL}
@@ -612,7 +761,7 @@ def _start_cache_unlocked(root: str | Path, *, project_file: str | Path | None =
     with tempfile.TemporaryFile() as diagnostics:
         options["stderr"] = diagnostics
         process = subprocess.Popen(command, **options)
-        deadline = time.monotonic() + 10
+        deadline = time.monotonic() + startup_timeout
         startup_ready = False
         try:
             while time.monotonic() < deadline:
@@ -649,14 +798,34 @@ def _start_cache_unlocked(root: str | Path, *, project_file: str | Path | None =
                     process.wait()
 
 
-def start_cache(root: str | Path, *, project_file: str | Path | None = None, max_memory_bytes: int = DEFAULT_MAX_MEMORY_BYTES, idle_timeout: int = DEFAULT_IDLE_TIMEOUT) -> CacheMetadata:
-    with _start_lock(root):
-        return _start_cache_unlocked(root, project_file=project_file, max_memory_bytes=max_memory_bytes, idle_timeout=idle_timeout)
+def start_cache(
+    root: str | Path,
+    *,
+    project_file: str | Path | None = None,
+    max_memory_bytes: int = DEFAULT_MAX_MEMORY_BYTES,
+    workers: int = 0,
+    idle_timeout: int = DEFAULT_IDLE_TIMEOUT,
+    startup_timeout: float = DEFAULT_STARTUP_TIMEOUT,
+) -> CacheMetadata:
+    if type(workers) is not int or not 0 <= workers <= 32:
+        raise ValueError("workers must be auto or an integer from 1 through 32.")
+    if not math.isfinite(startup_timeout) or startup_timeout <= 0:
+        raise ValueError("startup_timeout must be greater than zero.")
+    with _start_lock(root, startup_timeout):
+        return _start_cache_unlocked(
+            root,
+            project_file=project_file,
+            max_memory_bytes=max_memory_bytes,
+            workers=workers,
+            idle_timeout=idle_timeout,
+            startup_timeout=startup_timeout,
+        )
 
 
 def query_cache(root: str | Path, request: dict[str, object]) -> CacheClientResponse:
     metadata = _read_metadata(root)
     if metadata is None:
+        _remove_incompatible_metadata_if_stale(root)
         raise CacheClientError("cache_not_running", "Cache daemon is not running.")
     if not _pid_alive(metadata.pid):
         _remove_metadata_if_owned(metadata)
@@ -671,6 +840,7 @@ def cache_status(root: str | Path) -> dict[str, object]:
 def stop_cache(root: str | Path) -> None:
     metadata = _read_metadata(root)
     if metadata is None:
+        _remove_incompatible_metadata_if_stale(root)
         return
     if not _pid_alive(metadata.pid):
         _remove_metadata_if_owned(metadata)
@@ -681,11 +851,13 @@ def stop_cache(root: str | Path) -> None:
         pass
     deadline = time.monotonic() + 3
     stopped = False
-    while _pid_alive(metadata.pid) and time.monotonic() < deadline:
-        with contextlib.suppress(ChildProcessError):
-            if os.waitpid(metadata.pid, os.WNOHANG)[0] == metadata.pid:
-                stopped = True
-                break
+    while time.monotonic() < deadline:
+        if _reap_child_if_exited(metadata.pid):
+            stopped = True
+            break
+        if not _pid_alive(metadata.pid):
+            stopped = True
+            break
         time.sleep(0.05)
     if not stopped and _pid_alive(metadata.pid):
         raise CacheClientError("stop_failed", "Cache daemon did not stop.")
@@ -699,10 +871,17 @@ def main(argv: list[str] | None = None) -> int:
     serve.add_argument("--root", required=True)
     serve.add_argument("--project-file", default="")
     serve.add_argument("--max-memory", type=int, default=DEFAULT_MAX_MEMORY_BYTES)
+    serve.add_argument("--workers", type=int, default=0)
     serve.add_argument("--idle-timeout", type=int, default=DEFAULT_IDLE_TIMEOUT)
     args = parser.parse_args(argv)
     if args.command == "serve":
-        run_cache_daemon(args.root, project_file=args.project_file, max_memory_bytes=args.max_memory, idle_timeout=args.idle_timeout)
+        run_cache_daemon(
+            args.root,
+            project_file=args.project_file,
+            max_memory_bytes=args.max_memory,
+            workers=args.workers,
+            idle_timeout=args.idle_timeout,
+        )
     return 0
 
 

delphi_lsp/agent_cli.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 
 import argparse
 import json
+import math
 import os
 import sys
 from pathlib import Path
@@ -12,6 +13,7 @@ from .agent_cache import (
     CacheClientError,
     DEFAULT_IDLE_TIMEOUT,
     DEFAULT_MAX_MEMORY_BYTES,
+    DEFAULT_STARTUP_TIMEOUT,
     parse_memory_size,
     query_cache,
     run_cache_daemon,
@@ -21,6 +23,7 @@ from .agent_cache import (
 from .agent_layers import build_codebase_index, layer_payload, render_layer
 from .agent_protocol import AgentProtocolError, SUPPORTED_ACTIONS, SUPPORTED_DETAILS, SUPPORTED_RELATIONS
 from .agent_templates import install_opencode_support, install_skill
+from .parallel_outline import parse_worker_setting
 
 
 _MAX_WORKER_RECORD_BYTES = 1024 * 1024
@@ -60,12 +63,14 @@ def build_parser() -> argparse.ArgumentParser:
     view.add_argument("--query", default="")
     view.add_argument("--format", default="markdown", choices=["markdown", "json"])
     view.add_argument("--deep-projects", action="store_true", help="Deep-parse project dependencies for the projects layer.")
+    view.add_argument("--workers", type=parse_worker_setting, default=0)
     view.set_defaults(func=_view)
 
     index = subcommands.add_parser("index", help="Materialize a JSON codebase index.")
     index.add_argument("--root", type=Path, default=Path("."))
     index.add_argument("--project-file", type=Path)
     index.add_argument("--out", type=Path, default=Path(".delphi-lsp") / "agent-index" / "index.json")
+    index.add_argument("--workers", type=parse_worker_setting, default=0)
     index.set_defaults(func=_index)
 
     skill = subcommands.add_parser("skill", help="Install agent skill templates.")
@@ -95,6 +100,7 @@ def build_parser() -> argparse.ArgumentParser:
     worker = subcommands.add_parser("worker", help="Serve Protocol v2 NDJSON requests.")
     worker.add_argument("--root", type=Path, required=True)
     worker.add_argument("--project-file", type=Path)
+    worker.add_argument("--workers", type=parse_worker_setting, default=0)
     worker.set_defaults(func=_worker)
 
     cache = subcommands.add_parser("cache", help="Manage the shared Protocol v2 cache daemon.")
@@ -113,6 +119,7 @@ def build_parser() -> argparse.ArgumentParser:
     cache_serve.add_argument("--root", type=Path, required=True)
     cache_serve.add_argument("--project-file", type=Path)
     cache_serve.add_argument("--max-memory", type=parse_memory_size, required=True)
+    cache_serve.add_argument("--workers", type=parse_worker_setting, required=True)
     cache_serve.add_argument("--idle-timeout", type=int, required=True)
     cache_serve.set_defaults(func=_cache_serve)
 
@@ -135,7 +142,16 @@ def _add_cache_start_arguments(parser: argparse.ArgumentParser) -> None:
     parser.add_argument("--root", type=Path, default=Path("."))
     parser.add_argument("--project-file", type=Path)
     parser.add_argument("--max-memory", type=parse_memory_size, default=DEFAULT_MAX_MEMORY_BYTES)
+    parser.add_argument("--workers", type=parse_worker_setting, default=0)
     parser.add_argument("--idle-timeout", type=int, default=DEFAULT_IDLE_TIMEOUT)
+    parser.add_argument("--startup-timeout", type=_positive_float, default=DEFAULT_STARTUP_TIMEOUT)
+
+
+def _positive_float(value: str) -> float:
+    parsed = float(value)
+    if not math.isfinite(parsed) or parsed <= 0:
+        raise argparse.ArgumentTypeError("value must be greater than zero")
+    return parsed
 
 
 def main(argv: list[str] | None = None) -> int:
@@ -173,12 +189,22 @@ def _discard_broken_stdout() -> None:
 
 
 def _view(args: argparse.Namespace) -> None:
-    index = build_codebase_index(args.root, project_file=args.project_file, index_projects=args.deep_projects)
+    index = build_codebase_index(
+        args.root,
+        project_file=args.project_file,
+        index_projects=args.deep_projects,
+        workers=args.workers,
+    )
     sys.stdout.write(render_layer(index, args.layer, query=args.query, output_format=args.format))
 
 
 def _index(args: argparse.Namespace) -> None:
-    index = build_codebase_index(args.root, project_file=args.project_file, index_projects=True)
+    index = build_codebase_index(
+        args.root,
+        project_file=args.project_file,
+        index_projects=True,
+        workers=args.workers,
+    )
     payload = {
         "overview": layer_payload(index, "overview"),
         "projects": layer_payload(index, "projects"),
@@ -207,7 +233,7 @@ def _opencode_install(args: argparse.Namespace) -> None:
 
 
 def _worker(args: argparse.Namespace) -> None:
-    context = AgentContext.open(args.root, args.project_file)
+    context = AgentContext.open(args.root, args.project_file, workers=args.workers)
     try:
         _serve_worker(context, sys.stdin.buffer, sys.stdout.buffer, sys.stderr)
     finally:
@@ -235,7 +261,14 @@ def _cache_error(error: CacheClientError) -> int:
 
 def _cache_start(args: argparse.Namespace) -> int:
     try:
-        start_cache(args.root, project_file=args.project_file, max_memory_bytes=args.max_memory, idle_timeout=args.idle_timeout)
+        start_cache(
+            args.root,
+            project_file=args.project_file,
+            max_memory_bytes=args.max_memory,
+            workers=args.workers,
+            idle_timeout=args.idle_timeout,
+            startup_timeout=args.startup_timeout,
+        )
         response = query_cache(args.root, {"action": "status"})
     except CacheClientError as error:
         return _cache_error(error)
@@ -283,7 +316,13 @@ def _cache_stop(args: argparse.Namespace) -> int:
 
 
 def _cache_serve(args: argparse.Namespace) -> int:
-    run_cache_daemon(args.root, project_file=str(args.project_file or ""), max_memory_bytes=args.max_memory, idle_timeout=args.idle_timeout)
+    run_cache_daemon(
+        args.root,
+        project_file=str(args.project_file or ""),
+        max_memory_bytes=args.max_memory,
+        workers=args.workers,
+        idle_timeout=args.idle_timeout,
+    )
     return 0
 
 

delphi_lsp/agent_context.py

@@ -22,12 +22,12 @@ from .agent_metrics import build_workspace_metrics, project_metric_item, unit_me
 from .agent_relations import ProjectRelationIndex, RelationTarget
 from .agent_workspace import AgentUnit, AgentWorkspace, unit_display_path, unit_source_path, unit_target_id
 from .consts import AttributeName, SyntaxNodeType
-from .lsp_server import build_outline_semantic_model, multiline_string_block_end
+from .lsp_server import multiline_string_block_end
 from .nodes import CompoundSyntaxNode, SyntaxNode
 from .parser import DelphiParser
 from .semantic import Scope, ScopeKind, Symbol, SymbolKind
-from .source_reader import read_source_text
 from .metrics import ProjectMetrics
+from .parallel_outline import OutlineResult, OutlineTask, ParallelBuildStats, run_outline_tasks
 
 
 _ROUTINE_KINDS = frozenset(
@@ -239,8 +239,17 @@ class _Registry:
 
 
 class AgentContext:
-    def __init__(self, workspace: AgentWorkspace) -> None:
+    def __init__(
+        self,
+        workspace: AgentWorkspace,
+        *,
+        workers: int = 0,
+        worker_memory_budget_bytes: int | None = None,
+    ) -> None:
         self._workspace = workspace
+        self._workers = workers
+        self._worker_memory_budget_bytes = worker_memory_budget_bytes
+        self._parallel_stats = ParallelBuildStats(0, 0, 0, 0.0, 0)
         project_id = workspace.active_project_id
         self._focus = Focus(project_id=project_id) if project_id else Focus()
         self._last_revision = workspace.workspace_revision
@@ -254,8 +263,15 @@ class AgentContext:
         cls,
         root: str | Path,
         project_file: str | Path | None = None,
+        *,
+        workers: int = 0,
+        worker_memory_budget_bytes: int | None = None,
     ) -> AgentContext:
-        return cls(AgentWorkspace.open(root, project_file=project_file))
+        return cls(
+            AgentWorkspace.open(root, project_file=project_file),
+            workers=workers,
+            worker_memory_budget_bytes=worker_memory_budget_bytes,
+        )
 
     @property
     def workspace(self) -> AgentWorkspace:
@@ -265,6 +281,10 @@ class AgentContext:
     def navigation_cache_is_warm(self) -> bool:
         return self._registry is not None
 
+    @property
+    def parallel_stats(self) -> ParallelBuildStats:
+        return self._parallel_stats
+
     def cache_roots(self) -> tuple[object, ...]:
         return (
             *self._workspace.cache_roots(),
@@ -507,7 +527,13 @@ class AgentContext:
             and self._registry.revision == revision
         ):
             return self._registry
-        self._registry = _build_registry(self._workspace, project_id, revision)
+        self._registry, self._parallel_stats = _build_registry(
+            self._workspace,
+            project_id,
+            revision,
+            workers=self._workers,
+            worker_memory_budget_bytes=self._worker_memory_budget_bytes,
+        )
         if self._focus.target_id:
             focused_entry = self._registry.by_target.get(self._focus.target_id)
             if focused_entry is None:
@@ -696,38 +722,54 @@ def _validated_request(request: AgentRequest | Mapping[str, object]) -> AgentReq
     return AgentRequest.from_mapping(request)
 
 
-def _build_registry(workspace: AgentWorkspace, project_id: str, revision: str) -> _Registry:
+def _build_registry(
+    workspace: AgentWorkspace,
+    project_id: str,
+    revision: str,
+    *,
+    workers: int = 0,
+    worker_memory_budget_bytes: int | None = None,
+) -> tuple[_Registry, ParallelBuildStats]:
     raw_symbols: list[_RawSymbol] = []
     sources: dict[Path, _SourceDocument] = {}
-    for unit in workspace.units:
+    units = tuple(workspace.units)
+
+    def consume_result(result: OutlineResult) -> None:
+        unit = units[result.ordinal]
         source_path = unit_source_path(workspace.root, unit)
         display_path = unit_display_path(workspace.root, unit)
-        try:
-            text = read_source_text(source_path)
-        except OSError as exc:
+        if result.read_error or result.model is None:
             raise AgentProtocolError(
                 "source_unavailable",
-                f"Could not read selected source {unit.path}: {exc}.",
-            ) from None
+                f"Could not read selected source {display_path}.",
+            )
         document = _SourceDocument(
             source_path,
             display_path,
-            text,
+            result.text,
             defines=workspace.defines,
             include_paths=workspace.include_paths,
         )
         sources[source_path] = document
-        if workspace.defines:
-            model = build_outline_semantic_model(
-                text,
-                str(source_path),
-                defines=workspace.defines,
-            )
-        else:
-            model = build_outline_semantic_model(text, str(source_path))
-        unit_symbols = _collect_raw_symbols(model.unit_scope, unit, source_path, document)
+        unit_symbols = _collect_raw_symbols(result.model.unit_scope, unit, source_path, document)
         raw_symbols.extend(_exclude_routine_locals(unit_symbols, document))
 
+    outline_batch = run_outline_tasks(
+        (
+            OutlineTask(
+                ordinal,
+                str(unit_source_path(workspace.root, unit)),
+                workspace.defines,
+                True,
+            )
+            for ordinal, unit in enumerate(units)
+        ),
+        configured_workers=workers,
+        memory_budget_bytes=worker_memory_budget_bytes,
+        on_complete=consume_result,
+        retain_results=False,
+    )
+
     ordered = sorted(raw_symbols, key=_raw_sort_key)
     overload_groups: dict[tuple[str, str, str, str], list[_RawSymbol]] = {}
     for raw in raw_symbols:
@@ -817,13 +859,16 @@ def _build_registry(workspace: AgentWorkspace, project_id: str, revision: str) -
         )
 
     entries_tuple = tuple(sorted(with_parents, key=_entry_sort_key))
-    return _Registry(
-        project_id=project_id,
-        revision=revision,
-        entries=entries_tuple,
-        by_target={entry.target_id: entry for entry in entries_tuple},
-        sources=sources,
-        ranked_queries={},
+    return (
+        _Registry(
+            project_id=project_id,
+            revision=revision,
+            entries=entries_tuple,
+            by_target={entry.target_id: entry for entry in entries_tuple},
+            sources=sources,
+            ranked_queries={},
+        ),
+        outline_batch.stats,
     )
 
 

delphi_lsp/agent_layers.py

@@ -5,8 +5,8 @@ from pathlib import Path
 from typing import Any, Iterable
 import json
 
-from .lsp_server import build_outline_semantic_model
 from .metrics import analyze_project
+from .parallel_outline import OutlineResult, OutlineTask, ParallelBuildStats, run_outline_tasks
 from .project_discovery import DelphiProjectDiscovery, discover_delphi_project
 from .project_indexer import ProjectIndexResult, ProjectIndexer
 from .progress import ProgressCallback, ProgressEvent
@@ -22,6 +22,7 @@ class CodebaseIndex:
     models: dict[str, SemanticModel]
     symbol_index: SymbolIndex
     project_results: dict[str, ProjectIndexResult]
+    parallel_stats: ParallelBuildStats = ParallelBuildStats(0, 0, 0, 0.0, 0)
 
 
 def build_codebase_index(
@@ -30,40 +31,49 @@ def build_codebase_index(
     project_file: str | Path | None = None,
     index_projects: bool = False,
     on_progress: ProgressCallback | None = None,
+    workers: int = 0,
 ) -> CodebaseIndex:
     progress = _MonotonicProgress(on_progress)
     discovery = discover_delphi_project(root, project_file=project_file, on_progress=progress)
     models: dict[str, SemanticModel] = {}
     lines_processed = 0
     symbols_discovered = 0
-    for completed, source in enumerate(discovery.source_files, start=1):
-        path = Path(source)
-        if path.suffix.casefold() not in {".pas", ".dpr", ".dpk", ".inc"}:
-            continue
-        try:
-            text = read_source_text(path)
-        except (OSError, UnicodeError):
-            continue
-        model = build_outline_semantic_model(
-            text,
-            source,
-            defines=discovery.defines,
-        )
-        models[source] = model
-        lines_processed += text.count("\n") + (0 if not text or text.endswith("\n") else 1)
-        symbols_discovered += sum(len(items) for items in model.index.name_index.values())
+    completed_outlines = 0
+    outline_tasks = tuple(
+        OutlineTask(ordinal, source, tuple(discovery.defines), False)
+        for ordinal, source in enumerate(discovery.source_files)
+        if Path(source).suffix.casefold() in {".pas", ".dpr", ".dpk", ".inc"}
+    )
+    outline_task_count = len(outline_tasks)
+
+    def on_outline_complete(result: OutlineResult) -> None:
+        nonlocal completed_outlines, lines_processed, symbols_discovered
+        completed_outlines += 1
+        if not result.read_error:
+            lines_processed += result.lines_processed
+            symbols_discovered += result.symbols_discovered
         _emit_progress(
             progress,
             "outline",
-            source,
-            len(discovery.source_files),
-            completed,
+            result.source_path,
             len(discovery.source_files),
-            "source outlined",
+            completed_outlines,
+            outline_task_count,
+            "source unreadable" if result.read_error else "source outlined",
             lines_processed=lines_processed,
             symbols_discovered=symbols_discovered,
         )
 
+    outline_batch = run_outline_tasks(
+        outline_tasks,
+        configured_workers=workers,
+        on_complete=on_outline_complete,
+    )
+    for result in outline_batch.results:
+        if result.read_error or result.model is None:
+            continue
+        models[result.source_path] = result.model
+
     symbol_index = SymbolIndex()
     for model in models.values():
         symbol_index.register_unit(model.unit_scope.name, model.unit_scope)
@@ -99,6 +109,7 @@ def build_codebase_index(
         models=models,
         symbol_index=symbol_index,
         project_results=project_results,
+        parallel_stats=outline_batch.stats,
     )
     _emit_progress(
         progress,

delphi_lsp/parallel_outline.py

@@ -0,0 +1,278 @@
+from __future__ import annotations
+
+from concurrent.futures import ProcessPoolExecutor, as_completed
+from concurrent.futures.process import BrokenProcessPool
+from dataclasses import dataclass
+import multiprocessing
+import os
+from pathlib import Path
+from time import perf_counter
+from typing import Callable, Iterable
+
+from .lsp_server import build_outline_semantic_model
+from .semantic_builder import SemanticModel
+from .source_reader import read_source_text
+
+
+_MEBIBYTE = 1024 * 1024
+_WORKER_MEMORY_BYTES = 128 * _MEBIBYTE
+
+
+class ParallelOutlineError(RuntimeError):
+    """Raised when a parallel outline operation cannot complete."""
+
+
+@dataclass(frozen=True)
+class OutlineTask:
+    ordinal: int
+    source_path: str
+    defines: tuple[str, ...]
+    return_text: bool
+
+
+@dataclass(frozen=True)
+class OutlineResult:
+    ordinal: int
+    source_path: str
+    text: str
+    model: SemanticModel | None
+    lines_processed: int
+    symbols_discovered: int
+    read_error: str = ""
+
+
+@dataclass(frozen=True)
+class ParallelBuildStats:
+    configured_workers: int
+    effective_workers: int
+    files_completed: int
+    elapsed_seconds: float
+    fallbacks: int
+
+
+@dataclass(frozen=True)
+class OutlineBatch:
+    results: tuple[OutlineResult, ...]
+    stats: ParallelBuildStats
+
+
+def parse_worker_setting(value: str) -> int:
+    if value == "auto":
+        return 0
+    try:
+        workers = int(value)
+    except ValueError as error:
+        raise ValueError("workers must be 'auto' or an integer from 1 through 32") from error
+    if not 1 <= workers <= 32:
+        raise ValueError("workers must be 'auto' or an integer from 1 through 32")
+    return workers
+
+
+def resolve_worker_count(
+    configured_workers: int,
+    *,
+    task_count: int,
+    cpu_count: int | None = None,
+    memory_budget_bytes: int | None = None,
+) -> int:
+    if not 0 <= configured_workers <= 32:
+        raise ValueError("workers must be 'auto' or an integer from 1 through 32")
+    if task_count <= 0:
+        return 0
+    if configured_workers:
+        return min(configured_workers, task_count)
+
+    detected_cpus = os.cpu_count() if cpu_count is None else cpu_count
+    candidates = [task_count, 4, max(1, (detected_cpus or 1) - 1)]
+    if memory_budget_bytes is not None:
+        candidates.append(max(1, memory_budget_bytes // _WORKER_MEMORY_BYTES))
+    return min(candidates)
+
+
+def _parse_outline_task(task: OutlineTask) -> OutlineResult:
+    try:
+        text = read_source_text(Path(task.source_path))
+    except (OSError, UnicodeError) as error:
+        return OutlineResult(
+            ordinal=task.ordinal,
+            source_path=task.source_path,
+            text="",
+            model=None,
+            lines_processed=0,
+            symbols_discovered=0,
+            read_error=str(error),
+        )
+
+    try:
+        model = build_outline_semantic_model(text, task.source_path, defines=task.defines)
+    except Exception as error:
+        raise ParallelOutlineError(f"failed to parse {task.source_path}: {error}") from error
+    return OutlineResult(
+        ordinal=task.ordinal,
+        source_path=task.source_path,
+        text=text if task.return_text else "",
+        model=model,
+        lines_processed=len(text.splitlines()),
+        symbols_discovered=sum(len(items) for items in model.index.name_index.values()),
+    )
+
+
+def run_outline_tasks(
+    tasks: Iterable[OutlineTask],
+    *,
+    configured_workers: int,
+    memory_budget_bytes: int | None = None,
+    cpu_count: int | None = None,
+    on_complete: Callable[[OutlineResult], None] | None = None,
+    retain_results: bool = True,
+) -> OutlineBatch:
+    task_list = tuple(tasks)
+    started = perf_counter()
+    effective_workers = resolve_worker_count(
+        configured_workers,
+        task_count=len(task_list),
+        cpu_count=cpu_count,
+        memory_budget_bytes=memory_budget_bytes,
+    )
+    if effective_workers <= 1:
+        results, completed = _run_serial(task_list, on_complete, retain_results)
+        return _batch(
+            configured_workers,
+            effective_workers,
+            results,
+            started,
+            files_completed=completed,
+            fallbacks=0,
+        )
+
+    accepted: list[OutlineResult] = []
+    completed = 0
+    futures: dict[object, OutlineTask] = {}
+    executor: ProcessPoolExecutor | None = None
+    try:
+        context = multiprocessing.get_context("spawn")
+        executor = ProcessPoolExecutor(max_workers=effective_workers, mp_context=context)
+        task_iterator = iter(task_list)
+        for task in task_iterator:
+            futures[executor.submit(_parse_outline_task, task)] = task
+            if len(futures) == effective_workers:
+                break
+        while futures:
+            future = next(iter(as_completed(tuple(futures))))
+            task = futures.pop(future)
+            try:
+                result = future.result()
+            except ParallelOutlineError:
+                raise
+            except Exception as error:
+                wrapped = ParallelOutlineError(
+                    f"parallel outline execution failed for {task.source_path}: {error}"
+                )
+                if configured_workers == 0 and completed == 0:
+                    _cancel_futures(futures)
+                    _shutdown_failed_executor(executor)
+                    results, serial_completed = _run_serial(task_list, on_complete, retain_results)
+                    return _batch(
+                        configured_workers,
+                        1,
+                        results,
+                        started,
+                        files_completed=serial_completed,
+                        fallbacks=1,
+                    )
+                raise wrapped from error
+            completed += 1
+            if on_complete is not None:
+                on_complete(result)
+            if retain_results:
+                accepted.append(result)
+            try:
+                next_task = next(task_iterator)
+            except StopIteration:
+                continue
+            futures[executor.submit(_parse_outline_task, next_task)] = next_task
+    except ParallelOutlineError:
+        _cancel_futures(futures)
+        _shutdown_failed_executor(executor)
+        raise
+    except (OSError, BrokenProcessPool) as error:
+        _cancel_futures(futures)
+        _shutdown_failed_executor(executor)
+        if configured_workers == 0 and completed == 0:
+            results, serial_completed = _run_serial(task_list, on_complete, retain_results)
+            return _batch(
+                configured_workers,
+                1,
+                results,
+                started,
+                files_completed=serial_completed,
+                fallbacks=1,
+            )
+        raise ParallelOutlineError(f"parallel outline execution failed: {error}") from error
+    except BaseException:
+        _cancel_futures(futures)
+        _shutdown_failed_executor(executor)
+        raise
+
+    assert executor is not None
+    executor.shutdown(wait=True, cancel_futures=False)
+
+    return _batch(
+        configured_workers,
+        effective_workers,
+        accepted,
+        started,
+        files_completed=completed,
+        fallbacks=0,
+    )
+
+
+def _run_serial(
+    tasks: tuple[OutlineTask, ...],
+    on_complete: Callable[[OutlineResult], None] | None,
+    retain_results: bool,
+) -> tuple[list[OutlineResult], int]:
+    results = []
+    for task in tasks:
+        result = _parse_outline_task(task)
+        if on_complete is not None:
+            on_complete(result)
+        if retain_results:
+            results.append(result)
+    return results, len(tasks)
+
+
+def _cancel_futures(futures: dict[object, OutlineTask]) -> None:
+    for future in futures:
+        future.cancel()
+
+
+def _shutdown_failed_executor(executor: ProcessPoolExecutor | None) -> None:
+    if executor is None:
+        return
+    try:
+        executor.shutdown(wait=False, cancel_futures=True)
+    except BaseException:
+        pass
+
+
+def _batch(
+    configured_workers: int,
+    effective_workers: int,
+    results: list[OutlineResult],
+    started: float,
+    *,
+    files_completed: int,
+    fallbacks: int,
+) -> OutlineBatch:
+    ordered_results = tuple(sorted(results, key=lambda result: result.ordinal))
+    return OutlineBatch(
+        results=ordered_results,
+        stats=ParallelBuildStats(
+            configured_workers=configured_workers,
+            effective_workers=effective_workers,
+            files_completed=files_completed,
+            elapsed_seconds=perf_counter() - started,
+            fallbacks=fallbacks,
+        ),
+    )

{python_delphi_lsp-2.0.5.dist-info → python_delphi_lsp-2.1.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-delphi-lsp
-Version: 2.0.5
+Version: 2.1.0
 Summary: Python Delphi/Object Pascal parser, semantic indexer, and language server.
 Author: Dark Light
 License-Expression: MPL-2.0
@@ -41,7 +41,7 @@ Dynamic: license-file
 
 `python-delphi-lsp` parses Delphi/Object Pascal, builds semantic and project
 indexes, serves LSP, and provides bounded codebase navigation for agents.
-Version 2.0.5 is authored by Dark Light and supports Windows, macOS, and Linux.
+Version 2.1.0 is authored by Dark Light and supports Windows, macOS, and Linux.
 
 ## Install and quick start
 
@@ -186,12 +186,15 @@ problems; paths are not guessed.
 
 ```text
 delphi-lsp-agent cache start --root PATH [--project-file FILE] [--max-memory 512M]
+                                  [--workers auto|N] [--startup-timeout 120]
                                   [--idle-timeout 1800]
 delphi-lsp-agent cache status --root PATH [--format text|json]
 delphi-lsp-agent cache stop --root PATH
 delphi-lsp-agent view --root PATH [--project-file FILE] --layer LAYER
                       [--query TEXT] [--format markdown|json] [--deep-projects]
+                      [--workers auto|N]
 delphi-lsp-agent index --root PATH [--project-file FILE] [--out FILE]
+                       [--workers auto|N]
 delphi-lsp-agent query --root PATH ACTION [VALUE]
                       [--project-id FILE] [--detail summary|declaration|members|context|body|implementations]
                       [--relation references|callers|callees|uses|used_by|inherits|implements]
@@ -199,7 +202,7 @@ delphi-lsp-agent query --root PATH ACTION [VALUE]
 delphi-lsp-agent skill install [--target PATH] [--force]
 delphi-lsp-agent opencode install [--target PATH] [--python PYTHON]
                                   [--force] [--write-agent|--write-config]
-delphi-lsp-agent worker --root PATH [--project-file FILE]
+delphi-lsp-agent worker --root PATH [--project-file FILE] [--workers auto|N]
 ```
 
 The `cache` commands manage one daemon per canonical root. Use these:
@@ -233,6 +236,27 @@ fast. The cache retained-cache budget is `512 MiB` by default and tracks retaine
 cache usage only, not a hard RSS/parse peak. Warnings are emitted on stderr at or
 above 80 percent.
 
+Cold builds parse independent source units in short-lived processes created with
+the cross-platform `spawn` method. `--workers auto|N` defaults to `auto`.
+Automatic selection uses at most four worker processes, leaves one detected CPU
+free, never exceeds the source task count, and—for the cache daemon—allows one
+worker per `128 MiB` of retained-cache budget. `view` and `index` use the same
+task, CPU, and four-worker caps without the cache-budget term. An explicit value
+from 1 through 32 overrides the automatic CPU and memory caps but is still
+limited by the number of tasks.
+
+Worker processes exit before retained-cache accounting. Their models and source
+text are streamed into the parent, so transient worker memory is separate from
+the retained navigation structures and the existing 80-percent warning. If an
+automatic pool fails before accepting a result, one automatic serial fallback
+is attempted; explicit worker counts fail instead of silently changing the
+requested configuration.
+
+`cache start` waits up to `--startup-timeout 120` seconds by default for a large
+workspace to prewarm. The timeout belongs to the starting client and does not
+change daemon compatibility or idle shutdown. Starting a live root with a
+different worker configuration reports a configuration conflict.
+
 Eviction is ordered: auxiliary caches are evicted first, navigation caches second.
 If compaction removes navigable data, the daemon rebuilds the navigation state on demand
 while preserving focus state for the next request.
@@ -240,7 +264,9 @@ while preserving focus state for the next request.
 The daemon tracks a 30-minute idle timeout; idle state shows in JSON status (`cache status`).
 `source revision` changes on source edits and invalidate reused request caches.
 Workspace state appears in status as `requests`, `warm_hits`, `rebuilds`, `invalidations`,
-`evictions`, and `cache_state`.
+`evictions`, and `cache_state`. Parallel prewarm status adds
+`workers_configured`, `workers_effective`, `parallel_files_completed`,
+`prewarm_seconds`, `parallel_seconds`, and `parallel_fallbacks`.
 
 Metadata is stored in `.delphi-lsp/agent-cache/daemon.json` with owner-only token and
 permissions (`daemon.json` mode 600 and parent 700). Do not copy or share this token

{python_delphi_lsp-2.0.5.dist-info → python_delphi_lsp-2.1.0.dist-info}/RECORD

@@ -1,9 +1,9 @@
 delphi_lsp/__init__.py,sha256=mq3tF0NrXDgbkJXDuf5HhW6sOnmP7DQxs3zl8fGoAmo,3867
-delphi_lsp/_version.py,sha256=xEb7Z4b8xalXXExBg42XPAhbJKniHzcsEPjp-6S3ppg,22
-delphi_lsp/agent_cache.py,sha256=wWPdAnKtenNyjLXu8QDG5QO0GPo8MdR8cIltfaL8g3A,28700
-delphi_lsp/agent_cli.py,sha256=tr-MmWRPkevbtNKSnmcPJghTqD7zWJNPBVRvFicmb4M,15169
-delphi_lsp/agent_context.py,sha256=7f4J6oqs5hRlIqiTLy-OYZhqIJPAG73G-xm9BJq_MFw,78346
-delphi_lsp/agent_layers.py,sha256=ngFn-zH2Jv6CBjOhd3UkoyVgsrdXW0BChnQxSVmkRRc,25131
+delphi_lsp/_version.py,sha256=Xybt2skBZamGMNlLuOX1IG-h4uIxqUDGAO8MIGWrJac,22
+delphi_lsp/agent_cache.py,sha256=mPoT94TYuv4RXHLS0rVQWn7TmbfiU34BaEkLOXP18m4,33299
+delphi_lsp/agent_cli.py,sha256=J2zmZP2D28pXi7tx06YyEqKsojbXQcO0LdZx27kGJ1M,16311
+delphi_lsp/agent_context.py,sha256=IJpGWkFZGYq7FU4ijvaf-xqSWJAuvEWdn3AOeM5TcnE,79572
+delphi_lsp/agent_layers.py,sha256=Waiwp47BuNxxwzM8EfGb0tvLSRn2udRHkTmuX2JE6cg,25658
 delphi_lsp/agent_metrics.py,sha256=6y9DrSnKitZbwRFQrofanw6k89YGqbvEacqgSKHgh2c,2695
 delphi_lsp/agent_protocol.py,sha256=cZ1LIMhrkOb5CqiGcjSH1eZUNqtJCYySUc54h-PCyOs,12551
 delphi_lsp/agent_relations.py,sha256=aOeRYa6pw8VO0OyQZLk1wHE529k9DIDm3ENPM5ZOJiw,32879
@@ -18,6 +18,7 @@ delphi_lsp/lark_tokens.py,sha256=xT_GES2z6p1IdN3EnoKE9RcUM6suu1RV3J-0FEJN2r8,417
 delphi_lsp/lsp_server.py,sha256=hfuv8QXGQIO2s4oWYWzOjujejXNcS_ITPQ9ikw4Ua1U,71468
 delphi_lsp/metrics.py,sha256=f70B1awypqVWZIW_SNpFHdShoS8OzDW5DWX5ftQMI0c,26166
 delphi_lsp/nodes.py,sha256=LW8KUgNCg9MHK_2NmzrgCMMJNcBwa4C76XwKoS7kt4E,13556
+delphi_lsp/parallel_outline.py,sha256=nXIv-a9sn3nBeKaBtIhdD2YxGzHObdW3GxYEZ5Sy0pE,8588
 delphi_lsp/parser.py,sha256=4hckHD_fsiiUe3oeSRJwqbY8bDWqJaYLsU10NYDIW6E,6025
 delphi_lsp/preprocessor.py,sha256=aXJiabmCvWoUdrxYAA4EVVxDDQXl_IeFUezoDdMlFyU,30984
 delphi_lsp/progress.py,sha256=FF3lqdDKLvq3b7cOhuSc3P0FDzVnX0miD8U8_3xt5iY,535
@@ -28,9 +29,9 @@ delphi_lsp/semantic_builder.py,sha256=ulA7xHJpltjc6cTo5wh9yTcYazuIykM-YLMXD1h-wz
 delphi_lsp/source_reader.py,sha256=HWiw25sLVZ6s1GGpMl17uZ-o68HoxTEd3Z0__m1vsSE,520
 delphi_lsp/workspace.py,sha256=TU__SujItRlW8hB2kuYC7ZJx1WQVOj7frYxvo7rDqeI,2137
 delphi_lsp/writer.py,sha256=j-cnyiHFNOTFECL7Ehm-m43ye7ev7qFeCCscFMjrAOY,2503
-python_delphi_lsp-2.0.5.dist-info/licenses/LICENSE,sha256=-rPda9qyJvHAhjCx3ZF-Efy07F4eAg4sFvg6ChOGPoU,16726
-python_delphi_lsp-2.0.5.dist-info/METADATA,sha256=T3eZ2AtK8UFsL-6RaVdGxWCh00c8MA06urr2pgRLYHo,18327
-python_delphi_lsp-2.0.5.dist-info/WHEEL,sha256=K260EYznzXsJYBQGqmI8VTxEdiZYNvDZwW9cBh9-_MA,91
-python_delphi_lsp-2.0.5.dist-info/entry_points.txt,sha256=rh_yGH7diowge_acQcST87A-ewH1QezEsAYC8T5ineY,103
-python_delphi_lsp-2.0.5.dist-info/top_level.txt,sha256=0Zp0sjw5Qtic3EQX9zNeegURga8NuXk6c2e9PN-3OTs,11
-python_delphi_lsp-2.0.5.dist-info/RECORD,,
+python_delphi_lsp-2.1.0.dist-info/licenses/LICENSE,sha256=-rPda9qyJvHAhjCx3ZF-Efy07F4eAg4sFvg6ChOGPoU,16726
+python_delphi_lsp-2.1.0.dist-info/METADATA,sha256=REk-5BwUnYBx-IwSg9vYBrYl-gsEkJdrD9KEQjxPwss,19972
+python_delphi_lsp-2.1.0.dist-info/WHEEL,sha256=K260EYznzXsJYBQGqmI8VTxEdiZYNvDZwW9cBh9-_MA,91
+python_delphi_lsp-2.1.0.dist-info/entry_points.txt,sha256=rh_yGH7diowge_acQcST87A-ewH1QezEsAYC8T5ineY,103
+python_delphi_lsp-2.1.0.dist-info/top_level.txt,sha256=0Zp0sjw5Qtic3EQX9zNeegURga8NuXk6c2e9PN-3OTs,11
+python_delphi_lsp-2.1.0.dist-info/RECORD,,