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

{specfuse_loop-0.22.1/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.1
+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.1 → specfuse_loop-0.22.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "specfuse-loop"
-version = "0.22.1"
+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.1 → specfuse_loop-0.22.3}/specfuse/agent/severity_backfill.py

@@ -37,9 +37,13 @@ from typing import Callable, Optional
 
 from specfuse.agent.invoke import run_claude
 from specfuse.agent.triage_invoke import build_invocation, classify_severity
-from specfuse.loop.labels import read_severity_rubric
+from specfuse.loop.labels import (
+    list_existing_labels,
+    read_severity_rubric,
+    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).
@@ -50,7 +54,13 @@ def _default_runner(argv: list, check: bool = False):
     return subprocess.run(argv, check=check, capture_output=True, text=True)
 
 
-def apply_severity_backfill(runner: Callable, repo: str, decisions: list) -> list:
+def apply_severity_backfill(
+    runner: Callable,
+    repo: str,
+    decisions: list,
+    *,
+    label_projection: "dict | None" = None,
+) -> list:
     """Record each decision in `decisions` against its GitHub issue, marker
     first, label second.
 
@@ -65,6 +75,13 @@ def apply_severity_backfill(runner: Callable, repo: str, decisions: list) -> lis
     amended marker in place -- the marker is the authoritative record, the
     label a projection re-derived from it (`PLAN.md`'s "Record
     precedence").
+
+    `label_projection` maps a vocabulary value to the label this repository
+    spells it with (`labels.severity_label_projection`, #3353). The marker
+    always records the vocabulary value, so it stays comparable across
+    repositories; only the label takes the operator's own word. Absent or
+    missing a value, the vocabulary label is written -- the behaviour before
+    the projection existed.
     """
     results = []
     for decision in decisions:
@@ -88,6 +105,7 @@ def apply_severity_backfill(runner: Callable, repo: str, decisions: list) -> lis
             "number": number,
             "severity": severity,
             "skipped": False,
+            "severity_source": decision.get("severity_source", "classifier"),
         }
 
         new_body = triage.amend_marker_severity(body, severity)
@@ -104,7 +122,19 @@ def apply_severity_backfill(runner: Callable, repo: str, decisions: list) -> lis
             continue
         row["marker_written"] = True
 
