sourcecode 5.0.1__py3-none-any.whl → 5.1.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__ = "5.0.1"
+__version__ = "5.1.0"

sourcecode/cache_model.py

@@ -616,6 +616,103 @@ def field_currency() -> dict:
     }
 
 
+def gate_anchor(command: str) -> "Optional[dict]":
+    """What the release gate measured for *command*, or ``None`` (C3-109).
+
+    The third figure in this module, and the only one this repository can refresh
+    by itself. `REFERENCE_*` is a 3.2.2 measurement on a 2 000-file tree;
+    `field_seconds` is the field's, at 3 342 files, on their machine and their
+    build. Both age, and neither can be re-measured from here — which is exactly
+    how B17 reopened one release after it was closed: the labelling worked and
+    the number still expired.
+
+    The gate measures a 2 985-file repository under a declared host class every
+    release and commits its cells, so this figure carries the build that produced
+    it and can be brought current by running the gate. It never overrides a field
+    anchor — a measurement at field scale outranks one at gate scale — it is
+    published *beside* it, so an anchor from an older build is no longer the only
+    number a reader has.
+    """
+    try:
+        from sourcecode.gate_anchors import (
+            GATE_ANCHORS,
+            GATE_HOST_CLASS,
+            GATE_JAVA_FILES,
+            GATE_MEASURED_VERSION,
+            GATE_REPOSITORY,
+        )
+    except Exception:
+        return None
+    cell = GATE_ANCHORS.get(command)
+    if not cell:
+        return None
+    return {
+        "seconds": cell["seconds"],
+        "cache_state": cell["mode"],
+        "runs": cell["runs"],
+        "measured_on_version": GATE_MEASURED_VERSION,
+        "repository": GATE_REPOSITORY,
+        "java_files": GATE_JAVA_FILES,
+        "host_class": GATE_HOST_CLASS,
+    }
+
+
+def gate_currency() -> dict:
+    """Whether the in-house gate figures describe the build in hand (C3-109).
+
+    Same shape and same purpose as `field_currency`, for the anchor set that can
+    actually be refreshed. When this says `current: false`, the remedy is a
+    command rather than a hope: re-run the gate on the tag and commit the cells.
+    """
+    from sourcecode import __version__
+
+    current = __version__
+    try:
+        from sourcecode.gate_anchors import (
+            GATE_ANCHORS,
+            GATE_CAPTURED_AT,
+            GATE_HOST_CLASS,
+            GATE_JAVA_FILES,
+            GATE_MEASURED_VERSION,
+            GATE_REPOSITORY,
+        )
+    except Exception:
+        return {
+            "available": False,
+            "running_version": current,
+            "statement": (
+                "This build carries no gate measurement of its own. The gate "
+                "publishes one per release (docs/perf/REGRESSION-GATE.md); until "
+                "it runs, the field anchors are the only measured figures here."
+            ),
+        }
+    return {
+        "available": True,
+        "measured_on_version": GATE_MEASURED_VERSION,
+        "running_version": current,
+        "current": GATE_MEASURED_VERSION == current,
+        "captured_at": GATE_CAPTURED_AT,
+        "repository": GATE_REPOSITORY,
+        "java_files": GATE_JAVA_FILES,
+        "host_class": GATE_HOST_CLASS,
+        "commands": sorted(GATE_ANCHORS),
+        "statement": (
+            f"The release gate measured {len(GATE_ANCHORS)} commands on "
+            f"{GATE_REPOSITORY} ({GATE_JAVA_FILES} Java files, {GATE_HOST_CLASS}) "
+            + (
+                f"on {current}, the build you are running."
+                if GATE_MEASURED_VERSION == current
+                else (
+                    f"on {GATE_MEASURED_VERSION}; you are running {current}, which "
+                    f"the gate has not measured. Re-run it on this build "
+                    f"(docs/perf/REGRESSION-GATE.md) — unlike the field anchors, "
+                    f"this is a figure this project can refresh."
+                )
+            )
+        ),
+    }
+
+
 def reference_currency() -> dict:
     """How old the reference figures are, in releases the reader can name (F-AP).
 
@@ -680,6 +777,11 @@ def as_dict(here: "Optional[Conditioning]" = None) -> dict:
         # measured 2 351 s and 8,4 s on two of our own builds (C4-19, C3-97).
         "field_anchor": FIELD_ANCHOR,
         "field_currency": field_currency(),
+        # C3-109: and the figure this project can refresh by itself. A field
+        # anchor belongs to the build the field ran; this one belongs to the
+        # build the gate ran, which is a release away at worst instead of
+        # unreachable. Published beside, never instead.
+        "gate_currency": gate_currency(),
         "commands": [
             {
                 "command": cmd.command,
@@ -716,6 +818,12 @@ def as_dict(here: "Optional[Conditioning]" = None) -> dict:
                         "note": field_anchor_note(cmd),
                     }
                 ),
+                # C3-109: the in-house measurement of this command, on the build
+                # the gate last ran. Absent for commands the gate does not cover —
+                # its population is declared in `sourcecode.perf`, with the
+                # exclusions and their reasons, and an axis nobody measured is
+                # never a number here.
+                "gate_measurement": gate_anchor(cmd.command),
             }
             for cmd in COMMANDS
         ],
@@ -827,6 +935,7 @@ def render_text(here: "Optional[Conditioning]" = None) -> str:
     lines.append(f"  Timings: {REFERENCE_REPOSITORY}, each command measured in isolation.")
     lines.append(f"  {reference_currency()['statement']}")
     lines.append(f"  {field_currency()['statement']}")
+    lines.append(f"  {gate_currency()['statement']}")
     width = max(len(c.command) for c in COMMANDS)
     for cmd in COMMANDS:
         repeat = "repeat cached" if cmd.repeat else "recomputes"
@@ -848,6 +957,17 @@ def render_text(here: "Optional[Conditioning]" = None) -> str:
                 f"  {' ' * width}    field:    {shown} at "
                 f"{_thousands(FIELD_ANCHOR_JAVA_FILES)} Java files{suffix}"
             )
+        _gate = gate_anchor(cmd.command)
+        if _gate:
+            # C3-109: the in-house figure, beside the field's rather than instead
+            # of it — one is at field scale on another build, one is on a build
+            # this project can bring current.
+            lines.append(
+                f"  {' ' * width}    gate:     {_gate['seconds']:g} s at "
+                f"{_thousands(_gate['java_files'])} Java files "
+                f"({_gate['cache_state']} cache, on {_gate['measured_on_version']}, "
+                f"{_gate['host_class']})"
+            )
         if cmd.note:
             lines.append(f"  {' ' * width}    {cmd.note}")
         if here is not None and cmd.command in here.per_command:

sourcecode/cli.py

@@ -934,6 +934,67 @@ def _emit_error_json(error: str, message: str, **context: object) -> None:
     sys.stderr.flush()
 
 
+#: Exit code for a confirmation that could not be read. Argument-validation
+#: convention (the same 2 an invalid `--format` returns): nothing was done, and
+#: the input is what has to change.
+_UNANSWERABLE_PROMPT_EXIT = 2
+
+
+def _stdin_is_interactive() -> bool:
+    """True when a human could answer a prompt on stdin.
+
+    The counterpart of `_stderr_is_interactive`, and one seam rather than three
+    call sites, because the two states this gate distinguishes are not the two
+    states the world has: stdin can also *claim* to be a terminal and answer
+    nothing, which is C3-106 and is handled by `_confirm` rather than here.
+    """
+    try:
+        return bool(sys.stdin.isatty())
+    except Exception:
+        return False
+
+
+def _confirm(question: str, *, command: str, default: bool = False, err: bool = False) -> bool:
+    """Ask a yes/no question, and diagnose a prompt that cannot be answered.
+
+    C3-106. v1.45.0 guarded the case it knew about — `sys.stdin.isatty()` false,
+    so never block on a pipe — and the field found the case it does not cover: a
+    PowerShell 5.1 session driven by a harness where `isatty()` answers **true**
+    and the read hits end-of-input immediately. `click.confirm` turns that into
+    `Abort`, nothing catches it, and the operator gets a Python traceback under a
+    half-printed prompt — from the first command anyone runs when following our
+    own advice to clear the cache between versions.
+
+    An unanswerable prompt is malformed input, and this product answers malformed
+    input with a diagnosed envelope everywhere else. So does this: what was asked,
+    why no answer arrived, and the flag that makes the question unnecessary.
+
+    `click` collapses end-of-input and interrupt into the same `Abort`, so the
+    message names the outcome (*no answer*) rather than a cause it cannot
+    distinguish. A plain "no" is not this: it returns `False` and the caller
+    decides.
+    """
+    import click as _click
+
+    try:
+        return bool(_click.confirm(question, default=default, err=err))
+    except (EOFError, OSError, _click.Abort):
+        _emit_error_json(
+            INVALID_INPUT_CODE,
+            f"{command} needs confirmation and no answer could be read from stdin",
+            hint=f"Pass --yes to skip the prompt: `{command} --yes`.",
+            expected="--yes when running non-interactively",
+            reason="unanswerable_prompt",
+            detail=(
+                "the prompt was written and the read ended without an answer "
+                "(end of input, or an interrupt). A terminal that reports itself "
+                "interactive and returns EOF — a harness-driven shell, a "
+                "redirected stdin — reaches here."
+            ),
+        )
+        raise typer.Exit(code=_UNANSWERABLE_PROMPT_EXIT)
+
+
 def _notice(message: str) -> None:
     """Say something to the person, and nothing to the pipeline.
 
