diff --git a/.dockerignore b/.dockerignore index 7add0f6..d5001e9 100644 --- a/.dockerignore +++ b/.dockerignore @@ -9,5 +9,9 @@ benchmark/* !benchmark/__init__.py !benchmark/codex_adapter/ !benchmark/codex_adapter/** +!benchmark/astra/ +benchmark/astra/* +!benchmark/astra/__init__.py +!benchmark/astra/pro_lane.py !benchmark/container/ !benchmark/container/** diff --git a/.superpowers/sdd/2026-09-07-astra-public-benchmark/task-pro-report.md b/.superpowers/sdd/2026-09-07-astra-public-benchmark/task-pro-report.md new file mode 100644 index 0000000..1fded45 --- /dev/null +++ b/.superpowers/sdd/2026-09-07-astra-public-benchmark/task-pro-report.md @@ -0,0 +1,49 @@ +# SWE-bench Pro Container Lane Report + +Implemented the minimal in-container Pro solver lane without running model inference or changing +the benchmark protocol. + +## Delivered + +- `benchmark/astra/pro_lane.py`: validates the instance ID, exact lowercase base commit, condition, + fixed input paths, repository root, and non-existing output before mutation. It archives the base + tree, retains ignored installed dependencies, removes future/current tracked content and original + Git metadata, creates a deterministic detached single-commit snapshot, verifies tree equality and + history size, rejects base trees containing gitlinks before mutation, purges nested Git metadata, + forwards the unchanged public prompt to `run_task`, and records original/snapshot commit and tree + hashes. +- `benchmark/astra/pro/Dockerfile.solver`: layers on a controller-supplied task image, uses pinned + amd64 Alpine Node and uv builder manifests, installs Codex 0.153.4 with the existing wrapper, + adds an independent musl Python 3.12.11 runtime, installs MARGINAL/benchmark packages into that + runtime's site-packages, records source/task/tool labels, and invokes the lane CLI from `/app`. +- `.dockerignore`: admits only the Astra package files required by the solver image. +- `tests/benchmark/test_astra_pro_lane.py`: focused repository-isolation, validation, overwrite, and + forwarding tests. + +## Verification + +```text +$ .venv/bin/python -m pytest -q tests/benchmark/test_astra_pro_lane.py +...... [100%] +7 passed in 2.24s +``` + +```text +$ .venv/bin/ruff check benchmark/astra/pro_lane.py tests/benchmark/test_astra_pro_lane.py +All checks passed! +``` + +The image build uses task image +`jefzda/sweap-images@sha256:d902632d1374cf0282a4ea301b82c296e13a41127308da0204aca87a4ba62c02`. +Despite earlier evaluator metadata describing Ubuntu 20.04/Python 3.8, this exact image is Alpine +Linux 3.18.3. The solver therefore uses musl-compatible Node and standalone Python binaries. Its +final image ID and no-inference executable smoke checks are recorded below once complete. + +## Concerns + +- Repository sanitization is intentionally destructive and is safe only because the official task + container is disposable. +- Ignored dependency retention depends on the base tree's ignore rules. The verified snapshot tree + contains only tracked base-commit files; ignored dependency content remains outside Git. +- Base commits containing gitlinks are rejected as unsupported infrastructure before mutation. +- No solver/model request was made during implementation or verification. diff --git a/README.md b/README.md index 62b5cd1..6793d37 100644 --- a/README.md +++ b/README.md @@ -68,6 +68,27 @@ marginal install codex --autopilot-consent ## How MARGINAL earns authority +### GPT-6 Astra + +The exact model ID `gpt-6-astra` has its own evidence namespace, `openai/gpt-6-astra`. +When Codex hooks identify that model, decisions and outcomes are recorded locally as work +happens. Existing unlabelled evidence is not reassigned to Astra. Commons sharing remains opt-in. + +A real Astra request was verified with Codex CLI **0.153.4**; **0.147.0** was rejected by the +provider. This is a tested version, not a claim that every intermediate version is unsupported. + +**Astra token savings are not yet demonstrated.** Shadow Mode observes work; it does not +reduce the model's internal reasoning budget. The complete public OFF/ON evaluation is still +outstanding. See [Astra evaluation status](benchmark/astra/README.md) for exact preflight facts +and what remains before a performance claim is justified. + +The [SWE-bench Pro protocol and evidence](benchmark/astra/pro/README.md) include all 731 +planned task IDs and the first passing official reference check. That reference check is +not a model score. A complete OFF/ON run requires 1,462 model executions; no complete +performance result is claimed until those executions and their grading are available. + +### Evidence gates + 1. **Observe** — collect derived action, outcome, coverage, state and evidence signals locally. 2. **Verify** — bind decisions, policy identity, trust state and governance cost into Decision Receipts. 3. **Earn** — require representative local evidence, clean coverage and explicit promotion. diff --git a/benchmark/astra/README.md b/benchmark/astra/README.md new file mode 100644 index 0000000..86dda64 --- /dev/null +++ b/benchmark/astra/README.md @@ -0,0 +1,57 @@ +# GPT-6 Astra evaluation status — updated 2026-09-08 + +**No complete Astra OFF/ON benchmark has been executed. No token-saving claim is supported.** + +This directory records preflight facts, not benchmark results. Product integration tests and a +successful model request do not demonstrate improved task quality or lower token use. + +The active experiment is [SWE-bench Pro](pro/README.md). Its complete 731-task manifest, +protocol and first official reference-validation artifacts are published there. HumanEval+ +preparation was withdrawn before any scored model inference. + +## Frozen public benchmark inputs + +- Dataset: [ScaleAI/SWE-bench_Pro](https://huggingface.co/datasets/ScaleAI/SWE-bench_Pro), + revision `7ab5114912baf22bb098818e604c02fe7ad2c11f`, complete `test` split: **731 tasks**. +- Evaluator: [scaleapi/SWE-bench_Pro-os](https://github.com/scaleapi/SWE-bench_Pro-os), + commit `ca10a60a5fcae51e6948ffe1485d4153d421e6c5`. +- A single complete OFF/ON comparison requires **1,462 independent task executions**, followed + by official grading. It is not equivalent to 1,462 unit tests or grading empty patches. +- Intended model: `gpt-6-astra`, with identical reasoning effort, prompts, tools, limits and + independent state in both conditions. No task has been selected based on its model outcome. + +## Observed preflight + +| Check | Observation | +| --- | --- | +| Codex 0.147.0 + Astra | Provider rejected the request and required a newer Codex version | +| Codex 0.153.4 + Astra | Minimal no-tool request completed successfully | +| Successful request usage | 16,474 input; 11,520 cached input; 7 output; 0 reasoning output | +| Docker | Existing local benchmark VM started; Docker 29.5.2, 6 CPUs, about 12 GiB RAM | +| Existing task images | Three historical Lite smoke images retained; first Pro image downloaded | +| First deterministic Pro image | Pinned in [Pro preflight](pro/preflight.json); actual OS is Alpine 3.18.3 | +| Official Pro grading | First reference patch passed; 1,350.20 seconds under x86 QEMU | +| Scored Astra task trajectories | **0 baseline / 0 MARGINAL** | + +The successful no-tool request is an API/CLI compatibility probe only. Its input token count +includes the Codex scaffold and cannot be extrapolated into a reliable per-task cost estimate. +Cached input and reasoning output are subsets, not additional tokens to sum twice. + +## Required before results can be published + +1. Adapt and validate the runner against current Codex and official Pro task environments. + The historical Lite adapter is not a verified Pro execution backend. +2. Pin images and prompts; validate the evaluator on reference patches in isolated containers. +3. Publish the executable protocol before scored inference. The dataset pins above alone are + **not** a complete preregistration. +4. Run all 731 tasks in each condition without exposing reference patches or grading tests + to the solving agent. Preserve failures, timeouts and every task ID. +5. Publish sanitized predictions, per-task usage, official grading, intervention traces, + environment hashes and analysis. Report correctness and governance overhead together. + +The sprint reserves 20% of the short Codex quota window for validation and publication. A +quota stop must remain visibly incomplete; it cannot become a fabricated full benchmark, +a smaller benchmark labelled Pro, or a claim that default Shadow Mode saves reasoning tokens. + +HumanEval+ was considered as a lower-cost alternative but has not been run or substituted +for the requested real-repository comparison. No external leaderboard certification is claimed. diff --git a/benchmark/astra/__init__.py b/benchmark/astra/__init__.py new file mode 100644 index 0000000..305f662 --- /dev/null +++ b/benchmark/astra/__init__.py @@ -0,0 +1 @@ +"""Astra public-benchmark orchestration.""" diff --git a/benchmark/astra/humaneval-plus/Dockerfile.evaluator b/benchmark/astra/humaneval-plus/Dockerfile.evaluator new file mode 100644 index 0000000..93bc2fb --- /dev/null +++ b/benchmark/astra/humaneval-plus/Dockerfile.evaluator @@ -0,0 +1,11 @@ +FROM ganler/evalplus@sha256:26b118098bef281fe8dfe999bf05f1d5b45374b4e6c00161ec0f30592aef4740 + +COPY evaluator-requirements.txt /tmp/evaluator-requirements.txt +RUN python -m pip install --no-deps --require-hashes -r /tmp/evaluator-requirements.txt \ + && python -c 'import importlib.metadata; assert importlib.metadata.version("evalplus") == "0.3.1"' + +ENV PYTHONDONTWRITEBYTECODE=1 \ + XDG_CACHE_HOME=/tmp/evalplus-cache \ + HUMANEVAL_OVERRIDE_PATH=/data/HumanEvalPlus.jsonl + +ENTRYPOINT ["evalplus.evaluate"] diff --git a/benchmark/astra/humaneval-plus/README.md b/benchmark/astra/humaneval-plus/README.md new file mode 100644 index 0000000..6170837 --- /dev/null +++ b/benchmark/astra/humaneval-plus/README.md @@ -0,0 +1,51 @@ +# Astra × MARGINAL — full HumanEval+ protocol + +**Withdrawn before scored inference.** The user requires SWE-bench Pro. No model samples +were generated for this suite. The reference-only evaluator check passed 163/164 tasks; +its remaining failure was not investigated after the scope correction. This directory is +retained for traceability, not as a performance result or an active preregistration. + +This is a **function-level** OFF/ON experiment, not SWE-bench Pro. No result is claimed +until all 164 tasks have both a real model run and official grading. + +## What is being tested + +The same Codex 0.153.4 agent and GPT-6 Astra (`low` reasoning) implement every HumanEval+ +v0.1.10 function twice, in separate clean workspaces. Baseline has no MARGINAL benchmark +adapter; ON uses the existing balanced/diminishing-return experimental enforcement adapter. +The installed plugin's default Shadow Mode is **not** this intervention. + +Each task starts with only its public function prompt in `solution.py`. Reference solutions +and official base/extra test inputs are not provided to the solver. The solver may perform +local checks, but may not use the network or files outside its workspace. Execution traces +must be audited for violations before any results are admitted. No extra repetition is +requested to make MARGINAL look effective. + +## Frozen conditions + +The machine-readable [protocol](protocol.json) records task/data hashes, order, model, +reasoning, timeout, concurrency, analysis and stop rules. Runner source revision, evaluator +image digest and exact prompt hash are recorded and published before scored inference. +All original tasks and all extra tests are included; neither `mini` nor `noextreme` is used. + +Correctness is primary: official base **and** extra tests must pass. Failed, timed-out, +missing-usage and infrastructure-invalid lanes remain visible. They are never silently +replaced with another attempt. The complete experiment requires 328 recorded lanes. + +Token accounting uses provider-reported totals and includes all calls, including recovery +work. Cached input is part of input, and reasoning output is part of output. They are not +added twice. Subscription quota is not a dollar bill. Unavailable costs stay unavailable. + +## Reading the eventual result + +Report paired correctness, token use, tool calls, elapsed time, intervention counts and +governance overhead together. Report overall results and the both-solve subset separately. +A zero-regression sample is an observation, not a statistical proof of equivalence. One +sample per task cannot establish production reliability; a public function benchmark may +also be saturated or present in model training data. + +Negative, zero-effect and inconclusive results are valid. This experiment cannot justify +claiming that installing the default plugin reduces Astra's internal reasoning tokens. + +Sources: [EvalPlus v0.3.1](https://github.com/evalplus/evalplus/tree/e5d0ed0bab96280b60b637ec7f15b5e4841b0cb2), +[HumanEval+ v0.1.10](https://github.com/evalplus/humanevalplus_release/releases/tag/v0.1.10). diff --git a/benchmark/astra/humaneval-plus/evaluator-requirements.txt b/benchmark/astra/humaneval-plus/evaluator-requirements.txt new file mode 100644 index 0000000..c944c55 --- /dev/null +++ b/benchmark/astra/humaneval-plus/evaluator-requirements.txt @@ -0,0 +1 @@ +evalplus==0.3.1 --hash=sha256:cd601debb67419113d10ac5c3317689d847f27de5d8cf3837975f3cab571b75d diff --git a/benchmark/astra/humaneval-plus/protocol.json b/benchmark/astra/humaneval-plus/protocol.json new file mode 100644 index 0000000..be7eb3b --- /dev/null +++ b/benchmark/astra/humaneval-plus/protocol.json @@ -0,0 +1,41 @@ +{ + "schema_version": 1, + "experiment": "astra-humaneval-plus-20260907", + "status": "withdrawn_before_scored_inference_user_requires_swe_bench_pro", + "dataset": "HumanEval+", + "dataset_version": "v0.1.10", + "dataset_sha256": "42526ec0e7d5f3ee0b06d6ced98f8c8bae3d76519151bfb3d36f79010645bd7f", + "task_inputs_sha256": "8fbac146a932a0e1bdbccf8b0596061d43312dc20143960c48b66029d2dbf425", + "task_count": 164, + "conditions": ["baseline", "marginal"], + "repetitions": 1, + "model": "gpt-6-astra", + "model_snapshot": "public alias; immutable provider weight snapshot unavailable", + "codex_version": "0.153.4", + "evaluator_version": "evalplus==0.3.1", + "evaluator_image_id": "sha256:a90b5cd691de7334d203b64435aaf1ef10701acf90eeb4455703df3724b5e6aa", + "reasoning_effort": "low", + "timeout_seconds": 180, + "concurrency": 2, + "task_order": "ascending sha256(task_id UTF-8)", + "condition_order": "baseline first at even task positions, marginal first at odd positions", + "baseline": "Codex without MARGINAL benchmark hooks or daemon", + "marginal": "existing benchmark adapter: balanced policy, default diminishing-return detector, experimental enforce, unlimited hard budgets", + "native_shadow_equivalent": false, + "reference_tests_available_to_solver": false, + "solutions_per_task_condition": 1, + "quality_primary": "official HumanEval+ base AND extra tests pass@1", + "failures": "retain every task; no re-solving after inspecting grading; timeouts and invalid infrastructure reported separately", + "quality_gate": "no observed baseline-only regressions; descriptive criterion, not a non-inferiority proof", + "efficiency": "paired total input+output tokens, cached-input subset, reasoning-output subset, tool calls, wall time, governance overhead and interventions", + "cost_usd": "unavailable unless directly reported; no invented zero or API bill for subscription usage", + "analysis": "per-task paired results and 95% task-bootstrap interval for token savings; report both-solve separately; do not infer equivalence from non-significance", + "stop_rules": "stop new lanes on missing usage, hook failures, invalid isolation or short quota >=80%; retain partial artifacts and label incomplete", + "claim_limits": [ + "Function-level coding tasks, not real-repository SWE-bench Pro", + "Experimental benchmark enforcement, not default installed Shadow Mode", + "One stochastic sample per task per condition", + "Public benchmark contamination and saturation are possible", + "Self-published evaluation, not external leaderboard certification" + ] +} diff --git a/benchmark/astra/humaneval_runner.py b/benchmark/astra/humaneval_runner.py new file mode 100644 index 0000000..562ce91 --- /dev/null +++ b/benchmark/astra/humaneval_runner.py @@ -0,0 +1,553 @@ +"""Run the complete HumanEval+ suite in isolated paired Codex lanes.""" + +from __future__ import annotations + +import argparse +import hashlib +import json +import shutil +import subprocess +from collections.abc import Callable +from concurrent.futures import FIRST_COMPLETED, Future, ThreadPoolExecutor, wait +from dataclasses import asdict, dataclass +from pathlib import Path +from typing import Any + +from benchmark.codex_adapter.runner import RunConfig, run_task + +_SOURCE_ROOT = Path(__file__).resolve().parents[2] +_EXPECTED_IDS = frozenset(f"HumanEval/{index}" for index in range(164)) +_LANES = {"off": "baseline", "on": "marginal"} +_INSTRUCTION = ( + "Implement the requested function in solution.py. Validate your implementation using only " + "local, self-authored checks. Do not use network access or read files outside this task " + "workspace. Avoid unnecessary repeated actions." +) +_HEX_DIGITS = frozenset("0123456789abcdef") +RunTask = Callable[[RunConfig], dict[str, Any]] + + +class TaskInputError(ValueError): + """The public task-only input is malformed or incomplete.""" + + +@dataclass(frozen=True, slots=True) +class HumanEvalTask: + task_id: str + prompt: str + entry_point: str + + +@dataclass(frozen=True, slots=True) +class BenchmarkConfig: + tasks_path: Path + protocol_path: Path + protocol_sha256: str + run_root: Path + codex_executable: Path + auth_source: Path + model: str + reasoning_effort: str + codex_version: str + timeout_seconds: float = 180 + lane_concurrency: int = 2 + maximum_new_lanes: int | None = None + + def __post_init__(self) -> None: + if len(self.protocol_sha256) != 64 or any( + character not in _HEX_DIGITS for character in self.protocol_sha256 + ): + raise ValueError("protocol_sha256 must be a lowercase SHA256 digest") + if not self.model or not self.reasoning_effort or not self.codex_version: + raise ValueError("model, reasoning effort, and Codex version must be explicit") + if self.timeout_seconds <= 0: + raise ValueError("timeout_seconds must be positive") + if self.lane_concurrency < 1: + raise ValueError("lane_concurrency must be positive") + if self.maximum_new_lanes is not None and self.maximum_new_lanes < 0: + raise ValueError("maximum_new_lanes cannot be negative") + + def as_kwargs(self) -> dict[str, object]: + """Return constructor values for a deliberate immutable-config replacement.""" + + return asdict(self) + + +def _sha256(raw: bytes) -> str: + return hashlib.sha256(raw).hexdigest() + + +def _json_hash(value: object) -> str: + encoded = json.dumps(value, sort_keys=True, separators=(",", ":")).encode("utf-8") + return _sha256(encoded) + + +def load_tasks(path: Path) -> tuple[HumanEvalTask, ...]: + """Load the exact public task-only HumanEval+ suite in frozen order.""" + + try: + lines = path.read_text(encoding="utf-8").splitlines() + except OSError as exc: + raise TaskInputError(f"cannot read task input: {exc}") from exc + tasks: list[HumanEvalTask] = [] + seen: set[str] = set() + for line_number, line in enumerate(lines, start=1): + if not line.strip(): + raise TaskInputError(f"blank JSONL row at line {line_number}") + try: + raw = json.loads(line) + except json.JSONDecodeError as exc: + raise TaskInputError(f"invalid JSON at line {line_number}: {exc.msg}") from exc + if not isinstance(raw, dict) or set(raw) != {"task_id", "prompt", "entry_point"}: + raise TaskInputError( + f"line {line_number} must contain only task_id, prompt, and entry_point" + ) + task_id = raw["task_id"] + prompt = raw["prompt"] + entry_point = raw["entry_point"] + if not isinstance(task_id, str) or task_id not in _EXPECTED_IDS or task_id in seen: + raise TaskInputError(f"invalid or duplicate task_id at line {line_number}") + if not isinstance(prompt, str) or not prompt or not prompt.endswith("\n"): + raise TaskInputError(f"prompt at line {line_number} must be nonempty and newline-ended") + if not isinstance(entry_point, str) or not entry_point: + raise TaskInputError(f"entry_point at line {line_number} must be nonempty") + seen.add(task_id) + tasks.append(HumanEvalTask(task_id, prompt, entry_point)) + if seen != _EXPECTED_IDS: + missing = sorted(_EXPECTED_IDS - seen) + raise TaskInputError( + f"task input must contain all 164 HumanEval IDs; missing {missing[:3]}" + ) + return tuple(sorted(tasks, key=lambda task: _sha256(task.task_id.encode("utf-8")))) + + +def _lane_key(task: HumanEvalTask, lane: str) -> str: + return f"{task.task_id}:{lane}" + + +def _lane_dir(run_root: Path, task: HumanEvalTask, lane: str) -> Path: + return run_root / "lanes" / task.task_id.replace("/", "_") / lane + + +def _ordered_lanes(tasks: tuple[HumanEvalTask, ...]) -> list[tuple[HumanEvalTask, str]]: + ordered: list[tuple[HumanEvalTask, str]] = [] + for position, task in enumerate(tasks): + lane_order = ("off", "on") if position % 2 == 0 else ("on", "off") + ordered.extend((task, lane) for lane in lane_order) + return ordered + + +def _task_hash(task: HumanEvalTask) -> str: + return _json_hash( + {"task_id": task.task_id, "prompt": task.prompt, "entry_point": task.entry_point} + ) + + +def _invocation_hash( + config: BenchmarkConfig, + task: HumanEvalTask, + lane: str, + input_sha256: str, +) -> str: + return _json_hash( + { + "schema_version": 1, + "task_sha256": _task_hash(task), + "lane": lane, + "condition": _LANES[lane], + "input_sha256": input_sha256, + "protocol_sha256": config.protocol_sha256, + "model": config.model, + "reasoning_effort": config.reasoning_effort, + "codex_version": config.codex_version, + "timeout_seconds": config.timeout_seconds, + "instruction": _INSTRUCTION, + } + ) + + +def _expected_manifest( + config: BenchmarkConfig, + task: HumanEvalTask, + lane: str, + input_sha256: str, +) -> dict[str, object]: + return { + "schema_version": 1, + "orchestration_status": "recorded", + "task_id": task.task_id, + "task_sha256": _task_hash(task), + "lane": lane, + "condition": _LANES[lane], + "input_sha256": input_sha256, + "protocol_sha256": config.protocol_sha256, + "invocation_sha256": _invocation_hash(config, task, lane, input_sha256), + } + + +def _read_json_object(path: Path) -> dict[str, Any] | None: + try: + value = json.loads(path.read_text(encoding="utf-8")) + except (OSError, json.JSONDecodeError): + return None + return value if isinstance(value, dict) else None + + +def _classify_existing_lane( + config: BenchmarkConfig, + task: HumanEvalTask, + lane: str, + input_sha256: str, +) -> tuple[str, dict[str, Any] | None]: + lane_dir = _lane_dir(config.run_root, task, lane) + if not lane_dir.exists(): + return "new", None + manifest = _read_json_object(lane_dir / "lane-manifest.json") + record = _read_json_object(lane_dir / "run" / "run-record.json") + if manifest is None: + return "partial", None + expected = _expected_manifest(config, task, lane, input_sha256) + if manifest != expected: + return "hash_mismatch", None + if ( + record is None + or not (lane_dir / "solution.py").is_file() + or record.get("instance_id") != task.task_id + or record.get("condition") != _LANES[lane] + or record.get("repetition") != 1 + or record.get("resolved") is not None + ): + return "partial", None + return "recorded", record + + +def _git(worktree: Path, *args: str, env: dict[str, str] | None = None) -> str: + completed = subprocess.run( + ["git", *args], + cwd=worktree, + env=env, + capture_output=True, + check=False, + text=True, + timeout=60, + ) + if completed.returncode != 0: + raise RuntimeError(f"git {' '.join(args)} failed: {completed.stderr.strip()}") + return completed.stdout.strip() + + +def _materialize_checkout(lane_dir: Path, task: HumanEvalTask) -> tuple[Path, str]: + lane_dir.mkdir(parents=True, exist_ok=False) + worktree = lane_dir / "worktree" + worktree.mkdir() + _git(worktree, "init", "-q") + (worktree / "solution.py").write_text(task.prompt + " pass\n", encoding="utf-8") + _git(worktree, "add", "solution.py") + fixed_environment = { + "GIT_AUTHOR_NAME": "HumanEval Benchmark", + "GIT_AUTHOR_EMAIL": "benchmark@example.invalid", + "GIT_AUTHOR_DATE": "2000-01-01T00:00:00+00:00", + "GIT_COMMITTER_NAME": "HumanEval Benchmark", + "GIT_COMMITTER_EMAIL": "benchmark@example.invalid", + "GIT_COMMITTER_DATE": "2000-01-01T00:00:00+00:00", + } + _git(worktree, "commit", "-qm", "frozen HumanEval task", env=fixed_environment) + _git(worktree, "checkout", "--detach", "-q", "HEAD") + return worktree, _git(worktree, "rev-parse", "HEAD") + + +def _record_lane( + config: BenchmarkConfig, + task: HumanEvalTask, + lane: str, + input_sha256: str, + run_task_fn: RunTask, +) -> None: + lane_dir = _lane_dir(config.run_root, task, lane) + worktree, base_commit = _materialize_checkout(lane_dir, task) + run_dir = lane_dir / "run" + record = run_task_fn( + RunConfig( + instance_id=task.task_id, + condition=_LANES[lane], + repetition=1, + worktree=worktree, + expected_base_commit=base_commit, + run_dir=run_dir, + prompt=_INSTRUCTION, + codex_executable=config.codex_executable, + auth_source=config.auth_source, + model=config.model, + reasoning_effort=config.reasoning_effort, + timeout_seconds=config.timeout_seconds, + codex_version=config.codex_version, + ) + ) + if not isinstance(record, dict) or record.get("resolved") is not None: + raise RuntimeError("run_task returned an invalid or prematurely graded record") + run_dir.mkdir(parents=True, exist_ok=True) + record_path = run_dir / "run-record.json" + existing_record = _read_json_object(record_path) if record_path.exists() else None + if record_path.exists() and existing_record != record: + raise RuntimeError("run_task record differs from its persisted evidence") + if not record_path.exists(): + record_path.write_text( + json.dumps(record, indent=2, sort_keys=True) + "\n", encoding="utf-8" + ) + solution_path = worktree / "solution.py" + if not solution_path.is_file(): + raise RuntimeError("run_task did not leave solution.py in the task checkout") + shutil.copyfile(solution_path, lane_dir / "solution.py") + (lane_dir / "lane-manifest.json").write_text( + json.dumps(_expected_manifest(config, task, lane, input_sha256), indent=2, sort_keys=True) + + "\n", + encoding="utf-8", + ) + + +def _has_complete_telemetry(record: dict[str, Any]) -> bool: + tokens = record.get("tokens") + return bool( + isinstance(tokens, dict) + and all( + isinstance(tokens.get(name), int) + for name in ("input", "cached_input", "output", "reasoning", "total") + ) + ) + + +def _write_samples( + config: BenchmarkConfig, + tasks: tuple[HumanEvalTask, ...], + recorded: dict[str, dict[str, Any]], +) -> None: + samples_dir = config.run_root / "samples" + samples_dir.mkdir(parents=True, exist_ok=True) + for lane in _LANES: + rows: list[str] = [] + for task in tasks: + key = _lane_key(task, lane) + if key not in recorded: + continue + solution = (_lane_dir(config.run_root, task, lane) / "solution.py").read_text( + encoding="utf-8" + ) + rows.append(json.dumps({"task_id": task.task_id, "solution": solution}, sort_keys=True)) + temporary = samples_dir / f".{lane}.jsonl.tmp" + temporary.write_text("\n".join(rows) + ("\n" if rows else ""), encoding="utf-8") + temporary.replace(samples_dir / f"{lane}.jsonl") + + +def _validate_config( + config: BenchmarkConfig, +) -> tuple[tuple[HumanEvalTask, ...], str, str]: + tasks = load_tasks(config.tasks_path) + input_sha256 = _sha256(config.tasks_path.read_bytes()) + try: + protocol = config.protocol_path.read_bytes() + except OSError as exc: + raise ValueError(f"cannot read immutable protocol: {exc}") from exc + actual_protocol_hash = _sha256(protocol) + if actual_protocol_hash != config.protocol_sha256: + raise ValueError( + "protocol SHA256 mismatch: " + f"expected {config.protocol_sha256}, got {actual_protocol_hash}" + ) + try: + protocol_data = json.loads(protocol) + except json.JSONDecodeError as exc: + raise ValueError(f"immutable protocol is not valid JSON: {exc.msg}") from exc + if not isinstance(protocol_data, dict): + raise ValueError("immutable protocol must be a JSON object") + if protocol_data.get("task_inputs_sha256") != input_sha256: + raise ValueError("immutable protocol task input SHA256 does not match the task-only JSONL") + dataset = protocol_data.get("dataset") + dataset_version = protocol_data.get("dataset_version") + if not isinstance(dataset, str) or not dataset or not isinstance(dataset_version, str): + raise ValueError("immutable protocol must name its dataset and dataset version") + if not config.codex_executable.is_file(): + raise ValueError(f"Codex executable does not exist: {config.codex_executable}") + if not config.auth_source.is_file(): + raise ValueError(f"Codex auth source does not exist: {config.auth_source}") + run_root = config.run_root.resolve() + if run_root == _SOURCE_ROOT or run_root.is_relative_to(_SOURCE_ROOT): + raise ValueError("run root must be outside the source tree") + return tasks, input_sha256, f"{dataset} {dataset_version}".strip() + + +def run_benchmark( + config: BenchmarkConfig, + *, + run_task_fn: RunTask = run_task, +) -> dict[str, Any]: + """Run a bounded number of new lanes and report exact resumable state.""" + + tasks, input_sha256, benchmark_name = _validate_config(config) + config.run_root.mkdir(parents=True, exist_ok=True) + schedule = _ordered_lanes(tasks) + initial: dict[str, tuple[str, dict[str, Any] | None]] = { + _lane_key(task, lane): _classify_existing_lane(config, task, lane, input_sha256) + for task, lane in schedule + } + blockers = { + key: status + for key, (status, _) in initial.items() + if status in {"partial", "hash_mismatch"} + } + for key, (status, record) in initial.items(): + if ( + status == "recorded" + and record is not None + and (record.get("run_status") != "completed" or not _has_complete_telemetry(record)) + ): + blockers[key] = "stop_rule" + new_lanes = [ + (task, lane) for task, lane in schedule if initial[_lane_key(task, lane)][0] == "new" + ] + limit = len(new_lanes) if config.maximum_new_lanes is None else config.maximum_new_lanes + selected = [] if blockers else new_lanes[:limit] + launched: list[str] = [] + execution_errors: dict[str, str] = {} + if selected: + remaining = iter(selected) + stop_launching = False + with ThreadPoolExecutor(max_workers=config.lane_concurrency) as executor: + futures: dict[Future[None], tuple[HumanEvalTask, str]] = {} + + def submit_next() -> bool: + try: + task, lane = next(remaining) + except StopIteration: + return False + launched.append(_lane_key(task, lane)) + future = executor.submit( + _record_lane, config, task, lane, input_sha256, run_task_fn + ) + futures[future] = (task, lane) + return True + + for _ in range(min(config.lane_concurrency, len(selected))): + submit_next() + while futures: + done, _ = wait(futures, return_when=FIRST_COMPLETED) + for future in done: + task, lane = futures.pop(future) + key = _lane_key(task, lane) + try: + future.result() + except Exception as exc: + execution_errors[key] = f"{type(exc).__name__}: {exc}" + stop_launching = True + continue + status, record = _classify_existing_lane(config, task, lane, input_sha256) + if ( + status != "recorded" + or record is None + or ( + record.get("run_status") != "completed" + or not _has_complete_telemetry(record) + ) + ): + stop_launching = True + while not stop_launching and len(futures) < config.lane_concurrency: + if not submit_next(): + break + + final: dict[str, tuple[str, dict[str, Any] | None]] = { + _lane_key(task, lane): _classify_existing_lane(config, task, lane, input_sha256) + for task, lane in schedule + } + recorded = { + key: record + for key, (status, record) in final.items() + if status == "recorded" and record is not None + } + partial_lanes = [key for key, (status, _) in final.items() if status == "partial"] + mismatch_lanes = [key for key, (status, _) in final.items() if status == "hash_mismatch"] + missing_telemetry = [ + key for key, record in recorded.items() if not _has_complete_telemetry(record) + ] + failed_lanes = [ + key for key, record in recorded.items() if record.get("run_status") != "completed" + ] + stop_rule_lanes = list( + dict.fromkeys([*partial_lanes, *mismatch_lanes, *missing_telemetry, *failed_lanes]) + ) + resumed = [key for key, (status, _) in initial.items() if status == "recorded"] + _write_samples(config, tasks, recorded) + pending_lanes = 328 - len(recorded) + complete = bool( + len(recorded) == 328 + and not partial_lanes + and not mismatch_lanes + and not missing_telemetry + and not failed_lanes + and not execution_errors + ) + summary: dict[str, Any] = { + "schema_version": 1, + "benchmark": benchmark_name, + "input_sha256": input_sha256, + "protocol_sha256": config.protocol_sha256, + "expected_tasks": 164, + "expected_lanes": 328, + "recorded_lanes": len(recorded), + "pending_lanes": pending_lanes, + "launched": launched, + "resumed": resumed, + "partial_lanes": partial_lanes, + "hash_mismatch_lanes": mismatch_lanes, + "missing_telemetry_lanes": missing_telemetry, + "failed_lanes": failed_lanes, + "stop_rule_lanes": stop_rule_lanes, + "execution_errors": execution_errors, + "complete": complete, + "official_grading_complete": False, + } + (config.run_root / "orchestration-summary.json").write_text( + json.dumps(summary, indent=2, sort_keys=True) + "\n", encoding="utf-8" + ) + return summary + + +def _parser() -> argparse.ArgumentParser: + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--tasks", required=True, type=Path) + parser.add_argument("--protocol", required=True, type=Path) + parser.add_argument("--protocol-sha256", required=True) + parser.add_argument("--run-root", required=True, type=Path) + parser.add_argument("--codex", required=True, type=Path) + parser.add_argument("--auth", required=True, type=Path) + parser.add_argument("--model", required=True) + parser.add_argument("--reasoning-effort", required=True) + parser.add_argument("--codex-version", required=True) + parser.add_argument("--timeout-seconds", type=float, default=180) + parser.add_argument("--lane-concurrency", type=int, default=2) + parser.add_argument("--maximum-new-lanes", type=int) + return parser + + +def main(argv: list[str] | None = None) -> int: + args = _parser().parse_args(argv) + summary = run_benchmark( + BenchmarkConfig( + tasks_path=args.tasks, + protocol_path=args.protocol, + protocol_sha256=args.protocol_sha256, + run_root=args.run_root, + codex_executable=args.codex, + auth_source=args.auth, + model=args.model, + reasoning_effort=args.reasoning_effort, + codex_version=args.codex_version, + timeout_seconds=args.timeout_seconds, + lane_concurrency=args.lane_concurrency, + maximum_new_lanes=args.maximum_new_lanes, + ) + ) + print(json.dumps(summary, sort_keys=True)) + return 0 + + +if __name__ == "__main__": + raise SystemExit(main()) diff --git a/benchmark/astra/pro/Dockerfile.solver b/benchmark/astra/pro/Dockerfile.solver new file mode 100644 index 0000000..4d350f5 --- /dev/null +++ b/benchmark/astra/pro/Dockerfile.solver @@ -0,0 +1,54 @@ +# syntax=docker/dockerfile:1 +ARG TASK_IMAGE + +FROM --platform=linux/amd64 node@sha256:4d676821dff059fd00d277ee4261ef34ea712317fed0737c03941481b5760c96 AS codex_builder + +RUN npm install --global --omit=dev "@openai/codex@0.153.4" \ + && codex --version + +FROM --platform=linux/amd64 ghcr.io/astral-sh/uv@sha256:1ececcacbbde240ffca54d400df86e4fdd38f29c1a2366299279d197e92eaed3 AS uv_builder + +FROM --platform=linux/amd64 node@sha256:76789712cd1ae89a1225eac9077010d68987a423588042dac30446f502f1858c AS tools_builder + +ENV UV_PYTHON_INSTALL_DIR=/overlay/opt/python +COPY --from=uv_builder /uv /uv +RUN /uv python install cpython-3.12.11-linux-x86_64-musl \ + && mkdir -p /overlay/opt/python/bin /overlay/opt/marginal-tools/bin \ + && installed_python="$(/uv python find cpython-3.12.11-linux-x86_64-musl)" \ + && ln -s "${installed_python#/overlay}" /overlay/opt/python/bin/python3 \ + && "${installed_python}" --version + +COPY --from=codex_builder /usr/local/lib/node_modules/@openai/codex /overlay/opt/marginal-tools/lib/codex +COPY benchmark/container/pro-codex-native-wrapper.sh /overlay/opt/marginal-tools/bin/codex +COPY . /overlay/opt/marginal + +RUN installed_python="$(/uv python find cpython-3.12.11-linux-x86_64-musl)" \ + && site_packages="$("${installed_python}" -c 'import site; print(site.getsitepackages()[0])')" \ + && cp -R /overlay/opt/marginal/src/marginal "${site_packages}/marginal" \ + && cp -R /overlay/opt/marginal/benchmark "${site_packages}/benchmark" \ + && chmod 0555 /overlay/opt/marginal-tools/bin/codex \ + && env -u PYTHONPATH "${installed_python}" -c \ + "from marginal import Treasury; from benchmark.astra.pro_lane import ProLaneConfig" + +FROM ${TASK_IMAGE} + +ARG TASK_IMAGE +ARG MARGINAL_SOURCE_COMMIT +LABEL org.opencontainers.image.title="MARGINAL Astra SWE-bench Pro solver" \ + org.opencontainers.image.source="https://github.com/SignalLayerLabs/Marginal" \ + org.marginal.codex.version="0.153.4" \ + org.marginal.python.version="3.12.11" \ + org.marginal.source.commit="${MARGINAL_SOURCE_COMMIT}" \ + org.marginal.task.image="${TASK_IMAGE}" \ + org.marginal.node.image="node@sha256:76789712cd1ae89a1225eac9077010d68987a423588042dac30446f502f1858c" \ + org.marginal.codex-builder.image="node@sha256:4d676821dff059fd00d277ee4261ef34ea712317fed0737c03941481b5760c96" \ + org.marginal.uv.image="ghcr.io/astral-sh/uv@sha256:1ececcacbbde240ffca54d400df86e4fdd38f29c1a2366299279d197e92eaed3" + +COPY --from=tools_builder /overlay / +RUN env -u PYTHONPATH /opt/python/bin/python3 -c \ + "from marginal import Treasury; from benchmark.astra.pro_lane import ProLaneConfig" \ + && /opt/marginal-tools/bin/codex --version + +ENV PATH=/opt/python/bin:/opt/marginal-tools/bin:${PATH} +WORKDIR /app +ENTRYPOINT ["/opt/python/bin/python3", "-m", "benchmark.astra.pro_lane"] diff --git a/benchmark/astra/pro/README.md b/benchmark/astra/pro/README.md new file mode 100644 index 0000000..0cfa737 --- /dev/null +++ b/benchmark/astra/pro/README.md @@ -0,0 +1,91 @@ +# GPT-6 Astra × MARGINAL on SWE-bench Pro + +**Incomplete; no new inference is started above the quota reserve (updated 2026-09-09).** The full experiment needs +731 problems × two independent conditions = 1,462 model executions and official grading. +A passing reference patch is not evidence that MARGINAL improves quality or reduces tokens. + +## Published evidence + +- [Protocol](protocol.json): model, limits, task order, accounting and failure rules. +- [All 731 task IDs](task-manifest.jsonl), ordered by SHA256 of instance ID before inference. +- [Preflight](preflight.json): the first official environment and measured validation facts. +- [Official reference verdict](gold-eval-results.json) and [parsed tests](gold-test-results.json). +- [Execution status](execution-status.json): actual coverage, preliminary failures and unavailable metrics. +- [Pinned September 9 invocation](invocation-20260909.json): image, corrected source overlay and prompt hashes. + +The first reference patch passed official grading in 1,350.20 seconds on an Apple Silicon +Mac running the x86 image under QEMU. This is an infrastructure check, not an Astra score. +The actual pinned image uses Alpine 3.18.3, although its published Dockerfile specifies +Ubuntu 20.04. Solver tooling must match the actual image ABI; no repository dependency +upgrade is used to hide that difference. + +## What the comparison can establish + +OFF is Codex without MARGINAL. ON uses the existing benchmark adapter with balanced policy, +the default diminishing-return detector and experimental enforcement. Both use Astra, +medium reasoning and a 900-second model-run limit, with fresh state and the same issue. + +**This is not the installed plugin's default Shadow Mode.** Findings cannot justify a claim +that simply installing the default plugin saves tokens or reduces internal reasoning. +Correctness, provider token totals, cached-token subsets, tool calls, elapsed time and +governance overhead must be reported together. Missing data and failures remain visible. +Public and independently regradable does not mean independently certified. + +## Reproduce the reference check + +1. Fetch `ScaleAI/SWE-bench_Pro`, revision + `7ab5114912baf22bb098818e604c02fe7ad2c11f`, complete `test` split. Export it as CSV. + The downloaded parquet SHA256 is recorded in the protocol. +2. Check out the [official evaluator](https://github.com/scaleapi/SWE-bench_Pro-os) at + `ca10a60a5fcae51e6948ffe1485d4153d421e6c5` and install its local-Docker dependencies. +3. Create a prediction JSON array using the first manifest ID and its dataset `patch` field: + `[{"instance_id": "...", "patch": "...", "prefix": "gold"}]`. +4. From the official evaluator checkout, run: + +```sh +python swe_bench_pro_eval.py \ + --raw_sample_path=dataset.csv --patch_path=gold-first.json \ + --output_dir=gold-evaluation --scripts_dir=run_scripts \ + --num_workers=1 --dockerhub_username=jefzda \ + --use_local_docker --block_network --docker_platform=linux/amd64 +``` + +Verify the downloaded task image digest matches `preflight.json`. The upstream evaluator +uses a tag; record its resolved digest before and after grading. Keep reference data and +test scripts outside solver mounts. + +## Solver boundary + +[Dockerfile.solver](Dockerfile.solver) adds pinned tools to an official task image. +[pro_lane.py](../pro_lane.py) executes one condition using the shared Codex runner. The +container must be disposable: the lane removes its original Git history and verifies a +single-commit snapshot with the exact base tree. Unsupported gitlinks fail closed. + +Mount only the public rendered prompt at `/marginal-input/prompt.txt`, a fresh output +directory at `/marginal-output`, and the existing Codex login read-only at +`/run/secrets/codex-auth.json`. Never mount the host workspace, other lane output, reference +data or Docker socket. Never publish authentication files. Preserve failed attempts and +their usage; do not rerun solved or failed model attempts to select a better result. + +No complete benchmark score or measured token-saving percentage is available yet. + +## Sprint closeout — 2026-09-08 + +The native Codex launcher was corrected for the actual Alpine image without upgrading task +dependencies. Python/module import and `codex-cli 0.153.4` passed the actual-image build check. +The launcher review passed, and eight focused tests passed. A CI formatting failure in the +new test was corrected in commit `6470794`; this is separate from runtime validation. + +The complete paired experiment remains outstanding. Do not use the reference check or +runtime smoke as a model score, a token-saving result, or a completed SWE-bench Pro benchmark. + +On September 9, the runner help and a local sandbox shell check passed. An actual launch +then exposed classic-vs-Pro instance-ID validation, fixed and tested against all 731 IDs. +The next attempt stopped at repository integrity: 16 original tracked fixtures matched ignore +rules and were omitted from the fresh index. Both failures occurred before provider inference; +they are not model samples. The equality check was retained, not bypassed. + +The tracked-file staging fix subsequently passed an offline check in the same solver image: +the complete recursive tree matched the original base, including all previously omitted files. +No credentials were mounted and no provider request was made. The execution-status artifact +records the image, fix commit and matching tree hashes. Model coverage remains **0/1,462**. diff --git a/benchmark/astra/pro/evaluator-requirements.txt b/benchmark/astra/pro/evaluator-requirements.txt new file mode 100644 index 0000000..c23ab78 --- /dev/null +++ b/benchmark/astra/pro/evaluator-requirements.txt @@ -0,0 +1,6 @@ +# Versions used for the local official reference evaluation. +pandas==3.0.5 +pyarrow==25.0.1 +docker==7.2.0 +datasets==5.0.1 +tqdm==4.70.0 diff --git a/benchmark/astra/pro/execution-status.json b/benchmark/astra/pro/execution-status.json new file mode 100644 index 0000000..966ce3c --- /dev/null +++ b/benchmark/astra/pro/execution-status.json @@ -0,0 +1,31 @@ +{ + "schema_version": 1, + "updated_date": "2026-09-09", + "complete": false, + "required_model_lanes": 1462, + "baseline_model_lanes": 0, + "marginal_model_lanes": 0, + "model_predictions_graded": 0, + "paired_quality_result": null, + "paired_token_reduction": null, + "reference_checks": {"executed": 1, "passed": 1, "is_model_score": false}, + "pre_provider_attempts": [ + {"stage": "instance_id_validation", "result": "failed", "provider_requests": 0, "fixed_in": "e4161548dcce8198913610b1af260e0a1382739e"}, + {"stage": "repository_snapshot_integrity", "result": "failed", "provider_requests": 0, "expected_tree": "20f05efdb071fa3148288d15abcb6b4b0c194a03", "observed_tree": "37708e37e0be4bea2a21c07b57f130d62f4a7acc", "missing_tracked_files": 16, "extra_files": 0, "changed_files": 0, "cause": "Fresh git add omitted original tracked files matching ignore rules"} + ], + "snapshot_fix_verification": { + "fix_commit": "d9b167fbb071836ddb74d32c639453a23a605e31", + "solver_image_id": "sha256:31ce815dc5c1324de5f0a73dae5d2a0cd42ff49db7d2e34cb0a274c62c9b458e", + "source_override": "benchmark/astra/pro_lane.py", + "instance_id": "instance_protonmail__webclients-01ea5214d11e0df8b7170d91bafd34f23cb0f2b1", + "base_commit": "24c785b20c23f614eeb9df7073247aeb244c4329", + "original_base_tree": "20f05efdb071fa3148288d15abcb6b4b0c194a03", + "snapshot_tree": "20f05efdb071fa3148288d15abcb6b4b0c194a03", + "exact_recursive_tree_comparison": "passed", + "network": "none", + "credentials_mounted": false, + "provider_requests": 0, + "is_model_score": false + }, + "claim": "No measured model performance or token-saving result. Full SWE-bench Pro evaluation remains incomplete." +} diff --git a/benchmark/astra/pro/gold-eval-results.json b/benchmark/astra/pro/gold-eval-results.json new file mode 100644 index 0000000..3c9800e --- /dev/null +++ b/benchmark/astra/pro/gold-eval-results.json @@ -0,0 +1 @@ +{"instance_protonmail__webclients-01ea5214d11e0df8b7170d91bafd34f23cb0f2b1": true} \ No newline at end of file diff --git a/benchmark/astra/pro/gold-test-results.json b/benchmark/astra/pro/gold-test-results.json new file mode 100644 index 0000000..5295ed4 --- /dev/null +++ b/benchmark/astra/pro/gold-test-results.json @@ -0,0 +1 @@ +{"tests": [{"name": "src/app/hooks/useShouldMoveOut.test.ts | should move out if elementID is not in elementIDs", "status": "PASSED"}, {"name": "src/app/hooks/useShouldMoveOut.test.ts | should do nothing if elements are loading", "status": "PASSED"}, {"name": "src/app/hooks/useShouldMoveOut.test.ts | should move out if elementID is not defined", "status": "PASSED"}, {"name": "src/app/hooks/useShouldMoveOut.test.ts | should move out if there is not elements", "status": "PASSED"}, {"name": "src/app/components/conversation/ConversationView.test.tsx | should return store value", "status": "PASSED"}, {"name": "src/app/components/conversation/ConversationView.test.tsx | should update value if store is updated", "status": "PASSED"}, {"name": "src/app/components/conversation/ConversationView.test.tsx | should launch api request when needed", "status": "PASSED"}, {"name": "src/app/components/conversation/ConversationView.test.tsx | should change conversation when id change", "status": "PASSED"}, {"name": "src/app/components/conversation/ConversationView.test.tsx | should reload a conversation if first request failed", "status": "PASSED"}, {"name": "src/app/components/conversation/ConversationView.test.tsx | should show error banner after 4 attemps", "status": "PASSED"}, {"name": "src/app/components/conversation/ConversationView.test.tsx | should retry when using the Try again button", "status": "PASSED"}, {"name": "src/app/components/conversation/ConversationView.test.tsx | should focus item container on left", "status": "PASSED"}, {"name": "src/app/components/conversation/ConversationView.test.tsx | should navigate through messages with up and down", "status": "PASSED"}, {"name": "src/app/components/conversation/ConversationView.test.tsx | should open a message on enter", "status": "PASSED"}]} \ No newline at end of file diff --git a/benchmark/astra/pro/invocation-20260909.json b/benchmark/astra/pro/invocation-20260909.json new file mode 100644 index 0000000..1b3890a --- /dev/null +++ b/benchmark/astra/pro/invocation-20260909.json @@ -0,0 +1,37 @@ +{ + "schema_version": 1, + "date": "2026-09-09", + "status": "frozen_before_provider_inference", + "scope": "first task in the full published order; not a complete benchmark", + "instance_id": "instance_protonmail__webclients-01ea5214d11e0df8b7170d91bafd34f23cb0f2b1", + "base_commit": "24c785b20c23f614eeb9df7073247aeb244c4329", + "solver_image_id": "sha256:31ce815dc5c1324de5f0a73dae5d2a0cd42ff49db7d2e34cb0a274c62c9b458e", + "solver_image_source_commit": "a167ab0c9d0c96d0de76c75785ac0906d4545fb5", + "source_override": { + "file": "benchmark/astra/pro_lane.py", + "commit": "e4161548dcce8198913610b1af260e0a1382739e", + "sha256": "104197b8e51c709f34cc6a880124391cc68a7a7e478ef0631e9fa2621a5a3134", + "mode": "read-only bind mount, identical in both conditions", + "targets": [ + "/opt/marginal/benchmark/astra/pro_lane.py", + "/opt/python/cpython-3.12.11-linux-x86_64-musl/lib/python3.12/site-packages/benchmark/astra/pro_lane.py" + ], + "reason": "Correct classic numeric-ID validation to the published Pro hash-ID format without rebuilding unchanged tools" + }, + "prompt_sha256": "a96856fff430ba01ad1cc7aacb72efb3188db1d00faa33f0c6e514ee2a0cfbc0", + "runtime_checks": { + "python_module_import": "passed", + "codex_version": "codex-cli 0.153.4", + "pro_lane_help": "passed", + "local_sandbox_shell_exit_zero": "passed" + }, + "prior_attempt": { + "stage": "input validation", + "error": "instance_id is not a valid SWE-bench instance ID", + "provider_requests": 0, + "model_sample": false + }, + "native_plugin_promotion": "none; Shadow unchanged", + "benchmark_intervention": "experimental adapter, not native default Shadow", + "no_new_inference_above_quota_used_percent": 65 +} diff --git a/benchmark/astra/pro/preflight.json b/benchmark/astra/pro/preflight.json new file mode 100644 index 0000000..f0c96a6 --- /dev/null +++ b/benchmark/astra/pro/preflight.json @@ -0,0 +1,20 @@ +{ + "schema_version": 1, + "status": "reference_grading_passed_solver_execution_pending", + "first_instance_id": "instance_protonmail__webclients-01ea5214d11e0df8b7170d91bafd34f23cb0f2b1", + "base_commit": "24c785b20c23f614eeb9df7073247aeb244c4329", + "task_image": "jefzda/sweap-images@sha256:d902632d1374cf0282a4ea301b82c296e13a41127308da0204aca87a4ba62c02", + "observed_image_os": "Alpine Linux 3.18.3", + "observed_image_python": "3.11.12", + "observed_image_node": "16.20.2", + "public_dockerfile_os": "Ubuntu 20.04; differs from actual image", + "official_gold_resolved": true, + "official_gold_wall_seconds": 1350.20, + "official_evaluator_commit": "ca10a60a5fcae51e6948ffe1485d4153d421e6c5", + "official_evaluator_network": "none", + "first_prompt_sha256": "a96856fff430ba01ad1cc7aacb72efb3188db1d00faa33f0c6e514ee2a0cfbc0", + "host": "Apple Silicon macOS; x86_64 Colima/QEMU emulation; 6 virtual CPUs; 12 GiB VM RAM", + "model_lanes_executed_at_preflight": 0, + "project_tests": {"passed": 1024, "warnings": 8}, + "claim": "Infrastructure preflight only. A reference patch is not a model prediction. No measured savings." +} diff --git a/benchmark/astra/pro/prompt-template.txt b/benchmark/astra/pro/prompt-template.txt new file mode 100644 index 0000000..f6c16ae --- /dev/null +++ b/benchmark/astra/pro/prompt-template.txt @@ -0,0 +1,12 @@ +Resolve the following software issue in the current repository. Implement the required code changes and validate them with the repository's existing tests or your own local checks when feasible. + +Use only files in this task repository and its installed dependencies. Do not access the network, authentication files, external workspaces, benchmark infrastructure, reference patches or hidden tests. Do not attempt to retrieve the original fix. Do not modify existing tests to hide a failure. Avoid unnecessary repeated actions. Leave the code changes in the working tree. + +Issue: +{problem_statement} + +Requirements: +{requirements} + +Interface: +{interface} diff --git a/benchmark/astra/pro/protocol.json b/benchmark/astra/pro/protocol.json new file mode 100644 index 0000000..c798482 --- /dev/null +++ b/benchmark/astra/pro/protocol.json @@ -0,0 +1,44 @@ +{ + "schema_version": 1, + "experiment": "astra-swe-bench-pro-20260907", + "status": "preflight_no_scored_inference", + "dataset": "ScaleAI/SWE-bench_Pro", + "dataset_revision": "7ab5114912baf22bb098818e604c02fe7ad2c11f", + "dataset_parquet_sha256": "c8cd7115496ad4e9a8b21d088cef576a65bf821bb542b24336f13f714cef13f8", + "split": "test", + "task_count": 731, + "task_inputs_sha256": "9b4f10e1496d8bcda8c2d050602498c13be993518f0798b6935ae3e675cea1f6", + "evaluator_repository": "https://github.com/scaleapi/SWE-bench_Pro-os", + "evaluator_commit": "ca10a60a5fcae51e6948ffe1485d4153d421e6c5", + "model": "gpt-6-astra", + "model_snapshot": "public alias; immutable provider weight snapshot unavailable", + "codex_version": "0.153.4", + "reasoning_effort": "medium", + "timeout_seconds": 900, + "conditions": ["baseline", "marginal"], + "repetitions": 1, + "required_lanes": 1462, + "lane_concurrency": 1, + "task_order": "ascending sha256(instance_id UTF-8)", + "condition_order": "baseline first at even task positions; marginal first at odd positions", + "baseline": "Codex without MARGINAL hooks or daemon", + "marginal": "balanced policy plus default diminishing-return detector; experimental enforce; unlimited hard budgets", + "native_shadow_equivalent": false, + "isolation": "fresh official task container per lane; base-only git snapshot; no future history, reference patches, held-out tests, other lane output or host workspace mounted", + "shell_network_access": false, + "grading_network_access": false, + "quality_primary": "official evaluator fail_to_pass AND pass_to_pass success", + "failure_policy": "retain every attempt, timeout and invalid lane; no outcome-selected tasks or re-solving after grading; missing infrastructure is not silently excluded", + "quality_gate": "no observed baseline-only regressions; descriptive, not proof of statistical equivalence", + "efficiency": "provider input+output totals; cached input and reasoning output as subsets; paired tool calls, wall time, governance overhead and interventions", + "cost_usd": "unavailable unless provider-reported; subscription usage is not an API invoice", + "analysis": "all-task paired correctness and token totals; both-solved subset separately; task-bootstrap 95% interval for paired token reduction; do not infer equivalence from nonsignificance", + "stop_rules": "stop new lanes on missing usage, failed hooks, isolation violation, insufficient disk or short quota >=80%; preserve resumable state; never label incomplete coverage complete", + "claim_limits": [ + "Experimental enforcement is not the installed plugin default Shadow Mode", + "One stochastic sample per task per condition", + "Public benchmark contamination is possible", + "Self-published and independently regradable, not independent certification", + "A complete protocol is not a completed benchmark" + ] +} diff --git a/benchmark/astra/pro/task-manifest.jsonl b/benchmark/astra/pro/task-manifest.jsonl new file mode 100644 index 0000000..3e45a8d --- /dev/null +++ b/benchmark/astra/pro/task-manifest.jsonl @@ -0,0 +1,731 @@ +{"instance_id":"instance_protonmail__webclients-01ea5214d11e0df8b7170d91bafd34f23cb0f2b1","repo":"protonmail/webclients","base_commit":"24c785b20c23f614eeb9df7073247aeb244c4329","dockerhub_tag":"protonmail.webclients-protonmail__webclients-01ea5214d11e0df8b7170d91bafd34f23cb0f2b1"} +{"instance_id":"instance_flipt-io__flipt-f1bc91a1b999656dbdb2495ccb57bf2105b84920","repo":"flipt-io/flipt","base_commit":"56d261e7c28e47faf537061e6ad3b306459a3e93","dockerhub_tag":"flipt-io.flipt-flipt-io__flipt-f1bc91a1b999656dbdb2495ccb57bf2105b84920"} +{"instance_id":"instance_navidrome__navidrome-8383527aaba1ae8fa9765e995a71a86c129ef626","repo":"navidrome/navidrome","base_commit":"8a56584aedcb810f586a8917e98517cde0834628","dockerhub_tag":"navidrome.navidrome-navidrome__navidrome-8383527aaba1ae8fa9765e995a71a86c129ef626"} +{"instance_id":"instance_protonmail__webclients-cb8cc309c6968b0a2a5fe4288d0ae0a969ff31e1","repo":"protonmail/webclients","base_commit":"3b48b60689a8403f25c6e475106652f299338ed9","dockerhub_tag":"protonmail.webclients-protonmail__webclients-cb8cc309c6968b0a2a5fe4288d0ae0a969ff31e1"} +{"instance_id":"instance_NodeBB__NodeBB-3c85b944e30a0ba8b3ec9e1f441c74f383625a15-v4fbcfae8b15e4ce5d132c408bca69ebb9cf146ed","repo":"NodeBB/NodeBB","base_commit":"b94bb1bf93390e5204551bfc647049c6f8c5a60d","dockerhub_tag":"nodebb.nodebb-NodeBB__NodeBB-3c85b944e30a0ba8b3ec9e1f441c74f383625a15-v4fbcfae8b15e4ce5d132c408bca69ebb9cf146ed"} +{"instance_id":"instance_element-hq__element-web-71fe08ea0f159ccb707904d87f0a4aef205a167c-vnan","repo":"element-hq/element-web","base_commit":"c153a4d3885b6359f8bfe2b056f56db23ab4c9d8","dockerhub_tag":"element-hq.element-element-hq__element-web-71fe08ea0f159ccb707904d87f0a4aef205a167c"} +{"instance_id":"instance_future-architect__vuls-8659668177f1feb65963db7a967347a79c5f9c40","repo":"future-architect/vuls","base_commit":"e07b6a916080426af5ad92e13383ca72c31330d1","dockerhub_tag":"future-architect.vuls-future-architect__vuls-8659668177f1feb65963db7a967347a79c5f9c40"} +{"instance_id":"instance_future-architect__vuls-139f3a81b66c47e6d8f70ce6c4afe7a9196a6ea8","repo":"future-architect/vuls","base_commit":"d1a617cfff042f4b9cd20334f3c693deae3d956b","dockerhub_tag":"future-architect.vuls-future-architect__vuls-139f3a81b66c47e6d8f70ce6c4afe7a9196a6ea8"} +{"instance_id":"instance_ansible__ansible-deb54e4c5b32a346f1f0b0a14f1c713d2cc2e961-vba6da65a0f3baefda7a058ebbd0a8dcafb8512f5","repo":"ansible/ansible","base_commit":"ac1ca40fb3ed0a0fce387ae70cb8937208a13e03","dockerhub_tag":"ansible.ansible-ansible__ansible-deb54e4c5b32a346f1f0b0a14f1c713d2cc2e961-vba6da65a0f3baefda7a058ebbd0a8dcafb8512f5"} +{"instance_id":"instance_NodeBB__NodeBB-97c8569a798075c50e93e585ac741ab55cb7c28b-vf2cf3cbd463b7ad942381f1c6d077626485a1e9e","repo":"NodeBB/NodeBB","base_commit":"d9e2190a6b4b6bef2d8d2558524dd124be33760f","dockerhub_tag":"nodebb.nodebb-NodeBB__NodeBB-97c8569a798075c50e93e585ac741ab55cb7c28b-vf2cf3cbd463b7ad942381f1c6d077626485a1e9e"} +{"instance_id":"instance_flipt-io__flipt-381b90f718435c4694380b5fcd0d5cf8e3b5a25a","repo":"flipt-io/flipt","base_commit":"0ed96dc5d33768c4b145d68d52e80e7bce3790d0","dockerhub_tag":"flipt-io.flipt-flipt-io__flipt-381b90f718435c4694380b5fcd0d5cf8e3b5a25a"} +{"instance_id":"instance_NodeBB__NodeBB-00c70ce7b0541cfc94afe567921d7668cdc8f4ac-vnan","repo":"NodeBB/NodeBB","base_commit":"ae3fa85f40db0dca83d19dda1afb96064dffcc83","dockerhub_tag":"nodebb.nodebb-NodeBB__NodeBB-00c70ce7b0541cfc94afe567921d7668cdc8f4ac"} +{"instance_id":"instance_internetarchive__openlibrary-08ac40d050a64e1d2646ece4959af0c42bf6b7b5-v0f5aece3601a5b4419f7ccec1dbda2071be28ee4","repo":"internetarchive/openlibrary","base_commit":"1e32ae3ec085dc3ab8611b88b56baf6354fa0762","dockerhub_tag":"internetarchive.openlibrary-internetarchive__openlibrary-08ac40d050a64e1d2646ece4959af0c42bf6b7b5-v0f5aece3601a5b4419f7ccec1dbda"} +{"instance_id":"instance_ansible__ansible-f02a62db509dc7463fab642c9c3458b9bc3476cc-v390e508d27db7a51eece36bb6d9698b63a5b638a","repo":"ansible/ansible","base_commit":"73248bf27d4c6094799512b95993382ea2139e72","dockerhub_tag":"ansible.ansible-ansible__ansible-f02a62db509dc7463fab642c9c3458b9bc3476cc-v390e508d27db7a51eece36bb6d9698b63a5b638a"} +{"instance_id":"instance_qutebrowser__qutebrowser-e5340c449f23608803c286da0563b62f58ba25b0-v059c6fdc75567943479b23ebca7c07b5e9a7f34c","repo":"qutebrowser/qutebrowser","base_commit":"ae910113a7a52a81c4574a18937b7feba48b387d","dockerhub_tag":"qutebrowser.qutebrowser-qutebrowser__qutebrowser-e5340c449f23608803c286da0563b62f58ba25b0-v059c6fdc75567943479b23ebca7c07b5e9a7f"} +{"instance_id":"instance_NodeBB__NodeBB-9c576a0758690f45a6ca03b5884c601e473bf2c1-vd59a5728dfc977f44533186ace531248c2917516","repo":"NodeBB/NodeBB","base_commit":"09f3ac6574b3192497df0403306aff8d6f20448b","dockerhub_tag":"nodebb.nodebb-NodeBB__NodeBB-9c576a0758690f45a6ca03b5884c601e473bf2c1-vd59a5728dfc977f44533186ace531248c2917516"} +{"instance_id":"instance_protonmail__webclients-cfd7571485186049c10c822f214d474f1edde8d1","repo":"protonmail/webclients","base_commit":"1346a7d3e1a27c544f891ba5130655720a34d22a","dockerhub_tag":"protonmail.webclients-protonmail__webclients-cfd7571485186049c10c822f214d474f1edde8d1"} +{"instance_id":"instance_qutebrowser__qutebrowser-0d2afd58f3d0e34af21cee7d8a3fc9d855594e9f-vnan","repo":"qutebrowser/qutebrowser","base_commit":"8e152aaa0ac40a5200658d2b283cdf11b9d7ca0d","dockerhub_tag":"qutebrowser.qutebrowser-qutebrowser__qutebrowser-0d2afd58f3d0e34af21cee7d8a3fc9d855594e9f"} +{"instance_id":"instance_qutebrowser__qutebrowser-9b71c1ea67a9e7eb70dd83214d881c2031db6541-v363c8a7e5ccdf6968fc7ab84a2053ac78036691d","repo":"qutebrowser/qutebrowser","base_commit":"b84ef9b299ec1639ddf79ab900b670a96d71d9f2","dockerhub_tag":"qutebrowser.qutebrowser-qutebrowser__qutebrowser-9b71c1ea67a9e7eb70dd83214d881c2031db6541-v363c8a7e5ccdf6968fc7ab84a2053ac780366"} +{"instance_id":"instance_future-architect__vuls-6eff6a9329a65cc412e79b8f82444dfa3d0f0b5a","repo":"future-architect/vuls","base_commit":"69d32d45116aefd871327b9254977015a57995b8","dockerhub_tag":"future-architect.vuls-future-architect__vuls-6eff6a9329a65cc412e79b8f82444dfa3d0f0b5a"} +{"instance_id":"instance_internetarchive__openlibrary-a48fd6ba9482c527602bc081491d9e8ae6e8226c-vfa6ff903cb27f336e17654595dd900fa943dcd91","repo":"internetarchive/openlibrary","base_commit":"5e9872c8e19487fbeac11873549275184ce9b817","dockerhub_tag":"internetarchive.openlibrary-internetarchive__openlibrary-a48fd6ba9482c527602bc081491d9e8ae6e8226c-vfa6ff903cb27f336e17654595dd90"} +{"instance_id":"instance_gravitational__teleport-2b15263e49da5625922581569834eec4838a9257-vee9b09fb20c43af7e520f57e9239bbcf46b7113d","repo":"gravitational/teleport","base_commit":"189d41a956ebf5b90b6cf5829d60be46c1df992e","dockerhub_tag":"gravitational.teleport-gravitational__teleport-2b15263e49da5625922581569834eec4838a9257-vee9b09fb20c43af7e520f57e9239bbcf46b7113"} +{"instance_id":"instance_internetarchive__openlibrary-77c16d530b4d5c0f33d68bead2c6b329aee9b996-ve8c8d62a2b60610a3c4631f5f23ed866bada9818","repo":"internetarchive/openlibrary","base_commit":"80f511d3344a1f9743ff6efb0a2bdf0051529e3a","dockerhub_tag":"internetarchive.openlibrary-internetarchive__openlibrary-77c16d530b4d5c0f33d68bead2c6b329aee9b996-ve8c8d62a2b60610a3c4631f5f23ed"} +{"instance_id":"instance_future-architect__vuls-9a32a94806b54141b7ff12503c48da680ebcf199","repo":"future-architect/vuls","base_commit":"2534098509025989abe9b69bebb6fba6e9c5488b","dockerhub_tag":"future-architect.vuls-future-architect__vuls-9a32a94806b54141b7ff12503c48da680ebcf199"} +{"instance_id":"instance_flipt-io__flipt-5ffba3406a7993d97ced4cc13658bee66150fcca","repo":"flipt-io/flipt","base_commit":"02f5a1f8ef79565d6f4efed09259e7bf6541437a","dockerhub_tag":"flipt-io.flipt-flipt-io__flipt-5ffba3406a7993d97ced4cc13658bee66150fcca"} +{"instance_id":"instance_qutebrowser__qutebrowser-f91ace96223cac8161c16dd061907e138fe85111-v059c6fdc75567943479b23ebca7c07b5e9a7f34c","repo":"qutebrowser/qutebrowser","base_commit":"ebfe9b7aa0c4ba9d451f993e08955004aaec4345","dockerhub_tag":"qutebrowser.qutebrowser-qutebrowser__qutebrowser-f91ace96223cac8161c16dd061907e138fe85111-v059c6fdc75567943479b23ebca7c07b5e9a7f"} +{"instance_id":"instance_flipt-io__flipt-b2393f07d893024ab1e47ea2081e0289e1f9d56f","repo":"flipt-io/flipt","base_commit":"19fe7a3e92fc128acc75d0c5ececdc6d9a4e64e5","dockerhub_tag":"flipt-io.flipt-flipt-io__flipt-b2393f07d893024ab1e47ea2081e0289e1f9d56f"} +{"instance_id":"instance_ansible__ansible-5c225dc0f5bfa677addeac100a8018df3f3a9db1-v173091e2e36d38c978002990795f66cfc0af30ad","repo":"ansible/ansible","base_commit":"d7fbb209b403e782c6e2b7883a106e6dca15b330","dockerhub_tag":"ansible.ansible-ansible__ansible-5c225dc0f5bfa677addeac100a8018df3f3a9db1-v173091e2e36d38c978002990795f66cfc0af30ad"} +{"instance_id":"instance_internetarchive__openlibrary-30bc73a1395fba2300087c7f307e54bb5372b60a-v76304ecdb3a5954fcf13feb710e8c40fcf24b73c","repo":"internetarchive/openlibrary","base_commit":"540853735859789920caf9ee78a762ebe14f6103","dockerhub_tag":"internetarchive.openlibrary-internetarchive__openlibrary-30bc73a1395fba2300087c7f307e54bb5372b60a-v76304ecdb3a5954fcf13feb710e8c"} +{"instance_id":"instance_ansible__ansible-4c5ce5a1a9e79a845aff4978cfeb72a0d4ecf7d6-v1055803c3a812189a1133297f7f5468579283f86","repo":"ansible/ansible","base_commit":"8a175f59c939ca29ad56f3fa9edbc37a8656879a","dockerhub_tag":"ansible.ansible-ansible__ansible-4c5ce5a1a9e79a845aff4978cfeb72a0d4ecf7d6-v1055803c3a812189a1133297f7f5468579283f86"} +{"instance_id":"instance_future-architect__vuls-edb324c3d9ec3b107bf947f00e38af99d05b3e16","repo":"future-architect/vuls","base_commit":"83bcca6e669ba2e4102f26c4a2b52f78c7861f1a","dockerhub_tag":"future-architect.vuls-future-architect__vuls-edb324c3d9ec3b107bf947f00e38af99d05b3e16"} +{"instance_id":"instance_gravitational__teleport-af5e2517de7d18406b614e413aca61c319312171-vee9b09fb20c43af7e520f57e9239bbcf46b7113d","repo":"gravitational/teleport","base_commit":"a60d1c0f43d5b1baaa3ed98ec19d69181b294f94","dockerhub_tag":"gravitational.teleport-gravitational__teleport-af5e2517de7d18406b614e413aca61c319312171-vee9b09fb20c43af7e520f57e9239bbcf46b7113"} +{"instance_id":"instance_NodeBB__NodeBB-cfc237c2b79d8c731bbfc6cadf977ed530bfd57a-v0495b863a912fbff5749c67e860612b91825407c","repo":"NodeBB/NodeBB","base_commit":"a592ebd1ff1915c72a71b7f738f1dc0ec7ed4f03","dockerhub_tag":"nodebb.nodebb-NodeBB__NodeBB-cfc237c2b79d8c731bbfc6cadf977ed530bfd57a-v0495b863a912fbff5749c67e860612b91825407c"} +{"instance_id":"instance_tutao__tutanota-fbdb72a2bd39b05131ff905780d9d4a2a074de26-vbc0d9ba8f0071fbe982809910959a6ff8884dbbf","repo":"tutao/tutanota","base_commit":"1919cee2f58945936f8cfabf32ac8bee670b75ed","dockerhub_tag":"tutao.tutanota-tutao__tutanota-fbdb72a2bd39b05131ff905780d9d4a2a074de26-vbc0d9ba8f0071fbe982809910959a6ff8884dbbf"} +{"instance_id":"instance_protonmail__webclients-b530a3db50cb33e5064464addbcbef1465856ce6","repo":"protonmail/webclients","base_commit":"32394eda944448efcd48d2487c2878cd402e612c","dockerhub_tag":"protonmail.webclients-protonmail__webclients-b530a3db50cb33e5064464addbcbef1465856ce6"} +{"instance_id":"instance_navidrome__navidrome-6b3b4d83ffcf273b01985709c8bc5df12bbb8286","repo":"navidrome/navidrome","base_commit":"3853c3318f67b41a9e4cb768618315ff77846fdb","dockerhub_tag":"navidrome.navidrome-navidrome__navidrome-6b3b4d83ffcf273b01985709c8bc5df12bbb8286"} +{"instance_id":"instance_navidrome__navidrome-ee21f3957e0de91624427e93c62b8ee390de72e3","repo":"navidrome/navidrome","base_commit":"a1551074bbabbf0a71c2201e1938a31e678e82cf","dockerhub_tag":"navidrome.navidrome-navidrome__navidrome-ee21f3957e0de91624427e93c62b8ee390de72e3"} +{"instance_id":"instance_element-hq__element-web-4fec436883b601a3cac2d4a58067e597f737b817-vnan","repo":"element-hq/element-web","base_commit":"b8bb8f163a89cb6f2af0ac1cfc97e89deb938368","dockerhub_tag":"element-hq.element-element-hq__element-web-4fec436883b601a3cac2d4a58067e597f737b817"} +{"instance_id":"instance_flipt-io__flipt-f743945d599b178293e89e784b3b2374b1026430","repo":"flipt-io/flipt","base_commit":"820f90fd26c5f8651217f2edee0e5770d5f5f011","dockerhub_tag":"flipt-io.flipt-flipt-io__flipt-f743945d599b178293e89e784b3b2374b1026430"} +{"instance_id":"instance_future-architect__vuls-73f0adad95c4d227e2ccfa876c85cc95dd065e13","repo":"future-architect/vuls","base_commit":"704492963c5dc75cc6131dca23a02aa405673dd5","dockerhub_tag":"future-architect.vuls-future-architect__vuls-73f0adad95c4d227e2ccfa876c85cc95dd065e13"} +{"instance_id":"instance_navidrome__navidrome-56303cde23a4122d2447cbb266f942601a78d7e4","repo":"navidrome/navidrome","base_commit":"e434ca937255be6e12f11300648b3486de0aa9c2","dockerhub_tag":"navidrome.navidrome-navidrome__navidrome-56303cde23a4122d2447cbb266f942601a78d7e4"} +{"instance_id":"instance_protonmail__webclients-4817fe14e1356789c90165c2a53f6a043c2c5f83","repo":"protonmail/webclients","base_commit":"a1a9b965990811708c7997e783778e146b6b2fbd","dockerhub_tag":"protonmail.webclients-protonmail__webclients-4817fe14e1356789c90165c2a53f6a043c2c5f83"} +{"instance_id":"instance_flipt-io__flipt-ea9a2663b176da329b3f574da2ce2a664fc5b4a1","repo":"flipt-io/flipt","base_commit":"866ba43dd49c238c97831362cdab50630b0b9aa7","dockerhub_tag":"flipt-io.flipt-flipt-io__flipt-ea9a2663b176da329b3f574da2ce2a664fc5b4a1"} +{"instance_id":"instance_gravitational__teleport-769b4b5eec7286b7b14e179f2cc52e6b15d2d9f3-v626ec2a48416b10a88641359a169d99e935ff037","repo":"gravitational/teleport","base_commit":"1879807d3c30626ec02a730133ac5592cece310c","dockerhub_tag":"gravitational.teleport-gravitational__teleport-769b4b5eec7286b7b14e179f2cc52e6b15d2d9f3-v626ec2a48416b10a88641359a169d99e935ff03"} +{"instance_id":"instance_NodeBB__NodeBB-be43cd25974681c9743d424238b7536c357dc8d3-vf2cf3cbd463b7ad942381f1c6d077626485a1e9e","repo":"NodeBB/NodeBB","base_commit":"f24b630e1afcb8135144be66d67a09a61b21753e","dockerhub_tag":"nodebb.nodebb-NodeBB__NodeBB-be43cd25974681c9743d424238b7536c357dc8d3-vf2cf3cbd463b7ad942381f1c6d077626485a1e9e"} +{"instance_id":"instance_protonmail__webclients-d494a66038112b239a381f49b3914caf8d2ef3b4","repo":"protonmail/webclients","base_commit":"94dc494bae131e6577f795cb5fa3ca66a09757e3","dockerhub_tag":"protonmail.webclients-protonmail__webclients-d494a66038112b239a381f49b3914caf8d2ef3b4"} +{"instance_id":"instance_qutebrowser__qutebrowser-c09e1439f145c66ee3af574386e277dd2388d094-v2ef375ac784985212b1805e1d0431dc8f1b3c171","repo":"qutebrowser/qutebrowser","base_commit":"ea60bcfc2ae1e018559031a4c8a26b29caec1c59","dockerhub_tag":"qutebrowser.qutebrowser-qutebrowser__qutebrowser-c09e1439f145c66ee3af574386e277dd2388d094-v2ef375ac784985212b1805e1d0431dc8f1b3c"} +{"instance_id":"instance_future-architect__vuls-3f8de0268376e1f0fa6d9d61abb0d9d3d580ea7d","repo":"future-architect/vuls","base_commit":"d02535d053e724cb7ac6f8c192aba353509076ae","dockerhub_tag":"future-architect.vuls-future-architect__vuls-3f8de0268376e1f0fa6d9d61abb0d9d3d580ea7d"} +{"instance_id":"instance_navidrome__navidrome-10108c63c9b5bdf2966ffb3239bbfd89683e37b7","repo":"navidrome/navidrome","base_commit":"aac6e2cb0774aa256c00098b2d88bf8af288da79","dockerhub_tag":"navidrome.navidrome-navidrome__navidrome-10108c63c9b5bdf2966ffb3239bbfd89683e37b7"} +{"instance_id":"instance_ansible__ansible-be59caa59bf47ca78a4760eb7ff38568372a8260-v1055803c3a812189a1133297f7f5468579283f86","repo":"ansible/ansible","base_commit":"98726ad86c27b4cbd607f7be97ae0f56461fcc03","dockerhub_tag":"ansible.ansible-ansible__ansible-be59caa59bf47ca78a4760eb7ff38568372a8260-v1055803c3a812189a1133297f7f5468579283f86"} +{"instance_id":"instance_tutao__tutanota-da4edb7375c10f47f4ed3860a591c5e6557f7b5c-vbc0d9ba8f0071fbe982809910959a6ff8884dbbf","repo":"tutao/tutanota","base_commit":"5f77040986114d0ed019e58cab6ddf5152e55dbb","dockerhub_tag":"tutao.tutanota-tutao__tutanota-da4edb7375c10f47f4ed3860a591c5e6557f7b5c-vbc0d9ba8f0071fbe982809910959a6ff8884dbbf"} +{"instance_id":"instance_qutebrowser__qutebrowser-fd6790fe8c02b144ab2464f1fc8ab3d02ce3c476-v2ef375ac784985212b1805e1d0431dc8f1b3c171","repo":"qutebrowser/qutebrowser","base_commit":"487f90443cd1bf66bf2368b7a5c004f4e1b27777","dockerhub_tag":"qutebrowser.qutebrowser-qutebrowser__qutebrowser-fd6790fe8c02b144ab2464f1fc8ab3d02ce3c476-v2ef375ac784985212b1805e1d0431dc8f1b3c"} +{"instance_id":"instance_future-architect__vuls-a76302c11174ca081f656c63a000ffa746e350af","repo":"future-architect/vuls","base_commit":"d8173cdd422ec9f7dfc6a43f75e905dca151a6d9","dockerhub_tag":"future-architect.vuls-future-architect__vuls-a76302c11174ca081f656c63a000ffa746e350af"} +{"instance_id":"instance_qutebrowser__qutebrowser-de4a1c1a2839b5b49c3d4ce21d39de48d24e2091-v2ef375ac784985212b1805e1d0431dc8f1b3c171","repo":"qutebrowser/qutebrowser","base_commit":"6e7bb038fdab304eb3b93dfbb57a49a48ccca287","dockerhub_tag":"qutebrowser.qutebrowser-qutebrowser__qutebrowser-de4a1c1a2839b5b49c3d4ce21d39de48d24e2091-v2ef375ac784985212b1805e1d0431dc8f1b3c"} +{"instance_id":"instance_protonmail__webclients-1501eb765873b2884b6f1944fd242ecfc9d6b103","repo":"protonmail/webclients","base_commit":"9b35b414f77c6165550550fdda8b25bbc74aac7b","dockerhub_tag":"protonmail.webclients-protonmail__webclients-1501eb765873b2884b6f1944fd242ecfc9d6b103"} +{"instance_id":"instance_ansible__ansible-be2c376ab87e3e872ca21697508f12c6909cf85a-vba6da65a0f3baefda7a058ebbd0a8dcafb8512f5","repo":"ansible/ansible","base_commit":"034e9b0252b9aafe27804ba72320ad99b3344090","dockerhub_tag":"ansible.ansible-ansible__ansible-be2c376ab87e3e872ca21697508f12c6909cf85a-vba6da65a0f3baefda7a058ebbd0a8dcafb8512f5"} +{"instance_id":"instance_flipt-io__flipt-29d3f9db40c83434d0e3cc082af8baec64c391a9","repo":"flipt-io/flipt","base_commit":"018129e08535e0a7ec725680a1e8b2c969a832e9","dockerhub_tag":"flipt-io.flipt-flipt-io__flipt-29d3f9db40c83434d0e3cc082af8baec64c391a9"} +{"instance_id":"instance_protonmail__webclients-cba6ebbd0707caa524ffee51c62b197f6122c902","repo":"protonmail/webclients","base_commit":"369593a83c05f81cd7c69b69c2a4bfc96b0d8783","dockerhub_tag":"protonmail.webclients-protonmail__webclients-cba6ebbd0707caa524ffee51c62b197f6122c902"} +{"instance_id":"instance_internetarchive__openlibrary-e8084193a895d8ee81200f49093389a3887479ce-ve8c8d62a2b60610a3c4631f5f23ed866bada9818","repo":"internetarchive/openlibrary","base_commit":"8d41b319745228044947e039f629c44a5da08a09","dockerhub_tag":"internetarchive.openlibrary-internetarchive__openlibrary-e8084193a895d8ee81200f49093389a3887479ce-ve8c8d62a2b60610a3c4631f5f23ed"} +{"instance_id":"instance_internetarchive__openlibrary-09865f5fb549694d969f0a8e49b9d204ef1853ca-ve8c8d62a2b60610a3c4631f5f23ed866bada9818","repo":"internetarchive/openlibrary","base_commit":"50350d0432e2edf3429552bd9b50e78e662df8eb","dockerhub_tag":"internetarchive.openlibrary-internetarchive__openlibrary-09865f5fb549694d969f0a8e49b9d204ef1853ca-ve8c8d62a2b60610a3c4631f5f23ed"} +{"instance_id":"instance_element-hq__element-web-75c2c1a572fa45d1ea1d1a96e9e36e303332ecaa-vnan","repo":"element-hq/element-web","base_commit":"1f8fbc819795b9c19c567b4737109183acf86162","dockerhub_tag":"element-hq.element-element-hq__element-web-75c2c1a572fa45d1ea1d1a96e9e36e303332ecaa"} +{"instance_id":"instance_internetarchive__openlibrary-72321288ea790a3ace9e36f1c05b68c93f7eec43-v0f5aece3601a5b4419f7ccec1dbda2071be28ee4","repo":"internetarchive/openlibrary","base_commit":"72593efe54e9ee0579798f418d7b823fa5d91834","dockerhub_tag":"internetarchive.openlibrary-internetarchive__openlibrary-72321288ea790a3ace9e36f1c05b68c93f7eec43-v0f5aece3601a5b4419f7ccec1dbda"} +{"instance_id":"instance_gravitational__teleport-bb69574e02bd62e5ccd3cebb25e1c992641afb2a","repo":"gravitational/teleport","base_commit":"e9b7a25d6a5bb89eff86349d7e695afec04be7d0","dockerhub_tag":"gravitational.teleport-gravitational__teleport-bb69574e02bd62e5ccd3cebb25e1c992641afb2a"} +{"instance_id":"instance_protonmail__webclients-2c3559cad02d1090985dba7e8eb5a129144d9811","repo":"protonmail/webclients","base_commit":"c35133622a7950d2aa96d1db03ad8b96ccd65df9","dockerhub_tag":"protonmail.webclients-protonmail__webclients-2c3559cad02d1090985dba7e8eb5a129144d9811"} +{"instance_id":"instance_NodeBB__NodeBB-f2082d7de85eb62a70819f4f3396dd85626a0c0a-vd59a5728dfc977f44533186ace531248c2917516","repo":"NodeBB/NodeBB","base_commit":"f0d989e4ba5b0dccff6e56022fc6d378d05ab404","dockerhub_tag":"nodebb.nodebb-NodeBB__NodeBB-f2082d7de85eb62a70819f4f3396dd85626a0c0a-vd59a5728dfc977f44533186ace531248c2917516"} +{"instance_id":"instance_protonmail__webclients-c8117f446c3d1d7e117adc6e0e46b0ece9b0b90e","repo":"protonmail/webclients","base_commit":"fc4c6e035e04f1bb44d57b3094f074b16ef2a0b2","dockerhub_tag":"protonmail.webclients-protonmail__webclients-c8117f446c3d1d7e117adc6e0e46b0ece9b0b90e"} +{"instance_id":"instance_internetarchive__openlibrary-431442c92887a3aece3f8aa771dd029738a80eb1-v76304ecdb3a5954fcf13feb710e8c40fcf24b73c","repo":"internetarchive/openlibrary","base_commit":"188a76779dbd2368d73313ad15cae639c295eb21","dockerhub_tag":"internetarchive.openlibrary-internetarchive__openlibrary-431442c92887a3aece3f8aa771dd029738a80eb1-v76304ecdb3a5954fcf13feb710e8c"} +{"instance_id":"instance_future-architect__vuls-d576b6c6c15e56c47cc3e26f5878867677d4a9ea","repo":"future-architect/vuls","base_commit":"514eb71482ee6541dd0151dfc7d2c7c7c78b6e44","dockerhub_tag":"future-architect.vuls-future-architect__vuls-d576b6c6c15e56c47cc3e26f5878867677d4a9ea"} +{"instance_id":"instance_ansible__ansible-5e369604e1930b1a2e071fecd7ec5276ebd12cb1-v0f01c69f1e2528b935359cfe578530722bca2c59","repo":"ansible/ansible","base_commit":"0fae2383dafba38cdd0f02bcc4da1b89f414bf93","dockerhub_tag":"ansible.ansible-ansible__ansible-5e369604e1930b1a2e071fecd7ec5276ebd12cb1-v0f01c69f1e2528b935359cfe578530722bca2c59"} +{"instance_id":"instance_protonmail__webclients-da91f084c0f532d9cc8ca385a701274d598057b8","repo":"protonmail/webclients","base_commit":"fd6d7f6479dd2ab0c3318e2680d677b9e61189cd","dockerhub_tag":"protonmail.webclients-protonmail__webclients-da91f084c0f532d9cc8ca385a701274d598057b8"} +{"instance_id":"instance_element-hq__element-web-dae13ac8522fc6d41e64d1ac6e3174486fdcce0c-vnan","repo":"element-hq/element-web","base_commit":"526645c79160ab1ad4b4c3845de27d51263a405e","dockerhub_tag":"element-hq.element-element-hq__element-web-dae13ac8522fc6d41e64d1ac6e3174486fdcce0c"} +{"instance_id":"instance_element-hq__element-web-27139ca68eb075a4438c18fca184887002a4ffbc-vnan","repo":"element-hq/element-web","base_commit":"29f9ccfb633dd2bac9082fff9016b90945a77b53","dockerhub_tag":"element-hq.element-element-hq__element-web-27139ca68eb075a4438c18fca184887002a4ffbc"} +{"instance_id":"instance_internetarchive__openlibrary-1351c59fd43689753de1fca32c78d539a116ffc1-v29f82c9cf21d57b242f8d8b0e541525d259e2d63","repo":"internetarchive/openlibrary","base_commit":"ddbbdd64ecde64f314b9083953af63d07305f640","dockerhub_tag":"internetarchive.openlibrary-internetarchive__openlibrary-1351c59fd43689753de1fca32c78d539a116ffc1-v29f82c9cf21d57b242f8d8b0e5415"} +{"instance_id":"instance_protonmail__webclients-369fd37de29c14c690cb3b1c09a949189734026f","repo":"protonmail/webclients","base_commit":"42082399f3c51b8e9fb92e54312aafda1838ec4d","dockerhub_tag":"protonmail.webclients-protonmail__webclients-369fd37de29c14c690cb3b1c09a949189734026f"} +{"instance_id":"instance_protonmail__webclients-0200ce0fc1d4dbd35178c10d440a284c82ecc858","repo":"protonmail/webclients","base_commit":"373580e2fc209cdf010f5f14d08bed546adb8a92","dockerhub_tag":"protonmail.webclients-protonmail__webclients-0200ce0fc1d4dbd35178c10d440a284c82ecc858"} +{"instance_id":"instance_ansible__ansible-83909bfa22573777e3db5688773bda59721962ad-vba6da65a0f3baefda7a058ebbd0a8dcafb8512f5","repo":"ansible/ansible","base_commit":"b6360dc5e068288dcdf9513dba732f1d823d1dfe","dockerhub_tag":"ansible.ansible-ansible__ansible-83909bfa22573777e3db5688773bda59721962ad-vba6da65a0f3baefda7a058ebbd0a8dcafb8512f5"} +{"instance_id":"instance_element-hq__element-web-56c7fc1948923b4b3f3507799e725ac16bcf8018-vnan","repo":"element-hq/element-web","base_commit":"9d8efacede71e3057383684446df3bde21e7bb1a","dockerhub_tag":"element-hq.element-element-hq__element-web-56c7fc1948923b4b3f3507799e725ac16bcf8018"} +{"instance_id":"instance_protonmail__webclients-281a6b3f190f323ec2c0630999354fafb84b2880","repo":"protonmail/webclients","base_commit":"1c1b09fb1fc7879b57927397db2b348586506ddf","dockerhub_tag":"protonmail.webclients-protonmail__webclients-281a6b3f190f323ec2c0630999354fafb84b2880"} +{"instance_id":"instance_ansible__ansible-5f4e332e3762999d94af27746db29ff1729252c1-v0f01c69f1e2528b935359cfe578530722bca2c59","repo":"ansible/ansible","base_commit":"a870e7d0c6368dbc4c8f1f088f540e8be07223e1","dockerhub_tag":"ansible.ansible-ansible__ansible-5f4e332e3762999d94af27746db29ff1729252c1-v0f01c69f1e2528b935359cfe578530722bca2c59"} +{"instance_id":"instance_gravitational__teleport-8302d467d160f869b77184e262adbe2fbc95d9ba-vce94f93ad1030e3136852817f2423c1b3ac37bc4","repo":"gravitational/teleport","base_commit":"c2ace99b1c8bc141c43730352107f6848cd4ca4c","dockerhub_tag":"gravitational.teleport-gravitational__teleport-8302d467d160f869b77184e262adbe2fbc95d9ba-vce94f93ad1030e3136852817f2423c1b3ac37bc"} +{"instance_id":"instance_ansible__ansible-5e88cd9972f10b66dd97e1ee684c910c6a2dd25e-v906c969b551b346ef54a2c0b41e04f632b7b73c2","repo":"ansible/ansible","base_commit":"5fa2d29c9a06baa8cc5d271c41e23b1f99b3814a","dockerhub_tag":"ansible.ansible-ansible__ansible-5e88cd9972f10b66dd97e1ee684c910c6a2dd25e-v906c969b551b346ef54a2c0b41e04f632b7b73c2"} +{"instance_id":"instance_qutebrowser__qutebrowser-52708364b5f91e198defb022d1a5b4b3ebd9b563-v2ef375ac784985212b1805e1d0431dc8f1b3c171","repo":"qutebrowser/qutebrowser","base_commit":"a0710124a1790237aa4f2a17e2f7011a074143b4","dockerhub_tag":"qutebrowser.qutebrowser-qutebrowser__qutebrowser-52708364b5f91e198defb022d1a5b4b3ebd9b563-v2ef375ac784985212b1805e1d0431dc8f1b3c"} +{"instance_id":"instance_qutebrowser__qutebrowser-1af602b258b97aaba69d2585ed499d95e2303ac2-v2ef375ac784985212b1805e1d0431dc8f1b3c171","repo":"qutebrowser/qutebrowser","base_commit":"ab65c542a0551abf105eeb58803cd08bd040753b","dockerhub_tag":"qutebrowser.qutebrowser-qutebrowser__qutebrowser-1af602b258b97aaba69d2585ed499d95e2303ac2-v2ef375ac784985212b1805e1d0431dc8f1b3c"} +{"instance_id":"instance_internetarchive__openlibrary-9bdfd29fac883e77dcbc4208cab28c06fd963ab2-v76304ecdb3a5954fcf13feb710e8c40fcf24b73c","repo":"internetarchive/openlibrary","base_commit":"b2086f9bf54a3a8289e558a8f542673e3d01b376","dockerhub_tag":"internetarchive.openlibrary-internetarchive__openlibrary-9bdfd29fac883e77dcbc4208cab28c06fd963ab2-v76304ecdb3a5954fcf13feb710e8c"} +{"instance_id":"instance_NodeBB__NodeBB-bd80d36e0dcf78cd4360791a82966078b3a07712-v4fbcfae8b15e4ce5d132c408bca69ebb9cf146ed","repo":"NodeBB/NodeBB","base_commit":"88e891fcc66d79c3fbc19379c12dc6225630251e","dockerhub_tag":"nodebb.nodebb-NodeBB__NodeBB-bd80d36e0dcf78cd4360791a82966078b3a07712-v4fbcfae8b15e4ce5d132c408bca69ebb9cf146ed"} +{"instance_id":"instance_internetarchive__openlibrary-e390c1212055dd84a262a798e53487e771d3fb64-v8717e18970bcdc4e0d2cea3b1527752b21e74866","repo":"internetarchive/openlibrary","base_commit":"a08e565962ccbbd2931c7e2821bd37067a97f339","dockerhub_tag":"internetarchive.openlibrary-internetarchive__openlibrary-e390c1212055dd84a262a798e53487e771d3fb64-v8717e18970bcdc4e0d2cea3b15277"} +{"instance_id":"instance_gravitational__teleport-3a5c1e26394df2cb4fb3f01147fb9979662972c5-vee9b09fb20c43af7e520f57e9239bbcf46b7113d","repo":"gravitational/teleport","base_commit":"12cdaed68d9445f88a540778d2e13443e0011ebb","dockerhub_tag":"gravitational.teleport-gravitational__teleport-3a5c1e26394df2cb4fb3f01147fb9979662972c5-vee9b09fb20c43af7e520f57e9239bbcf46b7113"} +{"instance_id":"instance_gravitational__teleport-d6ffe82aaf2af1057b69c61bf9df777f5ab5635a-vee9b09fb20c43af7e520f57e9239bbcf46b7113d","repo":"gravitational/teleport","base_commit":"69a9dbf3a27c6a6da4eaafb89d69849c34beed1b","dockerhub_tag":"gravitational.teleport-gravitational__teleport-d6ffe82aaf2af1057b69c61bf9df777f5ab5635a-vee9b09fb20c43af7e520f57e9239bbcf46b7113"} +{"instance_id":"instance_navidrome__navidrome-31799662706fedddf5bcc1a76b50409d1f91d327","repo":"navidrome/navidrome","base_commit":"537e2fc033b71a4a69190b74f755ebc352bb4196","dockerhub_tag":"navidrome.navidrome-navidrome__navidrome-31799662706fedddf5bcc1a76b50409d1f91d327"} +{"instance_id":"instance_future-architect__vuls-83bcca6e669ba2e4102f26c4a2b52f78c7861f1a","repo":"future-architect/vuls","base_commit":"a124518d78779cd9daefd92bb66b25da37516363","dockerhub_tag":"future-architect.vuls-future-architect__vuls-83bcca6e669ba2e4102f26c4a2b52f78c7861f1a"} +{"instance_id":"instance_protonmail__webclients-1917e37f5d9941a3459ce4b0177e201e2d94a622","repo":"protonmail/webclients","base_commit":"78e30c07b399db1aac8608275fe101e9d349534f","dockerhub_tag":"protonmail.webclients-protonmail__webclients-1917e37f5d9941a3459ce4b0177e201e2d94a622"} +{"instance_id":"instance_flipt-io__flipt-e42da21a07a5ae35835ec54f74004ebd58713874","repo":"flipt-io/flipt","base_commit":"899e567d89a15411311ed44fb34ec218ccb06389","dockerhub_tag":"flipt-io.flipt-flipt-io__flipt-e42da21a07a5ae35835ec54f74004ebd58713874"} +{"instance_id":"instance_future-architect__vuls-436341a4a522dc83eb8bddd1164b764c8dd6bc45","repo":"future-architect/vuls","base_commit":"2cd2d1a9a21e29c51f63c5dab938b9efc09bb862","dockerhub_tag":"future-architect.vuls-future-architect__vuls-436341a4a522dc83eb8bddd1164b764c8dd6bc45"} +{"instance_id":"instance_ansible__ansible-942424e10b2095a173dbd78e7128f52f7995849b-v30a923fb5c164d6cd18280c02422f75e611e8fb2","repo":"ansible/ansible","base_commit":"dd44449b6ec454a46426a020608fe3763287101f","dockerhub_tag":"ansible.ansible-ansible__ansible-942424e10b2095a173dbd78e7128f52f7995849b-v30a923fb5c164d6cd18280c02422f75e611e8fb2"} +{"instance_id":"instance_flipt-io__flipt-86906cbfc3a5d3629a583f98e6301142f5f14bdb-v6bea0cc3a6fc532d7da914314f2944fc1cd04dee","repo":"flipt-io/flipt","base_commit":"358e13bf5748bba4418ffdcdd913bcbfdedc9d3f","dockerhub_tag":"flipt-io.flipt-flipt-io__flipt-86906cbfc3a5d3629a583f98e6301142f5f14bdb-v6bea0cc3a6fc532d7da914314f2944fc1cd04dee"} +{"instance_id":"instance_internetarchive__openlibrary-3c48b4bb782189e0858e6c3fc7956046cf3e1cfb-v2d9a6c849c60ed19fd0858ce9e40b7cc8e097e59","repo":"internetarchive/openlibrary","base_commit":"d38cb5a4162aa2942cdb5037dd679f37687b9d4f","dockerhub_tag":"internetarchive.openlibrary-internetarchive__openlibrary-3c48b4bb782189e0858e6c3fc7956046cf3e1cfb-v2d9a6c849c60ed19fd0858ce9e40b"} +{"instance_id":"instance_ansible__ansible-e0c91af45fa9af575d10fd3e724ebc59d2b2d6ac-v30a923fb5c164d6cd18280c02422f75e611e8fb2","repo":"ansible/ansible","base_commit":"5d15af3a9563271615fa1d0f5a99a175bfe41a9f","dockerhub_tag":"ansible.ansible-ansible__ansible-e0c91af45fa9af575d10fd3e724ebc59d2b2d6ac-v30a923fb5c164d6cd18280c02422f75e611e8fb2"} +{"instance_id":"instance_tutao__tutanota-db90ac26ab78addf72a8efaff3c7acc0fbd6d000-vbc0d9ba8f0071fbe982809910959a6ff8884dbbf","repo":"tutao/tutanota","base_commit":"d9e1c91e933cf66ec9660231f9e19f66bb8e58e1","dockerhub_tag":"tutao.tutanota-tutao__tutanota-db90ac26ab78addf72a8efaff3c7acc0fbd6d000-vbc0d9ba8f0071fbe982809910959a6ff8884dbbf"} +{"instance_id":"instance_protonmail__webclients-2dce79ea4451ad88d6bfe94da22e7f2f988efa60","repo":"protonmail/webclients","base_commit":"5fe4a7bd9e222cf7a525f42e369174f9244eb176","dockerhub_tag":"protonmail.webclients-protonmail__webclients-2dce79ea4451ad88d6bfe94da22e7f2f988efa60"} +{"instance_id":"instance_internetarchive__openlibrary-c12943be1db80cf1114bc267ddf4f9933aca9b28-v2c55207218fb8a0138425cbf7d9675272e240b90","repo":"internetarchive/openlibrary","base_commit":"d55e8868085c70c2b9f2ef859ebacbb50fff85fe","dockerhub_tag":"internetarchive.openlibrary-internetarchive__openlibrary-c12943be1db80cf1114bc267ddf4f9933aca9b28-v2c55207218fb8a0138425cbf7d967"} +{"instance_id":"instance_future-architect__vuls-e6c0da61324a0c04026ffd1c031436ee2be9503a","repo":"future-architect/vuls","base_commit":"98cbe6ed837ce5983ddcb138f5c1577b9b7cf2bf","dockerhub_tag":"future-architect.vuls-future-architect__vuls-e6c0da61324a0c04026ffd1c031436ee2be9503a"} +{"instance_id":"instance_flipt-io__flipt-cd18e54a0371fa222304742c6312e9ac37ea86c1","repo":"flipt-io/flipt","base_commit":"9e469bf851c6519616c2b220f946138b71fab047","dockerhub_tag":"flipt-io.flipt-flipt-io__flipt-cd18e54a0371fa222304742c6312e9ac37ea86c1"} +{"instance_id":"instance_flipt-io__flipt-c12967bc73fdf02054cf3ef8498c05e25f0a18c0","repo":"flipt-io/flipt","base_commit":"3bf3255a7b7e2cbe9f71ec167f16a5449a357a5e","dockerhub_tag":"flipt-io.flipt-flipt-io__flipt-c12967bc73fdf02054cf3ef8498c05e25f0a18c0"} +{"instance_id":"instance_qutebrowser__qutebrowser-473a15f7908f2bb6d670b0e908ab34a28d8cf7e2-v363c8a7e5ccdf6968fc7ab84a2053ac78036691d","repo":"qutebrowser/qutebrowser","base_commit":"8e08f046aeffb38445cc659050f7a083b4a9649c","dockerhub_tag":"qutebrowser.qutebrowser-qutebrowser__qutebrowser-473a15f7908f2bb6d670b0e908ab34a28d8cf7e2-v363c8a7e5ccdf6968fc7ab84a2053ac780366"} +{"instance_id":"instance_qutebrowser__qutebrowser-36ade4bba504eb96f05d32ceab9972df7eb17bcc-v2ef375ac784985212b1805e1d0431dc8f1b3c171","repo":"qutebrowser/qutebrowser","base_commit":"73f93008f6c8104dcb317b10bae2c6d156674b33","dockerhub_tag":"qutebrowser.qutebrowser-qutebrowser__qutebrowser-36ade4bba504eb96f05d32ceab9972df7eb17bcc-v2ef375ac784985212b1805e1d0431dc8f1b3c"} +{"instance_id":"instance_qutebrowser__qutebrowser-322834d0e6bf17e5661145c9f085b41215c280e8-v488d33dd1b2540b234cbb0468af6b6614941ce8f","repo":"qutebrowser/qutebrowser","base_commit":"7691556ea171c241eabb76e65c64c90dfc354327","dockerhub_tag":"qutebrowser.qutebrowser-qutebrowser__qutebrowser-322834d0e6bf17e5661145c9f085b41215c280e8-v488d33dd1b2540b234cbb0468af6b6614941c"} +{"instance_id":"instance_flipt-io__flipt-5aef5a14890aa145c22d864a834694bae3a6f112","repo":"flipt-io/flipt","base_commit":"3e8ab3fdbd7b3bf14e1db6443d78bc530743d8d0","dockerhub_tag":"flipt-io.flipt-flipt-io__flipt-5aef5a14890aa145c22d864a834694bae3a6f112"} +{"instance_id":"instance_ansible__ansible-7e1a347695c7987ae56ef1b6919156d9254010ad-v390e508d27db7a51eece36bb6d9698b63a5b638a","repo":"ansible/ansible","base_commit":"20ec92728004bc94729ffc08cbc483b7496c0c1f","dockerhub_tag":"ansible.ansible-ansible__ansible-7e1a347695c7987ae56ef1b6919156d9254010ad-v390e508d27db7a51eece36bb6d9698b63a5b638a"} +{"instance_id":"instance_flipt-io__flipt-02e21636c58e86c51119b63e0fb5ca7b813b07b1","repo":"flipt-io/flipt","base_commit":"85bb23a3571794c7ba01e61904bac6913c3d9729","dockerhub_tag":"flipt-io.flipt-flipt-io__flipt-02e21636c58e86c51119b63e0fb5ca7b813b07b1"} +{"instance_id":"instance_ansible__ansible-34db57a47f875d11c4068567b9ec7ace174ec4cf-v1055803c3a812189a1133297f7f5468579283f86","repo":"ansible/ansible","base_commit":"d63a71e3f83fc23defb97393367859634881b8da","dockerhub_tag":"ansible.ansible-ansible__ansible-34db57a47f875d11c4068567b9ec7ace174ec4cf-v1055803c3a812189a1133297f7f5468579283f86"} +{"instance_id":"instance_navidrome__navidrome-de90152a7173039677ac808f5bfb1e644d761336","repo":"navidrome/navidrome","base_commit":"27875ba2dd1673ddf8affca526b0664c12c3b98b","dockerhub_tag":"navidrome.navidrome-navidrome__navidrome-de90152a7173039677ac808f5bfb1e644d761336"} +{"instance_id":"instance_qutebrowser__qutebrowser-fec187c2cb53d769c2682b35ca77858a811414a8-v363c8a7e5ccdf6968fc7ab84a2053ac78036691d","repo":"qutebrowser/qutebrowser","base_commit":"a55f4db26b4b1caa304dd4b842a4103445fdccc7","dockerhub_tag":"qutebrowser.qutebrowser-qutebrowser__qutebrowser-fec187c2cb53d769c2682b35ca77858a811414a8-v363c8a7e5ccdf6968fc7ab84a2053ac780366"} +{"instance_id":"instance_navidrome__navidrome-8e640bb8580affb7e0ea6225c0bbe240186b6b08","repo":"navidrome/navidrome","base_commit":"bce7b163bae6e0a377a3fde66b3aea2cfdce841b","dockerhub_tag":"navidrome.navidrome-navidrome__navidrome-8e640bb8580affb7e0ea6225c0bbe240186b6b08"} +{"instance_id":"instance_flipt-io__flipt-5c7037ececb0bead0a8eb56054e224bcd7ac5922","repo":"flipt-io/flipt","base_commit":"4914fdf32b09e3a9ffffab9a7f4f007561cc13d0","dockerhub_tag":"flipt-io.flipt-flipt-io__flipt-5c7037ececb0bead0a8eb56054e224bcd7ac5922"} +{"instance_id":"instance_element-hq__element-web-ca58617cee8aa91c93553449bfdf9b3465a5119b-vnan","repo":"element-hq/element-web","base_commit":"5583d07f25071ceb4f84462150717b68a244f166","dockerhub_tag":"element-hq.element-element-hq__element-web-ca58617cee8aa91c93553449bfdf9b3465a5119b"} +{"instance_id":"instance_internetarchive__openlibrary-d8162c226a9d576f094dc1830c4c1ffd0be2dd17-v76304ecdb3a5954fcf13feb710e8c40fcf24b73c","repo":"internetarchive/openlibrary","base_commit":"5de7de19211e71b29b2f2ba3b1dff2fe065d660f","dockerhub_tag":"internetarchive.openlibrary-internetarchive__openlibrary-d8162c226a9d576f094dc1830c4c1ffd0be2dd17-v76304ecdb3a5954fcf13feb710e8c"} +{"instance_id":"instance_NodeBB__NodeBB-f48ed3658aab7be0f1165d4c1f89af48d7865189-v0495b863a912fbff5749c67e860612b91825407c","repo":"NodeBB/NodeBB","base_commit":"140f9d2481f7a97941593eb6c158013deeb0c0d4","dockerhub_tag":"nodebb.nodebb-NodeBB__NodeBB-f48ed3658aab7be0f1165d4c1f89af48d7865189-v0495b863a912fbff5749c67e860612b91825407c"} +{"instance_id":"instance_qutebrowser__qutebrowser-c580ebf0801e5a3ecabc54f327498bb753c6d5f2-v2ef375ac784985212b1805e1d0431dc8f1b3c171","repo":"qutebrowser/qutebrowser","base_commit":"0b8cc812fd0b73e296a3f93db02ce5d0b35714fc","dockerhub_tag":"qutebrowser.qutebrowser-qutebrowser__qutebrowser-c580ebf0801e5a3ecabc54f327498bb753c6d5f2-v2ef375ac784985212b1805e1d0431dc8f1b3c"} +{"instance_id":"instance_flipt-io__flipt-524f277313606f8cd29b299617d6565c01642e15","repo":"flipt-io/flipt","base_commit":"190b3cdc8e354d1b4d1d2811cb8a29f62cab8488","dockerhub_tag":"flipt-io.flipt-flipt-io__flipt-524f277313606f8cd29b299617d6565c01642e15"} +{"instance_id":"instance_element-hq__element-web-6205c70462e0ce2e1e77afb3a70b55d0fdfe1b31-vnan","repo":"element-hq/element-web","base_commit":"6bc4523cf7c2c48bdf76b7a22e12e078f2c53f7f","dockerhub_tag":"element-hq.element-element-hq__element-web-6205c70462e0ce2e1e77afb3a70b55d0fdfe1b31"} +{"instance_id":"instance_flipt-io__flipt-af7a0be46d15f0b63f16a868d13f3b48a838e7ce","repo":"flipt-io/flipt","base_commit":"165ba79a44732208147f516fa6fa4d1dc72b7008","dockerhub_tag":"flipt-io.flipt-flipt-io__flipt-af7a0be46d15f0b63f16a868d13f3b48a838e7ce"} +{"instance_id":"instance_flipt-io__flipt-0b119520afca1cf25c470ff4288c464d4510b944","repo":"flipt-io/flipt","base_commit":"7620fe8bb64c0d875f419137acc5da24ca8e6031","dockerhub_tag":"flipt-io.flipt-flipt-io__flipt-0b119520afca1cf25c470ff4288c464d4510b944"} +{"instance_id":"instance_qutebrowser__qutebrowser-3d01c201b8aa54dd71d4f801b1dd12feb4c0a08a-v5fc38aaf22415ab0b70567368332beee7955b367","repo":"qutebrowser/qutebrowser","base_commit":"6d9c28ce10832aa727de1a326d9459a035ff3aba","dockerhub_tag":"qutebrowser.qutebrowser-qutebrowser__qutebrowser-3d01c201b8aa54dd71d4f801b1dd12feb4c0a08a-v5fc38aaf22415ab0b70567368332beee7955b"} +{"instance_id":"instance_flipt-io__flipt-f808b4dd6e36b9dc8b011eb26b196f4e2cc64c41","repo":"flipt-io/flipt","base_commit":"d26eba77ddd985eb621c79642b55b607cf125941","dockerhub_tag":"flipt-io.flipt-flipt-io__flipt-f808b4dd6e36b9dc8b011eb26b196f4e2cc64c41"} +{"instance_id":"instance_ansible__ansible-cd473dfb2fdbc97acf3293c134b21cbbcfa89ec3-vba6da65a0f3baefda7a058ebbd0a8dcafb8512f5","repo":"ansible/ansible","base_commit":"e8ae7211dabbd07093f50d6dfb383da3bb14f13d","dockerhub_tag":"ansible.ansible-ansible__ansible-cd473dfb2fdbc97acf3293c134b21cbbcfa89ec3-vba6da65a0f3baefda7a058ebbd0a8dcafb8512f5"} +{"instance_id":"instance_NodeBB__NodeBB-05f2236193f407cf8e2072757fbd6bb170bc13f0-vf2cf3cbd463b7ad942381f1c6d077626485a1e9e","repo":"NodeBB/NodeBB","base_commit":"c5ae8a70e1b0305af324ad7b1b0911d4023f1338","dockerhub_tag":"nodebb.nodebb-NodeBB__NodeBB-05f2236193f407cf8e2072757fbd6bb170bc13f0-vf2cf3cbd463b7ad942381f1c6d077626485a1e9e"} +{"instance_id":"instance_NodeBB__NodeBB-767973717be700f46f06f3e7f4fc550c63509046-vnan","repo":"NodeBB/NodeBB","base_commit":"a2ebf53b6098635c3abcab3fd9144c766e32b350","dockerhub_tag":"nodebb.nodebb-NodeBB__NodeBB-767973717be700f46f06f3e7f4fc550c63509046"} +{"instance_id":"instance_qutebrowser__qutebrowser-99029144b5109bb1b2a53964a7c129e009980cd9-va0fd88aac89cde702ec1ba84877234da33adce8a","repo":"qutebrowser/qutebrowser","base_commit":"ef62208ce998797c9a1f0110a528bbd11c402357","dockerhub_tag":"qutebrowser.qutebrowser-qutebrowser__qutebrowser-99029144b5109bb1b2a53964a7c129e009980cd9-va0fd88aac89cde702ec1ba84877234da33adc"} +{"instance_id":"instance_NodeBB__NodeBB-f1a80d48cc45877fcbadf34c2345dd9709722c7f-v4fbcfae8b15e4ce5d132c408bca69ebb9cf146ed","repo":"NodeBB/NodeBB","base_commit":"c1f873b302b47548a508c7fcc403942db43ea690","dockerhub_tag":"nodebb.nodebb-NodeBB__NodeBB-f1a80d48cc45877fcbadf34c2345dd9709722c7f-v4fbcfae8b15e4ce5d132c408bca69ebb9cf146ed"} +{"instance_id":"instance_tutao__tutanota-de49d486feef842101506adf040a0f00ded59519-v10a26bfb45a064b93f4fc044a0254925037b88f1","repo":"tutao/tutanota","base_commit":"cf4bcf0b4c5ecc970715c4ca59e57cfa2c4246af","dockerhub_tag":"tutao.tutanota-tutao__tutanota-de49d486feef842101506adf040a0f00ded59519-v10a26bfb45a064b93f4fc044a0254925037b88f1"} +{"instance_id":"instance_gravitational__teleport-3587cca7840f636489449113969a5066025dd5bf","repo":"gravitational/teleport","base_commit":"2308160e4e16359f8fd3ad24cd251b9cd80fae23","dockerhub_tag":"gravitational.teleport-gravitational__teleport-3587cca7840f636489449113969a5066025dd5bf"} +{"instance_id":"instance_NodeBB__NodeBB-1ea9481af6125ffd6da0592ed439aa62af0bca11-vd59a5728dfc977f44533186ace531248c2917516","repo":"NodeBB/NodeBB","base_commit":"bbaf26cedc3462ef928906dc90db5cb98a3ec22e","dockerhub_tag":"nodebb.nodebb-NodeBB__NodeBB-1ea9481af6125ffd6da0592ed439aa62af0bca11-vd59a5728dfc977f44533186ace531248c2917516"} +{"instance_id":"instance_flipt-io__flipt-cf06f4ebfab7fa21eed3e5838592e8e44566957f","repo":"flipt-io/flipt","base_commit":"962f8d028e1a2e1dd8a87035d7d8d85eb6665eaf","dockerhub_tag":"flipt-io.flipt-flipt-io__flipt-cf06f4ebfab7fa21eed3e5838592e8e44566957f"} +{"instance_id":"instance_future-architect__vuls-50580f6e98eeb36f53f27222f7f4fdfea0b21e8d","repo":"future-architect/vuls","base_commit":"472df0e1b6ab9b50f8605af957ad054c7a732938","dockerhub_tag":"future-architect.vuls-future-architect__vuls-50580f6e98eeb36f53f27222f7f4fdfea0b21e8d"} +{"instance_id":"instance_flipt-io__flipt-e594593dae52badf80ffd27878d2275c7f0b20e9","repo":"flipt-io/flipt","base_commit":"f9855c1e6110ab7ff24d3d278229a45776e891ae","dockerhub_tag":"flipt-io.flipt-flipt-io__flipt-e594593dae52badf80ffd27878d2275c7f0b20e9"} +{"instance_id":"instance_NodeBB__NodeBB-a5afad27e52fd336163063ba40dcadc80233ae10-vd59a5728dfc977f44533186ace531248c2917516","repo":"NodeBB/NodeBB","base_commit":"7800016f2f1b89d2d3cfea6a7da7c77096b7b927","dockerhub_tag":"nodebb.nodebb-NodeBB__NodeBB-a5afad27e52fd336163063ba40dcadc80233ae10-vd59a5728dfc977f44533186ace531248c2917516"} +{"instance_id":"instance_element-hq__element-web-f14374a51c153f64f313243f2df6ea4971db4e15","repo":"element-hq/element-web","base_commit":"8c13a0f8d48441eccdd69e41e76251478bdeab8c","dockerhub_tag":"element-hq.element-element-hq__element-web-f14374a51c153f64f313243f2df6ea4971db4e15"} +{"instance_id":"instance_flipt-io__flipt-6fe76d024ee0c50ddb09c86f4ae0bd4c208fd65f","repo":"flipt-io/flipt","base_commit":"edc61fb357077d0384391cdfefae4411d8a1848e","dockerhub_tag":"flipt-io.flipt-flipt-io__flipt-6fe76d024ee0c50ddb09c86f4ae0bd4c208fd65f"} +{"instance_id":"instance_internetarchive__openlibrary-5c6c22f3d2edf2f1b10f5dc335e32cb6a5f40341-v76304ecdb3a5954fcf13feb710e8c40fcf24b73c","repo":"internetarchive/openlibrary","base_commit":"31d6ecf3c04c8e365e557f2a9a6a65df2b8d01a3","dockerhub_tag":"internetarchive.openlibrary-internetarchive__openlibrary-5c6c22f3d2edf2f1b10f5dc335e32cb6a5f40341-v76304ecdb3a5954fcf13feb710e8c"} +{"instance_id":"instance_future-architect__vuls-8d5ea98e50cf616847f4e5a2df300395d1f719e9","repo":"future-architect/vuls","base_commit":"835dc080491a080c8b68979fb4efc38c4de2ce3f","dockerhub_tag":"future-architect.vuls-future-architect__vuls-8d5ea98e50cf616847f4e5a2df300395d1f719e9"} +{"instance_id":"instance_gravitational__teleport-46a13210519461c7cec8d643bfbe750265775b41","repo":"gravitational/teleport","base_commit":"63da43245e2cf491cb48fb4ee3278395930d4d97","dockerhub_tag":"gravitational.teleport-gravitational__teleport-46a13210519461c7cec8d643bfbe750265775b41"} +{"instance_id":"instance_navidrome__navidrome-3982ba725883e71d4e3e618c61d5140eeb8d850a","repo":"navidrome/navidrome","base_commit":"1bf94531fdb3599ccfbc5aca574152b8802bf5eb","dockerhub_tag":"navidrome.navidrome-navidrome__navidrome-3982ba725883e71d4e3e618c61d5140eeb8d850a"} +{"instance_id":"instance_navidrome__navidrome-d0dceae0943b8df16e579c2d9437e11760a0626a","repo":"navidrome/navidrome","base_commit":"94cc2b2ac56e2a8295dc258ddf5b8383b0b58e70","dockerhub_tag":"navidrome.navidrome-navidrome__navidrome-d0dceae0943b8df16e579c2d9437e11760a0626a"} +{"instance_id":"instance_NodeBB__NodeBB-b398321a5eb913666f903a794219833926881a8f-vd59a5728dfc977f44533186ace531248c2917516","repo":"NodeBB/NodeBB","base_commit":"47910d708d8d6c18fdc3e57a0933b6d2a1d881bd","dockerhub_tag":"nodebb.nodebb-NodeBB__NodeBB-b398321a5eb913666f903a794219833926881a8f-vd59a5728dfc977f44533186ace531248c2917516"} +{"instance_id":"instance_qutebrowser__qutebrowser-85b867fe8d4378c8e371f055c70452f546055854-v2ef375ac784985212b1805e1d0431dc8f1b3c171","repo":"qutebrowser/qutebrowser","base_commit":"c97257cac01d9f7d67fb42d0344cb4332c7a0833","dockerhub_tag":"qutebrowser.qutebrowser-qutebrowser__qutebrowser-85b867fe8d4378c8e371f055c70452f546055854-v2ef375ac784985212b1805e1d0431dc8f1b3c"} +{"instance_id":"instance_element-hq__element-web-a692fe21811f88d92e8f7047fc615e4f1f986b0f-vnan","repo":"element-hq/element-web","base_commit":"9d9c55d92e98f5302a316ee5cd8170de052c13da","dockerhub_tag":"element-hq.element-element-hq__element-web-a692fe21811f88d92e8f7047fc615e4f1f986b0f"} +{"instance_id":"instance_protonmail__webclients-d3e513044d299d04e509bf8c0f4e73d812030246","repo":"protonmail/webclients","base_commit":"738b22f1e8efbb8a0420db86af89fb630a6c9f58","dockerhub_tag":"protonmail.webclients-protonmail__webclients-d3e513044d299d04e509bf8c0f4e73d812030246"} +{"instance_id":"instance_internetarchive__openlibrary-427f1f4eddfc54735ca451779d4f95bf683d1b0e-v0f5aece3601a5b4419f7ccec1dbda2071be28ee4","repo":"internetarchive/openlibrary","base_commit":"8c988af810a451a2bda2dd080852c81f662aee1e","dockerhub_tag":"internetarchive.openlibrary-internetarchive__openlibrary-427f1f4eddfc54735ca451779d4f95bf683d1b0e-v0f5aece3601a5b4419f7ccec1dbda"} +{"instance_id":"instance_element-hq__element-web-33e8edb3d508d6eefb354819ca693b7accc695e7","repo":"element-hq/element-web","base_commit":"83612dd4adeb2a4dad77655ec8969fcb1c555e6f","dockerhub_tag":"element-hq.element-element-hq__element-web-33e8edb3d508d6eefb354819ca693b7accc695e7"} +{"instance_id":"instance_navidrome__navidrome-69e0a266f48bae24a11312e9efbe495a337e4c84","repo":"navidrome/navidrome","base_commit":"8f0d002922272432f5f6fed869c02480147cea6e","dockerhub_tag":"navidrome.navidrome-navidrome__navidrome-69e0a266f48bae24a11312e9efbe495a337e4c84"} +{"instance_id":"instance_NodeBB__NodeBB-0e07f3c9bace416cbab078a30eae972868c0a8a3-vf2cf3cbd463b7ad942381f1c6d077626485a1e9e","repo":"NodeBB/NodeBB","base_commit":"bbaaead09c5e3c852d243b113724d2048e1c175a","dockerhub_tag":"nodebb.nodebb-NodeBB__NodeBB-0e07f3c9bace416cbab078a30eae972868c0a8a3-vf2cf3cbd463b7ad942381f1c6d077626485a1e9e"} +{"instance_id":"instance_flipt-io__flipt-2eac0df47b5ecc8bb05002d80383ceb08ab3620a","repo":"flipt-io/flipt","base_commit":"01f583bb025dbd60e4210eb9a31a6f859ed150e8","dockerhub_tag":"flipt-io.flipt-flipt-io__flipt-2eac0df47b5ecc8bb05002d80383ceb08ab3620a"} +{"instance_id":"instance_qutebrowser__qutebrowser-cf06f4e3708f886032d4d2a30108c2fddb042d81-v2ef375ac784985212b1805e1d0431dc8f1b3c171","repo":"qutebrowser/qutebrowser","base_commit":"61ff98d395c39d57bbbae1b941150ca11b7671e1","dockerhub_tag":"qutebrowser.qutebrowser-qutebrowser__qutebrowser-cf06f4e3708f886032d4d2a30108c2fddb042d81-v2ef375ac784985212b1805e1d0431dc8f1b3c"} +{"instance_id":"instance_element-hq__element-web-ca8b1b04effb4fec0e1dd3de8e3198eeb364d50e-vnan","repo":"element-hq/element-web","base_commit":"372720ec8bab38e33fa0c375ce231c67792f43a4","dockerhub_tag":"element-hq.element-element-hq__element-web-ca8b1b04effb4fec0e1dd3de8e3198eeb364d50e"} +{"instance_id":"instance_flipt-io__flipt-507170da0f7f4da330f6732bffdf11c4df7fc192","repo":"flipt-io/flipt","base_commit":"5c6de423ccaad9eda072d951c4fc34e779308e95","dockerhub_tag":"flipt-io.flipt-flipt-io__flipt-507170da0f7f4da330f6732bffdf11c4df7fc192"} +{"instance_id":"instance_gravitational__teleport-007235446f85b1cbaef92664c3b3867517250f21","repo":"gravitational/teleport","base_commit":"2e7b253d55a1b6da5673ea5846503c43fa53cf37","dockerhub_tag":"gravitational.teleport-gravitational__teleport-007235446f85b1cbaef92664c3b3867517250f21"} +{"instance_id":"instance_ansible__ansible-de01db08d00c8d2438e1ba5989c313ba16a145b0-vba6da65a0f3baefda7a058ebbd0a8dcafb8512f5","repo":"ansible/ansible","base_commit":"fc8197e32675dd0343939f107b5f017993e36f62","dockerhub_tag":"ansible.ansible-ansible__ansible-de01db08d00c8d2438e1ba5989c313ba16a145b0-vba6da65a0f3baefda7a058ebbd0a8dcafb8512f5"} +{"instance_id":"instance_internetarchive__openlibrary-92db3454aeaa02f89b4cdbc3103f7e95c9759f92-v2c55207218fb8a0138425cbf7d9675272e240b90","repo":"internetarchive/openlibrary","base_commit":"4d2c696773853ee7fb4ec0ceb773351a52257447","dockerhub_tag":"internetarchive.openlibrary-internetarchive__openlibrary-92db3454aeaa02f89b4cdbc3103f7e95c9759f92-v2c55207218fb8a0138425cbf7d967"} +{"instance_id":"instance_gravitational__teleport-1316e6728a3ee2fc124e2ea0cc6a02044c87a144-v626ec2a48416b10a88641359a169d99e935ff037","repo":"gravitational/teleport","base_commit":"2f51af0e04d6022b1d6475c5637980f64b113658","dockerhub_tag":"gravitational.teleport-gravitational__teleport-1316e6728a3ee2fc124e2ea0cc6a02044c87a144-v626ec2a48416b10a88641359a169d99e935ff03"} +{"instance_id":"instance_internetarchive__openlibrary-8a5a63af6e0be406aa6c8c9b6d5f28b2f1b6af5a-v0f5aece3601a5b4419f7ccec1dbda2071be28ee4","repo":"internetarchive/openlibrary","base_commit":"9d9f3a19983876522bcfd17c9079c46a17986cb3","dockerhub_tag":"internetarchive.openlibrary-internetarchive__openlibrary-8a5a63af6e0be406aa6c8c9b6d5f28b2f1b6af5a-v0f5aece3601a5b4419f7ccec1dbda"} +{"instance_id":"instance_qutebrowser__qutebrowser-0833b5f6f140d04200ec91605f88704dd18e2970-v059c6fdc75567943479b23ebca7c07b5e9a7f34c","repo":"qutebrowser/qutebrowser","base_commit":"def864adc8b19bdbc506919270d8ff1408b4faac","dockerhub_tag":"qutebrowser.qutebrowser-qutebrowser__qutebrowser-0833b5f6f140d04200ec91605f88704dd18e2970-v059c6fdc75567943479b23ebca7c07b5e9a7f"} +{"instance_id":"instance_ansible__ansible-40ade1f84b8bb10a63576b0ac320c13f57c87d34-v6382ea168a93d80a64aab1fbd8c4f02dc5ada5bf","repo":"ansible/ansible","base_commit":"9ab63986ad528a6ad5bf4c59fe104d5106d6ef9b","dockerhub_tag":"ansible.ansible-ansible__ansible-40ade1f84b8bb10a63576b0ac320c13f57c87d34-v6382ea168a93d80a64aab1fbd8c4f02dc5ada5bf"} +{"instance_id":"instance_tutao__tutanota-8513a9e8114a8b42e64f4348335e0f23efa054c4-vee878bb72091875e912c52fc32bc60ec3760227b","repo":"tutao/tutanota","base_commit":"e5b2d146b0f5b67f46ba0f627439f11e763ebbc8","dockerhub_tag":"tutao.tutanota-tutao__tutanota-8513a9e8114a8b42e64f4348335e0f23efa054c4-vee878bb72091875e912c52fc32bc60ec3760227b"} +{"instance_id":"instance_ansible__ansible-9142be2f6cabbe6597c9254c5bb9186d17036d55-v0f01c69f1e2528b935359cfe578530722bca2c59","repo":"ansible/ansible","base_commit":"7fff4086523678f3c6533da4c500f86f6fb47efa","dockerhub_tag":"ansible.ansible-ansible__ansible-9142be2f6cabbe6597c9254c5bb9186d17036d55-v0f01c69f1e2528b935359cfe578530722bca2c59"} +{"instance_id":"instance_tutao__tutanota-12a6cbaa4f8b43c2f85caca0787ab55501539955-vc4e41fd0029957297843cb9dec4a25c7c756f029","repo":"tutao/tutanota","base_commit":"170958a2bb463b25c691640b522780d3b602ce99","dockerhub_tag":"tutao.tutanota-tutao__tutanota-12a6cbaa4f8b43c2f85caca0787ab55501539955-vc4e41fd0029957297843cb9dec4a25c7c756f029"} +{"instance_id":"instance_flipt-io__flipt-2ca5dfb3513e4e786d2b037075617cccc286d5c3","repo":"flipt-io/flipt","base_commit":"168f61194a4cd0f515a589511183bb1bd4f87507","dockerhub_tag":"flipt-io.flipt-flipt-io__flipt-2ca5dfb3513e4e786d2b037075617cccc286d5c3"} +{"instance_id":"instance_internetarchive__openlibrary-e010b2a13697de70170033902ba2e27a1e1acbe9-v0f5aece3601a5b4419f7ccec1dbda2071be28ee4","repo":"internetarchive/openlibrary","base_commit":"b70f9abab445676042e5c300dcf5dd8eac4afd18","dockerhub_tag":"internetarchive.openlibrary-internetarchive__openlibrary-e010b2a13697de70170033902ba2e27a1e1acbe9-v0f5aece3601a5b4419f7ccec1dbda"} +{"instance_id":"instance_ansible__ansible-185d41031660a676c43fbb781cd1335902024bfe-vba6da65a0f3baefda7a058ebbd0a8dcafb8512f5","repo":"ansible/ansible","base_commit":"a7c8093ce49145966c3af21e40fad9ee8912d297","dockerhub_tag":"ansible.ansible-ansible__ansible-185d41031660a676c43fbb781cd1335902024bfe-vba6da65a0f3baefda7a058ebbd0a8dcafb8512f5"} +{"instance_id":"instance_internetarchive__openlibrary-58999808a17a26b387f8237860a7a524d1e2d262-v08d8e8889ec945ab821fb156c04c7d2e2810debb","repo":"internetarchive/openlibrary","base_commit":"6e5fa4b4afcbbf022aff88732f1d458be31fc086","dockerhub_tag":"internetarchive.openlibrary-internetarchive__openlibrary-58999808a17a26b387f8237860a7a524d1e2d262-v08d8e8889ec945ab821fb156c04c7"} +{"instance_id":"instance_protonmail__webclients-09fcf0dbdb87fa4f4a27700800ee4a3caed8b413","repo":"protonmail/webclients","base_commit":"41f29d1c8dad68d693d2e3e10e5c65b6fb780142","dockerhub_tag":"protonmail.webclients-protonmail__webclients-09fcf0dbdb87fa4f4a27700800ee4a3caed8b413"} +{"instance_id":"instance_internetarchive__openlibrary-3aeec6afed9198d734b7ee1293f03ca94ff970e1-v13642507b4fc1f8d234172bf8129942da2c2ca26","repo":"internetarchive/openlibrary","base_commit":"b36762b27e11d2bdf1ef556a8c5588294bb7deb7","dockerhub_tag":"internetarchive.openlibrary-internetarchive__openlibrary-3aeec6afed9198d734b7ee1293f03ca94ff970e1-v13642507b4fc1f8d234172bf81299"} +{"instance_id":"instance_flipt-io__flipt-1dceb5edf3fa8f39495b939ef9cc0c3dd38fa17d","repo":"flipt-io/flipt","base_commit":"eafbf82dbc497801453f91bc991421d7491d4e15","dockerhub_tag":"flipt-io.flipt-flipt-io__flipt-1dceb5edf3fa8f39495b939ef9cc0c3dd38fa17d"} +{"instance_id":"instance_future-architect__vuls-fd18df1dd4e4360f8932bc4b894bd8b40d654e7c","repo":"future-architect/vuls","base_commit":"8775b5efdfc5811bc11da51dbfb66c6f09476423","dockerhub_tag":"future-architect.vuls-future-architect__vuls-fd18df1dd4e4360f8932bc4b894bd8b40d654e7c"} +{"instance_id":"instance_ansible__ansible-a6e671db25381ed111bbad0ab3e7d97366395d05-v0f01c69f1e2528b935359cfe578530722bca2c59","repo":"ansible/ansible","base_commit":"1f59bbf4f39504c8f2087f8132f2475a6ac38dcb","dockerhub_tag":"ansible.ansible-ansible__ansible-a6e671db25381ed111bbad0ab3e7d97366395d05-v0f01c69f1e2528b935359cfe578530722bca2c59"} +{"instance_id":"instance_flipt-io__flipt-492cc0b158200089dceede3b1aba0ed28df3fb1d","repo":"flipt-io/flipt","base_commit":"d38a357b67ced2c3eba83e7a4aa71a1b2af019ae","dockerhub_tag":"flipt-io.flipt-flipt-io__flipt-492cc0b158200089dceede3b1aba0ed28df3fb1d"} +{"instance_id":"instance_qutebrowser__qutebrowser-66cfa15c372fa9e613ea5a82d3b03e4609399fb6-v363c8a7e5ccdf6968fc7ab84a2053ac78036691d","repo":"qutebrowser/qutebrowser","base_commit":"6d0b7cb12b206f400f8b44041a86c1a93cd78c7f","dockerhub_tag":"qutebrowser.qutebrowser-qutebrowser__qutebrowser-66cfa15c372fa9e613ea5a82d3b03e4609399fb6-v363c8a7e5ccdf6968fc7ab84a2053ac780366"} +{"instance_id":"instance_navidrome__navidrome-55730514ea59d5f1d0b8e3f8745569c29bdbf7b4","repo":"navidrome/navidrome","base_commit":"768160b05e9929bf5d82359b7768e67ffffeb9b6","dockerhub_tag":"navidrome.navidrome-navidrome__navidrome-55730514ea59d5f1d0b8e3f8745569c29bdbf7b4"} +{"instance_id":"instance_protonmail__webclients-6e1873b06df6529a469599aa1d69d3b18f7d9d37","repo":"protonmail/webclients","base_commit":"2ea4c94b420367d482a72cff1471d40568d2b7a3","dockerhub_tag":"protonmail.webclients-protonmail__webclients-6e1873b06df6529a469599aa1d69d3b18f7d9d37"} +{"instance_id":"instance_NodeBB__NodeBB-0f788b8eaa4bba3c142d171fd941d015c53b65fc-v0ec6d6c2baf3cb4797482ce4829bc25cd5716649","repo":"NodeBB/NodeBB","base_commit":"606808760edd7f0bf73715ae71a3d365a9c6ae95","dockerhub_tag":"nodebb.nodebb-NodeBB__NodeBB-0f788b8eaa4bba3c142d171fd941d015c53b65fc-v0ec6d6c2baf3cb4797482ce4829bc25cd5716649"} +{"instance_id":"instance_future-architect__vuls-457a3a9627fb9a0800d0aecf1d4713fb634a9011","repo":"future-architect/vuls","base_commit":"4253550c999d27fac802f616dbe50dd884e93f51","dockerhub_tag":"future-architect.vuls-future-architect__vuls-457a3a9627fb9a0800d0aecf1d4713fb634a9011"} +{"instance_id":"instance_flipt-io__flipt-3ef34d1fff012140ba86ab3cafec8f9934b492be","repo":"flipt-io/flipt","base_commit":"456ee2570b53ee8efd812aeb64546a19ed9256fc","dockerhub_tag":"flipt-io.flipt-flipt-io__flipt-3ef34d1fff012140ba86ab3cafec8f9934b492be"} +{"instance_id":"instance_future-architect__vuls-17ae386d1e185ba742eea4668ca77642e22b54c4","repo":"future-architect/vuls","base_commit":"2d369d0cfe61ca06294b186eecb348104e9c98ae","dockerhub_tag":"future-architect.vuls-future-architect__vuls-17ae386d1e185ba742eea4668ca77642e22b54c4"} +{"instance_id":"instance_tutao__tutanota-d1aa0ecec288bfc800cfb9133b087c4f81ad8b38-vbc0d9ba8f0071fbe982809910959a6ff8884dbbf","repo":"tutao/tutanota","base_commit":"cc335e9fb1d6f5f42a36bd773a2e4009a01fb619","dockerhub_tag":"tutao.tutanota-tutao__tutanota-d1aa0ecec288bfc800cfb9133b087c4f81ad8b38-vbc0d9ba8f0071fbe982809910959a6ff8884dbbf"} +{"instance_id":"instance_future-architect__vuls-0ec945d0510cdebf92cdd8999f94610772689f14","repo":"future-architect/vuls","base_commit":"d3bf2a6f26e8e549c0732c26fdcc82725d3c6633","dockerhub_tag":"future-architect.vuls-future-architect__vuls-0ec945d0510cdebf92cdd8999f94610772689f14"} +{"instance_id":"instance_gravitational__teleport-1330415d33a27594c948a36d9d7701f496229e9f","repo":"gravitational/teleport","base_commit":"bb69574e02bd62e5ccd3cebb25e1c992641afb2a","dockerhub_tag":"gravitational.teleport-gravitational__teleport-1330415d33a27594c948a36d9d7701f496229e9f"} +{"instance_id":"instance_ansible__ansible-bf98f031f3f5af31a2d78dc2f0a58fe92ebae0bb-v1055803c3a812189a1133297f7f5468579283f86","repo":"ansible/ansible","base_commit":"17332532973343248297e3d3c746738d1f3b2f56","dockerhub_tag":"ansible.ansible-ansible__ansible-bf98f031f3f5af31a2d78dc2f0a58fe92ebae0bb-v1055803c3a812189a1133297f7f5468579283f86"} +{"instance_id":"instance_gravitational__teleport-87a593518b6ce94624f6c28516ce38cc30cbea5a","repo":"gravitational/teleport","base_commit":"49ab2a7bfd935317818b20a5bd0b59ac4d5289c9","dockerhub_tag":"gravitational.teleport-gravitational__teleport-87a593518b6ce94624f6c28516ce38cc30cbea5a"} +{"instance_id":"instance_flipt-io__flipt-c154dd1a3590954dfd3b901555fc6267f646a289","repo":"flipt-io/flipt","base_commit":"e432032cf2d11e3bb6f558748a5ee41a90640daa","dockerhub_tag":"flipt-io.flipt-flipt-io__flipt-c154dd1a3590954dfd3b901555fc6267f646a289"} +{"instance_id":"instance_qutebrowser__qutebrowser-a25e8a09873838ca9efefd36ea8a45170bbeb95c-vc2f56a753b62a190ddb23cd330c257b9cf560d12","repo":"qutebrowser/qutebrowser","base_commit":"83bef2ad4bdc10113bb9e5ed12c32d92bc1247af","dockerhub_tag":"qutebrowser.qutebrowser-qutebrowser__qutebrowser-a25e8a09873838ca9efefd36ea8a45170bbeb95c-vc2f56a753b62a190ddb23cd330c257b9cf560"} +{"instance_id":"instance_element-hq__element-web-1216285ed2e82e62f8780b6702aa0f9abdda0b34-vnan","repo":"element-hq/element-web","base_commit":"d7a6e3ec65cf28d2454ccb357874828bc8147eb0","dockerhub_tag":"element-hq.element-element-hq__element-web-1216285ed2e82e62f8780b6702aa0f9abdda0b34"} +{"instance_id":"instance_flipt-io__flipt-5af0757e96dec4962a076376d1bedc79de0d4249","repo":"flipt-io/flipt","base_commit":"d94448d3351ee69fd384b55f329003097951fe07","dockerhub_tag":"flipt-io.flipt-flipt-io__flipt-5af0757e96dec4962a076376d1bedc79de0d4249"} +{"instance_id":"instance_gravitational__teleport-47530e1fd8bfb84ec096ebcbbc29990f30829655-vee9b09fb20c43af7e520f57e9239bbcf46b7113d","repo":"gravitational/teleport","base_commit":"883cf1aeda25ae67262a9cb255db170937100987","dockerhub_tag":"gravitational.teleport-gravitational__teleport-47530e1fd8bfb84ec096ebcbbc29990f30829655-vee9b09fb20c43af7e520f57e9239bbcf46b7113"} +{"instance_id":"instance_NodeBB__NodeBB-18c45b44613aecd53e9f60457b9812049ab2998d-v0495b863a912fbff5749c67e860612b91825407c","repo":"NodeBB/NodeBB","base_commit":"34d99c15afd9441ab022b8feb203084a61e338b7","dockerhub_tag":"nodebb.nodebb-NodeBB__NodeBB-18c45b44613aecd53e9f60457b9812049ab2998d-v0495b863a912fbff5749c67e860612b91825407c"} +{"instance_id":"instance_flipt-io__flipt-8bd3604dc54b681f1f0f7dd52cbc70b3024184b6","repo":"flipt-io/flipt","base_commit":"25a5f278e1116ca22f86d86b4a5259ca05ef2623","dockerhub_tag":"flipt-io.flipt-flipt-io__flipt-8bd3604dc54b681f1f0f7dd52cbc70b3024184b6"} +{"instance_id":"instance_protonmail__webclients-2f66db85455f4b22a47ffd853738f679b439593c","repo":"protonmail/webclients","base_commit":"85560278585cd2d6f6f022112c912d03a79b2da7","dockerhub_tag":"protonmail.webclients-protonmail__webclients-2f66db85455f4b22a47ffd853738f679b439593c"} +{"instance_id":"instance_gravitational__teleport-1a77b7945a022ab86858029d30ac7ad0d5239d00-vee9b09fb20c43af7e520f57e9239bbcf46b7113d","repo":"gravitational/teleport","base_commit":"ddce494766621f4650c7e026595832edd8b40a26","dockerhub_tag":"gravitational.teleport-gravitational__teleport-1a77b7945a022ab86858029d30ac7ad0d5239d00-vee9b09fb20c43af7e520f57e9239bbcf46b7113"} +{"instance_id":"instance_gravitational__teleport-d873ea4fa67d3132eccba39213c1ca2f52064dcc-vce94f93ad1030e3136852817f2423c1b3ac37bc4","repo":"gravitational/teleport","base_commit":"0b192c8d132e07e024340a9780c1641a5de5b326","dockerhub_tag":"gravitational.teleport-gravitational__teleport-d873ea4fa67d3132eccba39213c1ca2f52064dcc-vce94f93ad1030e3136852817f2423c1b3ac37bc"} +{"instance_id":"instance_ansible__ansible-8127abbc298cabf04aaa89a478fc5e5e3432a6fc-v30a923fb5c164d6cd18280c02422f75e611e8fb2","repo":"ansible/ansible","base_commit":"3684b4824d367f866d038c5373f975503580d49e","dockerhub_tag":"ansible.ansible-ansible__ansible-8127abbc298cabf04aaa89a478fc5e5e3432a6fc-v30a923fb5c164d6cd18280c02422f75e611e8fb2"} +{"instance_id":"instance_qutebrowser__qutebrowser-8f46ba3f6dc7b18375f7aa63c48a1fe461190430-v2ef375ac784985212b1805e1d0431dc8f1b3c171","repo":"qutebrowser/qutebrowser","base_commit":"1547a48e6f1a8af8dc618d5afe858084ebfd317f","dockerhub_tag":"qutebrowser.qutebrowser-qutebrowser__qutebrowser-8f46ba3f6dc7b18375f7aa63c48a1fe461190430-v2ef375ac784985212b1805e1d0431dc8f1b3c"} +{"instance_id":"instance_internetarchive__openlibrary-25858f9f0c165df25742acf8309ce909773f0cdd-v13642507b4fc1f8d234172bf8129942da2c2ca26","repo":"internetarchive/openlibrary","base_commit":"322d7a46cdc965bfabbf9500e98fde098c9d95b2","dockerhub_tag":"internetarchive.openlibrary-internetarchive__openlibrary-25858f9f0c165df25742acf8309ce909773f0cdd-v13642507b4fc1f8d234172bf81299"} +{"instance_id":"instance_flipt-io__flipt-b6cef5cdc0daff3ee99e5974ed60a1dc6b4b0d67","repo":"flipt-io/flipt","base_commit":"1bd9924b177927fa51d016a71a4353ab9c0d32e7","dockerhub_tag":"flipt-io.flipt-flipt-io__flipt-b6cef5cdc0daff3ee99e5974ed60a1dc6b4b0d67"} +{"instance_id":"instance_future-architect__vuls-e4728e388120b311c4ed469e4f942e0347a2689b-v264a82e2f4818e30f5a25e4da53b27ba119f62b5","repo":"future-architect/vuls","base_commit":"61c39637f2f3809e1b5dad05f0c57c799dce1587","dockerhub_tag":"future-architect.vuls-future-architect__vuls-e4728e388120b311c4ed469e4f942e0347a2689b-v264a82e2f4818e30f5a25e4da53b27ba119f62b5"} +{"instance_id":"instance_internetarchive__openlibrary-f8cc11d9c1575fdba5ac66aee0befca970da8d64-v13642507b4fc1f8d234172bf8129942da2c2ca26","repo":"internetarchive/openlibrary","base_commit":"3677dd20bcdd17aa0fa0f202f4ea50c46936bdc5","dockerhub_tag":"internetarchive.openlibrary-internetarchive__openlibrary-f8cc11d9c1575fdba5ac66aee0befca970da8d64-v13642507b4fc1f8d234172bf81299"} +{"instance_id":"instance_future-architect__vuls-f0b3a8b1db98eb1bd32685f1c36c41a99c3452ed","repo":"future-architect/vuls","base_commit":"0b9ec05181360e3fdb4a314152927f6f3ccb746d","dockerhub_tag":"future-architect.vuls-future-architect__vuls-f0b3a8b1db98eb1bd32685f1c36c41a99c3452ed"} +{"instance_id":"instance_ansible__ansible-0ea40e09d1b35bcb69ff4d9cecf3d0defa4b36e8-v30a923fb5c164d6cd18280c02422f75e611e8fb2","repo":"ansible/ansible","base_commit":"f7234968d241d7171aadb1e873a67510753f3163","dockerhub_tag":"ansible.ansible-ansible__ansible-0ea40e09d1b35bcb69ff4d9cecf3d0defa4b36e8-v30a923fb5c164d6cd18280c02422f75e611e8fb2"} +{"instance_id":"instance_future-architect__vuls-e1df74cbc1a1d1889428b3333a3b2405c4651993","repo":"future-architect/vuls","base_commit":"426eb53af546eea10d44699b225ade095f4f5c03","dockerhub_tag":"future-architect.vuls-future-architect__vuls-e1df74cbc1a1d1889428b3333a3b2405c4651993"} +{"instance_id":"instance_gravitational__teleport-baeb2697c4e4870c9850ff0cd5c7a2d08e1401c9-vee9b09fb20c43af7e520f57e9239bbcf46b7113d","repo":"gravitational/teleport","base_commit":"875e9337e00cc332a8e786612aaff2566b128858","dockerhub_tag":"gravitational.teleport-gravitational__teleport-baeb2697c4e4870c9850ff0cd5c7a2d08e1401c9-vee9b09fb20c43af7e520f57e9239bbcf46b7113"} +{"instance_id":"instance_gravitational__teleport-10123c046e21e1826098e485a4c2212865a49d9f","repo":"gravitational/teleport","base_commit":"43fc9f6de6e22bf617b9973ffac6097c5d16982f","dockerhub_tag":"gravitational.teleport-gravitational__teleport-10123c046e21e1826098e485a4c2212865a49d9f"} +{"instance_id":"instance_flipt-io__flipt-0fd09def402258834b9d6c0eaa6d3b4ab93b4446","repo":"flipt-io/flipt","base_commit":"3ddd2d16f10a3a0c55c135bdcfa0d1a0307929f4","dockerhub_tag":"flipt-io.flipt-flipt-io__flipt-0fd09def402258834b9d6c0eaa6d3b4ab93b4446"} +{"instance_id":"instance_ansible__ansible-949c503f2ef4b2c5d668af0492a5c0db1ab86140-v0f01c69f1e2528b935359cfe578530722bca2c59","repo":"ansible/ansible","base_commit":"375d3889de9f437bc120ade623c170198629375d","dockerhub_tag":"ansible.ansible-ansible__ansible-949c503f2ef4b2c5d668af0492a5c0db1ab86140-v0f01c69f1e2528b935359cfe578530722bca2c59"} +{"instance_id":"instance_ansible__ansible-709484969c8a4ffd74b839a673431a8c5caa6457-vba6da65a0f3baefda7a058ebbd0a8dcafb8512f5","repo":"ansible/ansible","base_commit":"35809806d3ab5d66fbb9696dc6a0009383e50673","dockerhub_tag":"ansible.ansible-ansible__ansible-709484969c8a4ffd74b839a673431a8c5caa6457-vba6da65a0f3baefda7a058ebbd0a8dcafb8512f5"} +{"instance_id":"instance_flipt-io__flipt-cd2f3b0a9d4d8b8a6d3d56afab65851ecdc408e8","repo":"flipt-io/flipt","base_commit":"a91a0258e72c0f0aac3d33ae5c226a85c80ecdf8","dockerhub_tag":"flipt-io.flipt-flipt-io__flipt-cd2f3b0a9d4d8b8a6d3d56afab65851ecdc408e8"} +{"instance_id":"instance_navidrome__navidrome-28389fb05e1523564dfc61fa43ed8eb8a10f938c","repo":"navidrome/navidrome","base_commit":"5d8318f7b362c5b044f892f775d264a5d40e4e24","dockerhub_tag":"navidrome.navidrome-navidrome__navidrome-28389fb05e1523564dfc61fa43ed8eb8a10f938c"} +{"instance_id":"instance_element-hq__element-web-44b98896a79ede48f5ad7ff22619a39d5f6ff03c-vnan","repo":"element-hq/element-web","base_commit":"19f9f9856451a8e4cce6d313d19ca8aed4b5d6b4","dockerhub_tag":"element-hq.element-element-hq__element-web-44b98896a79ede48f5ad7ff22619a39d5f6ff03c"} +{"instance_id":"instance_ansible__ansible-e40889e7112ae00a21a2c74312b330e67a766cc0-v1055803c3a812189a1133297f7f5468579283f86","repo":"ansible/ansible","base_commit":"225ae65b0fcf0931c9ce58d68a28d1883d5bf451","dockerhub_tag":"ansible.ansible-ansible__ansible-e40889e7112ae00a21a2c74312b330e67a766cc0-v1055803c3a812189a1133297f7f5468579283f86"} +{"instance_id":"instance_protonmail__webclients-7b833df125859e5eb98a826e5b83efe0f93a347b","repo":"protonmail/webclients","base_commit":"7264c6bd7f515ae4609be9a5f0c3032ae6fe486a","dockerhub_tag":"protonmail.webclients-protonmail__webclients-7b833df125859e5eb98a826e5b83efe0f93a347b"} +{"instance_id":"instance_protonmail__webclients-0d0267c4438cf378bda90bc85eed3a3615871ac4","repo":"protonmail/webclients","base_commit":"782d01551257eb0a373db3b2d5c39612b87fa7e9","dockerhub_tag":"protonmail.webclients-protonmail__webclients-0d0267c4438cf378bda90bc85eed3a3615871ac4"} +{"instance_id":"instance_ansible__ansible-ea04e0048dbb3b63f876aad7020e1de8eee9f362-v1055803c3a812189a1133297f7f5468579283f86","repo":"ansible/ansible","base_commit":"341a6be78d7fc1701b0b120fc9df1c913a12948c","dockerhub_tag":"ansible.ansible-ansible__ansible-ea04e0048dbb3b63f876aad7020e1de8eee9f362-v1055803c3a812189a1133297f7f5468579283f86"} +{"instance_id":"instance_qutebrowser__qutebrowser-35168ade46184d7e5b91dfa04ca42fe2abd82717-v363c8a7e5ccdf6968fc7ab84a2053ac78036691d","repo":"qutebrowser/qutebrowser","base_commit":"04c65bb2b72542b239de2491c9242d8f641636db","dockerhub_tag":"qutebrowser.qutebrowser-qutebrowser__qutebrowser-35168ade46184d7e5b91dfa04ca42fe2abd82717-v363c8a7e5ccdf6968fc7ab84a2053ac780366"} +{"instance_id":"instance_flipt-io__flipt-db1c3b100e231c62f0c90c2ab037614f20a2a63b","repo":"flipt-io/flipt","base_commit":"6c91b1ad50c452d90c484888690eb6257ee2c20a","dockerhub_tag":"flipt-io.flipt-flipt-io__flipt-db1c3b100e231c62f0c90c2ab037614f20a2a63b"} +{"instance_id":"instance_gravitational__teleport-f432a71a13e698b6e1c4672a2e9e9c1f32d35c12","repo":"gravitational/teleport","base_commit":"a4a6a3e42d90918341224dd7f2ba45856b1b6c70","dockerhub_tag":"gravitational.teleport-gravitational__teleport-f432a71a13e698b6e1c4672a2e9e9c1f32d35c12"} +{"instance_id":"instance_navidrome__navidrome-3853c3318f67b41a9e4cb768618315ff77846fdb","repo":"navidrome/navidrome","base_commit":"257ccc5f4323bb2f39e09fa903546edf7cdf370a","dockerhub_tag":"navidrome.navidrome-navidrome__navidrome-3853c3318f67b41a9e4cb768618315ff77846fdb"} +{"instance_id":"instance_future-architect__vuls-f6cc8c263dc00329786fa516049c60d4779c4a07","repo":"future-architect/vuls","base_commit":"fa3c08bd3cc47c37c08e64e9868b2a17851e4818","dockerhub_tag":"future-architect.vuls-future-architect__vuls-f6cc8c263dc00329786fa516049c60d4779c4a07"} +{"instance_id":"instance_NodeBB__NodeBB-84e065752f6d7fbe5c08cbf50cb173ffb866b8fa-vf2cf3cbd463b7ad942381f1c6d077626485a1e9e","repo":"NodeBB/NodeBB","base_commit":"50e1a1a7ca1d95cbf82187ff685bea8cf3966cd0","dockerhub_tag":"nodebb.nodebb-NodeBB__NodeBB-84e065752f6d7fbe5c08cbf50cb173ffb866b8fa-vf2cf3cbd463b7ad942381f1c6d077626485a1e9e"} +{"instance_id":"instance_ansible__ansible-1ee70fc272aff6bf3415357c6e13c5de5b928d9b-v1055803c3a812189a1133297f7f5468579283f86","repo":"ansible/ansible","base_commit":"9281148b623d4e2e8302778d91af3e84ab9579a9","dockerhub_tag":"ansible.ansible-ansible__ansible-1ee70fc272aff6bf3415357c6e13c5de5b928d9b-v1055803c3a812189a1133297f7f5468579283f86"} +{"instance_id":"instance_NodeBB__NodeBB-84dfda59e6a0e8a77240f939a7cb8757e6eaf945-v2c59007b1005cd5cd14cbb523ca5229db1fd2dd8","repo":"NodeBB/NodeBB","base_commit":"aad0c5fd5138a31dfd766d2e6808a35b7dfb4a74","dockerhub_tag":"nodebb.nodebb-NodeBB__NodeBB-84dfda59e6a0e8a77240f939a7cb8757e6eaf945-v2c59007b1005cd5cd14cbb523ca5229db1fd2dd8"} +{"instance_id":"instance_element-hq__element-web-459df4583e01e4744a52d45446e34183385442d6-vnan","repo":"element-hq/element-web","base_commit":"dd91250111dcf4f398e125e14c686803315ebf5d","dockerhub_tag":"element-hq.element-element-hq__element-web-459df4583e01e4744a52d45446e34183385442d6"} +{"instance_id":"instance_tutao__tutanota-40e94dee2bcec2b63f362da283123e9df1874cc1-vc4e41fd0029957297843cb9dec4a25c7c756f029","repo":"tutao/tutanota","base_commit":"a74f4b8d6f357e1ef0f22b00a244c8a3d9272304","dockerhub_tag":"tutao.tutanota-tutao__tutanota-40e94dee2bcec2b63f362da283123e9df1874cc1-vc4e41fd0029957297843cb9dec4a25c7c756f029"} +{"instance_id":"instance_future-architect__vuls-78b52d6a7f480bd610b692de9bf0c86f57332f23","repo":"future-architect/vuls","base_commit":"048e204b330494643a3b6859a68c31b4b2126f59","dockerhub_tag":"future-architect.vuls-future-architect__vuls-78b52d6a7f480bd610b692de9bf0c86f57332f23"} +{"instance_id":"instance_element-hq__element-web-66d0b318bc6fee0d17b54c1781d6ab5d5d323135-vnan","repo":"element-hq/element-web","base_commit":"04bc8fb71c4a1ee1eb1f0c4a1de1641d353e9f2c","dockerhub_tag":"element-hq.element-element-hq__element-web-66d0b318bc6fee0d17b54c1781d6ab5d5d323135"} +{"instance_id":"instance_qutebrowser__qutebrowser-a84ecfb80a00f8ab7e341372560458e3f9cfffa2-v2ef375ac784985212b1805e1d0431dc8f1b3c171","repo":"qutebrowser/qutebrowser","base_commit":"c9380605a1240748769c012403520323b4d2c3be","dockerhub_tag":"qutebrowser.qutebrowser-qutebrowser__qutebrowser-a84ecfb80a00f8ab7e341372560458e3f9cfffa2-v2ef375ac784985212b1805e1d0431dc8f1b3c"} +{"instance_id":"instance_flipt-io__flipt-dbe263961b187e1c5d7fe34c65b000985a2da5a0","repo":"flipt-io/flipt","base_commit":"8ba3ab7d7ac8f552e61204103f5632ab8843a721","dockerhub_tag":"flipt-io.flipt-flipt-io__flipt-dbe263961b187e1c5d7fe34c65b000985a2da5a0"} +{"instance_id":"instance_ansible__ansible-a26c325bd8f6e2822d9d7e62f77a424c1db4fbf6-v0f01c69f1e2528b935359cfe578530722bca2c59","repo":"ansible/ansible","base_commit":"79f67ed56116be11b1c992fade04acf06d9208d1","dockerhub_tag":"ansible.ansible-ansible__ansible-a26c325bd8f6e2822d9d7e62f77a424c1db4fbf6-v0f01c69f1e2528b935359cfe578530722bca2c59"} +{"instance_id":"instance_internetarchive__openlibrary-798055d1a19b8fa0983153b709f460be97e33064-v13642507b4fc1f8d234172bf8129942da2c2ca26","repo":"internetarchive/openlibrary","base_commit":"7b1ec94b425e4032a8c1b66a5219b4262af49484","dockerhub_tag":"internetarchive.openlibrary-internetarchive__openlibrary-798055d1a19b8fa0983153b709f460be97e33064-v13642507b4fc1f8d234172bf81299"} +{"instance_id":"instance_gravitational__teleport-eefac60a350930e5f295f94a2d55b94c1988c04e-vee9b09fb20c43af7e520f57e9239bbcf46b7113d","repo":"gravitational/teleport","base_commit":"eca1d01746c031f95e8df1ef3eea36d31416633d","dockerhub_tag":"gravitational.teleport-gravitational__teleport-eefac60a350930e5f295f94a2d55b94c1988c04e-vee9b09fb20c43af7e520f57e9239bbcf46b7113"} +{"instance_id":"instance_protonmail__webclients-7e54526774e577c0ebb58ced7ba8bef349a69fec","repo":"protonmail/webclients","base_commit":"9962092e576b71effbd99523da503148691bb3a6","dockerhub_tag":"protonmail.webclients-protonmail__webclients-7e54526774e577c0ebb58ced7ba8bef349a69fec"} +{"instance_id":"instance_gravitational__teleport-4d0117b50dc8cdb91c94b537a4844776b224cd3d","repo":"gravitational/teleport","base_commit":"e2412a7c37314c9482d856f407f737c9e5b34bce","dockerhub_tag":"gravitational.teleport-gravitational__teleport-4d0117b50dc8cdb91c94b537a4844776b224cd3d"} +{"instance_id":"instance_navidrome__navidrome-5e549255201e622c911621a7b770477b1f5a89be","repo":"navidrome/navidrome","base_commit":"39da741a807498a01a31435a097b98fe6021c902","dockerhub_tag":"navidrome.navidrome-navidrome__navidrome-5e549255201e622c911621a7b770477b1f5a89be"} +{"instance_id":"instance_ansible__ansible-11c1777d56664b1acb56b387a1ad6aeadef1391d-v0f01c69f1e2528b935359cfe578530722bca2c59","repo":"ansible/ansible","base_commit":"e1daaae42af1a4e465edbdad4bb3c6dd7e7110d5","dockerhub_tag":"ansible.ansible-ansible__ansible-11c1777d56664b1acb56b387a1ad6aeadef1391d-v0f01c69f1e2528b935359cfe578530722bca2c59"} +{"instance_id":"instance_qutebrowser__qutebrowser-8d05f0282a271bfd45e614238bd1b555c58b3fc1-v35616345bb8052ea303186706cec663146f0f184","repo":"qutebrowser/qutebrowser","base_commit":"190bab127d9e8421940f5f3fdc738d1c7ec02193","dockerhub_tag":"qutebrowser.qutebrowser-qutebrowser__qutebrowser-8d05f0282a271bfd45e614238bd1b555c58b3fc1-v35616345bb8052ea303186706cec663146f0f"} +{"instance_id":"instance_NodeBB__NodeBB-eb49a64974ca844bca061744fb3383f5d13b02ad-vnan","repo":"NodeBB/NodeBB","base_commit":"8fd8079a84d8e71ab02eaa69ef15cb33fcea85c7","dockerhub_tag":"nodebb.nodebb-NodeBB__NodeBB-eb49a64974ca844bca061744fb3383f5d13b02ad"} +{"instance_id":"instance_ansible__ansible-3b823d908e8a5d17674f8c26d337d3114b7493b1-v0f01c69f1e2528b935359cfe578530722bca2c59","repo":"ansible/ansible","base_commit":"92df66480613d0f3c1f11ab27146e3162d2a5bd5","dockerhub_tag":"ansible.ansible-ansible__ansible-3b823d908e8a5d17674f8c26d337d3114b7493b1-v0f01c69f1e2528b935359cfe578530722bca2c59"} +{"instance_id":"instance_future-architect__vuls-9aa0d87a21bede91c2b45c32187456bb69455e92","repo":"future-architect/vuls","base_commit":"fe3f1b99245266e848f7b8f240f1f81ae3ff04df","dockerhub_tag":"future-architect.vuls-future-architect__vuls-9aa0d87a21bede91c2b45c32187456bb69455e92"} +{"instance_id":"instance_navidrome__navidrome-fa85e2a7816a6fe3829a4c0d8e893e982b0985da","repo":"navidrome/navidrome","base_commit":"5360283bb0368c5226b301f99b7095a54407b053","dockerhub_tag":"navidrome.navidrome-navidrome__navidrome-fa85e2a7816a6fe3829a4c0d8e893e982b0985da"} +{"instance_id":"instance_ansible__ansible-a02e22e902a69aeb465f16bf03f7f5a91b2cb828-vba6da65a0f3baefda7a058ebbd0a8dcafb8512f5","repo":"ansible/ansible","base_commit":"813c25eed1e4832a8ae363455a2f40bb3de33c7f","dockerhub_tag":"ansible.ansible-ansible__ansible-a02e22e902a69aeb465f16bf03f7f5a91b2cb828-vba6da65a0f3baefda7a058ebbd0a8dcafb8512f5"} +{"instance_id":"instance_internetarchive__openlibrary-757fcf46c70530739c150c57b37d6375f155dc97-ve8c8d62a2b60610a3c4631f5f23ed866bada9818","repo":"internetarchive/openlibrary","base_commit":"34099a36bcd3e9f33e169beb06f64dfab81c2cde","dockerhub_tag":"internetarchive.openlibrary-internetarchive__openlibrary-757fcf46c70530739c150c57b37d6375f155dc97-ve8c8d62a2b60610a3c4631f5f23ed"} +{"instance_id":"instance_navidrome__navidrome-c90468b895f6171e33e937ff20dc915c995274f0","repo":"navidrome/navidrome","base_commit":"69e0a266f48bae24a11312e9efbe495a337e4c84","dockerhub_tag":"navidrome.navidrome-navidrome__navidrome-c90468b895f6171e33e937ff20dc915c995274f0"} +{"instance_id":"instance_protonmail__webclients-708ed4a299711f0fa79a907cc5847cfd39c0fc71","repo":"protonmail/webclients","base_commit":"3f9771dd682247118e66e9e27bc6ef677ef5214d","dockerhub_tag":"protonmail.webclients-protonmail__webclients-708ed4a299711f0fa79a907cc5847cfd39c0fc71"} +{"instance_id":"instance_internetarchive__openlibrary-acdddc590d0b3688f8f6386f43709049622a6e19-vfa6ff903cb27f336e17654595dd900fa943dcd91","repo":"internetarchive/openlibrary","base_commit":"ba03a119df799aba82ff81b72d3366975de7ceed","dockerhub_tag":"internetarchive.openlibrary-internetarchive__openlibrary-acdddc590d0b3688f8f6386f43709049622a6e19-vfa6ff903cb27f336e17654595dd90"} +{"instance_id":"instance_navidrome__navidrome-b65e76293a917ee2dfc5d4b373b1c62e054d0dca","repo":"navidrome/navidrome","base_commit":"5f6f74ff2dde934aae2f2def911506d8c4ba66e1","dockerhub_tag":"navidrome.navidrome-navidrome__navidrome-b65e76293a917ee2dfc5d4b373b1c62e054d0dca"} +{"instance_id":"instance_internetarchive__openlibrary-bdba0af0f6cbaca8b5fc3be2a3080f38156d9c92-ve8c8d62a2b60610a3c4631f5f23ed866bada9818","repo":"internetarchive/openlibrary","base_commit":"4a17636ae04cf6039ccb6b91f2ed13ce589358d4","dockerhub_tag":"internetarchive.openlibrary-internetarchive__openlibrary-bdba0af0f6cbaca8b5fc3be2a3080f38156d9c92-ve8c8d62a2b60610a3c4631f5f23ed"} +{"instance_id":"instance_qutebrowser__qutebrowser-deeb15d6f009b3ca0c3bd503a7cef07462bd16b4-v363c8a7e5ccdf6968fc7ab84a2053ac78036691d","repo":"qutebrowser/qutebrowser","base_commit":"3ae5cc96aecb12008345f45bd7d06dbc52e48fa7","dockerhub_tag":"qutebrowser.qutebrowser-qutebrowser__qutebrowser-deeb15d6f009b3ca0c3bd503a7cef07462bd16b4-v363c8a7e5ccdf6968fc7ab84a2053ac780366"} +{"instance_id":"instance_internetarchive__openlibrary-6fdbbeee4c0a7e976ff3e46fb1d36f4eb110c428-v08d8e8889ec945ab821fb156c04c7d2e2810debb","repo":"internetarchive/openlibrary","base_commit":"71b18af1fa3b1e0ea6acb368037736be759a8bca","dockerhub_tag":"internetarchive.openlibrary-internetarchive__openlibrary-6fdbbeee4c0a7e976ff3e46fb1d36f4eb110c428-v08d8e8889ec945ab821fb156c04c7"} +{"instance_id":"instance_gravitational__teleport-24cafecd8721891092210afc55f6413ab46ca211-vee9b09fb20c43af7e520f57e9239bbcf46b7113d","repo":"gravitational/teleport","base_commit":"6e16ad6627ca17789a12c53fec627260002bbed0","dockerhub_tag":"gravitational.teleport-gravitational__teleport-24cafecd8721891092210afc55f6413ab46ca211-vee9b09fb20c43af7e520f57e9239bbcf46b7113"} +{"instance_id":"instance_internetarchive__openlibrary-4b7ea2977be2747496ba792a678940baa985f7ea-v0f5aece3601a5b4419f7ccec1dbda2071be28ee4","repo":"internetarchive/openlibrary","base_commit":"86d9b8a203cab5bc446614f3cbffd77b4751084a","dockerhub_tag":"internetarchive.openlibrary-internetarchive__openlibrary-4b7ea2977be2747496ba792a678940baa985f7ea-v0f5aece3601a5b4419f7ccec1dbda"} +{"instance_id":"instance_NodeBB__NodeBB-397835a05a8e2897324e566b41c5e616e172b4af-v89631a1cdb318276acb48860c5d78077211397c6","repo":"NodeBB/NodeBB","base_commit":"7f48edc02aa68c547d96ad7d6432ff8c1e359742","dockerhub_tag":"nodebb.nodebb-NodeBB__NodeBB-397835a05a8e2897324e566b41c5e616e172b4af-v89631a1cdb318276acb48860c5d78077211397c6"} +{"instance_id":"instance_gravitational__teleport-005dcb16bacc6a5d5890c4cd302ccfd4298e275d-vee9b09fb20c43af7e520f57e9239bbcf46b7113d","repo":"gravitational/teleport","base_commit":"4d7c51b4f535cecfd139625e6af1746c46abc712","dockerhub_tag":"gravitational.teleport-gravitational__teleport-005dcb16bacc6a5d5890c4cd302ccfd4298e275d-vee9b09fb20c43af7e520f57e9239bbcf46b7113"} +{"instance_id":"instance_gravitational__teleport-ac2fb2f9b4fd1896b554d3011df23d3d71295779","repo":"gravitational/teleport","base_commit":"7b8bfe4f609a40c5a4d592b91c91d2921ed24e64","dockerhub_tag":"gravitational.teleport-gravitational__teleport-ac2fb2f9b4fd1896b554d3011df23d3d71295779"} +{"instance_id":"instance_element-hq__element-web-404c412bcb694f04ba0c4d5479541203d701bca0-vnan","repo":"element-hq/element-web","base_commit":"f152613f830ec32a3de3d7f442816a63a4c732c5","dockerhub_tag":"element-hq.element-element-hq__element-web-404c412bcb694f04ba0c4d5479541203d701bca0"} +{"instance_id":"instance_internetarchive__openlibrary-4a5d2a7d24c9e4c11d3069220c0685b736d5ecde-v13642507b4fc1f8d234172bf8129942da2c2ca26","repo":"internetarchive/openlibrary","base_commit":"90475fb6c168e8317e22bd5fbe057d98e570a715","dockerhub_tag":"internetarchive.openlibrary-internetarchive__openlibrary-4a5d2a7d24c9e4c11d3069220c0685b736d5ecde-v13642507b4fc1f8d234172bf81299"} +{"instance_id":"instance_gravitational__teleport-645afa051b65d137654fd0d2d878a700152b305a-vee9b09fb20c43af7e520f57e9239bbcf46b7113d","repo":"gravitational/teleport","base_commit":"ec6c5eafcec27adb503ff9ead7e42d2be4374fac","dockerhub_tag":"gravitational.teleport-gravitational__teleport-645afa051b65d137654fd0d2d878a700152b305a-vee9b09fb20c43af7e520f57e9239bbcf46b7113"} +{"instance_id":"instance_internetarchive__openlibrary-f3b26c2c0721f8713353fe4b341230332e30008d-v0f5aece3601a5b4419f7ccec1dbda2071be28ee4","repo":"internetarchive/openlibrary","base_commit":"471ffcf05c6b9ceaf879eb95d3a86ccf8232123b","dockerhub_tag":"internetarchive.openlibrary-internetarchive__openlibrary-f3b26c2c0721f8713353fe4b341230332e30008d-v0f5aece3601a5b4419f7ccec1dbda"} +{"instance_id":"instance_ansible__ansible-29aea9ff3466e4cd2ed00524b9e56738d568ce8b-vba6da65a0f3baefda7a058ebbd0a8dcafb8512f5","repo":"ansible/ansible","base_commit":"270f109bb3af5c2498725b384f77ddc26da2fb73","dockerhub_tag":"ansible.ansible-ansible__ansible-29aea9ff3466e4cd2ed00524b9e56738d568ce8b-vba6da65a0f3baefda7a058ebbd0a8dcafb8512f5"} +{"instance_id":"instance_ansible__ansible-ed6581e4db2f1bec5a772213c3e186081adc162d-v0f01c69f1e2528b935359cfe578530722bca2c59","repo":"ansible/ansible","base_commit":"c819c1725de510fb41e8bdc38e68c2ac1df81ced","dockerhub_tag":"ansible.ansible-ansible__ansible-ed6581e4db2f1bec5a772213c3e186081adc162d-v0f01c69f1e2528b935359cfe578530722bca2c59"} +{"instance_id":"instance_internetarchive__openlibrary-6a117fab6c963b74dc1ba907d838e74f76d34a4b-v13642507b4fc1f8d234172bf8129942da2c2ca26","repo":"internetarchive/openlibrary","base_commit":"f1f4efd659429d868ba8c4efc1405763d7864a70","dockerhub_tag":"internetarchive.openlibrary-internetarchive__openlibrary-6a117fab6c963b74dc1ba907d838e74f76d34a4b-v13642507b4fc1f8d234172bf81299"} +{"instance_id":"instance_qutebrowser__qutebrowser-479aa075ac79dc975e2e949e188a328e95bf78ff-vc2f56a753b62a190ddb23cd330c257b9cf560d12","repo":"qutebrowser/qutebrowser","base_commit":"34db7a1ef4139f30f5b6289ea114c44e1a7b33a6","dockerhub_tag":"qutebrowser.qutebrowser-qutebrowser__qutebrowser-479aa075ac79dc975e2e949e188a328e95bf78ff-vc2f56a753b62a190ddb23cd330c257b9cf560"} +{"instance_id":"instance_navidrome__navidrome-d8e794317f788198227e10fb667e10496b3eb99a","repo":"navidrome/navidrome","base_commit":"128b626ec9330a7693ec6bbc9788d75eb2ef55e6","dockerhub_tag":"navidrome.navidrome-navidrome__navidrome-d8e794317f788198227e10fb667e10496b3eb99a"} +{"instance_id":"instance_navidrome__navidrome-d613b1930688422122796b43acb3caf2538c8fd1","repo":"navidrome/navidrome","base_commit":"a2d9aaeff8774115cd1d911c23a74e319d72ce62","dockerhub_tag":"navidrome.navidrome-navidrome__navidrome-d613b1930688422122796b43acb3caf2538c8fd1"} +{"instance_id":"instance_protonmail__webclients-08bb09914d0d37b0cd6376d4cab5b77728a43e7b","repo":"protonmail/webclients","base_commit":"cc7976723b05683d80720fc9a352445e5dbb4c85","dockerhub_tag":"protonmail.webclients-protonmail__webclients-08bb09914d0d37b0cd6376d4cab5b77728a43e7b"} +{"instance_id":"instance_NodeBB__NodeBB-0c81642997ea1d827dbd02c311db9d4976112cd4-vf2cf3cbd463b7ad942381f1c6d077626485a1e9e","repo":"NodeBB/NodeBB","base_commit":"03a98f4de484f16d038892a0a9d2317a45e79df1","dockerhub_tag":"nodebb.nodebb-NodeBB__NodeBB-0c81642997ea1d827dbd02c311db9d4976112cd4-vf2cf3cbd463b7ad942381f1c6d077626485a1e9e"} +{"instance_id":"instance_gravitational__teleport-4e1c39639edf1ab494dd7562844c8b277b5cfa18-vee9b09fb20c43af7e520f57e9239bbcf46b7113d","repo":"gravitational/teleport","base_commit":"07e2ca13e4b4836f93d8e2c3ed727b3d5e3cd73f","dockerhub_tag":"gravitational.teleport-gravitational__teleport-4e1c39639edf1ab494dd7562844c8b277b5cfa18-vee9b09fb20c43af7e520f57e9239bbcf46b7113"} +{"instance_id":"instance_ansible__ansible-42355d181a11b51ebfc56f6f4b3d9c74e01cb13b-v1055803c3a812189a1133297f7f5468579283f86","repo":"ansible/ansible","base_commit":"fafb23094e77a619066a92a7fa99a7045292e473","dockerhub_tag":"ansible.ansible-ansible__ansible-42355d181a11b51ebfc56f6f4b3d9c74e01cb13b-v1055803c3a812189a1133297f7f5468579283f86"} +{"instance_id":"instance_flipt-io__flipt-a42d38a1bb1df267c53d9d4a706cf34825ae3da9","repo":"flipt-io/flipt","base_commit":"ee02b164f6728d3227c42671028c67a4afd36918","dockerhub_tag":"flipt-io.flipt-flipt-io__flipt-a42d38a1bb1df267c53d9d4a706cf34825ae3da9"} +{"instance_id":"instance_flipt-io__flipt-690672523398c2b6f6e4562f0bf9868664ab894f","repo":"flipt-io/flipt","base_commit":"6da20eb7afb693a1cbee2482272e3aee2fbd43ee","dockerhub_tag":"flipt-io.flipt-flipt-io__flipt-690672523398c2b6f6e4562f0bf9868664ab894f"} +{"instance_id":"instance_qutebrowser__qutebrowser-394bfaed6544c952c6b3463751abab3176ad4997-vafb3e8e01b31319c66c4e666b8a3b1d8ba55db24","repo":"qutebrowser/qutebrowser","base_commit":"d1164925c55f2417f1c3130b0196830bc2a3d25d","dockerhub_tag":"qutebrowser.qutebrowser-qutebrowser__qutebrowser-394bfaed6544c952c6b3463751abab3176ad4997-vafb3e8e01b31319c66c4e666b8a3b1d8ba55d"} +{"instance_id":"instance_qutebrowser__qutebrowser-96b997802e942937e81d2b8a32d08f00d3f4bc4e-v5fc38aaf22415ab0b70567368332beee7955b367","repo":"qutebrowser/qutebrowser","base_commit":"2e65f731b1b615b5cd60417c00b6993c2295e9f8","dockerhub_tag":"qutebrowser.qutebrowser-qutebrowser__qutebrowser-96b997802e942937e81d2b8a32d08f00d3f4bc4e-v5fc38aaf22415ab0b70567368332beee7955b"} +{"instance_id":"instance_internetarchive__openlibrary-03095f2680f7516fca35a58e665bf2a41f006273-v8717e18970bcdc4e0d2cea3b1527752b21e74866","repo":"internetarchive/openlibrary","base_commit":"46bcf7c30178f53ef427a5840c4b24717ed79fb0","dockerhub_tag":"internetarchive.openlibrary-internetarchive__openlibrary-03095f2680f7516fca35a58e665bf2a41f006273-v8717e18970bcdc4e0d2cea3b15277"} +{"instance_id":"instance_flipt-io__flipt-15b76cada1ef29cfa56b0fba36754be36243dded","repo":"flipt-io/flipt","base_commit":"77e21fd62a00c6d2d4fd55a7501e6a8a95404e2e","dockerhub_tag":"flipt-io.flipt-flipt-io__flipt-15b76cada1ef29cfa56b0fba36754be36243dded"} +{"instance_id":"instance_navidrome__navidrome-677d9947f302c9f7bba8c08c788c3dc99f235f39","repo":"navidrome/navidrome","base_commit":"a0290587b92cf29a3f8af6ea9f93551b28d1ce75","dockerhub_tag":"navidrome.navidrome-navidrome__navidrome-677d9947f302c9f7bba8c08c788c3dc99f235f39"} +{"instance_id":"instance_internetarchive__openlibrary-fad4a40acf5ff5f06cd7441a5c7baf41a7d81fe4-vfa6ff903cb27f336e17654595dd900fa943dcd91","repo":"internetarchive/openlibrary","base_commit":"afb819f8166c6dff4295c6802cc0b55b67f05731","dockerhub_tag":"internetarchive.openlibrary-internetarchive__openlibrary-fad4a40acf5ff5f06cd7441a5c7baf41a7d81fe4-vfa6ff903cb27f336e17654595dd90"} +{"instance_id":"instance_gravitational__teleport-46aa81b1ce96ebb4ebed2ae53fd78cd44a05da6c-vee9b09fb20c43af7e520f57e9239bbcf46b7113d","repo":"gravitational/teleport","base_commit":"f958e03439735473578485ff01d720c06324a716","dockerhub_tag":"gravitational.teleport-gravitational__teleport-46aa81b1ce96ebb4ebed2ae53fd78cd44a05da6c-vee9b09fb20c43af7e520f57e9239bbcf46b7113"} +{"instance_id":"instance_flipt-io__flipt-b22f5f02e40b225b6b93fff472914973422e97c6","repo":"flipt-io/flipt","base_commit":"08213a50b2cb54709aeb44125f33d55364ea6237","dockerhub_tag":"flipt-io.flipt-flipt-io__flipt-b22f5f02e40b225b6b93fff472914973422e97c6"} +{"instance_id":"instance_internetarchive__openlibrary-1894cb48d6e7fb498295a5d3ed0596f6f603b784-v0f5aece3601a5b4419f7ccec1dbda2071be28ee4","repo":"internetarchive/openlibrary","base_commit":"88da48a8faf5d6864c6ceea4a3e4a305550318e2","dockerhub_tag":"internetarchive.openlibrary-internetarchive__openlibrary-1894cb48d6e7fb498295a5d3ed0596f6f603b784-v0f5aece3601a5b4419f7ccec1dbda"} +{"instance_id":"instance_navidrome__navidrome-3977ef6e0f287f598b6e4009876239d6f13b686d","repo":"navidrome/navidrome","base_commit":"653b4d97f959df49ddf6ac9c76939d2fbbfc9bf1","dockerhub_tag":"navidrome.navidrome-navidrome__navidrome-3977ef6e0f287f598b6e4009876239d6f13b686d"} +{"instance_id":"instance_qutebrowser__qutebrowser-ed19d7f58b2664bb310c7cb6b52c5b9a06ea60b2-v059c6fdc75567943479b23ebca7c07b5e9a7f34c","repo":"qutebrowser/qutebrowser","base_commit":"836221ecaf2bad121c741b0c41dff508049e8ca5","dockerhub_tag":"qutebrowser.qutebrowser-qutebrowser__qutebrowser-ed19d7f58b2664bb310c7cb6b52c5b9a06ea60b2-v059c6fdc75567943479b23ebca7c07b5e9a7f"} +{"instance_id":"instance_navidrome__navidrome-29b7b740ce469201af0a0510f3024adc93ef4c8e","repo":"navidrome/navidrome","base_commit":"29bc17acd71596ae92131aca728716baf5af9906","dockerhub_tag":"navidrome.navidrome-navidrome__navidrome-29b7b740ce469201af0a0510f3024adc93ef4c8e"} +{"instance_id":"instance_protonmail__webclients-3a6790f480309130b5d6332dce6c9d5ccca13ee3","repo":"protonmail/webclients","base_commit":"e131cde781c398b38f649501cae5f03cf77e75bd","dockerhub_tag":"protonmail.webclients-protonmail__webclients-3a6790f480309130b5d6332dce6c9d5ccca13ee3"} +{"instance_id":"instance_internetarchive__openlibrary-89e4b4431fe7506c365a6f6eb6f6d048d04c044c-v08d8e8889ec945ab821fb156c04c7d2e2810debb","repo":"internetarchive/openlibrary","base_commit":"64c18604714c0672f272ee1e620ad62e9a248312","dockerhub_tag":"internetarchive.openlibrary-internetarchive__openlibrary-89e4b4431fe7506c365a6f6eb6f6d048d04c044c-v08d8e8889ec945ab821fb156c04c7"} +{"instance_id":"instance_element-hq__element-web-7c63d52500e145d6fff6de41dd717f61ab88d02f-vnan","repo":"element-hq/element-web","base_commit":"8b8d24c24c1387210ad1826552126c724c49ee42","dockerhub_tag":"element-hq.element-element-hq__element-web-7c63d52500e145d6fff6de41dd717f61ab88d02f"} +{"instance_id":"instance_internetarchive__openlibrary-7edd1ef09d91fe0b435707633c5cc9af41dedddf-v76304ecdb3a5954fcf13feb710e8c40fcf24b73c","repo":"internetarchive/openlibrary","base_commit":"1d2cbffd8cbda42d71d50a045a8d2b9ebfe1f781","dockerhub_tag":"internetarchive.openlibrary-internetarchive__openlibrary-7edd1ef09d91fe0b435707633c5cc9af41dedddf-v76304ecdb3a5954fcf13feb710e8c"} +{"instance_id":"instance_element-hq__element-web-41dfec20bfe9b62cddbbbf621bef2e9aa9685157-vnan","repo":"element-hq/element-web","base_commit":"d5d1ec775caf2d3c9132122c1243898e99fdb2da","dockerhub_tag":"element-hq.element-element-hq__element-web-41dfec20bfe9b62cddbbbf621bef2e9aa9685157"} +{"instance_id":"instance_future-architect__vuls-5af1a227339e46c7abf3f2815e4c636a0c01098e","repo":"future-architect/vuls","base_commit":"053306944695e6616f320393f865f667e984481d","dockerhub_tag":"future-architect.vuls-future-architect__vuls-5af1a227339e46c7abf3f2815e4c636a0c01098e"} +{"instance_id":"instance_gravitational__teleport-c782838c3a174fdff80cafd8cd3b1aa4dae8beb2","repo":"gravitational/teleport","base_commit":"d96ea00a00c897ce2fed9f8dca92ca17932d8d02","dockerhub_tag":"gravitational.teleport-gravitational__teleport-c782838c3a174fdff80cafd8cd3b1aa4dae8beb2"} +{"instance_id":"instance_qutebrowser__qutebrowser-fea33d607fde83cf505b228238cf365936437a63-v9f8e9d96c85c85a605e382f1510bd08563afc566","repo":"qutebrowser/qutebrowser","base_commit":"54c0c493b3e560f478c3898627c582cab11fbc2b","dockerhub_tag":"qutebrowser.qutebrowser-qutebrowser__qutebrowser-fea33d607fde83cf505b228238cf365936437a63-v9f8e9d96c85c85a605e382f1510bd08563afc"} +{"instance_id":"instance_navidrome__navidrome-5001518260732e36d9a42fb8d4c054b28afab310","repo":"navidrome/navidrome","base_commit":"265f33ed9da106cd2c926a243d564ad93c04df0e","dockerhub_tag":"navidrome.navidrome-navidrome__navidrome-5001518260732e36d9a42fb8d4c054b28afab310"} +{"instance_id":"instance_ansible__ansible-502270c804c33d3bc963930dc85e0f4ca359674d-v7eee2454f617569fd6889f2211f75bc02a35f9f8","repo":"ansible/ansible","base_commit":"2ad10ffe43baaa849acdfa3a9dedfc1824c021d3","dockerhub_tag":"ansible.ansible-ansible__ansible-502270c804c33d3bc963930dc85e0f4ca359674d-v7eee2454f617569fd6889f2211f75bc02a35f9f8"} +{"instance_id":"instance_flipt-io__flipt-f36bd61fb1cee4669de1f00e59da462bfeae8765","repo":"flipt-io/flipt","base_commit":"54e188b64f0dda5a1ab9caf8425f94dac3d08f40","dockerhub_tag":"flipt-io.flipt-flipt-io__flipt-f36bd61fb1cee4669de1f00e59da462bfeae8765"} +{"instance_id":"instance_navidrome__navidrome-3972616585e82305eaf26aa25697b3f5f3082288","repo":"navidrome/navidrome","base_commit":"d0ce0303864d6859ee683214baab9c647f7467fe","dockerhub_tag":"navidrome.navidrome-navidrome__navidrome-3972616585e82305eaf26aa25697b3f5f3082288"} +{"instance_id":"instance_qutebrowser__qutebrowser-5fdc83e5da6222fe61163395baaad7ae57fa2cb4-v363c8a7e5ccdf6968fc7ab84a2053ac78036691d","repo":"qutebrowser/qutebrowser","base_commit":"cb59619327e7fa941087d62b83459750c1b7c579","dockerhub_tag":"qutebrowser.qutebrowser-qutebrowser__qutebrowser-5fdc83e5da6222fe61163395baaad7ae57fa2cb4-v363c8a7e5ccdf6968fc7ab84a2053ac780366"} +{"instance_id":"instance_qutebrowser__qutebrowser-ff1c025ad3210506fc76e1f604d8c8c27637d88e-v363c8a7e5ccdf6968fc7ab84a2053ac78036691d","repo":"qutebrowser/qutebrowser","base_commit":"e545faaf7b18d451c082f697675f0ab0e7599ed1","dockerhub_tag":"qutebrowser.qutebrowser-qutebrowser__qutebrowser-ff1c025ad3210506fc76e1f604d8c8c27637d88e-v363c8a7e5ccdf6968fc7ab84a2053ac780366"} +{"instance_id":"instance_ansible__ansible-e22e103cdf8edc56ff7d9b848a58f94f1471a263-v1055803c3a812189a1133297f7f5468579283f86","repo":"ansible/ansible","base_commit":"a77dbf08663e002198d0fa2af502d5cde8009454","dockerhub_tag":"ansible.ansible-ansible__ansible-e22e103cdf8edc56ff7d9b848a58f94f1471a263-v1055803c3a812189a1133297f7f5468579283f86"} +{"instance_id":"instance_internetarchive__openlibrary-6afdb09df692223c3a31df65cfa92f15e5614c01-v08d8e8889ec945ab821fb156c04c7d2e2810debb","repo":"internetarchive/openlibrary","base_commit":"1a3fab3f0b319e0df49dd742ce2ffa0d747d1b44","dockerhub_tag":"internetarchive.openlibrary-internetarchive__openlibrary-6afdb09df692223c3a31df65cfa92f15e5614c01-v08d8e8889ec945ab821fb156c04c7"} +{"instance_id":"instance_NodeBB__NodeBB-087e6020e490b4a1759f38c1ad03869511928263-vf2cf3cbd463b7ad942381f1c6d077626485a1e9e","repo":"NodeBB/NodeBB","base_commit":"50517020a28f11a8748e4de66a646e82bb3050e7","dockerhub_tag":"nodebb.nodebb-NodeBB__NodeBB-087e6020e490b4a1759f38c1ad03869511928263-vf2cf3cbd463b7ad942381f1c6d077626485a1e9e"} +{"instance_id":"instance_gravitational__teleport-0ecf31de0e98b272a6a2610abe1bbedd379a38a3-vce94f93ad1030e3136852817f2423c1b3ac37bc4","repo":"gravitational/teleport","base_commit":"b1da3b3054e2394b81f8c14a274e64fb43136602","dockerhub_tag":"gravitational.teleport-gravitational__teleport-0ecf31de0e98b272a6a2610abe1bbedd379a38a3-vce94f93ad1030e3136852817f2423c1b3ac37bc"} +{"instance_id":"instance_ansible__ansible-d2f80991180337e2be23d6883064a67dcbaeb662-vba6da65a0f3baefda7a058ebbd0a8dcafb8512f5","repo":"ansible/ansible","base_commit":"f9a450551de47ac2b9d1d7e66a103cbf8f05c37f","dockerhub_tag":"ansible.ansible-ansible__ansible-d2f80991180337e2be23d6883064a67dcbaeb662-vba6da65a0f3baefda7a058ebbd0a8dcafb8512f5"} +{"instance_id":"instance_tutao__tutanota-4b4e45949096bb288f2b522f657610e480efa3e8-vee878bb72091875e912c52fc32bc60ec3760227b","repo":"tutao/tutanota","base_commit":"636501198b8b94196281e45c796180e602cdfc66","dockerhub_tag":"tutao.tutanota-tutao__tutanota-4b4e45949096bb288f2b522f657610e480efa3e8-vee878bb72091875e912c52fc32bc60ec3760227b"} +{"instance_id":"instance_gravitational__teleport-78b0d8c72637df1129fb6ff84fc49ef4b5ab1288","repo":"gravitational/teleport","base_commit":"19c5768873a50f1f84f0906add418c29c68f4bc2","dockerhub_tag":"gravitational.teleport-gravitational__teleport-78b0d8c72637df1129fb6ff84fc49ef4b5ab1288"} +{"instance_id":"instance_element-hq__element-web-ce554276db97b9969073369fefa4950ca8e54f84-vnan","repo":"element-hq/element-web","base_commit":"16e92a4d8cb66c10c46eb9d94d9e2b82d612108a","dockerhub_tag":"element-hq.element-element-hq__element-web-ce554276db97b9969073369fefa4950ca8e54f84"} +{"instance_id":"instance_internetarchive__openlibrary-0d13e6b4bf80bced6c0946b969b9a1b6963f6bce-v76304ecdb3a5954fcf13feb710e8c40fcf24b73c","repo":"internetarchive/openlibrary","base_commit":"fe6c160d3f2afd9fd70bea62195337fad15c6535","dockerhub_tag":"internetarchive.openlibrary-internetarchive__openlibrary-0d13e6b4bf80bced6c0946b969b9a1b6963f6bce-v76304ecdb3a5954fcf13feb710e8c"} +{"instance_id":"instance_internetarchive__openlibrary-b112069e31e0553b2d374abb5f9c5e05e8f3dbbe-ve8c8d62a2b60610a3c4631f5f23ed866bada9818","repo":"internetarchive/openlibrary","base_commit":"4825ff66e84545216c35d7a0bb01c177f5591b96","dockerhub_tag":"internetarchive.openlibrary-internetarchive__openlibrary-b112069e31e0553b2d374abb5f9c5e05e8f3dbbe-ve8c8d62a2b60610a3c4631f5f23ed"} +{"instance_id":"instance_flipt-io__flipt-b433bd05ce405837804693bebd5f4b88d87133c8","repo":"flipt-io/flipt","base_commit":"4e066b8b836ceac716b6f63db41a341fb4df1375","dockerhub_tag":"flipt-io.flipt-flipt-io__flipt-b433bd05ce405837804693bebd5f4b88d87133c8"} +{"instance_id":"instance_qutebrowser__qutebrowser-21b426b6a20ec1cc5ecad770730641750699757b-v363c8a7e5ccdf6968fc7ab84a2053ac78036691d","repo":"qutebrowser/qutebrowser","base_commit":"1d9d945349cdffd3094ebe7159894f1128bf4e1c","dockerhub_tag":"qutebrowser.qutebrowser-qutebrowser__qutebrowser-21b426b6a20ec1cc5ecad770730641750699757b-v363c8a7e5ccdf6968fc7ab84a2053ac780366"} +{"instance_id":"instance_element-hq__element-web-582a1b093fc0b77538052f45cbb9c7295f991b51-vnan","repo":"element-hq/element-web","base_commit":"ec6bb880682286216458d73560aa91746d4f099b","dockerhub_tag":"element-hq.element-element-hq__element-web-582a1b093fc0b77538052f45cbb9c7295f991b51"} +{"instance_id":"instance_navidrome__navidrome-0488fb92cb02a82924fb1181bf1642f2e87096db","repo":"navidrome/navidrome","base_commit":"61903facdf5d56277bf57c7aa83bce7fb35b597a","dockerhub_tag":"navidrome.navidrome-navidrome__navidrome-0488fb92cb02a82924fb1181bf1642f2e87096db"} +{"instance_id":"instance_NodeBB__NodeBB-445b70deda20201b7d9a68f7224da751b3db728c-v4fbcfae8b15e4ce5d132c408bca69ebb9cf146ed","repo":"NodeBB/NodeBB","base_commit":"565ca3cc3b78d6e5177b7834d496927b96b6c88c","dockerhub_tag":"nodebb.nodebb-NodeBB__NodeBB-445b70deda20201b7d9a68f7224da751b3db728c-v4fbcfae8b15e4ce5d132c408bca69ebb9cf146ed"} +{"instance_id":"instance_NodeBB__NodeBB-f9ce92df988db7c1ae55d9ef96d247d27478bc70-vf2cf3cbd463b7ad942381f1c6d077626485a1e9e","repo":"NodeBB/NodeBB","base_commit":"61d17c95e573f91ab5c65d25218451e9afd07d77","dockerhub_tag":"nodebb.nodebb-NodeBB__NodeBB-f9ce92df988db7c1ae55d9ef96d247d27478bc70-vf2cf3cbd463b7ad942381f1c6d077626485a1e9e"} +{"instance_id":"instance_future-architect__vuls-2923cbc645fbc7a37d50398eb2ab8febda8c3264","repo":"future-architect/vuls","base_commit":"7c209cc9dc71e30bf762677d6a380ddc93d551ec","dockerhub_tag":"future-architect.vuls-future-architect__vuls-2923cbc645fbc7a37d50398eb2ab8febda8c3264"} +{"instance_id":"instance_element-hq__element-web-ecfd1736e5dd9808e87911fc264e6c816653e1a9-vnan","repo":"element-hq/element-web","base_commit":"f34c1609c3c42f095b59bc068620f342894f94ed","dockerhub_tag":"element-hq.element-element-hq__element-web-ecfd1736e5dd9808e87911fc264e6c816653e1a9"} +{"instance_id":"instance_future-architect__vuls-f6509a537660ea2bce0e57958db762edd3a36702","repo":"future-architect/vuls","base_commit":"80b48fcbaab5ad307beb69e73b30aabc1b6f033c","dockerhub_tag":"future-architect.vuls-future-architect__vuls-f6509a537660ea2bce0e57958db762edd3a36702"} +{"instance_id":"instance_internetarchive__openlibrary-c506c1b0b678892af5cb22c1c1dbc35d96787a0a-v0f5aece3601a5b4419f7ccec1dbda2071be28ee4","repo":"internetarchive/openlibrary","base_commit":"2f590171b1d95cc124c44fb6ec647c85f1ca9581","dockerhub_tag":"internetarchive.openlibrary-internetarchive__openlibrary-c506c1b0b678892af5cb22c1c1dbc35d96787a0a-v0f5aece3601a5b4419f7ccec1dbda"} +{"instance_id":"instance_future-architect__vuls-030b2e03525d68d74cb749959aac2d7f3fc0effa","repo":"future-architect/vuls","base_commit":"2c51bcf4764b7e0fd151a1ceb5cde0640a971fb1","dockerhub_tag":"future-architect.vuls-future-architect__vuls-030b2e03525d68d74cb749959aac2d7f3fc0effa"} +{"instance_id":"instance_qutebrowser__qutebrowser-cc360cd4a34a126274c7b51f3b63afbaf3e05a02-v5fc38aaf22415ab0b70567368332beee7955b367","repo":"qutebrowser/qutebrowser","base_commit":"96b997802e942937e81d2b8a32d08f00d3f4bc4e","dockerhub_tag":"qutebrowser.qutebrowser-qutebrowser__qutebrowser-cc360cd4a34a126274c7b51f3b63afbaf3e05a02-v5fc38aaf22415ab0b70567368332beee7955b"} +{"instance_id":"instance_protonmail__webclients-d8ff92b414775565f496b830c9eb6cc5fa9620e6","repo":"protonmail/webclients","base_commit":"7fb29b60c6b33fab16fd5464786f74427c9eb16e","dockerhub_tag":"protonmail.webclients-protonmail__webclients-d8ff92b414775565f496b830c9eb6cc5fa9620e6"} +{"instance_id":"instance_tutao__tutanota-1ff82aa365763cee2d609c9d19360ad87fdf2ec7-vc4e41fd0029957297843cb9dec4a25c7c756f029","repo":"tutao/tutanota","base_commit":"2e5d877afe8a1b8fc9ad3ac0a0d579bbad364224","dockerhub_tag":"tutao.tutanota-tutao__tutanota-1ff82aa365763cee2d609c9d19360ad87fdf2ec7-vc4e41fd0029957297843cb9dec4a25c7c756f029"} +{"instance_id":"instance_flipt-io__flipt-56a620b8fc9ef7a0819b47709aa541cdfdbba00b","repo":"flipt-io/flipt","base_commit":"32864671f44b7bbd9edc8e2bc1d6255906c31f5b","dockerhub_tag":"flipt-io.flipt-flipt-io__flipt-56a620b8fc9ef7a0819b47709aa541cdfdbba00b"} +{"instance_id":"instance_ansible__ansible-c616e54a6e23fa5616a1d56d243f69576164ef9b-v1055803c3a812189a1133297f7f5468579283f86","repo":"ansible/ansible","base_commit":"b479adddce8fe46a2df5469f130cf7b6ad70fdc4","dockerhub_tag":"ansible.ansible-ansible__ansible-c616e54a6e23fa5616a1d56d243f69576164ef9b-v1055803c3a812189a1133297f7f5468579283f86"} +{"instance_id":"instance_protonmail__webclients-c5a2089ca2bfe9aa1d85a664b8ad87ef843a1c9c","repo":"protonmail/webclients","base_commit":"83c2b47478a5224db61c6557ad326c2bbda18645","dockerhub_tag":"protonmail.webclients-protonmail__webclients-c5a2089ca2bfe9aa1d85a664b8ad87ef843a1c9c"} +{"instance_id":"instance_element-hq__element-web-f63160f38459fb552d00fcc60d4064977a9095a6-vnan","repo":"element-hq/element-web","base_commit":"5a4355059d15053b89eae9d82a2506146c7832c0","dockerhub_tag":"element-hq.element-element-hq__element-web-f63160f38459fb552d00fcc60d4064977a9095a6"} +{"instance_id":"instance_qutebrowser__qutebrowser-44e64199ed38003253f0296badd4a447645067b6-v2ef375ac784985212b1805e1d0431dc8f1b3c171","repo":"qutebrowser/qutebrowser","base_commit":"22a3fd479accc3b9a0c0e2e5c2f1841324c3ab3d","dockerhub_tag":"qutebrowser.qutebrowser-qutebrowser__qutebrowser-44e64199ed38003253f0296badd4a447645067b6-v2ef375ac784985212b1805e1d0431dc8f1b3c"} +{"instance_id":"instance_flipt-io__flipt-36e62baffae2132f78f9d34dc300a9baa2d7ae0e","repo":"flipt-io/flipt","base_commit":"22ce5e88968025e0ae44ce4c1de90fb10f6e38fa","dockerhub_tag":"flipt-io.flipt-flipt-io__flipt-36e62baffae2132f78f9d34dc300a9baa2d7ae0e"} +{"instance_id":"instance_protonmail__webclients-944adbfe06644be0789f59b78395bdd8567d8547","repo":"protonmail/webclients","base_commit":"7c7e668956cf9df0f51d401dbb00b7e1d445198b","dockerhub_tag":"protonmail.webclients-protonmail__webclients-944adbfe06644be0789f59b78395bdd8567d8547"} +{"instance_id":"instance_qutebrowser__qutebrowser-f7753550f2c1dcb2348e4779fd5287166754827e-v059c6fdc75567943479b23ebca7c07b5e9a7f34c","repo":"qutebrowser/qutebrowser","base_commit":"a7e6a3a178a8e06909d26990295a014802371f50","dockerhub_tag":"qutebrowser.qutebrowser-qutebrowser__qutebrowser-f7753550f2c1dcb2348e4779fd5287166754827e-v059c6fdc75567943479b23ebca7c07b5e9a7f"} +{"instance_id":"instance_future-architect__vuls-4a72295de7b91faa59d90a5bee91535bbe76755d","repo":"future-architect/vuls","base_commit":"9ed5f2cac5be482995b68adaac4620ffb52e95a8","dockerhub_tag":"future-architect.vuls-future-architect__vuls-4a72295de7b91faa59d90a5bee91535bbe76755d"} +{"instance_id":"instance_navidrome__navidrome-1e96b858a91c640fe64e84c5e5ad8cc0954ea38d","repo":"navidrome/navidrome","base_commit":"aafd5a952c2cf19868b681c52400b395c33273a0","dockerhub_tag":"navidrome.navidrome-navidrome__navidrome-1e96b858a91c640fe64e84c5e5ad8cc0954ea38d"} +{"instance_id":"instance_gravitational__teleport-5dca072bb4301f4579a15364fcf37cc0c39f7f6c","repo":"gravitational/teleport","base_commit":"d45e26cec6dc799afbb9eac4381d70f95c21c41f","dockerhub_tag":"gravitational.teleport-gravitational__teleport-5dca072bb4301f4579a15364fcf37cc0c39f7f6c"} +{"instance_id":"instance_element-hq__element-web-772df3021201d9c73835a626df8dcb6334ad9a3e-vnan","repo":"element-hq/element-web","base_commit":"7a33818bd7ec89c21054691afcb6db2fb2631e14","dockerhub_tag":"element-hq.element-element-hq__element-web-772df3021201d9c73835a626df8dcb6334ad9a3e"} +{"instance_id":"instance_navidrome__navidrome-29bc17acd71596ae92131aca728716baf5af9906","repo":"navidrome/navidrome","base_commit":"4044642abf5a7147c3ed3076c045e0e3b2520171","dockerhub_tag":"navidrome.navidrome-navidrome__navidrome-29bc17acd71596ae92131aca728716baf5af9906"} +{"instance_id":"instance_flipt-io__flipt-abaa5953795afb9c621605bb18cb32ac48b4508c","repo":"flipt-io/flipt","base_commit":"fddcf20f9e79532db9feade40395883565f6eb57","dockerhub_tag":"flipt-io.flipt-flipt-io__flipt-abaa5953795afb9c621605bb18cb32ac48b4508c"} +{"instance_id":"instance_NodeBB__NodeBB-22368b996ee0e5f11a5189b400b33af3cc8d925a-v4fbcfae8b15e4ce5d132c408bca69ebb9cf146ed","repo":"NodeBB/NodeBB","base_commit":"88aee439477603da95beb8a1cc23d43b9d6d482c","dockerhub_tag":"nodebb.nodebb-NodeBB__NodeBB-22368b996ee0e5f11a5189b400b33af3cc8d925a-v4fbcfae8b15e4ce5d132c408bca69ebb9cf146ed"} +{"instance_id":"instance_qutebrowser__qutebrowser-ec2dcfce9eee9f808efc17a1b99e227fc4421dea-v5149fcda2a9a6fe1d35dfed1bade1444a11ef271","repo":"qutebrowser/qutebrowser","base_commit":"b9920503db6482f0d3af7e95b3cf3c71fbbd7d4f","dockerhub_tag":"qutebrowser.qutebrowser-qutebrowser__qutebrowser-ec2dcfce9eee9f808efc17a1b99e227fc4421dea-v5149fcda2a9a6fe1d35dfed1bade1444a11ef"} +{"instance_id":"instance_flipt-io__flipt-65581fef4aa807540cb933753d085feb0d7e736f","repo":"flipt-io/flipt","base_commit":"e53fb0f25ef6747aa10fc3e6f457b620137bcd4f","dockerhub_tag":"flipt-io.flipt-flipt-io__flipt-65581fef4aa807540cb933753d085feb0d7e736f"} +{"instance_id":"instance_future-architect__vuls-6682232b5c8a9d08c0e9f15bd90d41bff3875adc","repo":"future-architect/vuls","base_commit":"984debe929fad8e248489e2a1d691b0635e6b120","dockerhub_tag":"future-architect.vuls-future-architect__vuls-6682232b5c8a9d08c0e9f15bd90d41bff3875adc"} +{"instance_id":"instance_internetarchive__openlibrary-3f580a5f244c299d936d73d9e327ba873b6401d9-v0f5aece3601a5b4419f7ccec1dbda2071be28ee4","repo":"internetarchive/openlibrary","base_commit":"46d7d325e6ed4b4de998d69c0e89893274ad5d60","dockerhub_tag":"internetarchive.openlibrary-internetarchive__openlibrary-3f580a5f244c299d936d73d9e327ba873b6401d9-v0f5aece3601a5b4419f7ccec1dbda"} +{"instance_id":"instance_qutebrowser__qutebrowser-e64622cd2df5b521342cf4a62e0d4cb8f8c9ae5a-v363c8a7e5ccdf6968fc7ab84a2053ac78036691d","repo":"qutebrowser/qutebrowser","base_commit":"09925f74817cf7a970f166342f81886a1d27ee35","dockerhub_tag":"qutebrowser.qutebrowser-qutebrowser__qutebrowser-e64622cd2df5b521342cf4a62e0d4cb8f8c9ae5a-v363c8a7e5ccdf6968fc7ab84a2053ac780366"} +{"instance_id":"instance_ansible__ansible-e64c6c1ca50d7d26a8e7747d8eb87642e767cd74-v0f01c69f1e2528b935359cfe578530722bca2c59","repo":"ansible/ansible","base_commit":"a0aad17912da687a3b0b5a573ab6ed0394b569ad","dockerhub_tag":"ansible.ansible-ansible__ansible-e64c6c1ca50d7d26a8e7747d8eb87642e767cd74-v0f01c69f1e2528b935359cfe578530722bca2c59"} +{"instance_id":"instance_element-hq__element-web-494d9de6f0a94ffb491e74744d2735bce02dc0ab-vnan","repo":"element-hq/element-web","base_commit":"28f7aac9a5970d27ff3757875b464a5a58a1eb1a","dockerhub_tag":"element-hq.element-element-hq__element-web-494d9de6f0a94ffb491e74744d2735bce02dc0ab"} +{"instance_id":"instance_qutebrowser__qutebrowser-f631cd4422744160d9dcf7a0455da532ce973315-v35616345bb8052ea303186706cec663146f0f184","repo":"qutebrowser/qutebrowser","base_commit":"5ee28105ad972dd635fcdc0ea56e5f82de478fb1","dockerhub_tag":"qutebrowser.qutebrowser-qutebrowser__qutebrowser-f631cd4422744160d9dcf7a0455da532ce973315-v35616345bb8052ea303186706cec663146f0f"} +{"instance_id":"instance_flipt-io__flipt-ee02b164f6728d3227c42671028c67a4afd36918","repo":"flipt-io/flipt","base_commit":"e38e41543f08b762904ed8a08969d0b6aba67166","dockerhub_tag":"flipt-io.flipt-flipt-io__flipt-ee02b164f6728d3227c42671028c67a4afd36918"} +{"instance_id":"instance_gravitational__teleport-ba6c4a135412c4296dd5551bd94042f0dc024504-v626ec2a48416b10a88641359a169d99e935ff037","repo":"gravitational/teleport","base_commit":"396812cebff3ebfd075bbed04acefc65e787a537","dockerhub_tag":"gravitational.teleport-gravitational__teleport-ba6c4a135412c4296dd5551bd94042f0dc024504-v626ec2a48416b10a88641359a169d99e935ff03"} +{"instance_id":"instance_navidrome__navidrome-89b12b34bea5687c70e4de2109fd1e7330bb2ba2","repo":"navidrome/navidrome","base_commit":"4e0177ee5340b888126092d1146c1c7b6a92fed8","dockerhub_tag":"navidrome.navidrome-navidrome__navidrome-89b12b34bea5687c70e4de2109fd1e7330bb2ba2"} +{"instance_id":"instance_element-hq__element-web-33299af5c9b7a7ec5a9c31d578d4ec5b18088fb7-vnan","repo":"element-hq/element-web","base_commit":"8166306e0f8951a9554bf1437f7ef6eef54a3267","dockerhub_tag":"element-hq.element-element-hq__element-web-33299af5c9b7a7ec5a9c31d578d4ec5b18088fb7"} +{"instance_id":"instance_navidrome__navidrome-66b74c81f115c78cb69910b0472eeb376750efc4","repo":"navidrome/navidrome","base_commit":"d42dfafad4c556a5c84147c8c3789575ae77c5ae","dockerhub_tag":"navidrome.navidrome-navidrome__navidrome-66b74c81f115c78cb69910b0472eeb376750efc4"} +{"instance_id":"instance_ansible__ansible-b5e0293645570f3f404ad1dbbe5f006956ada0df-v0f01c69f1e2528b935359cfe578530722bca2c59","repo":"ansible/ansible","base_commit":"9b0d2decb24b5ef08ba3e27e4ab18dcf10afbbc4","dockerhub_tag":"ansible.ansible-ansible__ansible-b5e0293645570f3f404ad1dbbe5f006956ada0df-v0f01c69f1e2528b935359cfe578530722bca2c59"} +{"instance_id":"instance_ansible__ansible-a7d2a4e03209cff1e97e59fd54bb2b05fdbdbec6-v0f01c69f1e2528b935359cfe578530722bca2c59","repo":"ansible/ansible","base_commit":"38067860e271ce2f68d6d5d743d70286e5209623","dockerhub_tag":"ansible.ansible-ansible__ansible-a7d2a4e03209cff1e97e59fd54bb2b05fdbdbec6-v0f01c69f1e2528b935359cfe578530722bca2c59"} +{"instance_id":"instance_ansible__ansible-77658704217d5f166404fc67997203c25381cb6e-v390e508d27db7a51eece36bb6d9698b63a5b638a","repo":"ansible/ansible","base_commit":"db2d5b09eff918e981c9e10787a5f2c500d1784f","dockerhub_tag":"ansible.ansible-ansible__ansible-77658704217d5f166404fc67997203c25381cb6e-v390e508d27db7a51eece36bb6d9698b63a5b638a"} +{"instance_id":"instance_internetarchive__openlibrary-c8996ecc40803b9155935fd7ff3b8e7be6c1437c-ve8fc82d8aae8463b752a211156c5b7b59f349237","repo":"internetarchive/openlibrary","base_commit":"f0341c0ba81c790241b782f5103ce5c9a6edf8e3","dockerhub_tag":"internetarchive.openlibrary-internetarchive__openlibrary-c8996ecc40803b9155935fd7ff3b8e7be6c1437c-ve8fc82d8aae8463b752a211156c5b"} +{"instance_id":"instance_internetarchive__openlibrary-5de7de19211e71b29b2f2ba3b1dff2fe065d660f-v08d8e8889ec945ab821fb156c04c7d2e2810debb","repo":"internetarchive/openlibrary","base_commit":"5f7d8d190e2f0d837545e582fd5db99aae51a979","dockerhub_tag":"internetarchive.openlibrary-internetarchive__openlibrary-5de7de19211e71b29b2f2ba3b1dff2fe065d660f-v08d8e8889ec945ab821fb156c04c7"} +{"instance_id":"instance_internetarchive__openlibrary-0a90f9f0256e4f933523e9842799e39f95ae29ce-v76304ecdb3a5954fcf13feb710e8c40fcf24b73c","repo":"internetarchive/openlibrary","base_commit":"5c6c22f3d2edf2f1b10f5dc335e32cb6a5f40341","dockerhub_tag":"internetarchive.openlibrary-internetarchive__openlibrary-0a90f9f0256e4f933523e9842799e39f95ae29ce-v76304ecdb3a5954fcf13feb710e8c"} +{"instance_id":"instance_element-hq__element-web-9bf77963ee5e036d54b2a3ca202fbf6378464a5e-vnan","repo":"element-hq/element-web","base_commit":"ba171f1fe5814a1b9ee88f792afaf05ce5aa507b","dockerhub_tag":"element-hq.element-element-hq__element-web-9bf77963ee5e036d54b2a3ca202fbf6378464a5e"} +{"instance_id":"instance_protonmail__webclients-0ec14e36ceb01ba45602a563e12352af8171ed39","repo":"protonmail/webclients","base_commit":"bf575a521f3789c0b7e99969ad22a15c78165991","dockerhub_tag":"protonmail.webclients-protonmail__webclients-0ec14e36ceb01ba45602a563e12352af8171ed39"} +{"instance_id":"instance_element-hq__element-web-5dfde12c1c1c0b6e48f17e3405468593e39d9492-vnan","repo":"element-hq/element-web","base_commit":"f97cef80aed8ee6011543f08bee8b1745a33a7db","dockerhub_tag":"element-hq.element-element-hq__element-web-5dfde12c1c1c0b6e48f17e3405468593e39d9492"} +{"instance_id":"instance_future-architect__vuls-e52fa8d6ed1d23e36f2a86e5d3efe9aa057a1b0d","repo":"future-architect/vuls","base_commit":"854821eb5489ac7448551f213f49bcf8159a110a","dockerhub_tag":"future-architect.vuls-future-architect__vuls-e52fa8d6ed1d23e36f2a86e5d3efe9aa057a1b0d"} +{"instance_id":"instance_ansible__ansible-f86c58e2d235d8b96029d102c71ee2dfafd57997-v0f01c69f1e2528b935359cfe578530722bca2c59","repo":"ansible/ansible","base_commit":"3398c102b5c41d48d0cbc2d81f9c004f07ac3fcb","dockerhub_tag":"ansible.ansible-ansible__ansible-f86c58e2d235d8b96029d102c71ee2dfafd57997-v0f01c69f1e2528b935359cfe578530722bca2c59"} +{"instance_id":"instance_internetarchive__openlibrary-0dc5b20fa186f9714f8a838178597e69f549d026-v2d9a6c849c60ed19fd0858ce9e40b7cc8e097e59","repo":"internetarchive/openlibrary","base_commit":"bd9d2a04efbbaec1575faa02a02eea995badf7f0","dockerhub_tag":"internetarchive.openlibrary-internetarchive__openlibrary-0dc5b20fa186f9714f8a838178597e69f549d026-v2d9a6c849c60ed19fd0858ce9e40b"} +{"instance_id":"instance_internetarchive__openlibrary-f343c08f89c772f7ba6c0246f384b9e6c3dc0add-v08d8e8889ec945ab821fb156c04c7d2e2810debb","repo":"internetarchive/openlibrary","base_commit":"53d376b148897466bb86d5accb51912bbbe9a8ed","dockerhub_tag":"internetarchive.openlibrary-internetarchive__openlibrary-f343c08f89c772f7ba6c0246f384b9e6c3dc0add-v08d8e8889ec945ab821fb156c04c7"} +{"instance_id":"instance_qutebrowser__qutebrowser-e70f5b03187bdd40e8bf70f5f3ead840f52d1f42-v02ad04386d5238fe2d1a1be450df257370de4b6a","repo":"qutebrowser/qutebrowser","base_commit":"d7d1293569cd71200758068cabc54e1e2596d606","dockerhub_tag":"qutebrowser.qutebrowser-qutebrowser__qutebrowser-e70f5b03187bdd40e8bf70f5f3ead840f52d1f42-v02ad04386d5238fe2d1a1be450df257370de4"} +{"instance_id":"instance_ansible__ansible-d62496fe416623e88b90139dc7917080cb04ce70-v0f01c69f1e2528b935359cfe578530722bca2c59","repo":"ansible/ansible","base_commit":"df29852f3a48160e1a60635692c202531dd8b14a","dockerhub_tag":"ansible.ansible-ansible__ansible-d62496fe416623e88b90139dc7917080cb04ce70-v0f01c69f1e2528b935359cfe578530722bca2c59"} +{"instance_id":"instance_element-hq__element-web-8f3c8b35153d2227af45f32e46bd1e15bd60b71f-vnan","repo":"element-hq/element-web","base_commit":"2d0319ec1b0298fdb0e02afc3109c40cd0cebe65","dockerhub_tag":"element-hq.element-element-hq__element-web-8f3c8b35153d2227af45f32e46bd1e15bd60b71f"} +{"instance_id":"instance_navidrome__navidrome-9c3b4561652a15846993d477003e111f0df0c585","repo":"navidrome/navidrome","base_commit":"23bebe4e06124becf1000e88472ae71a6ca7de4c","dockerhub_tag":"navidrome.navidrome-navidrome__navidrome-9c3b4561652a15846993d477003e111f0df0c585"} +{"instance_id":"instance_ansible__ansible-106909db8b730480615f4a33de0eb5b710944e78-v0f01c69f1e2528b935359cfe578530722bca2c59","repo":"ansible/ansible","base_commit":"3fffddc18305f4d910774b57bc90e14456e7a15b","dockerhub_tag":"ansible.ansible-ansible__ansible-106909db8b730480615f4a33de0eb5b710944e78-v0f01c69f1e2528b935359cfe578530722bca2c59"} +{"instance_id":"instance_future-architect__vuls-ef2be3d6ea4c0a13674aaab08b182eca4e2b9a17-v264a82e2f4818e30f5a25e4da53b27ba119f62b5","repo":"future-architect/vuls","base_commit":"827f2cb8d86509c4455b2df2fe79b9d59533d3b0","dockerhub_tag":"future-architect.vuls-future-architect__vuls-ef2be3d6ea4c0a13674aaab08b182eca4e2b9a17-v264a82e2f4818e30f5a25e4da53b27ba119f62b5"} +{"instance_id":"instance_qutebrowser__qutebrowser-e15d26630934d0b6415ed2295ac42fd570a57620-va0fd88aac89cde702ec1ba84877234da33adce8a","repo":"qutebrowser/qutebrowser","base_commit":"e158a480f52185c77ee07a52bc022f021d9789fe","dockerhub_tag":"qutebrowser.qutebrowser-qutebrowser__qutebrowser-e15d26630934d0b6415ed2295ac42fd570a57620-va0fd88aac89cde702ec1ba84877234da33adc"} +{"instance_id":"instance_element-hq__element-web-b007ea81b2ccd001b00f332bee65070aa7fc00f9-vnan","repo":"element-hq/element-web","base_commit":"c2ae6c279b8c80ea5bd58f3354e5949a9fa5ee41","dockerhub_tag":"element-hq.element-element-hq__element-web-b007ea81b2ccd001b00f332bee65070aa7fc00f9"} +{"instance_id":"instance_gravitational__teleport-b8fbb2d1e90ffcde88ed5fe9920015c1be075788-vee9b09fb20c43af7e520f57e9239bbcf46b7113d","repo":"gravitational/teleport","base_commit":"9c25440e8d6de54447215934d4c4fae81067eb97","dockerhub_tag":"gravitational.teleport-gravitational__teleport-b8fbb2d1e90ffcde88ed5fe9920015c1be075788-vee9b09fb20c43af7e520f57e9239bbcf46b7113"} +{"instance_id":"instance_NodeBB__NodeBB-7b8bffd763e2155cf88f3ebc258fa68ebe18188d-vf2cf3cbd463b7ad942381f1c6d077626485a1e9e","repo":"NodeBB/NodeBB","base_commit":"e0149462b3f4e7c843d89701ad9edd2e744d7593","dockerhub_tag":"nodebb.nodebb-NodeBB__NodeBB-7b8bffd763e2155cf88f3ebc258fa68ebe18188d-vf2cf3cbd463b7ad942381f1c6d077626485a1e9e"} +{"instance_id":"instance_ansible__ansible-bec27fb4c0a40c5f8bbcf26a475704227d65ee73-v30a923fb5c164d6cd18280c02422f75e611e8fb2","repo":"ansible/ansible","base_commit":"6d34eb88d95c02013d781a29dfffaaf2901cd81f","dockerhub_tag":"ansible.ansible-ansible__ansible-bec27fb4c0a40c5f8bbcf26a475704227d65ee73-v30a923fb5c164d6cd18280c02422f75e611e8fb2"} +{"instance_id":"instance_qutebrowser__qutebrowser-16de05407111ddd82fa12e54389d532362489da9-v363c8a7e5ccdf6968fc7ab84a2053ac78036691d","repo":"qutebrowser/qutebrowser","base_commit":"744cd94469de77f52905bebb123597c040ac07b6","dockerhub_tag":"qutebrowser.qutebrowser-qutebrowser__qutebrowser-16de05407111ddd82fa12e54389d532362489da9-v363c8a7e5ccdf6968fc7ab84a2053ac780366"} +{"instance_id":"instance_flipt-io__flipt-b68b8960b8a08540d5198d78c665a7eb0bea4008","repo":"flipt-io/flipt","base_commit":"324b9ed54747624c488d7123c38e9420c3750368","dockerhub_tag":"flipt-io.flipt-flipt-io__flipt-b68b8960b8a08540d5198d78c665a7eb0bea4008"} +{"instance_id":"instance_ansible__ansible-e9e6001263f51103e96e58ad382660df0f3d0e39-v30a923fb5c164d6cd18280c02422f75e611e8fb2","repo":"ansible/ansible","base_commit":"bddb9a7490b5e9475d0d01a8d906332e81789cde","dockerhub_tag":"ansible.ansible-ansible__ansible-e9e6001263f51103e96e58ad382660df0f3d0e39-v30a923fb5c164d6cd18280c02422f75e611e8fb2"} +{"instance_id":"instance_ansible__ansible-489156378c8e97374a75a544c7c9c2c0dd8146d1-v390e508d27db7a51eece36bb6d9698b63a5b638a","repo":"ansible/ansible","base_commit":"5ee81338fcf7adbc1a8eda26dd8105a07825cb08","dockerhub_tag":"ansible.ansible-ansible__ansible-489156378c8e97374a75a544c7c9c2c0dd8146d1-v390e508d27db7a51eece36bb6d9698b63a5b638a"} +{"instance_id":"instance_flipt-io__flipt-b2170346dc37cf42fda1386cd630f24821ad2ac5","repo":"flipt-io/flipt","base_commit":"5d544c9172ccf6c445c16ed333409930d2a1f0ad","dockerhub_tag":"flipt-io.flipt-flipt-io__flipt-b2170346dc37cf42fda1386cd630f24821ad2ac5"} +{"instance_id":"instance_protonmail__webclients-a6e6f617026794e7b505d649d2a7a9cdf17658c8","repo":"protonmail/webclients","base_commit":"808897a3f701f58c9b93efb5bc79112e79fd20f9","dockerhub_tag":"protonmail.webclients-protonmail__webclients-a6e6f617026794e7b505d649d2a7a9cdf17658c8"} +{"instance_id":"instance_internetarchive__openlibrary-7bf3238533070f2d24bafbb26eedf675d51941f6-v08d8e8889ec945ab821fb156c04c7d2e2810debb","repo":"internetarchive/openlibrary","base_commit":"0c5d154db9a199adc4be35be84390368693b2144","dockerhub_tag":"internetarchive.openlibrary-internetarchive__openlibrary-7bf3238533070f2d24bafbb26eedf675d51941f6-v08d8e8889ec945ab821fb156c04c7"} +{"instance_id":"instance_internetarchive__openlibrary-fdbc0d8f418333c7e575c40b661b582c301ef7ac-v13642507b4fc1f8d234172bf8129942da2c2ca26","repo":"internetarchive/openlibrary","base_commit":"69cb6f271d8eb461baf163260f8e43e7420793e7","dockerhub_tag":"internetarchive.openlibrary-internetarchive__openlibrary-fdbc0d8f418333c7e575c40b661b582c301ef7ac-v13642507b4fc1f8d234172bf81299"} +{"instance_id":"instance_ansible__ansible-cb94c0cc550df9e98f1247bc71d8c2b861c75049-v1055803c3a812189a1133297f7f5468579283f86","repo":"ansible/ansible","base_commit":"96c19724394a32b9d3c596966be2f46e478681f8","dockerhub_tag":"ansible.ansible-ansible__ansible-cb94c0cc550df9e98f1247bc71d8c2b861c75049-v1055803c3a812189a1133297f7f5468579283f86"} +{"instance_id":"instance_ansible__ansible-379058e10f3dbc0fdcaf80394bd09b18927e7d33-v1055803c3a812189a1133297f7f5468579283f86","repo":"ansible/ansible","base_commit":"e658995760ac1209cb12df97027a2e282b4536ae","dockerhub_tag":"ansible.ansible-ansible__ansible-379058e10f3dbc0fdcaf80394bd09b18927e7d33-v1055803c3a812189a1133297f7f5468579283f86"} +{"instance_id":"instance_qutebrowser__qutebrowser-0b621cb0ce2b54d3f93d8d41d8ff4257888a87e5-v2ef375ac784985212b1805e1d0431dc8f1b3c171","repo":"qutebrowser/qutebrowser","base_commit":"df2b817aa418ea7a83c5cbe523aab58ef26a2b20","dockerhub_tag":"qutebrowser.qutebrowser-qutebrowser__qutebrowser-0b621cb0ce2b54d3f93d8d41d8ff4257888a87e5-v2ef375ac784985212b1805e1d0431dc8f1b3c"} +{"instance_id":"instance_future-architect__vuls-cc63a0eccfdd318e67c0a6edeffc7bf09b6025c0","repo":"future-architect/vuls","base_commit":"fd18df1dd4e4360f8932bc4b894bd8b40d654e7c","dockerhub_tag":"future-architect.vuls-future-architect__vuls-cc63a0eccfdd318e67c0a6edeffc7bf09b6025c0"} +{"instance_id":"instance_internetarchive__openlibrary-b67138b316b1e9c11df8a4a8391fe5cc8e75ff9f-ve8c8d62a2b60610a3c4631f5f23ed866bada9818","repo":"internetarchive/openlibrary","base_commit":"d8518f64d954113c9363335eb25201befa2de6f2","dockerhub_tag":"internetarchive.openlibrary-internetarchive__openlibrary-b67138b316b1e9c11df8a4a8391fe5cc8e75ff9f-ve8c8d62a2b60610a3c4631f5f23ed"} +{"instance_id":"instance_NodeBB__NodeBB-04998908ba6721d64eba79ae3b65a351dcfbc5b5-vnan","repo":"NodeBB/NodeBB","base_commit":"1e137b07052bc3ea0da44ed201702c94055b8ad2","dockerhub_tag":"nodebb.nodebb-NodeBB__NodeBB-04998908ba6721d64eba79ae3b65a351dcfbc5b5"} +{"instance_id":"instance_gravitational__teleport-326fd1d7be87b03998dbc53bc706fdef90f5065c-v626ec2a48416b10a88641359a169d99e935ff037","repo":"gravitational/teleport","base_commit":"b1e4f1e0324f7e89d1c3c49070a05a243bfddf99","dockerhub_tag":"gravitational.teleport-gravitational__teleport-326fd1d7be87b03998dbc53bc706fdef90f5065c-v626ec2a48416b10a88641359a169d99e935ff03"} +{"instance_id":"instance_internetarchive__openlibrary-ba3abfb6af6e722185d3715929ab0f3e5a134eed-v76304ecdb3a5954fcf13feb710e8c40fcf24b73c","repo":"internetarchive/openlibrary","base_commit":"2edaf7283cf5d934e0d60aac0cc89eff7ceb6e43","dockerhub_tag":"internetarchive.openlibrary-internetarchive__openlibrary-ba3abfb6af6e722185d3715929ab0f3e5a134eed-v76304ecdb3a5954fcf13feb710e8c"} +{"instance_id":"instance_NodeBB__NodeBB-8ca65b0c78c67c1653487c02d1135e1b702185e1-vf2cf3cbd463b7ad942381f1c6d077626485a1e9e","repo":"NodeBB/NodeBB","base_commit":"f2c0c18879ffdeea8d643ffa05a188e43f14afee","dockerhub_tag":"nodebb.nodebb-NodeBB__NodeBB-8ca65b0c78c67c1653487c02d1135e1b702185e1-vf2cf3cbd463b7ad942381f1c6d077626485a1e9e"} +{"instance_id":"instance_ansible__ansible-0fd88717c953b92ed8a50495d55e630eb5d59166-vba6da65a0f3baefda7a058ebbd0a8dcafb8512f5","repo":"ansible/ansible","base_commit":"016b7f71b10539c90ddbb3246f19f9cbf0e65428","dockerhub_tag":"ansible.ansible-ansible__ansible-0fd88717c953b92ed8a50495d55e630eb5d59166-vba6da65a0f3baefda7a058ebbd0a8dcafb8512f5"} +{"instance_id":"instance_future-architect__vuls-abd80417728b16c6502067914d27989ee575f0ee","repo":"future-architect/vuls","base_commit":"847c6438e7604bf45a6a4efda0925f41b4f14d7f","dockerhub_tag":"future-architect.vuls-future-architect__vuls-abd80417728b16c6502067914d27989ee575f0ee"} +{"instance_id":"instance_navidrome__navidrome-3f2d24695e9382125dfe5e6d6c8bbeb4a313a4f9","repo":"navidrome/navidrome","base_commit":"cbe3adf9873af6d255c5476d2fde54116968f01c","dockerhub_tag":"navidrome.navidrome-navidrome__navidrome-3f2d24695e9382125dfe5e6d6c8bbeb4a313a4f9"} +{"instance_id":"instance_protonmail__webclients-5d2576632037d655c3b6a28e98cd157f7e9a5ce1","repo":"protonmail/webclients","base_commit":"7d863f89768bf19207c19af1b2e0c78d0b56a716","dockerhub_tag":"protonmail.webclients-protonmail__webclients-5d2576632037d655c3b6a28e98cd157f7e9a5ce1"} +{"instance_id":"instance_navidrome__navidrome-55bff343cdaad1f04496f724eda4b55d422d7f17","repo":"navidrome/navidrome","base_commit":"68f03d01672a868f86e0fd73dde3957df8bf0dab","dockerhub_tag":"navidrome.navidrome-navidrome__navidrome-55bff343cdaad1f04496f724eda4b55d422d7f17"} +{"instance_id":"instance_ansible__ansible-d72025be751c894673ba85caa063d835a0ad3a8c-v390e508d27db7a51eece36bb6d9698b63a5b638a","repo":"ansible/ansible","base_commit":"ea164fdde79a3e624c28f90c74f57f06360d2333","dockerhub_tag":"ansible.ansible-ansible__ansible-d72025be751c894673ba85caa063d835a0ad3a8c-v390e508d27db7a51eece36bb6d9698b63a5b638a"} +{"instance_id":"instance_flipt-io__flipt-3d5a345f94c2adc8a0eaa102c189c08ad4c0f8e8","repo":"flipt-io/flipt","base_commit":"91cc1b9fc38280a53a36e1e9543d87d7306144b2","dockerhub_tag":"flipt-io.flipt-flipt-io__flipt-3d5a345f94c2adc8a0eaa102c189c08ad4c0f8e8"} +{"instance_id":"instance_navidrome__navidrome-d21932bd1b2379b0ebca2d19e5d8bae91040268a","repo":"navidrome/navidrome","base_commit":"c72add516a0f260e83a289c2355b2e74071311e0","dockerhub_tag":"navidrome.navidrome-navidrome__navidrome-d21932bd1b2379b0ebca2d19e5d8bae91040268a"} +{"instance_id":"instance_future-architect__vuls-54e73c2f5466ef5daec3fb30922b9ac654e4ed25","repo":"future-architect/vuls","base_commit":"2d075079f112658b02e67b409958d5872477aad6","dockerhub_tag":"future-architect.vuls-future-architect__vuls-54e73c2f5466ef5daec3fb30922b9ac654e4ed25"} +{"instance_id":"instance_flipt-io__flipt-967855b429f749c28c112b8cb1b15bc79157f973","repo":"flipt-io/flipt","base_commit":"3c6bd20465f0c801ebbcdadaf998e46b37b98e6b","dockerhub_tag":"flipt-io.flipt-flipt-io__flipt-967855b429f749c28c112b8cb1b15bc79157f973"} +{"instance_id":"instance_gravitational__teleport-0ac7334939981cf85b9591ac295c3816954e287e","repo":"gravitational/teleport","base_commit":"42beccb27e0e5797a10db05bf126e529273d2d95","dockerhub_tag":"gravitational.teleport-gravitational__teleport-0ac7334939981cf85b9591ac295c3816954e287e"} +{"instance_id":"instance_gravitational__teleport-fb0ab2b9b771377a689fd0d0374777c251e58bbf","repo":"gravitational/teleport","base_commit":"b58ad484649e51b439ba11df387e25e23e8296d1","dockerhub_tag":"gravitational.teleport-gravitational__teleport-fb0ab2b9b771377a689fd0d0374777c251e58bbf"} +{"instance_id":"instance_gravitational__teleport-73cc189b0e9636d418c4470ecce0d9af5dae2f02-vee9b09fb20c43af7e520f57e9239bbcf46b7113d","repo":"gravitational/teleport","base_commit":"31b8f1571759ebf5fe082a18a2efd1e8ee6148e7","dockerhub_tag":"gravitational.teleport-gravitational__teleport-73cc189b0e9636d418c4470ecce0d9af5dae2f02-vee9b09fb20c43af7e520f57e9239bbcf46b7113"} +{"instance_id":"instance_protonmail__webclients-e65cc5f33719e02e1c378146fb981d27bc24bdf4","repo":"protonmail/webclients","base_commit":"bd293dcc05b75ecca4a648edd7ae237ec48c1454","dockerhub_tag":"protonmail.webclients-protonmail__webclients-e65cc5f33719e02e1c378146fb981d27bc24bdf4"} +{"instance_id":"instance_navidrome__navidrome-0130c6dc13438b48cf0fdfab08a89e357b5517c9","repo":"navidrome/navidrome","base_commit":"2f90fc9bd40e24afd900b5ee85426f32684b960b","dockerhub_tag":"navidrome.navidrome-navidrome__navidrome-0130c6dc13438b48cf0fdfab08a89e357b5517c9"} +{"instance_id":"instance_NodeBB__NodeBB-b1f9ad5534bb3a44dab5364f659876a4b7fe34c1-vnan","repo":"NodeBB/NodeBB","base_commit":"6ecc791db9bfbb2a22e113e4630071da87ce3c1e","dockerhub_tag":"nodebb.nodebb-NodeBB__NodeBB-b1f9ad5534bb3a44dab5364f659876a4b7fe34c1"} +{"instance_id":"instance_ansible__ansible-f8ef34672b961a95ec7282643679492862c688ec-vba6da65a0f3baefda7a058ebbd0a8dcafb8512f5","repo":"ansible/ansible","base_commit":"e889b1063f60f6b99f5d031f7e903f7be5f58900","dockerhub_tag":"ansible.ansible-ansible__ansible-f8ef34672b961a95ec7282643679492862c688ec-vba6da65a0f3baefda7a058ebbd0a8dcafb8512f5"} +{"instance_id":"instance_gravitational__teleport-fd2959260ef56463ad8afa4c973f47a50306edd4","repo":"gravitational/teleport","base_commit":"025143d85654c604656571c363d0c7b9a6579f62","dockerhub_tag":"gravitational.teleport-gravitational__teleport-fd2959260ef56463ad8afa4c973f47a50306edd4"} +{"instance_id":"instance_navidrome__navidrome-d5df102f9f97c21715c756069c9e141da2a422dc","repo":"navidrome/navidrome","base_commit":"20271df4fb0b94e201ed5e4b6501d591aa8cd813","dockerhub_tag":"navidrome.navidrome-navidrome__navidrome-d5df102f9f97c21715c756069c9e141da2a422dc"} +{"instance_id":"instance_qutebrowser__qutebrowser-6b320dc18662580e1313d2548fdd6231d2a97e6d-v363c8a7e5ccdf6968fc7ab84a2053ac78036691d","repo":"qutebrowser/qutebrowser","base_commit":"d283e2250fcc533838fbac1078acd5883c77e2e3","dockerhub_tag":"qutebrowser.qutebrowser-qutebrowser__qutebrowser-6b320dc18662580e1313d2548fdd6231d2a97e6d-v363c8a7e5ccdf6968fc7ab84a2053ac780366"} +{"instance_id":"instance_future-architect__vuls-61c39637f2f3809e1b5dad05f0c57c799dce1587","repo":"future-architect/vuls","base_commit":"f1c384812a1541f7c859488daeff03a008bce7fc","dockerhub_tag":"future-architect.vuls-future-architect__vuls-61c39637f2f3809e1b5dad05f0c57c799dce1587"} +{"instance_id":"instance_qutebrowser__qutebrowser-7b603dd6bf195e3e723ce08ff64a82b406e3f6b6-v9f8e9d96c85c85a605e382f1510bd08563afc566","repo":"qutebrowser/qutebrowser","base_commit":"a67832ba311fdb0e9d57190d1671241a369b5b0a","dockerhub_tag":"qutebrowser.qutebrowser-qutebrowser__qutebrowser-7b603dd6bf195e3e723ce08ff64a82b406e3f6b6-v9f8e9d96c85c85a605e382f1510bd08563afc"} +{"instance_id":"instance_NodeBB__NodeBB-bad15643013ca15affe408b75eba9e47cc604bb2-vd59a5728dfc977f44533186ace531248c2917516","repo":"NodeBB/NodeBB","base_commit":"be86d8efc7fb019e707754b8b64dd6cf3517e8c7","dockerhub_tag":"nodebb.nodebb-NodeBB__NodeBB-bad15643013ca15affe408b75eba9e47cc604bb2-vd59a5728dfc977f44533186ace531248c2917516"} +{"instance_id":"instance_NodeBB__NodeBB-4327a09d76f10a79109da9d91c22120428d3bdb9-vnan","repo":"NodeBB/NodeBB","base_commit":"754965b572f33bfd864e98e4805e1182c1960080","dockerhub_tag":"nodebb.nodebb-NodeBB__NodeBB-4327a09d76f10a79109da9d91c22120428d3bdb9"} +{"instance_id":"instance_NodeBB__NodeBB-6ea3b51f128dd270281db576a1b59270d5e45db0-vnan","repo":"NodeBB/NodeBB","base_commit":"d9c42c000cd6c624794722fd55a741aff9d18823","dockerhub_tag":"nodebb.nodebb-NodeBB__NodeBB-6ea3b51f128dd270281db576a1b59270d5e45db0"} +{"instance_id":"instance_gravitational__teleport-6a14edcf1ff010172fdbac622d0a474ed6af46de","repo":"gravitational/teleport","base_commit":"9c041361f9ff3270d252609d5aa92eb1251cd8d7","dockerhub_tag":"gravitational.teleport-gravitational__teleport-6a14edcf1ff010172fdbac622d0a474ed6af46de"} +{"instance_id":"instance_internetarchive__openlibrary-11838fad1028672eb975c79d8984f03348500173-v0f5aece3601a5b4419f7ccec1dbda2071be28ee4","repo":"internetarchive/openlibrary","base_commit":"4ff15b75531e51f365d72241efe9675b6982bdcc","dockerhub_tag":"internetarchive.openlibrary-internetarchive__openlibrary-11838fad1028672eb975c79d8984f03348500173-v0f5aece3601a5b4419f7ccec1dbda"} +{"instance_id":"instance_gravitational__teleport-b5d8169fc0a5e43fee2616c905c6d32164654dc6","repo":"gravitational/teleport","base_commit":"103f3de22f3986d4f73d931b1e433e011b26a488","dockerhub_tag":"gravitational.teleport-gravitational__teleport-b5d8169fc0a5e43fee2616c905c6d32164654dc6"} +{"instance_id":"instance_future-architect__vuls-7e91f5ef7e5712b1a3d7d5066ad6607e9debc21c","repo":"future-architect/vuls","base_commit":"76267a54fcb1cb1aea83e34e2673d88bf8987f05","dockerhub_tag":"future-architect.vuls-future-architect__vuls-7e91f5ef7e5712b1a3d7d5066ad6607e9debc21c"} +{"instance_id":"instance_qutebrowser__qutebrowser-305e7c96d5e2fdb3b248b27dfb21042fb2b7e0b8-v2ef375ac784985212b1805e1d0431dc8f1b3c171","repo":"qutebrowser/qutebrowser","base_commit":"1aec789f4d010dfebae3cceac2c71ebeafe81e08","dockerhub_tag":"qutebrowser.qutebrowser-qutebrowser__qutebrowser-305e7c96d5e2fdb3b248b27dfb21042fb2b7e0b8-v2ef375ac784985212b1805e1d0431dc8f1b3c"} +{"instance_id":"instance_flipt-io__flipt-6fd0f9e2587f14ac1fdd1c229f0bcae0468c8daa","repo":"flipt-io/flipt","base_commit":"563a8c4593610e431f0c3db55e88a679c4386991","dockerhub_tag":"flipt-io.flipt-flipt-io__flipt-6fd0f9e2587f14ac1fdd1c229f0bcae0468c8daa"} +{"instance_id":"instance_gravitational__teleport-3ff19cf7c41f396ae468797d3aeb61515517edc9-vee9b09fb20c43af7e520f57e9239bbcf46b7113d","repo":"gravitational/teleport","base_commit":"e3a8fb7a0fa7e32504a714c370c3a8dbf71b1d6f","dockerhub_tag":"gravitational.teleport-gravitational__teleport-3ff19cf7c41f396ae468797d3aeb61515517edc9-vee9b09fb20c43af7e520f57e9239bbcf46b7113"} +{"instance_id":"instance_NodeBB__NodeBB-f083cd559d69c16481376868c8da65172729c0ca-vnan","repo":"NodeBB/NodeBB","base_commit":"163c977d2f4891fa7c4372b9f6a686b1fa34350f","dockerhub_tag":"nodebb.nodebb-NodeBB__NodeBB-f083cd559d69c16481376868c8da65172729c0ca"} +{"instance_id":"instance_flipt-io__flipt-9d25c18b79bc7829a6fb08ec9e8793d5d17e2868","repo":"flipt-io/flipt","base_commit":"fa8f302adcde48b4a94bf45726fe4da73de5e5ab","dockerhub_tag":"flipt-io.flipt-flipt-io__flipt-9d25c18b79bc7829a6fb08ec9e8793d5d17e2868"} +{"instance_id":"instance_gravitational__teleport-2bb3bbbd8aff1164a2353381cb79e1dc93b90d28-vee9b09fb20c43af7e520f57e9239bbcf46b7113d","repo":"gravitational/teleport","base_commit":"040ec6d3b264d152a674718eb5a0864debb68470","dockerhub_tag":"gravitational.teleport-gravitational__teleport-2bb3bbbd8aff1164a2353381cb79e1dc93b90d28-vee9b09fb20c43af7e520f57e9239bbcf46b7113"} +{"instance_id":"instance_future-architect__vuls-407407d306e9431d6aa0ab566baa6e44e5ba2904","repo":"future-architect/vuls","base_commit":"dccdd8a091bc57785341d911b7d8c7867d522e9a","dockerhub_tag":"future-architect.vuls-future-architect__vuls-407407d306e9431d6aa0ab566baa6e44e5ba2904"} +{"instance_id":"instance_navidrome__navidrome-f7d4fcdcc1a59d1b4f835519efb402897757e371","repo":"navidrome/navidrome","base_commit":"002cb4ed71550a5642612d29dd90b63636961430","dockerhub_tag":"navidrome.navidrome-navidrome__navidrome-f7d4fcdcc1a59d1b4f835519efb402897757e371"} +{"instance_id":"instance_flipt-io__flipt-84806a178447e766380cc66b14dee9c6eeb534f4","repo":"flipt-io/flipt","base_commit":"b22f5f02e40b225b6b93fff472914973422e97c6","dockerhub_tag":"flipt-io.flipt-flipt-io__flipt-84806a178447e766380cc66b14dee9c6eeb534f4"} +{"instance_id":"instance_ansible__ansible-d9f1866249756efc264b00ff7497e92c11a9885f-v0f01c69f1e2528b935359cfe578530722bca2c59","repo":"ansible/ansible","base_commit":"59ca05b70994b07a9507f61a0871146a4991b262","dockerhub_tag":"ansible.ansible-ansible__ansible-d9f1866249756efc264b00ff7497e92c11a9885f-v0f01c69f1e2528b935359cfe578530722bca2c59"} +{"instance_id":"instance_gravitational__teleport-3ff75e29fb2153a2637fe7f83e49dc04b1c99c9f","repo":"gravitational/teleport","base_commit":"4b11dc4a8e02ec5620b27f9ecb28f3180a5e67f7","dockerhub_tag":"gravitational.teleport-gravitational__teleport-3ff75e29fb2153a2637fe7f83e49dc04b1c99c9f"} +{"instance_id":"instance_qutebrowser__qutebrowser-bedc9f7fadf93f83d8dee95feeecb9922b6f063f-v2ef375ac784985212b1805e1d0431dc8f1b3c171","repo":"qutebrowser/qutebrowser","base_commit":"0e624e64695e8f566c7391f65f737311aeb6b2eb","dockerhub_tag":"qutebrowser.qutebrowser-qutebrowser__qutebrowser-bedc9f7fadf93f83d8dee95feeecb9922b6f063f-v2ef375ac784985212b1805e1d0431dc8f1b3c"} +{"instance_id":"instance_internetarchive__openlibrary-308a35d6999427c02b1dbf5211c033ad3b352556-ve8c8d62a2b60610a3c4631f5f23ed866bada9818","repo":"internetarchive/openlibrary","base_commit":"cb6c053eba49facef557ee95d587f6d6c93caf3a","dockerhub_tag":"internetarchive.openlibrary-internetarchive__openlibrary-308a35d6999427c02b1dbf5211c033ad3b352556-ve8c8d62a2b60610a3c4631f5f23ed"} +{"instance_id":"instance_flipt-io__flipt-3b2c25ee8a3ac247c3fad13ad8d64ace34ec8ee7","repo":"flipt-io/flipt","base_commit":"8d72418bf67cec833da7f59beeecb5abfd48cb05","dockerhub_tag":"flipt-io.flipt-flipt-io__flipt-3b2c25ee8a3ac247c3fad13ad8d64ace34ec8ee7"} +{"instance_id":"instance_navidrome__navidrome-7073d18b54da7e53274d11c9e2baef1242e8769e","repo":"navidrome/navidrome","base_commit":"7fc964aec5d432480d76bb90eee14a09aca5125f","dockerhub_tag":"navidrome.navidrome-navidrome__navidrome-7073d18b54da7e53274d11c9e2baef1242e8769e"} +{"instance_id":"instance_flipt-io__flipt-2ce8a0331e8a8f63f2c1b555db8277ffe5aa2e63","repo":"flipt-io/flipt","base_commit":"f3421c143953d2a2e3f4373f8ec366e0904f9bdd","dockerhub_tag":"flipt-io.flipt-flipt-io__flipt-2ce8a0331e8a8f63f2c1b555db8277ffe5aa2e63"} +{"instance_id":"instance_element-hq__element-web-53b42e321777a598aaf2bb3eab22d710569f83a8-vnan","repo":"element-hq/element-web","base_commit":"53415bfdfeb9f25e6755dde2bc41e9dbca4fa791","dockerhub_tag":"element-hq.element-element-hq__element-web-53b42e321777a598aaf2bb3eab22d710569f83a8"} +{"instance_id":"instance_flipt-io__flipt-b4bb5e13006a729bc0eed8fe6ea18cff54acdacb","repo":"flipt-io/flipt","base_commit":"c2c0f7761620a8348be46e2f1a3cedca84577eeb","dockerhub_tag":"flipt-io.flipt-flipt-io__flipt-b4bb5e13006a729bc0eed8fe6ea18cff54acdacb"} +{"instance_id":"instance_ansible__ansible-984216f52e76b904e5b0fa0fb956ab4f1e0a7751-v1055803c3a812189a1133297f7f5468579283f86","repo":"ansible/ansible","base_commit":"d79b23910a1a16931885c5b3056179e72e0e6466","dockerhub_tag":"ansible.ansible-ansible__ansible-984216f52e76b904e5b0fa0fb956ab4f1e0a7751-v1055803c3a812189a1133297f7f5468579283f86"} +{"instance_id":"instance_element-hq__element-web-9a31cd0fa849da810b4fac6c6c015145e850b282-vnan","repo":"element-hq/element-web","base_commit":"b03433ef8b83a4c82b9d879946fb1ab5afaca522","dockerhub_tag":"element-hq.element-element-hq__element-web-9a31cd0fa849da810b4fac6c6c015145e850b282"} +{"instance_id":"instance_navidrome__navidrome-6bd4c0f6bfa653e9b8b27cfdc2955762d371d6e9","repo":"navidrome/navidrome","base_commit":"b445cdd64166fb679103464c2e7ba7c890f97cb1","dockerhub_tag":"navidrome.navidrome-navidrome__navidrome-6bd4c0f6bfa653e9b8b27cfdc2955762d371d6e9"} +{"instance_id":"instance_internetarchive__openlibrary-f0341c0ba81c790241b782f5103ce5c9a6edf8e3-ve8fc82d8aae8463b752a211156c5b7b59f349237","repo":"internetarchive/openlibrary","base_commit":"ba3abfb6af6e722185d3715929ab0f3e5a134eed","dockerhub_tag":"internetarchive.openlibrary-internetarchive__openlibrary-f0341c0ba81c790241b782f5103ce5c9a6edf8e3-ve8fc82d8aae8463b752a211156c5b"} +{"instance_id":"instance_ansible__ansible-3889ddeb4b780ab4bac9ca2e75f8c1991bcabe83-v0f01c69f1e2528b935359cfe578530722bca2c59","repo":"ansible/ansible","base_commit":"d5a740ddca57ed344d1d023383d4aff563657424","dockerhub_tag":"ansible.ansible-ansible__ansible-3889ddeb4b780ab4bac9ca2e75f8c1991bcabe83-v0f01c69f1e2528b935359cfe578530722bca2c59"} +{"instance_id":"instance_qutebrowser__qutebrowser-01d1d1494411380d97cac14614a829d3a69cecaf-v2ef375ac784985212b1805e1d0431dc8f1b3c171","repo":"qutebrowser/qutebrowser","base_commit":"71451483f4f380c2f70f6e5b28025af79b1168e5","dockerhub_tag":"qutebrowser.qutebrowser-qutebrowser__qutebrowser-01d1d1494411380d97cac14614a829d3a69cecaf-v2ef375ac784985212b1805e1d0431dc8f1b3c"} +{"instance_id":"instance_navidrome__navidrome-6c6223f2f9db2c8c253e0d40a192e3519c9037d1","repo":"navidrome/navidrome","base_commit":"6ff7ab52f4a62e65d59b6c6eb9b9f47eb976c43b","dockerhub_tag":"navidrome.navidrome-navidrome__navidrome-6c6223f2f9db2c8c253e0d40a192e3519c9037d1"} +{"instance_id":"instance_protonmail__webclients-428cd033fede5fd6ae9dbc7ab634e010b10e4209","repo":"protonmail/webclients","base_commit":"29aaad40bdc4c440960cf493116399bd96863a0e","dockerhub_tag":"protonmail.webclients-protonmail__webclients-428cd033fede5fd6ae9dbc7ab634e010b10e4209"} +{"instance_id":"instance_element-hq__element-web-f0359a5c180b8fec4329c77adcf967c8d3b7b787-vnan","repo":"element-hq/element-web","base_commit":"a3a2a0f9141d8ee6e12cb4a8ab2ecf3211b71829","dockerhub_tag":"element-hq.element-element-hq__element-web-f0359a5c180b8fec4329c77adcf967c8d3b7b787"} +{"instance_id":"instance_NodeBB__NodeBB-70b4a0e2aebebe8f2f559de6680093d96a697b2f-vnan","repo":"NodeBB/NodeBB","base_commit":"6bbe3d1c4cefe56f81629dfa3343fd0a875d9cf1","dockerhub_tag":"nodebb.nodebb-NodeBB__NodeBB-70b4a0e2aebebe8f2f559de6680093d96a697b2f"} +{"instance_id":"instance_flipt-io__flipt-aebaecd026f752b187f11328b0d464761b15d2ab","repo":"flipt-io/flipt","base_commit":"1d550f0c0d693844b6f4b44fd7859254ef3569c0","dockerhub_tag":"flipt-io.flipt-flipt-io__flipt-aebaecd026f752b187f11328b0d464761b15d2ab"} +{"instance_id":"instance_future-architect__vuls-e3c27e1817d68248043bd09d63cc31f3344a6f2c","repo":"future-architect/vuls","base_commit":"aeaf3086799a04924a81b47b031c1c39c949f924","dockerhub_tag":"future-architect.vuls-future-architect__vuls-e3c27e1817d68248043bd09d63cc31f3344a6f2c"} +{"instance_id":"instance_flipt-io__flipt-7161f7b876773a911afdd804b281e52681cb7321","repo":"flipt-io/flipt","base_commit":"11775ea830dd27bccd3e28152309df91d754a11b","dockerhub_tag":"flipt-io.flipt-flipt-io__flipt-7161f7b876773a911afdd804b281e52681cb7321"} +{"instance_id":"instance_element-hq__element-web-aeabf3b18896ac1eb7ae9757e66ce886120f8309-vnan","repo":"element-hq/element-web","base_commit":"c9d9c421bc7e3f2a9d5d5ed05679cb3e8e06a388","dockerhub_tag":"element-hq.element-element-hq__element-web-aeabf3b18896ac1eb7ae9757e66ce886120f8309"} +{"instance_id":"instance_qutebrowser__qutebrowser-0aa57e4f7243024fa4bba8853306691b5dbd77b3-v5149fcda2a9a6fe1d35dfed1bade1444a11ef271","repo":"qutebrowser/qutebrowser","base_commit":"e8a7c6b257478bd39810f19c412f484ada6a3dc6","dockerhub_tag":"qutebrowser.qutebrowser-qutebrowser__qutebrowser-0aa57e4f7243024fa4bba8853306691b5dbd77b3-v5149fcda2a9a6fe1d35dfed1bade1444a11ef"} +{"instance_id":"instance_gravitational__teleport-b1bcd8b90c474a35bb11cc3ef4cc8941e1f8eab2-vee9b09fb20c43af7e520f57e9239bbcf46b7113d","repo":"gravitational/teleport","base_commit":"b054261bc1cce536d307cbdad358f7c6c941b851","dockerhub_tag":"gravitational.teleport-gravitational__teleport-b1bcd8b90c474a35bb11cc3ef4cc8941e1f8eab2-vee9b09fb20c43af7e520f57e9239bbcf46b7113"} +{"instance_id":"instance_gravitational__teleport-e6d86299a855687b21970504fbf06f52a8f80c74-vce94f93ad1030e3136852817f2423c1b3ac37bc4","repo":"gravitational/teleport","base_commit":"ea02952f53663a6a068ac70088ad5a044f54a094","dockerhub_tag":"gravitational.teleport-gravitational__teleport-e6d86299a855687b21970504fbf06f52a8f80c74-vce94f93ad1030e3136852817f2423c1b3ac37bc"} +{"instance_id":"instance_flipt-io__flipt-756f00f79ba8abf9fe53f3c6c818123b42eb7355","repo":"flipt-io/flipt","base_commit":"266e5e143e87519047b9be3202a0aba273b83de3","dockerhub_tag":"flipt-io.flipt-flipt-io__flipt-756f00f79ba8abf9fe53f3c6c818123b42eb7355"} +{"instance_id":"instance_internetarchive__openlibrary-91efee627df01e32007abf2d6ebf73f9d9053076-vbee42ad1b72fb23c6a1c874868a720b370983ed2","repo":"internetarchive/openlibrary","base_commit":"ab62fa4d63d15b7bc1b9a856ae9acd74df1f1f93","dockerhub_tag":"internetarchive.openlibrary-internetarchive__openlibrary-91efee627df01e32007abf2d6ebf73f9d9053076-vbee42ad1b72fb23c6a1c874868a72"} +{"instance_id":"instance_qutebrowser__qutebrowser-2dd8966fdcf11972062c540b7a787e4d0de8d372-v363c8a7e5ccdf6968fc7ab84a2053ac78036691d","repo":"qutebrowser/qutebrowser","base_commit":"6c653125d95a26db53471dba1bc331aee3b0477e","dockerhub_tag":"qutebrowser.qutebrowser-qutebrowser__qutebrowser-2dd8966fdcf11972062c540b7a787e4d0de8d372-v363c8a7e5ccdf6968fc7ab84a2053ac780366"} +{"instance_id":"instance_internetarchive__openlibrary-3f7db6bbbcc7c418b3db72d157c6aed1d45b2ccf-v430f20c722405e462d9ef44dee7d34c41e76fe7a","repo":"internetarchive/openlibrary","base_commit":"c46e5170e93bbfac133dd1e2e1e3b56882f2519f","dockerhub_tag":"internetarchive.openlibrary-internetarchive__openlibrary-3f7db6bbbcc7c418b3db72d157c6aed1d45b2ccf-v430f20c722405e462d9ef44dee7d3"} +{"instance_id":"instance_NodeBB__NodeBB-76c6e30282906ac664f2c9278fc90999b27b1f48-vd59a5728dfc977f44533186ace531248c2917516","repo":"NodeBB/NodeBB","base_commit":"a3e1a666b876e0b3ccbb5284dd826c8c90c113b4","dockerhub_tag":"nodebb.nodebb-NodeBB__NodeBB-76c6e30282906ac664f2c9278fc90999b27b1f48-vd59a5728dfc977f44533186ace531248c2917516"} +{"instance_id":"instance_ansible__ansible-1a4644ff15355fd696ac5b9d074a566a80fe7ca3-v30a923fb5c164d6cd18280c02422f75e611e8fb2","repo":"ansible/ansible","base_commit":"1503805b703787aba06111f67e7dc564e3420cad","dockerhub_tag":"ansible.ansible-ansible__ansible-1a4644ff15355fd696ac5b9d074a566a80fe7ca3-v30a923fb5c164d6cd18280c02422f75e611e8fb2"} +{"instance_id":"instance_element-hq__element-web-f3534b42df3dcfe36dc48bddbf14034085af6d30-vnan","repo":"element-hq/element-web","base_commit":"64733e59822c91e1d0a72fbe000532fac6f40bf4","dockerhub_tag":"element-hq.element-element-hq__element-web-f3534b42df3dcfe36dc48bddbf14034085af6d30"} +{"instance_id":"instance_navidrome__navidrome-dfa453cc4ab772928686838dc73d0130740f054e","repo":"navidrome/navidrome","base_commit":"8f03454312f28213293da7fec7f63508985f0eeb","dockerhub_tag":"navidrome.navidrome-navidrome__navidrome-dfa453cc4ab772928686838dc73d0130740f054e"} +{"instance_id":"instance_navidrome__navidrome-09ae41a2da66264c60ef307882362d2e2d8d8b89","repo":"navidrome/navidrome","base_commit":"70487a09f4e202dce34b3d0253137f25402495d4","dockerhub_tag":"navidrome.navidrome-navidrome__navidrome-09ae41a2da66264c60ef307882362d2e2d8d8b89"} +{"instance_id":"instance_internetarchive__openlibrary-6e889f4a733c9f8ce9a9bd2ec6a934413adcedb9-ve8c8d62a2b60610a3c4631f5f23ed866bada9818","repo":"internetarchive/openlibrary","base_commit":"9a9204b43f9ab94601e8664340eb1dd0fca33517","dockerhub_tag":"internetarchive.openlibrary-internetarchive__openlibrary-6e889f4a733c9f8ce9a9bd2ec6a934413adcedb9-ve8c8d62a2b60610a3c4631f5f23ed"} +{"instance_id":"instance_gravitational__teleport-eda668c30d9d3b56d9c69197b120b01013611186","repo":"gravitational/teleport","base_commit":"4f6f52f86d65f506d1884a9f56bcd919a8744734","dockerhub_tag":"gravitational.teleport-gravitational__teleport-eda668c30d9d3b56d9c69197b120b01013611186"} +{"instance_id":"instance_element-hq__element-web-880428ab94c6ea98d3d18dcaeb17e8767adcb461-vnan","repo":"element-hq/element-web","base_commit":"e6fe7b7ea8aad2672854b96b5eb7fb863e19cf92","dockerhub_tag":"element-hq.element-element-hq__element-web-880428ab94c6ea98d3d18dcaeb17e8767adcb461"} +{"instance_id":"instance_ansible__ansible-12734fa21c08a0ce8c84e533abdc560db2eb1955-v7eee2454f617569fd6889f2211f75bc02a35f9f8","repo":"ansible/ansible","base_commit":"de01db08d00c8d2438e1ba5989c313ba16a145b0","dockerhub_tag":"ansible.ansible-ansible__ansible-12734fa21c08a0ce8c84e533abdc560db2eb1955-v7eee2454f617569fd6889f2211f75bc02a35f9f8"} +{"instance_id":"instance_ansible__ansible-748f534312f2073a25a87871f5bd05882891b8c4-v0f01c69f1e2528b935359cfe578530722bca2c59","repo":"ansible/ansible","base_commit":"68e270d4cc2579e4659ed53aecbc5a3358b85985","dockerhub_tag":"ansible.ansible-ansible__ansible-748f534312f2073a25a87871f5bd05882891b8c4-v0f01c69f1e2528b935359cfe578530722bca2c59"} +{"instance_id":"instance_ansible__ansible-d58e69c82d7edd0583dd8e78d76b075c33c3151e-v173091e2e36d38c978002990795f66cfc0af30ad","repo":"ansible/ansible","base_commit":"a6e671db25381ed111bbad0ab3e7d97366395d05","dockerhub_tag":"ansible.ansible-ansible__ansible-d58e69c82d7edd0583dd8e78d76b075c33c3151e-v173091e2e36d38c978002990795f66cfc0af30ad"} +{"instance_id":"instance_gravitational__teleport-7744f72c6eb631791434b648ba41083b5f6d2278-vce94f93ad1030e3136852817f2423c1b3ac37bc4","repo":"gravitational/teleport","base_commit":"44b89c75c07c34c4026beaeab494fef1ad67e5e5","dockerhub_tag":"gravitational.teleport-gravitational__teleport-7744f72c6eb631791434b648ba41083b5f6d2278-vce94f93ad1030e3136852817f2423c1b3ac37bc"} +{"instance_id":"instance_element-hq__element-web-6961c256035bed0b7640a6e5907652c806968478-vnan","repo":"element-hq/element-web","base_commit":"29c193210fc5297f0839f02eddea36aa63977516","dockerhub_tag":"element-hq.element-element-hq__element-web-6961c256035bed0b7640a6e5907652c806968478"} +{"instance_id":"instance_navidrome__navidrome-812dc2090f20ac4f8ac271b6ed95be5889d1a3ca","repo":"navidrome/navidrome","base_commit":"a9cf54afef34f980985c76ae3a5e1b7441098831","dockerhub_tag":"navidrome.navidrome-navidrome__navidrome-812dc2090f20ac4f8ac271b6ed95be5889d1a3ca"} +{"instance_id":"instance_navidrome__navidrome-874b17b8f614056df0ef021b5d4f977341084185","repo":"navidrome/navidrome","base_commit":"5808b9fb718eaec4d0e72f02bebb811ca7bc8ca0","dockerhub_tag":"navidrome.navidrome-navidrome__navidrome-874b17b8f614056df0ef021b5d4f977341084185"} +{"instance_id":"instance_element-hq__element-web-fe14847bb9bb07cab1b9c6c54335ff22ca5e516a-vnan","repo":"element-hq/element-web","base_commit":"ad9cbe93994888e8f8ba88ce3614dc041a698930","dockerhub_tag":"element-hq.element-element-hq__element-web-fe14847bb9bb07cab1b9c6c54335ff22ca5e516a"} +{"instance_id":"instance_internetarchive__openlibrary-62d2243131a9c7e6aee00d1e9c5660fd5b594e89-v0f5aece3601a5b4419f7ccec1dbda2071be28ee4","repo":"internetarchive/openlibrary","base_commit":"e0e34eb48957fa645e0a3a8e30667252c3bed3fe","dockerhub_tag":"internetarchive.openlibrary-internetarchive__openlibrary-62d2243131a9c7e6aee00d1e9c5660fd5b594e89-v0f5aece3601a5b4419f7ccec1dbda"} +{"instance_id":"instance_qutebrowser__qutebrowser-50efac08f623644a85441bbe02ab9347d2b71a9d-v9f8e9d96c85c85a605e382f1510bd08563afc566","repo":"qutebrowser/qutebrowser","base_commit":"434f6906f9088172494fa7e219a856d893ed55ba","dockerhub_tag":"qutebrowser.qutebrowser-qutebrowser__qutebrowser-50efac08f623644a85441bbe02ab9347d2b71a9d-v9f8e9d96c85c85a605e382f1510bd08563afc"} +{"instance_id":"instance_protonmail__webclients-bf2e89c0c488ae1a87d503e5b09fe9dd2f2a635f","repo":"protonmail/webclients","base_commit":"a5e37d3fe77abd2279bea864bf57f8d641e1777b","dockerhub_tag":"protonmail.webclients-protonmail__webclients-bf2e89c0c488ae1a87d503e5b09fe9dd2f2a635f"} +{"instance_id":"instance_gravitational__teleport-53814a2d600ccd74c1e9810a567563432b98386e-vce94f93ad1030e3136852817f2423c1b3ac37bc4","repo":"gravitational/teleport","base_commit":"b8394b3bd388d81a5007d3671e3248d3542f6a22","dockerhub_tag":"gravitational.teleport-gravitational__teleport-53814a2d600ccd74c1e9810a567563432b98386e-vce94f93ad1030e3136852817f2423c1b3ac37bc"} +{"instance_id":"instance_protonmail__webclients-8be4f6cb9380fcd2e67bcb18cef931ae0d4b869c","repo":"protonmail/webclients","base_commit":"57f1225f76db015f914c010d2c840c12184b587e","dockerhub_tag":"protonmail.webclients-protonmail__webclients-8be4f6cb9380fcd2e67bcb18cef931ae0d4b869c"} +{"instance_id":"instance_qutebrowser__qutebrowser-3e21c8214a998cb1058defd15aabb24617a76402-v5fc38aaf22415ab0b70567368332beee7955b367","repo":"qutebrowser/qutebrowser","base_commit":"fce306d5f184f185b660f35ec2808b6745d57520","dockerhub_tag":"qutebrowser.qutebrowser-qutebrowser__qutebrowser-3e21c8214a998cb1058defd15aabb24617a76402-v5fc38aaf22415ab0b70567368332beee7955b"} +{"instance_id":"instance_navidrome__navidrome-27875ba2dd1673ddf8affca526b0664c12c3b98b","repo":"navidrome/navidrome","base_commit":"28f7ef43c1083fab4f7eabbade6a5bab83615e73","dockerhub_tag":"navidrome.navidrome-navidrome__navidrome-27875ba2dd1673ddf8affca526b0664c12c3b98b"} +{"instance_id":"instance_element-hq__element-web-cf3c899dd1f221aa1a1f4c5a80dffc05b9c21c85-vnan","repo":"element-hq/element-web","base_commit":"973513cc758030917cb339ba35d6436bc2c7d5dd","dockerhub_tag":"element-hq.element-element-hq__element-web-cf3c899dd1f221aa1a1f4c5a80dffc05b9c21c85"} +{"instance_id":"instance_qutebrowser__qutebrowser-2e961080a85d660148937ee8f0f6b3445a8f2c01-v363c8a7e5ccdf6968fc7ab84a2053ac78036691d","repo":"qutebrowser/qutebrowser","base_commit":"10cb81e81a3782b56ced3d00d7f5b912841b80a2","dockerhub_tag":"qutebrowser.qutebrowser-qutebrowser__qutebrowser-2e961080a85d660148937ee8f0f6b3445a8f2c01-v363c8a7e5ccdf6968fc7ab84a2053ac780366"} +{"instance_id":"instance_future-architect__vuls-7eb77f5b5127c847481bcf600b4dca2b7a85cf3e","repo":"future-architect/vuls","base_commit":"e1152352999e04f347aaaee64b5b4e361631e7ac","dockerhub_tag":"future-architect.vuls-future-architect__vuls-7eb77f5b5127c847481bcf600b4dca2b7a85cf3e"} +{"instance_id":"instance_internetarchive__openlibrary-123e6e5e1c85b9c07d1e98f70bfc480bc8016890-v2733ff199fb72f0d033a30dc62cb0a4742e3a7f4","repo":"internetarchive/openlibrary","base_commit":"115079a6a07b6341bb487f954e50384273b56a98","dockerhub_tag":"internetarchive.openlibrary-internetarchive__openlibrary-123e6e5e1c85b9c07d1e98f70bfc480bc8016890-v2733ff199fb72f0d033a30dc62cb0"} +{"instance_id":"instance_qutebrowser__qutebrowser-5e0d6dc1483cb3336ea0e3dcbd4fe4aa00fc1742-v5149fcda2a9a6fe1d35dfed1bade1444a11ef271","repo":"qutebrowser/qutebrowser","base_commit":"4df7aedf2b2e1f844e8f0ba55bb6fdcafcfa8ec8","dockerhub_tag":"qutebrowser.qutebrowser-qutebrowser__qutebrowser-5e0d6dc1483cb3336ea0e3dcbd4fe4aa00fc1742-v5149fcda2a9a6fe1d35dfed1bade1444a11ef"} +{"instance_id":"instance_future-architect__vuls-be7b9114cc9545e68fb0ee7bc63d7ec53d1a00ad","repo":"future-architect/vuls","base_commit":"bf14b5f61f7a65cb64cf762c71885a413a9fcb66","dockerhub_tag":"future-architect.vuls-future-architect__vuls-be7b9114cc9545e68fb0ee7bc63d7ec53d1a00ad"} +{"instance_id":"instance_protonmail__webclients-6e165e106d258a442ae849cdf08260329cb92d39","repo":"protonmail/webclients","base_commit":"03feb9230522f77f82e6c7860c2aab087624d540","dockerhub_tag":"protonmail.webclients-protonmail__webclients-6e165e106d258a442ae849cdf08260329cb92d39"} +{"instance_id":"instance_flipt-io__flipt-72d06db14d58692bfb4d07b1aa745a37b35956f3","repo":"flipt-io/flipt","base_commit":"b6edc5e46af598a3c187d917ad42b2d013e4dfee","dockerhub_tag":"flipt-io.flipt-flipt-io__flipt-72d06db14d58692bfb4d07b1aa745a37b35956f3"} +{"instance_id":"instance_ansible__ansible-189fcb37f973f0b1d52b555728208eeb9a6fce83-v906c969b551b346ef54a2c0b41e04f632b7b73c2","repo":"ansible/ansible","base_commit":"bc6cd138740bd927b5c52c3b9c18c7812179835e","dockerhub_tag":"ansible.ansible-ansible__ansible-189fcb37f973f0b1d52b555728208eeb9a6fce83-v906c969b551b346ef54a2c0b41e04f632b7b73c2"} +{"instance_id":"instance_protonmail__webclients-e7f3f20c8ad86089967498632ace73c1157a9d51","repo":"protonmail/webclients","base_commit":"4377e82755826b2e09e943a07da0b964aff529cf","dockerhub_tag":"protonmail.webclients-protonmail__webclients-e7f3f20c8ad86089967498632ace73c1157a9d51"} +{"instance_id":"instance_tutao__tutanota-219bc8f05d7b980e038bc1524cb021bf56397a1b-vee878bb72091875e912c52fc32bc60ec3760227b","repo":"tutao/tutanota","base_commit":"9dfb7c231f98a2d3bf48a99577d8a55cfdb2480b","dockerhub_tag":"tutao.tutanota-tutao__tutanota-219bc8f05d7b980e038bc1524cb021bf56397a1b-vee878bb72091875e912c52fc32bc60ec3760227b"} +{"instance_id":"instance_internetarchive__openlibrary-8a9d9d323dfcf2a5b4f38d70b1108b030b20ebf3-v13642507b4fc1f8d234172bf8129942da2c2ca26","repo":"internetarchive/openlibrary","base_commit":"9db365285453fb388757aa65ae06226e7c0f64cf","dockerhub_tag":"internetarchive.openlibrary-internetarchive__openlibrary-8a9d9d323dfcf2a5b4f38d70b1108b030b20ebf3-v13642507b4fc1f8d234172bf81299"} +{"instance_id":"instance_future-architect__vuls-fe8d252c51114e922e6836055ef86a15f79ad042","repo":"future-architect/vuls","base_commit":"0cdc7a3af55e323b86d4e76e17fdc90112b42a63","dockerhub_tag":"future-architect.vuls-future-architect__vuls-fe8d252c51114e922e6836055ef86a15f79ad042"} +{"instance_id":"instance_navidrome__navidrome-97434c1789a6444b30aae5ff5aa124a96a88f504","repo":"navidrome/navidrome","base_commit":"f8ee6db72a015f33b41879d1ba253eeff8884bfd","dockerhub_tag":"navidrome.navidrome-navidrome__navidrome-97434c1789a6444b30aae5ff5aa124a96a88f504"} +{"instance_id":"instance_internetarchive__openlibrary-5069b09e5f64428dce59b33455c8bb17fe577070-v8717e18970bcdc4e0d2cea3b1527752b21e74866","repo":"internetarchive/openlibrary","base_commit":"facafbe7339ca48a33e0d07e089e99b2cf6235df","dockerhub_tag":"internetarchive.openlibrary-internetarchive__openlibrary-5069b09e5f64428dce59b33455c8bb17fe577070-v8717e18970bcdc4e0d2cea3b15277"} +{"instance_id":"instance_element-hq__element-web-18c03daa865d3c5b10e52b669cd50be34c67b2e5-vnan","repo":"element-hq/element-web","base_commit":"212233cb0b9127c95966492175a730d5b954690f","dockerhub_tag":"element-hq.element-element-hq__element-web-18c03daa865d3c5b10e52b669cd50be34c67b2e5"} +{"instance_id":"instance_tutao__tutanota-f373ac3808deefce8183dad8d16729839cc330c1-v2939aa9f4356f0dc9f523ee5ce19d09e08ab979b","repo":"tutao/tutanota","base_commit":"a834bd49d148888778075a3a48d3b92d832c4eed","dockerhub_tag":"tutao.tutanota-tutao__tutanota-f373ac3808deefce8183dad8d16729839cc330c1-v2939aa9f4356f0dc9f523ee5ce19d09e08ab979b"} +{"instance_id":"instance_internetarchive__openlibrary-a7b7dc5735a1b3a9824376b1b469b556dd413981-va4315b5dc369c1ef66ae22f9ae4267aa3114e1b3","repo":"internetarchive/openlibrary","base_commit":"79dccb33ad74f3e9f16e69dce2bae7a568c8d3d0","dockerhub_tag":"internetarchive.openlibrary-internetarchive__openlibrary-a7b7dc5735a1b3a9824376b1b469b556dd413981-va4315b5dc369c1ef66ae22f9ae426"} +{"instance_id":"instance_navidrome__navidrome-b3980532237e57ab15b2b93c49d5cd5b2d050013","repo":"navidrome/navidrome","base_commit":"db11b6b8f8ab9a8557f5783846cc881cc50b627b","dockerhub_tag":"navidrome.navidrome-navidrome__navidrome-b3980532237e57ab15b2b93c49d5cd5b2d050013"} +{"instance_id":"instance_future-architect__vuls-3c1489e588dacea455ccf4c352a3b1006902e2d4","repo":"future-architect/vuls","base_commit":"e4f1e03f6234bbe88564bdfc2d23f120db3c67a6","dockerhub_tag":"future-architect.vuls-future-architect__vuls-3c1489e588dacea455ccf4c352a3b1006902e2d4"} +{"instance_id":"instance_gravitational__teleport-65438e6e44b6ce51458d09b7bb028a2797cfb0ea-vce94f93ad1030e3136852817f2423c1b3ac37bc4","repo":"gravitational/teleport","base_commit":"39cd6e2e750c7700de1e158af9cabc478b2a5110","dockerhub_tag":"gravitational.teleport-gravitational__teleport-65438e6e44b6ce51458d09b7bb028a2797cfb0ea-vce94f93ad1030e3136852817f2423c1b3ac37bc"} +{"instance_id":"instance_qutebrowser__qutebrowser-c0be28ebee3e1837aaf3f30ec534ccd6d038f129-v9f8e9d96c85c85a605e382f1510bd08563afc566","repo":"qutebrowser/qutebrowser","base_commit":"690813e1b10fee83660a6740ab3aabc575a9b125","dockerhub_tag":"qutebrowser.qutebrowser-qutebrowser__qutebrowser-c0be28ebee3e1837aaf3f30ec534ccd6d038f129-v9f8e9d96c85c85a605e382f1510bd08563afc"} +{"instance_id":"instance_ansible__ansible-b748edea457a4576847a10275678127895d2f02f-v1055803c3a812189a1133297f7f5468579283f86","repo":"ansible/ansible","base_commit":"08da8f49b83adec1427abb350d734e6c0569410e","dockerhub_tag":"ansible.ansible-ansible__ansible-b748edea457a4576847a10275678127895d2f02f-v1055803c3a812189a1133297f7f5468579283f86"} +{"instance_id":"instance_protonmail__webclients-5f0745dd6993bb1430a951c62a49807c6635cd77","repo":"protonmail/webclients","base_commit":"12381540293c55229fd3d0d15bd9a14f98385aea","dockerhub_tag":"protonmail.webclients-protonmail__webclients-5f0745dd6993bb1430a951c62a49807c6635cd77"} +{"instance_id":"instance_future-architect__vuls-dc496468b9e9fb73371f9606cdcdb0f8e12e70ca","repo":"future-architect/vuls","base_commit":"54dae08f54aade659d1733e9bc1b2674e7526f29","dockerhub_tag":"future-architect.vuls-future-architect__vuls-dc496468b9e9fb73371f9606cdcdb0f8e12e70ca"} +{"instance_id":"instance_flipt-io__flipt-e5fe37c379e1eec2dd3492c5737c0be761050b26","repo":"flipt-io/flipt","base_commit":"6fd0f9e2587f14ac1fdd1c229f0bcae0468c8daa","dockerhub_tag":"flipt-io.flipt-flipt-io__flipt-e5fe37c379e1eec2dd3492c5737c0be761050b26"} +{"instance_id":"instance_gravitational__teleport-0415e422f12454db0c22316cf3eaa5088d6b6322","repo":"gravitational/teleport","base_commit":"8ee8122b10b3a0a53cb369503ed64d25a6ad1f34","dockerhub_tag":"gravitational.teleport-gravitational__teleport-0415e422f12454db0c22316cf3eaa5088d6b6322"} +{"instance_id":"instance_qutebrowser__qutebrowser-5cef49ff3074f9eab1da6937a141a39a20828502-v02ad04386d5238fe2d1a1be450df257370de4b6a","repo":"qutebrowser/qutebrowser","base_commit":"c41f152fa5b0bc44e15779e99706d7fb8431de85","dockerhub_tag":"qutebrowser.qutebrowser-qutebrowser__qutebrowser-5cef49ff3074f9eab1da6937a141a39a20828502-v02ad04386d5238fe2d1a1be450df257370de4"} +{"instance_id":"instance_future-architect__vuls-d18e7a751d07260d75ce3ba0cd67c4a6aebfd967","repo":"future-architect/vuls","base_commit":"8d5ea98e50cf616847f4e5a2df300395d1f719e9","dockerhub_tag":"future-architect.vuls-future-architect__vuls-d18e7a751d07260d75ce3ba0cd67c4a6aebfd967"} +{"instance_id":"instance_internetarchive__openlibrary-53d376b148897466bb86d5accb51912bbbe9a8ed-v08d8e8889ec945ab821fb156c04c7d2e2810debb","repo":"internetarchive/openlibrary","base_commit":"0d13e6b4bf80bced6c0946b969b9a1b6963f6bce","dockerhub_tag":"internetarchive.openlibrary-internetarchive__openlibrary-53d376b148897466bb86d5accb51912bbbe9a8ed-v08d8e8889ec945ab821fb156c04c7"} +{"instance_id":"instance_ansible__ansible-5d253a13807e884b7ce0b6b57a963a45e2f0322c-v1055803c3a812189a1133297f7f5468579283f86","repo":"ansible/ansible","base_commit":"14e7f05318ddc421330209eece0e891d0eaef10d","dockerhub_tag":"ansible.ansible-ansible__ansible-5d253a13807e884b7ce0b6b57a963a45e2f0322c-v1055803c3a812189a1133297f7f5468579283f86"} +{"instance_id":"instance_qutebrowser__qutebrowser-54bcdc1eefa86cc20790973d6997b60c3bba884c-v2ef375ac784985212b1805e1d0431dc8f1b3c171","repo":"qutebrowser/qutebrowser","base_commit":"0df0985292b79e54c062b7fd8b3f5220b444b429","dockerhub_tag":"qutebrowser.qutebrowser-qutebrowser__qutebrowser-54bcdc1eefa86cc20790973d6997b60c3bba884c-v2ef375ac784985212b1805e1d0431dc8f1b3c"} +{"instance_id":"instance_future-architect__vuls-878c25bf5a9c9fd88ac32eb843f5636834d5712d","repo":"future-architect/vuls","base_commit":"e4728e388120b311c4ed469e4f942e0347a2689b","dockerhub_tag":"future-architect.vuls-future-architect__vuls-878c25bf5a9c9fd88ac32eb843f5636834d5712d"} +{"instance_id":"instance_gravitational__teleport-288c5519ce0dec9622361a5e5d6cd36aa2d9e348","repo":"gravitational/teleport","base_commit":"dafcf377a004506ff840d713bfd7359848ef7b8b","dockerhub_tag":"gravitational.teleport-gravitational__teleport-288c5519ce0dec9622361a5e5d6cd36aa2d9e348"} +{"instance_id":"instance_element-hq__element-web-d06cf09bf0b3d4a0fbe6bd32e4115caea2083168-vnan","repo":"element-hq/element-web","base_commit":"2f8e98242c6de16cbfb6ebb6bc29cfe404b343cb","dockerhub_tag":"element-hq.element-element-hq__element-web-d06cf09bf0b3d4a0fbe6bd32e4115caea2083168"} +{"instance_id":"instance_ansible__ansible-9759e0ca494de1fd5fc2df2c5d11c57adbe6007c-v1055803c3a812189a1133297f7f5468579283f86","repo":"ansible/ansible","base_commit":"fce22529c4f5a7293f12979e7cb45f5ed9f6e9f7","dockerhub_tag":"ansible.ansible-ansible__ansible-9759e0ca494de1fd5fc2df2c5d11c57adbe6007c-v1055803c3a812189a1133297f7f5468579283f86"} +{"instance_id":"instance_element-hq__element-web-1077729a19c0ce902e713cf6fab42c91fb7907f1-vnan","repo":"element-hq/element-web","base_commit":"4f32727829c1087e9d3d9955785d8a6255457c7d","dockerhub_tag":"element-hq.element-element-hq__element-web-1077729a19c0ce902e713cf6fab42c91fb7907f1"} +{"instance_id":"instance_protonmail__webclients-b387b24147e4b5ec3b482b8719ea72bee001462a","repo":"protonmail/webclients","base_commit":"0a917c6b190dd872338287d9abbb73a7a03eee2c","dockerhub_tag":"protonmail.webclients-protonmail__webclients-b387b24147e4b5ec3b482b8719ea72bee001462a"} +{"instance_id":"instance_future-architect__vuls-aaea15e516ece43978cf98e09e52080478b1d39f","repo":"future-architect/vuls","base_commit":"83d1f80959307f189bb0e4571f22f2dd0d669354","dockerhub_tag":"future-architect.vuls-future-architect__vuls-aaea15e516ece43978cf98e09e52080478b1d39f"} +{"instance_id":"instance_internetarchive__openlibrary-00bec1e7c8f3272c469a58e1377df03f955ed478-v13642507b4fc1f8d234172bf8129942da2c2ca26","repo":"internetarchive/openlibrary","base_commit":"02f647f7d525286b6e3a661133c3772649e585cd","dockerhub_tag":"internetarchive.openlibrary-internetarchive__openlibrary-00bec1e7c8f3272c469a58e1377df03f955ed478-v13642507b4fc1f8d234172bf81299"} +{"instance_id":"instance_qutebrowser__qutebrowser-fcfa069a06ade76d91bac38127f3235c13d78eb1-v5fc38aaf22415ab0b70567368332beee7955b367","repo":"qutebrowser/qutebrowser","base_commit":"74671c167f6f18a5494ffe44809e6a0e1c6ea8e9","dockerhub_tag":"qutebrowser.qutebrowser-qutebrowser__qutebrowser-fcfa069a06ade76d91bac38127f3235c13d78eb1-v5fc38aaf22415ab0b70567368332beee7955b"} +{"instance_id":"instance_gravitational__teleport-3fa6904377c006497169945428e8197158667910-v626ec2a48416b10a88641359a169d99e935ff037","repo":"gravitational/teleport","base_commit":"481158d6310e36e3c1115e25ab3fdf1c1ed45e60","dockerhub_tag":"gravitational.teleport-gravitational__teleport-3fa6904377c006497169945428e8197158667910-v626ec2a48416b10a88641359a169d99e935ff03"} +{"instance_id":"instance_ansible__ansible-cd9c4eb5a6b2bfaf4a6709f001ce3d0c92c1eed2-v0f01c69f1e2528b935359cfe578530722bca2c59","repo":"ansible/ansible","base_commit":"585ef6c55e87c10c1ce7d59ebe9c33dd6dbe5afb","dockerhub_tag":"ansible.ansible-ansible__ansible-cd9c4eb5a6b2bfaf4a6709f001ce3d0c92c1eed2-v0f01c69f1e2528b935359cfe578530722bca2c59"} +{"instance_id":"instance_navidrome__navidrome-669c8f4c49a7ef51ac9a53c725097943f67219eb","repo":"navidrome/navidrome","base_commit":"3910e77a7a6ff747487b5ef484a67dbab5826f6a","dockerhub_tag":"navidrome.navidrome-navidrome__navidrome-669c8f4c49a7ef51ac9a53c725097943f67219eb"} +{"instance_id":"instance_protonmail__webclients-3f22e2172cbdfd7b9abb2b1d8fd80c16d38b4bbe","repo":"protonmail/webclients","base_commit":"8f58c5dd5ea6e1b87a8ea6786d99f3eb7014a7b6","dockerhub_tag":"protonmail.webclients-protonmail__webclients-3f22e2172cbdfd7b9abb2b1d8fd80c16d38b4bbe"} +{"instance_id":"instance_gravitational__teleport-4f771403dc4177dc26ee0370f7332f3fe54bee0f-vee9b09fb20c43af7e520f57e9239bbcf46b7113d","repo":"gravitational/teleport","base_commit":"0a61c9e86902cd9feb63246d496b8b78f3e13203","dockerhub_tag":"gravitational.teleport-gravitational__teleport-4f771403dc4177dc26ee0370f7332f3fe54bee0f-vee9b09fb20c43af7e520f57e9239bbcf46b7113"} +{"instance_id":"instance_qutebrowser__qutebrowser-46e6839e21d9ff72abb6c5d49d5abaa5a8da8a81-v2ef375ac784985212b1805e1d0431dc8f1b3c171","repo":"qutebrowser/qutebrowser","base_commit":"e46adf32bdf880385319cb701d926fec6899046d","dockerhub_tag":"qutebrowser.qutebrowser-qutebrowser__qutebrowser-46e6839e21d9ff72abb6c5d49d5abaa5a8da8a81-v2ef375ac784985212b1805e1d0431dc8f1b3c"} +{"instance_id":"instance_qutebrowser__qutebrowser-0fc6d1109d041c69a68a896db87cf1b8c194cef7-v2ef375ac784985212b1805e1d0431dc8f1b3c171","repo":"qutebrowser/qutebrowser","base_commit":"21b20116f5872490bfbba4cf9cbdc8410a8a1d7d","dockerhub_tag":"qutebrowser.qutebrowser-qutebrowser__qutebrowser-0fc6d1109d041c69a68a896db87cf1b8c194cef7-v2ef375ac784985212b1805e1d0431dc8f1b3c"} +{"instance_id":"instance_protonmail__webclients-fc9d535e9beb3ae30a52a7146398cadfd6e30606","repo":"protonmail/webclients","base_commit":"ebed8ea9f69216d3ce996dd88457046c0a033caf","dockerhub_tag":"protonmail.webclients-protonmail__webclients-fc9d535e9beb3ae30a52a7146398cadfd6e30606"} +{"instance_id":"instance_future-architect__vuls-ad2edbb8448e2c41a097f1c0b52696c0f6c5924d","repo":"future-architect/vuls","base_commit":"bfe0db77b4e16e3099a1e58b8db8f18120a11117","dockerhub_tag":"future-architect.vuls-future-architect__vuls-ad2edbb8448e2c41a097f1c0b52696c0f6c5924d"} +{"instance_id":"instance_protonmail__webclients-715dbd4e6999499cd2a576a532d8214f75189116","repo":"protonmail/webclients","base_commit":"aba05b2f451b2f8765207846b11dc67190cb9930","dockerhub_tag":"protonmail.webclients-protonmail__webclients-715dbd4e6999499cd2a576a532d8214f75189116"} +{"instance_id":"instance_gravitational__teleport-59d39dee5a8a66e5b8a18a9085a199d369b1fba8-v626ec2a48416b10a88641359a169d99e935ff037","repo":"gravitational/teleport","base_commit":"79f7d4b1e761a6133a8d844dda14274ac39362e1","dockerhub_tag":"gravitational.teleport-gravitational__teleport-59d39dee5a8a66e5b8a18a9085a199d369b1fba8-v626ec2a48416b10a88641359a169d99e935ff03"} +{"instance_id":"instance_future-architect__vuls-4c04acbd9ea5b073efe999e33381fa9f399d6f27","repo":"future-architect/vuls","base_commit":"1c4f2315727ae4370177b9c1a540fc8b0c0a7c91","dockerhub_tag":"future-architect.vuls-future-architect__vuls-4c04acbd9ea5b073efe999e33381fa9f399d6f27"} +{"instance_id":"instance_internetarchive__openlibrary-111347e9583372e8ef91c82e0612ea437ae3a9c9-v2d9a6c849c60ed19fd0858ce9e40b7cc8e097e59","repo":"internetarchive/openlibrary","base_commit":"c9795319b19c60e884f34df3eaf7e3e7f2bfd58c","dockerhub_tag":"internetarchive.openlibrary-internetarchive__openlibrary-111347e9583372e8ef91c82e0612ea437ae3a9c9-v2d9a6c849c60ed19fd0858ce9e40b"} +{"instance_id":"instance_element-hq__element-web-b7fea97bb68c6628a644580076f840109132f074-vnan","repo":"element-hq/element-web","base_commit":"90801eb38bd0bcca067c02ccc7434b6b9309c03c","dockerhub_tag":"element-hq.element-element-hq__element-web-b7fea97bb68c6628a644580076f840109132f074"} +{"instance_id":"instance_protonmail__webclients-815695401137dac2975400fc610149a16db8214b","repo":"protonmail/webclients","base_commit":"21b45bd4378834403ad9e69dc91605c21f43438b","dockerhub_tag":"protonmail.webclients-protonmail__webclients-815695401137dac2975400fc610149a16db8214b"} +{"instance_id":"instance_ansible__ansible-fb144c44144f8bd3542e71f5db62b6d322c7bd85-vba6da65a0f3baefda7a058ebbd0a8dcafb8512f5","repo":"ansible/ansible","base_commit":"662d34b9a7a1b3ab1d4847eeaef201a005826aef","dockerhub_tag":"ansible.ansible-ansible__ansible-fb144c44144f8bd3542e71f5db62b6d322c7bd85-vba6da65a0f3baefda7a058ebbd0a8dcafb8512f5"} +{"instance_id":"instance_element-hq__element-web-53a9b6447bd7e6110ee4a63e2ec0322c250f08d1-vnan","repo":"element-hq/element-web","base_commit":"97f6431d60ff5e3f9168948a306036402c316fa1","dockerhub_tag":"element-hq.element-element-hq__element-web-53a9b6447bd7e6110ee4a63e2ec0322c250f08d1"} +{"instance_id":"instance_ansible__ansible-b6290e1d156af608bd79118d209a64a051c55001-v390e508d27db7a51eece36bb6d9698b63a5b638a","repo":"ansible/ansible","base_commit":"b6e71c5ffb8ba382b6f49fc9b25e6d8bc78a9a88","dockerhub_tag":"ansible.ansible-ansible__ansible-b6290e1d156af608bd79118d209a64a051c55001-v390e508d27db7a51eece36bb6d9698b63a5b638a"} +{"instance_id":"instance_protonmail__webclients-ac23d1efa1a6ab7e62724779317ba44c28d78cfd","repo":"protonmail/webclients","base_commit":"8b68951e795c21134273225efbd64e5999ffba0f","dockerhub_tag":"protonmail.webclients-protonmail__webclients-ac23d1efa1a6ab7e62724779317ba44c28d78cfd"} +{"instance_id":"instance_future-architect__vuls-1832b4ee3a20177ad313d806983127cb6e53f5cf","repo":"future-architect/vuls","base_commit":"78b52d6a7f480bd610b692de9bf0c86f57332f23","dockerhub_tag":"future-architect.vuls-future-architect__vuls-1832b4ee3a20177ad313d806983127cb6e53f5cf"} +{"instance_id":"instance_gravitational__teleport-a95b3ae0667f9e4b2404bf61f51113e6d83f01cd","repo":"gravitational/teleport","base_commit":"91449219e798e1440f1553738a224d50b5ac9ba1","dockerhub_tag":"gravitational.teleport-gravitational__teleport-a95b3ae0667f9e4b2404bf61f51113e6d83f01cd"} +{"instance_id":"instance_protonmail__webclients-5e815cfa518b223a088fa9bb232a5fc90ab15691","repo":"protonmail/webclients","base_commit":"bf70473d724be9664974c0bc6b04458f6123ead2","dockerhub_tag":"protonmail.webclients-protonmail__webclients-5e815cfa518b223a088fa9bb232a5fc90ab15691"} +{"instance_id":"instance_qutebrowser__qutebrowser-8cd06741bb56cdca49f5cdc0542da97681154315-v5149fcda2a9a6fe1d35dfed1bade1444a11ef271","repo":"qutebrowser/qutebrowser","base_commit":"2a10461ca473838cbc3bf6b92501324470d4f521","dockerhub_tag":"qutebrowser.qutebrowser-qutebrowser__qutebrowser-8cd06741bb56cdca49f5cdc0542da97681154315-v5149fcda2a9a6fe1d35dfed1bade1444a11ef"} +{"instance_id":"instance_protonmail__webclients-8afd9ce04c8dde9e150e1c2b50d32e7ee2efa3e7","repo":"protonmail/webclients","base_commit":"7ff95b70115415f47b89c81a40e90b60bcf3dbd8","dockerhub_tag":"protonmail.webclients-protonmail__webclients-8afd9ce04c8dde9e150e1c2b50d32e7ee2efa3e7"} +{"instance_id":"instance_internetarchive__openlibrary-9c392b60e2c6fa1d68cb68084b4b4ff04d0cb35c-v2d9a6c849c60ed19fd0858ce9e40b7cc8e097e59","repo":"internetarchive/openlibrary","base_commit":"bf5511b4348e89a143ffc99553cd7e4e2a6b0485","dockerhub_tag":"internetarchive.openlibrary-internetarchive__openlibrary-9c392b60e2c6fa1d68cb68084b4b4ff04d0cb35c-v2d9a6c849c60ed19fd0858ce9e40b"} +{"instance_id":"instance_NodeBB__NodeBB-da0211b1a001d45d73b4c84c6417a4f1b0312575-vf2cf3cbd463b7ad942381f1c6d077626485a1e9e","repo":"NodeBB/NodeBB","base_commit":"f8cfe64c7e5243ac394695293d7517b0b509a4b3","dockerhub_tag":"nodebb.nodebb-NodeBB__NodeBB-da0211b1a001d45d73b4c84c6417a4f1b0312575-vf2cf3cbd463b7ad942381f1c6d077626485a1e9e"} +{"instance_id":"instance_tutao__tutanota-befce4b146002b9abc86aa95f4d57581771815ce-vee878bb72091875e912c52fc32bc60ec3760227b","repo":"tutao/tutanota","base_commit":"26c98dd37701c1c657edec33465d52e43e4a05cb","dockerhub_tag":"tutao.tutanota-tutao__tutanota-befce4b146002b9abc86aa95f4d57581771815ce-vee878bb72091875e912c52fc32bc60ec3760227b"} +{"instance_id":"instance_internetarchive__openlibrary-5fb312632097be7e9ac6ab657964af115224d15d-v0f5aece3601a5b4419f7ccec1dbda2071be28ee4","repo":"internetarchive/openlibrary","base_commit":"7549c413a901a640aa351933392f503648d345cc","dockerhub_tag":"internetarchive.openlibrary-internetarchive__openlibrary-5fb312632097be7e9ac6ab657964af115224d15d-v0f5aece3601a5b4419f7ccec1dbda"} +{"instance_id":"instance_internetarchive__openlibrary-60725705782832a2cb22e17c49697948a42a9d03-v298a7a812ceed28c4c18355a091f1b268fe56d86","repo":"internetarchive/openlibrary","base_commit":"73e4b70aa3adafbbf44e7942b5bf9efabce70447","dockerhub_tag":"internetarchive.openlibrary-internetarchive__openlibrary-60725705782832a2cb22e17c49697948a42a9d03-v298a7a812ceed28c4c18355a091f1"} +{"instance_id":"instance_flipt-io__flipt-e88e93990e3ec1e7697754b423decc510d5dd5fe","repo":"flipt-io/flipt","base_commit":"7ee465fe8dbcf9b319c70ef7f3bfd00b3aaab6ca","dockerhub_tag":"flipt-io.flipt-flipt-io__flipt-e88e93990e3ec1e7697754b423decc510d5dd5fe"} +{"instance_id":"instance_ansible__ansible-a1569ea4ca6af5480cf0b7b3135f5e12add28a44-v0f01c69f1e2528b935359cfe578530722bca2c59","repo":"ansible/ansible","base_commit":"f10d11bcdc54c9b7edc0111eb38c59a88e396d0a","dockerhub_tag":"ansible.ansible-ansible__ansible-a1569ea4ca6af5480cf0b7b3135f5e12add28a44-v0f01c69f1e2528b935359cfe578530722bca2c59"} +{"instance_id":"instance_flipt-io__flipt-292fdaca9be39e6a921aaa8874c011d0fdd3e874","repo":"flipt-io/flipt","base_commit":"2cdbe9ca09b33520c1b19059571163ea6d8435ea","dockerhub_tag":"flipt-io.flipt-flipt-io__flipt-292fdaca9be39e6a921aaa8874c011d0fdd3e874"} +{"instance_id":"instance_future-architect__vuls-e049df50fa1eecdccc5348e27845b5c783ed7c76-v73dc95f6b90883d8a87e01e5e9bb6d3cc32add6d","repo":"future-architect/vuls","base_commit":"dce837950529084d34c6815fa66e59a4f68fa8e4","dockerhub_tag":"future-architect.vuls-future-architect__vuls-e049df50fa1eecdccc5348e27845b5c783ed7c76-v73dc95f6b90883d8a87e01e5e9bb6d3cc32add6d"} +{"instance_id":"instance_internetarchive__openlibrary-7f7e53aa4cf74a4f8549a5bcd4810c527e2f6d7e-v13642507b4fc1f8d234172bf8129942da2c2ca26","repo":"internetarchive/openlibrary","base_commit":"630221ab686c64e75a2ce253c893c033e4814b2e","dockerhub_tag":"internetarchive.openlibrary-internetarchive__openlibrary-7f7e53aa4cf74a4f8549a5bcd4810c527e2f6d7e-v13642507b4fc1f8d234172bf81299"} +{"instance_id":"instance_qutebrowser__qutebrowser-6dd402c0d0f7665d32a74c43c5b4cf5dc8aff28d-v5fc38aaf22415ab0b70567368332beee7955b367","repo":"qutebrowser/qutebrowser","base_commit":"d6a3d1fe608bae2afedd3019e46de3476ac18ff6","dockerhub_tag":"qutebrowser.qutebrowser-qutebrowser__qutebrowser-6dd402c0d0f7665d32a74c43c5b4cf5dc8aff28d-v5fc38aaf22415ab0b70567368332beee7955b"} +{"instance_id":"instance_navidrome__navidrome-87d4db7638b37eeb754b217440ab7a372f669205","repo":"navidrome/navidrome","base_commit":"213ceeca7893d3c85eb688e6e99c09dd6cd7e453","dockerhub_tag":"navidrome.navidrome-navidrome__navidrome-87d4db7638b37eeb754b217440ab7a372f669205"} +{"instance_id":"instance_protonmail__webclients-dfe5604193d63bfcb91ce60d62db2f805c43bf11","repo":"protonmail/webclients","base_commit":"ebf2993b7bdc187ec2f3e84c76e0584689202a68","dockerhub_tag":"protonmail.webclients-protonmail__webclients-dfe5604193d63bfcb91ce60d62db2f805c43bf11"} +{"instance_id":"instance_protonmail__webclients-2f2f6c311c6128fe86976950d3c0c2db07b03921","repo":"protonmail/webclients","base_commit":"4d0ef1ed136e80692723f148dc0390dcf28ba9dc","dockerhub_tag":"protonmail.webclients-protonmail__webclients-2f2f6c311c6128fe86976950d3c0c2db07b03921"} +{"instance_id":"instance_qutebrowser__qutebrowser-70248f256f93ed9b1984494d0a1a919ddd774892-v2ef375ac784985212b1805e1d0431dc8f1b3c171","repo":"qutebrowser/qutebrowser","base_commit":"bf65a1db0f3f49977de77d7d61eeaaecd022185c","dockerhub_tag":"qutebrowser.qutebrowser-qutebrowser__qutebrowser-70248f256f93ed9b1984494d0a1a919ddd774892-v2ef375ac784985212b1805e1d0431dc8f1b3c"} +{"instance_id":"instance_ansible__ansible-415e08c2970757472314e515cb63a51ad825c45e-v7eee2454f617569fd6889f2211f75bc02a35f9f8","repo":"ansible/ansible","base_commit":"f05bcf569367904985c0e5796a4c14ce0b7d4be9","dockerhub_tag":"ansible.ansible-ansible__ansible-415e08c2970757472314e515cb63a51ad825c45e-v7eee2454f617569fd6889f2211f75bc02a35f9f8"} +{"instance_id":"instance_ansible__ansible-39bd8b99ec8c6624207bf3556ac7f9626dad9173-v1055803c3a812189a1133297f7f5468579283f86","repo":"ansible/ansible","base_commit":"8502c2302871e35e59fb7092b4b01b937c934031","dockerhub_tag":"ansible.ansible-ansible__ansible-39bd8b99ec8c6624207bf3556ac7f9626dad9173-v1055803c3a812189a1133297f7f5468579283f86"} +{"instance_id":"instance_internetarchive__openlibrary-c4eebe6677acc4629cb541a98d5e91311444f5d4-v13642507b4fc1f8d234172bf8129942da2c2ca26","repo":"internetarchive/openlibrary","base_commit":"84cc4ed5697b83a849e9106a09bfed501169cc20","dockerhub_tag":"internetarchive.openlibrary-internetarchive__openlibrary-c4eebe6677acc4629cb541a98d5e91311444f5d4-v13642507b4fc1f8d234172bf81299"} +{"instance_id":"instance_gravitational__teleport-b4e7cd3a5e246736d3fe8d6886af55030b232277","repo":"gravitational/teleport","base_commit":"85addfbd36943a4b655e1a4241979789e8b4ff22","dockerhub_tag":"gravitational.teleport-gravitational__teleport-b4e7cd3a5e246736d3fe8d6886af55030b232277"} +{"instance_id":"instance_internetarchive__openlibrary-bb152d23c004f3d68986877143bb0f83531fe401-ve8c8d62a2b60610a3c4631f5f23ed866bada9818","repo":"internetarchive/openlibrary","base_commit":"a6145ca7f3579a5d2e3a880db2f365782f459087","dockerhub_tag":"internetarchive.openlibrary-internetarchive__openlibrary-bb152d23c004f3d68986877143bb0f83531fe401-ve8c8d62a2b60610a3c4631f5f23ed"} +{"instance_id":"instance_future-architect__vuls-c11ba27509f733d7d280bdf661cbbe2e7a99df4c","repo":"future-architect/vuls","base_commit":"8a611f9ba6d470cbaa3b781c92c96f5fc9f0b3ba","dockerhub_tag":"future-architect.vuls-future-architect__vuls-c11ba27509f733d7d280bdf661cbbe2e7a99df4c"} +{"instance_id":"instance_gravitational__teleport-dd3977957a67bedaf604ad6ca255ba8c7b6704e9","repo":"gravitational/teleport","base_commit":"e7683826a909e3db7d2fb32e631ea75636ff25ca","dockerhub_tag":"gravitational.teleport-gravitational__teleport-dd3977957a67bedaf604ad6ca255ba8c7b6704e9"} +{"instance_id":"instance_ansible__ansible-b8025ac160146319d2b875be3366b60c852dd35d-v0f01c69f1e2528b935359cfe578530722bca2c59","repo":"ansible/ansible","base_commit":"fa093d8adf03c88908caa38fe70e0db2711e801c","dockerhub_tag":"ansible.ansible-ansible__ansible-b8025ac160146319d2b875be3366b60c852dd35d-v0f01c69f1e2528b935359cfe578530722bca2c59"} +{"instance_id":"instance_flipt-io__flipt-1737085488ecdcd3299c8e61af45a8976d457b7e","repo":"flipt-io/flipt","base_commit":"1f6255dda6648ecafd94826cda3fac2486af4b0f","dockerhub_tag":"flipt-io.flipt-flipt-io__flipt-1737085488ecdcd3299c8e61af45a8976d457b7e"} +{"instance_id":"instance_element-hq__element-web-d405160080bbe804f7e9294067d004a7d4dad9d6-vnan","repo":"element-hq/element-web","base_commit":"b0317e67523f46f81fc214afd6014d7105d726cc","dockerhub_tag":"element-hq.element-element-hq__element-web-d405160080bbe804f7e9294067d004a7d4dad9d6"} +{"instance_id":"instance_qutebrowser__qutebrowser-ef5ba1a0360b39f9eff027fbdc57f363597c3c3b-v363c8a7e5ccdf6968fc7ab84a2053ac78036691d","repo":"qutebrowser/qutebrowser","base_commit":"9c056f288aefebbb95734fa3dc46a2405862405b","dockerhub_tag":"qutebrowser.qutebrowser-qutebrowser__qutebrowser-ef5ba1a0360b39f9eff027fbdc57f363597c3c3b-v363c8a7e5ccdf6968fc7ab84a2053ac780366"} +{"instance_id":"instance_element-hq__element-web-923ad4323b2006b2b180544429455ffe7d4a6cc3-vnan","repo":"element-hq/element-web","base_commit":"19b81d257f7b8b134bf5d7e555c9d5fca3570f69","dockerhub_tag":"element-hq.element-element-hq__element-web-923ad4323b2006b2b180544429455ffe7d4a6cc3"} +{"instance_id":"instance_element-hq__element-web-ad26925bb6628260cfe0fcf90ec0a8cba381f4a4-vnan","repo":"element-hq/element-web","base_commit":"c0e40217f35e2d2a067bbb881c3871565eaf54b2","dockerhub_tag":"element-hq.element-element-hq__element-web-ad26925bb6628260cfe0fcf90ec0a8cba381f4a4"} +{"instance_id":"instance_qutebrowser__qutebrowser-e57b6e0eeeb656eb2c84d6547d5a0a7333ecee85-v2ef375ac784985212b1805e1d0431dc8f1b3c171","repo":"qutebrowser/qutebrowser","base_commit":"5a7f64ea219f3f008a4b61546ae18820e6780d8e","dockerhub_tag":"qutebrowser.qutebrowser-qutebrowser__qutebrowser-e57b6e0eeeb656eb2c84d6547d5a0a7333ecee85-v2ef375ac784985212b1805e1d0431dc8f1b3c"} +{"instance_id":"instance_navidrome__navidrome-f78257235ec3429ef42af6687738cd327ec77ce8","repo":"navidrome/navidrome","base_commit":"1a6a284bc124d579c44053a6b0435cd20ead715c","dockerhub_tag":"navidrome.navidrome-navidrome__navidrome-f78257235ec3429ef42af6687738cd327ec77ce8"} +{"instance_id":"instance_future-architect__vuls-e1fab805afcfc92a2a615371d0ec1e667503c254-v264a82e2f4818e30f5a25e4da53b27ba119f62b5","repo":"future-architect/vuls","base_commit":"5af1a227339e46c7abf3f2815e4c636a0c01098e","dockerhub_tag":"future-architect.vuls-future-architect__vuls-e1fab805afcfc92a2a615371d0ec1e667503c254-v264a82e2f4818e30f5a25e4da53b27ba119f62b5"} +{"instance_id":"instance_gravitational__teleport-bb562408da4adeae16e025be65e170959d1ec492-vee9b09fb20c43af7e520f57e9239bbcf46b7113d","repo":"gravitational/teleport","base_commit":"e0c9b35a5567c186760e10b3a51a8f74f0dabea1","dockerhub_tag":"gravitational.teleport-gravitational__teleport-bb562408da4adeae16e025be65e170959d1ec492-vee9b09fb20c43af7e520f57e9239bbcf46b7113"} +{"instance_id":"instance_internetarchive__openlibrary-9cd47f4dc21e273320d9e30d889c864f8cb20ccf-v0f5aece3601a5b4419f7ccec1dbda2071be28ee4","repo":"internetarchive/openlibrary","base_commit":"7fab050b6a99923d9d2efcc2f79311580b88f8a9","dockerhub_tag":"internetarchive.openlibrary-internetarchive__openlibrary-9cd47f4dc21e273320d9e30d889c864f8cb20ccf-v0f5aece3601a5b4419f7ccec1dbda"} +{"instance_id":"instance_flipt-io__flipt-40007b9d97e3862bcef8c20ae6c87b22ea0627f0","repo":"flipt-io/flipt","base_commit":"bbf0a917fbdf4c92017f760b63727b921eb9fc98","dockerhub_tag":"flipt-io.flipt-flipt-io__flipt-40007b9d97e3862bcef8c20ae6c87b22ea0627f0"} +{"instance_id":"instance_future-architect__vuls-2c84be80b65d022c262956cd26fc79d8bb2f7010","repo":"future-architect/vuls","base_commit":"4c598bb9726d68b6fdef264b26fc700591b303f6","dockerhub_tag":"future-architect.vuls-future-architect__vuls-2c84be80b65d022c262956cd26fc79d8bb2f7010"} +{"instance_id":"instance_protonmail__webclients-51742625834d3bd0d10fe0c7e76b8739a59c6b9f","repo":"protonmail/webclients","base_commit":"8472bc64099be00753167dbb516a1187e0ce9b69","dockerhub_tag":"protonmail.webclients-protonmail__webclients-51742625834d3bd0d10fe0c7e76b8739a59c6b9f"} +{"instance_id":"instance_internetarchive__openlibrary-43f9e7e0d56a4f1d487533543c17040a029ac501-v0f5aece3601a5b4419f7ccec1dbda2071be28ee4","repo":"internetarchive/openlibrary","base_commit":"de903b9535d53122d655590f238a78e217a6c770","dockerhub_tag":"internetarchive.openlibrary-internetarchive__openlibrary-43f9e7e0d56a4f1d487533543c17040a029ac501-v0f5aece3601a5b4419f7ccec1dbda"} +{"instance_id":"instance_ansible__ansible-164881d871964aa64e0f911d03ae270acbad253c-v390e508d27db7a51eece36bb6d9698b63a5b638a","repo":"ansible/ansible","base_commit":"e80f8048ee027ab0c7c8b5912fb6c69c44fb877a","dockerhub_tag":"ansible.ansible-ansible__ansible-164881d871964aa64e0f911d03ae270acbad253c-v390e508d27db7a51eece36bb6d9698b63a5b638a"} +{"instance_id":"instance_ansible__ansible-eea46a0d1b99a6dadedbb6a3502d599235fa7ec3-v390e508d27db7a51eece36bb6d9698b63a5b638a","repo":"ansible/ansible","base_commit":"07e7b69c04116f598ed2376616cbb46343d9a0e9","dockerhub_tag":"ansible.ansible-ansible__ansible-eea46a0d1b99a6dadedbb6a3502d599235fa7ec3-v390e508d27db7a51eece36bb6d9698b63a5b638a"} +{"instance_id":"instance_flipt-io__flipt-d966559200183b713cdf3ea5007a7e0ba86a5afb","repo":"flipt-io/flipt","base_commit":"16e240cc4b24e051ff7c1cb0b430cca67768f4bb","dockerhub_tag":"flipt-io.flipt-flipt-io__flipt-d966559200183b713cdf3ea5007a7e0ba86a5afb"} +{"instance_id":"instance_tutao__tutanota-b4934a0f3c34d9d7649e944b183137e8fad3e859-vbc0d9ba8f0071fbe982809910959a6ff8884dbbf","repo":"tutao/tutanota","base_commit":"6f4d5b9dfc3afe58c74be3be03cab3eb3865aa56","dockerhub_tag":"tutao.tutanota-tutao__tutanota-b4934a0f3c34d9d7649e944b183137e8fad3e859-vbc0d9ba8f0071fbe982809910959a6ff8884dbbf"} +{"instance_id":"instance_internetarchive__openlibrary-2abe28b472ffed563a87cfe83685b161b35263b0-v13642507b4fc1f8d234172bf8129942da2c2ca26","repo":"internetarchive/openlibrary","base_commit":"eb8da9e755f4bf59f8f0bd2b021d3e49a87ccf4e","dockerhub_tag":"internetarchive.openlibrary-internetarchive__openlibrary-2abe28b472ffed563a87cfe83685b161b35263b0-v13642507b4fc1f8d234172bf81299"} +{"instance_id":"instance_ansible__ansible-6cc97447aac5816745278f3735af128afb255c81-v0f01c69f1e2528b935359cfe578530722bca2c59","repo":"ansible/ansible","base_commit":"e094d48b1bdd93cbc189f416543e810c19b2e561","dockerhub_tag":"ansible.ansible-ansible__ansible-6cc97447aac5816745278f3735af128afb255c81-v0f01c69f1e2528b935359cfe578530722bca2c59"} +{"instance_id":"instance_tutao__tutanota-09c2776c0fce3db5c6e18da92b5a45dce9f013aa-vbc0d9ba8f0071fbe982809910959a6ff8884dbbf","repo":"tutao/tutanota","base_commit":"70c37c09d61793fb8a34df626c6b9687b115ecb9","dockerhub_tag":"tutao.tutanota-tutao__tutanota-09c2776c0fce3db5c6e18da92b5a45dce9f013aa-vbc0d9ba8f0071fbe982809910959a6ff8884dbbf"} +{"instance_id":"instance_internetarchive__openlibrary-53e02a22972e9253aeded0e1981e6845e1e521fe-vfa6ff903cb27f336e17654595dd900fa943dcd91","repo":"internetarchive/openlibrary","base_commit":"2e2140e23dde91a233a91e9a7d04648450387721","dockerhub_tag":"internetarchive.openlibrary-internetarchive__openlibrary-53e02a22972e9253aeded0e1981e6845e1e521fe-vfa6ff903cb27f336e17654595dd90"} +{"instance_id":"instance_navidrome__navidrome-3bc9e75b2843f91f6a1e9b604e321c2bd4fd442a","repo":"navidrome/navidrome","base_commit":"3993c4d17fd4b25db867c06b817d3fc146e67d60","dockerhub_tag":"navidrome.navidrome-navidrome__navidrome-3bc9e75b2843f91f6a1e9b604e321c2bd4fd442a"} +{"instance_id":"instance_qutebrowser__qutebrowser-34a13afd36b5e529d553892b1cd8b9d5ce8881c4-vafb3e8e01b31319c66c4e666b8a3b1d8ba55db24","repo":"qutebrowser/qutebrowser","base_commit":"f8692cb141776c3567e35f9032e9892bf0a7cfc9","dockerhub_tag":"qutebrowser.qutebrowser-qutebrowser__qutebrowser-34a13afd36b5e529d553892b1cd8b9d5ce8881c4-vafb3e8e01b31319c66c4e666b8a3b1d8ba55d"} +{"instance_id":"instance_ansible__ansible-622a493ae03bd5e5cf517d336fc426e9d12208c7-v906c969b551b346ef54a2c0b41e04f632b7b73c2","repo":"ansible/ansible","base_commit":"f4502a8f1ce71d88cc90f4b4f6c2899943441ebf","dockerhub_tag":"ansible.ansible-ansible__ansible-622a493ae03bd5e5cf517d336fc426e9d12208c7-v906c969b551b346ef54a2c0b41e04f632b7b73c2"} +{"instance_id":"instance_qutebrowser__qutebrowser-bf045f7ec7c27709ea3ef61cf41a24e8fdd2e7da-v059c6fdc75567943479b23ebca7c07b5e9a7f34c","repo":"qutebrowser/qutebrowser","base_commit":"e15bda307e42c288b926f578e7bf8c610e4767af","dockerhub_tag":"qutebrowser.qutebrowser-qutebrowser__qutebrowser-bf045f7ec7c27709ea3ef61cf41a24e8fdd2e7da-v059c6fdc75567943479b23ebca7c07b5e9a7f"} +{"instance_id":"instance_internetarchive__openlibrary-630221ab686c64e75a2ce253c893c033e4814b2e-v93c53c13d5f9b383ebb411ee7750b49dcd1a34c6","repo":"internetarchive/openlibrary","base_commit":"247986f00311d9ee34009b0bb02d0d3bd7497ebd","dockerhub_tag":"internetarchive.openlibrary-internetarchive__openlibrary-630221ab686c64e75a2ce253c893c033e4814b2e-v93c53c13d5f9b383ebb411ee7750b"} +{"instance_id":"instance_NodeBB__NodeBB-2657804c1fb6b84dc76ad3b18ecf061aaab5f29f-vf2cf3cbd463b7ad942381f1c6d077626485a1e9e","repo":"NodeBB/NodeBB","base_commit":"3ecbb624d892b9fce078304cf89c0fe94f8ab3be","dockerhub_tag":"nodebb.nodebb-NodeBB__NodeBB-2657804c1fb6b84dc76ad3b18ecf061aaab5f29f-vf2cf3cbd463b7ad942381f1c6d077626485a1e9e"} +{"instance_id":"instance_tutao__tutanota-1e516e989b3c0221f4af6b297d9c0e4c43e4adc3-vbc0d9ba8f0071fbe982809910959a6ff8884dbbf","repo":"tutao/tutanota","base_commit":"7ebf14a3432c8f0d8b31d48968a08d055bec2002","dockerhub_tag":"tutao.tutanota-tutao__tutanota-1e516e989b3c0221f4af6b297d9c0e4c43e4adc3-vbc0d9ba8f0071fbe982809910959a6ff8884dbbf"} +{"instance_id":"instance_future-architect__vuls-bff6b7552370b55ff76d474860eead4ab5de785a-v1151a6325649aaf997cd541ebe533b53fddf1b07","repo":"future-architect/vuls","base_commit":"6fca8d97c145fbe50a247dd222947a240639fd50","dockerhub_tag":"future-architect.vuls-future-architect__vuls-bff6b7552370b55ff76d474860eead4ab5de785a-v1151a6325649aaf997cd541ebe533b53fddf1b07"} +{"instance_id":"instance_ansible__ansible-3db08adbb1cc6aa9941be5e0fc810132c6e1fa4b-vba6da65a0f3baefda7a058ebbd0a8dcafb8512f5","repo":"ansible/ansible","base_commit":"709484969c8a4ffd74b839a673431a8c5caa6457","dockerhub_tag":"ansible.ansible-ansible__ansible-3db08adbb1cc6aa9941be5e0fc810132c6e1fa4b-vba6da65a0f3baefda7a058ebbd0a8dcafb8512f5"} +{"instance_id":"instance_qutebrowser__qutebrowser-233cb1cc48635130e5602549856a6fa4ab4c087f-v35616345bb8052ea303186706cec663146f0f184","repo":"qutebrowser/qutebrowser","base_commit":"08604f5a871e7bf2332f24552895a11b7295cee9","dockerhub_tag":"qutebrowser.qutebrowser-qutebrowser__qutebrowser-233cb1cc48635130e5602549856a6fa4ab4c087f-v35616345bb8052ea303186706cec663146f0f"} +{"instance_id":"instance_protonmail__webclients-32ff10999a06455cb2147f6873d627456924ae13","repo":"protonmail/webclients","base_commit":"c40dccc34870418e29f51861a38647bc1cbdf0a8","dockerhub_tag":"protonmail.webclients-protonmail__webclients-32ff10999a06455cb2147f6873d627456924ae13"} +{"instance_id":"instance_navidrome__navidrome-bf2bcb12799b21069f137749e0c331f761d1f693","repo":"navidrome/navidrome","base_commit":"ac4ceab14342bbcb42a6d57bba99e5f933023839","dockerhub_tag":"navidrome.navidrome-navidrome__navidrome-bf2bcb12799b21069f137749e0c331f761d1f693"} +{"instance_id":"instance_ansible__ansible-395e5e20fab9cad517243372fa3c3c5d9e09ab2a-v7eee2454f617569fd6889f2211f75bc02a35f9f8","repo":"ansible/ansible","base_commit":"cd64e0b070f8630e1dcc021e594ed42ea7afe304","dockerhub_tag":"ansible.ansible-ansible__ansible-395e5e20fab9cad517243372fa3c3c5d9e09ab2a-v7eee2454f617569fd6889f2211f75bc02a35f9f8"} +{"instance_id":"instance_flipt-io__flipt-e50808c03e4b9d25a6a78af9c61a3b1616ea356b","repo":"flipt-io/flipt","base_commit":"5069ba6fa22fbbf208352ff341ea7a85d6eca29f","dockerhub_tag":"flipt-io.flipt-flipt-io__flipt-e50808c03e4b9d25a6a78af9c61a3b1616ea356b"} +{"instance_id":"instance_protonmail__webclients-b9387af4cdf79c2cb2a221dea33d665ef789512e","repo":"protonmail/webclients","base_commit":"e2bd7656728f18cfc201a1078e10f23365dd06b5","dockerhub_tag":"protonmail.webclients-protonmail__webclients-b9387af4cdf79c2cb2a221dea33d665ef789512e"} +{"instance_id":"instance_qutebrowser__qutebrowser-ebfe9b7aa0c4ba9d451f993e08955004aaec4345-v059c6fdc75567943479b23ebca7c07b5e9a7f34c","repo":"qutebrowser/qutebrowser","base_commit":"30570a5cad1a3e7f648f066b4a1df8158d6b1189","dockerhub_tag":"qutebrowser.qutebrowser-qutebrowser__qutebrowser-ebfe9b7aa0c4ba9d451f993e08955004aaec4345-v059c6fdc75567943479b23ebca7c07b5e9a7f"} +{"instance_id":"instance_qutebrowser__qutebrowser-77c3557995704a683cdb67e2a3055f7547fa22c3-v363c8a7e5ccdf6968fc7ab84a2053ac78036691d","repo":"qutebrowser/qutebrowser","base_commit":"1799b7926a0202497a88e4ee1fdb232f06ab8e3a","dockerhub_tag":"qutebrowser.qutebrowser-qutebrowser__qutebrowser-77c3557995704a683cdb67e2a3055f7547fa22c3-v363c8a7e5ccdf6968fc7ab84a2053ac780366"} +{"instance_id":"instance_gravitational__teleport-82185f232ae8974258397e121b3bc2ed0c3729ed-v626ec2a48416b10a88641359a169d99e935ff037","repo":"gravitational/teleport","base_commit":"ad00c6c789bdac9b04403889d7ed426242205d64","dockerhub_tag":"gravitational.teleport-gravitational__teleport-82185f232ae8974258397e121b3bc2ed0c3729ed-v626ec2a48416b10a88641359a169d99e935ff03"} +{"instance_id":"instance_navidrome__navidrome-e12a14a87d392ac70ee4cc8079e3c3e0103dbcb2","repo":"navidrome/navidrome","base_commit":"0079a9b93873621fa0bed5439a0f753f48e081b5","dockerhub_tag":"navidrome.navidrome-navidrome__navidrome-e12a14a87d392ac70ee4cc8079e3c3e0103dbcb2"} +{"instance_id":"instance_NodeBB__NodeBB-82562bec444940608052f3e4149e0c61ec80bf3f-vd59a5728dfc977f44533186ace531248c2917516","repo":"NodeBB/NodeBB","base_commit":"779c73eadea5d4246a60ab60486d5e49164884db","dockerhub_tag":"nodebb.nodebb-NodeBB__NodeBB-82562bec444940608052f3e4149e0c61ec80bf3f-vd59a5728dfc977f44533186ace531248c2917516"} +{"instance_id":"instance_flipt-io__flipt-e91615cf07966da41756017a7d571f9fc0fdbe80","repo":"flipt-io/flipt","base_commit":"bdf53a4ec2288975416f9292634bb120ac47eef3","dockerhub_tag":"flipt-io.flipt-flipt-io__flipt-e91615cf07966da41756017a7d571f9fc0fdbe80"} +{"instance_id":"instance_ansible__ansible-a20a52701402a12f91396549df04ac55809f68e9-v1055803c3a812189a1133297f7f5468579283f86","repo":"ansible/ansible","base_commit":"8c044b846d1ea9e2a9c8870b1eaf6db3775e8e2c","dockerhub_tag":"ansible.ansible-ansible__ansible-a20a52701402a12f91396549df04ac55809f68e9-v1055803c3a812189a1133297f7f5468579283f86"} +{"instance_id":"instance_internetarchive__openlibrary-2fe532a33635aab7a9bfea5d977f6a72b280a30c-v0f5aece3601a5b4419f7ccec1dbda2071be28ee4","repo":"internetarchive/openlibrary","base_commit":"4315bbe27c111e85712899901fde689d0eac18bd","dockerhub_tag":"internetarchive.openlibrary-internetarchive__openlibrary-2fe532a33635aab7a9bfea5d977f6a72b280a30c-v0f5aece3601a5b4419f7ccec1dbda"} +{"instance_id":"instance_qutebrowser__qutebrowser-3fd8e12949b8feda401930574facf09dd4180bba","repo":"qutebrowser/qutebrowser","base_commit":"a19634474246739027f826968ea34e720c0ec987","dockerhub_tag":"qutebrowser.qutebrowser-qutebrowser__qutebrowser-3fd8e12949b8feda401930574facf09dd4180bba"} +{"instance_id":"instance_gravitational__teleport-c1b1c6a1541c478d7777a48fca993cc8206c73b9","repo":"gravitational/teleport","base_commit":"b37b02cd6203f1e32d471acfcec8a7675c0a8664","dockerhub_tag":"gravitational.teleport-gravitational__teleport-c1b1c6a1541c478d7777a48fca993cc8206c73b9"} +{"instance_id":"instance_protonmail__webclients-f161c10cf7d31abf82e8d64d7a99c9fac5acfa18","repo":"protonmail/webclients","base_commit":"52ada0340f0ae0869ef1e3b92e1cc4c799b637cf","dockerhub_tag":"protonmail.webclients-protonmail__webclients-f161c10cf7d31abf82e8d64d7a99c9fac5acfa18"} +{"instance_id":"instance_protonmail__webclients-caf10ba9ab2677761c88522d1ba8ad025779c492","repo":"protonmail/webclients","base_commit":"8ae1b7f17822e5121f7394d03192e283904579ad","dockerhub_tag":"protonmail.webclients-protonmail__webclients-caf10ba9ab2677761c88522d1ba8ad025779c492"} +{"instance_id":"instance_gravitational__teleport-1b08e7d0dbe68fe530a0f08ad408ec198b7c53fc-vee9b09fb20c43af7e520f57e9239bbcf46b7113d","repo":"gravitational/teleport","base_commit":"5157a38cadfcaca25a94a6cf380828cbe6e47fe7","dockerhub_tag":"gravitational.teleport-gravitational__teleport-1b08e7d0dbe68fe530a0f08ad408ec198b7c53fc-vee9b09fb20c43af7e520f57e9239bbcf46b7113"} +{"instance_id":"instance_flipt-io__flipt-9f8127f225a86245fa35dca4885c2daef824ee55","repo":"flipt-io/flipt","base_commit":"2d0ff0c91a63a1165f5ca528faa1f0785b1f730c","dockerhub_tag":"flipt-io.flipt-flipt-io__flipt-9f8127f225a86245fa35dca4885c2daef824ee55"} +{"instance_id":"instance_ansible__ansible-83fb24b923064d3576d473747ebbe62e4535c9e3-vba6da65a0f3baefda7a058ebbd0a8dcafb8512f5","repo":"ansible/ansible","base_commit":"0044091a055dd9cd448f7639a65b7e8cc3dacbf1","dockerhub_tag":"ansible.ansible-ansible__ansible-83fb24b923064d3576d473747ebbe62e4535c9e3-vba6da65a0f3baefda7a058ebbd0a8dcafb8512f5"} +{"instance_id":"instance_navidrome__navidrome-8d56ec898e776e7e53e352cb9b25677975787ffc","repo":"navidrome/navidrome","base_commit":"5064cb2a46e4b7ca6a834b3c48a409eec8ca1830","dockerhub_tag":"navidrome.navidrome-navidrome__navidrome-8d56ec898e776e7e53e352cb9b25677975787ffc"} +{"instance_id":"instance_NodeBB__NodeBB-51d8f3b195bddb13a13ddc0de110722774d9bb1b-vf2cf3cbd463b7ad942381f1c6d077626485a1e9e","repo":"NodeBB/NodeBB","base_commit":"da2441b9bd293d7188ee645be3322a7305a43a19","dockerhub_tag":"nodebb.nodebb-NodeBB__NodeBB-51d8f3b195bddb13a13ddc0de110722774d9bb1b-vf2cf3cbd463b7ad942381f1c6d077626485a1e9e"} +{"instance_id":"instance_ansible__ansible-b2a289dcbb702003377221e25f62c8a3608f0e89-v173091e2e36d38c978002990795f66cfc0af30ad","repo":"ansible/ansible","base_commit":"6382ea168a93d80a64aab1fbd8c4f02dc5ada5bf","dockerhub_tag":"ansible.ansible-ansible__ansible-b2a289dcbb702003377221e25f62c8a3608f0e89-v173091e2e36d38c978002990795f66cfc0af30ad"} +{"instance_id":"instance_gravitational__teleport-37c3724d0d6637e959e39408ee351565d73afe71-vee9b09fb20c43af7e520f57e9239bbcf46b7113d","repo":"gravitational/teleport","base_commit":"a2c8576a4873e516a9cce0e0a6b9387c9ea8d91f","dockerhub_tag":"gravitational.teleport-gravitational__teleport-37c3724d0d6637e959e39408ee351565d73afe71-vee9b09fb20c43af7e520f57e9239bbcf46b7113"} +{"instance_id":"instance_flipt-io__flipt-a0cbc0cb65ae601270bdbe3f5313e2dfd49c80e4","repo":"flipt-io/flipt","base_commit":"fee220d0a20adfb21686685bef2a1d6c2ff6fc17","dockerhub_tag":"flipt-io.flipt-flipt-io__flipt-a0cbc0cb65ae601270bdbe3f5313e2dfd49c80e4"} +{"instance_id":"instance_future-architect__vuls-86b60e1478e44d28b1aff6b9ac7e95ceb05bc5fc","repo":"future-architect/vuls","base_commit":"42fdc08933d2b60adc555972b32ae599386b0b9c","dockerhub_tag":"future-architect.vuls-future-architect__vuls-86b60e1478e44d28b1aff6b9ac7e95ceb05bc5fc"} +{"instance_id":"instance_navidrome__navidrome-0a650de357babdcc8ce910fe37fee84acf4ed2fe","repo":"navidrome/navidrome","base_commit":"9c3b4561652a15846993d477003e111f0df0c585","dockerhub_tag":"navidrome.navidrome-navidrome__navidrome-0a650de357babdcc8ce910fe37fee84acf4ed2fe"} +{"instance_id":"instance_flipt-io__flipt-ebb3f84c74d61eee4d8c6875140b990eee62e146","repo":"flipt-io/flipt","base_commit":"9c3cab439846ad339a0a9aa73574f0d05849246e","dockerhub_tag":"flipt-io.flipt-flipt-io__flipt-ebb3f84c74d61eee4d8c6875140b990eee62e146"} +{"instance_id":"instance_flipt-io__flipt-c188284ff0c094a4ee281afebebd849555ebee59","repo":"flipt-io/flipt","base_commit":"47499077ce785f0eee0e3940ef6c074e29a664fc","dockerhub_tag":"flipt-io.flipt-flipt-io__flipt-c188284ff0c094a4ee281afebebd849555ebee59"} +{"instance_id":"instance_qutebrowser__qutebrowser-9ed748effa8f3bcd804612d9291da017b514e12f-v363c8a7e5ccdf6968fc7ab84a2053ac78036691d","repo":"qutebrowser/qutebrowser","base_commit":"30250d8e680041a15e440aa7441a224d670c3862","dockerhub_tag":"qutebrowser.qutebrowser-qutebrowser__qutebrowser-9ed748effa8f3bcd804612d9291da017b514e12f-v363c8a7e5ccdf6968fc7ab84a2053ac780366"} +{"instance_id":"instance_future-architect__vuls-01441351c3407abfc21c48a38e28828e1b504e0c","repo":"future-architect/vuls","base_commit":"4a28722e4aa14f1d125ae789b9966c658d60c0ed","dockerhub_tag":"future-architect.vuls-future-architect__vuls-01441351c3407abfc21c48a38e28828e1b504e0c"} +{"instance_id":"instance_tutao__tutanota-f3ffe17af6e8ab007e8d461355057ad237846d9d-vbc0d9ba8f0071fbe982809910959a6ff8884dbbf","repo":"tutao/tutanota","base_commit":"376d4f298af944bda3e3207ab03de0fcbfc13b2f","dockerhub_tag":"tutao.tutanota-tutao__tutanota-f3ffe17af6e8ab007e8d461355057ad237846d9d-vbc0d9ba8f0071fbe982809910959a6ff8884dbbf"} +{"instance_id":"instance_protonmail__webclients-01b519cd49e6a24d9a05d2eb97f54e420740072e","repo":"protonmail/webclients","base_commit":"a118161e912592cc084945157b713050ca7ea4ba","dockerhub_tag":"protonmail.webclients-protonmail__webclients-01b519cd49e6a24d9a05d2eb97f54e420740072e"} +{"instance_id":"instance_element-hq__element-web-e15ef9f3de36df7f318c083e485f44e1de8aad17","repo":"element-hq/element-web","base_commit":"1a0dbbf1925d5112ddb844ed9ca3fbc49bbb85e8","dockerhub_tag":"element-hq.element-element-hq__element-web-e15ef9f3de36df7f318c083e485f44e1de8aad17"} +{"instance_id":"instance_internetarchive__openlibrary-322d7a46cdc965bfabbf9500e98fde098c9d95b2-v13642507b4fc1f8d234172bf8129942da2c2ca26","repo":"internetarchive/openlibrary","base_commit":"0d5acead6fdfb5e41a1d29a076a6e89ad1a39027","dockerhub_tag":"internetarchive.openlibrary-internetarchive__openlibrary-322d7a46cdc965bfabbf9500e98fde098c9d95b2-v13642507b4fc1f8d234172bf81299"} +{"instance_id":"instance_flipt-io__flipt-c1728053367c753688f114ec26e703c8fdeda125","repo":"flipt-io/flipt","base_commit":"775da4fe5fcbc163ab01fd9a809fdbddd9a87ebd","dockerhub_tag":"flipt-io.flipt-flipt-io__flipt-c1728053367c753688f114ec26e703c8fdeda125"} +{"instance_id":"instance_gravitational__teleport-6eaaf3a27e64f4ef4ef855bd35d7ec338cf17460-v626ec2a48416b10a88641359a169d99e935ff037","repo":"gravitational/teleport","base_commit":"a51596d8d779935e1dfa8d0fabce39d9edd91457","dockerhub_tag":"gravitational.teleport-gravitational__teleport-6eaaf3a27e64f4ef4ef855bd35d7ec338cf17460-v626ec2a48416b10a88641359a169d99e935ff03"} +{"instance_id":"instance_qutebrowser__qutebrowser-e34dfc68647d087ca3175d9ad3f023c30d8c9746-v363c8a7e5ccdf6968fc7ab84a2053ac78036691d","repo":"qutebrowser/qutebrowser","base_commit":"c984983bc4cf6f9148e16ea17369597f67774ff9","dockerhub_tag":"qutebrowser.qutebrowser-qutebrowser__qutebrowser-e34dfc68647d087ca3175d9ad3f023c30d8c9746-v363c8a7e5ccdf6968fc7ab84a2053ac780366"} +{"instance_id":"instance_ansible__ansible-de5858f48dc9e1ce9117034e0d7e76806f420ca8-v1055803c3a812189a1133297f7f5468579283f86","repo":"ansible/ansible","base_commit":"a1730af91f94552e8aaff4bedfb8dcae00bd284d","dockerhub_tag":"ansible.ansible-ansible__ansible-de5858f48dc9e1ce9117034e0d7e76806f420ca8-v1055803c3a812189a1133297f7f5468579283f86"} +{"instance_id":"instance_flipt-io__flipt-e2bd19dafa7166c96b082fb2a59eb54b4be0d778","repo":"flipt-io/flipt","base_commit":"0eaf98f050d86247bfe9bd7e41178865cb585060","dockerhub_tag":"flipt-io.flipt-flipt-io__flipt-e2bd19dafa7166c96b082fb2a59eb54b4be0d778"} +{"instance_id":"instance_internetarchive__openlibrary-7f6b722a10f822171501d027cad60afe53337732-ve8c8d62a2b60610a3c4631f5f23ed866bada9818","repo":"internetarchive/openlibrary","base_commit":"febda3f008cb4d4e4e0568ab4d671992ceea07cf","dockerhub_tag":"internetarchive.openlibrary-internetarchive__openlibrary-7f6b722a10f822171501d027cad60afe53337732-ve8c8d62a2b60610a3c4631f5f23ed"} +{"instance_id":"instance_ansible__ansible-c1f2df47538b884a43320f53e787197793b105e8-v906c969b551b346ef54a2c0b41e04f632b7b73c2","repo":"ansible/ansible","base_commit":"57596edcca0ef3bc4d0d90a55d33ac433b407abb","dockerhub_tag":"ansible.ansible-ansible__ansible-c1f2df47538b884a43320f53e787197793b105e8-v906c969b551b346ef54a2c0b41e04f632b7b73c2"} +{"instance_id":"instance_flipt-io__flipt-dae029cba7cdb98dfb1a6b416c00d324241e6063","repo":"flipt-io/flipt","base_commit":"879520526664656ad9f93925cd0b1f2220c0c3f2","dockerhub_tag":"flipt-io.flipt-flipt-io__flipt-dae029cba7cdb98dfb1a6b416c00d324241e6063"} +{"instance_id":"instance_ansible__ansible-5640093f1ca63fd6af231cc8a7fb7d40e1907b8c-vba6da65a0f3baefda7a058ebbd0a8dcafb8512f5","repo":"ansible/ansible","base_commit":"a5a13246ce02fd4c4ce997627b4f42152e59d288","dockerhub_tag":"ansible.ansible-ansible__ansible-5640093f1ca63fd6af231cc8a7fb7d40e1907b8c-vba6da65a0f3baefda7a058ebbd0a8dcafb8512f5"} +{"instance_id":"instance_gravitational__teleport-96019ce0be7a2c8e36363f359eb7c943b41dde70","repo":"gravitational/teleport","base_commit":"d05df372ce37abd7c190f9fbb68192a773330e63","dockerhub_tag":"gravitational.teleport-gravitational__teleport-96019ce0be7a2c8e36363f359eb7c943b41dde70"} +{"instance_id":"instance_tutao__tutanota-fe240cbf7f0fdd6744ef7bef8cb61676bcdbb621-vc4e41fd0029957297843cb9dec4a25c7c756f029","repo":"tutao/tutanota","base_commit":"fe8a8d9396398fa221bac7ac27bb92c44d93c176","dockerhub_tag":"tutao.tutanota-tutao__tutanota-fe240cbf7f0fdd6744ef7bef8cb61676bcdbb621-vc4e41fd0029957297843cb9dec4a25c7c756f029"} +{"instance_id":"instance_flipt-io__flipt-96820c3ad10b0b2305e8877b6b303f7fafdf815f","repo":"flipt-io/flipt","base_commit":"8dd44097778951eaa6976631d35bc418590d1555","dockerhub_tag":"flipt-io.flipt-flipt-io__flipt-96820c3ad10b0b2305e8877b6b303f7fafdf815f"} +{"instance_id":"instance_internetarchive__openlibrary-b4f7c185ae5f1824ac7f3a18e8adf6a4b468459c-v08d8e8889ec945ab821fb156c04c7d2e2810debb","repo":"internetarchive/openlibrary","base_commit":"0b2e93f2d150770f6ecbfd1931ef56ad876d2c4c","dockerhub_tag":"internetarchive.openlibrary-internetarchive__openlibrary-b4f7c185ae5f1824ac7f3a18e8adf6a4b468459c-v08d8e8889ec945ab821fb156c04c7"} +{"instance_id":"instance_protonmail__webclients-df60460f163fd5c34e844ab9015e3176f1ab1ac0","repo":"protonmail/webclients","base_commit":"e1b69297374f068516a958199da5637448c453cd","dockerhub_tag":"protonmail.webclients-protonmail__webclients-df60460f163fd5c34e844ab9015e3176f1ab1ac0"} +{"instance_id":"instance_ansible__ansible-ecea15c508f0e081525be036cf76bbb56dbcdd9d-vba6da65a0f3baefda7a058ebbd0a8dcafb8512f5","repo":"ansible/ansible","base_commit":"01e7915b0a9778a934a0f0e9e9d110dbef7e31ec","dockerhub_tag":"ansible.ansible-ansible__ansible-ecea15c508f0e081525be036cf76bbb56dbcdd9d-vba6da65a0f3baefda7a058ebbd0a8dcafb8512f5"} +{"instance_id":"instance_gravitational__teleport-c335534e02de143508ebebc7341021d7f8656e8f","repo":"gravitational/teleport","base_commit":"cc3c38d7805e007b25afe751d3690f4e51ba0a0f","dockerhub_tag":"gravitational.teleport-gravitational__teleport-c335534e02de143508ebebc7341021d7f8656e8f"} +{"instance_id":"instance_protonmail__webclients-4feccbc9990980aee26ea29035f8f931d6089895","repo":"protonmail/webclients","base_commit":"e7f4e98ce40bb0a3275feb145a713989cc78804a","dockerhub_tag":"protonmail.webclients-protonmail__webclients-4feccbc9990980aee26ea29035f8f931d6089895"} +{"instance_id":"instance_internetarchive__openlibrary-e1e502986a3b003899a8347ac8a7ff7b08cbfc39-v08d8e8889ec945ab821fb156c04c7d2e2810debb","repo":"internetarchive/openlibrary","base_commit":"77c16d530b4d5c0f33d68bead2c6b329aee9b996","dockerhub_tag":"internetarchive.openlibrary-internetarchive__openlibrary-e1e502986a3b003899a8347ac8a7ff7b08cbfc39-v08d8e8889ec945ab821fb156c04c7"} +{"instance_id":"instance_NodeBB__NodeBB-8168c6c40707478f71b8af60300830fe554c778c-vf2cf3cbd463b7ad942381f1c6d077626485a1e9e","repo":"NodeBB/NodeBB","base_commit":"ab5e2a416324ec56cea44b79067ba798f8394de1","dockerhub_tag":"nodebb.nodebb-NodeBB__NodeBB-8168c6c40707478f71b8af60300830fe554c778c-vf2cf3cbd463b7ad942381f1c6d077626485a1e9e"} +{"instance_id":"instance_flipt-io__flipt-b2cd6a6dd73ca91b519015fd5924fde8d17f3f06","repo":"flipt-io/flipt","base_commit":"d52e03fd5781eabad08e9a5b33c9283b8ffdb1ce","dockerhub_tag":"flipt-io.flipt-flipt-io__flipt-b2cd6a6dd73ca91b519015fd5924fde8d17f3f06"} +{"instance_id":"instance_ansible__ansible-1c06c46cc14324df35ac4f39a45fb3ccd602195d-v0f01c69f1e2528b935359cfe578530722bca2c59","repo":"ansible/ansible","base_commit":"6198c7377f545207218fe8eb2e3cfa9673ff8f5e","dockerhub_tag":"ansible.ansible-ansible__ansible-1c06c46cc14324df35ac4f39a45fb3ccd602195d-v0f01c69f1e2528b935359cfe578530722bca2c59"} +{"instance_id":"instance_ansible__ansible-d6d2251929c84c3aa883bad7db0f19cc9ff0339e-v30a923fb5c164d6cd18280c02422f75e611e8fb2","repo":"ansible/ansible","base_commit":"02e00aba3fd7b646a4f6d6af72159c2b366536bf","dockerhub_tag":"ansible.ansible-ansible__ansible-d6d2251929c84c3aa883bad7db0f19cc9ff0339e-v30a923fb5c164d6cd18280c02422f75e611e8fb2"} +{"instance_id":"instance_protonmail__webclients-6dcf0d0b0f7965ad94be3f84971afeb437f25b02","repo":"protonmail/webclients","base_commit":"473d37b9dc0ab4fb4935b1ee59e3ab2d6ea6b9c2","dockerhub_tag":"protonmail.webclients-protonmail__webclients-6dcf0d0b0f7965ad94be3f84971afeb437f25b02"} +{"instance_id":"instance_flipt-io__flipt-c6a7b1fd933e763b1675281b30077e161fa115a1","repo":"flipt-io/flipt","base_commit":"dc07fbbd64b05a6f14cc16aa5bcbade2863f9d53","dockerhub_tag":"flipt-io.flipt-flipt-io__flipt-c6a7b1fd933e763b1675281b30077e161fa115a1"} +{"instance_id":"instance_element-hq__element-web-5e8488c2838ff4268f39db4a8cca7d74eecf5a7e-vnan","repo":"element-hq/element-web","base_commit":"339e7dab18df52b7fb3e5a86a195eab2adafe36a","dockerhub_tag":"element-hq.element-element-hq__element-web-5e8488c2838ff4268f39db4a8cca7d74eecf5a7e"} +{"instance_id":"instance_gravitational__teleport-0cb341c926713bdfcbb490c69659a9b101df99eb","repo":"gravitational/teleport","base_commit":"2839d2aa27c8cdcd9bc3a78d7bd831fee8e9ab65","dockerhub_tag":"gravitational.teleport-gravitational__teleport-0cb341c926713bdfcbb490c69659a9b101df99eb"} +{"instance_id":"instance_flipt-io__flipt-05d7234fa582df632f70a7cd10194d61bd7043b9","repo":"flipt-io/flipt","base_commit":"b64891e57df74861e89ebcfa81394e4bc096f8c7","dockerhub_tag":"flipt-io.flipt-flipt-io__flipt-05d7234fa582df632f70a7cd10194d61bd7043b9"} +{"instance_id":"instance_gravitational__teleport-e6895d8934f6e484341034869901145fbc025e72-vce94f93ad1030e3136852817f2423c1b3ac37bc4","repo":"gravitational/teleport","base_commit":"19081df863165c67a8570dde690dd92c38c8926e","dockerhub_tag":"gravitational.teleport-gravitational__teleport-e6895d8934f6e484341034869901145fbc025e72-vce94f93ad1030e3136852817f2423c1b3ac37bc"} +{"instance_id":"instance_internetarchive__openlibrary-798a582540019363d14b2090755cc7b89a350788-v430f20c722405e462d9ef44dee7d34c41e76fe7a","repo":"internetarchive/openlibrary","base_commit":"a8db93460b49a39fc3bd8639e34abfca9303236f","dockerhub_tag":"internetarchive.openlibrary-internetarchive__openlibrary-798a582540019363d14b2090755cc7b89a350788-v430f20c722405e462d9ef44dee7d3"} +{"instance_id":"instance_internetarchive__openlibrary-c05ccf2cd8baa81609434e0e35c4a63bc0da5a25-v0f5aece3601a5b4419f7ccec1dbda2071be28ee4","repo":"internetarchive/openlibrary","base_commit":"0180e2ca33a152e69bdbc97047cf6961787c947d","dockerhub_tag":"internetarchive.openlibrary-internetarchive__openlibrary-c05ccf2cd8baa81609434e0e35c4a63bc0da5a25-v0f5aece3601a5b4419f7ccec1dbda"} +{"instance_id":"instance_element-hq__element-web-ec0f940ef0e8e3b61078f145f34dc40d1938e6c5-vnan","repo":"element-hq/element-web","base_commit":"1b39dbdb53f8374094a767c02ad81c46043f3116","dockerhub_tag":"element-hq.element-web-element-hq__element-web-ec0f940ef0e8e3b61078f145f34dc40d1938e6c5-vnan"} +{"instance_id":"instance_internetarchive__openlibrary-1be7de788a444f6255e89c10ef6aa608550604a8-v29f82c9cf21d57b242f8d8b0e541525d259e2d63","repo":"internetarchive/openlibrary","base_commit":"8b933806b52d3785f98d2c397032c8b97a88feb2","dockerhub_tag":"internetarchive.openlibrary-internetarchive__openlibrary-1be7de788a444f6255e89c10ef6aa608550604a8-v29f82c9cf21d57b242f8d8b0e5415"} +{"instance_id":"instance_internetarchive__openlibrary-7cbfb812ef0e1f9716e2d6e85d538a96fcb79d13-vfa6ff903cb27f336e17654595dd900fa943dcd91","repo":"internetarchive/openlibrary","base_commit":"20e8fee0e879ca47c0a1259fec0a5ab1e292aa1f","dockerhub_tag":"internetarchive.openlibrary-internetarchive__openlibrary-7cbfb812ef0e1f9716e2d6e85d538a96fcb79d13-vfa6ff903cb27f336e17654595dd90"} +{"instance_id":"instance_element-hq__element-web-2760bfc8369f1bee640d6d7a7e910783143d4c5f-vnan","repo":"element-hq/element-web","base_commit":"cdffd1ca1f7b60334a8ca3bba64d0a4e6d2b68d0","dockerhub_tag":"element-hq.element-element-hq__element-web-2760bfc8369f1bee640d6d7a7e910783143d4c5f"} +{"instance_id":"instance_internetarchive__openlibrary-de6ae10512f1b5ef585c8341b451bc49c9fd4996-vfa6ff903cb27f336e17654595dd900fa943dcd91","repo":"internetarchive/openlibrary","base_commit":"02e8f0cc1e68830a66cb6bc4ee9f3b81463d5e65","dockerhub_tag":"internetarchive.openlibrary-internetarchive__openlibrary-de6ae10512f1b5ef585c8341b451bc49c9fd4996-vfa6ff903cb27f336e17654595dd90"} +{"instance_id":"instance_protonmail__webclients-ae36cb23a1682dcfd69587c1b311ae0227e28f39","repo":"protonmail/webclients","base_commit":"6ff80e3e9b482201065ec8af21d8a2ddfec0eead","dockerhub_tag":"protonmail.webclients-protonmail__webclients-ae36cb23a1682dcfd69587c1b311ae0227e28f39"} +{"instance_id":"instance_ansible__ansible-5260527c4a71bfed99d803e687dd19619423b134-vba6da65a0f3baefda7a058ebbd0a8dcafb8512f5","repo":"ansible/ansible","base_commit":"bf98f031f3f5af31a2d78dc2f0a58fe92ebae0bb","dockerhub_tag":"ansible.ansible-ansible__ansible-5260527c4a71bfed99d803e687dd19619423b134-vba6da65a0f3baefda7a058ebbd0a8dcafb8512f5"} +{"instance_id":"instance_gravitational__teleport-ad41b3c15414b28a6cec8c25424a19bfa7abd0e9-vee9b09fb20c43af7e520f57e9239bbcf46b7113d","repo":"gravitational/teleport","base_commit":"cdae4e3ee28eedb6b58c1989676c6523ba6dadcc","dockerhub_tag":"gravitational.teleport-gravitational__teleport-ad41b3c15414b28a6cec8c25424a19bfa7abd0e9-vee9b09fb20c43af7e520f57e9239bbcf46b7113"} +{"instance_id":"instance_ansible__ansible-9a21e247786ebd294dafafca1105fcd770ff46c6-v67cdaa49f89b34e42b69d5b7830b3c3ad3d8803f","repo":"ansible/ansible","base_commit":"4c8c40fd3d4a58defdc80e7d22aa8d26b731353e","dockerhub_tag":"ansible.ansible-ansible__ansible-9a21e247786ebd294dafafca1105fcd770ff46c6-v67cdaa49f89b34e42b69d5b7830b3c3ad3d8803f"} +{"instance_id":"instance_protonmail__webclients-6f8916fbadf1d1f4a26640f53b5cf7f55e8bedb7","repo":"protonmail/webclients","base_commit":"2099c5070b15ba5984cd386f63811e4321a27611","dockerhub_tag":"protonmail.webclients-protonmail__webclients-6f8916fbadf1d1f4a26640f53b5cf7f55e8bedb7"} +{"instance_id":"instance_qutebrowser__qutebrowser-7f9713b20f623fc40473b7167a082d6db0f0fd40-va0fd88aac89cde702ec1ba84877234da33adce8a","repo":"qutebrowser/qutebrowser","base_commit":"142f019c7a262e95eb1957ad0766c7a51621109b","dockerhub_tag":"qutebrowser.qutebrowser-qutebrowser__qutebrowser-7f9713b20f623fc40473b7167a082d6db0f0fd40-va0fd88aac89cde702ec1ba84877234da33adc"} +{"instance_id":"instance_future-architect__vuls-999529a05b202b0fd29c6fca5039a4c47a3766bb","repo":"future-architect/vuls","base_commit":"847d820af7fb48131086afe43f79ce79f61122c7","dockerhub_tag":"future-architect.vuls-future-architect__vuls-999529a05b202b0fd29c6fca5039a4c47a3766bb"} +{"instance_id":"instance_NodeBB__NodeBB-6489e9fd9ed16ea743cc5627f4d86c72fbdb3a8a-v2c59007b1005cd5cd14cbb523ca5229db1fd2dd8","repo":"NodeBB/NodeBB","base_commit":"84dfda59e6a0e8a77240f939a7cb8757e6eaf945","dockerhub_tag":"nodebb.nodebb-NodeBB__NodeBB-6489e9fd9ed16ea743cc5627f4d86c72fbdb3a8a-v2c59007b1005cd5cd14cbb523ca5229db1fd2dd8"} +{"instance_id":"instance_ansible__ansible-f327e65d11bb905ed9f15996024f857a95592629-vba6da65a0f3baefda7a058ebbd0a8dcafb8512f5","repo":"ansible/ansible","base_commit":"f533d46572113655a0a698beab4b38671744a458","dockerhub_tag":"ansible.ansible-ansible__ansible-f327e65d11bb905ed9f15996024f857a95592629-vba6da65a0f3baefda7a058ebbd0a8dcafb8512f5"} +{"instance_id":"instance_internetarchive__openlibrary-dbbd9d539c6d4fd45d5be9662aa19b6d664b5137-v08d8e8889ec945ab821fb156c04c7d2e2810debb","repo":"internetarchive/openlibrary","base_commit":"409914bf541b32b2160200b7623060f2b5fab6c0","dockerhub_tag":"internetarchive.openlibrary-internetarchive__openlibrary-dbbd9d539c6d4fd45d5be9662aa19b6d664b5137-v08d8e8889ec945ab821fb156c04c7"} +{"instance_id":"instance_ansible__ansible-1bd7dcf339dd8b6c50bc16670be2448a206f4fdb-vba6da65a0f3baefda7a058ebbd0a8dcafb8512f5","repo":"ansible/ansible","base_commit":"20ef733ee02ba688757998404c1926381356b031","dockerhub_tag":"ansible.ansible-ansible__ansible-1bd7dcf339dd8b6c50bc16670be2448a206f4fdb-vba6da65a0f3baefda7a058ebbd0a8dcafb8512f5"} +{"instance_id":"instance_protonmail__webclients-c6f65d205c401350a226bb005f42fac1754b0b5b","repo":"protonmail/webclients","base_commit":"4aeaf4a64578fe82cdee4a01636121ba0c03ac97","dockerhub_tag":"protonmail.webclients-protonmail__webclients-c6f65d205c401350a226bb005f42fac1754b0b5b"} +{"instance_id":"instance_ansible__ansible-d33bedc48fdd933b5abd65a77c081876298e2f07-v0f01c69f1e2528b935359cfe578530722bca2c59","repo":"ansible/ansible","base_commit":"dcc5dac1846be3bf6e948a2950b93477b9193076","dockerhub_tag":"ansible.ansible-ansible__ansible-d33bedc48fdd933b5abd65a77c081876298e2f07-v0f01c69f1e2528b935359cfe578530722bca2c59"} +{"instance_id":"instance_future-architect__vuls-ca3f6b1dbf2cd24d1537bfda43e788443ce03a0c","repo":"future-architect/vuls","base_commit":"f1c78e42a22aaefe3aa816c0ebd47a845850b856","dockerhub_tag":"future-architect.vuls-future-architect__vuls-ca3f6b1dbf2cd24d1537bfda43e788443ce03a0c"} +{"instance_id":"instance_gravitational__teleport-2be514d3c33b0ae9188e11ac9975485c853d98bb-vce94f93ad1030e3136852817f2423c1b3ac37bc4","repo":"gravitational/teleport","base_commit":"c2a8ff3e78b0e89c060719123caa153993d8bb46","dockerhub_tag":"gravitational.teleport-gravitational__teleport-2be514d3c33b0ae9188e11ac9975485c853d98bb-vce94f93ad1030e3136852817f2423c1b3ac37bc"} +{"instance_id":"instance_protonmail__webclients-f080ffc38e2ad7bddf2e93e5193e82c20c7a11e7","repo":"protonmail/webclients","base_commit":"01b4c82697b2901299ccda53294d7cba95794647","dockerhub_tag":"protonmail.webclients-protonmail__webclients-f080ffc38e2ad7bddf2e93e5193e82c20c7a11e7"} +{"instance_id":"instance_flipt-io__flipt-c8d71ad7ea98d97546f01cce4ccb451dbcf37d3b","repo":"flipt-io/flipt","base_commit":"29d3f9db40c83434d0e3cc082af8baec64c391a9","dockerhub_tag":"flipt-io.flipt-flipt-io__flipt-c8d71ad7ea98d97546f01cce4ccb451dbcf37d3b"} +{"instance_id":"instance_internetarchive__openlibrary-7c8dc180281491ccaa1b4b43518506323750d1e4-v298a7a812ceed28c4c18355a091f1b268fe56d86","repo":"internetarchive/openlibrary","base_commit":"a797a05d077f8896c5d8f480b3620eb1ee398f8c","dockerhub_tag":"internetarchive.openlibrary-internetarchive__openlibrary-7c8dc180281491ccaa1b4b43518506323750d1e4-v298a7a812ceed28c4c18355a091f1"} +{"instance_id":"instance_internetarchive__openlibrary-d109cc7e6e161170391f98f9a6fa1d02534c18e4-ve8c8d62a2b60610a3c4631f5f23ed866bada9818","repo":"internetarchive/openlibrary","base_commit":"daf93507208f2206f8950e3bb5fffac7caf80520","dockerhub_tag":"internetarchive.openlibrary-internetarchive__openlibrary-d109cc7e6e161170391f98f9a6fa1d02534c18e4-ve8c8d62a2b60610a3c4631f5f23ed"} +{"instance_id":"instance_gravitational__teleport-e6681abe6a7113cfd2da507f05581b7bdf398540-v626ec2a48416b10a88641359a169d99e935ff037","repo":"gravitational/teleport","base_commit":"be52cd325af38f53fa6b6f869bc10b88160e06e2","dockerhub_tag":"gravitational.teleport-gravitational__teleport-e6681abe6a7113cfd2da507f05581b7bdf398540-v626ec2a48416b10a88641359a169d99e935ff03"} +{"instance_id":"instance_element-hq__element-web-72a8f8f03b1a01bb70ef8a5bb61759416991b32c-vnan","repo":"element-hq/element-web","base_commit":"650b9cb0cf9bb10674057e232f4792acf83f2e46","dockerhub_tag":"element-hq.element-element-hq__element-web-72a8f8f03b1a01bb70ef8a5bb61759416991b32c"} +{"instance_id":"instance_element-hq__element-web-ee13e23b156fbad9369d6a656c827b6444343d4f-vnan","repo":"element-hq/element-web","base_commit":"8ebdcab7d92f90422776c4390363338dcfd98ba5","dockerhub_tag":"element-hq.element-element-hq__element-web-ee13e23b156fbad9369d6a656c827b6444343d4f"} +{"instance_id":"instance_element-hq__element-web-aec454dd6feeb93000380523cbb0b3681c0275fd-vnan","repo":"element-hq/element-web","base_commit":"1c039fcd3880ef4fefa58812d375104d2d70fe6c","dockerhub_tag":"element-hq.element-element-hq__element-web-aec454dd6feeb93000380523cbb0b3681c0275fd"} +{"instance_id":"instance_qutebrowser__qutebrowser-f8e7fea0becae25ae20606f1422068137189fe9e","repo":"qutebrowser/qutebrowser","base_commit":"a6171337f956048daa8e72745b755a40b607a4f4","dockerhub_tag":"qutebrowser.qutebrowser-qutebrowser__qutebrowser-f8e7fea0becae25ae20606f1422068137189fe9e"} +{"instance_id":"instance_tutao__tutanota-51818218c6ae33de00cbea3a4d30daac8c34142e-vc4e41fd0029957297843cb9dec4a25c7c756f029","repo":"tutao/tutanota","base_commit":"dac77208814de95c4018bcf13137324153cc9a3a","dockerhub_tag":"tutao.tutanota-tutao__tutanota-51818218c6ae33de00cbea3a4d30daac8c34142e-vc4e41fd0029957297843cb9dec4a25c7c756f029"} +{"instance_id":"instance_internetarchive__openlibrary-910b08570210509f3bcfebf35c093a48243fe754-v0f5aece3601a5b4419f7ccec1dbda2071be28ee4","repo":"internetarchive/openlibrary","base_commit":"e9e9d8be33f09cd487b905f339ec3e76ad75e0bb","dockerhub_tag":"internetarchive.openlibrary-internetarchive__openlibrary-910b08570210509f3bcfebf35c093a48243fe754-v0f5aece3601a5b4419f7ccec1dbda"} +{"instance_id":"instance_protonmail__webclients-863d524b5717b9d33ce08a0f0535e3fd8e8d1ed8","repo":"protonmail/webclients","base_commit":"464a02f3da87d165d1bfc330e5310c7c6e5e9734","dockerhub_tag":"protonmail.webclients-protonmail__webclients-863d524b5717b9d33ce08a0f0535e3fd8e8d1ed8"} +{"instance_id":"instance_future-architect__vuls-4b680b996061044e93ef5977a081661665d3360a","repo":"future-architect/vuls","base_commit":"8a8ab8cb18161244ee6f078b43a89b3588d99a4d","dockerhub_tag":"future-architect.vuls-future-architect__vuls-4b680b996061044e93ef5977a081661665d3360a"} +{"instance_id":"instance_future-architect__vuls-b8db2e0b74f60cb7d45f710f255e061f054b6afc","repo":"future-architect/vuls","base_commit":"43b46cb324f64076e4d9e807c0b60c4b9ce11a82","dockerhub_tag":"future-architect.vuls-future-architect__vuls-b8db2e0b74f60cb7d45f710f255e061f054b6afc"} +{"instance_id":"instance_element-hq__element-web-776ffa47641c7ec6d142ab4a47691c30ebf83c2e","repo":"element-hq/element-web","base_commit":"8b54be6f48631083cb853cda5def60d438daa14f","dockerhub_tag":"element-hq.element-element-hq__element-web-776ffa47641c7ec6d142ab4a47691c30ebf83c2e"} +{"instance_id":"instance_flipt-io__flipt-406f9396ad65696d58865b3a6283109cd4eaf40e","repo":"flipt-io/flipt","base_commit":"0c6e9b3f3cd2a42b577a7d84710b6e2470754739","dockerhub_tag":"flipt-io.flipt-flipt-io__flipt-406f9396ad65696d58865b3a6283109cd4eaf40e"} +{"instance_id":"instance_future-architect__vuls-36456cb151894964ba1683ce7da5c35ada789970","repo":"future-architect/vuls","base_commit":"4ae87cc36cb1b1dbc7fd49680d553c8bb47fa8b6","dockerhub_tag":"future-architect.vuls-future-architect__vuls-36456cb151894964ba1683ce7da5c35ada789970"} +{"instance_id":"instance_qutebrowser__qutebrowser-1943fa072ec3df5a87e18a23b0916f134c131016-vafb3e8e01b31319c66c4e666b8a3b1d8ba55db24","repo":"qutebrowser/qutebrowser","base_commit":"1e473c4bc01da1d7f1c4386d8b7b887e00fbf385","dockerhub_tag":"qutebrowser.qutebrowser-qutebrowser__qutebrowser-1943fa072ec3df5a87e18a23b0916f134c131016-vafb3e8e01b31319c66c4e666b8a3b1d8ba55d"} +{"instance_id":"instance_gravitational__teleport-db89206db6c2969266e664c7c0fb51b70e958b64","repo":"gravitational/teleport","base_commit":"08775e34c7463c7aec7d852bb255cb0c3709ca08","dockerhub_tag":"gravitational.teleport-gravitational__teleport-db89206db6c2969266e664c7c0fb51b70e958b64"} +{"instance_id":"instance_flipt-io__flipt-21a935ad7886cc50c46852be21b37f363a926af0","repo":"flipt-io/flipt","base_commit":"4e1cd36398ee73acf7d9235b517f05178651c464","dockerhub_tag":"flipt-io.flipt-flipt-io__flipt-21a935ad7886cc50c46852be21b37f363a926af0"} +{"instance_id":"instance_protonmail__webclients-e9677f6c46d5ea7d277a4532a4bf90074f125f31","repo":"protonmail/webclients","base_commit":"078178de4df1ffb606f1fc5a46bebe6c31d06b4a","dockerhub_tag":"protonmail.webclients-protonmail__webclients-e9677f6c46d5ea7d277a4532a4bf90074f125f31"} +{"instance_id":"instance_flipt-io__flipt-c1fd7a81ef9f23e742501bfb26d914eb683262aa","repo":"flipt-io/flipt","base_commit":"dbe263961b187e1c5d7fe34c65b000985a2da5a0","dockerhub_tag":"flipt-io.flipt-flipt-io__flipt-c1fd7a81ef9f23e742501bfb26d914eb683262aa"} +{"instance_id":"instance_navidrome__navidrome-eebfbc5381a1e506ff17b5f1371d1ad83d5fd642","repo":"navidrome/navidrome","base_commit":"a5dfd2d4a14ac5a5b87fc6016e57b94d2b964a69","dockerhub_tag":"navidrome.navidrome-navidrome__navidrome-eebfbc5381a1e506ff17b5f1371d1ad83d5fd642"} +{"instance_id":"instance_gravitational__teleport-629dc432eb191ca479588a8c49205debb83e80e2","repo":"gravitational/teleport","base_commit":"c12ce90636425daef82da2a7fe2a495e9064d1f8","dockerhub_tag":"gravitational.teleport-gravitational__teleport-629dc432eb191ca479588a8c49205debb83e80e2"} +{"instance_id":"instance_gravitational__teleport-32bcd71591c234f0d8b091ec01f1f5cbfdc0f13c-vee9b09fb20c43af7e520f57e9239bbcf46b7113d","repo":"gravitational/teleport","base_commit":"601c9525b7e146e1b2e2ce989b10697d0f4f8abb","dockerhub_tag":"gravitational.teleport-gravitational__teleport-32bcd71591c234f0d8b091ec01f1f5cbfdc0f13c-vee9b09fb20c43af7e520f57e9239bbcf46b7113"} +{"instance_id":"instance_ansible__ansible-1b70260d5aa2f6c9782fd2b848e8d16566e50d85-vba6da65a0f3baefda7a058ebbd0a8dcafb8512f5","repo":"ansible/ansible","base_commit":"252685092cacdd0f8b485ed6f105ec7acc29c7a4","dockerhub_tag":"ansible.ansible-ansible__ansible-1b70260d5aa2f6c9782fd2b848e8d16566e50d85-vba6da65a0f3baefda7a058ebbd0a8dcafb8512f5"} +{"instance_id":"instance_gravitational__teleport-02d1efb8560a1aa1c72cfb1c08edd8b84a9511b4-vce94f93ad1030e3136852817f2423c1b3ac37bc4","repo":"gravitational/teleport","base_commit":"6f2f17a7f6749418d0bb329169b9181dba446845","dockerhub_tag":"gravitational.teleport-gravitational__teleport-02d1efb8560a1aa1c72cfb1c08edd8b84a9511b4-vce94f93ad1030e3136852817f2423c1b3ac37bc"} +{"instance_id":"instance_navidrome__navidrome-23bebe4e06124becf1000e88472ae71a6ca7de4c","repo":"navidrome/navidrome","base_commit":"8808eadddaa517ab58ce33a70d08f37b0ffdef0e","dockerhub_tag":"navidrome.navidrome-navidrome__navidrome-23bebe4e06124becf1000e88472ae71a6ca7de4c"} +{"instance_id":"instance_gravitational__teleport-89f0432ad5dc70f1f6a30ec3a8363d548371a718","repo":"gravitational/teleport","base_commit":"85244157b056985dd5289f6cbf92f60b35ffad8a","dockerhub_tag":"gravitational.teleport-gravitational__teleport-89f0432ad5dc70f1f6a30ec3a8363d548371a718"} +{"instance_id":"instance_ansible__ansible-811093f0225caa4dd33890933150a81c6a6d5226-v1055803c3a812189a1133297f7f5468579283f86","repo":"ansible/ansible","base_commit":"254de2a43487c61adf3cdc9e35d8a9aa58a186a3","dockerhub_tag":"ansible.ansible-ansible__ansible-811093f0225caa4dd33890933150a81c6a6d5226-v1055803c3a812189a1133297f7f5468579283f86"} +{"instance_id":"instance_qutebrowser__qutebrowser-996487c43e4fcc265b541f9eca1e7930e3c5cf05-v2ef375ac784985212b1805e1d0431dc8f1b3c171","repo":"qutebrowser/qutebrowser","base_commit":"03fa9383833c6262b08a5f7c4930143e39327173","dockerhub_tag":"qutebrowser.qutebrowser-qutebrowser__qutebrowser-996487c43e4fcc265b541f9eca1e7930e3c5cf05-v2ef375ac784985212b1805e1d0431dc8f1b3c"} +{"instance_id":"instance_ansible__ansible-935528e22e5283ee3f63a8772830d3d01f55ed8c-vba6da65a0f3baefda7a058ebbd0a8dcafb8512f5","repo":"ansible/ansible","base_commit":"43300e22798e4c9bd8ec2e321d28c5e8d2018aeb","dockerhub_tag":"ansible.ansible-ansible__ansible-935528e22e5283ee3f63a8772830d3d01f55ed8c-vba6da65a0f3baefda7a058ebbd0a8dcafb8512f5"} +{"instance_id":"instance_tutao__tutanota-fb32e5f9d9fc152a00144d56dd0af01760a2d4dc-vc4e41fd0029957297843cb9dec4a25c7c756f029","repo":"tutao/tutanota","base_commit":"409b35839628e0a63c76dbcb8d41b87e8a06782d","dockerhub_tag":"tutao.tutanota-tutao__tutanota-fb32e5f9d9fc152a00144d56dd0af01760a2d4dc-vc4e41fd0029957297843cb9dec4a25c7c756f029"} +{"instance_id":"instance_ansible__ansible-d30fc6c0b359f631130b0e979d9a78a7b3747d48-v1055803c3a812189a1133297f7f5468579283f86","repo":"ansible/ansible","base_commit":"a58fcde3a0d7a93c363ae7af4e6ee03001b96d82","dockerhub_tag":"ansible.ansible-ansible__ansible-d30fc6c0b359f631130b0e979d9a78a7b3747d48-v1055803c3a812189a1133297f7f5468579283f86"} +{"instance_id":"instance_protonmail__webclients-8142704f447df6e108d53cab25451c8a94976b92","repo":"protonmail/webclients","base_commit":"b63f2ef3157bdfb8b3ff46d9097f9e65b00a4c3a","dockerhub_tag":"protonmail.webclients-protonmail__webclients-8142704f447df6e108d53cab25451c8a94976b92"} +{"instance_id":"instance_flipt-io__flipt-b3cd920bbb25e01fdb2dab66a5a913363bc62f6c","repo":"flipt-io/flipt","base_commit":"490cc12996575ec353e9755ca1c21e222a4e5191","dockerhub_tag":"flipt-io.flipt-flipt-io__flipt-b3cd920bbb25e01fdb2dab66a5a913363bc62f6c"} +{"instance_id":"instance_internetarchive__openlibrary-d40ec88713dc95ea791b252f92d2f7b75e107440-v13642507b4fc1f8d234172bf8129942da2c2ca26","repo":"internetarchive/openlibrary","base_commit":"cbfef314d45fe04e8bf7ebb239f1699606378634","dockerhub_tag":"internetarchive.openlibrary-internetarchive__openlibrary-d40ec88713dc95ea791b252f92d2f7b75e107440-v13642507b4fc1f8d234172bf81299"} +{"instance_id":"instance_element-hq__element-web-4c6b0d35add7ae8d58f71ea1711587e31081444b-vnan","repo":"element-hq/element-web","base_commit":"6da3cc8ca1baf268d768ed63e4b9cb16e40ce33d","dockerhub_tag":"element-hq.element-element-hq__element-web-4c6b0d35add7ae8d58f71ea1711587e31081444b"} +{"instance_id":"instance_qutebrowser__qutebrowser-1a9e74bfaf9a9db2a510dc14572d33ded6040a57-v2ef375ac784985212b1805e1d0431dc8f1b3c171","repo":"qutebrowser/qutebrowser","base_commit":"ebf4b987ecb6c239af91bb44235567c30e288d71","dockerhub_tag":"qutebrowser.qutebrowser-qutebrowser__qutebrowser-1a9e74bfaf9a9db2a510dc14572d33ded6040a57-v2ef375ac784985212b1805e1d0431dc8f1b3c"} +{"instance_id":"instance_gravitational__teleport-cb712e3f0b06dadc679f895daef8072cae400c26-vee9b09fb20c43af7e520f57e9239bbcf46b7113d","repo":"gravitational/teleport","base_commit":"8bca6e20c6c7374080180f7a5b5ea62bb15c136c","dockerhub_tag":"gravitational.teleport-gravitational__teleport-cb712e3f0b06dadc679f895daef8072cae400c26-vee9b09fb20c43af7e520f57e9239bbcf46b7113"} +{"instance_id":"instance_flipt-io__flipt-518ec324b66a07fdd95464a5e9ca5fe7681ad8f9","repo":"flipt-io/flipt","base_commit":"0018c5df774444117b107dfe3fe503d4c7126d73","dockerhub_tag":"flipt-io.flipt-flipt-io__flipt-518ec324b66a07fdd95464a5e9ca5fe7681ad8f9"} +{"instance_id":"instance_NodeBB__NodeBB-a917210c5b2c20637094545401f85783905c074c-vf2cf3cbd463b7ad942381f1c6d077626485a1e9e","repo":"NodeBB/NodeBB","base_commit":"81611ae1c419b25a3bd5861972cb996afe295a93","dockerhub_tag":"nodebb.nodebb-NodeBB__NodeBB-a917210c5b2c20637094545401f85783905c074c-vf2cf3cbd463b7ad942381f1c6d077626485a1e9e"} diff --git a/benchmark/astra/pro_lane.py b/benchmark/astra/pro_lane.py new file mode 100644 index 0000000..c0c4c2f --- /dev/null +++ b/benchmark/astra/pro_lane.py @@ -0,0 +1,319 @@ +"""Execute one SWE-bench Pro lane inside its disposable task container.""" + +from __future__ import annotations + +import argparse +import contextlib +import json +import os +import re +import shutil +import subprocess +import tempfile +from collections.abc import Callable, Sequence +from dataclasses import asdict, dataclass, replace +from pathlib import Path, PurePosixPath +from typing import Any + +from benchmark.codex_adapter.runner import RunConfig, run_task + +_INSTANCE_ID = re.compile( + r"^instance_[A-Za-z0-9][A-Za-z0-9._-]*__[A-Za-z0-9][A-Za-z0-9._-]*-" + r"[0-9a-f]{40}(?:-v(?:[0-9a-f]{40}|nan))?$" +) +_COMMIT = re.compile(r"^[0-9a-f]{40}$") +_CONDITIONS = frozenset({"baseline", "marginal"}) +RunTask = Callable[[RunConfig], dict[str, Any]] + + +@dataclass(frozen=True, slots=True) +class ProLaneConfig: + instance_id: str + base_commit: str + condition: str + worktree: Path = Path("/app") + prompt_path: Path = Path("/marginal-input/prompt.txt") + run_dir: Path = Path("/marginal-output/lane") + codex_executable: Path = Path("/opt/marginal-tools/bin/codex") + auth_source: Path = Path("/run/secrets/codex-auth.json") + + +@dataclass(frozen=True, slots=True) +class SnapshotProvenance: + original_base_commit: str + original_base_tree: str + snapshot_commit: str + snapshot_tree: str + + +def _git( + worktree: Path, + *args: str, + env: dict[str, str] | None = None, + text: bool = True, + input_data: str | bytes | None = None, +) -> str | bytes: + completed = subprocess.run( + ["git", *args], + cwd=worktree, + env=env, + capture_output=True, + check=False, + text=text, + input=input_data, + timeout=120, + ) + if completed.returncode != 0: + stderr = completed.stderr if text else completed.stderr.decode("utf-8", errors="replace") + raise RuntimeError(f"git {' '.join(args)} failed: {stderr.strip()}") + return completed.stdout + + +def _absolute(path: Path, label: str) -> Path: + if not path.is_absolute(): + raise ValueError(f"{label} must be an absolute path") + return path.resolve() + + +def _validate_config(config: ProLaneConfig) -> ProLaneConfig: + if _INSTANCE_ID.fullmatch(config.instance_id) is None: + raise ValueError("instance_id is not a valid SWE-bench instance ID") + if _COMMIT.fullmatch(config.base_commit) is None: + raise ValueError("base_commit must be a lowercase 40-character SHA") + if config.condition not in _CONDITIONS: + raise ValueError("condition must be baseline or marginal") + + worktree = _absolute(config.worktree, "worktree") + prompt_path = _absolute(config.prompt_path, "prompt path") + run_dir = _absolute(config.run_dir, "run directory") + codex_executable = _absolute(config.codex_executable, "Codex executable") + auth_source = _absolute(config.auth_source, "auth source") + if not worktree.is_dir(): + raise ValueError(f"worktree does not exist: {worktree}") + for label, path in ( + ("prompt", prompt_path), + ("Codex executable", codex_executable), + ("auth source", auth_source), + ): + if not path.is_file(): + raise ValueError(f"{label} does not exist: {path}") + if path.is_relative_to(worktree): + raise ValueError(f"{label} must be outside the task repository") + if run_dir.exists(): + raise FileExistsError(f"run directory already exists: {run_dir}") + if run_dir == worktree or run_dir.is_relative_to(worktree): + raise ValueError("run directory must be outside the task repository") + + try: + top_level = str(_git(worktree, "rev-parse", "--show-toplevel")).strip() + resolved_commit = str( + _git(worktree, "rev-parse", f"{config.base_commit}^{{commit}}") + ).strip() + except RuntimeError as exc: + raise ValueError(f"task repository validation failed: {exc}") from exc + if Path(top_level).resolve() != worktree: + raise ValueError("worktree must be the task repository root") + if resolved_commit != config.base_commit: + raise ValueError("base_commit did not resolve to the exact requested commit") + tree_entries = _git(worktree, "ls-tree", "-r", "-z", config.base_commit, text=False) + assert isinstance(tree_entries, bytes) + for entry in tree_entries.split(b"\0"): + if entry.startswith(b"160000 commit "): + raise ValueError("base_commit contains an unsupported gitlink") + return replace( + config, + worktree=worktree, + prompt_path=prompt_path, + run_dir=run_dir, + codex_executable=codex_executable, + auth_source=auth_source, + ) + + +def _remove_tracked_files(worktree: Path) -> None: + raw = _git(worktree, "ls-files", "-z", text=False) + assert isinstance(raw, bytes) + tracked = raw.decode("utf-8", errors="surrogateescape").split("\0") + by_depth = sorted( + (item for item in tracked if item), + key=lambda item: item.count("/"), + reverse=True, + ) + for relative in by_depth: + pure = PurePosixPath(relative) + if pure.is_absolute() or ".." in pure.parts: + raise RuntimeError(f"unsafe tracked path: {relative!r}") + target = worktree.joinpath(*pure.parts) + if target.is_symlink() or target.is_file(): + target.unlink() + elif target.is_dir(): + with contextlib.suppress(OSError): + target.rmdir() + + +def _extract_archive(archive: Path, worktree: Path) -> None: + completed = subprocess.run( + ["tar", "-xf", str(archive), "-C", str(worktree)], + capture_output=True, + check=False, + text=True, + timeout=120, + ) + if completed.returncode != 0: + raise RuntimeError(f"base archive extraction failed: {completed.stderr.strip()}") + + +def _remove_git_metadata(metadata: Path) -> None: + if metadata.is_dir() and not metadata.is_symlink(): + shutil.rmtree(metadata) + elif metadata.exists() or metadata.is_symlink(): + metadata.unlink() + + +def _purge_git_metadata(worktree: Path) -> None: + for root, directories, files in os.walk(worktree, topdown=True, followlinks=False): + if ".git" in directories: + _remove_git_metadata(Path(root) / ".git") + directories.remove(".git") + if ".git" in files: + _remove_git_metadata(Path(root) / ".git") + + +def prepare_repository(config: ProLaneConfig) -> SnapshotProvenance: + """Replace the task checkout with a detached one-commit base snapshot.""" + + config = _validate_config(config) + original_tree = str( + _git(config.worktree, "rev-parse", f"{config.base_commit}^{{tree}}") + ).strip() + base_paths = _git( + config.worktree, + "ls-tree", + "-r", + "-z", + "--name-only", + config.base_commit, + text=False, + ) + assert isinstance(base_paths, bytes) + with tempfile.TemporaryDirectory(prefix="marginal-pro-base-") as temporary: + archive = Path(temporary) / "base.tar" + _git( + config.worktree, + "archive", + "--format=tar", + f"--output={archive}", + config.base_commit, + ) + + _git(config.worktree, "clean", "-ffd") + _remove_tracked_files(config.worktree) + _extract_archive(archive, config.worktree) + _purge_git_metadata(config.worktree) + + _git(config.worktree, "init", "-q") + _git( + config.worktree, + "--literal-pathspecs", + "add", + "-f", + "--pathspec-from-file=-", + "--pathspec-file-nul", + text=False, + input_data=base_paths, + ) + commit_environment = dict(os.environ) + commit_environment.update( + { + "GIT_AUTHOR_NAME": "MARGINAL Pro Benchmark", + "GIT_AUTHOR_EMAIL": "benchmark@example.invalid", + "GIT_AUTHOR_DATE": "2000-01-01T00:00:00+00:00", + "GIT_COMMITTER_NAME": "MARGINAL Pro Benchmark", + "GIT_COMMITTER_EMAIL": "benchmark@example.invalid", + "GIT_COMMITTER_DATE": "2000-01-01T00:00:00+00:00", + } + ) + _git(config.worktree, "commit", "-qm", "frozen SWE-bench Pro base", env=commit_environment) + _git(config.worktree, "checkout", "--detach", "-q", "HEAD") + snapshot_commit = str(_git(config.worktree, "rev-parse", "HEAD")).strip() + snapshot_tree = str(_git(config.worktree, "rev-parse", "HEAD^{tree}")).strip() + if snapshot_tree != original_tree: + raise RuntimeError(f"snapshot tree mismatch: expected {original_tree}, got {snapshot_tree}") + if str(_git(config.worktree, "status", "--porcelain", "--untracked-files=all")): + raise RuntimeError("fresh task snapshot is not clean") + if str(_git(config.worktree, "rev-list", "--count", "--all")).strip() != "1": + raise RuntimeError("fresh task snapshot contains more than one commit") + return SnapshotProvenance( + original_base_commit=config.base_commit, + original_base_tree=original_tree, + snapshot_commit=snapshot_commit, + snapshot_tree=snapshot_tree, + ) + + +def run_lane( + config: ProLaneConfig, + *, + run_task_fn: RunTask = run_task, +) -> dict[str, Any]: + """Prepare and execute one fixed-contract Pro solver lane.""" + + config = _validate_config(config) + provenance = prepare_repository(config) + prompt = config.prompt_path.read_text(encoding="utf-8") + record = run_task_fn( + RunConfig( + instance_id=config.instance_id, + condition=config.condition, + repetition=1, + worktree=config.worktree, + expected_base_commit=provenance.snapshot_commit, + run_dir=config.run_dir, + prompt=prompt, + codex_executable=config.codex_executable, + auth_source=config.auth_source, + model="gpt-6-astra", + reasoning_effort="medium", + timeout_seconds=900, + codex_version="0.153.4", + ) + ) + provenance_path = config.run_dir / "pro-lane.json" + with provenance_path.open("x", encoding="utf-8") as output: + json.dump(asdict(provenance), output, indent=2, sort_keys=True) + output.write("\n") + return record + + +def _parser() -> argparse.ArgumentParser: + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--instance-id", required=True) + parser.add_argument("--base-commit", required=True) + parser.add_argument("--condition", required=True, choices=sorted(_CONDITIONS)) + return parser + + +def main(argv: Sequence[str] | None = None) -> int: + args = _parser().parse_args(argv) + config = ProLaneConfig( + instance_id=args.instance_id, + base_commit=args.base_commit, + condition=args.condition, + ) + record = run_lane(config) + print( + json.dumps( + { + "instance_id": config.instance_id, + "condition": config.condition, + "run_status": record.get("run_status"), + "run_dir": str(config.run_dir), + }, + sort_keys=True, + ) + ) + return 0 + + +if __name__ == "__main__": + raise SystemExit(main()) diff --git a/benchmark/codex_adapter/hook_config.py b/benchmark/codex_adapter/hook_config.py index 8c6867f..67d2088 100644 --- a/benchmark/codex_adapter/hook_config.py +++ b/benchmark/codex_adapter/hook_config.py @@ -7,24 +7,21 @@ from pathlib import Path -def install_project_hooks( - worktree: str | Path, +def _install_hooks( + config_path: Path, *, python_executable: str | Path, hook_client: str | Path, timeout_seconds: int = 60, ) -> Path: - """Write deterministic synchronous PreToolUse/PostToolUse command hooks.""" - - root = Path(worktree).resolve() python_path = Path(python_executable).resolve() client_path = Path(hook_client).resolve() if isinstance(timeout_seconds, bool) or not isinstance(timeout_seconds, int): raise TypeError("timeout_seconds must be an integer") if timeout_seconds < 1: raise ValueError("timeout_seconds must be positive") - if not root.is_dir(): - raise ValueError(f"worktree is not a directory: {root}") + if not config_path.parent.is_dir(): + raise ValueError(f"hook config directory does not exist: {config_path.parent}") if not python_path.is_file(): raise ValueError(f"Python executable does not exist: {python_path}") if not client_path.is_file(): @@ -50,10 +47,49 @@ def handler(operation: str) -> dict[str, object]: "PostToolUse": [handler("post")], }, } - config_path = root / ".codex" / "hooks.json" config_path.parent.mkdir(parents=True, exist_ok=True) config_path.write_text( json.dumps(config, indent=2, sort_keys=True) + "\n", encoding="utf-8", ) return config_path + + +def install_project_hooks( + worktree: str | Path, + *, + python_executable: str | Path, + hook_client: str | Path, + timeout_seconds: int = 60, +) -> Path: + """Write deterministic synchronous hooks in a project's Codex layer.""" + + root = Path(worktree).resolve() + if not root.is_dir(): + raise ValueError(f"worktree is not a directory: {root}") + config_dir = root / ".codex" + config_dir.mkdir(parents=True, exist_ok=True) + return _install_hooks( + config_dir / "hooks.json", + python_executable=python_executable, + hook_client=hook_client, + timeout_seconds=timeout_seconds, + ) + + +def install_codex_home_hooks( + codex_home: str | Path, + *, + python_executable: str | Path, + hook_client: str | Path, + timeout_seconds: int = 60, +) -> Path: + """Write deterministic synchronous hooks in an isolated Codex home.""" + + config_dir = Path(codex_home).resolve() + return _install_hooks( + config_dir / "hooks.json", + python_executable=python_executable, + hook_client=hook_client, + timeout_seconds=timeout_seconds, + ) diff --git a/benchmark/codex_adapter/runner.py b/benchmark/codex_adapter/runner.py index fa77f35..1d64e3d 100644 --- a/benchmark/codex_adapter/runner.py +++ b/benchmark/codex_adapter/runner.py @@ -18,7 +18,7 @@ from typing import Any from .codex_events import CodexMetrics, EventParseError, parse_codex_jsonl -from .hook_config import install_project_hooks +from .hook_config import install_codex_home_hooks _SOURCE_ROOT = Path(__file__).resolve().parents[2] _HOOK_CLIENT = Path(__file__).resolve().with_name("hook_client.py") @@ -95,34 +95,39 @@ def _toml_inline_table(values: Mapping[str, str]) -> str: def _command(config: RunConfig, shell_environment: Mapping[str, str]) -> list[str]: command = [ str(config.codex_executable), - "exec", - "--ignore-user-config", - "--ignore-rules", - "--ephemeral", - "--json", - "--color", - "never", - "--strict-config", - "--dangerously-bypass-hook-trust", - "-m", - config.model, - "-c", - f'model_reasoning_effort="{config.reasoning_effort}"', - "-c", - "sandbox_workspace_write.network_access=false", - "-c", - 'shell_environment_policy.inherit="none"', - "-c", - "shell_environment_policy.ignore_default_excludes=false", - "-c", - f"shell_environment_policy.set={_toml_inline_table(shell_environment)}", - "-s", - "workspace-write", "-a", "never", - "-C", - str(config.worktree), + "exec", ] + if config.condition == "baseline": + command.append("--ignore-user-config") + command.extend( + [ + "--ignore-rules", + "--ephemeral", + "--json", + "--color", + "never", + "--strict-config", + "--dangerously-bypass-hook-trust", + "-m", + config.model, + "-c", + f'model_reasoning_effort="{config.reasoning_effort}"', + "-c", + "sandbox_workspace_write.network_access=false", + "-c", + 'shell_environment_policy.inherit="none"', + "-c", + "shell_environment_policy.ignore_default_excludes=false", + "-c", + f"shell_environment_policy.set={_toml_inline_table(shell_environment)}", + "-s", + "workspace-write", + "-C", + str(config.worktree), + ] + ) for feature in _FEATURES_DISABLED: command.extend(("--disable", feature)) command.append("-") @@ -381,8 +386,8 @@ def run_task(config: RunConfig) -> dict[str, Any]: try: if config.condition == "marginal": - install_project_hooks( - worktree, + install_codex_home_hooks( + codex_home, python_executable=Path(sys.executable), hook_client=_HOOK_CLIENT, ) @@ -502,7 +507,7 @@ def run_task(config: RunConfig) -> dict[str, Any]: hook_coverage_missing = bool( config.condition == "marginal" and daemon_summary is not None - and int(daemon_summary.get("committed", 0)) != metrics.tool_calls + and int(daemon_summary.get("committed", 0)) != metrics.shell_commands ) if security_violation: run_status = "security_failed" diff --git a/benchmark/container/pro-codex-native-wrapper.sh b/benchmark/container/pro-codex-native-wrapper.sh new file mode 100644 index 0000000..41c6e44 --- /dev/null +++ b/benchmark/container/pro-codex-native-wrapper.sh @@ -0,0 +1,13 @@ +#!/bin/sh +set -eu + +CODEX_PACKAGE_ROOT="${CODEX_PACKAGE_ROOT:-/opt/marginal-tools/lib/codex}" +CODEX_NATIVE_ROOT="${CODEX_PACKAGE_ROOT}/node_modules/@openai/codex-linux-x64/vendor/x86_64-unknown-linux-musl" + +PATH="${CODEX_NATIVE_ROOT}/codex-path:${PATH}" +export PATH +export CODEX_MANAGED_PACKAGE_ROOT="${CODEX_PACKAGE_ROOT}" +unset CODEX_MANAGED_BY_NPM CODEX_MANAGED_BY_BUN CODEX_MANAGED_BY_PNPM CODEX_MANAGED_BY_VITE_PLUS +export CODEX_MANAGED_BY_NPM=1 + +exec "${CODEX_NATIVE_ROOT}/bin/codex" "$@" diff --git a/contracts/commons-contract-v1.manifest.json b/contracts/commons-contract-v1.manifest.json index 9da445e..b659b9c 100644 --- a/contracts/commons-contract-v1.manifest.json +++ b/contracts/commons-contract-v1.manifest.json @@ -1,8 +1,8 @@ { "schema_version": "1.0", "sha256": { - "canonical-model-registry-v1.json": "142a8bc5645141f9c467279d6935663b5b11af03092ce4bd493edd42f3278ea6", - "commons-evidence-envelope-v1.json": "7a7601748e94107e5a2ccbf54a376a1d074de48d2f7ddd85dfd2b6b335091277", - "commons-pack-v1.json": "2db170ba822cf2dd2052eddd4e3ac84b5a998922201267f0e9fca9bcb06d8305" + "canonical-model-registry-v1.json": "693c71c28af5cddb3b1ed0d2a979c078f91b0823d7f36c56d726508d253b392d", + "commons-evidence-envelope-v1.json": "ddc26363093c22f5e37c2bcc2a7b4453f37f511b1315a74727e391797584ce7b", + "commons-pack-v1.json": "5ad237c956da4ca5ba62e3c62d6bfc333e26745668486d60fb774eb4a574955b" } } diff --git a/docs/superpowers/plans/2026-09-07-astra-public-benchmark.md b/docs/superpowers/plans/2026-09-07-astra-public-benchmark.md new file mode 100644 index 0000000..d888317 --- /dev/null +++ b/docs/superpowers/plans/2026-09-07-astra-public-benchmark.md @@ -0,0 +1,77 @@ +# Astra compatibility and public benchmark implementation plan + +> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development or superpowers:executing-plans to implement this plan task-by-task. + +**Goal:** Support Astra operational memory and publish a genuine public OFF/ON evaluation. + +**Architecture:** Extend the existing exact model registry and lifecycle evidence path. +Use the existing isolated benchmark scaffold where compatible, with official task grading. +Keep integration tests separate from experimental evidence. + +**Tech Stack:** Python 3.10+, Codex CLI, Docker/Colima, official SWE-bench Pro evaluator. + +**Spec:** docs/superpowers/specs/2026-09-07-astra-public-benchmark-design.md + +## Global Constraints + +- Exact identity: `gpt-6-astra` maps to `openai/gpt-6-astra`; unknown identifiers stay local. +- Preserve local-only defaults, signed Commons trust, and enforcement evidence gates. +- Do not publish credentials, private source, prompts, commands or transcripts as operational memory. +- Benchmark evidence covers public benchmark tasks only, sanitized before publication. +- Reserve 20% of the short quota window; do not redeem resets or purchase compute. +- A partial, failed, or unexecuted benchmark must never be labelled complete or a savings result. + +### Task 1: Astra identity and operational memory + +**Files:** `src/marginal/commons/identity.py`, registry/schema/contract mirrors, +`tests/commons/test_identity.py`, `tests/integrations/codex/test_service.py`, and the +corresponding model contracts in the sibling Commons and Ingress repositories. + +**Interfaces:** Existing `resolve_canonical_model(provider=..., model=...)` returns a +`CanonicalModelIdentity`; lifecycle evidence retains `model_namespace` on decisions/outcomes. + +- [ ] Write a failing resolver test asserting the Astra namespace and rejection of ambiguous variants. + +```python +identity = resolve_canonical_model(provider="openai", model="gpt-6-astra") +assert identity is not None +assert identity.namespace == "openai/gpt-6-astra" +assert resolve_canonical_model(provider="openai", model="gpt-6-astra-private") is None +``` + +- [ ] Run `.venv/bin/pytest tests/commons/test_identity.py -q`; verify the missing identity failure. +- [ ] Add Astra to reviewed registries and strict contract enums without widening unknown identity handling. +- [ ] Exercise real lifecycle pre/post events with Astra and verify model-specific persisted evidence, + mixed-model exclusion, and restart persistence using existing service test fixtures. +- [ ] Run focused Commons and Codex integration tests; regenerate contract digests mechanically. +- [ ] Commit only task-owned source/tests/contracts; leave runtime rebuild to final packaging. + +### Task 2: Real execution and benchmark protocol + +**Files:** `benchmark/astra/` protocol/environment and execution artifacts; runner modules only +where actual preflight identifies a compatibility defect; `tests/benchmark/` regression tests. + +**Interfaces:** Official dataset instance IDs and grader outcomes join one-to-one with measured +Codex usage and intervention records. Missing metrics stay null, never zero by assumption. + +- [ ] Verify Astra on a current available Codex executable with a minimal no-tool request. +- [ ] Start the existing benchmark VM and inventory official image/evaluator availability. +- [ ] Freeze the public dataset/evaluator revisions and full task manifest before inference. +- [ ] For each runner defect, first add a failing regression at the boundary, then implement and test. +- [ ] Publish the protocol commit before scored inference; run an evaluator gold-patch check. +- [ ] Execute independent OFF/ON lanes for every frozen task, recording actual usage and failures. +- [ ] Stop launching work at the reserved quota threshold and report any incompleteness explicitly. + +### Task 3: Analysis, verification and GitHub delivery + +**Files:** benchmark report and sanitized raw artifacts, `README.md`, plugin runtime/provenance. + +**Interfaces:** Complete paired rows feed the existing public comparator; incomplete runs retain +their failure records but produce no headline savings claim. + +- [ ] Verify coverage and provider usage accounting; report correctness, interventions, token and time deltas. +- [ ] Scan public artifacts for secrets/private data and retain only benchmark-scoped evidence. +- [ ] Rebuild with `.venv/bin/python scripts/build_codex_plugin.py` and verify with `--check`. +- [ ] Run `.venv/bin/ruff check .`, `.venv/bin/mypy src/marginal`, and `.venv/bin/pytest -q`. +- [ ] Obtain independent code/claims review, then publish commits and PR with reproducible commands. +- [ ] Report exact shipped functionality, evidence, limits and remaining blockers. diff --git a/docs/superpowers/plans/2026-09-09-marginal-swebench-lite-full.md b/docs/superpowers/plans/2026-09-09-marginal-swebench-lite-full.md new file mode 100644 index 0000000..9eee5d9 --- /dev/null +++ b/docs/superpowers/plans/2026-09-09-marginal-swebench-lite-full.md @@ -0,0 +1,126 @@ +# Marginal SWE-bench Lite Full Benchmark Implementation Plan + +> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking. + +**Goal:** Produce, grade, publish, and submit a complete 300-task paired SWE-bench Lite benchmark. + +**Architecture:** A frozen safe manifest drives an immutable checkpointed schedule. Each OFF/ON +lane runs once in a disposable derivative of the same official image; exporters feed the official +v5 evaluator, paired analysis, public artifact repository, and submission CLI. + +**Tech Stack:** Python 3.10+, Codex CLI 0.153.4, Docker amd64, official SWE-bench v5 CLI, pytest. + +**Spec:** `docs/superpowers/specs/2026-09-09-marginal-swebench-lite-full-design.md` + +## Global Constraints + +- Exactly 300 test tasks and 600 single-attempt lanes; no outcome-based exclusion or retry. +- Zero euros, ChatGPT-authenticated Codex CLI only, no `OPENAI_API_KEY`. +- Never expose benchmark tests, hints, gold data, another lane, auth material, or private reasoning. +- Preserve incomplete attempts and distinguish infrastructure failures from task failures. +- Do not claim completion, savings, submission acceptance, or leaderboard acceptance without evidence. + +--- + +### Task 1: Freeze the full public contract + +**Files:** +- Create: `benchmark/astra/lite/protocol.json` +- Create: `benchmark/astra/lite/task-manifest.jsonl` +- Create: `benchmark/astra/lite/status.json` +- Create: `benchmark/astra/lite/freeze.py` +- Test: `tests/benchmark/test_astra_lite_freeze.py` + +**Interfaces:** +- Produces: `load_safe_manifest(path) -> tuple[LiteTask, ...]` and the exact 300-task schedule. + +- [ ] Write tests that reject fewer than 300 IDs, duplicate IDs, unsafe fields, invalid commits, + altered hashes, and a schedule that does not match the public seed. +- [ ] Run the focused test and verify it fails because the loader is absent. +- [ ] Implement the safe frozen loader/generator; export only identity, repository, base commit, + official image reference, problem hash, and schedule position/condition order. +- [ ] Generate the manifest from the pinned dataset without reading outcome fields into solver data. +- [ ] Verify 300 unique tasks, 600 unique scheduled lanes, JSON validity, Ruff, and focused tests. +- [ ] Commit the frozen contract before any test-split inference. + +### Task 2: Add one generic Lite lane and image + +**Files:** +- Create: `benchmark/astra/lite_lane.py` +- Create: `benchmark/astra/lite/Dockerfile.solver` +- Modify: `benchmark/astra/pro_lane.py` +- Test: `tests/benchmark/test_astra_lite_lane.py` + +**Interfaces:** +- Consumes: `LiteTask` identity/base commit and public rendered prompt. +- Produces: `run_lane(LiteLaneConfig) -> dict[str, object]` plus exact-tree provenance. + +- [ ] Write tests proving classic IDs are accepted, Pro/path traversal IDs are rejected, the + original tree is recreated without future Git history, and OFF/ON pass identical RunConfig. +- [ ] Verify RED, extract the already-tested snapshot logic into a shared internal function, and + keep the Pro lane behavior unchanged. +- [ ] Add the `/testbed` Lite entry point and derivative image using pinned Codex/Python builders. +- [ ] Verify focused Pro and Lite tests, Ruff, and a no-provider exact-tree image smoke. +- [ ] Commit the lane and image. + +### Task 3: Implement immutable campaign resume + +**Files:** +- Create: `benchmark/astra/lite_campaign.py` +- Create: `benchmark/astra/lite/checkpoint.py` +- Test: `tests/benchmark/test_astra_lite_campaign.py` + +**Interfaces:** +- Produces: `init`, `next`, `run --max-lanes N`, `status`, and `export` CLI commands. + +- [ ] Write tests for deterministic ordering, attempt-before-launch, crash preservation, skip of + attempted lanes, quota-stop behavior, exact OFF/ON pairing, and explicit image cleanup targets. +- [ ] Verify RED and implement atomic checkpoint records derived from immutable lane directories. +- [ ] Build/pull one task at a time, pin the resolved image digest, run both scheduled conditions, + then remove only the explicit local overlay/task image after artifacts are durable. +- [ ] Verify no auth marker appears in any public/exportable artifact. +- [ ] Commit the resumable campaign. + +### Task 4: Validate without touching the test score + +**Files:** +- Create: `benchmark/astra/lite/validation.json` +- Modify: `benchmark/astra/lite/status.json` + +- [ ] Freeze one Lite dev ID and build its exact solver image. +- [ ] Run one OFF and one ON validation attempt with ChatGPT authentication. +- [ ] Confirm Codex 0.153.4, Astra identity, token telemetry, trajectory, patch extraction, MARGINAL + coverage, identical base tree, and absence of auth material. +- [ ] Grade both validation patches with the pinned official evaluator and record every outcome. +- [ ] Publish validation evidence as pipeline evidence only; do not tune MARGINAL from task quality. + +### Task 5: Execute and grade all 600 lanes + +**Files:** +- Update: `benchmark/astra/lite/status.json` +- Generate outside Git: immutable raw run root and official evaluation directories. + +- [ ] Run the campaign until account quota exhaustion; preserve the final attempt and stop. +- [ ] Resume after each reset from the first untouched schedule entry. +- [ ] Verify all 300 OFF and 300 ON attempt records exist before export. +- [ ] Export complete prediction JSONL and public trajectories without secrets. +- [ ] Evaluate OFF and ON under distinct run IDs with the official v5 local Docker harness. +- [ ] Verify 300 reports per lane and no missing, duplicate, or silently dropped instance. + +### Task 6: Analyze, publish, and register + +**Files:** +- Create: `benchmark/astra/lite/analyze.py` +- Create: `benchmark/astra/lite/PUBLIC_BENCHMARK.md` +- Modify: `README.md` +- Test: `tests/benchmark/test_astra_lite_analysis.py` + +- [ ] Write literal-fixture tests for the paired table, exact McNemar result, bootstrap seed, + confidence intervals, non-inferiority, intervention metrics, and failure separation. +- [ ] Verify RED, implement analysis, and reproduce every Markdown value from machine JSON. +- [ ] Run `swebench submit package` for the finished ON evaluation and complete all metadata/assets. +- [ ] Run submission dry-runs and local `swebench submit verify`; scan for TODOs and secrets. +- [ ] Publish `SignalLayerLabs/Marginal-SWE-bench-Lite`, then run `submit register` to open the PR. +- [ ] Update Marginal README only with measured results and direct artifact/submission links. +- [ ] Run full tests, Ruff, runtime provenance check, and GitHub CI; commit and push. + diff --git a/docs/superpowers/specs/2026-09-07-astra-public-benchmark-design.md b/docs/superpowers/specs/2026-09-07-astra-public-benchmark-design.md new file mode 100644 index 0000000..47fa1a6 --- /dev/null +++ b/docs/superpowers/specs/2026-09-07-astra-public-benchmark-design.md @@ -0,0 +1,39 @@ +# Astra compatibility and public benchmark + +Approved direction: support GPT-6 Astra, record model-specific operational memory, and +publish an independently regradable, complete public benchmark using existing Codex quota. +No paid infrastructure, purchases, or usage-reset redemption is authorized by this plan. + +## Product + +Resolve the exact public identifier `gpt-6-astra` to `openai/gpt-6-astra`. Keep unknown +models fail-closed and evidence model-specific. Record decisions and outcomes during +operations, not merely in prose at session end. Preserve local-only defaults, privacy +boundaries, signed Commons trust, and all enforcement evidence gates. Never attribute old +unlabelled evidence retroactively to Astra. + +## Evaluation + +User correction, before scored inference: use SWE-bench Pro directly. HumanEval+ preparation +is retained as unexecuted auxiliary infrastructure, not a substitute for repository evidence. +Run a deterministic prefix of the full 731-task order until the quota reserve or an integrity +gate stops execution; publish exact coverage, never call a prefix a complete benchmark. + +Target SWE-bench Pro Public using its official evaluator and pinned dataset and images. +Run identical agent/model/reasoning/prompt/tool/timeout conditions OFF and ON, with +independent task workspaces and memory. Preregister task coverage, configuration, accounting, +failure handling and analysis before inference. Count every task, including failures. +Report quality before token/cost/latency effects and include MARGINAL overhead. Never +claim a partial run is complete, a replay is paired inference, or self-published results +are externally certified. Do not train or tune on scored test outcomes. + +First establish real Astra execution and a working evaluator. Preserve at least 20% +of the short quota window for validation/publication. A quota or infrastructure stop is +a documented incomplete run, not a performance result. No promotion of native enforcement +without earned evidence; an explicit experimental intervention is labelled separately. + +## Delivery + +Publish code, tests, protocol, sanitized machine-readable evidence, analysis and reproduction +instructions on GitHub. Preserve negative findings. Release builds must match source and +the latest upstream signed Commons changes. diff --git a/docs/superpowers/specs/2026-09-09-marginal-swebench-lite-full-design.md b/docs/superpowers/specs/2026-09-09-marginal-swebench-lite-full-design.md new file mode 100644 index 0000000..74dd83b --- /dev/null +++ b/docs/superpowers/specs/2026-09-09-marginal-swebench-lite-full-design.md @@ -0,0 +1,95 @@ +# Marginal SWE-bench Lite Full Benchmark Design + +Status: approved by the user mandate dated 2026-09-09. + +## Outcome + +Run every task in the 300-instance SWE-bench Lite test split once with Codex alone and once +with the experimental MARGINAL benchmark adapter. Produce 600 immutable attempts, grade both +prediction sets with the official local Docker harness, publish independently verifiable +artifacts, and open a real Lite submission PR for the ON lane. + +Completion has four distinct states: benchmark complete, submission packaged, submission PR +opened, and leaderboard accepted. Only maintainers can establish the last state. + +## Frozen contract + +- Dataset: `SWE-bench/SWE-bench_Lite`, `test`, repository revision + `b0dde1093fe417d83b7184254edf8199c1f0dff5`, all 300 instances. +- Evaluator: `SWE-bench/SWE-bench` commit + `02e7a74ffd0b707aab73d203fe87bdc7c76afc8e` using its v5 local Docker CLI. +- Product under test: MARGINAL commit `71c8eae` and packaged runtime provenance at that commit. +- Agent: Codex CLI `0.153.4`, model `gpt-6-astra`, reasoning effort `medium`. +- One attempt per condition and task; 900-second model timeout; no hints, gold patches, + `FAIL_TO_PASS`, `PASS_TO_PASS`, or evaluator feedback in inference. +- Prompt: `benchmark/prompt_template.txt`, SHA-256 + `3a2ced1afb7e9a74176090db264259c52b6ebcf383d787a1030f83ecb6d67416`. +- Public randomization seed: + `81b598cbff3bff863cbbb4a3dea1489ce9dd3f2070e6bf766befb25cd436cd9b`. +- Cost: zero euros. Authentication is the existing Codex CLI ChatGPT session. No OpenAI API + key is requested, copied, logged, or published. + +The 300 tasks are ordered by SHA-256 of `seed + NUL + instance_id`. Within each task, the first +condition is selected by the low bit of SHA-256 of `seed + NUL + instance_id + NUL + "condition"`; +the other condition follows. This schedule is committed before test inference. + +## Execution boundary + +Each condition runs in a fresh derivative of the official per-instance Docker image. The common +tooling layer contains Codex 0.153.4, a pinned standalone Python, the product-under-test source, +and the benchmark adapter. The solver receives only the issue text and its one-commit base-tree +snapshot. Git history, benchmark tests, hints, reference patches, the other lane, and prior +artifacts are absent. Tool network access is disabled while Codex transport retains network access. + +OFF uses the same binary, model, prompt, timeout, image, and resource limits with MARGINAL absent. +ON uses the experimental synchronous PreToolUse/PostToolUse adapter in enforce mode. Native plugin +status remains Shadow/L0 and is reported separately; ON is not described as default plugin behavior. + +## Checkpoint and failure semantics + +The orchestrator writes an immutable attempt marker before launching a lane and never overwrites +an existing lane directory. A completed lane contains raw Codex events, stderr, patch, run record, +environment provenance, and ON governance evidence. An interrupted, timed-out, quota-limited, or +failed attempt remains represented with an empty patch when necessary. It is not retried or removed. + +Resume selects only schedule entries with no attempt marker. When Codex reports exhausted account +capacity, execution stops after preserving that attempt. Subsequent invocations continue from the +next untouched entry; no cherry-picking or outcome-dependent ordering is possible. + +The validation phase uses one preregistered Lite `dev` task and is excluded from the 300-task score. +Pipeline fixes may address transport, packaging, telemetry, or evaluator defects, but the MARGINAL +policy cannot be tuned from validation outcomes. + +## Evaluation and analysis + +Export complete OFF and ON `all_preds.jsonl` files, including empty patches. Use distinct evaluator +run IDs and the official Docker harness. Preserve per-instance reports and test output. Separate +task failures from infrastructure failures. + +The report includes resolved counts, absolute and relative deltas, the paired 2x2 table, exact +McNemar analysis, paired bootstrap confidence intervals, preregistered non-inferiority, token, +wall-time and tool-call deltas, intervention and effective-intervention rates, false-stop rate, +governance overhead, repository breakdowns, and timeout/error breakdowns. A token-saving claim is +allowed only if quality and governance tax are reported beside it. + +## Publication and submission + +The Marginal repository publishes the protocol, frozen manifest, runner, validation, status, and +analysis code. Completed public artifacts go to `SignalLayerLabs/Marginal-SWE-bench-Lite` with all +predictions, official logs, patches, reports, compressed test output, and available public Codex +event trajectories. Authentication material and private chain-of-thought are never included. + +Use the current official workflow against the finished ON evaluation directory: + +```sh +swebench submit package --trajs +swebench submit publish -r SignalLayerLabs/Marginal-SWE-bench-Lite +swebench submit verify +swebench submit register +``` + +Complete metadata identifies `Marginal + Codex` as the agent system, GPT-6 Astra as the model, +attempts `1`, SignalLayerLabs as the organization, the public technical report, author Renato +Vinai, source code, exact commits, and experimental governance mode. The PR checklist explicitly +attests no test knowledge, hints, solution lookup, or repeated attempts. + diff --git a/models/canonical-model-registry-v1.json b/models/canonical-model-registry-v1.json index 6f2c530..94f478b 100644 --- a/models/canonical-model-registry-v1.json +++ b/models/canonical-model-registry-v1.json @@ -1,6 +1,7 @@ { "schema_version": "1.0", "models": { + "gpt-6-astra": "openai/gpt-6-astra", "gpt-5.6-sol": "openai/gpt-5.6-sol", "gpt-5.6-terra": "openai/gpt-5.6-terra", "gpt-5.6-luna": "openai/gpt-5.6-luna" diff --git a/plugins/marginal/runtime/marginal_runtime.pyz b/plugins/marginal/runtime/marginal_runtime.pyz index 21ce493..9a42eef 100644 Binary files a/plugins/marginal/runtime/marginal_runtime.pyz and b/plugins/marginal/runtime/marginal_runtime.pyz differ diff --git a/plugins/marginal/runtime/provenance.json b/plugins/marginal/runtime/provenance.json index 74f75bf..1b7fa84 100644 --- a/plugins/marginal/runtime/provenance.json +++ b/plugins/marginal/runtime/provenance.json @@ -1 +1 @@ -{"builder":"scripts/build_codex_plugin.py","python_requires":">=3.10","schema_version":1,"sha256":"650e6eee439a2e1ad5999ded2c019964713eb0d166a40d179f5f470be7cb1842","source_hash":"bf71beb4fa69d0888d5efe077cbcac825e0e5e75d072e5a0243ded690133f285"} +{"builder":"scripts/build_codex_plugin.py","python_requires":">=3.10","schema_version":1,"sha256":"da07e5b564960dbd288e8d39ada481f9549101b0a9ca6629c88033f0e8d908b7","source_hash":"3d55fcb9c1021ebf424f0363f4c69a3574191b572844cd4b075f19b22cf77545"} diff --git a/pyproject.toml b/pyproject.toml index 7cc60ae..a25bb3c 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -57,6 +57,7 @@ dependencies = [] [project.optional-dependencies] dev = [ "build>=1.2.2", + "cryptography>=46.0", "mypy>=1.17", "pytest>=8.3", "PyYAML>=6.0", diff --git a/schemas/commons-evidence-envelope-v1.json b/schemas/commons-evidence-envelope-v1.json index 5711b66..c77101b 100644 --- a/schemas/commons-evidence-envelope-v1.json +++ b/schemas/commons-evidence-envelope-v1.json @@ -8,6 +8,7 @@ "schema_version": {"const": "1.0"}, "model_namespace": { "enum": [ + "openai/gpt-6-astra", "openai/gpt-5.6-sol", "openai/gpt-5.6-terra", "openai/gpt-5.6-luna" diff --git a/schemas/commons-evidence-envelope-v1.sha256 b/schemas/commons-evidence-envelope-v1.sha256 index cfc8703..465e9cf 100644 --- a/schemas/commons-evidence-envelope-v1.sha256 +++ b/schemas/commons-evidence-envelope-v1.sha256 @@ -1 +1 @@ -7a7601748e94107e5a2ccbf54a376a1d074de48d2f7ddd85dfd2b6b335091277 +ddc26363093c22f5e37c2bcc2a7b4453f37f511b1315a74727e391797584ce7b diff --git a/schemas/commons-pack-v1.json b/schemas/commons-pack-v1.json index 49a7394..e021bb5 100644 --- a/schemas/commons-pack-v1.json +++ b/schemas/commons-pack-v1.json @@ -30,6 +30,7 @@ "openai/gpt-5.6-luna" ], "properties": { + "openai/gpt-6-astra": {"$ref": "#/$defs/model"}, "openai/gpt-5.6-sol": {"$ref": "#/$defs/model"}, "openai/gpt-5.6-terra": {"$ref": "#/$defs/model"}, "openai/gpt-5.6-luna": {"$ref": "#/$defs/model"} diff --git a/src/marginal/commons/_storage.py b/src/marginal/commons/_storage.py index 43b9eba..305ded9 100644 --- a/src/marginal/commons/_storage.py +++ b/src/marginal/commons/_storage.py @@ -78,6 +78,41 @@ def _open_lock(directory_descriptor: int, name: str) -> int: raise +def ensure_lock_file_at(directory_descriptor: int, name: str) -> None: + """Create and validate a lock leaf without acquiring its advisory lock.""" + + descriptor = _open_lock(directory_descriptor, name) + os.close(descriptor) + + +@contextmanager +def opened_directory(path: Path, *, create: bool) -> Iterator[int]: + """Hold one validated nofollow directory descriptor without serializing callers.""" + + directory_descriptor = -1 + for _ in range(16): + try: + directory_descriptor = _open_parent_directory(path / ".anchor", create_parents=create) + except FileExistsError: + continue + break + if directory_descriptor < 0: + raise FileExistsError("unable to open concurrently created Commons storage") + primary_error: BaseException | None = None + try: + _validate_directory(directory_descriptor) + yield directory_descriptor + except BaseException as exc: + primary_error = exc + raise + finally: + try: + os.close(directory_descriptor) + except BaseException: + if primary_error is None: + raise + + @contextmanager def locked_directory(path: Path, *, create: bool, lock_name: str) -> Iterator[int]: """Hold one nofollow directory descriptor and an interprocess lock.""" diff --git a/src/marginal/commons/cache.py b/src/marginal/commons/cache.py index 5ba9cef..ad77a88 100644 --- a/src/marginal/commons/cache.py +++ b/src/marginal/commons/cache.py @@ -26,11 +26,12 @@ from .trust import verify_signed_pack _CACHE_NAME = "commons-signed-cache-v1.json" -_MODEL_NAMESPACES = { +_REQUIRED_MODEL_NAMESPACES = { "openai/gpt-5.6-sol", "openai/gpt-5.6-terra", "openai/gpt-5.6-luna", } +_MODEL_NAMESPACES = _REQUIRED_MODEL_NAMESPACES | {"openai/gpt-6-astra"} _MAX_PACK_BYTES = 2 * 1024 * 1024 _MAX_SIGNATURE_BYTES = 64 * 1024 _BASE64URL = re.compile(r"[A-Za-z0-9_-]+\Z") @@ -157,7 +158,11 @@ def _parse_pack(raw: bytes) -> dict[str, Any]: ): raise ValueError("Commons pack is incompatible") models = payload["models"] - if not isinstance(models, dict) or set(models) != _MODEL_NAMESPACES: + if ( + not isinstance(models, dict) + or not _REQUIRED_MODEL_NAMESPACES.issubset(models) + or not set(models).issubset(_MODEL_NAMESPACES) + ): raise ValueError("Commons pack model registry is invalid") for namespace, model in models.items(): if not _exact_keys(model, {"aggregates"}): diff --git a/src/marginal/commons/canonical-model-registry-v1.json b/src/marginal/commons/canonical-model-registry-v1.json index 6f2c530..94f478b 100644 --- a/src/marginal/commons/canonical-model-registry-v1.json +++ b/src/marginal/commons/canonical-model-registry-v1.json @@ -1,6 +1,7 @@ { "schema_version": "1.0", "models": { + "gpt-6-astra": "openai/gpt-6-astra", "gpt-5.6-sol": "openai/gpt-5.6-sol", "gpt-5.6-terra": "openai/gpt-5.6-terra", "gpt-5.6-luna": "openai/gpt-5.6-luna" diff --git a/src/marginal/commons/identity.py b/src/marginal/commons/identity.py index dacbbde..a2cff37 100644 --- a/src/marginal/commons/identity.py +++ b/src/marginal/commons/identity.py @@ -9,6 +9,7 @@ from typing import Any _REVIEWED_MODELS = { + "gpt-6-astra": "openai/gpt-6-astra", "gpt-5.6-sol": "openai/gpt-5.6-sol", "gpt-5.6-terra": "openai/gpt-5.6-terra", "gpt-5.6-luna": "openai/gpt-5.6-luna", diff --git a/src/marginal/commons/outbox.py b/src/marginal/commons/outbox.py index 2ab53ad..429e5fb 100644 --- a/src/marginal/commons/outbox.py +++ b/src/marginal/commons/outbox.py @@ -11,7 +11,13 @@ from pathlib import Path from typing import Any, cast -from ._storage import atomic_create_at, locked_directory, read_bounded_at +from ._storage import ( + atomic_create_at, + ensure_lock_file_at, + locked_directory, + opened_directory, + read_bounded_at, +) from .evidence import ( ActionKind, AggregateReasonCode, @@ -252,7 +258,14 @@ def enqueue( ).encode("utf-8") if len(encoded) > _MAX_QUEUE_BYTES: return None - with locked_directory(self.queue_path, create=True, lock_name=".outbox.lock") as directory: + directory_context = ( + locked_directory(self.queue_path, create=True, lock_name=".outbox.lock") + if export_receipt is not None + else opened_directory(self.queue_path, create=True) + ) + with directory_context as directory: + if export_receipt is None: + ensure_lock_file_at(directory, ".outbox.lock") if export_receipt is not None: for existing_name in os.listdir(directory): if existing_name.startswith("."): diff --git a/src/marginal/schemas/commons-evidence-envelope-v1.json b/src/marginal/schemas/commons-evidence-envelope-v1.json index 5711b66..c77101b 100644 --- a/src/marginal/schemas/commons-evidence-envelope-v1.json +++ b/src/marginal/schemas/commons-evidence-envelope-v1.json @@ -8,6 +8,7 @@ "schema_version": {"const": "1.0"}, "model_namespace": { "enum": [ + "openai/gpt-6-astra", "openai/gpt-5.6-sol", "openai/gpt-5.6-terra", "openai/gpt-5.6-luna" diff --git a/src/marginal/schemas/commons-pack-v1.json b/src/marginal/schemas/commons-pack-v1.json index 49a7394..e021bb5 100644 --- a/src/marginal/schemas/commons-pack-v1.json +++ b/src/marginal/schemas/commons-pack-v1.json @@ -30,6 +30,7 @@ "openai/gpt-5.6-luna" ], "properties": { + "openai/gpt-6-astra": {"$ref": "#/$defs/model"}, "openai/gpt-5.6-sol": {"$ref": "#/$defs/model"}, "openai/gpt-5.6-terra": {"$ref": "#/$defs/model"}, "openai/gpt-5.6-luna": {"$ref": "#/$defs/model"} diff --git a/tests/benchmark/test_astra_humaneval_runner.py b/tests/benchmark/test_astra_humaneval_runner.py new file mode 100644 index 0000000..3cbf14d --- /dev/null +++ b/tests/benchmark/test_astra_humaneval_runner.py @@ -0,0 +1,346 @@ +from __future__ import annotations + +import hashlib +import json +import subprocess +import threading +from pathlib import Path + +import pytest +from benchmark.astra.humaneval_runner import ( + BenchmarkConfig, + TaskInputError, + load_tasks, + run_benchmark, +) +from benchmark.codex_adapter.runner import RunConfig + + +def _write_tasks(path: Path, *, count: int = 164) -> None: + rows = [ + { + "task_id": f"HumanEval/{index}", + "prompt": f'def function_{index}():\n """Return {index}."""\n', + "entry_point": f"function_{index}", + } + for index in range(count) + ] + path.write_text( + "".join(json.dumps(row, sort_keys=True) + "\n" for row in rows), encoding="utf-8" + ) + + +def _config(tmp_path: Path, *, maximum_new_lanes: int | None = None) -> BenchmarkConfig: + tasks_path = tmp_path / "tasks.jsonl" + _write_tasks(tasks_path) + protocol_path = tmp_path / "protocol.md" + protocol_path.write_text( + json.dumps( + { + "dataset": "FixtureEval+", + "dataset_version": "v-test", + "task_inputs_sha256": hashlib.sha256(tasks_path.read_bytes()).hexdigest(), + } + ) + + "\n", + encoding="utf-8", + ) + executable = tmp_path / "codex" + executable.write_text("fixture\n", encoding="utf-8") + auth = tmp_path / "auth.json" + auth.write_text("{}\n", encoding="utf-8") + return BenchmarkConfig( + tasks_path=tasks_path, + protocol_path=protocol_path, + protocol_sha256=hashlib.sha256(protocol_path.read_bytes()).hexdigest(), + run_root=tmp_path / "runs", + codex_executable=executable, + auth_source=auth, + model="gpt-6-astra", + reasoning_effort="low", + codex_version="0.153.4", + maximum_new_lanes=maximum_new_lanes, + ) + + +def _record(config: RunConfig, *, tokens: int | None = 12) -> dict[str, object]: + return { + "schema_version": 1, + "instance_id": config.instance_id, + "condition": config.condition, + "repetition": 1, + "run_status": "completed", + "resolved": None, + "configuration_sha256": "a" * 64, + "patch_sha256": "b" * 64, + "tokens": { + "input": tokens, + "cached_input": 0 if tokens is not None else None, + "output": 1 if tokens is not None else None, + "reasoning": 0 if tokens is not None else None, + "total": tokens, + }, + "wall_time_ms": 1, + "tool_calls": 0, + "shell_commands": 0, + "file_operations": 1, + "searches": 0, + "test_executions": 0, + "repeated_calls": 0, + "files_modified": 1, + "diff_lines": 2, + "model_reroutes": None, + "interventions": { + "recommended_denies": 0, + "applied_denies": 0, + "reviewed": 0, + "false_stops": 0, + }, + "governance": {"tokens": 0, "usd": 0.0, "latency_ms": 0.0}, + "error_code": None, + } + + +def _git(repo: Path, *args: str) -> str: + return subprocess.run( + ["git", *args], cwd=repo, check=True, capture_output=True, text=True + ).stdout.strip() + + +def test_load_tasks_accepts_only_the_unique_full_humaneval_plus_id_set(tmp_path: Path) -> None: + tasks_path = tmp_path / "tasks.jsonl" + _write_tasks(tasks_path) + + tasks = load_tasks(tasks_path) + + assert len(tasks) == 164 + assert [task.task_id for task in tasks[:4]] == [ + "HumanEval/145", + "HumanEval/91", + "HumanEval/84", + "HumanEval/85", + ] + + +@pytest.mark.parametrize( + "mutation", + ["duplicate", "missing", "out-of-range", "grading-field"], +) +def test_load_tasks_rejects_nonpublic_or_nonfull_inputs(tmp_path: Path, mutation: str) -> None: + tasks_path = tmp_path / "tasks.jsonl" + _write_tasks(tasks_path) + rows = [json.loads(line) for line in tasks_path.read_text(encoding="utf-8").splitlines()] + if mutation == "duplicate": + rows[-1]["task_id"] = "HumanEval/0" + elif mutation == "missing": + rows.pop() + elif mutation == "out-of-range": + rows[-1]["task_id"] = "HumanEval/164" + else: + rows[0]["canonical_solution"] = "return 0" + tasks_path.write_text("".join(json.dumps(row) + "\n" for row in rows), encoding="utf-8") + + with pytest.raises(TaskInputError): + load_tasks(tasks_path) + + +def test_bounded_run_creates_independent_detached_lanes_in_frozen_order(tmp_path: Path) -> None: + config = _config(tmp_path, maximum_new_lanes=2) + observed: list[tuple[str, str, str, str]] = [] + lock = threading.Lock() + + def fake_run_task(run_config: RunConfig) -> dict[str, object]: + files = sorted(path.name for path in run_config.worktree.iterdir() if path.name != ".git") + assert files == ["solution.py"] + assert _git(run_config.worktree, "rev-parse", "--abbrev-ref", "HEAD") == "HEAD" + assert _git(run_config.worktree, "status", "--porcelain") == "" + initial = (run_config.worktree / "solution.py").read_text(encoding="utf-8") + assert initial.endswith(' """Return 145."""\n pass\n') + assert run_config.model == "gpt-6-astra" + assert run_config.reasoning_effort == "low" + assert run_config.codex_version == "0.153.4" + assert run_config.timeout_seconds == 180 + with lock: + observed.append( + ( + run_config.instance_id, + run_config.condition, + str(run_config.worktree), + run_config.prompt, + ) + ) + (run_config.worktree / "solution.py").write_text( + initial.replace(" pass\n", " return 145\n"), encoding="utf-8" + ) + return _record(run_config) + + summary = run_benchmark(config, run_task_fn=fake_run_task) + + assert summary["launched"] == ["HumanEval/145:off", "HumanEval/145:on"] + assert summary["benchmark"] == "FixtureEval+ v-test" + assert {(row[0], row[1]) for row in observed} == { + ("HumanEval/145", "baseline"), + ("HumanEval/145", "marginal"), + } + assert len({row[2] for row in observed}) == 2 + assert len({row[3] for row in observed}) == 1 + assert summary["complete"] is False + assert summary["recorded_lanes"] == 2 + assert summary["pending_lanes"] == 326 + assert summary["missing_telemetry_lanes"] == [] + for lane in ("off", "on"): + lane_dir = config.run_root / "lanes" / "HumanEval_145" / lane + assert (lane_dir / "solution.py").read_text(encoding="utf-8").endswith(" return 145\n") + assert json.loads((lane_dir / "run" / "run-record.json").read_text())["resolved"] is None + manifest = json.loads((lane_dir / "lane-manifest.json").read_text()) + assert manifest["task_id"] == "HumanEval/145" + assert manifest["lane"] == lane + off_samples = [ + json.loads(line) + for line in (config.run_root / "samples" / "off.jsonl") + .read_text(encoding="utf-8") + .splitlines() + ] + assert off_samples == [ + { + "task_id": "HumanEval/145", + "solution": 'def function_145():\n """Return 145."""\n return 145\n', + } + ] + + +def test_resume_trusts_matching_records_without_reexecution_and_blocks_hash_drift( + tmp_path: Path, +) -> None: + config = _config(tmp_path, maximum_new_lanes=1) + calls: list[str] = [] + + def fake_run_task(run_config: RunConfig) -> dict[str, object]: + calls.append(f"{run_config.instance_id}:{run_config.condition}") + source = (run_config.worktree / "solution.py").read_text(encoding="utf-8") + (run_config.worktree / "solution.py").write_text( + source.replace(" pass\n", " return 1\n"), encoding="utf-8" + ) + return _record(run_config) + + first = run_benchmark(config, run_task_fn=fake_run_task) + second = run_benchmark(config, run_task_fn=fake_run_task) + + assert first["launched"] == ["HumanEval/145:off"] + assert second["resumed"] == ["HumanEval/145:off"] + assert second["launched"] == ["HumanEval/145:on"] + assert calls == ["HumanEval/145:baseline", "HumanEval/145:marginal"] + + protocol = json.loads(config.protocol_path.read_text(encoding="utf-8")) + protocol["experiment"] = "changed-protocol" + config.protocol_path.write_text(json.dumps(protocol) + "\n", encoding="utf-8") + changed = BenchmarkConfig( + **{ + **config.as_kwargs(), + "protocol_sha256": hashlib.sha256(config.protocol_path.read_bytes()).hexdigest(), + } + ) + drift = run_benchmark(changed, run_task_fn=fake_run_task) + + assert drift["launched"] == [] + assert drift["hash_mismatch_lanes"] == ["HumanEval/145:off", "HumanEval/145:on"] + assert drift["complete"] is False + assert calls == ["HumanEval/145:baseline", "HumanEval/145:marginal"] + + +def test_protocol_must_bind_the_exact_task_only_input_before_creating_run_root( + tmp_path: Path, +) -> None: + config = _config(tmp_path, maximum_new_lanes=1) + protocol = json.loads(config.protocol_path.read_text(encoding="utf-8")) + protocol["task_inputs_sha256"] = "0" * 64 + config.protocol_path.write_text(json.dumps(protocol) + "\n", encoding="utf-8") + mismatched = BenchmarkConfig( + **{ + **config.as_kwargs(), + "protocol_sha256": hashlib.sha256(config.protocol_path.read_bytes()).hexdigest(), + } + ) + + with pytest.raises(ValueError, match="task input SHA256"): + run_benchmark(mismatched) + + assert not config.run_root.exists() + + +def test_partial_lane_is_retained_diagnosed_and_blocks_new_launches(tmp_path: Path) -> None: + config = _config(tmp_path, maximum_new_lanes=2) + partial = config.run_root / "lanes" / "HumanEval_145" / "off" + partial.mkdir(parents=True) + marker = partial / "keep-me" + marker.write_text("partial\n", encoding="utf-8") + + def unexpected_run(_: RunConfig) -> dict[str, object]: + raise AssertionError("a partial run root must block new launches") + + summary = run_benchmark(config, run_task_fn=unexpected_run) + + assert summary["partial_lanes"] == ["HumanEval/145:off"] + assert summary["launched"] == [] + assert summary["complete"] is False + assert marker.read_text(encoding="utf-8") == "partial\n" + + +def test_recorded_lane_with_missing_usage_remains_truthfully_incomplete(tmp_path: Path) -> None: + config = _config(tmp_path, maximum_new_lanes=1) + + def missing_usage(run_config: RunConfig) -> dict[str, object]: + source = (run_config.worktree / "solution.py").read_text(encoding="utf-8") + (run_config.worktree / "solution.py").write_text( + source.replace(" pass\n", " return None\n"), encoding="utf-8" + ) + return _record(run_config, tokens=None) + + summary = run_benchmark(config, run_task_fn=missing_usage) + + assert summary["recorded_lanes"] == 1 + assert summary["missing_telemetry_lanes"] == ["HumanEval/145:off"] + assert summary["complete"] is False + + +def test_failure_stops_queued_lanes_and_blocks_new_work_on_resume(tmp_path: Path) -> None: + config = _config(tmp_path, maximum_new_lanes=5) + calls: list[str] = [] + + def missing_usage(run_config: RunConfig) -> dict[str, object]: + calls.append(f"{run_config.instance_id}:{run_config.condition}") + return _record(run_config, tokens=None) + + first = run_benchmark(config, run_task_fn=missing_usage) + + assert first["launched"] == ["HumanEval/145:off", "HumanEval/145:on"] + assert len(calls) == config.lane_concurrency + assert first["stop_rule_lanes"] == ["HumanEval/145:off", "HumanEval/145:on"] + + def unexpected_run(_: RunConfig) -> dict[str, object]: + raise AssertionError("failed resumed lanes must block new work") + + resumed = run_benchmark(config, run_task_fn=unexpected_run) + + assert resumed["launched"] == [] + assert resumed["stop_rule_lanes"] == ["HumanEval/145:off", "HumanEval/145:on"] + + +def test_recorded_hook_failure_is_not_misreported_as_missing_usage(tmp_path: Path) -> None: + config = _config(tmp_path, maximum_new_lanes=1) + + def hook_failure(run_config: RunConfig) -> dict[str, object]: + source = (run_config.worktree / "solution.py").read_text(encoding="utf-8") + (run_config.worktree / "solution.py").write_text( + source.replace(" pass\n", " return None\n"), encoding="utf-8" + ) + record = _record(run_config) + record["run_status"] = "integration_failed" + record["error_code"] = "HOOK_FAILURE" + return record + + summary = run_benchmark(config, run_task_fn=hook_failure) + + assert summary["failed_lanes"] == ["HumanEval/145:off"] + assert summary["missing_telemetry_lanes"] == [] + assert summary["complete"] is False diff --git a/tests/benchmark/test_astra_pro_lane.py b/tests/benchmark/test_astra_pro_lane.py new file mode 100644 index 0000000..7b2e69a --- /dev/null +++ b/tests/benchmark/test_astra_pro_lane.py @@ -0,0 +1,203 @@ +from __future__ import annotations + +import json +import subprocess +from dataclasses import replace +from pathlib import Path + +import pytest +from benchmark.astra.pro_lane import ProLaneConfig, _validate_config, prepare_repository, run_lane +from benchmark.codex_adapter.runner import RunConfig + + +def _git(repo: Path, *args: str, check: bool = True) -> str: + return subprocess.run( + ["git", *args], + cwd=repo, + check=check, + capture_output=True, + text=True, + ).stdout.strip() + + +def _git_result(repo: Path, *args: str) -> subprocess.CompletedProcess[str]: + return subprocess.run(["git", *args], cwd=repo, check=False, capture_output=True, text=True) + + +def _repository(tmp_path: Path) -> tuple[Path, str, str]: + repo = tmp_path / "app" + repo.mkdir() + _git(repo, "init", "-q") + _git(repo, "config", "user.name", "Pro lane fixture") + _git(repo, "config", "user.email", "fixture@example.invalid") + (repo / ".gitignore").write_text(".deps/\n", encoding="utf-8") + (repo / "base.py").write_text("BASE = True\n", encoding="utf-8") + (repo / ".deps").mkdir() + (repo / ".deps" / "tracked.txt").write_text("tracked base file\n", encoding="utf-8") + _git(repo, "add", ".gitignore", "base.py") + _git(repo, "add", "-f", ".deps/tracked.txt") + _git(repo, "commit", "-qm", "base") + base_commit = _git(repo, "rev-parse", "HEAD") + (repo / ".deps" / "installed.txt").write_text("keep me\n", encoding="utf-8") + (repo / ".deps" / "nested" / ".git" / "objects").mkdir(parents=True) + (repo / ".deps" / "nested" / ".git" / "HEAD").write_text( + "ref: refs/heads/future\n", encoding="utf-8" + ) + (repo / "base.py").write_text("BASE = False\n", encoding="utf-8") + (repo / "future.py").write_text("SECRET = True\n", encoding="utf-8") + _git(repo, "add", "base.py", "future.py") + _git(repo, "commit", "-qm", "future") + return repo, base_commit, _git(repo, "rev-parse", "HEAD") + + +def _config(tmp_path: Path, repo: Path, base_commit: str) -> ProLaneConfig: + prompt = tmp_path / "prompt.txt" + prompt.write_text("Fix only the public issue.\n", encoding="utf-8") + auth = tmp_path / "auth.json" + auth.write_text("{}\n", encoding="utf-8") + codex = tmp_path / "codex" + codex.write_text("fixture\n", encoding="utf-8") + return ProLaneConfig( + instance_id="instance_protonmail__webclients-01ea5214d11e0df8b7170d91bafd34f23cb0f2b1", + base_commit=base_commit, + condition="marginal", + worktree=repo, + prompt_path=prompt, + run_dir=tmp_path / "output" / "lane", + codex_executable=codex, + auth_source=auth, + ) + + +def test_prepare_repository_keeps_only_the_base_tree_and_ignored_dependencies( + tmp_path: Path, +) -> None: + repo, base_commit, future_commit = _repository(tmp_path) + config = _config(tmp_path, repo, base_commit) + original_tree = _git(repo, "rev-parse", f"{base_commit}^{{tree}}") + + provenance = prepare_repository(config) + + assert (repo / "base.py").read_text(encoding="utf-8") == "BASE = True\n" + assert (repo / ".deps" / "tracked.txt").read_text(encoding="utf-8") == "tracked base file\n" + assert not (repo / "future.py").exists() + assert (repo / ".deps" / "installed.txt").read_text(encoding="utf-8") == "keep me\n" + assert _git_result(repo, "ls-files", "--error-unmatch", ".deps/installed.txt").returncode != 0 + assert not (repo / ".deps" / "nested" / ".git").exists() + assert _git(repo, "status", "--porcelain", "--untracked-files=all") == "" + assert _git(repo, "rev-parse", "--abbrev-ref", "HEAD") == "HEAD" + assert _git(repo, "rev-list", "--count", "--all") == "1" + assert _git_result(repo, "cat-file", "-e", f"{future_commit}^{{commit}}").returncode != 0 + assert provenance.original_base_commit == base_commit + assert provenance.original_base_tree == original_tree + assert provenance.snapshot_commit == _git(repo, "rev-parse", "HEAD") + assert provenance.snapshot_tree == original_tree + + +def test_base_gitlink_is_rejected_before_any_repository_mutation(tmp_path: Path) -> None: + repo, _base_commit, _future_commit = _repository(tmp_path) + linked_commit = _git(repo, "rev-parse", "HEAD") + _git(repo, "update-index", "--add", "--cacheinfo", f"160000,{linked_commit},vendor/sub") + _git(repo, "commit", "-qm", "add gitlink") + gitlink_base = _git(repo, "rev-parse", "HEAD") + nested_git = repo / "vendor" / "sub" / ".git" + nested_git.mkdir(parents=True) + (nested_git / "HEAD").write_text("future history\n", encoding="utf-8") + config = _config(tmp_path, repo, gitlink_base) + + with pytest.raises(ValueError, match="gitlink"): + prepare_repository(config) + + assert _git(repo, "rev-parse", "HEAD") == gitlink_base + assert nested_git.is_dir() + + +@pytest.mark.parametrize( + ("mutation", "message"), + [ + (lambda config: replace(config, instance_id="../escape"), "instance_id"), + (lambda config: replace(config, base_commit="A" * 40), "base_commit"), + (lambda config: replace(config, prompt_path=Path("prompt.txt")), "absolute"), + ], +) +def test_invalid_public_inputs_are_rejected_before_repository_mutation( + tmp_path: Path, + mutation: object, + message: str, +) -> None: + repo, base_commit, future_commit = _repository(tmp_path) + config = mutation(_config(tmp_path, repo, base_commit)) # type: ignore[operator] + + with pytest.raises(ValueError, match=message): + prepare_repository(config) + + assert _git(repo, "rev-parse", "HEAD") == future_commit + assert (repo / "future.py").is_file() + + +def test_existing_run_directory_is_rejected_before_repository_mutation(tmp_path: Path) -> None: + repo, base_commit, future_commit = _repository(tmp_path) + config = _config(tmp_path, repo, base_commit) + config.run_dir.mkdir(parents=True) + (config.run_dir / "existing.json").write_text("do not overwrite\n", encoding="utf-8") + + with pytest.raises(FileExistsError, match="run directory"): + run_lane(config, run_task_fn=lambda _: {}) + + assert _git(repo, "rev-parse", "HEAD") == future_commit + assert (config.run_dir / "existing.json").read_text(encoding="utf-8") == "do not overwrite\n" + + +def test_run_lane_forwards_fixed_solver_contract_and_records_hashes(tmp_path: Path) -> None: + repo, base_commit, _future_commit = _repository(tmp_path) + config = _config(tmp_path, repo, base_commit) + observed: list[RunConfig] = [] + + def fake_run_task(run_config: RunConfig) -> dict[str, object]: + observed.append(run_config) + run_config.run_dir.mkdir(parents=True) + return {"run_status": "completed", "instance_id": run_config.instance_id} + + record = run_lane(config, run_task_fn=fake_run_task) + + assert record == { + "run_status": "completed", + "instance_id": "instance_protonmail__webclients-01ea5214d11e0df8b7170d91bafd34f23cb0f2b1", + } + assert len(observed) == 1 + forwarded = observed[0] + assert forwarded.instance_id == ( + "instance_protonmail__webclients-01ea5214d11e0df8b7170d91bafd34f23cb0f2b1" + ) + assert forwarded.condition == "marginal" + assert forwarded.repetition == 1 + assert forwarded.worktree == repo.resolve() + assert forwarded.expected_base_commit == _git(repo, "rev-parse", "HEAD") + assert forwarded.run_dir == config.run_dir.resolve() + assert forwarded.prompt == "Fix only the public issue.\n" + assert forwarded.codex_executable == config.codex_executable + assert forwarded.auth_source == config.auth_source + assert forwarded.model == "gpt-6-astra" + assert forwarded.reasoning_effort == "medium" + assert forwarded.timeout_seconds == 900 + assert forwarded.codex_version == "0.153.4" + provenance = json.loads((config.run_dir / "pro-lane.json").read_text(encoding="utf-8")) + assert provenance["original_base_commit"] == base_commit + assert provenance["snapshot_commit"] == forwarded.expected_base_commit + assert provenance["original_base_tree"] == provenance["snapshot_tree"] + + +def test_manifest_instance_ids_are_accepted_and_unsafe_ids_are_rejected(tmp_path: Path) -> None: + repo, base_commit, _future_commit = _repository(tmp_path) + config = _config(tmp_path, repo, base_commit) + manifest = ( + Path(__file__).resolve().parents[2] / "benchmark" / "astra" / "pro" / "task-manifest.jsonl" + ) + instance_ids = [json.loads(line)["instance_id"] for line in manifest.read_text().splitlines()] + + for instance_id in instance_ids: + _validate_config(replace(config, instance_id=instance_id)) + + for instance_id in ("", "../escape", "instance_foo__bar-abc def", " instance_foo__bar-abc"): + with pytest.raises(ValueError, match="instance_id"): + _validate_config(replace(config, instance_id=instance_id)) diff --git a/tests/benchmark/test_astra_pro_solver.py b/tests/benchmark/test_astra_pro_solver.py new file mode 100644 index 0000000..a5288d4 --- /dev/null +++ b/tests/benchmark/test_astra_pro_solver.py @@ -0,0 +1,56 @@ +from __future__ import annotations + +import os +import subprocess +from pathlib import Path + + +def test_pro_launcher_executes_packaged_native_codex_with_vendor_environment( + tmp_path: Path, +) -> None: + package_root = tmp_path / "codex" + target_root = ( + package_root + / "node_modules" + / "@openai" + / "codex-linux-x64" + / "vendor" + / "x86_64-unknown-linux-musl" + ) + native_codex = target_root / "bin" / "codex" + vendor_rg = target_root / "codex-path" / "rg" + native_codex.parent.mkdir(parents=True) + vendor_rg.parent.mkdir(parents=True) + native_codex.write_text( + "#!/bin/sh\n" + "set -eu\n" + 'test "$1" = --version\n' + 'test "$(command -v rg)" = "$CODEX_TEST_EXPECTED_RG"\n' + 'test "$CODEX_MANAGED_PACKAGE_ROOT" = "$CODEX_TEST_EXPECTED_ROOT"\n' + 'test "$CODEX_MANAGED_BY_NPM" = 1\n' + 'test "${CODEX_MANAGED_BY_BUN-unset}" = unset\n' + "printf 'codex 0.153.4\\n'\n", + encoding="utf-8", + ) + vendor_rg.write_text("#!/bin/sh\nexit 0\n", encoding="utf-8") + native_codex.chmod(0o755) + vendor_rg.chmod(0o755) + launcher = Path("benchmark/container/pro-codex-native-wrapper.sh") + environment = { + **os.environ, + "CODEX_PACKAGE_ROOT": str(package_root), + "CODEX_TEST_EXPECTED_RG": str(vendor_rg), + "CODEX_TEST_EXPECTED_ROOT": str(package_root), + "CODEX_MANAGED_BY_BUN": "stale", + } + + completed = subprocess.run( + ["/bin/sh", str(launcher), "--version"], + check=False, + capture_output=True, + text=True, + env=environment, + ) + + assert completed.returncode == 0, completed.stderr + assert completed.stdout == "codex 0.153.4\n" diff --git a/tests/benchmark/test_codex_runner.py b/tests/benchmark/test_codex_runner.py index 22580cf..c8fd176 100644 --- a/tests/benchmark/test_codex_runner.py +++ b/tests/benchmark/test_codex_runner.py @@ -52,6 +52,7 @@ def _fake_codex(tmp_path: Path) -> Path: "args": sys.argv[1:], "prompt": prompt, "has_hooks": Path(".codex/hooks.json").is_file(), + "has_home_hooks": (Path(os.environ["CODEX_HOME"]) / "hooks.json").is_file(), "has_socket_env": "MARGINAL_SOCKET" in os.environ, "home": os.environ.get("HOME"), "codex_home": os.environ.get("CODEX_HOME"), @@ -84,6 +85,16 @@ def _fake_codex(tmp_path: Path) -> Path: "status": "completed", }, })) + if os.environ.get("FAKE_FILE_EVENT") == "1": + print(json.dumps({ + "type": "item.completed", + "item": { + "id": "item-file", + "type": "file_change", + "changes": [{"path": "solution.py", "kind": "update"}], + "status": "completed", + }, + })) print(json.dumps({ "type": "turn.completed", "usage": { @@ -162,6 +173,7 @@ def test_off_has_no_marginal_process_hook_state_or_environment(tmp_path: Path) - assert observed["has_socket_env"] is False assert observed["home"] != os.environ.get("HOME") assert observed["codex_home"] != observed["home"] + assert observed["args"][:3] == ["-a", "never", "exec"] assert 'shell_environment_policy.inherit="none"' in observed["args"] assert not (config.worktree / ".codex").exists() schema = json.loads( @@ -172,7 +184,7 @@ def test_off_has_no_marginal_process_hook_state_or_environment(tmp_path: Path) - Draft202012Validator(schema).validate(record) -def test_on_starts_daemon_and_loads_only_generated_project_hooks(tmp_path: Path) -> None: +def test_on_starts_daemon_and_loads_only_generated_isolated_home_hooks(tmp_path: Path) -> None: log = tmp_path / "marginal-log.json" config = _config(tmp_path, condition="marginal", extra_env={"FAKE_CODEX_LOG": str(log)}) @@ -180,14 +192,31 @@ def test_on_starts_daemon_and_loads_only_generated_project_hooks(tmp_path: Path) observed = json.loads(log.read_text(encoding="utf-8")) assert record["run_status"] == "completed" - assert observed["has_hooks"] is True + assert observed["has_hooks"] is False + assert observed["has_home_hooks"] is True assert observed["has_socket_env"] is True - assert (config.worktree / ".codex" / "hooks.json").is_file() + assert "--ignore-user-config" not in observed["args"] + assert not (config.worktree / ".codex").exists() assert record["governance"]["tokens"] == 0 assert record["files_modified"] == 1 assert ".codex" not in (config.run_dir / "model.patch").read_text(encoding="utf-8") +def test_on_hook_coverage_counts_only_cli_tool_types_supported_by_hooks(tmp_path: Path) -> None: + log = tmp_path / "marginal-log.json" + config = _config( + tmp_path, + condition="marginal", + extra_env={"FAKE_CODEX_LOG": str(log), "FAKE_FILE_EVENT": "1"}, + ) + + record = run_task(config) + + assert record["tool_calls"] == 1 + assert record["shell_commands"] == 0 + assert record["run_status"] == "completed" + + def test_on_fails_if_codex_reports_tool_use_without_hook_coverage(tmp_path: Path) -> None: log = tmp_path / "marginal-log.json" config = _config( diff --git a/tests/commons/test_cache.py b/tests/commons/test_cache.py index 02c71fe..02a5015 100644 --- a/tests/commons/test_cache.py +++ b/tests/commons/test_cache.py @@ -42,6 +42,7 @@ def _pack_bytes( source_commit: str = SOURCE_COMMIT, revision: int = 1, compatibility: str = "1.0", + include_astra: bool = True, extra: tuple[str, object] | None = None, ) -> bytes: payload: dict[str, object] = { @@ -50,11 +51,16 @@ def _pack_bytes( "commons_revision": revision, "compatibility": {"evidence_envelope_schema_version": compatibility}, "models": { + "openai/gpt-6-astra": {"aggregates": []}, "openai/gpt-5.6-sol": {"aggregates": [_aggregate(count=count)]}, "openai/gpt-5.6-terra": {"aggregates": []}, "openai/gpt-5.6-luna": {"aggregates": []}, }, } + if not include_astra: + models = payload["models"] + assert isinstance(models, dict) + models.pop("openai/gpt-6-astra") if extra is not None: payload[extra[0]] = extra[1] canonical = json.dumps( @@ -94,6 +100,13 @@ def test_refresh_loads_only_the_selected_model_from_a_canonical_pack(tmp_path: P assert stat.S_IMODE(cache.path.stat().st_mode) == 0o600 +def test_refresh_preserves_compatibility_with_a_signed_pre_astra_pack(tmp_path: Path) -> None: + cache = _cache(tmp_path) + + assert cache.refresh(signed_download(_pack_bytes(include_astra=False))) is True + assert [prior.count for prior in cache.load_prior()] == [7] + + @pytest.mark.parametrize( "candidate", [ diff --git a/tests/commons/test_identity.py b/tests/commons/test_identity.py index b86e24c..9ecaf61 100644 --- a/tests/commons/test_identity.py +++ b/tests/commons/test_identity.py @@ -12,6 +12,7 @@ ) REVIEWED = { + "gpt-6-astra": "openai/gpt-6-astra", "gpt-5.6-sol": "openai/gpt-5.6-sol", "gpt-5.6-terra": "openai/gpt-5.6-terra", "gpt-5.6-luna": "openai/gpt-5.6-luna", @@ -41,7 +42,10 @@ def test_exact_public_registry_match_resolves_an_immutable_identity( ("openai", "gpt-5.6"), ("openai", "gpt-5.6-sol-latest"), ("openai", "gpt-5.6-sol-2026-08-21"), + ("openai", "gpt-6-astra-latest"), + ("openai", "gpt-6-astra-2026-09-07"), ("openai", "ft:gpt-5.6-sol:private"), + ("openai", "ft:gpt-6-astra:private"), ("openai", "private/gpt-5.6-sol"), ("custom", "gpt-5.6-sol"), ], diff --git a/tests/commons/test_local_e2e.py b/tests/commons/test_local_e2e.py index 0702b6b..ea1fbed 100644 --- a/tests/commons/test_local_e2e.py +++ b/tests/commons/test_local_e2e.py @@ -25,6 +25,7 @@ _SOURCE_COMMIT = "7347a1b4024329780139d17494430f2ccac94fec" _MODEL_NAMESPACES = ( + "openai/gpt-6-astra", "openai/gpt-5.6-luna", "openai/gpt-5.6-sol", "openai/gpt-5.6-terra", diff --git a/tests/commons/test_outbox.py b/tests/commons/test_outbox.py index 82ccebc..85f359e 100644 --- a/tests/commons/test_outbox.py +++ b/tests/commons/test_outbox.py @@ -279,6 +279,24 @@ def test_outbox_rejects_a_symlinked_queue_directory_without_writing_outside(tmp_ assert list(outside.iterdir()) == [] +@pytest.mark.skipif(os.name == "nt", reason="POSIX advisory locks are required") +def test_atomic_enqueue_does_not_contend_on_the_outbox_scan_lock(tmp_path: Path) -> None: + import fcntl + + outbox = CommonsOutbox(tmp_path) + assert outbox.enqueue(batch=_batch()) is not None + assert len(outbox.pending(limit=1).entries) == 1 + lock = (outbox.queue_path / ".outbox.lock").open("r+b") + fcntl.flock(lock.fileno(), fcntl.LOCK_EX) + try: + queued = outbox.enqueue(batch=_batch()) + finally: + fcntl.flock(lock.fileno(), fcntl.LOCK_UN) + lock.close() + + assert queued is not None + + @pytest.mark.skipif(os.name == "nt", reason="POSIX process locks are required") def test_concurrent_processes_publish_complete_unique_entries(tmp_path: Path) -> None: context = multiprocessing.get_context("fork") diff --git a/tests/commons/test_sync.py b/tests/commons/test_sync.py index cd4e68e..a260460 100644 --- a/tests/commons/test_sync.py +++ b/tests/commons/test_sync.py @@ -46,6 +46,7 @@ def _pack_bytes() -> bytes: "commons_revision": 1, "compatibility": {"evidence_envelope_schema_version": "1.0"}, "models": { + "openai/gpt-6-astra": {"aggregates": []}, MODEL_NAMESPACE: {"aggregates": []}, "openai/gpt-5.6-terra": {"aggregates": []}, "openai/gpt-5.6-luna": {"aggregates": []}, diff --git a/tests/commons_signing.py b/tests/commons_signing.py index 007fc1f..b60e8fe 100644 --- a/tests/commons_signing.py +++ b/tests/commons_signing.py @@ -12,6 +12,7 @@ ROOT_PRIVATE = Ed25519PrivateKey.from_private_bytes(bytes(range(32))) RELEASE_PRIVATE = Ed25519PrivateKey.from_private_bytes(bytes(range(32, 64))) MODEL_NAMESPACES = ( + "openai/gpt-6-astra", "openai/gpt-5.6-luna", "openai/gpt-5.6-sol", "openai/gpt-5.6-terra", diff --git a/tests/integrations/codex/test_service.py b/tests/integrations/codex/test_service.py index 96bb834..5bba2e5 100644 --- a/tests/integrations/codex/test_service.py +++ b/tests/integrations/codex/test_service.py @@ -233,6 +233,68 @@ def test_session_start_and_end_are_complete_hook_lifecycle(tmp_path: Path) -> No assert not (data / "sessions" / connection_filename("session-1")).exists() +def test_astra_operation_memory_survives_reopen_without_merging_a_model_change( + tmp_path: Path, +) -> None: + workspace = tmp_path / "repo" + workspace.mkdir() + _repository(workspace) + data = tmp_path / "data" + start = replace(_start(workspace), model="gpt-6-astra") + connection = start_session_service(start, data_root=data) + common = { + "session_id": start.session_id, + "cwd": start.cwd, + "permission_mode": start.permission_mode, + "turn_id": "turn-1", + "tool_name": "Read", + "tool_input": {"path": str(workspace / "tracked.txt")}, + } + astra_pre = { + **common, + "hook_event_name": "PreToolUse", + "model": "gpt-6-astra", + "tool_use_id": "astra-call", + } + astra_post = { + **astra_pre, + "hook_event_name": "PostToolUse", + "tool_response": {"exit_code": 0}, + } + changed_pre = { + **common, + "hook_event_name": "PreToolUse", + "model": "gpt-5.6-sol", + "tool_use_id": "changed-model-call", + } + changed_post = { + **changed_pre, + "hook_event_name": "PostToolUse", + "tool_response": {"exit_code": 0}, + } + + try: + assert request_session(connection, operation="pre", payload=astra_pre)["ok"] is True + assert request_session(connection, operation="post", payload=astra_post)["ok"] is True + assert request_session(connection, operation="pre", payload=changed_pre)["ok"] is True + assert request_session(connection, operation="post", payload=changed_post)["ok"] is True + finally: + stop_session_service(start.session_id, data_root=data) + + repository_hash = current_promotion_identity(workspace).repository_hash + reopened = EvidenceStore(data / "evidence" / repository_hash).read_all() + operation_records = [ + record for record in reopened if record.get("event") in {"decision", "outcome"} + ] + + assert [record.get("model_namespace") for record in operation_records] == [ + "openai/gpt-6-astra", + "openai/gpt-6-astra", + None, + None, + ] + + class _OfflineCommonsClient: def __init__(self) -> None: self.downloads = 0 diff --git a/tests/test_commons_contract.py b/tests/test_commons_contract.py index ec369aa..7775b22 100644 --- a/tests/test_commons_contract.py +++ b/tests/test_commons_contract.py @@ -13,6 +13,7 @@ ROOT = Path(__file__).resolve().parents[1] NAMESPACES = ( + "openai/gpt-6-astra", "openai/gpt-5.6-sol", "openai/gpt-5.6-terra", "openai/gpt-5.6-luna", @@ -135,6 +136,7 @@ def test_registry_contains_only_the_reviewed_exact_model_mapping() -> None: assert registry == { "schema_version": "1.0", "models": { + "gpt-6-astra": "openai/gpt-6-astra", "gpt-5.6-sol": "openai/gpt-5.6-sol", "gpt-5.6-terra": "openai/gpt-5.6-terra", "gpt-5.6-luna": "openai/gpt-5.6-luna", @@ -181,3 +183,20 @@ def test_pack_rejects_noncanonical_or_open_content() -> None: candidate = copy.deepcopy(pack) mutation(candidate) _assert_invalid(validator, candidate) + + +def test_pack_contract_accepts_a_pre_astra_model_set() -> None: + pack = { + "schema_version": "1.0", + "source_commit": "a" * 40, + "commons_revision": 1, + "compatibility": {"evidence_envelope_schema_version": "1.0"}, + "models": { + namespace: {"aggregates": []} + for namespace in NAMESPACES + if namespace != "openai/gpt-6-astra" + }, + "integrity": {"sha256": "b" * 64}, + } + + _validator("commons-pack-v1.json").validate(pack)