loomweave-plugin-python 1.5.1__py3-none-any.whl → 1.6.0__py3-none-any.whl

loomweave_plugin_python/__init__.py

@@ -1,3 +1,3 @@
 """loomweave-plugin-python — Python language plugin for Loomweave."""
 
-__version__ = "1.5.1"
+__version__ = "1.6.0"

loomweave_plugin_python/call_resolver.py

@@ -115,6 +115,9 @@ class FacetCoverage:
 class CallResolutionResult:
     edges: list[CallsRawEdge] = field(default_factory=list)
     unresolved_call_sites_total: int = 0
+    # Bare unshadowed-builtin calls dropped before persistence; disclosed so
+    # the omission is visible in run stats (clarion-8a862d8f7e).
+    unresolved_call_sites_skipped_builtin_total: int = 0
     unresolved_call_sites: list[UnresolvedCallSite] = field(default_factory=list)
     pyright_query_latency_ms: list[int] = field(default_factory=list)
     pyright_index_parse_latency_ms: list[int] = field(default_factory=list)

loomweave_plugin_python/extractor.py

@@ -260,6 +260,7 @@ class ImportsEdgeProperties(TypedDict):
 @dataclass
 class ExtractionStats:
     unresolved_call_sites_total: int = 0
+    unresolved_call_sites_skipped_builtin_total: int = 0
     unresolved_call_sites: list[UnresolvedCallSite] = field(default_factory=list)
     reference_sites_total: int = 0
     references_resolved_total: int = 0
@@ -307,6 +308,9 @@ class ExtractionStats:
             calls_coverage=calls.coverage,
             references_coverage=references.coverage,
             unresolved_call_sites_total=calls.unresolved_call_sites_total,
+            unresolved_call_sites_skipped_builtin_total=(
+                calls.unresolved_call_sites_skipped_builtin_total
+            ),
             unresolved_call_sites=calls.unresolved_call_sites,
             reference_sites_total=references.reference_sites_total,
             references_resolved_total=references.references_resolved_total,

loomweave_plugin_python/pyright_session.py

@@ -14,7 +14,12 @@ is decided by WHICH catch-site caught the failure, never by message text:
   host re-dispatches when the interpreter fingerprint changes.
 - ``pyright_timeout`` -- this file's own per-query or file budget expired
   while pyright stayed alive. Self-inflicted (``collateral=False``). A single
-  timeout does not restart: the process is slow, not dead. A streak of
+  timeout does not restart: the process is slow, not dead. In the calls pass
+  a per-query timeout with file budget remaining skips ONLY that function
+  (its sites disclosed as unresolved, the abandoned computation cancelled via
+  ``$/cancelRequest``) and continues -- one pathological function no longer
+  forfeits the rest of the file (clarion-bf3986e301); the pass aborts, and
+  the facet degrades, only when the FILE budget itself is spent. A streak of
   ``MAX_CONSECUTIVE_TIMEOUT_FILES`` consecutive files whose calls pass timed
   out is read as a wedged-but-alive process and restarted once, charged to
   the run-level ``MAX_PYRIGHT_RESTARTS_PER_RUN`` budget; the streak's files
@@ -245,6 +250,15 @@ PYRIGHT_SHUTDOWN_TIMEOUT_SECS = 5.0
 # handing a small one a budget it will never use.
 PYRIGHT_FILE_TIMEOUT_BASE_SECS = 10.0
 PYRIGHT_FILE_TIMEOUT_PER_FUNCTION_SECS = 0.25
+# Second scaling axis (clarion-bf3986e301): pyright's evaluation work tracks
+# the amount of CODE it must type-check, not the def count. elspeth's
+# tool_batch.py (2,354 lines, 17 defs -- one a 1,199-line nested closure) got
+# base + 17 * 0.25 ~= 14 s under the per-function-only budget: starved the
+# same way the flat budget starved ML files (clarion-7f527d3d32). The budget
+# takes ``max(per_function * n_functions, per_line * n_lines)`` -- for the
+# common shape (many small defs) the per-function term still governs, and the
+# cap (90 s) still bounds the monster files.
+PYRIGHT_FILE_TIMEOUT_PER_LINE_SECS = 0.03
 # The host watchdog (``DEFAULT_PLUGIN_FILE_TIMEOUT`` in
 # crates/loomweave-cli/src/analyze.rs) kills an ``analyze_file`` call at 120s.
 # Stay well under it so the plugin always hands back the partial evidence it
@@ -276,6 +290,21 @@ FILE_DEADLINE_TERMINAL_SAFETY_MARGIN_SECS = 15.0
 # A respawn with less real headroom than this is pointless: pyright's
 # initialize handshake rarely completes faster on a machine that just lost it.
 MIN_RESPAWN_HEADROOM_SECS = 5.0