@@ -2478,14 +2539,24 @@ _FREE_TIER_NODE_CAP: int = 50  # graph/semantic node cap — applies only to lar
 _JAVA_MIN_SCAN_DEPTH: int = 12  # Maven src/main/java/<pkg>/<module>/File depth floor
 _LARGE_REPO_ADVISORY_FILES: int = 3000  # cold-scan advisory threshold (files); honest expectation-setting, not a speed claim
 
-#: What one Java file costs in serialized `repo-ir` output, measured across four
+#: What one Java file costs in serialized `repo-ir` output, measured across five
 #: repositories (C3-18): spring-petclinic 30 files/318 KB (10.8 KB/file),
 #: jobrunr 581/9.5 MB (16.8), openmrs-core 866/21 MB (25.2), eureka 299/8.0 MB
-#: (27.3). Kept as a band, never collapsed to a midpoint: the 2.6x spread is
-#: real — it tracks how densely the code cross-references — and a point estimate
-#: would assert a precision the sample does not support (the C1-12 rule).
+#: (27.3), and the field repository 3 342/101 254 852 B (**30.3**, eval #23).
+#: Kept as a band, never collapsed to a midpoint: the 2.8x spread is real — it
+#: tracks how densely the code cross-references — and a point estimate would
+#: assert a precision the sample does not support (the C1-12 rule).
+#:
+#: C3-105: the fifth sample is the one that opened the row. The band was 10.8-27.9
+#: and the largest repository anybody had run this on landed **above** it, so the
+#: one number offered for planning excluded the measurement a reader would take.
+#: Same class as C3-97 — a published figure a later measurement falsifies — and
+#: the remedy is the same: admit the sample, and say how many there are.
 _IR_BYTES_PER_FILE_LOW: int = 10_800
-_IR_BYTES_PER_FILE_HIGH: int = 27_900
+_IR_BYTES_PER_FILE_HIGH: int = 30_300
+#: How many repositories the band is drawn from. Published with the band, because
+#: a range without its sample size reads as a bound rather than an observation.
+_IR_BYTES_PER_FILE_SAMPLES: int = 5
 _IR_SIZE_WARN_MB: int = 10  # advise above this; below it the write is not worth a sentence
 
 #: What `--no-cache` means on a subcommand (C3-5). The old text — "this command
@@ -2516,12 +2587,19 @@ def _ir_size_advisory_message(file_count: int) -> "Optional[str]":
     file already on disk — so it could tell a user what they had just spent,
     never what they were about to.
 
-    The figure is a band, not a point. Sampled across four repositories the IR
-    costs 10.8-27.9 KB per Java file, and that 2.6x spread is a real property of
+    The figure is a band, not a point. Sampled across five repositories the IR
+    costs 10.8-30.3 KB per Java file, and that 2.8x spread is a real property of
     the input (how densely the code cross-references), not sampling noise.
     Publishing its midpoint as one number would assert a precision the sample
     does not support — the same defect C1-12 records for migration effort — so
-    the band is published with the word "estimate" on it.
+    the band is published with the word "estimate" and its sample size on it.
+
+    C3-105: the band's own direction is declared, because the sample that sets
+    its high end (the field repository, 101 254 852 B) counted **every** Java
+    file in the repository, tests included, while this estimate multiplies the
+    files this run will actually scan. Per scanned file the true rate is
+    therefore higher, so the top of the band under-states — stated rather than
+    left for a reader to discover the way C3-105 was discovered.
 
     Pure and TTY-agnostic: the caller owns the terminal gate, so this never
     reaches stdout or a pipeline (C3-26).
@@ -2532,7 +2610,10 @@ def _ir_size_advisory_message(file_count: int) -> "Optional[str]":
         return None
     return (
         f"[repo-ir] {file_count} files — estimated output "
-        f"{est_low_mb:.0f}-{est_high_mb:.0f}MB (estimate, not a measurement). "
+        f"{est_low_mb:.0f}-{est_high_mb:.0f}MB (estimate from "
+        f"{_IR_BYTES_PER_FILE_SAMPLES} repositories, not a measurement; the top "
+        "of the band under-states, since its sample counted tests among its "
+        "files and this run does not). "
         "To spend less: --summary-only, --max-nodes N --max-edges N, or --gzip."
     )
 