-        label = triage.severity_label_for(severity)
+        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)
+        )
         try:
             runner(
                 ["gh", "issue", "edit", str(number), "--repo", repo, "--add-label", label],
@@ -156,7 +186,14 @@ def run_backfill(
     once `apply_severity_backfill` has run over it, that function's own
     `skipped`/`marker_written`/`label_written` fields.
     """
-    rubric = read_severity_rubric(working_dir, runner=runner, repo=repo)
+    # One `gh label list` feeds both the rubric and the write-side
+    # projection (#3353): the once-per-run listing this run is asserted on.
+    existing, _listing_reason = list_existing_labels(
+        working_dir, runner=runner, repo=repo
+    )
+    rubric = read_severity_rubric(
+        working_dir, runner=runner, repo=repo, existing=existing
+    )
     if not rubric:
         return {
             "rubric": {},
@@ -180,6 +217,8 @@ def run_backfill(
             ),
         }
 
+    aliases = agent_policy.resolve_severity_aliases()
+
     rows = []
     decisions = []
     for issue in candidates:
@@ -187,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
         )
@@ -194,14 +258,24 @@ 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:
-        write_results = apply_severity_backfill(runner, repo, decisions)
+        # A property of the repository's label set, not of any one issue
+        # (#3353) -- derived from the listing already read above.
+        projection = severity_label_projection(
+            [item.get("name", "") for item in (existing or [])]
+        )
+        write_results = apply_severity_backfill(
+            runner, repo, decisions, label_projection=projection
+        )
         by_number = {result["number"]: result for result in write_results}
         for row in rows:
             result = by_number.get(row["number"])
@@ -238,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.1 → specfuse_loop-0.22.3}/specfuse/loop/agent_policy.py

@@ -363,10 +363,21 @@ def describe_budget_sources(**caps) -> str:
     that is not capped: the operator cannot tell which of the two they have.
     Each value is a `(value, source)` pair, source being `flag`, `policy` or
     `none`.
+
+    `max_items` carries an explicit `per run` (#3340). The policy key it comes
+    from is named `max_items_per_day` and is applied per run -- enforcing it
+    across a day needs state that survives a process. Printing `max_items=62
+    (policy)` against that key invites the reading the name suggests, and the
+    wrong reading is the unsafe one: a day of runs can exceed the number the
+    operator believes they set. Only this cap is annotated, because only this
+    one has a name promising something wider than it delivers; an unset cap
+    prints `unbounded` and needs no qualifier.
     """
     parts = []
     for name, (value, source) in sorted(caps.items()):
-        parts.append(f"{name}={'unbounded' if value is None else value} ({source})")
+        rendered = "unbounded" if value is None else str(value)
+        qualifier = " per run" if name == "max_items" and value is not None else ""
+        parts.append(f"{name}={rendered} ({source}{qualifier})")
     return "budgets: " + ", ".join(parts)
 
 

specfuse_loop-0.22.3/specfuse/loop/data/VERSION

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

{specfuse_loop-0.22.1 → specfuse_loop-0.22.3}/specfuse/loop/labels.py

@@ -402,11 +402,75 @@ def _ensure_severity_labels(target, *, runner, repo=None) -> list:
     return failed
 
 
+def severity_label_projection(label_names, *, aliases: Optional[dict] = None) -> dict:
+    """`{severity_value: label_name}` for the values a repository spells in its
+    own word (#3353), given the `severity:*` labels it defines.
+
+    `severity_aliases` (#3349) are honoured by the `min_severity` floor, which
+    reads an aliased label through `read_severity_label`. The classifier
+    FEAT-2026-0113 added answers in the published vocabulary instead, so the
+    write path projected `severity:high` at a repository whose issues all say
+    `severity:major` -- both spellings in circulation, and nothing reporting
+    the asymmetry.
+
+    This is the write-side half. The classifier is deliberately left answering
+    in the vocabulary so the marker's `severity=` field stays comparable across
+    repositories; only the *label* takes the repository's own word.
+
+    Pure over *label_names* rather than listing them itself, so the one caller
+    that needs both this and `read_severity_rubric` pays for a single
+    `gh label list` -- the once-per-run listing that run is asserted on.
+
+    Entries appear only where the projection actually differs, so an empty
+    result means "write the vocabulary label" and callers need no special case.
+    Two bounds keep it honest:
+
+    * **A label the repository does not define is never projected.** The
+      shipped `DEFAULT_SEVERITY_ALIASES` name words (`blocker`, `urgent`,
+      `trivial`) most repositories have never created; projecting one would
+      write a label that does not exist.
+    * **An in-vocabulary label always wins.** A repository defining both
+      `severity:high` and `severity:major` gets no entry for `high` -- the same
+      precedence `read_severity_rubric` applies when it builds the rubric.
+
+    Two aliases onto one value is the operator's own ambiguity. The lowest
+    label name sorts first, so a run is at least reproducible; defining the
+    vocabulary label is what removes the ambiguity.
+    """
+    prefix = agent_policy.SEVERITY_LABEL_PREFIX
+    try:
+        severity_names = sorted(
+            name for name in label_names if name.startswith(prefix)
+        )
+    except TypeError:
+        return {}
+
+    in_vocabulary = {
+        name[len(prefix):] for name in severity_names
+        if name[len(prefix):] in agent_policy.SEVERITY_VALUES
+    }
+
+    aliases = aliases if aliases is not None else agent_policy.resolve_severity_aliases()
+    projection: dict = {}
+    for name in severity_names:
+        word = name[len(prefix):]
+        if word in agent_policy.SEVERITY_VALUES:
+            continue
+        mapped = aliases.get(word.strip().lower())
+        if mapped not in agent_policy.SEVERITY_VALUES:
+            continue
+        if mapped in in_vocabulary or mapped in projection:
+            continue
+        projection[mapped] = name
+    return projection
+
+
 def read_severity_rubric(
     target: str | Path,
     *,
     runner: Optional[Callable] = None,
     repo: Optional[str] = None,
+    existing: Optional[list] = None,
 ) -> dict:
     """`{severity_value: description}` from the repo's own `severity:*` labels,
     or specfuse's `DEFAULT_SEVERITY_RUBRIC` when it has defined none (#3352).
@@ -428,7 +492,11 @@ def read_severity_rubric(
     """
     runner = runner if runner is not None else _default_runner
 
-    existing, _reason = list_existing_labels(target, runner=runner, repo=repo)
+    # `existing` lets a caller that already listed the repository's labels pass
+    # them in rather than pay for a second `gh label list` (#3353). Absent, the
+    # listing happens here exactly as it always did.
+    if existing is None:
+        existing, _reason = list_existing_labels(target, runner=runner, repo=repo)
     if existing is None:
         return {}
 

{specfuse_loop-0.22.1 → 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.1"
+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",