From 6a7a8412e5467993b96b959d672d9ac72282afae Mon Sep 17 00:00:00 2001 From: Renato Date: Mon, 7 Sep 2026 08:16:49 +0200 Subject: [PATCH 01/25] Add Astra model identity and operation memory --- contracts/commons-contract-v1.manifest.json | 6 +- models/canonical-model-registry-v1.json | 1 + pyproject.toml | 1 + schemas/commons-evidence-envelope-v1.json | 1 + schemas/commons-evidence-envelope-v1.sha256 | 2 +- schemas/commons-pack-v1.json | 1 + src/marginal/commons/cache.py | 9 ++- .../commons/canonical-model-registry-v1.json | 1 + src/marginal/commons/identity.py | 1 + .../schemas/commons-evidence-envelope-v1.json | 1 + src/marginal/schemas/commons-pack-v1.json | 1 + tests/commons/test_cache.py | 13 ++++ tests/commons/test_identity.py | 4 ++ tests/commons/test_local_e2e.py | 1 + tests/commons/test_sync.py | 1 + tests/commons_signing.py | 1 + tests/integrations/codex/test_service.py | 62 +++++++++++++++++++ tests/test_commons_contract.py | 19 ++++++ 18 files changed, 120 insertions(+), 6 deletions(-) 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/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/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/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/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/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_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) From 821eb2b3b63645c58dd32cbf9b4388e84144bb61 Mon Sep 17 00:00:00 2001 From: Renato Date: Mon, 7 Sep 2026 08:35:39 +0200 Subject: [PATCH 02/25] Package Astra support and document benchmark preflight honestly --- README.md | 16 ++++ benchmark/astra/README.md | 53 ++++++++++++ .../2026-09-07-astra-public-benchmark.md | 77 ++++++++++++++++++ ...026-09-07-astra-public-benchmark-design.md | 40 +++++++++ plugins/marginal/runtime/marginal_runtime.pyz | Bin 741546 -> 741890 bytes plugins/marginal/runtime/provenance.json | 2 +- 6 files changed, 187 insertions(+), 1 deletion(-) create mode 100644 benchmark/astra/README.md create mode 100644 docs/superpowers/plans/2026-09-07-astra-public-benchmark.md create mode 100644 docs/superpowers/specs/2026-09-07-astra-public-benchmark-design.md diff --git a/README.md b/README.md index 62b5cd1..3a88d26 100644 --- a/README.md +++ b/README.md @@ -68,6 +68,22 @@ 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. + +### 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..a792922 --- /dev/null +++ b/benchmark/astra/README.md @@ -0,0 +1,53 @@ +# GPT-6 Astra evaluation status — 2026-09-07 + +**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. + +## 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 SWE-bench Lite smoke images; no Pro images | +| First deterministic Pro image | Manifest reachable; 4,663,263,960 compressed layer bytes | +| Official Pro grading | Not executed | +| 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/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/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..e222f7b --- /dev/null +++ b/docs/superpowers/specs/2026-09-07-astra-public-benchmark-design.md @@ -0,0 +1,40 @@ +# 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 + +Execution amendment, before scored inference: complete HumanEval+ v0.1.10 (164 tasks) +using EvalPlus v0.3.1 in both conditions within existing quota. The previously proposed +SWE-bench Pro run remains incomplete. Function-level results must not be represented as +real-repository evidence or as equivalent to SWE-bench Pro. All accounting and isolation +requirements below still apply. + +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/plugins/marginal/runtime/marginal_runtime.pyz b/plugins/marginal/runtime/marginal_runtime.pyz index 21ce493a7a8ddd02b3329748b142dfd7a89e9eb1..70ecac1bfb99f18e41df746d623f57078769e9a9 100644 GIT binary patch delta 1902 zcmah}YfMvT7(VAaZEepd*dYiqE-l_B3Jif33iLwHp%e<#>q54KVa7J(W~9?45N&Zz zog)j=_5Gt}PLg?vlONM++@_cv@68rtKBO^0W2|Wqfjk~p4uu$ zrMS}TaEdDp#fI7lp|4ymb!+l*Vg+oOc`};z72J0p#w4ONj==HB6H!$ z&ur8d-k|(iHyB!4eg9E1v!Si+jkRs{zUP`-U#V|uTl}&^tt>S48ur~y?gLZEZi5^RjCo{7Q?^&p{3A&i}i<2i0qBM{G}%+|16JY znDXe|-`t50_5Q@BvHz#vj(QA&!C|N{)EF9!85r77|1F&n8Lrw%}{hf4Ic-e z7yoZ=s|@Q*bQw8+7>Z5QMbb{e+a{WsG&x&_ zNs5%hXHTH!7JO@>Wn^d^63w)fJj{Z%W-5@!rEthhMPgnDV`l0mmz%(nPd()RHrSC* zD>(i81eSJ_6!^f64r&gOsTMtl!B9Y*-0a^7WKEDc&{06s$?0d|5TfMqA{Z^8Ztm)4 z4g&pLJa{cMk9%oLIGYDYrL1q8oCUXWGvyW=-{tgC5$ipHhAxG^wvgs?7n` zM6|T)i)sALXBEchh{MeiWSEO+B3FMgjAy{@Y=nYDHMPl3P6dOjRmm_=gr1^iD4C&{ znz)!;C9B9$QQ2a5F%~?rCX6qH#zHK(qd_%wFzxGtR=SdefF#8{qgs z6)ziiU6>}Z^yB(+Zg5y>#}BI%|J^oh_uc~qAF!dtk%vlVu%pF+EVXQZqa7O^s}DM` z>42T)kaIuayO+CkS0Su-ApM;YwY(qa9JH7__N$T&kE>&0NeOP?92V*XngEDsVN(g# zdG(no$mJ4hA@kE@#NedGM0j3VuF~kh??l0|>c0^^3^}o={bdO;LPxEJ!iyH1nJD0K z*1s;nt4Lv&ynIbSHMdVrYs5Ik%Nb`cHRiKD&*`Jps|XsQIENJrWxEW9;-?CXagivQ?L4J zlZ0nCA%0Q1u?|+_CN=xuY&D*=&pLPrwBt>xF2kkyUR>HW2zD<{@niyQ@zMnvE(dRJ F<}aRLP9OjP delta 1691 zcmY*ZdrVVj6udx)A-7w;>>V~n}5i}Z81J@6YHD_nq}wq7HylHoc@0IJic?j z^PNpYdEe~K+jv6!KqqDR+a!ZY5Dfl}I`I@kXT12X|KE7=xPIq%OoxZ=iqkW@+SbnP z=xl9U-IbeZEYDo-t9QD*%j@huS5t%C;cCM7a>ZPKXSOICWB*Hd^Z7AB5ELoc@$=n8 z{L&>Z@h7{*hCR~YSn7Z=P7sX#HGhg05s6*5rTUIY!bmtt6iGCRhGZIv)?a-`I++*S ze>~;kY!C!R7GdKPDbb&qAYT$O&n?DbPL`aAZ@I-7^` zNz)60B6EVyxUdcqaafku`pp?~H&?=Fw*<0ee;^Ac<6pG}pPIm$9#IulHuW3oJM9$l zm|IN1T`n;L?|DIw+lwHTpLPZLG`vy-^Z3EOkd<5vcK-gR5bF6z)M9%v89X>3;@Cma zfY(bX!i8c;Wi@`hRSfxtmrbL_8Kx4G9_s7+1Lu~2hmTH(IQdvi!)+xnk3GxB?@PeR zCS8MOaIvCxyltjhmzu%Eeq5!37pqwuo-mX3gUt$4%X9Y{4BV_=%yO#sTl~Hx) zHiz@e%Akm^{PY!NBVuZG|E>y%3LDp^2Yp4zZ6~q9mMOLBZFzhp2TGdJs zF9lHscH5wUUmFYg!S7Le>@BAYyKkc_-}YCCAO1TEFyBs&1amQPiKg>FjBcB{a)M-#k7J>EPYVSV+SYB1)eLseW>LC>&8 zMt2nr(+|HWObUKdMGe>!zzbF2VA|hsng^`x<_xS-^oC;G;(>D3T#6SxU}I@+)K(Ke zzXLthP{CH;#;w(0(ArNTGFEzacM1Bd0x3$Nkl3SO3sHyUA%=1>7`cHw_8aQplK diff --git a/plugins/marginal/runtime/provenance.json b/plugins/marginal/runtime/provenance.json index 74f75bf..7087489 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":"6e244fef7171604839e66ceb1f098d5e15cd9320a4a18c7a9b2abea11603810b","source_hash":"de41d2644a7a918830060aeeba0f88c866c41819f85b47cabd7c62d8a3e99622"} From 10764b87184c77f8554f5cba45f015905d3dd649 Mon Sep 17 00:00:00 2001 From: Renato Date: Mon, 7 Sep 2026 09:09:40 +0200 Subject: [PATCH 03/25] Add resumable paired benchmark orchestration --- benchmark/astra/__init__.py | 1 + benchmark/astra/humaneval_runner.py | 538 ++++++++++++++++++ benchmark/codex_adapter/hook_config.py | 52 +- benchmark/codex_adapter/runner.py | 63 +- .../benchmark/test_astra_humaneval_runner.py | 313 ++++++++++ tests/benchmark/test_codex_runner.py | 35 +- 6 files changed, 962 insertions(+), 40 deletions(-) create mode 100644 benchmark/astra/__init__.py create mode 100644 benchmark/astra/humaneval_runner.py create mode 100644 tests/benchmark/test_astra_humaneval_runner.py 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_runner.py b/benchmark/astra/humaneval_runner.py new file mode 100644 index 0000000..8172649 --- /dev/null +++ b/benchmark/astra/humaneval_runner.py @@ -0,0 +1,538 @@ +"""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]: + tasks = load_tasks(config.tasks_path) + 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}" + ) + 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, _sha256(config.tasks_path.read_bytes()) + + +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 = _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": "HumanEval+ v0.1.10", + "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/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/tests/benchmark/test_astra_humaneval_runner.py b/tests/benchmark/test_astra_humaneval_runner.py new file mode 100644 index 0000000..8c23f88 --- /dev/null +++ b/tests/benchmark/test_astra_humaneval_runner.py @@ -0,0 +1,313 @@ +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("frozen protocol\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 {(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"] + + config.protocol_path.write_text("changed 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_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_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( From 579fa1aa830c9d6787f315ecee579ace472e632b Mon Sep 17 00:00:00 2001 From: Renato Date: Mon, 7 Sep 2026 09:15:00 +0200 Subject: [PATCH 04/25] Restore SWE-bench Pro target and record full task protocol --- .../astra/humaneval-plus/Dockerfile.evaluator | 11 ++++ benchmark/astra/humaneval-plus/README.md | 51 +++++++++++++++++++ .../humaneval-plus/evaluator-requirements.txt | 1 + benchmark/astra/humaneval-plus/protocol.json | 41 +++++++++++++++ benchmark/astra/pro/prompt-template.txt | 12 +++++ benchmark/astra/pro/protocol.json | 43 ++++++++++++++++ ...026-09-07-astra-public-benchmark-design.md | 9 ++-- 7 files changed, 163 insertions(+), 5 deletions(-) create mode 100644 benchmark/astra/humaneval-plus/Dockerfile.evaluator create mode 100644 benchmark/astra/humaneval-plus/README.md create mode 100644 benchmark/astra/humaneval-plus/evaluator-requirements.txt create mode 100644 benchmark/astra/humaneval-plus/protocol.json create mode 100644 benchmark/astra/pro/prompt-template.txt create mode 100644 benchmark/astra/pro/protocol.json 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/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..318c64a --- /dev/null +++ b/benchmark/astra/pro/protocol.json @@ -0,0 +1,43 @@ +{ + "schema_version": 1, + "experiment": "astra-swe-bench-pro-20260907", + "status": "preflight_no_scored_inference", + "dataset": "ScaleAI/SWE-bench_Pro", + "dataset_revision": "7ab5114912baf22bb098818e604c02fe7ad2c11f", + "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/docs/superpowers/specs/2026-09-07-astra-public-benchmark-design.md b/docs/superpowers/specs/2026-09-07-astra-public-benchmark-design.md index e222f7b..47fa1a6 100644 --- a/docs/superpowers/specs/2026-09-07-astra-public-benchmark-design.md +++ b/docs/superpowers/specs/2026-09-07-astra-public-benchmark-design.md @@ -14,11 +14,10 @@ unlabelled evidence retroactively to Astra. ## Evaluation -Execution amendment, before scored inference: complete HumanEval+ v0.1.10 (164 tasks) -using EvalPlus v0.3.1 in both conditions within existing quota. The previously proposed -SWE-bench Pro run remains incomplete. Function-level results must not be represented as -real-repository evidence or as equivalent to SWE-bench Pro. All accounting and isolation -requirements below still apply. +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 From 6d5f3f32dd94204f0be79cef63ad28e10db8d32f Mon Sep 17 00:00:00 2001 From: Renato Date: Mon, 7 Sep 2026 09:16:16 +0200 Subject: [PATCH 05/25] Publish deterministic 731-task SWE-bench Pro manifest --- benchmark/astra/pro/task-manifest.jsonl | 731 ++++++++++++++++++++++++ 1 file changed, 731 insertions(+) create mode 100644 benchmark/astra/pro/task-manifest.jsonl 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"} From fb3c4a37068476ac0b31fbd4a0670369064315b0 Mon Sep 17 00:00:00 2001 From: Renato Date: Mon, 7 Sep 2026 09:25:07 +0200 Subject: [PATCH 06/25] Add minimal SWE-bench Pro container lane --- .dockerignore | 4 + .../task-pro-report.md | 45 +++ benchmark/astra/pro/Dockerfile.solver | 54 ++++ benchmark/astra/pro_lane.py | 282 ++++++++++++++++++ tests/benchmark/test_astra_pro_lane.py | 155 ++++++++++ 5 files changed, 540 insertions(+) create mode 100644 .superpowers/sdd/2026-09-07-astra-public-benchmark/task-pro-report.md create mode 100644 benchmark/astra/pro/Dockerfile.solver create mode 100644 benchmark/astra/pro_lane.py create mode 100644 tests/benchmark/test_astra_pro_lane.py 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..8aa0cae --- /dev/null +++ b/.superpowers/sdd/2026-09-07-astra-public-benchmark/task-pro-report.md @@ -0,0 +1,45 @@ +# 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, 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 Node and uv builder manifests, installs Codex 0.153.4 with the existing wrapper, adds an + independent 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%] +6 passed in 1.84s +``` + +```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`. +Its final result and 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. +- No solver/model request was made during implementation or verification. diff --git a/benchmark/astra/pro/Dockerfile.solver b/benchmark/astra/pro/Dockerfile.solver new file mode 100644 index 0000000..716ace3 --- /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:4d676821dff059fd00d277ee4261ef34ea712317fed0737c03941481b5760c96 AS tools_builder + +ENV UV_PYTHON_INSTALL_DIR=/overlay/opt/python +COPY --from=uv_builder /uv /uv +RUN /uv python install 3.12.11 \ + && mkdir -p /overlay/opt/python/bin \ + && installed_python="$(/uv python find 3.12.11)" \ + && ln -s "${installed_python#/overlay}" /overlay/opt/python/bin/python3 \ + && "${installed_python}" --version + +COPY --from=codex_builder /usr/local/bin/node /overlay/opt/marginal-tools/bin/node +COPY --from=codex_builder /usr/local/lib/node_modules/@openai/codex /overlay/opt/marginal-tools/lib/codex +COPY benchmark/container/codex-wrapper.sh /overlay/opt/marginal-tools/bin/codex +COPY . /overlay/opt/marginal + +RUN installed_python="$(/uv python find 3.12.11)" \ + && 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: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_lane.py b/benchmark/astra/pro_lane.py new file mode 100644 index 0000000..de22bcd --- /dev/null +++ b/benchmark/astra/pro_lane.py @@ -0,0 +1,282 @@ +"""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"^[A-Za-z0-9][A-Za-z0-9._-]*__[A-Za-z0-9][A-Za-z0-9._-]*-[1-9][0-9]*$") +_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, +) -> str | bytes: + completed = subprocess.run( + ["git", *args], + cwd=worktree, + env=env, + capture_output=True, + check=False, + text=text, + 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") + 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(worktree: Path) -> None: + metadata = worktree / ".git" + if metadata.is_dir() and not metadata.is_symlink(): + shutil.rmtree(metadata) + elif metadata.exists() or metadata.is_symlink(): + metadata.unlink() + + +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() + 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) + _remove_git_metadata(config.worktree) + + _git(config.worktree, "init", "-q") + _git(config.worktree, "add", "-A") + 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/tests/benchmark/test_astra_pro_lane.py b/tests/benchmark/test_astra_pro_lane.py new file mode 100644 index 0000000..e0574f8 --- /dev/null +++ b/tests/benchmark/test_astra_pro_lane.py @@ -0,0 +1,155 @@ +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, 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") + _git(repo, "add", ".gitignore", "base.py") + _git(repo, "commit", "-qm", "base") + base_commit = _git(repo, "rev-parse", "HEAD") + (repo / ".deps").mkdir() + (repo / ".deps" / "installed.txt").write_text("keep me\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="acme__widgets-123", + 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 not (repo / "future.py").exists() + assert (repo / ".deps" / "installed.txt").read_text(encoding="utf-8") == "keep me\n" + 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 + + +@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": "acme__widgets-123"} + assert len(observed) == 1 + forwarded = observed[0] + assert forwarded.instance_id == "acme__widgets-123" + 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"] From 2dc8fb3f9f63bdee15f06dbc100486f4168cf993 Mon Sep 17 00:00:00 2001 From: Renato Date: Mon, 7 Sep 2026 09:32:23 +0200 Subject: [PATCH 07/25] Reject nested Git history in Pro lanes --- .../task-pro-report.md | 8 ++++--- benchmark/astra/pro_lane.py | 19 ++++++++++++--- tests/benchmark/test_astra_pro_lane.py | 23 +++++++++++++++++++ 3 files changed, 44 insertions(+), 6 deletions(-) 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 index 8aa0cae..e30a6a6 100644 --- 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 @@ -9,8 +9,9 @@ the benchmark protocol. 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, forwards the unchanged public prompt to `run_task`, and records original/snapshot - commit and tree hashes. + 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 Node and uv builder manifests, installs Codex 0.153.4 with the existing wrapper, adds an independent Python 3.12.11 runtime, installs MARGINAL/benchmark packages into that runtime's @@ -24,7 +25,7 @@ the benchmark protocol. ```text $ .venv/bin/python -m pytest -q tests/benchmark/test_astra_pro_lane.py ...... [100%] -6 passed in 1.84s +7 passed in 2.24s ``` ```text @@ -42,4 +43,5 @@ Its final result and smoke checks are recorded below once complete. 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/benchmark/astra/pro_lane.py b/benchmark/astra/pro_lane.py index de22bcd..8668a1b 100644 --- a/benchmark/astra/pro_lane.py +++ b/benchmark/astra/pro_lane.py @@ -110,6 +110,11 @@ def _validate_config(config: ProLaneConfig) -> ProLaneConfig: 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, @@ -153,14 +158,22 @@ def _extract_archive(archive: Path, worktree: Path) -> None: raise RuntimeError(f"base archive extraction failed: {completed.stderr.strip()}") -def _remove_git_metadata(worktree: Path) -> None: - metadata = worktree / ".git" +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.""" @@ -181,7 +194,7 @@ def prepare_repository(config: ProLaneConfig) -> SnapshotProvenance: _git(config.worktree, "clean", "-ffd") _remove_tracked_files(config.worktree) _extract_archive(archive, config.worktree) - _remove_git_metadata(config.worktree) + _purge_git_metadata(config.worktree) _git(config.worktree, "init", "-q") _git(config.worktree, "add", "-A") diff --git a/tests/benchmark/test_astra_pro_lane.py b/tests/benchmark/test_astra_pro_lane.py index e0574f8..1fc561a 100644 --- a/tests/benchmark/test_astra_pro_lane.py +++ b/tests/benchmark/test_astra_pro_lane.py @@ -37,6 +37,10 @@ def _repository(tmp_path: Path) -> tuple[Path, str, str]: base_commit = _git(repo, "rev-parse", "HEAD") (repo / ".deps").mkdir() (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") @@ -75,6 +79,7 @@ def test_prepare_repository_keeps_only_the_base_tree_and_ignored_dependencies( assert (repo / "base.py").read_text(encoding="utf-8") == "BASE = True\n" assert not (repo / "future.py").exists() assert (repo / ".deps" / "installed.txt").read_text(encoding="utf-8") == "keep me\n" + 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" @@ -85,6 +90,24 @@ def test_prepare_repository_keeps_only_the_base_tree_and_ignored_dependencies( 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"), [ From 529f41b3f472dae4a2d675c6fa23ee6cba61b6be Mon Sep 17 00:00:00 2001 From: Renato Date: Mon, 7 Sep 2026 09:35:14 +0200 Subject: [PATCH 08/25] Bind benchmark inputs to protocol metadata --- benchmark/astra/humaneval_runner.py | 23 ++++++++++-- .../benchmark/test_astra_humaneval_runner.py | 37 ++++++++++++++++++- 2 files changed, 54 insertions(+), 6 deletions(-) diff --git a/benchmark/astra/humaneval_runner.py b/benchmark/astra/humaneval_runner.py index 8172649..562ce91 100644 --- a/benchmark/astra/humaneval_runner.py +++ b/benchmark/astra/humaneval_runner.py @@ -338,8 +338,11 @@ def _write_samples( temporary.replace(samples_dir / f"{lane}.jsonl") -def _validate_config(config: BenchmarkConfig) -> tuple[tuple[HumanEvalTask, ...], str]: +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: @@ -350,6 +353,18 @@ def _validate_config(config: BenchmarkConfig) -> tuple[tuple[HumanEvalTask, ...] "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(): @@ -357,7 +372,7 @@ def _validate_config(config: BenchmarkConfig) -> tuple[tuple[HumanEvalTask, ...] 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, _sha256(config.tasks_path.read_bytes()) + return tasks, input_sha256, f"{dataset} {dataset_version}".strip() def run_benchmark( @@ -367,7 +382,7 @@ def run_benchmark( ) -> dict[str, Any]: """Run a bounded number of new lanes and report exact resumable state.""" - tasks, input_sha256 = _validate_config(config) + 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]] = { @@ -471,7 +486,7 @@ def submit_next() -> bool: ) summary: dict[str, Any] = { "schema_version": 1, - "benchmark": "HumanEval+ v0.1.10", + "benchmark": benchmark_name, "input_sha256": input_sha256, "protocol_sha256": config.protocol_sha256, "expected_tasks": 164, diff --git a/tests/benchmark/test_astra_humaneval_runner.py b/tests/benchmark/test_astra_humaneval_runner.py index 8c23f88..3cbf14d 100644 --- a/tests/benchmark/test_astra_humaneval_runner.py +++ b/tests/benchmark/test_astra_humaneval_runner.py @@ -34,7 +34,17 @@ def _config(tmp_path: Path, *, maximum_new_lanes: int | None = None) -> Benchmar tasks_path = tmp_path / "tasks.jsonl" _write_tasks(tasks_path) protocol_path = tmp_path / "protocol.md" - protocol_path.write_text("frozen protocol\n", encoding="utf-8") + 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" @@ -167,6 +177,7 @@ def fake_run_task(run_config: RunConfig) -> dict[str, object]: 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"), @@ -220,7 +231,9 @@ def fake_run_task(run_config: RunConfig) -> dict[str, object]: assert second["launched"] == ["HumanEval/145:on"] assert calls == ["HumanEval/145:baseline", "HumanEval/145:marginal"] - config.protocol_path.write_text("changed protocol\n", encoding="utf-8") + 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(), @@ -235,6 +248,26 @@ def fake_run_task(run_config: RunConfig) -> dict[str, object]: 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" From 1d46b853a4c1d3f5eb7ddc60d07e4dcf5907303b Mon Sep 17 00:00:00 2001 From: Renato Date: Mon, 7 Sep 2026 09:39:56 +0200 Subject: [PATCH 09/25] Use musl runtimes for Pro task image --- .../task-pro-report.md | 10 ++++++---- benchmark/astra/pro/Dockerfile.solver | 12 ++++++------ 2 files changed, 12 insertions(+), 10 deletions(-) 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 index e30a6a6..1fded45 100644 --- 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 @@ -13,9 +13,9 @@ the benchmark protocol. 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 Node and uv builder manifests, installs Codex 0.153.4 with the existing wrapper, adds an - independent 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`. + 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. @@ -35,7 +35,9 @@ All checks passed! The image build uses task image `jefzda/sweap-images@sha256:d902632d1374cf0282a4ea301b82c296e13a41127308da0204aca87a4ba62c02`. -Its final result and smoke checks are recorded below once complete. +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 diff --git a/benchmark/astra/pro/Dockerfile.solver b/benchmark/astra/pro/Dockerfile.solver index 716ace3..b9e5199 100644 --- a/benchmark/astra/pro/Dockerfile.solver +++ b/benchmark/astra/pro/Dockerfile.solver @@ -1,20 +1,20 @@ # syntax=docker/dockerfile:1 ARG TASK_IMAGE -FROM --platform=linux/amd64 node@sha256:4d676821dff059fd00d277ee4261ef34ea712317fed0737c03941481b5760c96 AS codex_builder +FROM --platform=linux/amd64 node@sha256:76789712cd1ae89a1225eac9077010d68987a423588042dac30446f502f1858c 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:4d676821dff059fd00d277ee4261ef34ea712317fed0737c03941481b5760c96 AS tools_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 3.12.11 \ +RUN /uv python install cpython-3.12.11-linux-x86_64-musl \ && mkdir -p /overlay/opt/python/bin \ - && installed_python="$(/uv python find 3.12.11)" \ + && 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 @@ -23,7 +23,7 @@ COPY --from=codex_builder /usr/local/lib/node_modules/@openai/codex /overlay/opt COPY benchmark/container/codex-wrapper.sh /overlay/opt/marginal-tools/bin/codex COPY . /overlay/opt/marginal -RUN installed_python="$(/uv python find 3.12.11)" \ +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" \ @@ -41,7 +41,7 @@ LABEL org.opencontainers.image.title="MARGINAL Astra SWE-bench Pro solver" \ 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:4d676821dff059fd00d277ee4261ef34ea712317fed0737c03941481b5760c96" \ + org.marginal.node.image="node@sha256:76789712cd1ae89a1225eac9077010d68987a423588042dac30446f502f1858c" \ org.marginal.uv.image="ghcr.io/astral-sh/uv@sha256:1ececcacbbde240ffca54d400df86e4fdd38f29c1a2366299279d197e92eaed3" COPY --from=tools_builder /overlay / From 4ad6fc48c0ff7d30f75ddfa22e9527fe8932cb34 Mon Sep 17 00:00:00 2001 From: Renato Date: Mon, 7 Sep 2026 09:47:24 +0200 Subject: [PATCH 10/25] Use musl runtimes for Pro task images --- benchmark/astra/pro/Dockerfile.solver | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/benchmark/astra/pro/Dockerfile.solver b/benchmark/astra/pro/Dockerfile.solver index b9e5199..2f40f84 100644 --- a/benchmark/astra/pro/Dockerfile.solver +++ b/benchmark/astra/pro/Dockerfile.solver @@ -1,7 +1,7 @@ # syntax=docker/dockerfile:1 ARG TASK_IMAGE -FROM --platform=linux/amd64 node@sha256:76789712cd1ae89a1225eac9077010d68987a423588042dac30446f502f1858c AS codex_builder +FROM --platform=linux/amd64 node@sha256:4d676821dff059fd00d277ee4261ef34ea712317fed0737c03941481b5760c96 AS codex_builder RUN npm install --global --omit=dev "@openai/codex@0.153.4" \ && codex --version @@ -42,6 +42,7 @@ LABEL org.opencontainers.image.title="MARGINAL Astra SWE-bench Pro solver" \ 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 / From 8743d3cada4063e8912630bd05d838b004d1743f Mon Sep 17 00:00:00 2001 From: Renato Date: Mon, 7 Sep 2026 09:49:04 +0200 Subject: [PATCH 11/25] Publish official SWE-bench Pro reference validation evidence --- benchmark/astra/pro/README.md | 68 ++++++++++++++++++++++ benchmark/astra/pro/gold-eval-results.json | 1 + benchmark/astra/pro/gold-test-results.json | 1 + benchmark/astra/pro/preflight.json | 20 +++++++ benchmark/astra/pro/protocol.json | 1 + 5 files changed, 91 insertions(+) create mode 100644 benchmark/astra/pro/README.md create mode 100644 benchmark/astra/pro/gold-eval-results.json create mode 100644 benchmark/astra/pro/gold-test-results.json create mode 100644 benchmark/astra/pro/preflight.json diff --git a/benchmark/astra/pro/README.md b/benchmark/astra/pro/README.md new file mode 100644 index 0000000..d7c04ef --- /dev/null +++ b/benchmark/astra/pro/README.md @@ -0,0 +1,68 @@ +# GPT-6 Astra × MARGINAL on SWE-bench Pro + +**Execution in progress, not a completed performance benchmark.** 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). + +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. 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/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/protocol.json b/benchmark/astra/pro/protocol.json index 318c64a..c798482 100644 --- a/benchmark/astra/pro/protocol.json +++ b/benchmark/astra/pro/protocol.json @@ -4,6 +4,7 @@ "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", From 2097391686b8a87e737d9dc579b08a2f9d307cd1 Mon Sep 17 00:00:00 2001 From: Renato Date: Mon, 7 Sep 2026 09:49:41 +0200 Subject: [PATCH 12/25] Use Alpine Node in Pro runtime --- benchmark/astra/pro/Dockerfile.solver | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/benchmark/astra/pro/Dockerfile.solver b/benchmark/astra/pro/Dockerfile.solver index 2f40f84..50f3967 100644 --- a/benchmark/astra/pro/Dockerfile.solver +++ b/benchmark/astra/pro/Dockerfile.solver @@ -13,12 +13,12 @@ FROM --platform=linux/amd64 node@sha256:76789712cd1ae89a1225eac9077010d68987a423 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 \ + && 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 \ + && cp /usr/local/bin/node /overlay/opt/marginal-tools/bin/node \ && "${installed_python}" --version -COPY --from=codex_builder /usr/local/bin/node /overlay/opt/marginal-tools/bin/node COPY --from=codex_builder /usr/local/lib/node_modules/@openai/codex /overlay/opt/marginal-tools/lib/codex COPY benchmark/container/codex-wrapper.sh /overlay/opt/marginal-tools/bin/codex COPY . /overlay/opt/marginal From 1cf8145737a4a4a3b3a4833664700b6119c8088b Mon Sep 17 00:00:00 2001 From: Renato Date: Mon, 7 Sep 2026 09:51:03 +0200 Subject: [PATCH 13/25] Link active Pro experiment and pin evaluator dependencies --- benchmark/astra/README.md | 6 +++++- benchmark/astra/pro/evaluator-requirements.txt | 6 ++++++ 2 files changed, 11 insertions(+), 1 deletion(-) create mode 100644 benchmark/astra/pro/evaluator-requirements.txt diff --git a/benchmark/astra/README.md b/benchmark/astra/README.md index a792922..2279ddc 100644 --- a/benchmark/astra/README.md +++ b/benchmark/astra/README.md @@ -5,6 +5,10 @@ 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), @@ -26,7 +30,7 @@ successful model request do not demonstrate improved task quality or lower token | Docker | Existing local benchmark VM started; Docker 29.5.2, 6 CPUs, about 12 GiB RAM | | Existing task images | Three historical SWE-bench Lite smoke images; no Pro images | | First deterministic Pro image | Manifest reachable; 4,663,263,960 compressed layer bytes | -| Official Pro grading | Not executed | +| 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 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 From 91b5ff8a48151452c2eac0887b736c0e5dd0c636 Mon Sep 17 00:00:00 2001 From: Renato Date: Tue, 8 Sep 2026 08:41:58 +0200 Subject: [PATCH 14/25] Clarify Astra support and distinguish Pro reference checks from model scores --- README.md | 5 +++++ benchmark/astra/README.md | 6 +++--- 2 files changed, 8 insertions(+), 3 deletions(-) diff --git a/README.md b/README.md index 3a88d26..6793d37 100644 --- a/README.md +++ b/README.md @@ -82,6 +82,11 @@ reduce the model's internal reasoning budget. The complete public OFF/ON evaluat 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. diff --git a/benchmark/astra/README.md b/benchmark/astra/README.md index 2279ddc..86dda64 100644 --- a/benchmark/astra/README.md +++ b/benchmark/astra/README.md @@ -1,4 +1,4 @@ -# GPT-6 Astra evaluation status — 2026-09-07 +# GPT-6 Astra evaluation status — updated 2026-09-08 **No complete Astra OFF/ON benchmark has been executed. No token-saving claim is supported.** @@ -28,8 +28,8 @@ preparation was withdrawn before any scored model inference. | 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 SWE-bench Lite smoke images; no Pro images | -| First deterministic Pro image | Manifest reachable; 4,663,263,960 compressed layer bytes | +| 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** | From 6dcc81dc193f43bdfa517e7f7fd78c42f6d1595a Mon Sep 17 00:00:00 2001 From: Renato Date: Tue, 8 Sep 2026 08:55:22 +0200 Subject: [PATCH 15/25] Use packaged native Codex in Pro solver --- benchmark/astra/pro/Dockerfile.solver | 3 +- benchmark/astra/pro/codex-native-wrapper.sh | 13 +++++ tests/benchmark/test_astra_pro_solver.py | 56 +++++++++++++++++++++ 3 files changed, 70 insertions(+), 2 deletions(-) create mode 100644 benchmark/astra/pro/codex-native-wrapper.sh create mode 100644 tests/benchmark/test_astra_pro_solver.py diff --git a/benchmark/astra/pro/Dockerfile.solver b/benchmark/astra/pro/Dockerfile.solver index 50f3967..b3a5a66 100644 --- a/benchmark/astra/pro/Dockerfile.solver +++ b/benchmark/astra/pro/Dockerfile.solver @@ -16,11 +16,10 @@ 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 \ - && cp /usr/local/bin/node /overlay/opt/marginal-tools/bin/node \ && "${installed_python}" --version COPY --from=codex_builder /usr/local/lib/node_modules/@openai/codex /overlay/opt/marginal-tools/lib/codex -COPY benchmark/container/codex-wrapper.sh /overlay/opt/marginal-tools/bin/codex +COPY benchmark/astra/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)" \ diff --git a/benchmark/astra/pro/codex-native-wrapper.sh b/benchmark/astra/pro/codex-native-wrapper.sh new file mode 100644 index 0000000..41c6e44 --- /dev/null +++ b/benchmark/astra/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/tests/benchmark/test_astra_pro_solver.py b/tests/benchmark/test_astra_pro_solver.py new file mode 100644 index 0000000..bb62d01 --- /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/astra/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" From a167ab0c9d0c96d0de76c75785ac0906d4545fb5 Mon Sep 17 00:00:00 2001 From: Renato Date: Tue, 8 Sep 2026 08:58:44 +0200 Subject: [PATCH 16/25] Include Pro Codex launcher in solver context --- benchmark/astra/pro/Dockerfile.solver | 2 +- .../pro-codex-native-wrapper.sh} | 0 tests/benchmark/test_astra_pro_solver.py | 2 +- 3 files changed, 2 insertions(+), 2 deletions(-) rename benchmark/{astra/pro/codex-native-wrapper.sh => container/pro-codex-native-wrapper.sh} (100%) diff --git a/benchmark/astra/pro/Dockerfile.solver b/benchmark/astra/pro/Dockerfile.solver index b3a5a66..4d350f5 100644 --- a/benchmark/astra/pro/Dockerfile.solver +++ b/benchmark/astra/pro/Dockerfile.solver @@ -19,7 +19,7 @@ RUN /uv python install cpython-3.12.11-linux-x86_64-musl \ && "${installed_python}" --version COPY --from=codex_builder /usr/local/lib/node_modules/@openai/codex /overlay/opt/marginal-tools/lib/codex -COPY benchmark/astra/pro/codex-native-wrapper.sh /overlay/opt/marginal-tools/bin/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)" \ diff --git a/benchmark/astra/pro/codex-native-wrapper.sh b/benchmark/container/pro-codex-native-wrapper.sh similarity index 100% rename from benchmark/astra/pro/codex-native-wrapper.sh rename to benchmark/container/pro-codex-native-wrapper.sh diff --git a/tests/benchmark/test_astra_pro_solver.py b/tests/benchmark/test_astra_pro_solver.py index bb62d01..ddf835c 100644 --- a/tests/benchmark/test_astra_pro_solver.py +++ b/tests/benchmark/test_astra_pro_solver.py @@ -35,7 +35,7 @@ def test_pro_launcher_executes_packaged_native_codex_with_vendor_environment( vendor_rg.write_text("#!/bin/sh\nexit 0\n", encoding="utf-8") native_codex.chmod(0o755) vendor_rg.chmod(0o755) - launcher = Path("benchmark/astra/pro/codex-native-wrapper.sh") + launcher = Path("benchmark/container/pro-codex-native-wrapper.sh") environment = { **os.environ, "CODEX_PACKAGE_ROOT": str(package_root), From 64707947f8a52f06e1ac31fcfd0362ad9d3866f9 Mon Sep 17 00:00:00 2001 From: Renato Date: Tue, 8 Sep 2026 09:09:17 +0200 Subject: [PATCH 17/25] Format Pro solver regression test --- tests/benchmark/test_astra_pro_solver.py | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/tests/benchmark/test_astra_pro_solver.py b/tests/benchmark/test_astra_pro_solver.py index ddf835c..a5288d4 100644 --- a/tests/benchmark/test_astra_pro_solver.py +++ b/tests/benchmark/test_astra_pro_solver.py @@ -24,11 +24,11 @@ def test_pro_launcher_executes_packaged_native_codex_with_vendor_environment( 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" + '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", ) From 1d22d7fea1412d46b77238df6a825dae00e96d38 Mon Sep 17 00:00:00 2001 From: Renato Date: Tue, 8 Sep 2026 09:12:06 +0200 Subject: [PATCH 18/25] Record verified Pro runtime and incomplete benchmark closeout --- benchmark/astra/pro/README.md | 12 +++++++++++- 1 file changed, 11 insertions(+), 1 deletion(-) diff --git a/benchmark/astra/pro/README.md b/benchmark/astra/pro/README.md index d7c04ef..0168827 100644 --- a/benchmark/astra/pro/README.md +++ b/benchmark/astra/pro/README.md @@ -1,6 +1,6 @@ # GPT-6 Astra × MARGINAL on SWE-bench Pro -**Execution in progress, not a completed performance benchmark.** The full experiment needs +**Incomplete; execution paused to preserve remaining account quota (2026-09-08).** 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. @@ -66,3 +66,13 @@ data or Docker socket. Never publish authentication files. Preserve failed attem 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. From e4161548dcce8198913610b1af260e0a1382739e Mon Sep 17 00:00:00 2001 From: Renato Date: Wed, 9 Sep 2026 07:01:53 +0200 Subject: [PATCH 19/25] Fix SWE-bench Pro instance ID validation --- benchmark/astra/pro_lane.py | 5 ++++- tests/benchmark/test_astra_pro_lane.py | 29 ++++++++++++++++++++++---- 2 files changed, 29 insertions(+), 5 deletions(-) diff --git a/benchmark/astra/pro_lane.py b/benchmark/astra/pro_lane.py index 8668a1b..e3b61ee 100644 --- a/benchmark/astra/pro_lane.py +++ b/benchmark/astra/pro_lane.py @@ -17,7 +17,10 @@ from benchmark.codex_adapter.runner import RunConfig, run_task -_INSTANCE_ID = re.compile(r"^[A-Za-z0-9][A-Za-z0-9._-]*__[A-Za-z0-9][A-Za-z0-9._-]*-[1-9][0-9]*$") +_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]] diff --git a/tests/benchmark/test_astra_pro_lane.py b/tests/benchmark/test_astra_pro_lane.py index 1fc561a..f9d21c9 100644 --- a/tests/benchmark/test_astra_pro_lane.py +++ b/tests/benchmark/test_astra_pro_lane.py @@ -6,7 +6,7 @@ from pathlib import Path import pytest -from benchmark.astra.pro_lane import ProLaneConfig, prepare_repository, run_lane +from benchmark.astra.pro_lane import ProLaneConfig, _validate_config, prepare_repository, run_lane from benchmark.codex_adapter.runner import RunConfig @@ -56,7 +56,7 @@ def _config(tmp_path: Path, repo: Path, base_commit: str) -> ProLaneConfig: codex = tmp_path / "codex" codex.write_text("fixture\n", encoding="utf-8") return ProLaneConfig( - instance_id="acme__widgets-123", + instance_id="instance_protonmail__webclients-01ea5214d11e0df8b7170d91bafd34f23cb0f2b1", base_commit=base_commit, condition="marginal", worktree=repo, @@ -156,10 +156,15 @@ def fake_run_task(run_config: RunConfig) -> dict[str, object]: record = run_lane(config, run_task_fn=fake_run_task) - assert record == {"run_status": "completed", "instance_id": "acme__widgets-123"} + assert record == { + "run_status": "completed", + "instance_id": "instance_protonmail__webclients-01ea5214d11e0df8b7170d91bafd34f23cb0f2b1", + } assert len(observed) == 1 forwarded = observed[0] - assert forwarded.instance_id == "acme__widgets-123" + assert forwarded.instance_id == ( + "instance_protonmail__webclients-01ea5214d11e0df8b7170d91bafd34f23cb0f2b1" + ) assert forwarded.condition == "marginal" assert forwarded.repetition == 1 assert forwarded.worktree == repo.resolve() @@ -176,3 +181,19 @@ def fake_run_task(run_config: RunConfig) -> dict[str, object]: 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)) From f80f36e7824619ead541320b8911fccb6fc063f1 Mon Sep 17 00:00:00 2001 From: Renato Date: Wed, 9 Sep 2026 07:03:04 +0200 Subject: [PATCH 20/25] Pin corrected Pro execution module and pre-inference invocation --- benchmark/astra/pro/invocation-20260909.json | 37 ++++++++++++++++++++ 1 file changed, 37 insertions(+) create mode 100644 benchmark/astra/pro/invocation-20260909.json 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 +} From d9b167fbb071836ddb74d32c639453a23a605e31 Mon Sep 17 00:00:00 2001 From: Renato Date: Wed, 9 Sep 2026 07:09:50 +0200 Subject: [PATCH 21/25] Preserve ignored tracked files in Pro snapshots --- benchmark/astra/pro_lane.py | 22 +++++++++++++++++++++- tests/benchmark/test_astra_pro_lane.py | 6 +++++- 2 files changed, 26 insertions(+), 2 deletions(-) diff --git a/benchmark/astra/pro_lane.py b/benchmark/astra/pro_lane.py index e3b61ee..7bf7972 100644 --- a/benchmark/astra/pro_lane.py +++ b/benchmark/astra/pro_lane.py @@ -51,6 +51,7 @@ def _git( *args: str, env: dict[str, str] | None = None, text: bool = True, + input_data: str | bytes | None = None, ) -> str | bytes: completed = subprocess.run( ["git", *args], @@ -59,6 +60,7 @@ def _git( capture_output=True, check=False, text=text, + input=input_data, timeout=120, ) if completed.returncode != 0: @@ -184,6 +186,16 @@ def prepare_repository(config: ProLaneConfig) -> SnapshotProvenance: 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( @@ -200,7 +212,15 @@ def prepare_repository(config: ProLaneConfig) -> SnapshotProvenance: _purge_git_metadata(config.worktree) _git(config.worktree, "init", "-q") - _git(config.worktree, "add", "-A") + _git( + config.worktree, + "add", + "-f", + "--pathspec-from-file=-", + "--pathspec-file-nul", + text=False, + input_data=base_paths, + ) commit_environment = dict(os.environ) commit_environment.update( { diff --git a/tests/benchmark/test_astra_pro_lane.py b/tests/benchmark/test_astra_pro_lane.py index f9d21c9..7b2e69a 100644 --- a/tests/benchmark/test_astra_pro_lane.py +++ b/tests/benchmark/test_astra_pro_lane.py @@ -32,10 +32,12 @@ def _repository(tmp_path: Path) -> tuple[Path, str, str]: _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").mkdir() (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( @@ -77,8 +79,10 @@ def test_prepare_repository_keeps_only_the_base_tree_and_ignored_dependencies( 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" From 5a1a94cb9041f2ee210ea0a952c6f891914dfa99 Mon Sep 17 00:00:00 2001 From: Renato Date: Wed, 9 Sep 2026 07:13:15 +0200 Subject: [PATCH 22/25] Publish exact-tree verification and explicit incomplete Pro coverage --- benchmark/astra/pro/README.md | 15 ++++++++++- benchmark/astra/pro/execution-status.json | 31 +++++++++++++++++++++++ 2 files changed, 45 insertions(+), 1 deletion(-) create mode 100644 benchmark/astra/pro/execution-status.json diff --git a/benchmark/astra/pro/README.md b/benchmark/astra/pro/README.md index 0168827..0cfa737 100644 --- a/benchmark/astra/pro/README.md +++ b/benchmark/astra/pro/README.md @@ -1,6 +1,6 @@ # GPT-6 Astra × MARGINAL on SWE-bench Pro -**Incomplete; execution paused to preserve remaining account quota (2026-09-08).** The full experiment needs +**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. @@ -10,6 +10,8 @@ A passing reference patch is not evidence that MARGINAL improves quality or redu - [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. @@ -76,3 +78,14 @@ new test was corrected in commit `6470794`; this is separate from runtime valida 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/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." +} From 553c2ac573298a99ed99d91b70e625fa9b11b506 Mon Sep 17 00:00:00 2001 From: Renato Date: Wed, 9 Sep 2026 07:13:16 +0200 Subject: [PATCH 23/25] Use literal pathspecs for Pro snapshot staging --- benchmark/astra/pro_lane.py | 1 + 1 file changed, 1 insertion(+) diff --git a/benchmark/astra/pro_lane.py b/benchmark/astra/pro_lane.py index 7bf7972..c0c4c2f 100644 --- a/benchmark/astra/pro_lane.py +++ b/benchmark/astra/pro_lane.py @@ -214,6 +214,7 @@ def prepare_repository(config: ProLaneConfig) -> SnapshotProvenance: _git(config.worktree, "init", "-q") _git( config.worktree, + "--literal-pathspecs", "add", "-f", "--pathspec-from-file=-", From 71c8eae5ef1321c45c3d5c7aa8af1ffcded719b1 Mon Sep 17 00:00:00 2001 From: Renato Date: Wed, 9 Sep 2026 12:03:35 +0200 Subject: [PATCH 24/25] Avoid unnecessary contention for atomic outbox writes --- plugins/marginal/runtime/marginal_runtime.pyz | Bin 741890 -> 743367 bytes plugins/marginal/runtime/provenance.json | 2 +- src/marginal/commons/_storage.py | 35 ++++++++++++++++++ src/marginal/commons/outbox.py | 17 ++++++++- tests/commons/test_outbox.py | 18 +++++++++ 5 files changed, 69 insertions(+), 3 deletions(-) diff --git a/plugins/marginal/runtime/marginal_runtime.pyz b/plugins/marginal/runtime/marginal_runtime.pyz index 70ecac1bfb99f18e41df746d623f57078769e9a9..9a42eefbd4b345ae81c0da22d6bcd235a567f081 100644 GIT binary patch delta 2029 zcmZWpX;4#F6z08~gydb+sO;+_#mcTyS;7($_9X}|@T0b6V)D?8kYGp(@IV6YgL z3O3Fp)bZ9v!Qvbkj&+8N#3-KTH950KqC%f0Y!Yl{ENGRO(rBo!7i>`JAS&n3UEh5> zMs$o*e$V1$?yrW=Guf$dI)!l1^&S)8ta=dcY#ipC-{U^?_cT{4k-gb73_Zh4%%s-Q z&n~NTeSAaRSNs$`snCDxW?(Loir2~(pHGzpp% zO@`)+CP!1CaR(0v(yNi3i(o$K`X8F)0zguy!*G@kt~6~4)!1?*A1OHB*eCsw$urv9*4O;g!+ zn+H6pXD7pcHF|e%6`6AOEO<_|+gS?wOgx#|1udC0pPYNh!t8r&Ae<4|H=J!=t8pU z6)$_cMxubkTol(fda34I412x9jUwUKT$EJraicg$)S~C;NjHju7A-!x>rZbS9grxY zEe9X$h8CZE(LFDJVn{+ES%-mp|MgNWI;>?|Ds=1U0%BV(_0+4%!&Dotc~Ns7O(E~z z_M+ZAjHn!O<FGegOStD5~v+kaFC2orJ~Z zR71YLq5$PZg+FwcW1Wt>Z~<`d~q%`&ZCRi1DWC; z4u?~@DUex#Z&IY0;P_8IL{!oma-^7ppgbNLd9z^RaE~)?2(_xtTp@&YXMa z&dVMBCfd;#JvcHizg%^`rZLjZtuYd_^OFC!bMyCgr;^r?v?hh=Z*S{)`<}_oO^Lv+ zsd>MlrZp*4@~Ud6tF1XydFXg`RRfB)Nim4@b~g;|T9+2WaLXiZ$5;?E!k8v`qb`W) z;bUZb;O)gc@zjrdBjhuUd)u&)QE&?7zlK6f;X&a^p`(z8hK=IrYM?y$}6ofOWB8s;brlY?$Y4JN;VNPNIFe%~n(xF58Fcn$Gsm%2cYply z0Tp=vaVjdx5qDR-gYkQoNZ@)86`3p|k#C7tQJ01GzAN8UT0|UgI;^6UY}y<8R7GbM)X=A* zxomPtzP72%p<I}i!ZFJLX(w_{T!=t7B-%skg|+xGuZ$ z1M38gbUUphfB*A7ECRUz` zcDpb$qZN}1AN?-$MIxQm-i5u0c>VxqmDQSpUyJC&6`k-e7ABtDse=)^0Mr+gd&D_( z7n7>#3hpTD%qT)i$Zcf?2TRCpa1mcBIB^AcOGGZaxUp_U+FoH{OKS?b0kmj-qBEd> zFL_ozaiRBdS&x5-<_=j#2ABO{E~P|ETi_@a2e@OWj5ovOUCOwK(geiHZnfx4kRws4 z;H7vK2jF3{?Bkp%!XmrQl%zBnffji;yvr!dqYN3-Ryh>=71V2yaWbFwHm21`8TI^6 zD`v|?DPOFSalKBC!0Y9d=;l!+k^Ma?WRNhcZNPLnb@|c>1XWPE?NfN8g7Eh{&|M)S Kv^-AG)cFr4*xVoh diff --git a/plugins/marginal/runtime/provenance.json b/plugins/marginal/runtime/provenance.json index 7087489..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":"6e244fef7171604839e66ceb1f098d5e15cd9320a4a18c7a9b2abea11603810b","source_hash":"de41d2644a7a918830060aeeba0f88c866c41819f85b47cabd7c62d8a3e99622"} +{"builder":"scripts/build_codex_plugin.py","python_requires":">=3.10","schema_version":1,"sha256":"da07e5b564960dbd288e8d39ada481f9549101b0a9ca6629c88033f0e8d908b7","source_hash":"3d55fcb9c1021ebf424f0363f4c69a3574191b572844cd4b075f19b22cf77545"} 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/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/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") From 64d59cf9b746c84a7de66ff1416b61d7eb522bf1 Mon Sep 17 00:00:00 2001 From: Renato Date: Wed, 9 Sep 2026 12:12:42 +0200 Subject: [PATCH 25/25] Preregister full paired SWE-bench Lite campaign --- .../2026-09-09-marginal-swebench-lite-full.md | 126 ++++++++++++++++++ ...9-09-marginal-swebench-lite-full-design.md | 95 +++++++++++++ 2 files changed, 221 insertions(+) create mode 100644 docs/superpowers/plans/2026-09-09-marginal-swebench-lite-full.md create mode 100644 docs/superpowers/specs/2026-09-09-marginal-swebench-lite-full-design.md 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-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. +