sourcecode 4.15.0__py3-none-any.whl → 4.16.0__py3-none-any.whl

sourcecode/__init__.py

@@ -4,4 +4,4 @@ ASK Engine is the product. ``ask`` is the canonical CLI command; ``sourcecode``
 the legacy compatibility alias and the Python/PyPI package name. See
 docs/PRODUCT_IDENTITY.md (normative)."""
 
-__version__ = "4.15.0"
+__version__ = "4.16.0"

sourcecode/cli.py

@@ -8230,6 +8230,14 @@ def spring_audit_cmd(
             cir = ContextGraph.build(
                 file_list, target, progress=_work_sink(_prog)
             ).cir
+            # C3-85: the stretch between the last `linking` tick and the first rule
+            # tick reports nothing, and what stays on the line is `n/n` — a counter
+            # that finished, reading as a stage still running. Measured on keycloak
+            # (5 486 files, warm): **8,2 s of a 24 s run, 34 %**, all of it here.
+            # It has no population to count — it is one walk that builds the model
+            # every rule then reads — so it is named, which is what C3-56 does for
+            # a stage whose denominator would have to be invented.
+            _prog.update(f"building the semantic model over {len(file_list)} Java files")
             _model = SpringSemanticModel.build(cir)
             _run.checkpoint("ir")
             # The IR is built; the rule passes are the work now, and they are not
@@ -8353,37 +8361,15 @@ def spring_audit_cmd(
 
             data = combined.to_compact_dict() if compact else combined.to_dict()
             if _stopped_early:
-                data["_partial"] = _run.status(_stopped_early)
-                if _rules_partial:
-                    # C3-79: neither run nor not-run. How far it got is what a
-                    # reader needs to decide whether to re-run with more time, and
-                    # the findings it produced before the cut are in the payload.
-                    data["_partial"]["rules_partially_run"] = _rules_partial
-                    data["_partial"]["how_to_read"] += (
-                        " One rule family was stopped part-way through its own "
-                        "population: "
-                        + "; ".join(
-                            f"{'/'.join(entry['rule_ids'])} after "
-                            f"{entry['units_done']} of {entry['units_total']} "
-                            f"{entry['unit']}"
-                            for entry in _rules_partial
-                        )
-                        + ". What it found before the cut is reported and is a floor."
-                    )
-                if _rules_cut:
-                    # C3-71: a phase stopped *inside* is neither completed nor
-                    # pending, and calling it either would misreport the run. The
-                    # families it did not reach are named instead.
-                    data["_partial"]["rules_not_run"] = _rules_cut
-                    # A phase that was stopped inside is in neither list, and
-                    # putting it in `phases_pending` alone would claim none of it
-                    # ran when most of it did.
-                    data["_partial"]["phases_stopped_inside"] = _phases_cut
-                    data["_partial"]["how_to_read"] += (
-                        " The rule pass was stopped between families: "
-                        f"{', '.join(_rules_cut)} did not run, so every count here "
-                        "is a floor over the families that did."
-                    )
+                # C3-87: the block is composed by `PhasedRun.status`, which is the
+                # authority `risk` is now bound to as well — one vocabulary for
+                # "the budget cut this run", not one per command.
+                data["_partial"] = _run.status(
+                    _stopped_early,
+                    rules_partially_run=_rules_partial,
+                    rules_not_run=_rules_cut,
+                    phases_stopped_inside=_phases_cut,
+                )
 
             # Non-fatal RIS side-effect — persist summary only (not full findings).
             try:
@@ -8949,10 +8935,18 @@ def risk_cmd(
                 profiles=_profile_set(profile),
                 # C3-73: 54 minutes with one line on stderr in the field. The
                 # factory hands the composer an observer per counted stage.
+                #
+                # C3-87: and the observer carries the deadline. This factory built
+                # its observers with no `stop_when` for four releases, so `risk`
+                # declared `budget_seconds` on the run above and then never asked
+                # whether it was spent — the budget was honoured only between the
+                # two phases. `PhasedRun.exhausted` stays the one authority; what
+                # is new is that the second consumer asks it.
                 progress=lambda stage, unit="rule families": _rule_pass_progress(
-                    _prog, stage, unit
+                    _prog, stage, unit, stop_when=_run.exhausted
                 ),
                 checkpoint=_run.checkpoint,
+                partial_status=lambda **cut: _run.status(_WHY_BUDGET, **cut),
             )
         finally:
             _prog.stop()
@@ -8969,6 +8963,9 @@ def risk_cmd(
         success_msg=(
             f"risk written to {output_path} ({data['shown']} of "
             f"{data['total_defects']} defects composed)"
+            # C3-87: the terminal says it too. A reader who never opens the payload
+            # must not take a truncated ranking for the repository's risk.
+            + (" — PARTIAL, budget exhausted" if data.get("partial") else "")
         ),
     )
     # The complete answer is on disk; the checkpoint that stood in for it is not

sourcecode/phased_run.py

@@ -131,8 +131,29 @@ class PhasedRun:
         done = set(self.completed)
         return [p for p in self.phases if p not in done]
 
-    def status(self, why: str) -> dict:
-        """The block an incomplete answer carries, and nothing else does."""
+    def status(
+        self,
+        why: str,
+        *,
+        rules_partially_run: "Optional[list[dict]]" = None,
+        rules_not_run: "Optional[list[str]]" = None,
+        phases_stopped_inside: "Optional[list[str]]" = None,
+    ) -> dict:
+        """The block an incomplete answer carries, and nothing else does.
+
+        **C3-87.** The three rule-pass keys used to be assembled by the caller, and
+        for four releases there was exactly one caller, so "the caller" and "the
+        authority" were the same object by accident. When `risk` was bound to the
+        same budget it became clear what that costs: a second consumer either
+        duplicates thirty lines of `how_to_read` composition or publishes a
+        different vocabulary for the same fact. They live here now, so a command
+        that stops inside its rule pass describes it the one way — and a *third*
+        consumer gets it by construction.
+
+        Each key is present only when there is something to say. A run stopped
+        between phases, with no family cut, produces exactly the block it produced
+        before this seam existed.
+        """
         out: dict[str, Any] = {
             "schema_version": SCHEMA_VERSION,
             "partial": True,
@@ -147,6 +168,38 @@ class PhasedRun:
             out["budget_seconds"] = float(self.budget_seconds)
             if self.budget_source:
                 out["budget_source"] = self.budget_source
+        if rules_partially_run:
+            # C3-79: neither run nor not-run. How far it got is what a reader needs
+            # in order to decide whether to re-run with more time, and the findings
+            # it produced before the cut are in the payload.
+            out["rules_partially_run"] = list(rules_partially_run)
+            out["how_to_read"] += (
+                " One rule family was stopped part-way through its own "
+                "population: "
+                + "; ".join(
+                    f"{'/'.join(entry['rule_ids'])} after "
+                    f"{entry['units_done']} of {entry['units_total']} "
+                    f"{entry['unit']}"
+                    for entry in rules_partially_run
+                )
+                + ". What it found before the cut is reported and is a floor."
+            )
+        if phases_stopped_inside:
+            # C3-71: a phase stopped *inside* is neither completed nor pending, and
+            # putting it in `phases_pending` alone would claim none of it ran when
+            # most of it did. Independent of the rule keys: a phase can be cut in a
+            # walk that evaluates no rules at all, which is how `risk` loses its
+            # composition join (C3-87).
+            out["phases_stopped_inside"] = list(phases_stopped_inside)
+        if rules_not_run:
+            # The families it did not reach are named, so the answer states a gap
+            # rather than an absence of findings.
+            out["rules_not_run"] = list(rules_not_run)
+            out["how_to_read"] += (
+                " The rule pass was stopped between families: "
+                f"{', '.join(rules_not_run)} did not run, so every count here "
+                "is a floor over the families that did."
+            )
         return out
 
     # -- checkpoints -------------------------------------------------------

sourcecode/progress.py

@@ -178,6 +178,10 @@ class Progress:
         self._unit = "files"
         self._stage = ""
         self._stage_t0 = time.monotonic()
+        #: When the counted state last *advanced* (C3-86). Distinct from
+        #: `_stage_t0`, which is when the stage began: a stage can begin, count to
+        #: 3 340 of 3 342, and then stand still while an uncounted walk runs.
+        self._count_t0 = time.monotonic()
         #: When a heartbeat line was last written, by either emitter (C3-80). One
         #: stamp is what keeps the loop and the in-band beat from double-printing.
         self._last_emit = 0.0
@@ -227,6 +231,7 @@ class Progress:
             self._total = 0
             self._stage = ""
             self._estimate = True
+            self._count_t0 = time.monotonic()
         # C3-80: a new phase is the most informative thing this line can say, and
         # the phase that follows it may be the long one.
         self._beat()
@@ -262,6 +267,11 @@ class Progress:
         rule `_eta_seconds` already applies to a stage that has barely started.
         """
         with self._lock:
