What causes "oracle sanitization could not verify removal of the {label}" in abhigyanpatwari/GitNexus?

Re-run the probe manually: `git -C cat-file -e ; echo "exit=$?"` and inspect the code.

abhigyanpatwari/GitNexus · error · ValueError

oracle sanitization could not verify removal of the {label}

Error message

oracle sanitization could not verify removal of the {label}

What it means

For each forbidden object, `git cat-file -e` must either succeed-in-the-good-sense is failure here — the harness expects non-existence. The expected not-found terminal states are exit codes 1 or 128 with state 'exited'. Any other state (timeout, forced-kill, reap-failure, spawn-failure) or unexpected exit code means the harness cannot prove removal, so it refuses to guess.

Source

Thrown at eval/workflow_bench/oracle_assets.py:439

        tail_bytes=MAX_CLONE_REF_BYTES,
    )
    if fsck.stdout_tail.strip() or fsck.stderr_tail.strip():
        raise ValueError("oracle sanitization left unreachable Git objects recoverable")

    forbidden_objects: list[tuple[str, str]] = []
    if original_head != sanitized_head:
        forbidden_objects.append((original_head, "original commit"))
    if hidden_tree:
        forbidden_objects.append((hidden_tree, "hidden harness tree"))
    for forbidden_object, label in forbidden_objects:
        probe = run_managed(
            ["git", "-C", str(root), "cat-file", "-e", forbidden_object],
            timeout=60,
        )
        if probe.ok:
            raise ValueError(f"oracle sanitization left the {label} recoverable")
        if probe.state != "exited" or probe.returncode not in {1, 128}:
            raise ValueError(f"oracle sanitization could not verify removal of the {label}")

    hidden_listing = _git_checked(
        root,
        ["ls-tree", "-r", "--name-only", "HEAD", "--", HIDDEN_HARNESS_PATH.as_posix()],
        timeout=60,
    )
    if hidden_listing or current.exists() or current.is_symlink():
        raise ValueError("oracle sanitization left the benchmark harness visible")
    if _git_checked(root, ["status", "--porcelain=v1", "--untracked-files=all"], timeout=60):
        raise ValueError("oracle sanitization did not produce a clean task snapshot")
    if _git_checked(root, ["rev-parse", "--verify", "HEAD^{commit}"], timeout=60) != sanitized_head:
        raise ValueError("oracle sanitization did not retain its parentless task snapshot")
    parents = _git_checked(root, ["show", "-s", "--format=%P", "HEAD"], timeout=60)
    if parents:
        raise ValueError("oracle sanitization snapshot unexpectedly retained parent history")
    if _git_checked(root, ["remote"], timeout=60):
        raise ValueError("oracle sanitization retained a repository remote")
    if logs.exists() or logs.is_symlink():

View on GitHub (pinned to d540b00184)

Solutions

Re-run the probe manually: `git -C <clone> cat-file -e <sha>; echo "exit=$?"` and inspect the code.
Run `git -C <clone> fsck --full` to detect corruption; repair or re-clone.
Ensure the clone is on local fast storage (the probe has a 60s timeout) and no concurrent git process is active.

Defensive patterns

Strategy: try-catch

Validate before calling

from pathlib import Path
from eval.workflow_bench.process_control import run_managed

def removal_is_verifiable(clone: Path, sha: str) -> bool:
    r = run_managed(["git", "-C", str(clone), "cat-file", "-e", sha], timeout=60)
    return r.state == "exited" and r.returncode in (1, 128)

Type guard

def is_removal_unverifiable(exc: BaseException) -> bool:
    return isinstance(exc, ValueError) and "could not verify removal" in str(exc)

Try / catch

try:
    oracle_assets.sanitize_clone_for_hidden_oracles(clone)
except ValueError as exc:
    quarantine(clone)
    raise AbortTask(str(exc)) from exc

Prevention

Keep benchmark clones on local SSDs so git probes stay well under the 60s budget.
Run sanitization as the only git process touching the clone.

When it happens

Trigger: Triggered when cat-file -e neither cleanly reports missing (exit 1/128) nor the process exited normally — e.g., git crashed, the repo is corrupt, the probe timed out, or the process was force-killed.

Common situations: Corrupt object store causing git to segfault or error oddly; very slow disk making the 60s probe time out; a concurrent writer changing state mid-probe; a broken git binary.

Related errors

AI-assisted analysis of abhigyanpatwari/GitNexus@d540b00184 (2026-08-12). Data as JSON: /api/errors/e102a9b403831be2. Report an issue: GitHub.