@@ -3360,6 +3441,43 @@ def main(
                         _l1_needs_env_inject = "em" in _subset
                         break
 
+            # C3-103: and the same reasoning in the other direction, which was never
+            # tried. The candidate set above turns requested overlays OFF to find a
+            # poorer base and re-attaches them; a base that is *richer* than the
+            # request is reusable too, because an overlay only ever attaches a block —
+            # the same additivity the inject path already depends on — so projecting
+            # the richer core down is a drop, not a rescan. Measured in the field:
+            # `--compact --git-context --env-map` 72,3 s cold, then `--agent` 71,7 s
+            # with the RIS already built, because `--agent` asks for `gc=False` and
+            # the only core on disk had `gc=True`. 144 s for two views of one state.
+            _l1_needs_env_drop = False
+            _l1_needs_git_drop = False
+            if _l1_result is None and _core_key and not (env_map and git_context):
+                _sha_prefix = _tree_sig
+                _addable = []
+                if not git_context:
+                    _addable.append("gc")
+                if not env_map:
+                    _addable.append("em")
+                import itertools as _it2
+                _up_subsets = [
+                    s for n in range(1, len(_addable) + 1)
+                    for s in _it2.combinations(_addable, n)
+                ]
+                for _subset in _up_subsets:
+                    _bf = _core_flags_str
+                    if "gc" in _subset:
+                        _bf = _bf.replace(",gc=False,", ",gc=True,")
+                    if "em" in _subset:
+                        _bf = _bf.replace(",em=False,", ",em=True,")
+                    _bk = f"{_sha_prefix}-{_hashlib.sha256(_bf.encode()).hexdigest()[:8]}"
+                    _br = _cache_mod.read_core(target, _bk)
+                    if _br is not None:
+                        _l1_result = _br
+                        _l1_needs_git_drop = "gc" in _subset
+                        _l1_needs_env_drop = "em" in _subset
+                        break
+
             if _l1_result is not None:
                 _core_dict_l1, _core_hash = _l1_result
                 _view_key = f"{_core_hash}-{_view_h}"
@@ -3373,6 +3491,14 @@ def main(
                         f"{_view_key}-ov:gc{int(_l1_needs_git_inject)}"
                         f"em{int(_l1_needs_env_inject)}"
                     )
+                # C3-103: a projected-down view shares the richer base's core hash
+                # with the base's own view, and it is a different answer — one block
+                # shorter. Its own suffix, for the reason the inject path has one.
+                if _l1_needs_git_drop or _l1_needs_env_drop:
+                    _view_key = (
+                        f"{_view_key}-pd:gc{int(_l1_needs_git_drop)}"
+                        f"em{int(_l1_needs_env_drop)}"
+                    )
 
                 # Step 2: try L2 (exact view match).
                 # Skip L2 for --changed-only: the stored view is a previous
@@ -3443,6 +3569,17 @@ def main(
                                     _rebuilt["git_context"] = _gc_block
                             except Exception:
                                 pass  # git inject failed — continue without git data
+                        # C3-103: drop the overlays the richer base carried and this
+                        # request did not ask for. The view is what the flags decide,
+                        # so a block the caller did not request must not arrive just
+                        # because a previous run paid for it.
+                        if _rebuilt is not None and (_l1_needs_git_drop or _l1_needs_env_drop):
+                            _rebuilt = dict(_rebuilt)
+                            if _l1_needs_git_drop:
+                                _rebuilt.pop("git_context", None)
+                            if _l1_needs_env_drop:
+                                _rebuilt.pop("env_summary", None)
+                                _rebuilt.pop("env_map", None)
                         if _rebuilt is not None:
                             # Apply redaction
                             if not no_redact:
@@ -6948,19 +7085,34 @@ def _two_states(
             root = repo_root(target)
             base_sha = resolve_ref(root, base_ref)
             head_sha = resolve_ref(root, head_ref)
+            _identical = bool(base_sha) and base_sha == head_sha
+            block = {
+                "basis": "git_refs",
+                "repository": str(root),
+                "base": {"ref": base_ref, "commit": base_sha},
+                "head": {"ref": head_ref, "commit": head_sha},
+                "note": (
+                    "Both states were read with `git archive`: nothing was "
+                    "written to the repository, no worktree was created and "
+                    "the working tree and index were not read."
+                ),
+            }
+            _record_state_identity(
+                block,
+                _identical,
+                f"--base-ref and --head-ref resolve to the same commit ({base_sha})",
+            )
+            if _identical:
+                # C3-107, the first half: two refs that name one commit are one
+                # tree, so it is read out once. The second `git archive` copied
+                # the same bytes to a second directory for a build that is going
+                # to be reused rather than repeated.
+                with materialize_ref(target, base_ref) as tree:
+                    yield tree, tree, block
+                return
             with materialize_ref(target, base_ref) as base_tree, \
                     materialize_ref(target, head_ref) as head_tree:
-                yield base_tree, head_tree, {
-                    "basis": "git_refs",
-                    "repository": str(root),
-                    "base": {"ref": base_ref, "commit": base_sha},
-                    "head": {"ref": head_ref, "commit": head_sha},
-                    "note": (
-                        "Both states were read with `git archive`: nothing was "
-                        "written to the repository, no worktree was created and "
-                        "the working tree and index were not read."
-                    ),
-                }
+                yield base_tree, head_tree, block
         except RefError as exc:
             _emit_error_json(exc.code, exc.message, ref=exc.ref, hint=usage)
             raise typer.Exit(code=1)
@@ -6980,11 +7132,53 @@ def _two_states(
             usage=usage,
             extra_hint=f"Refused as the {label} checkout.",
         )
-    yield base.resolve(), head.resolve(), {
+    block = {
         "basis": "checkouts",
         "base": {"path": str(base.resolve())},
         "head": {"path": str(head.resolve())},
     }
+    _record_state_identity(block, *_checkouts_are_one_state(base, head))
+    yield base.resolve(), head.resolve(), block
+
+
+def _checkouts_are_one_state(base: Path, head: Path) -> "tuple[bool, Optional[str]]":
+    """Are these two checkouts provably the same tree state?
+
+    `cache.worktree_signature` is the authority this product already keys every
+    cached answer on — *"any change to the analysed files invalidates, committed
+    or not"* — so the question needs no second definition of "the same tree".
+
+    Identity is claimed only when a signature was computed on both sides: a tree
+    that cannot be described answers `""`, and two unknowns are not a match. The
+    error direction is deliberate — a missed identity costs a second build, a
+    false one would answer for a tree nobody read.
+    """
+    from sourcecode import cache as _cache
+
+    try:
+        base_sig = _cache.worktree_signature(Path(base).resolve())
+        head_sig = _cache.worktree_signature(Path(head).resolve())
+    except Exception:
+        return False, None
+    if base_sig and base_sig == head_sig:
+        return True, f"both checkouts carry the same tree signature ({base_sig})"
+    return False, None
+
+
+def _record_state_identity(block: dict, identical: bool, basis: "Optional[str]") -> None:
+    """Publish the identity verdict beside the two states it is about.
+
+    C3-107: a reader who sees one analysis where the command names two states is
+    owed the reason, and a consumer gating on `delta` is owed the fact that the
+    comparison was degenerate. Always present, so its absence is never the answer.
+    """
+    block["identical_states"] = bool(identical)
+    if identical:
+        block["identical_states_basis"] = basis
+        block["identical_states_effect"] = (
+            "One tree state, so it was read and analysed once and compared with "
+            "itself. The result is a diff of a real analysis, not an assumed-empty one."
+        )
 
 
 @app.command("delta")
@@ -7045,10 +7239,16 @@ def delta_cmd(
     with _two_states(
         base, head, base_ref, head_ref, repo, usage="ask delta <base> <head>",
     ) as (_base_root, _head_root, _comparison):
+        # C3-107: `_two_states` has already decided this, from the commit on the
+        # ref path and from the tree signature on the checkout path.
+        _same = bool(_comparison.get("identical_states"))
         _prog.start("building base IR")
         _base_cir = ContextGraph.build_from_root(_base_root).cir
-        _prog.update("building head IR")
-        _head_cir = ContextGraph.build_from_root(_head_root).cir
+        if _same:
+            _head_cir = _base_cir
+        else:
+            _prog.update("building head IR")
+            _head_cir = ContextGraph.build_from_root(_head_root).cir
         _prog.update("diffing snapshots")
         data = architectural_delta(_base_cir, _head_cir)
     data["comparison"] = _comparison
@@ -7136,17 +7336,24 @@ def contract_diff_cmd(
     with _two_states(
         base, head, base_ref, head_ref, repo, usage="ask contract-diff <base> <head>",
     ) as (_base_root, _head_root, _comparison):
+        # C3-107: `_two_states` has already decided this, from the commit on the
+        # ref path and from the tree signature on the checkout path.
+        _same = bool(_comparison.get("identical_states"))
         _prog.start("building base IR")
         _base_cir = ContextGraph.build_from_root(_base_root).cir
-        _prog.update("building head IR")
-        _head_cir = ContextGraph.build_from_root(_head_root).cir
+        if _same:
+            _head_cir = _base_cir
+        else:
+            _prog.update("building head IR")
+            _head_cir = ContextGraph.build_from_root(_head_root).cir
         # D2-b: proven request-constraint loosenings fill the non_breaking bucket. The
         # validation surface needs the repo roots (it discovers specs/DTOs), not just the
         # CIR — build it per side and diff the constraint contracts.
         _prog.update("projecting validation constraints")
+        _base_surface = build_validation_surface(_base_root)
         _cfindings = _constraint_findings(
-            build_validation_surface(_base_root),
-            build_validation_surface(_head_root),
+            _base_surface,
+            _base_surface if _same else build_validation_surface(_head_root),
         )
         _prog.update("diffing contracts")
         data = _contract_diff(_base_cir, _head_cir, constraint_findings=_cfindings)
@@ -12907,8 +13114,7 @@ def mcp_init(
     typer.echo("")
 
     if not yes:
-        confirmed = typer.confirm("Proceed?", default=False)
-        if not confirmed:
+        if not _confirm("Proceed?", command="ask mcp init"):
             typer.echo("Aborted.")
             raise typer.Exit(code=0)
         typer.echo("")
@@ -13174,8 +13380,7 @@ def mcp_remove(
     typer.echo("")
 
     if not yes:
-        confirmed = typer.confirm("Proceed?", default=False)
-        if not confirmed:
+        if not _confirm("Proceed?", command="ask mcp remove"):
             typer.echo("Aborted.")
             raise typer.Exit(code=0)
         typer.echo("")
@@ -13384,11 +13589,22 @@ def cache_clear_cmd(
     yes: bool = typer.Option(False, "--yes", "-y", help="Skip confirmation prompt."),
     include_ris: bool = typer.Option(False, "--include-ris", hidden=True, help="Alias for --all. Preserved for backward compatibility."),
     all_: bool = typer.Option(False, "--all", help="Also delete the RIS snapshot (ris.json.gz). By default, RIS is preserved across clears."),
+    global_: bool = typer.Option(
+        False, "--global",
+        help="Also empty the shared parse store (every repository's per-file parses).",
+    ),
 ) -> None:
     """Delete cached snapshots for a repository.
 
+    \b
     By default, RIS (ris.json.gz) is preserved — it is the persistent structural
     index used for cold-start bootstrapping.  Use --all to also clear it.
+
+    \b
+    --global additionally empties the shared parse store that `cache status`
+    reports. That store is content-addressed **across repositories**, so it is
+    not this repository's to clear selectively: the flag says so by being a
+    separate one, and the line it prints names the whole store.
     """
     from sourcecode import cache as _cm
     # Clear exactly the path given, for the same reason `cache warm` warms it:
@@ -13403,9 +13619,14 @@ def cache_clear_cmd(
         # The interactive prompt is only meaningful on a TTY; elsewhere it would
         # hang indefinitely waiting for input. Treat non-interactive as confirmed
         # (clear is idempotent cleanup; RIS is preserved unless --all is passed).
-        if sys.stdin.isatty():
-            import click as _click
-            _click.confirm(f"Delete all cache files for {target}{_ris_note}?", abort=True, err=True)
+        if _stdin_is_interactive():
+            if not _confirm(
+                f"Delete all cache files for {target}{_ris_note}?",
+                command="ask cache clear",
+                err=True,
+            ):
+                typer.echo("Aborted.", err=True)
+                raise typer.Exit(code=1)
         else:
             typer.echo(
                 f"Non-interactive: clearing cache for {target}{_ris_note}. "
@@ -13414,6 +13635,34 @@ def cache_clear_cmd(
             )
     removed = _cm.clear(target, clear_ris=_clear_ris)
     typer.echo(f"Removed {removed} file(s).")
+    # C3-104: a layer `cache status` publishes and `cache clear` cannot empty is
+    # a fact with no authority over it. The eviction is here; the notice is here
+    # too, because the operator who purges between versions is following our own
+    # advice and should not have to find `rm -rf` in the documentation.
+    if global_:
+        from sourcecode import parse_cache as _pc
+
+        store = _pc.clear_store()
+        typer.echo(
+            f"Removed {store['entries']} shared parse entrie(s), "
+            f"{store['bytes'] / (1024 * 1024):.1f} MB "
+            "(shared across every repository on this machine)."
+        )
+    else:
+        try:
+            from sourcecode import parse_cache as _pc
+
+            _store = _pc.store_stats()
+            if int(_store.get("entries", 0) or 0):
+                _notice(
+                    f"[ask] the shared parse store still holds "
+                    f"{_store['entries']} entries "
+                    f"({int(_store.get('bytes', 0) or 0) / (1024 * 1024):.1f} MB) — "
+                    "it is content-addressed across every repository. "
+                    "`ask cache clear --global` empties it."
+                )
+        except Exception:
+            pass
 
 
 def _warm_shared_cir(target: Path):
@@ -13794,9 +14043,14 @@ def cache_context_clear_cmd(
     """Delete the AI Context Cache for a repository (structured context + stats)."""
     from sourcecode import context_cache as _ctxcache
     target = _resolve_repo_root(Path(path))
-    if not yes and sys.stdin.isatty():
-        import click as _click
-        _click.confirm(f"Delete AI context cache for {target}?", abort=True, err=True)
+    if not yes and _stdin_is_interactive():
+        if not _confirm(
+            f"Delete AI context cache for {target}?",
+            command="ask cache context-clear",
+            err=True,
+        ):
+            typer.echo("Aborted.", err=True)
+            raise typer.Exit(code=1)
     removed = _ctxcache.clear_for_repo(target)
     typer.echo(f"Removed {removed} context file(s).")
 

sourcecode/gate_anchors.py

@@ -0,0 +1,42 @@
+"""gate_anchors.py — what the release gate measured, on the build that ran it.
+
+**Generated by `scripts/sync_gate_anchors.py` from `docs/perf/baselines/gate-latest/`.
+Do not edit by hand.** The baseline is the authority; this module is how a build
+carries it.
+
+C3-109. `cache_model`'s field anchors are the field's own measurements, on their
+repository and their machine — the reason they are trustworthy is the reason they
+cannot be refreshed here, and B17 reopened one release after closing because a
+refreshed anchor expires the moment the next release ships. This is the figure
+this project *can* re-measure every release: the gate's own population on a
+2 985-file repository, under a declared host class, with the build that produced
+it recorded beside it.
+
+It does not replace a field anchor and never overrides one. It is the second
+figure a reader gets — one measured at field scale on another build, one measured
+on this build on a repository we control — and the pair is honest in a way
+neither is alone.
+"""
+from __future__ import annotations
+
+#: The build the gate cells below were captured on.
+GATE_MEASURED_VERSION = '5.0.0'
+#: When, so a reader can tell a stale capture from a missing one.
+GATE_CAPTURED_AT = '2026-08-11T07:49:57Z'
+#: The repository the gate measures, and its size axis.
+GATE_REPOSITORY = 'BroadleafCommerce'
+GATE_JAVA_FILES = 2985
+#: The host class the runs are comparable within. Cross-machine numbers
+#: are recorded, never diffed (ADR-0006).
+GATE_HOST_CLASS = 'github-ubuntu-latest'
+
+#: command → measured wall time (p50 seconds), the cache mode it was
+#: taken in, and how many runs the median is over.
+GATE_ANCHORS: "dict[str, dict]" = {
+    'ask': {"seconds": 0.46, "mode": 'warm', "runs": 5},
+    'endpoints': {"seconds": 2.07, "mode": 'warm', "runs": 5},
+    'migrate-check': {"seconds": 8.72, "mode": 'warm', "runs": 5},
+    'posture': {"seconds": 2.89, "mode": 'warm', "runs": 5},
+    'spring-audit': {"seconds": 3.51, "mode": 'warm', "runs": 5},
+    'validation': {"seconds": 9.22, "mode": 'warm', "runs": 5},
+}

sourcecode/parse_cache.py

@@ -204,6 +204,49 @@ def purge_stale_generations() -> int:
     return removed
 
 
+def clear_store() -> "dict[str, int]":
+    """Empty the shared parse store — every generation, every entry (C3-104).
+
+    `cache status` publishes this layer and, until this existed, nothing could
+    evict it: `cache.clear()` deletes the per-repository core, view and snapshot
+    files, and the only surface here was `purge_stale_generations()`, which
+    deliberately keeps the current build's. The field purging for a from-scratch
+    audit had to be told `rm -rf ~/.sourcecode/parse-cache-v1` (6 684 files /
+    142,5 MB) — a path they learned from our documentation rather than from the
+    CLI, in the one workflow we actively recommend.
+
+    Global on purpose: the store is content-addressed **across repositories**, so
+    an entry cannot be attributed to one of them. Deleting "this repository's
+    entries" would mean deleting parses other repositories share, which is why
+    the surface is a separate flag and says what it clears.
+
+    Returns the entries and bytes removed. Best-effort like everything here: an
+    entry that cannot be removed is still a correct cache, and a missing entry is
+    only ever a miss.
+    """
+    root = _cache_root()
+    entries = 0
+    total = 0
+    if not root.exists():
+        return {"entries": 0, "bytes": 0}
+    for path in root.rglob("*"):
+        if path.is_file():
+            try:
+                total += path.stat().st_size
+            except OSError:
+                pass
+    for child in list(root.iterdir()):
+        if child.is_dir():
+            entries += _rmtree(child)
+        else:
+            try:
+                child.unlink()
+                entries += 1
+            except OSError:
+                continue
+    return {"entries": entries, "bytes": total}
+
+
 def enforce_budget(*, force: bool = False) -> "dict[str, object]":
     """Evict least-recently-used entries until the store fits its budget (F-AR).
 

sourcecode/perf.py

@@ -421,12 +421,31 @@ RELEASE_GATE_REPO = "broadleaf"
 RELEASE_GATE_REPO_URL = "https://github.com/BroadleafCommerce/BroadleafCommerce"
 RELEASE_GATE_REPO_SCALE = "~3 000 Java files"
 
-#: Warm, because that is the state a returning user is in and the state every
-#: field regression was measured in. Cold is dominated by the parse cache being
-#: empty, which each release invalidates by construction (C3-70) — gating on it
-#: would measure the cache, not the code.
+#: Warm, because that is the state a returning user is in — and it is the mode
+#: the gate *decides* on.
 RELEASE_GATE_MODE = "warm"
 
+#: **C3-108.** What the gate *measures*. Warm was the whole population for five
+#: releases, on the argument that "cold is dominated by the parse cache being
+#: empty, which each release invalidates by construction (C3-70), so gating on it
+#: would measure the cache, not the code". Half of that is right and the half that
+#: is wrong cost four rounds: an empty parse cache means the run pays the parser,
+#: and the parser is code — C3-95 and C3-96 were both found by measuring exactly
+#: that. Meanwhile every field report since #23 purges every layer first, so the
+#: regime the reports live in is the one regime nothing here measured, and four
+#: consecutive in-house A/Bs failed to reproduce a field regression.
+#:
+#: Cold cells are therefore **captured and published, and do not decide.** A cold
+#: median on an ephemeral runner carries the noise of a cold page cache as well as
+#: a cold parse store, which is not a base a release may be blocked on; but a cold
+#: cell that doubles between two releases is the evidence this project did not
+#: have, and the next report of a cold regression can be answered with a
+#: measurement instead of a shrug.
+RELEASE_GATE_MEASURED_MODES: tuple[str, ...] = ("warm", "cold")
+
+#: The modes a cell may fail the release on. One, deliberately: see above.
+RELEASE_GATE_DECIDING_MODES: tuple[str, ...] = ("warm",)
+
 #: ADR-0006 §5 floor for a cell that may be compared at all.
 RELEASE_GATE_MIN_RUNS = 5
 
@@ -485,21 +504,36 @@ def gate_report(
 
     ``require_min_runs`` fails a cell whose sample is below the ADR-0006 floor,
     for the same reason: a 1-run cell is not a measurement the gate may bless.
+
+    **C3-108: a cell may be measured without deciding.** Every cell is compared
+    and published; only cells whose mode is in `RELEASE_GATE_DECIDING_MODES` can
+    turn the verdict red. Cold cells are measured because the field measures cold
+    and nothing here did; they do not block a release because a cold median on an
+    ephemeral runner carries the noise of a cold page cache as well as a cold
+    parse store. Each cell says which it is (`decides`), so "the gate is green" is
+    never mistaken for "nothing moved".
     """
     cells: list[dict[str, object]] = []
     regressions: list[str] = []
     missing: list[str] = []
     under_sampled: list[str] = []
+    observed: list[str] = []
+
+    def _decides(cell: "Mapping[str, object] | None") -> bool:
+        mode = str((cell or {}).get("mode") or "")
+        return not mode or mode in RELEASE_GATE_DECIDING_MODES
 
     for cid in sorted(set(baseline_cells) | set(current_cells)):
         base = baseline_cells.get(cid)
         head = current_cells.get(cid)
         if head is None:
-            missing.append(cid)
+            decides = _decides(base)
+            (missing if decides else observed).append(cid)
             cells.append({
                 "cell": cid,
                 "status": "missing",
-                "passed": False,
+                "passed": not decides,
+                "decides": decides,
                 "reasons": ["measured in the baseline, not measured in this run"],
             })
             continue
@@ -508,17 +542,20 @@ def gate_report(
                 "cell": cid,
                 "status": "new",
                 "passed": True,
+                "decides": _decides(head),
                 "wall_ms": head.get("wall_ms"),
                 "reasons": ["no baseline cell — recorded, nothing to compare"],
             })
             continue
         runs = head.get("runs")
         if isinstance(runs, int) and runs < require_min_runs:
-            under_sampled.append(cid)
+            decides = _decides(head)
+            (under_sampled if decides else observed).append(cid)
             cells.append({
                 "cell": cid,
                 "status": "under-sampled",
-                "passed": False,
+                "passed": not decides,
+                "decides": decides,
                 "runs": runs,
                 "required_runs": require_min_runs,
                 "reasons": [
@@ -532,10 +569,20 @@ def gate_report(
             max_regression=max_regression,
             allow_incomparable=allow_incomparable,
         )
-        entry = {"cell": cid, **gate}
+        decides = _decides(head)
+        entry = {"cell": cid, **gate, "decides": decides}
+        if not gate.get("passed") and not decides:
+            # Measured, published, and explicitly not a blocker — the distinction
+            # C3-108 needs, because the alternative to publishing a cold cell that
+            # nobody may block on is not publishing it at all.
+            entry["passed"] = True
+            entry["reasons"] = list(gate.get("reasons") or []) + [
+                f"mode `{head.get('mode')}` is measured, not gated — see "
+                f"RELEASE_GATE_DECIDING_MODES"
+            ]
         cells.append(entry)
         if not gate.get("passed"):
-            regressions.append(cid)
+            (regressions if decides else observed).append(cid)
 
     passed = not (regressions or missing or under_sampled)
     return {
@@ -543,11 +590,17 @@ def gate_report(
         "threshold": max_regression,
         "gate_repository": RELEASE_GATE_REPO,
         "gate_mode": RELEASE_GATE_MODE,
+        "measured_modes": list(RELEASE_GATE_MEASURED_MODES),
+        "deciding_modes": list(RELEASE_GATE_DECIDING_MODES),
         "passed": passed,
         "cells_compared": len(cells),
         "regressions": regressions,
         "missing_cells": missing,
         "under_sampled_cells": under_sampled,
+        # C3-108: cells that moved (or went missing, or were under-sampled) in a
+        # mode the gate measures but does not decide on. Never empty by policy —
+        # it is empty when nothing moved there, which is a fact worth reading.
+        "observed_not_gated": observed,
         "excluded_commands": [
             {"command": cmd, "reason": why} for cmd, why in RELEASE_GATE_EXCLUSIONS
         ],
@@ -558,7 +611,9 @@ def gate_report(
             f"was not measured at all, or when a cell's sample is under "
             f"{require_min_runs} runs. Commands outside the gated population are "
             f"listed in `excluded_commands` — a green gate is a claim about the "
-            f"cells it names and about no others."
+            f"cells it names and about no others. Modes in `measured_modes` but "
+            f"not in `deciding_modes` are compared and published in "
+            f"`observed_not_gated`; they never turn the verdict red (C3-108)."
         ),
     }
 

sourcecode/verify_edit.py

@@ -217,6 +217,37 @@ def _build_head_cir_via_worktree(root: Path) -> Any:
         shutil.rmtree(tmp, ignore_errors=True)
 
 
+def _clean_tree_cir(root: Path) -> tuple[Any, bool]:
+    """The CIR of a tree git reports identical to HEAD — from the shared entry.
+
+    C3-102. C3-32 closed the second half of this: on a clean tree the *working*
+    CIR is the HEAD CIR, so it is not built twice. What was left is the first
+    half — the HEAD side still checked out a throwaway detached worktree and
+    parsed it, which on the field's repository is 76,6 s to answer *"you have
+    not edited anything"*, and 176,6 s in the round after.
+
+    When git says the tree does not differ from HEAD, the HEAD tree **is** the
+    worktree: copying it to a temp directory copies bytes that are already on
+    disk, and the shared repository-wide CIR for exactly this state is what
+    every other command on this repository has already built or will build.
+    `context_cache` keys that entry on `worktree_signature`, which on a clean
+    tree *is* the HEAD sha — the two lanes were separate for a reason that only
+    holds while the tree is dirty.
+
+    The shortcut is reached only through `git_answered` (C3-32's guard): a failed
+    `git diff` also returns an empty change set, and mistaking that for a clean
+    tree would turn an unknown into a confident *"nothing changed"*.
+    """
+    from sourcecode import context_cache as _ctx
+    from sourcecode.repository_ir import find_java_files
+
+    repo_root = _ctx.repo_root_of(root)
+    cached = _ctx.peek_cir(repo_root)
+    if cached is not None:
+        return cached, True
+    return _ctx.shared_cir(root, find_java_files(root)), False
+
+
 def _head_cir(root: Path, head_sha: str) -> tuple[Any, bool]:
     """Return ``(cir_head, cache_hit)``, caching the HEAD CIR by **HEAD sha**.
 
@@ -249,21 +280,41 @@ def _head_cir(root: Path, head_sha: str) -> tuple[Any, bool]:
                     pass  # corrupt payload — rebuild
 
     cir = _build_head_cir_via_worktree(root)
-    if cache.enabled:
-        try:
-            cache.put(
-                key,
-                CachedContext(
-                    metadata={"scope": SCOPE_JAVA_CIR, "head_sha": head_sha, "cir_hash": cir.cir_hash},
-                    graph_metrics={"symbol_count": len(cir.symbols), "endpoint_count": len(cir.endpoints)},
-                    payload={"raw_ir": cir._raw_ir},
-                ),
-            )
-        except Exception:
-            pass  # caching is best-effort; correctness never depends on it
+    _store_head_cir(root, head_sha, cir)
     return cir, False
 
 
+def _store_head_cir(root: Path, head_sha: str, cir: Any) -> None:
+    """Write *cir* into the HEAD-sha lane. Best-effort: correctness never depends on it.
+
+    Called from both lanes on purpose. A clean-tree run reads the shared entry
+    (C3-102) and would otherwise leave the edit lane cold, so the first edit
+    after it would pay the worktree checkout this row exists to remove — the
+    bytes are identical, and writing them costs one serialisation.
+    """
+    from sourcecode.context_cache import (
+        SCOPE_JAVA_CIR,
+        CachedContext,
+        ContextCache,
+        _cache_dir,
+    )
+
+    cache = ContextCache(_cache_dir(root.resolve()), head_sha)
+    if not cache.enabled:
+        return
+    try:
+        cache.put(
+            cache.knowledge_key(SCOPE_JAVA_CIR),
+            CachedContext(
+                metadata={"scope": SCOPE_JAVA_CIR, "head_sha": head_sha, "cir_hash": cir.cir_hash},
+                graph_metrics={"symbol_count": len(cir.symbols), "endpoint_count": len(cir.endpoints)},
+                payload={"raw_ir": cir._raw_ir},
+            ),
+        )
+    except Exception:
+        pass
+
+
 # ── entry point ─────────────────────────────────────────────────────────────────
 def head_vs_working(path: Path) -> HeadVsWorking:
     """Produce the ``(CIR_HEAD, CIR_working, changed_files)`` diff substrate.
@@ -284,10 +335,6 @@ def head_vs_working(path: Path) -> HeadVsWorking:
     changed_build = tuple(f for f in all_changed if _is_build_config_path(f))
     timings["changed_files_ms"] = (time.perf_counter() - t0) * 1000.0
 
-    t1 = time.perf_counter()
-    cir_head, hit = _head_cir(root, head_sha)
-    timings["head_cir_ms"] = (time.perf_counter() - t1) * 1000.0
-
     # C3-32: on a tree git reports as unmodified, the working CIR is the HEAD CIR
     # by construction — building it again was 94 s of dead cost on the field's
     # repository, paid *after* the change set was already known to be empty. The
@@ -295,6 +342,20 @@ def head_vs_working(path: Path) -> HeadVsWorking:
     # `git diff` also yields an empty list, and mistaking that for a clean tree
     # would turn an unknown into a confident "nothing changed".
     reused = git_answered and not all_changed
+
+    # C3-102: and the same fact decides the HEAD side, which is why it is read
+    # before the build rather than after it. A clean tree needs no worktree
+    # checkout: the tree on disk is HEAD, and its CIR is the shared one.
+    t1 = time.perf_counter()
+    if reused:
+        cir_head, hit = _clean_tree_cir(root)
+        if not hit:
+            # Keep the edit lane warm: the next run is the one with an edit in it.
+            _store_head_cir(root, head_sha, cir_head)
+    else:
+        cir_head, hit = _head_cir(root, head_sha)
+    timings["head_cir_ms"] = (time.perf_counter() - t1) * 1000.0
+
     t2 = time.perf_counter()
     cir_working = cir_head if reused else _build_cir(root)
     timings["working_cir_ms"] = (time.perf_counter() - t2) * 1000.0

{sourcecode-5.0.1.dist-info → sourcecode-5.1.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sourcecode
-Version: 5.0.1
+Version: 5.1.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-5.0.1-blue)
+![Version](https://img.shields.io/badge/version-5.1.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 5.0.1 — and, on a build that has aged,
+ask version                    # ask 5.1.0 — and, on a build that has aged,
                                # how many releases have probably shipped since
 ```
 

{sourcecode-5.0.1.dist-info → sourcecode-5.1.0.dist-info}/RECORD

@@ -1,4 +1,4 @@
-sourcecode/__init__.py,sha256=Vi4TJSP5-Nuef7bTyGWp6icmexh3SfDW_L2-OJMHyWk,308
+sourcecode/__init__.py,sha256=AQosRL48ISdUoMCE4htHdgvYGVNDHGx2oIMtrSEFoew,308
 sourcecode/adaptive_scanner.py,sha256=yJBKjNpkY6bpueYJ2YnRezen3sYZDecEt7WaaNWdqug,9466
 sourcecode/archetype.py,sha256=CZvRLpkHot_D8D3JFQVorr-EHDJyh0BbS7RnSTqBigM,40499
 sourcecode/architectural_baseline.py,sha256=4GiMVBLJVHvRKSWQGf2ZVurI1-R0qk5pmaevgvGSgVA,26325
@@ -9,7 +9,7 @@ sourcecode/ast_extractor.py,sha256=aXJjZ7XjAdxa99hWNm4SyzPqx4gNWiTbUYjNWGNl-Vc,5
 sourcecode/audit_report.py,sha256=CLvvlQH2oA6Qj4UADUWhNwSsp1OcyzwXXey5DN_IiWI,8660
 sourcecode/baseline_autocapture.py,sha256=tmMLexQSeaQRRbqxAd7walvGQqnF0mdpxQmkL40rlhI,15623
 sourcecode/cache.py,sha256=CK_J8NqyaTNZ57KQT-R4puqI8yYlzG5WL7uLFRbzods,41727
-sourcecode/cache_model.py,sha256=8xaRd_9zS6XMGPWZ7E6FHSimAG-pZQKNGQBi1jBFLhY,47724
+sourcecode/cache_model.py,sha256=w-pmiVRxzNO6BOqYwEQ6fPNXEPDhz0hSmJruX2byNAY,52868
 sourcecode/call_surface.py,sha256=fiqYfHooxN1fX9oQoysq1LS3LoZcobhyUNjAGEZKpwk,4148
 sourcecode/caller_metrics.py,sha256=--sFGDnIog_YGu9xZHMcB91F5xZakfaAKvy15xU54hg,7904
 sourcecode/caller_reach.py,sha256=RRF49tv4-QswraJ2vsZ89VAMOj7BmYXlAdXr-tLP_CA,9483
@@ -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=5sTk3jJ1Xh-JlnLiwN9bH0y3puiYejENXfl5iN0efrU,604917
+sourcecode/cli.py,sha256=KEYjMKuDdlsrmhfAa3c4MKKPVGywZtPYNNWQriQGrnc,617524
 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
@@ -59,6 +59,7 @@ sourcecode/file_classifier.py,sha256=pJCeN9KqWpAwKMCgGP4KDsBjuWMeo4zlbj5fv3hk9dA
 sourcecode/filter_surface.py,sha256=HeV1qU0y_UO95KNTy3Xb551zXvv7_ns2gyxCS5uC3fs,16418
 sourcecode/format_contract.py,sha256=e6GvU88TpV1QBq_BSZ6ZMpCq0gu07q7-zW7AjWb-xnI,6041
 sourcecode/fqn_utils.py,sha256=XLU7zDkNBXz_RZkIUNfpPmp1nekWtqP-fxV92tDV1vg,2158
+sourcecode/gate_anchors.py,sha256=26v8wUtzOk1K1Un5uXdUxAu20mqSPX3jo82zuM05ByE,2066
 sourcecode/git_analyzer.py,sha256=irvEwddbd5_tbA_eYUZebf4mH7_nFhpjwaWAV1f7jUY,15755
 sourcecode/git_checkout.py,sha256=gCnkMwHpU6yLyc10FoGzE8W9-tI8KyYxKTgpbWPjayo,6009
 sourcecode/graph_analyzer.py,sha256=lp0eB1PWC20BYF-GpPhAyegRpKrUKgOmXZIcZSIX_Ks,65777
@@ -78,11 +79,11 @@ sourcecode/openrewrite_recipe.py,sha256=4dyY5twRB6Xew-G9Zy5FafNZwlMU1S7DnRa2FqPk
 sourcecode/output_budget.py,sha256=GxoFnbwk0dvqScgmMRPZHj7m-zRIoHLwUKplrH0u89s,13872
 sourcecode/output_encoding.py,sha256=OxiZQtr7uWBDUtblNQviNHsTH1Xo9AZEpsegPlQWKFk,2139
 sourcecode/parallel.py,sha256=T9N-I8rtr43eXx2ZmKcmj2e62v6wsEKE9Y7zGNZ62TU,10224
-sourcecode/parse_cache.py,sha256=fhXnoaOgVWwp_8q0ngJ76UZ09qJ6uxDd0jaX8jdezvo,20826
+sourcecode/parse_cache.py,sha256=TpIoSeNUba4Aoaz5o5SmgAc0Tz02OKq1Du4Hw7HyJfg,22560
 sourcecode/partial_contract.py,sha256=x_N_0bF3mpNNjXd7JFB1zr6LSIroo2zN5GCz14GXvXQ,3510
 sourcecode/path_admission.py,sha256=OGNSoluhVh8YYOBZBnACUrkmH4Tp_yxjGLifkcsxQpo,5838
 sourcecode/path_filters.py,sha256=LmTYq735orssKTIuxTX1mE1FHAXF7dVEJEse35xE1RA,12371
-sourcecode/perf.py,sha256=ZCPxDIg6ww6PXfLwcqNTH99lc1UgkYUZI3MywFgRO90,25991
+sourcecode/perf.py,sha256=l5YW_BBKMRZb88yjzI9FnXpr21pgmQ7LPt1MZBYhf3k,29345
 sourcecode/phased_run.py,sha256=cFd0Lxfc8XL-XkCVCCzcjd9bZbtgkJkGZAHfmJ6dBJ4,16542
 sourcecode/pipe_contract.py,sha256=PML0Er5d8uDyec4OrdUXuyqHbGPUYndjeaKUjkFz2u4,8369
 sourcecode/posture.py,sha256=7d3zM4ExrSXVKrWNTlXQ0fUQNqDdl1LOuKwRVaXdRss,76574
@@ -142,7 +143,7 @@ sourcecode/tree_utils.py,sha256=8GAkIfQAsvtEudIeW1l4ooH_oRtrWR8cpJQJsEa_Pfw,2093
 sourcecode/type_usage_surface.py,sha256=51IrKRQoIoRnlsiDjHnqpJBn2rc6E59aRhgS0HTzAF0,4428
 sourcecode/validation_inference.py,sha256=-oWJqE6PqkqcZbCFDJeWCQHgI9Dbuv5ggJWD3LE_2IU,20817
 sourcecode/validation_surface.py,sha256=jYL-hkDjaaRKkAt7ZUcbxm3Dydl8o6KVRhTkuPXKPVc,31460
-sourcecode/verify_edit.py,sha256=O6nhDN3DLwr2RniMdWq7tSeVUkzlbfQfyBz5K_-o4SM,37608
+sourcecode/verify_edit.py,sha256=djBCZcDMEM71UFhls_J4oImYBu7CUeQOHPKzWrT9c9U,40288
 sourcecode/verify_repo.py,sha256=aHlNIUfoVVUxTXTNtSFryP4dOFBOvCfdyC31fFRXU6s,15346
 sourcecode/verify_rules.py,sha256=YxG5JkDXBVpwbU1_tIKVtU8_eaF3zjpsq05tjpN4Z7Y,19401
 sourcecode/version_check.py,sha256=CHp6ZxTIfo8kyHPCBgJA1uFC0xQCoXMuuOfrW8QTL8o,4942
@@ -206,8 +207,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-5.0.1.dist-info/METADATA,sha256=wKxYzyIT5zVAkDjb12M3Wzj2yyLMr-uklRY8AmRlHGI,42410
-sourcecode-5.0.1.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
-sourcecode-5.0.1.dist-info/entry_points.txt,sha256=-JEAdChrK5We51kZcb7OaDcyil-dHBjBPL-NhuO-QY8,89
-sourcecode-5.0.1.dist-info/licenses/LICENSE,sha256=7DdHrU9Z_3e7dSvq4ISijZNjnuHo5NIHNiHDouMQ9JU,10491
-sourcecode-5.0.1.dist-info/RECORD,,
+sourcecode-5.1.0.dist-info/METADATA,sha256=-w-kPbI2gq9YUOyXPsS8f-zgKHUVJBsbC_u-iXcgAZ0,42410
+sourcecode-5.1.0.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+sourcecode-5.1.0.dist-info/entry_points.txt,sha256=-JEAdChrK5We51kZcb7OaDcyil-dHBjBPL-NhuO-QY8,89
+sourcecode-5.1.0.dist-info/licenses/LICENSE,sha256=7DdHrU9Z_3e7dSvq4ISijZNjnuHo5NIHNiHDouMQ9JU,10491
+sourcecode-5.1.0.dist-info/RECORD,,