abhigyanpatwari/GitNexus · error · RuntimeError

sanitized graph snapshot is unavailable

Error message

sanitized graph snapshot is unavailable

What it means

Raised inside the per-arm run loop when graph_snapshot is None and no preparation error was recorded — i.e. the sanitized graph snapshot was never produced (or was reset) and is unavailable for this arm. The sandboxed session needs the graph snapshot to run, so a None snapshot with no recorded cause is treated as a hard failure rather than running an arm with no graph state.

Source

Thrown at eval/workflow_bench/runner.py:1070

                graph_snapshot_error = exc
                graph_snapshot_errors[graph_key] = exc
            per_arm: dict[str, list[dict[str, Any]]] = {a: [] for a in args.arms}
            for run_idx in range(args.runs):
                if outage_tripped:
                    break
                for arm in args.arms:
                    if outage_tripped:
                        break
                    worktree: Path | None = None
                    record: dict[str, Any] | None = None
                    cleanup_error: OSError | None = None
                    try:
                        if asset_snapshot_error is not None:
                            raise RuntimeError(f"task asset snapshot preparation failed: {asset_snapshot_error}")
                        if graph_snapshot_error is not None:
                            raise RuntimeError(f"sanitized graph snapshot preparation failed: {graph_snapshot_error}")
                        if graph_snapshot is None:
                            raise RuntimeError("sanitized graph snapshot is unavailable")
                        if asset_snapshot is None:
                            try:
                                asset_snapshot = task_asset_cache.prepare(
                                    task,
                                    repo=repo,
                                    resolved_sha=task_sha,
                                    expected_dependency_binding=task_binding,
                                )
                            except (OSError, SandboxError, ValueError) as exc:
                                asset_snapshot_error = exc
                                raise
                        worktree = make_worktree(repo, task_sha, Path(trees))
                        sanitized_head = sanitize_clone_for_hidden_oracles(worktree)
                        graph_snapshot.materialize(worktree, sanitized_head=sanitized_head)
                        dependency_mounts = stage_task_assets(
                            task,
                            repo=repo,
                            clone=worktree,

View on GitHub (pinned to d540b00184)

Solutions

  1. Confirm graph snapshot preparation is actually invoked for the task before the arm loop (the prepare() call must run and either set graph_snapshot or graph_snapshot_error).
  2. Check args/config that gate graph preparation (e.g. a --no-graph or skip flag) and remove it if the arm needs the graph.
  3. If preparation ran but produced None, trace why prepare returned None and fix the producer.
  4. Re-run with graph preparation enabled so graph_snapshot is populated.

Example fix

// before — graph prep skipped via flag, snapshot stays None
if args.skip_graph:
    graph_snapshot = None   # then arm loop raises 'unavailable'
// after — let preparation run so a snapshot is produced
graph_snapshot = graph_cache.prepare(task, repo=repo, resolved_sha=task_sha)
Defensive patterns

Strategy: validation

Validate before calling

if graph_snapshot is None and graph_snapshot_error is None:
    raise RuntimeError('sanitized graph snapshot is unavailable')
# ensure graph_cache.prepare(...) is actually invoked upstream so graph_snapshot is set

Prevention

When it happens

Trigger: The loop reaches the run block with graph_snapshot is None and graph_snapshot_error is None — preparation did not run, was skipped, or the snapshot was cleared without an error being captured.

Common situations: A code path that short-circuited graph preparation without setting the error variable; a config flag combination that disables graph preparation but still enters the arm loop; an earlier cleanup that reset graph_snapshot to None; a regression that drops the prepare() call.

Related errors

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