+            # C3-86: read before anything is mutated — the clock the *staleness* of
+            # a line is measured against only restarts when the state it reports
+            # actually changed.
+            if (done, total, stage) != (self._done, self._total, self._stage):
+                self._count_t0 = time.monotonic()
             if stage != self._stage or done < self._done:
                 self._stage = stage
                 self._stage_t0 = time.monotonic()
@@ -407,6 +417,19 @@ class Progress:
                 self._done, self._total, self._unit, self._stage
             )
             eta = self._eta_seconds(done, total)
+            # C3-86: how long this count has stood still. The field read
+            # `3340/3342 java files eta=0.5s` **fourteen minutes** after the
+            # counter last advanced, and both halves of that line are claims the
+            # run cannot support: it asserts the stage is 99,9 % done *now*, and
+            # the rate behind the ETA is computed over a window in which nothing
+            # happened — so the longer the stall lasts, the more imminent the
+            # finish looks. A count that has not moved for a whole interval says
+            # so and withholds the estimate, which is the rule `_eta_seconds`
+            # already applies to a stage too young to extrapolate from.
+            stalled = time.monotonic() - self._count_t0
+        stale = total > 0 and stalled >= self._interval
+        if stale:
+            eta = None
         counted = f"{done}/{total} {unit}" if total > 0 else ""
         if self._line_mode:
             line = f"[ask] progress phase={phase}"
