specfuse-loop 0.22.2__tar.gz → 0.22.3__tar.gz

{specfuse_loop-0.22.2/specfuse_loop.egg-info → specfuse_loop-0.22.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: specfuse-loop
-Version: 0.22.2
+Version: 0.22.3
 Summary: Local-first executor for the Specfuse Plan + Work Unit gate-cycle methodology.
 Author: Specfuse contributors
 License: Apache-2.0

{specfuse_loop-0.22.2 → specfuse_loop-0.22.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "specfuse-loop"
-version = "0.22.2"
+version = "0.22.3"
 description = "Local-first executor for the Specfuse Plan + Work Unit gate-cycle methodology."
 readme = "README.md"
 requires-python = ">=3.10"

{specfuse_loop-0.22.2 → specfuse_loop-0.22.3}/specfuse/agent/severity_backfill.py

@@ -43,7 +43,7 @@ from specfuse.loop.labels import (
     severity_label_projection,
 )
 
-from specfuse.loop import triage
+from specfuse.loop import agent_policy, triage
 from specfuse.loop.build_provenance import warn_if_out_of_tree
 
 #: Stands in for T10's classification session (gate 3, walking skeleton).
@@ -105,6 +105,7 @@ def apply_severity_backfill(
             "number": number,
             "severity": severity,
             "skipped": False,
+            "severity_source": decision.get("severity_source", "classifier"),
         }
 
         new_body = triage.amend_marker_severity(body, severity)
@@ -121,6 +122,16 @@ def apply_severity_backfill(
             continue
         row["marker_written"] = True
 
+        if decision.get("severity_source") == "label":
+            # Reconciled (#3360): the label IS the source of this severity, so
+            # it is already on the issue. Writing one would at best re-apply
+            # what is there and at worst add a second spelling beside the
+            # person's, which is the collision this path exists to avoid.
+            row["label_written"] = False
+            row["label_skipped_reason"] = "severity read from the issue's own label"
+            results.append(row)
+            continue
+
         label = (label_projection or {}).get(
             severity, triage.severity_label_for(severity)
         )
@@ -206,6 +217,8 @@ def run_backfill(
             ),
         }
 
+    aliases = agent_policy.resolve_severity_aliases()
+
     rows = []
     decisions = []
     for issue in candidates:
@@ -213,6 +226,31 @@ def run_backfill(
         title = issue.get("title", "")
         body = issue.get("body") or ""
 
+        # The label is consulted BEFORE any classification session (#3360): an
+        # issue a person already labelled must have its marker written from
+        # that label, never from a fresh opinion about it. This also means a
+        # reconciled issue costs no `claude` invocation at all.
+        action, labelled_severity, reason = triage.severity_decision(
+            issue.get("labels"), aliases)
+
+        if action == triage.SEVERITY_SKIP:
+            rows.append({
+                "number": number, "classified": False, "severity": None,
+                "severity_source": "label", "skipped_reason": reason,
+            })
+            continue
+
+        if action == triage.SEVERITY_RECONCILE:
+            rows.append({
+                "number": number, "classified": True,
+                "severity": labelled_severity, "severity_source": "label",
+            })
+            decisions.append({
+                "number": number, "body": body,
+                "severity": labelled_severity, "severity_source": "label",
+            })
+            continue
+
         argv, prompt = build_invocation(
             number, title, body, repo, working_dir, model=model, effort=effort, rubric=rubric
         )
@@ -220,11 +258,14 @@ def run_backfill(
         severity = classify_severity(invoked.text, rubric)
 
         if severity is None:
-            rows.append({"number": number, "classified": False, "severity": None})
+            rows.append({"number": number, "classified": False, "severity": None,
+                         "severity_source": "classifier"})
             continue
 
-        rows.append({"number": number, "classified": True, "severity": severity})
-        decisions.append({"number": number, "body": body, "severity": severity})
+        rows.append({"number": number, "classified": True, "severity": severity,
+                     "severity_source": "classifier"})
+        decisions.append({"number": number, "body": body, "severity": severity,
+                          "severity_source": "classifier"})
 
     if apply and decisions:
         # A property of the repository's label set, not of any one issue
@@ -271,7 +312,19 @@ def _print_run_report(report: dict) -> None:
         return
     for row in report["rows"]:
         if not row["classified"]:
-            print(f"#{row['number']}: no usable classification, skipped")
+            # A refusal to overwrite a person is not a classification failure,
+            # and #3360's re-run condition is read off these lines: it asks for
+            # zero rows the run would contradict, which is unanswerable if both
+            # print the same sentence.
+            reason = row.get("skipped_reason")
+            if reason:
+                print(f"#{row['number']}: left alone — {reason}")
+            else:
+                print(f"#{row['number']}: no usable classification, skipped")
+            continue
+        if row.get("severity_source") == "label":
+            print(f"#{row['number']}: severity={row['severity']} "
+                  f"(reconciled from its own label, not classified)")
             continue
         print(f"#{row['number']}: severity={row['severity']}")
 

specfuse_loop-0.22.3/specfuse/loop/data/VERSION

@@ -0,0 +1 @@
+0.22.3

{specfuse_loop-0.22.2 → specfuse_loop-0.22.3}/specfuse/loop/loop.py

@@ -125,7 +125,7 @@ SPECFUSE_DIR = Path(".specfuse")
 REPO_ROOT = SPECFUSE_DIR.parent
 FEATURES_DIR = SPECFUSE_DIR / "features"
 VERIFICATION_PATH = SPECFUSE_DIR / "verification.yml"
-DRIVER_VERSION = "0.22.2"
+DRIVER_VERSION = "0.22.3"
 # Oldest scaffold layout this driver can drive. init.sh stamps the scaffold's own
 # version into `.specfuse/VERSION`; check_scaffold_version() fails loud at startup if
 # the consumer's scaffold is older than this, pointing at `specfuse upgrade`. Bump
@@ -2244,6 +2244,34 @@ def untracked_paths() -> set[str]:
     return {line.strip() for line in out.splitlines() if line.strip()}
 
 
+def ignored_paths() -> set[str]:
+    """Repo-relative paths git reports as IGNORED, file by file.
+
+    Twin of :func:`untracked_paths`, snapshotted per-WU at dispatch so the
+    attempt-failure path can tell "this ignored file was already here" from
+    "this attempt produced it" (#3330). A `git reset --hard` restores tracked
+    content and leaves ignored files in place, so without this the baseline
+    attribution probe measures the failed attempt's own build output and
+    reports the failure as pre-existing.
+
+    `--ignored` is deliberately paired with `ls-files` rather than read off
+    `git status --porcelain --ignored`: status collapses a wholly-ignored
+    directory to a single entry, so `!! out/` is byte-identical before and
+    after an attempt adds files underneath it. That is precisely the reported
+    case -- `out/` already existed and the attempt wrote 11 new files into it --
+    and a snapshot diff over the status listing would have seen nothing.
+
+    Can be large on a repository carrying vendored dependency trees, so it is
+    called only on the failure path that actually probes, where it is cheap
+    beside the full gate-set run it precedes.
+    """
+    out = subprocess.run(
+        ["git", "ls-files", "--others", "--ignored", "--exclude-standard"],
+        capture_output=True, text=True, check=True,
+    ).stdout
+    return {line.strip() for line in out.splitlines() if line.strip()}
+
+
 def _tracked_dirty_paths() -> set[str]:
     """Paths with TRACKED, uncommitted changes (staged or unstaged), repo-relative.
 
@@ -3787,10 +3815,70 @@ def _clean_attempt_untracked(
             continue
 
 
+#: Ignored path prefixes the attempt-ignored clean never deletes. `work/` holds
+#: the per-attempt verify-output notes `persist_attempt_notes` writes (#168) --
+#: gitignored, and written AFTER the reset, so at the next attempt's reset they
+#: look exactly like the build output this clean exists to remove. The snapshot
+#: is taken once per WU rather than per attempt, so without this keep-list
+#: attempt 2 would delete attempt 1's evidence.
+IGNORED_CLEAN_KEEP_PREFIXES = ("work/", ".specfuse/")
+
+
+def _clean_attempt_ignored(
+    ignored_before: "set[str] | frozenset[str]", events_path: Path,
+) -> None:
+    """Delete gitignored files that appeared since the *ignored_before* snapshot.
+
+    Defect 1 of #3330. `_clean_attempt_untracked` above deliberately leaves
+    ignored paths alone, and that carve-out is load-bearing -- the driver's own
+    gitignored `work/` notes have to survive the reset. But it also leaves the
+    failed attempt's build output on disk, and the baseline attribution probe
+    then runs against it: in the reported incident a unit's own generated files
+    failed the probe, and the driver concluded the failure predated the feature
+    and halted a green branch.
+
+    Only files that appeared SINCE the snapshot are removed, which is what makes
+    this safe for the expensive case raised on #3371: a build cache present at
+    dispatch is in the snapshot and is never touched. Only what this attempt
+    produced goes.
+
+    Never deletes: paths in *ignored_before*, anything under
+    `IGNORED_CLEAN_KEEP_PREFIXES`, *events_path*, or a per-criterion close-state
+    file -- the same exclusions its untracked twin honours.
+
+    Best-effort: any git or filesystem error is swallowed, reverting to the old
+    leftover behaviour rather than crashing the run.
+    """
+    try:
+        root = Path(git("rev-parse", "--show-toplevel"))
+        candidates = ignored_paths() - set(ignored_before)
+    except (subprocess.CalledProcessError, OSError):
+        return
+    try:
+        keep = events_path.resolve()
+    except OSError:
+        keep = None
+    for rel in sorted(candidates):
+        if any(rel.startswith(p) or f"/{p}" in rel
+               for p in IGNORED_CLEAN_KEEP_PREFIXES):
+            continue
+        target = root / rel
+        try:
+            if keep is not None and target.resolve() == keep:
+                continue
+            if criteria_state.CRITERIA_FILENAME_RE.match(target.name):
+                continue
+            if target.is_file() or target.is_symlink():
+                target.unlink()
+        except OSError:
+            continue
+
+
 def reset_preserving_events(
     head_before: str,
     events_path: Path,
     untracked_before: "set[str] | frozenset[str] | None" = None,
+    ignored_before: "set[str] | frozenset[str] | None" = None,
 ) -> None:
     """`git reset --hard <head_before>` without losing events.jsonl content.
 
@@ -3828,6 +3916,12 @@ def reset_preserving_events(
     nothing untracked" and delete the entire untracked working tree; `None`
     means "no snapshot available, do not clean" and preserves the pre-#162
     behavior for callers that cannot supply one.
+
+    `ignored_before` (#3330 defect 1) does the same for GITIGNORED paths, and
+    is supplied by the one call site whose reset is followed by the baseline
+    attribution probe. Same inert-on-`None` contract. It is not passed on every
+    reset: the listing it diffs walks ignored trees, which is cheap beside the
+    gate-set run the probe performs and not worth paying where nothing probes.
     """
     saved = events_path.read_text() if events_path.is_file() else None
     git("reset", "--hard", head_before)
@@ -3835,6 +3929,8 @@ def reset_preserving_events(
         events_path.write_text(saved)
     if untracked_before is not None:
         _clean_attempt_untracked(untracked_before, events_path)
+    if ignored_before is not None:
+        _clean_attempt_ignored(ignored_before, events_path)
 
 
 def retain_tree_after_refusal(head_before: str, events_path: Path) -> str:
@@ -6485,6 +6581,7 @@ def baseline_evidence_diffstat(feat_fm: dict) -> "str | None":
 def format_preexisting_gate_failure(
     gate_number: int, failing_gates: list[dict], feat_fm: dict,
     done_unit_ids: "list[str] | None" = None,
+    attributed_to: "str | None" = None,
 ) -> str:
     """Render the `preexisting_gate_failure` halt as a message a non-expert
     operator can act on without reading driver source (FEAT-2026-0051/T03).
@@ -6497,6 +6594,22 @@ def format_preexisting_gate_failure(
     defer the feature. There is no "proceed anyway" option in v1: the waiver
     is future work tracked as FEAT-2026-0052, never offered here as if it
     already existed.
+
+    `attributed_to` names the work unit whose failed attempt triggered the
+    probe (#3330 defect 2). This message was written for a gate-entry probe,
+    where "zero work units were dispatched" was true; FEAT-2026-0109/T01 then
+    removed that probe, leaving attribution as the only path that renders it --
+    and on that path a unit *was* dispatched and its failure is what caused the
+    re-run. Left unsaid, every fresh-gate claim here is false exactly when the
+    message is shown.
+
+    The proof is softened on every path (#3371). A `git diff --stat` compares
+    TRACKED files, so it cannot see a check's gitignored inputs; `git reset
+    --hard` restores tracked files and leaves ignored ones behind, which is how
+    a failed attempt's own build output ends up failing the probe that is
+    supposed to exonerate it. Stating "the failure predates this feature" from
+    that diff reads as conclusive and cost one reported incident a bisect
+    across three commits.
     """
     # A RESUMED gate -- one where work units already ran and committed -- has a
     # baseline that INCLUDES this feature's own landed work, so the fresh-gate
@@ -6505,8 +6618,17 @@ def format_preexisting_gate_failure(
     # that a previous unit of the same gate had added two commits earlier.
     done_unit_ids = list(done_unit_ids or [])
     resumed = bool(done_unit_ids)
+    attributed = bool(attributed_to) and not resumed
 
-    if resumed:
+    if attributed:
+        lines = [
+            f"Gate {gate_number} is blocked: the automated checks it depends "
+            f"on failed on a probe the driver ran AFTER {attributed_to}'s "
+            f"attempt failed and its changes were reset.",
+            "",
+            "Failing check(s) found by that probe:",
+        ]
+    elif resumed:
         lines = [
             f"Gate {gate_number} is blocked: the automated checks it depends on "
             f"are failing, and this gate has ALREADY LANDED WORK.",
@@ -6526,7 +6648,14 @@ def format_preexisting_gate_failure(
             f"(signature: {g['failure_signature']})"
         )
     lines.append("")
-    if resumed:
+    if attributed:
+        lines.append(
+            f"{attributed_to} WAS dispatched and its attempt failed. The "
+            f"driver then reset the tree and re-ran the checks to ask whether "
+            f"the failure predated that attempt; the result above is what "
+            f"that probe found."
+        )
+    elif resumed:
         lines.append(
             f"{len(done_unit_ids)} work unit(s) in this gate are already `done` "
             f"and committed, so the baseline these checks measured includes this "
@@ -6554,12 +6683,16 @@ def format_preexisting_gate_failure(
             )
         else:
             lines.append(
-                "Proof the failing check(s)' input files are unchanged vs "
-                "the integration branch (so the failure predates this "
-                "feature; the diff below is the feature's own plan/scaffold "
-                "files, not code the failing check(s) read):"
+                "The failing check(s)' TRACKED input files are unchanged vs "
+                "the integration branch (the diff below is the feature's own "
+                "plan/scaffold files, not code the failing check(s) read):"
             )
         lines.append(diffstat)
+    elif attributed:
+        lines.append(
+            "Base-tree comparison unavailable (no integration branch could "
+            "be resolved, or the comparison itself failed)."
+        )
     else:
         lines.append(
             "Base-tree comparison unavailable (no integration branch could "
@@ -6567,9 +6700,41 @@ def format_preexisting_gate_failure(
             "check(s) above were still measured before any work unit ran, "
             "so the conclusion stands even without this proof."
         )
+    if not resumed:
+        # The limit of the proof above, stated wherever it is offered (#3371).
+        # A tracked diff is consistent with BOTH "pre-existing" and "left
+        # behind by this run", so naming what it cannot see is the difference
+        # between a reader checking `out/` first and bisecting the branch.
+        lines.append("")
+        lines.append(
+            "What that comparison does NOT cover: untracked and gitignored "
+            "paths. `git reset --hard` restores tracked files and leaves "
+            "ignored ones in place, so a check that reads a build or output "
+            "directory (`out/`, `target/`, generated-code trees, caches) can "
+            "fail on state this feature's own failed attempt produced. The "
+            "diff above cannot distinguish that from pre-existing breakage."
+        )
     lines.append("")
     lines.append("What to do next:")
-    if resumed:
+    if attributed:
+        lines.append(
+            "  1. Check for leftover untracked/ignored state from the reset "
+            "attempt FIRST — it is the cheapest to rule out and the most "
+            "likely cause. `git status --ignored --short` and `git clean -ndX` "
+            "list what survived; if a listed path feeds a failing check, that "
+            "is your answer."
+        )
+        lines.append(
+            "  2. Only if the tree is clean of those is this pre-existing "
+            "debt — confirm by running the failing check(s) on the "
+            "integration branch in a fresh checkout before assuming it."
+        )
+        lines.append(
+            f"  3. If it was leftover state, remove it and re-run; "
+            f"{attributed_to} is back at its previous attempt count and will "
+            f"be retried."
+        )
+    elif resumed:
         lines.append(
             "  1. Find which of this gate's landed work units introduced the "
             "failing check, and fix it ON THIS BRANCH. `git log -S<signature> "
@@ -10671,6 +10836,13 @@ def run(
                 # (#150). Captured here, not inside squash_commit, because by
                 # then the agent's own new files are indistinguishable from it.
                 untracked_before = untracked_paths()
+                # Ignored counterpart (#3330 defect 1), taken in the same
+                # breath: only the attempt-failure reset that precedes the
+                # baseline attribution probe consumes it, but it has to be
+                # captured HERE, before the agent runs, or the attempt's own
+                # build output is already indistinguishable from what was
+                # on disk when it started.
+                ignored_before = ignored_paths()
                 _is_rearm = detect_rearm_dispatch(wu)
                 if _is_rearm:
                     fold_cumulative_on_rearm(wu, backend)
@@ -11646,9 +11818,15 @@ def run(
                                 untracked_before=untracked_before)
                             print("   no FINDINGS metric — reset to base")
                     else:
+                        # `ignored_before` is passed HERE and nowhere else: this
+                        # is the one reset whose tree is then measured by the
+                        # attribution probe below, so it is the one place where
+                        # the attempt's own gitignored output would be read as
+                        # pre-existing breakage (#3330 defect 1).
                         reset_preserving_events(
                             head_before, events_path,
-                            untracked_before=untracked_before)
+                            untracked_before=untracked_before,
+                            ignored_before=ignored_before)
                         # Retroactive baseline attribution (FEAT-2026-0109/T01):
                         # decide, right after the reset above restores the
                         # tree the unit was dispatched against, whether this
@@ -11685,7 +11863,8 @@ def run(
                                         gate.number, _attr_failing, feat_fm,
                                         done_unit_ids=[
                                             u.wu_id for u in units
-                                            if u.status == "done"]))
+                                            if u.status == "done"],
+                                        attributed_to=wu.wu_id))
                                 wu_events.append(build_event(
                                     "human_escalation", feature_id, {
                                         "reason": "preexisting_gate_failure",

{specfuse_loop-0.22.2 → specfuse_loop-0.22.3}/specfuse/loop/triage.py

@@ -25,7 +25,11 @@ import json
 import re
 from typing import Callable, Optional
 
-from specfuse.loop.agent_policy import SEVERITY_LABEL_PREFIX
+from specfuse.loop.agent_policy import (
+    SEVERITY_LABEL_PREFIX,
+    SEVERITY_VALUES,
+    read_severity_label,
+)
 from specfuse.loop.escalation import CATEGORY_LABELS, NEEDS_HUMAN_LABEL
 from specfuse.monitor.issues import DEFAULT_LIST_LIMIT, has_finding_marker
 
@@ -359,6 +363,88 @@ def list_untriaged(runner: Callable, repo: str, limit: int = DEFAULT_LIST_LIMIT)
 _BACKFILL_PAGE_SIZE = DEFAULT_LIST_LIMIT
 
 
+#: What a backfill run should do with one candidate's severity (#3360).
+SEVERITY_CLASSIFY = "classify"
+SEVERITY_RECONCILE = "reconcile"
+SEVERITY_SKIP = "skip"
+
+
+def _severity_label_names(labels) -> list:
+    """The `severity:*` label names on an issue, however `labels` is shaped.
+
+    `gh issue list --json ...,labels` yields `{"name": ...}` mappings; callers
+    holding bare strings are accepted too so the decision below stays testable
+    without a fixture shape.
+    """
+    names = []
+    for label in labels or ():
+        name = label.get("name") if isinstance(label, dict) else label
+        text = str(name or "").strip().lower()
+        if text.startswith(SEVERITY_LABEL_PREFIX):
+            names.append(text)
+    return names
+
+
+def severity_decision(labels, aliases: Optional[dict] = None) -> tuple:
+    """`(action, severity, reason)` for one backfill candidate (#3360).
+
+    A candidate is selected on its MARKER -- already triaged, no `severity=`
+    field. That predicate never looked at the issue's labels, so an issue a
+    person had already labelled `severity:minor` was still a candidate: it got
+    a fresh classification, and the write path added a second severity label
+    beside the human's. `read_severity_label` then returns whichever it
+    recognises first, which is the agent silently overriding a person at the
+    `min_severity` floor.
+
+    So the label is consulted first, and when it states a severity the marker is
+    written FROM it:
+
+    * `SEVERITY_RECONCILE` -- the labels agree on one value. The issue stops
+      being stranded *and* the person's judgement is what gets recorded. No
+      classification session is spent, and no label is written, because the
+      label is already there and is the source.
+    * `SEVERITY_CLASSIFY` -- no `severity:*` label at all. The original path.
+    * `SEVERITY_SKIP` -- the labels resolve to more than one value (the
+      operator's own ambiguity), or a `severity:*` label is present that
+      nothing can read. Classifying either would put a second, readable label
+      beside one a human chose, which is the collision in a different spelling.
+
+    This was latent when FEAT-2026-0113 closed: the measured repository's
+    `critical`/`major`/`minor` scheme yielded a one-entry rubric, so the
+    classifier failed closed on exactly the issues that would have collided.
+    Shipping the default alias table (#3355) made that scheme readable, which
+    removed the mask rather than the hazard.
+    """
+    names = _severity_label_names(labels)
+    if not names:
+        return (SEVERITY_CLASSIFY, None, None)
+
+    resolved = set()
+    unreadable = []
+    for name in names:
+        value, _aliased_from = read_severity_label([name], aliases)
+        if value in SEVERITY_VALUES:
+            resolved.add(value)
+        else:
+            unreadable.append(name)
+
+    if len(resolved) > 1:
+        return (
+            SEVERITY_SKIP,
+            None,
+            f"labels resolve to more than one severity ({', '.join(sorted(resolved))}) "
+            f"— the marker is left alone rather than picking one",
+        )
+    if not resolved:
+        return (
+            SEVERITY_SKIP,
+            None,
+            f"carries {', '.join(sorted(unreadable))}, which no vocabulary value "
+            f"or alias reads — a person's judgement this run cannot interpret",
+        )
+    return (SEVERITY_RECONCILE, resolved.pop(), None)
+
+
 def _is_backfill_candidate(issue: dict) -> bool:
     body = issue.get("body") or ""
     fields = parse_marker_fields(body)

{specfuse_loop-0.22.2 → specfuse_loop-0.22.3/specfuse_loop.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: specfuse-loop
-Version: 0.22.2
+Version: 0.22.3
 Summary: Local-first executor for the Specfuse Plan + Work Unit gate-cycle methodology.
 Author: Specfuse contributors
 License: Apache-2.0

{specfuse_loop-0.22.2 → specfuse_loop-0.22.3}/specfuse_loop.egg-info/SOURCES.txt

@@ -196,6 +196,7 @@ tests/test_attempt_outcome_emission.py
 tests/test_attention_nonwriting_guard.py
 tests/test_attention_silence_section.py
 tests/test_attention_skill_structure.py
+tests/test_attribution_halt_claims.py
 tests/test_autoclose_deferral_visibility.py
 tests/test_autoclose_gate_note.py
 tests/test_autoclose_stub_states_what_passed.py
@@ -369,6 +370,7 @@ tests/test_human_output_rule.py
 tests/test_human_work_unit.py
 tests/test_hygiene_boundary_guidance.py
 tests/test_hyphenated_gate_name.py
+tests/test_ignored_cleanup_before_probe.py
 tests/test_init_integration.py
 tests/test_installed_copy_driver_e2e.py
 tests/test_interpreter_normalization.py
@@ -558,6 +560,7 @@ tests/test_severity_backfill_limit.py
 tests/test_severity_backfill_marker.py
 tests/test_severity_backfill_run.py
 tests/test_severity_label_projection.py
+tests/test_severity_reconciliation.py
 tests/test_severity_rubric.py
 tests/test_shipped_templates_parse.py
 tests/test_skill_discovery_links.py