+# The raising sites spell this label; the calls-pass skip logic keys on it to
+# tell "the FILE's budget is spent" (abort the pass) from "one query's grant
+# expired" (skip the function and continue, clarion-bf3986e301).
+FILE_BUDGET_EXPIRED_METHOD = "analyze_file budget"
+# Write bound for the fire-and-forget ``$/cancelRequest`` notify after an
+# abandoned query: a healthy pyright drains it in microseconds; a full pipe
+# means cancellation is hopeless anyway and the suppressed write timeout
+# leaves the file budget to backstop.
+CANCEL_WRITE_DEADLINE_SECS = 2.0
+# Last stderr bytes attached to a FINDING_PYRIGHT_RESTART's metadata
+# (clarion-bf3986e301 direction 3): enough to carry a crash reason (OOM kill,
+# node stack trace tail) without bloating the findings channel. The in-memory
+# tail keeps ``STDERR_TAIL_LIMIT`` for future probes; findings carry the tail
+# end of it.
+STDERR_TAIL_FINDING_LIMIT_BYTES = 512
 
 
 def resolve_host_file_watchdog_secs(environ: Mapping[str, str] | None = None) -> float:
@@ -328,7 +357,7 @@ _TYPE_PARAMETER_NODE_NAMES = frozenset({"ParamSpec", "TypeVar", "TypeVarTuple"})
 
 
 if TYPE_CHECKING:
-    from collections.abc import Callable, Mapping, Sequence
+    from collections.abc import Callable, Iterable, Mapping, Sequence
 
 
 class LspTimeoutError(TimeoutError):
@@ -460,6 +489,7 @@ class PyrightSession:
         call_timeout_secs: float = PYRIGHT_CALL_TIMEOUT_SECS,
         file_timeout_base_secs: float = PYRIGHT_FILE_TIMEOUT_BASE_SECS,
         file_timeout_per_function_secs: float = PYRIGHT_FILE_TIMEOUT_PER_FUNCTION_SECS,
+        file_timeout_per_line_secs: float = PYRIGHT_FILE_TIMEOUT_PER_LINE_SECS,
         file_timeout_cap_secs: float = PYRIGHT_FILE_TIMEOUT_CAP_SECS,
         max_restarts_per_run: int = MAX_PYRIGHT_RESTARTS_PER_RUN,
         max_total_restarts_per_run: int = MAX_TOTAL_PYRIGHT_RESTARTS_PER_RUN,
@@ -496,6 +526,7 @@ class PyrightSession:
         self.call_timeout_secs = call_timeout_secs
         self.file_timeout_base_secs = file_timeout_base_secs
         self.file_timeout_per_function_secs = file_timeout_per_function_secs
+        self.file_timeout_per_line_secs = file_timeout_per_line_secs
         self.file_timeout_cap_secs = file_timeout_cap_secs
         self.max_restarts_per_run = max_restarts_per_run
         self.max_total_restarts_per_run = max_total_restarts_per_run
@@ -511,6 +542,12 @@ class PyrightSession:
         self._stderr_thread: threading.Thread | None = None
         self._stderr_tail = bytearray()
         self._next_id = 1
+        # The id of the request currently awaiting its response, for
+        # ``$/cancelRequest`` after an abandoned per-query timeout
+        # (clarion-bf3986e301). Set by ``_request`` before the write, cleared
+        # on a completed round-trip; a timeout leaves it set for the skip
+        # path to consume.
+        self._request_id_in_flight: int | None = None
         self._findings: list[Finding] = []
         self._function_indexes: dict[Path, _FunctionIndex] = {}
         self._index_parse_latency_ms: list[int] = []
@@ -637,15 +674,21 @@ class PyrightSession:
                 coverage=self._unavailable_coverage(),
             )
 
-        deadline = self._deadline_for_file(path, len(index.functions))
+        deadline = self._deadline_for_file(
+            path,
+            len(index.functions),
+            index.source.count("\n") + 1,
+        )
         latency_started = time.perf_counter()
         coverage = FacetCoverage()
         try:
-            edges, unresolved, unresolved_sites, abort = self._resolve_with_pyright(
-                path,
-                index,
-                requested,
-                deadline,
+            edges, unresolved, skipped_builtin, unresolved_sites, skipped_timeouts, abort = (
+                self._resolve_with_pyright(
+                    path,
+                    index,
+                    requested,
+                    deadline,
+                )
             )
         # These two arms remain reachable only from the ``didOpen`` notify
         # that precedes the per-function loop: nothing was visited yet, so
@@ -659,6 +702,7 @@ class PyrightSession:
             )
             edges = []
             unresolved = ast_call_sites_total
+            skipped_builtin = 0
             unresolved_sites = []
             coverage = FacetCoverage.degraded("pyright_timeout", transient=True)
         except (LspTransportClosedError, BrokenPipeError, OSError) as exc:
@@ -667,9 +711,19 @@ class PyrightSession:
             self._record_arrival_death(str(exc))
             edges = []
             unresolved = ast_call_sites_total
+            skipped_builtin = 0
             unresolved_sites = []
             coverage = FacetCoverage.degraded("pyright_restarting", transient=True, collateral=True)
         else:
+            if abort is None and skipped_timeouts and skipped_timeouts == len(requested):
+                # EVERY function timed out: nothing was genuinely answered, so
+                # a ``complete`` claim would be a lie -- and it would reset the
+                # consecutive-timeout streak the ADR-057 wedge breaker needs to
+                # spot a wedged-but-alive server that survives per-function
+                # skip-and-continue. Partial timeouts (some functions resolved)
+                # stay complete with the skipped functions disclosed as
+                # unresolved sites + findings.
+                coverage = FacetCoverage.degraded("pyright_timeout", transient=True)
             if abort is not None:
                 if abort.reason == "pyright_timeout":
                     self._record_finding(
@@ -692,6 +746,7 @@ class PyrightSession:
         return CallResolutionResult(
             edges=edges,
             unresolved_call_sites_total=unresolved,
+            unresolved_call_sites_skipped_builtin_total=skipped_builtin,
             unresolved_call_sites=unresolved_sites,
             pyright_query_latency_ms=[latency_ms],
             pyright_index_parse_latency_ms=self._pop_index_parse_latencies(),
@@ -814,7 +869,11 @@ class PyrightSession:
                 coverage=self._unavailable_coverage(),
             )
 
-        deadline = self._deadline_for_file(path, len(index.functions))
+        deadline = self._deadline_for_file(
+            path,
+            len(index.functions),
+            index.source.count("\n") + 1,
+        )
         latency_started = time.perf_counter()
         coverage = FacetCoverage()
         self._reference_pass_timed_out = False
@@ -881,7 +940,7 @@ class PyrightSession:
         index: _FunctionIndex,
         functions: Sequence[_FunctionInfo],
         deadline: float,
-    ) -> tuple[list[CallsRawEdge], int, list[UnresolvedCallSite], _CallPassAbort | None]:
+    ) -> tuple[list[CallsRawEdge], int, int, list[UnresolvedCallSite], int, _CallPassAbort | None]:
         uri = path.as_uri()
         self._notify(
             "textDocument/didOpen",
@@ -898,9 +957,18 @@ class PyrightSession:
         try:
             edges: list[CallsRawEdge] = []
             unresolved_total = 0
+            skipped_builtin_total = 0
             unresolved_sites: list[UnresolvedCallSite] = []
             abort: _CallPassAbort | None = None
+            skipped_function_timeouts = 0
             remaining_start = len(functions)
+            # A bare call to an unshadowed builtin (``len(x)``, ``str(v)``,
+            # ``isinstance(...)``) can never resolve to a project entity, so
+            # it is neither an unresolved site worth persisting nor evidence
+            # of a resolution gap. Same shadowing-aware oracle the references
+            # pass uses; a star import disables it for the file
+            # (clarion-8a862d8f7e).
+            builtin_names = frozenset(_reference_fast_path_names(index.tree))
             for position, function in enumerate(functions):
                 try:
                     function_edges, resolved_ranges = self._resolve_function_with_pyright(
@@ -910,20 +978,62 @@ class PyrightSession:
                         deadline,
                     )
                 except LspTimeoutError as exc:
-                    abort = _CallPassAbort("pyright_timeout", exc.method, str(exc))
-                    remaining_start = position
-                    break
+                    if (
+                        isinstance(exc, LspWriteTimeoutError)
+                        or exc.method == FILE_BUDGET_EXPIRED_METHOD
+                        or self._file_budget_expired(deadline)
+                    ):
+                        # The FILE's window is spent (or the pipe itself timed
+                        # out, where a "next function" would block the same
+                        # way): abort with the evidence gathered so far.
+                        abort = _CallPassAbort("pyright_timeout", exc.method, str(exc))
+                        remaining_start = position
+                        break
+                    # One query's grant expired with file budget remaining:
+                    # this function alone is unresolved. Cancel the abandoned
+                    # computation so pyright can serve the next function, and
+                    # continue the pass (clarion-bf3986e301) -- one
+                    # pathological function no longer forfeits the file.
+                    self._cancel_in_flight_request()
+                    self._record_finding(
+                        FINDING_PYRIGHT_CALL_RESOLUTION_TIMEOUT,
+                        f"pyright query timed out: {exc.method}; skipped "
+                        f"{function.entity_id} and continued the calls pass",
+                        method=exc.method,
+                        function=function.entity_id,
+                        skipped_function=True,
+                    )
+                    counted, skipped = _unresolved_call_site_total_for_function(
+                        function,
+                        set(),
+                        builtin_names,
+                    )
+                    unresolved_total += counted
+                    skipped_builtin_total += skipped
+                    unresolved_sites.extend(
+                        _unresolved_call_sites_for_function(index, function, set(), builtin_names),
+                    )
+                    skipped_function_timeouts += 1
+                    continue
                 except (LspTransportClosedError, BrokenPipeError, OSError) as exc:
                     abort = _CallPassAbort(self._in_flight_failure_reason(exc), None, str(exc))
                     remaining_start = position
                     break
                 edges.extend(function_edges)
-                unresolved_total += _unresolved_call_site_total_for_function(
+                counted, skipped = _unresolved_call_site_total_for_function(
                     function,
                     resolved_ranges,
+                    builtin_names,
                 )
+                unresolved_total += counted
+                skipped_builtin_total += skipped
                 unresolved_sites.extend(
-                    _unresolved_call_sites_for_function(index, function, resolved_ranges),
+                    _unresolved_call_sites_for_function(
+                        index,
+                        function,
+                        resolved_ranges,
+                        builtin_names,
+                    ),
                 )
             if abort is not None:
                 # INVARIANT: this fallback is only correct because a function is
@@ -938,11 +1048,24 @@ class PyrightSession:
                 # its sites unresolved); track "functions with edges appended"
                 # explicitly instead of relying on ``position`` if you add one.
                 for function in functions[remaining_start:]:
-                    unresolved_total += _unresolved_call_site_total_for_function(function, set())
+                    counted, skipped = _unresolved_call_site_total_for_function(
+                        function,
+                        set(),
+                        builtin_names,
+                    )
+                    unresolved_total += counted
+                    skipped_builtin_total += skipped
                     unresolved_sites.extend(
-                        _unresolved_call_sites_for_function(index, function, set()),
+                        _unresolved_call_sites_for_function(index, function, set(), builtin_names),
                     )
-            return edges, unresolved_total, unresolved_sites, abort
+            return (
+                edges,
+                unresolved_total,
+                skipped_builtin_total,
+                unresolved_sites,
+                skipped_function_timeouts,
+                abort,
+            )
         finally:
             # The pipe may be the very thing that just failed: a notify over a
             # dead transport must not raise and discard the evidence above.
@@ -1024,7 +1147,7 @@ class PyrightSession:
                 edge["properties"] = {"candidates": candidate_ids}
             function_edges.append(edge)
 
-        return function_edges, set(grouped)
+        return function_edges, _resolved_call_site_keys(function, grouped)
 
     def _resolve_references_with_pyright(
         self,
@@ -1184,11 +1307,11 @@ class PyrightSession:
         """The clock every deadline lives on (monotonic; overridable in tests)."""
         return time.monotonic()
 
-    def _deadline_for_file(self, path: Path, n_functions: int) -> float:
+    def _deadline_for_file(self, path: Path, n_functions: int, n_lines: int) -> float:
         existing = self._file_deadlines.get(path)
         if existing is not None:
             return existing
-        deadline = self._now() + self._file_timeout_for(n_functions)
+        deadline = self._now() + self._file_timeout_for(n_functions, n_lines)
         anchor = self._file_started_at.get(path)
         if anchor is not None:
             # A spawn paid before this point (first file, or a restart) has
@@ -1214,15 +1337,17 @@ class PyrightSession:
             return math.inf
         return self._watchdog_ceiling_for(anchor) - self._now()
 
-    def _file_timeout_for(self, n_functions: int) -> float:
-        budget = self.file_timeout_base_secs + self.file_timeout_per_function_secs * n_functions
-        return min(budget, self.file_timeout_cap_secs)
+    def _file_timeout_for(self, n_functions: int, n_lines: int) -> float:
+        scaled = max(
+            self.file_timeout_per_function_secs * n_functions,
+            self.file_timeout_per_line_secs * n_lines,
+        )
+        return min(self.file_timeout_base_secs + scaled, self.file_timeout_cap_secs)
 
     def _budgeted_timeout(self, deadline: float) -> float:
         remaining = deadline - self._now()
         if remaining <= 0:
-            method = "analyze_file budget"
-            raise LspTimeoutError(method)
+            raise LspTimeoutError(FILE_BUDGET_EXPIRED_METHOD)
         return min(self.call_timeout_secs, remaining)
 
     def _write_deadline(self, deadline: float) -> float:
@@ -1242,8 +1367,7 @@ class PyrightSession:
 
     def _ensure_file_budget(self, deadline: float) -> None:
         if self._file_budget_expired(deadline):
-            method = "analyze_file budget"
-            raise LspTimeoutError(method)
+            raise LspTimeoutError(FILE_BUDGET_EXPIRED_METHOD)
 
     def _file_budget_expired(self, deadline: float) -> bool:
         return deadline - self._now() <= 0
@@ -1384,6 +1508,7 @@ class PyrightSession:
             file_attributed_restart_count=self._run_state.file_attributed_restart_count,
             attribution="arrival",
             reason=reason,
+            stderr_tail=self._stderr_tail_snapshot(),
         )
 
     def _charge_run_level_restart(self, reason: str, *, attribution: str) -> bool:
@@ -1495,8 +1620,14 @@ class PyrightSession:
         """
         state = self._run_state
         state.file_attributed_restart_count += 1
+        # Snapshot before any restart path terminates the process, which
+        # clears the tail (clarion-bf3986e301: attribute the NEXT crash class
+        # without a manual probe).
+        stderr_tail = self._stderr_tail_snapshot()
         if self._total_restart_budget_exceeded():
-            self._record_in_flight_restart_finding(reason, outcome="cap_exceeded")
+            self._record_in_flight_restart_finding(
+                reason, outcome="cap_exceeded", stderr_tail=stderr_tail
+            )
             self._trip_total_restart_cap(reason)
             return
         outcome = self._restart_process_for_file(path)
@@ -1505,9 +1636,11 @@ class PyrightSession:
             # spawn path already triaged it -- a transient deferral (next file
             # retries) or a permanent disable with its OWN ``disabled_reason``.
             state.file_attributed_respawn_failure_count += 1
-        self._record_in_flight_restart_finding(reason, outcome=outcome)
+        self._record_in_flight_restart_finding(reason, outcome=outcome, stderr_tail=stderr_tail)
 
-    def _record_in_flight_restart_finding(self, reason: str, *, outcome: str) -> None:
+    def _record_in_flight_restart_finding(
+        self, reason: str, *, outcome: str, stderr_tail: str
+    ) -> None:
         self._record_finding(
             FINDING_PYRIGHT_RESTART,
             f"pyright subprocess died during this file's request; {outcome}",
@@ -1516,6 +1649,7 @@ class PyrightSession:
             attribution="in_flight",
             outcome=outcome,
             reason=reason,
+            stderr_tail=stderr_tail,
         )
 
     def _restart_process_for_file(self, path: Path) -> _RestartOutcome:
@@ -1563,9 +1697,20 @@ class PyrightSession:
         process = self._process
         self._process = None
         if process is not None and process.poll() is None:
+            # The venv's ``pyright-langserver`` is a Python wrapper around a
+            # ``node`` grandchild; killing the wrapper alone leaves node
+            # behind, reparented to pid 1 and -- when wedged, which is why we
+            # are killing it -- spinning forever (clarion-ebf404dfbb). Walk
+            # the descendants BEFORE the kill (they are reparented the moment
+            # the wrapper dies), then kill wrapper and descendants.
+            pid = getattr(process, "pid", None)
+            descendants = _descendant_pids(pid) if isinstance(pid, int) else []
             process.kill()
             with contextlib.suppress(subprocess.TimeoutExpired):
                 process.wait(timeout=2)
+            for pid in descendants:
+                with contextlib.suppress(ProcessLookupError, PermissionError):
+                    os.kill(pid, signal.SIGKILL)
         if self._stderr_thread is not None:
             self._stderr_thread.join(timeout=2)
             self._stderr_thread = None
@@ -1818,6 +1963,7 @@ class PyrightSession:
         # One deadline for the whole request, write included: the write is the
         # half that blocked on elspeth (clarion-e3ab8a4131).
         deadline = self._now() + timeout_secs
+        self._request_id_in_flight = request_id
         self._write_message(
             {
                 "jsonrpc": "2.0",
@@ -1843,6 +1989,7 @@ class PyrightSession:
                 continue
             if response.get("id") != request_id:
                 continue
+            self._request_id_in_flight = None
             if "error" in response:
                 raise LspTransportClosedError(str(response["error"]))
             process.poll()
@@ -2001,8 +2148,13 @@ class PyrightSession:
         if index.parse_status == "syntax_error":
             return None
         key = _range_start_key(raw_selection)
-        if key is not None and key in index.by_name_position:
-            return index.by_name_position[key].entity_id
+        # Functions AND classes: pyright reports ``Name(...)`` naming a class
+        # as an outgoing call whose target item IS the class (selection range
+        # on the class name) -- never its ``__init__`` -- so an instantiation
+        # is a ``calls`` edge to the class entity (clarion-e5224c3aff). The
+        # function-only index dropped every such target as unresolved.
+        if key is not None and key in index.entity_by_name_position:
+            return index.entity_by_name_position[key]
         return _containing_function_id(index, raw_selection)
 
     def _is_internal_project_path(self, path: Path) -> bool:
@@ -2022,6 +2174,42 @@ class PyrightSession:
         self._index_parse_latency_ms.append(index.parse_latency_ms)
         return index
 
+    def _cancel_in_flight_request(self) -> None:
+        """Fire-and-forget ``$/cancelRequest`` for an abandoned query.
+
+        pyright honours LSP cancellation between evaluation steps, so telling
+        it the caller stopped waiting lets it drop the pathological
+        computation and answer the NEXT function's query instead of chewing
+        through the rest of the file's budget behind our back
+        (clarion-bf3986e301). Best-effort by design: a transport already
+        broken, or a pipe already full, means the file budget backstops --
+        every failure here is suppressed. (A partial-write timeout still
+        invalidates the frame inside ``_write_message``, so a corrupted
+        stream is put down rather than limped on.)
+        """
+        request_id = self._request_id_in_flight
+        self._request_id_in_flight = None
+        if request_id is None:
+            return
+        with contextlib.suppress(
+            LspTimeoutError, LspTransportClosedError, BrokenPipeError, OSError
+        ):
+            self._notify(
+                "$/cancelRequest",
+                {"id": request_id},
+                deadline=self._now() + CANCEL_WRITE_DEADLINE_SECS,
+            )
+
+    def _stderr_tail_snapshot(self) -> str:
+        """The last stderr bytes of the CURRENT process, finding-sized.
+
+        Callers must snapshot BEFORE ``_terminate_process``, which clears the
+        tail so two processes' stderr never mix in one finding.
+        """
+        return bytes(self._stderr_tail[-STDERR_TAIL_FINDING_LIMIT_BYTES:]).decode(
+            "utf-8", "replace"
+        )
+
     def _record_finding(self, subcode: str, message: str, **metadata: object) -> None:
         self._findings.append(
             {
@@ -2375,6 +2563,38 @@ def _reference_accumulator_to_edge(
     return edge
 
 
+def _descendant_pids(pid: int) -> list[int]:
+    """Every live descendant of ``pid`` via ``/proc/<pid>/task/*/children``.
+
+    Linux only (``CONFIG_PROC_CHILDREN``, on by default); elsewhere, or once
+    the process is gone, the walk yields nothing and only the direct child
+    is killed -- the pre-existing behaviour.
+    """
+    found: list[int] = []
+    frontier = [pid]
+    while frontier:
+        parent = frontier.pop()
+        task_dir = Path("/proc") / str(parent) / "task"
+        try:
+            tasks = list(task_dir.iterdir())
+        except OSError:
+            continue
+        for task in tasks:
+            try:
+                listed = (task / "children").read_text(encoding="ascii").split()
+            except OSError:
+                continue
+            for raw in listed:
+                try:
+                    child = int(raw)
+                except ValueError:
+                    continue
+                if child not in found:
+                    found.append(child)
+                    frontier.append(child)
+    return found
+
+
 def _function_call_sites(
     node: ast.FunctionDef | ast.AsyncFunctionDef,
     source_lines: Sequence[str],
@@ -2385,27 +2605,88 @@ def _function_call_sites(
     return visitor.call_sites
 
 
+def _is_builtin_call_site(call_site: _CallSite, builtin_names: frozenset[str]) -> bool:
+    """A bare ``Name(...)`` call whose name is an unshadowed builtin in this file.
+
+    Attribute calls (``pytest.raises``) are deliberately NOT matched: they may
+    resolve to an external module (counted by the external skip) or, under a
+    rebinding, to a project entity -- only pyright can tell.
+    """
+    return call_site.callee_expr in builtin_names
+
+
+def _resolved_call_site_keys(
+    function: _FunctionInfo,
+    resolved_ranges: Iterable[tuple[int, int, int, int]],
+) -> set[tuple[int, int, int, int]]:
+    """The AST call-site keys the resolved ranges account for.
+
+    pyright anchors an outgoing call's ``fromRange`` on the callee's terminal
+    token (``helper`` in ``self.helper()``), while ``_CallSite`` spans the
+    whole callee expression (``self.helper``). Matching the two by equality
+    only ever succeeded for bare ``Name()`` calls, so every resolved attribute
+    call was also reported as an unresolved site -- breaking the partition
+    (resolved + unresolved + skipped builtins == AST call sites) the host and
+    ``entity_callers_list``'s ``traversal_complete`` depend on. A range
+    resolves the SMALLEST call site containing it: in ``Svc().helper()`` the
+    ``Svc`` token claims the inner site and ``helper`` the outer one.
+    """
+    sites_by_line: dict[int, list[_CallSite]] = {}
+    for site in function.call_sites:
+        for line in range(site.line, site.end_line + 1):
+            sites_by_line.setdefault(line, []).append(site)
+    resolved: set[tuple[int, int, int, int]] = set()
+    for start_line, start_character, end_line, end_character in resolved_ranges:
+        best: _CallSite | None = None
+        for site in sites_by_line.get(start_line, ()):
+            if (site.line, site.character) > (start_line, start_character):
+                continue
+            if (end_line, end_character) > (site.end_line, site.end_character):
+                continue
+            if best is None or (site.end_line - site.line, site.end_character - site.character) < (
+                best.end_line - best.line,
+                best.end_character - best.character,
+            ):
+                best = site
+        if best is not None:
+            resolved.add((best.line, best.character, best.end_line, best.end_character))
+    return resolved
+
+
 def _unresolved_call_site_total_for_function(
     function: _FunctionInfo,
     resolved_ranges: set[tuple[int, int, int, int]],
-) -> int:
-    return sum(
-        1
-        for call_site in function.call_sites
-        if (
+    builtin_names: frozenset[str] = frozenset(),
+) -> tuple[int, int]:
+    """``(unresolved, skipped_builtin)`` for one function's call sites.
+
+    The two are disjoint and, with the resolved sites, partition the AST call
+    sites; the host treats the unresolved-site LIST as authoritative only when
+    its length equals ``unresolved``, so a builtin skip must leave both.
+    """
+    unresolved = 0
+    skipped_builtin = 0
+    for call_site in function.call_sites:
+        range_key = (
             call_site.line,
             call_site.character,
             call_site.end_line,
             call_site.end_character,
         )
-        not in resolved_ranges
-    )
+        if range_key in resolved_ranges:
+            continue
+        if _is_builtin_call_site(call_site, builtin_names):
+            skipped_builtin += 1
+            continue
+        unresolved += 1
+    return unresolved, skipped_builtin
 
 
 def _unresolved_call_sites_for_function(
     index: _FunctionIndex,
     function: _FunctionInfo,
     resolved_ranges: set[tuple[int, int, int, int]],
+    builtin_names: frozenset[str] = frozenset(),
 ) -> list[UnresolvedCallSite]:
     unresolved: list[UnresolvedCallSite] = []
     for site_ordinal, call_site in enumerate(function.call_sites):
@@ -2417,6 +2698,8 @@ def _unresolved_call_sites_for_function(
         )
         if range_key in resolved_ranges:
             continue
+        if _is_builtin_call_site(call_site, builtin_names):
+            continue
         if len(call_site.callee_expr.encode("utf-8")) > MAX_UNRESOLVED_CALLEE_EXPR_BYTES:
             continue
         start_byte = _position_to_byte(index, call_site.line, call_site.character)

loomweave_plugin_python/server.py

@@ -35,7 +35,7 @@ from loomweave_plugin_python.pyright_session import PyrightRunState, PyrightSess
 from loomweave_plugin_python.stdout_guard import install_stdio
 from loomweave_plugin_python.wardline_descriptor import WardlineVocabulary, load_wardline_descriptor
 
-ONTOLOGY_VERSION = "0.12.0"
+ONTOLOGY_VERSION = "0.13.0"
 
 # Plugin-side Content-Length sanity cap. Matches the host's ADR-021 §2b
 # default (8 MiB) so the plugin never emits a frame the host would kill us
@@ -212,6 +212,7 @@ def handle_analyze_file(params: dict[str, Any], state: ServerState) -> dict[str,
     """Read the requested file, extract entities + edges, return AnalyzeFileResult shape."""
     empty_stats = {
         "unresolved_call_sites_total": 0,
+        "unresolved_call_sites_skipped_builtin_total": 0,
         "unresolved_call_sites": [],
         "reference_sites_total": 0,
         "references_resolved_total": 0,
@@ -258,6 +259,9 @@ def handle_analyze_file(params: dict[str, Any], state: ServerState) -> dict[str,
         state.pyright_files_since_restart = 0
     stats = {
         "unresolved_call_sites_total": result.stats.unresolved_call_sites_total,
+        "unresolved_call_sites_skipped_builtin_total": (
+            result.stats.unresolved_call_sites_skipped_builtin_total
+        ),
         "unresolved_call_sites": result.stats.unresolved_call_sites,
         "reference_sites_total": result.stats.reference_sites_total,
         "references_resolved_total": result.stats.references_resolved_total,

{loomweave_plugin_python-1.5.1.data → loomweave_plugin_python-1.6.0.data}/data/share/loomweave/plugins/python/plugin.toml

@@ -1,7 +1,7 @@
 [plugin]
 name = "loomweave-plugin-python"
 plugin_id = "python"
-version = "1.5.1"
+version = "1.6.0"
 protocol_version = "1.0"
 # Bare basename per ADR-021 §Layer 1 + WP2 scrub commit eb0a41d — the host
 # refuses manifests whose `executable` carries any path component.
@@ -57,13 +57,17 @@ rule_id_prefix = "LMWV-PY-"
 # runner-wrapper, `sys.argv`, and argparse `cli-command` tagging; 0.12.0
 # declares the complete static classifier set so supported-empty results are
 # distinguishable from unsupported classifiers and forces unchanged files to
-# re-dispatch. Classifier declarations do not create entity-tag rows. NOTE:
+# re-dispatch. Classifier declarations do not create entity-tag rows. 0.13.0
+# widens `calls` targets to class entities: an instantiation ``Name(...)``
+# is a call to the class (clarion-e5224c3aff) -- a semantic widening of an
+# existing kind, bumped so unchanged files re-dispatch and pick up the edges.
+# NOTE:
 # ADR-007's summary-cache key is the 5-tuple (entity_id, content_hash,
 # prompt_template_id, model_tier, guidance_fingerprint) — ontology_version is
 # handshake-validation, NOT a cache-key component. New edge rows miss the
 # cache by component-1 of the 5-tuple organically (no edges live in the
 # 5-tuple yet anyway).
-ontology_version = "0.12.0"
+ontology_version = "0.13.0"
 classifier_tags = [
     "cli-command",
     "data-model",

{loomweave_plugin_python-1.5.1.dist-info → loomweave_plugin_python-1.6.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: loomweave-plugin-python
-Version: 1.5.1
+Version: 1.6.0
 Summary: Loomweave Python language plugin — v1.0 release
 Author-email: John Morrissey <qacona@gmail.com>
 Classifier: Development Status :: 4 - Beta

loomweave_plugin_python-1.6.0.dist-info/RECORD

@@ -0,0 +1,18 @@
+loomweave_plugin_python/__init__.py,sha256=5mhialMRwU5-O9sz_IX8_mGzsMX1RYvQJAwawhAXlr0,95
+loomweave_plugin_python/__main__.py,sha256=oy1S1Ru7WdX6jcAVhsqNI25LxAbQq3jHBlETBt20fyM,376
+loomweave_plugin_python/call_resolver.py,sha256=sc4b-h1CLcaPF1wu7CpQ5nDh75O7xaZokqe_PRS8bcE,5130
+loomweave_plugin_python/entity_id.py,sha256=l7_5yyh6WVH9xIzrQVCDb2GmBMhovOVmuQezcZIVf8k,2691
+loomweave_plugin_python/extractor.py,sha256=hGjyLvYGJF4XbyvAfwxnkfQQB6h4U0--uT-ndUwvbGE,102488
+loomweave_plugin_python/interpreter.py,sha256=mWrxnNN6eMQUR0TUT4uxA5bzL48lyqR7KHgtEF7T8os,4320
+loomweave_plugin_python/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+loomweave_plugin_python/pyright_session.py,sha256=Yf-5W8qWX1hC3kv1mjshrxOS0MGC1sKKivJG1r-gMK0,139286
+loomweave_plugin_python/qualname.py,sha256=gk6N2e4tMvufnPgpVZLv--c9_9gW5y9YvJIwUArffFg,2102
+loomweave_plugin_python/reference_resolver.py,sha256=yp9Ff59A130mEn5txCh7jpVcpjQjy1EmXFoUhdyA4as,2830
+loomweave_plugin_python/server.py,sha256=wiTi98XaFa3LKo_OnGtRWpwM4UuOYXHePS6wwzu3FlM,14079
+loomweave_plugin_python/stdout_guard.py,sha256=tUzcXyvXuy3-dXB81_xCNk8KWE3mqtsWSge81KPDhKg,2007
+loomweave_plugin_python/wardline_descriptor.py,sha256=4TX7PCZLyYVI3dd4xT98ueNEcYpUd8OV0oyOJO0wseE,16354
+loomweave_plugin_python-1.6.0.data/data/share/loomweave/plugins/python/plugin.toml,sha256=O0onhlYaXi3mdt7XBsuAnsXg2xYOSEEkpzFgreyZ4FE,5218
+loomweave_plugin_python-1.6.0.dist-info/METADATA,sha256=CyALXx3Vp0cWUG6jlBff_rXB1F7x8l9LJMwgX5JrPpw,4885
+loomweave_plugin_python-1.6.0.dist-info/WHEEL,sha256=zOwg4jB6zX2kU910N-cMawjivD6tO8NEWvE12je1bVk,87
+loomweave_plugin_python-1.6.0.dist-info/entry_points.txt,sha256=X1DQOYU5o1z2lBOJoh9JgQR5pg9fd_Yd8KozTHdfZqA,82
+loomweave_plugin_python-1.6.0.dist-info/RECORD,,

loomweave_plugin_python-1.5.1.dist-info/RECORD

@@ -1,18 +0,0 @@
-loomweave_plugin_python/__init__.py,sha256=kMw1zndW_xa7Jd0dYOYPhgeFazYz1eeXt5CsZkl_-Us,95
-loomweave_plugin_python/__main__.py,sha256=oy1S1Ru7WdX6jcAVhsqNI25LxAbQq3jHBlETBt20fyM,376
-loomweave_plugin_python/call_resolver.py,sha256=JorafhgCDP8LlHJFcBiWbeU8_2HdBLtwsfgdDHZtUiM,4931
-loomweave_plugin_python/entity_id.py,sha256=l7_5yyh6WVH9xIzrQVCDb2GmBMhovOVmuQezcZIVf8k,2691
-loomweave_plugin_python/extractor.py,sha256=7sYCohPMvYV39WTO8gZW5iDqIEGqvoOVgHijbR148ng,102292
-loomweave_plugin_python/interpreter.py,sha256=mWrxnNN6eMQUR0TUT4uxA5bzL48lyqR7KHgtEF7T8os,4320
-loomweave_plugin_python/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-loomweave_plugin_python/pyright_session.py,sha256=VdtdHdzAQGGKf0x1p8kBhea_sdv4ISUqMHgNiEX0RKg,125134
-loomweave_plugin_python/qualname.py,sha256=gk6N2e4tMvufnPgpVZLv--c9_9gW5y9YvJIwUArffFg,2102
-loomweave_plugin_python/reference_resolver.py,sha256=yp9Ff59A130mEn5txCh7jpVcpjQjy1EmXFoUhdyA4as,2830
-loomweave_plugin_python/server.py,sha256=WBaiEQwrhw8iA8m5FyOuJQ_ydRLJJ1GIwa64DOFHQ1w,13884
-loomweave_plugin_python/stdout_guard.py,sha256=tUzcXyvXuy3-dXB81_xCNk8KWE3mqtsWSge81KPDhKg,2007
-loomweave_plugin_python/wardline_descriptor.py,sha256=4TX7PCZLyYVI3dd4xT98ueNEcYpUd8OV0oyOJO0wseE,16354
-loomweave_plugin_python-1.5.1.data/data/share/loomweave/plugins/python/plugin.toml,sha256=Zh4v74rc03Ha9BGIqJx2NuxP5ZM8tyGnWD6Kf_rCtF4,4981
-loomweave_plugin_python-1.5.1.dist-info/METADATA,sha256=kNzUfBMP5OgHwHSycUd6JIctPbRwLb2bNCxW8fCqtUg,4885
-loomweave_plugin_python-1.5.1.dist-info/WHEEL,sha256=zOwg4jB6zX2kU910N-cMawjivD6tO8NEWvE12je1bVk,87
-loomweave_plugin_python-1.5.1.dist-info/entry_points.txt,sha256=X1DQOYU5o1z2lBOJoh9JgQR5pg9fd_Yd8KozTHdfZqA,82
-loomweave_plugin_python-1.5.1.dist-info/RECORD,,