@@ -415,6 +438,8 @@ class Progress:
             if counted:
                 line += f" {counted}"
             line += f" elapsed={_duration(elapsed)}"
+            if stale:
+                line += f" unchanged_for={_duration(stalled)}"
             if eta is not None:
                 # Named, not implied: the estimate covers the counted stage.
                 # Nothing here knows the cost of the stages after it, and a
@@ -426,6 +451,8 @@ class Progress:
             if counted:
                 shown += f" {counted}"
             tail = f"{elapsed:.1f}s"
+            if stale:
+                tail += f", unchanged for {_duration(stalled)}"
             if eta is not None:
                 tail += f", eta {_duration(eta)}"
             line = f"\r\033[K{frame} {shown} ({tail})"

sourcecode/repository_ir.py

@@ -5538,6 +5538,14 @@ def build_repo_ir(
             )
         )
 
+    # C3-85: from here to the end of the build there is no per-file loop, so the
+    # heartbeat kept `linking n/n` on screen — a counter that finished, reading as
+    # a stage still running. Measured on keycloak (5 486 files, warm), the stretch
+    # between the last `linking` tick and the first rule tick was **8,2 s of a 24 s
+    # run**. These stages have no population to count; they are named, which is
+    # what C3-56 does rather than invent a denominator.
+    if progress is not None:
+        progress(0, 0, "assembling the IR")
     spring_summary = _build_spring_summary(all_symbols)
 
     # Deduplicate relations
@@ -5570,6 +5578,8 @@ def build_repo_ir(
     # when `since` is set). Done here, where `root` is available; placed before the
     # XML-security retag so spec routes lacking security get the same treatment.
     if route_diffs_arg is None:
+        if progress is not None:
+            progress(0, 0, "recovering spec-declared routes")
         _routed_fqns_ir = {
             r.get("effective_class")
             for r in (ir.get("route_surface") or [])
@@ -5597,6 +5607,8 @@ def build_repo_ir(
         r'|xmlns:security="http://www\.springframework\.org/schema/security")',
         re.IGNORECASE,
     )
+    if progress is not None:
+        progress(0, 0, "scanning XML security configuration")
     _xml_sec_detected = False
     for _xml_glob in (
         "*security*.xml", "*Security*.xml",

sourcecode/risk.py

@@ -788,6 +788,14 @@ class RiskComposer:
         # caller owns — `(stage, unit) -> RulePassProgress | None` — so this module
         # never learns what a spinner is and a run nobody watches pays nothing.
         self._progress = progress
+        # C3-87: the observers are kept, not discarded. Each one holds what the
+        # operator's budget cut out of the pass it watched, and until this command
+        # was bound to the budget there was nothing to keep: `stop_when` was never
+        # passed, so `should_stop()` answered False for the life of the run and the
+        # deadline could only ever be observed on the boundary between two phases.
+        # The field measured what that costs on one machine under one 420 s
+        # budget — `spring-audit` 1,94× over, `risk` 6,8× over.
+        self._rule_watchers: "list[Any]" = []
         if findings is None:
             findings = list(run_tx_audit(
                 self.cir, root=self.root, model=self.model,
@@ -801,7 +809,21 @@ class RiskComposer:
             )
         self.findings = findings
 
+        # C3-85: everything from here to the composition is repository-wide work
+        # with no population of its own, and it reported nothing — so the line held
+        # the last rule family's count while it ran. Each walk is named as it
+        # starts, which is what the operator needs in order to tell a slow stage
+        # from a hung one, and which is also how the next round gets to say *which*
+        # of these walks the wall time is in.
+        _setup = self._rule_progress("composing risk factors", "walks")
+
+        def _named(label: str) -> None:
+            if _setup is not None:
+                _setup.step(label)
+
+        _named("inferring the security posture")
         posture = infer_security_posture(self.cir, root=self.root)
+        _named("resolving the endpoint security surface")
         self.surface = endpoint_security_surface(self.cir, root=self.root, posture=posture)
         access = (
             posture.to_dict().get("endpoints", []) if hasattr(posture, "to_dict") else []
@@ -815,8 +837,11 @@ class RiskComposer:
         # F.4-1. One pass over the α argument-shape atoms and one over the validation
         # surface: both are repository-wide facts, read once and joined by symbol and
         # by route, never re-derived per row.
+        _named("reading concatenated-query owners")
         self.concat_owners = _concatenated_query_owners(self.cir)
+        _named("reading HTTP-input query sinks")
         self.http_input_query_sinks = _http_input_query_sinks(self.root, self.cir)
+        _named("indexing the validation surface")
         self.constraint_index = _constraint_index(
             self.root, self.cir, extract_java_endpoints(self.root)
         )
@@ -843,6 +868,7 @@ class RiskComposer:
 
         # One pass answers both: the access axis (C1-26) and how much of the
         # request surface each chain configuration file decides (C1-25).
+        _named("resolving the conditional bean graph")
         self.profile_access, self.chain_reach = access_resolution(
             self.root,
             self.profiles if self.profiles is not None else set(),
@@ -887,13 +913,58 @@ class RiskComposer:
         return symbol, "method" if "#" in symbol else "class"
 
     def _rule_progress(self, stage: str, unit: str = "rule families") -> "Any":
-        """The observer for one counted stage, or None when nobody is watching."""
+        """The observer for one counted stage, or None when nobody is watching.
+
+        C3-87: "nobody is watching" now includes the budget. The factory returns an
+        observer whenever a heartbeat *or* a deadline exists, so a CI run with no
+        TTY — precisely where a budget matters — gets the same stop the terminal
+        does. The observer is registered here because this is the one place that
+        makes them, so `budget_gap()` cannot miss a pass.
+        """
         if self._progress is None:
             return None
         try:
-            return self._progress(stage, unit)
+            watcher = self._progress(stage, unit)
         except Exception:
             return None
+        if watcher is not None:
+            self._rule_watchers.append((stage, watcher))
+        return watcher
+
+    def budget_gap(self) -> dict:
+        """What the operator's budget cut out of the rule passes, or `{}`.
+
+        The two audits report through observers this class made, and each records
+        its own cut in the vocabulary `spring-audit` already publishes: families
+        that never started (`rules_not_run`) and a family stopped part-way through
+        one of its stages (`rules_partially_run`, with `stage_stopped_in`). Read
+        back here so the composition can publish the gap rather than a total that
+        silently shrank.
+
+        Only the *rule* passes are read. The composition observer counts defects,
+        not rule families, and folding its ids into a rule inventory would be the
+        two-populations-under-one-name defect this ledger already carries twice.
+        """
+        not_run: "list[str]" = []
+        partially_run: "list[dict]" = []
+        stages: "list[str]" = []
+        for stage, watcher in self._rule_watchers:
+            if not stage.endswith("rules"):
+                continue
+            _cut = list(getattr(watcher, "not_run", []) or [])
+            _partial = list(getattr(watcher, "partially_run", []) or [])
+            if not _cut and not _partial:
+                continue
+            not_run.extend(_cut)
+            partially_run.extend(_partial)
+            stages.append(stage)
+        if not not_run and not partially_run:
+            return {}
+        return {
+            "rules_not_run": not_run,
+            "rules_partially_run": partially_run,
+            "stages_stopped_inside": stages,
+        }
 
     def compose(
         self,
@@ -1157,6 +1228,7 @@ def _assemble_payload(
     limit: int,
     min_band: str,
     profiles: "Optional[set[str]]",
+    budget_cut: "Optional[dict]" = None,
 ) -> dict:
     """The `risk` answer document for `rows`. One construction, two callers.
 
@@ -1199,6 +1271,21 @@ def _assemble_payload(
         # that sentence, and it belongs where the composition is, not one command away.
         "non_coverage": non_coverage.block("security_surface"),
     }
+    # C3-87 (and C2-31's rule, applied to the second consumer): the counts above
+    # are arithmetic over what was composed, and on a cut run that is a truncated
+    # population. The mark goes where the numbers are — a reader who never opens
+    # `_partial` must not read `total_defects` as a census. A complete run gains
+    # no fields and stays byte-identical.
+    if budget_cut:
+        payload["partial"] = True
+        payload["counts_are_floor"] = True
+        payload["counts_basis"] = (
+            "This run was cut short by the analysis budget, so every count above "
+            "is a FLOOR over what did run — the absence of a risk composed from a "
+            "rule family that never ran is not evidence there is none, and a "
+            "composition stopped part-way leaves defects unranked rather than "
+            "unfound. `_partial` names what was not measured."
+        )
     if len(kept) > limit:
         from sourcecode.degradation import cap_effect
 
@@ -1238,6 +1325,7 @@ def build_risk(
     profiles: "Optional[set[str]]" = None,
     progress: "Optional[Callable[..., Any]]" = None,
     checkpoint: "Optional[Callable[[str, dict], None]]" = None,
+    partial_status: "Optional[Callable[..., dict]]" = None,
 ) -> dict:
     """Compose this build's own audit with reach, access, write effect and shape.
 
@@ -1267,11 +1355,47 @@ def build_risk(
     # C3-73: the join is the other half of this command's wall time, and it has a
     # denominator of its own — one row per defect. Counted with the same seam as
     # the rule passes, so there is one place that knows how to report counted work.
+    # C3-87: what the budget cut out of the two rule passes, read back from the
+    # observers this composition made. Empty on a run that was not cut, which is
+    # every run without `ASK_MAX_ANALYSIS_SECONDS` set.
+    _cut: dict = dict(composer.budget_gap())
+
     def _assemble(_rows: "list[Any]") -> dict:
-        return _assemble_payload(
+        payload = _assemble_payload(
             _rows, findings=findings, composer=composer, root=root,
             limit=limit, min_band=min_band, profiles=profiles,
+            budget_cut=_cut or None,
         )
+        if _cut and partial_status is not None:
+            # A phase stopped *inside* is neither completed nor pending: `audit`
+            # when a rule family was cut, `compose` when the join was.
+            _inside = [
+                name
+                for name, hit in (
+                    ("audit", bool(_cut.get("rules_not_run"))),
+                    ("compose", _cut.get("defects_composed") is not None),
+                )
+                if hit
+            ]
+            payload["_partial"] = partial_status(
+                rules_partially_run=_cut.get("rules_partially_run") or None,
+                rules_not_run=_cut.get("rules_not_run") or None,
+                phases_stopped_inside=_inside or None,
+            )
+            if _cut.get("defects_composed") is not None:
+                # The join is this command's own population, and a run cut inside
+                # it did rank some defects and not others. Neither `phases_completed`
+                # nor `phases_pending` can say that, so it is said here.
+                payload["_partial"]["composition_stopped_after"] = {
+                    "defects_composed": _cut["defects_composed"],
+                    "defects_total": _cut["defects_total"],
+                    "basis": (
+                        "The audit ran; the join that ranks its defects was cut. "
+                        "The defects not composed were measured and are counted in "
+                        "total_defects — they carry no band and are not in `risks`."
+                    ),
+                }
+        return payload
 
     if checkpoint is not None:
         # The audit and the posture are paid for; the join has not started. A
@@ -1286,6 +1410,15 @@ def build_risk(
     rows = []
     for _index, defect in enumerate(_defects, start=1):
         if _rows_progress is not None:
+            # C3-87: the join is the other half of this command's wall time, so the
+            # deadline is asked here too — on a whole composed row, which is this
+            # loop's unit, and sampled by the same seam the rule passes use.
+            if _rows_progress.tick(
+                _index - 1, len(_defects), label="composing defects", unit="defects"
+            ):
+                _cut["defects_composed"] = _index - 1
+                _cut["defects_total"] = len(_defects)
+                break
             _rows_progress.rule(_index, len(_defects), str(defect["defect_id"]))
         rows.append(composer.compose(
             defect_id=str(defect["defect_id"]),

sourcecode/rule_pass.py

@@ -257,6 +257,18 @@ class FamilyBudget:
     label: str
     stopped: bool = False
 
+    def stage(self, label: str) -> None:
+        """Name a stretch of this family that has no population to count (C3-85).
+
+        A family walks several populations in sequence and does uncounted work
+        between them — finding the files the next stage will read, for one. That
+        work reports nothing, so the line keeps the previous stage's `n/n` on
+        screen, which reads as a stage still running rather than one that ended.
+        Named, not counted: inventing a denominator for it is the fabrication
+        C3-56 refused.
+        """
+        self.progress.step(f"{self.label}: {label}")
+
     def tick(
         self, done: int, total: int, *, unit: str = "files", stage: str = ""
     ) -> bool:

sourcecode/security_config_scan.py

@@ -638,6 +638,11 @@ def scan_security_configuration(
     # surface and Java discovery cannot disagree about what is source.
     from sourcecode.repository_ir import walk_source_tree
 
+    # C3-85: one walk of the whole source tree, between the Java stage that just
+    # ended and the configuration stage that has not started. It reported nothing,
+    # so the line held `3342/3342 java files` while it ran.
+    if budget is not None:
+        budget.stage("finding configuration files, descriptors and mappers")
     _walked_config: "list[str]" = []
     descriptors: "list[str]" = []
     mappers: "list[str]" = []

sourcecode/spring_security_audit.py

@@ -996,6 +996,11 @@ class SecurityScanner:
             self.rules_run.extend(rule_ids_of(pattern))
             if progress is not None:
                 progress.rule(_index, _total, pattern.pattern_id, done=True)
+        # C3-85: the tail of the pass. Two walks over every finding the families
+        # produced, after the last family reported and before the next named stage
+        # — inside the field's silence, like the two stages C3-73 named before it.
+        if progress is not None:
+            progress.step("deduplicating and ordering findings")
         deduped = deduplicate_findings(all_findings)
         return sorted(deduped, key=lambda f: (SEVERITY_ORDER.get(f.severity, 9), f.symbol))
 

{sourcecode-4.15.0.dist-info → sourcecode-4.16.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sourcecode
-Version: 4.15.0
+Version: 4.16.0
 Summary: Persistent structural context and ultra-fast repeated analysis for AI coding agents
 License-File: LICENSE
 Keywords: agents,ai,codebase,context,developer-tools,llm
@@ -42,7 +42,7 @@ Description-Content-Type: text/markdown
 
 **Context · Impact · Migration · Architecture · Review — everything from one structural model.**
 
-![Version](https://img.shields.io/badge/version-4.15.0-blue)
+![Version](https://img.shields.io/badge/version-4.16.0-blue)
 ![Python](https://img.shields.io/badge/python-3.9%2B-green)
 
 > **ASK Engine** is the product. The CLI command is **`ask`**. The legacy **`sourcecode`**
@@ -126,7 +126,7 @@ brew tap haroundominique/sourcecode && brew install sourcecode
 # pip / pipx
 pipx install sourcecode        # or: pip install sourcecode
 
-ask version                    # ask 4.15.0 — and, on a build that has aged,
+ask version                    # ask 4.16.0 — and, on a build that has aged,
                                # how many releases have probably shipped since
 ```
 

{sourcecode-4.15.0.dist-info → sourcecode-4.16.0.dist-info}/RECORD

@@ -1,4 +1,4 @@
-sourcecode/__init__.py,sha256=Ub5mdlZZyGdFTJZvvfzvTcZgbEJ8EyeNf62l-V-LOP0,309
+sourcecode/__init__.py,sha256=5rp02UOw1nxBYqNTQnjILrQlHGCnAIXmjbWqy0Ci4T4,309
 sourcecode/adaptive_scanner.py,sha256=yJBKjNpkY6bpueYJ2YnRezen3sYZDecEt7WaaNWdqug,9466
 sourcecode/archetype.py,sha256=CZvRLpkHot_D8D3JFQVorr-EHDJyh0BbS7RnSTqBigM,40499
 sourcecode/architectural_baseline.py,sha256=4GiMVBLJVHvRKSWQGf2ZVurI1-R0qk5pmaevgvGSgVA,26325
@@ -18,7 +18,7 @@ sourcecode/chain_rules.py,sha256=Bi6UHfgd-GxWswmnHRcPz5jdbAuqka3Zkz_P-MTvqhw,127
 sourcecode/change_plan.py,sha256=aX1mp2XnlDN-8R2BcTiu8HlkDwQ_4fN1ZLckj0VMXHM,9945
 sourcecode/cir_graphs.py,sha256=9G0HHj1kw2325IDyzo2OpX73BNswEckecf4MZUXB4JM,12078
 sourcecode/classifier.py,sha256=JBzPwSSrDG-tUHAbcKB678HRbjLpD-ohzbzzO62mgpo,20114
-sourcecode/cli.py,sha256=lUGvP4xPxLvTlKqMyqJhF-Lomls1L_qYijD6BpxcaQ4,597537
+sourcecode/cli.py,sha256=TvA4KIhUnm4Pr25B1ISCRSD0OzFdxD9wdP7x9TmKLig,597596
 sourcecode/client_calls.py,sha256=daRTgbXNUOfkzGXJpVb6A737R_Thhka8vw1_YgxCaLg,13548
 sourcecode/code_notes_analyzer.py,sha256=EJemNCNc9Dn-1RZYu-aNbK0ELzmsyC4s6FdHi3XyNEI,9392
 sourcecode/compare.py,sha256=2GdDy0qkDSgmkkpgvoCHitoLj3mt30EeFgJ8PGEXJng,14712
@@ -81,13 +81,13 @@ sourcecode/parse_cache.py,sha256=fhXnoaOgVWwp_8q0ngJ76UZ09qJ6uxDd0jaX8jdezvo,208
 sourcecode/path_admission.py,sha256=OGNSoluhVh8YYOBZBnACUrkmH4Tp_yxjGLifkcsxQpo,5838
 sourcecode/path_filters.py,sha256=LmTYq735orssKTIuxTX1mE1FHAXF7dVEJEse35xE1RA,12371
 sourcecode/perf.py,sha256=vZDEj1wS905peXmREdOniZrWCikElOyPTw-E32zVZAQ,25847
-sourcecode/phased_run.py,sha256=yrTV7qtGDwgOPw0wYEioLMCKwReAZPtml567n4SYED4,12750
+sourcecode/phased_run.py,sha256=zJGOLAuMAzjr71NQAEkXclXkgzTYpBsF4KP5EV2Itdk,15545
 sourcecode/pipe_contract.py,sha256=PML0Er5d8uDyec4OrdUXuyqHbGPUYndjeaKUjkFz2u4,8369
 sourcecode/posture.py,sha256=cZ3By8LR-1bHfzyVpCDo2HHSAsCvePOmUc37E9GXYDw,76206
 sourcecode/pr_comment_renderer.py,sha256=239PmJdf95av_ZW236C7_tvq_ahECeuF9AZxrheJ4OQ,15573
 sourcecode/pr_impact.py,sha256=KyVBvHCCbgByKA_wqTbO1dSkfi05GEudIAuH4CyDPK4,27395
 sourcecode/prepare_context.py,sha256=ntB2MSScHtYRKRm9SansA0FrklMnXZmE9_yRXqXk0qc,239264
-sourcecode/progress.py,sha256=3aw7mF7JtrRIy29SsORBtF-5LbQY45f_SfRw_wu7vv8,18869
+sourcecode/progress.py,sha256=A4hNoCRgmHofilbIXMoR4vlvoF4gupefTUCuYmceI_E,20547
 sourcecode/provenance.py,sha256=gLbsLv0gze7k7ChM4i5M3MwKfFPzs8wzM72rUd2C5sM,7342
 sourcecode/ranking_engine.py,sha256=ZAucq_YX2KkWUuAZf4P0lhtQ_38vEFnUhuGtSZd1S0E,12970
 sourcecode/readiness_timeline.py,sha256=KjghC1MWH7Tzto97TBR3N0F8FkR87w5z7lZ1QsWvAQE,8506
@@ -100,18 +100,18 @@ sourcecode/relevance_scorer.py,sha256=0AgEt4KrV73nioMqBgjhGjtY7L2C7L7cSyKtj3IKcr
 sourcecode/remedies.py,sha256=9eAuP9ndw78YvuUtOi2VvoeNnVCMh1q0uxfnPIkvx7c,7838
 sourcecode/rename_refactor.py,sha256=h6dNFlB9aZ_3q6heeHBkgXQeXaT03nvPSsYH6P8qxFg,12965
 sourcecode/repo_classifier.py,sha256=FG1vaWKdWXsWdl-S8hjVMiTqcwgaRXkDyvK4rPcOGtQ,22681
-sourcecode/repository_ir.py,sha256=t1JNnk5g3ksfjkkrxaXZUKMyszw9zWEb6HQd-vlE3SE,367981
+sourcecode/repository_ir.py,sha256=x0u0m-Dlgtcfr7VsggnKRw_mCobe6B7lZMw3U2H1rd8,368709
 sourcecode/ris.py,sha256=SjjDNMcc9Zr9us9G8ikBVkoPXKK3BpM-dBodSGMh_g4,24783
-sourcecode/risk.py,sha256=jfhCIhxiAqHE0CUO3FZK_-m1bwu-o-yEZfQZrhKnvVs,58449
+sourcecode/risk.py,sha256=aSnK369sYcooEm57oaPX3QcCWoElt5YYJrqTtrXUUdo,65486
 sourcecode/rule_catalog.py,sha256=pTkgkQZ1u7atB3fkQJ9BPWo8lNiamvEuRN7MtRgle0c,5263
-sourcecode/rule_pass.py,sha256=lHk2Y9hp73th2Rh6yeJdOBQyVz9NQS3rTZKOiW7Ky1Q,13374
+sourcecode/rule_pass.py,sha256=xK3Tj5wXOzRaSmteKZD4I-QeyrAy7ZZzB8ItjC3r2II,13986
 sourcecode/runs.py,sha256=zIxEPz9DBVVCrX958bZR6bODyfH56A6srAyc8LFMs8I,5303
 sourcecode/runtime_classifier.py,sha256=uTAD6BDCiBLUZEDRfqk718kM4RTT_vAbfkcOI2_Xx58,18432
 sourcecode/sarif.py,sha256=3hQEegUxIZbojFdY59oB-yKsK-rnafHdTNmYsEP2--A,25984
 sourcecode/scanner.py,sha256=z3CV0rcGunu0Y8mpNgp07wI7nxT0pxw1BkXRRtI0Rpo,9609
 sourcecode/schema.py,sha256=aHNXDf8LGyUC8ZDE_VS9kiskC2-Oswhi_WnpdGy6HDw,24897
 sourcecode/security_config.py,sha256=KblMEoRiEjrIE68YsPaUAFebxFp8UM7MS7lAk5CGD8U,3531
-sourcecode/security_config_scan.py,sha256=dO_z9pquH3pypaZU5gL3eHuWx4rpLEUp5jQVUDZ6u6Y,29693
+sourcecode/security_config_scan.py,sha256=vpAglQkh7QxUhY_eR6aOOE5d-aU2tsEd-bE8pMoFz8g,30021
 sourcecode/security_posture.py,sha256=JH3v8HKBT4oBKaDCrxNOyrlYSleLlxQw_UgRJcvjX4c,51677
 sourcecode/semantic_analyzer.py,sha256=bpgdC6m0_ftVtRf3rSdwhbhWjnZnGxRXaZVcfe4BbcQ,95414
 sourcecode/semantic_impact_engine.py,sha256=t09IirGC3JjQDy33JZd1_WKzQVKXkoNl3-XEUr5kjis,20563
@@ -126,7 +126,7 @@ sourcecode/spring_impact.py,sha256=GW77k7KMn13QmzP5520BbVcXSCYlTFeD1bFibhbmzJM,8
 sourcecode/spring_model.py,sha256=zOAgFmrRbG4a6KLm1TJl55aWMyPNsz3OS3FSczqPG6A,16594
 sourcecode/spring_profiles.py,sha256=-kwrCK0O-MRjrCp6SA1d31t--o4Tg87iqPVrTwxoIUs,19605
 sourcecode/spring_properties.py,sha256=kPTk5qAJxdbHc1hclhHAP0O-hCIzBn8PTh3lzl-I4a4,8400
-sourcecode/spring_security_audit.py,sha256=0cS73BXaoFByJk4cMl3YqItPQ2xRUMu4XChURbKLCQo,55519
+sourcecode/spring_security_audit.py,sha256=-W_cs2vl_GgqWtC2OCdJKL8WuYcZQsessdBO0UTIU-8,55866
 sourcecode/spring_semantic.py,sha256=UrmLg_4gmBVmMqvSnUMgSReVEERVGv3X7LYDBEs6k_o,16598
 sourcecode/spring_tx_analyzer.py,sha256=4pUTaqqlsKRTBUr6tIwYP9oLamHz_IVKmLq3kFcH7Ww,49412
 sourcecode/summarizer.py,sha256=0aD4x3vgPngqBCEBKGuES1J2Vk5f7mqCm_ZWErwm3js,27025
@@ -203,8 +203,8 @@ sourcecode/telemetry/consent.py,sha256=pQdl-QeLl6Gcibn0eWHSKZrm-HYSsjpVqOnjrgFp8
 sourcecode/telemetry/events.py,sha256=4_yeO58U-Cwc1Qb27VB0_EjhmroY0k91n3_VGxeALB8,2776
 sourcecode/telemetry/filters.py,sha256=RzxauTz8HliO4BllQnXEXc7zTeqdCZi5MgqGEDuW7OQ,6570
 sourcecode/telemetry/transport.py,sha256=4gGHsq0WeY9VywEZXA3vUxykfiYnw9uuqfjAAec7F8o,1681
-sourcecode-4.15.0.dist-info/METADATA,sha256=Pej25eqhwMzbD468yWla-_e00Xg2fwKH5gRJmgBoMW8,42089
-sourcecode-4.15.0.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
-sourcecode-4.15.0.dist-info/entry_points.txt,sha256=-JEAdChrK5We51kZcb7OaDcyil-dHBjBPL-NhuO-QY8,89
-sourcecode-4.15.0.dist-info/licenses/LICENSE,sha256=7DdHrU9Z_3e7dSvq4ISijZNjnuHo5NIHNiHDouMQ9JU,10491
-sourcecode-4.15.0.dist-info/RECORD,,
+sourcecode-4.16.0.dist-info/METADATA,sha256=lWzS830gWVniMl2-yHA-C6RhBojPBdBuVNDm8fBkgZc,42089
+sourcecode-4.16.0.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+sourcecode-4.16.0.dist-info/entry_points.txt,sha256=-JEAdChrK5We51kZcb7OaDcyil-dHBjBPL-NhuO-QY8,89
+sourcecode-4.16.0.dist-info/licenses/LICENSE,sha256=7DdHrU9Z_3e7dSvq4ISijZNjnuHo5NIHNiHDouMQ9JU,10491
+sourcecode-4.16.0.dist-info/RECORD,,