Blame for data/foundry/python_test_generation.train.jsonl

{"id":"foundry::tests/test_atomic_writes.py::test_locked_path_serializes_writers::generate","input":"Source path: tests/test_atomic_writes.py\nDomains: atomic_write\nImports: primitive_foundry.io_utils\nAssertion count: 2","instruction":"Write a pytest test for Primitive Foundry that verifies: test locked path serializes writers.","output":"def test_locked_path_serializes_writers(tmp_path: Path) -> None:\n    target = tmp_path / \"shared.json\"\n    target.write_text(json.dumps({\"count\": 0}), encoding=\"utf-8\")\n\n    def writer(value: int) -> None:\n        with locked_path(target):\n            current = json.loads(target.read_text(encoding=\"utf-8\"))\n            current[\"count\"] = current[\"count\"] + value\n            target.write_text(json.dumps(current), encoding=\"utf-8\")\n\n    processes = [mp.Process(target=writer, args=(1,)) for _ in range(8)]\n    for p in processes:\n        p.start()\n    for p in processes:\n        p.join(timeout=10)\n        assert p.exitcode == 0\n\n    final = json.loads(target.read_text(encoding=\"utf-8\"))\n    assert final[\"count\"] == 8","source_id":"foundry::tests/test_atomic_writes.py::test_locked_path_serializes_writers","task":"python_test_generation"}
{"id":"foundry::tests/test_atomic_writes.py::test_locked_atomic_write_survives_concurrent_writers::generate","input":"Source path: tests/test_atomic_writes.py\nDomains: atomic_write\nImports: primitive_foundry.io_utils\nAssertion count: 4","instruction":"Write a pytest test for Primitive Foundry that verifies: test locked atomic write survives concurrent writers.","output":"def test_locked_atomic_write_survives_concurrent_writers(tmp_path: Path) -> None:\n    target = tmp_path / \"concurrent.json\"\n\n    processes = [\n        mp.Process(target=_concurrent_writer, args=(str(target), n))\n        for n in range(12)\n    ]\n    for p in processes:\n        p.start()\n    for p in processes:\n        p.join(timeout=10)\n        assert p.exitcode == 0\n\n    # File parses to one of the writers' payloads. No partial / mixed bytes.\n    payload = json.loads(target.read_text(encoding=\"utf-8\"))\n    marker = payload[\"marker\"]\n    assert 0 <= marker <= 11\n    assert payload[\"payload\"] == list(range(marker, marker + 4))\n    assert list(tmp_path.glob(\".*.tmp\")) == []","source_id":"foundry::tests/test_atomic_writes.py::test_locked_atomic_write_survives_concurrent_writers","task":"python_test_generation"}
{"id":"foundry::tests/test_bus_poller.py::test_poll_once_imports_jsonl_adapter::generate","input":"Source path: tests/test_bus_poller.py\nDomains: bus\nImports: primitive_foundry\nAssertion count: 3","instruction":"Write a pytest test for Primitive Foundry that verifies: test poll once imports jsonl adapter.","output":"def test_poll_once_imports_jsonl_adapter(tmp_path: Path) -> None:\n    adapter = _write_jsonl_adapter(\n        tmp_path,\n        source_payload=[\n            {\n                \"event_id\": \"e1\",\n                \"text\": \"first event\",\n                \"source_path\": str(tmp_path / \"src.md\"),\n                \"source_id\": \"s1\",\n                \"tags\": [\"t1\"],\n            }\n        ],\n    )\n    inbox = tmp_path / \"inbox.jsonl\"\n    result = bus_poller.poll_once(adapter=adapter, inbox=inbox, tick=1)\n    assert result.ok\n    assert result.imported_count == 1\n    assert inbox.exists()","source_id":"foundry::tests/test_bus_poller.py::test_poll_once_imports_jsonl_adapter","task":"python_test_generation"}
{"id":"foundry::tests/test_bus_poller.py::test_poll_once_handles_missing_adapter_gracefully::generate","input":"Source path: tests/test_bus_poller.py\nDomains: bus\nImports: primitive_foundry\nAssertion count: 3","instruction":"Write a pytest test for Primitive Foundry that verifies: test poll once handles missing adapter gracefully.","output":"def test_poll_once_handles_missing_adapter_gracefully(tmp_path: Path) -> None:\n    inbox = tmp_path / \"inbox.jsonl\"\n    missing = tmp_path / \"does_not_exist.json\"\n    result = bus_poller.poll_once(adapter=missing, inbox=inbox, tick=1)\n    assert result.ok is False\n    assert result.error  # something non-empty\n    assert \"FileNotFoundError\" in result.error or \"No such\" in result.error","source_id":"foundry::tests/test_bus_poller.py::test_poll_once_handles_missing_adapter_gracefully","task":"python_test_generation"}
{"id":"foundry::tests/test_bus_poller.py::test_poll_loop_continues_after_transient_error::generate","input":"Source path: tests/test_bus_poller.py\nDomains: bus\nImports: primitive_foundry\nAssertion count: 3","instruction":"Write a pytest test for Primitive Foundry that verifies: test poll loop continues after transient error.","output":"def test_poll_loop_continues_after_transient_error(tmp_path: Path) -> None:\n    adapter = tmp_path / \"missing.json\"  # adapter does not exist on first call\n    inbox = tmp_path / \"inbox.jsonl\"\n\n    real_source = tmp_path / \"feed.jsonl\"\n    real_source.write_text(\n        json.dumps({\"event_id\": \"e1\", \"text\": \"x\", \"source_path\": str(tmp_path), \"source_id\": \"s1\", \"tags\": []}) + \"\\n\",\n        encoding=\"utf-8\",\n    )\n\n    counter = {\"n\": 0}\n\n    def fake_sleep(_seconds: float) -> None:\n        counter[\"n\"] += 1\n        # On the second call, materialize the adapter so the next tick succeeds.\n        if counter[\"n\"] == 1:\n            adapter.write_text(\n                json.dumps({\"adapter_type\": \"jsonl\", \"source\": str(real_source)}),\n                encoding=\"utf-8\",\n            )\n\n    state = bus_poller.poll_loop(\n        adapter=adapter,\n        inbox=inbox,\n        interval_seconds=0,\n        status_path=None,\n        max_ticks=2,\n        sleep=fake_sleep,\n    )\n    assert state.tick_count == 2\n    assert state.error_count == 1\n    assert state.success_count == 1","source_id":"foundry::tests/test_bus_poller.py::test_poll_loop_continues_after_transient_error","task":"python_test_generation"}
{"id":"foundry::tests/test_bus_poller.py::test_poll_loop_respects_stop_predicate::generate","input":"Source path: tests/test_bus_poller.py\nDomains: bus\nImports: primitive_foundry\nAssertion count: 1","instruction":"Write a pytest test for Primitive Foundry that verifies: test poll loop respects stop predicate.","output":"def test_poll_loop_respects_stop_predicate(tmp_path: Path) -> None:\n    adapter = _write_jsonl_adapter(\n        tmp_path,\n        source_payload=[{\"event_id\": \"e1\", \"text\": \"x\", \"source_path\": str(tmp_path),\n                          \"source_id\": \"s1\", \"tags\": []}],\n    )\n    inbox = tmp_path / \"inbox.jsonl\"\n    stopper = {\"calls\": 0}\n\n    def stop() -> bool:\n        stopper[\"calls\"] += 1\n        return stopper[\"calls\"] > 1  # stop on second check\n\n    state = bus_poller.poll_loop(\n        adapter=adapter,\n        inbox=inbox,\n        interval_seconds=0,\n        status_path=None,\n        max_ticks=10,\n        sleep=lambda _: None,\n        stop_predicate=stop,\n    )\n    assert state.tick_count == 1","source_id":"foundry::tests/test_bus_poller.py::test_poll_loop_respects_stop_predicate","task":"python_test_generation"}
{"id":"foundry::tests/test_compliance.py::test_source_license_matrix_counts_and_passes::generate","input":"Source path: tests/test_compliance.py\nDomains: release, commercial, license, compliance, source_card\nImports: primitive_foundry.compliance\nAssertion count: 2","instruction":"Write a pytest test for Primitive Foundry that verifies: test source license matrix counts and passes.","output":"def test_source_license_matrix_counts_and_passes(tmp_path: Path) -> None:\n    cards = [\n        {\"source_id\": \"s1\", \"metadata\": {\"source_license\": \"cc-by-4.0\"}},\n        {\"source_id\": \"s2\", \"metadata\": {\"source_license\": \"cc-by-4.0\"}},\n        {\"source_id\": \"s3\", \"metadata\": {\"source_license\": \"public-domain\"}},\n    ]\n    matrix = build_source_license_matrix(\n        source_cards=cards,\n        release_license=\"private-commercial-evaluation\",\n    )\n    assert matrix[\"all_sources_compatible\"] is True\n    assert matrix[\"source_license_counts\"][\"cc-by-4.0\"] == 2","source_id":"foundry::tests/test_compliance.py::test_source_license_matrix_counts_and_passes","task":"python_test_generation"}
{"id":"foundry::tests/test_compliance.py::test_source_license_matrix_flags_incompatible::generate","input":"Source path: tests/test_compliance.py\nDomains: release, commercial, license, compliance, source_card\nImports: primitive_foundry.compliance\nAssertion count: 2","instruction":"Write a pytest test for Primitive Foundry that verifies: test source license matrix flags incompatible.","output":"def test_source_license_matrix_flags_incompatible() -> None:\n    cards = [\n        {\"source_id\": \"s1\", \"metadata\": {\"source_license\": \"AGPL-3.0\"}},\n    ]\n    matrix = build_source_license_matrix(\n        source_cards=cards,\n        release_license=\"private-commercial-evaluation\",\n    )\n    assert matrix[\"all_sources_compatible\"] is False\n    assert matrix[\"incompatibilities\"][0][\"source_license\"] == \"agpl-3.0\"","source_id":"foundry::tests/test_compliance.py::test_source_license_matrix_flags_incompatible","task":"python_test_generation"}
{"id":"foundry::tests/test_compliance.py::test_source_license_unspecified_is_tracked::generate","input":"Source path: tests/test_compliance.py\nDomains: release, commercial, license, compliance, source_card\nImports: primitive_foundry.compliance\nAssertion count: 1","instruction":"Write a pytest test for Primitive Foundry that verifies: test source license unspecified is tracked.","output":"def test_source_license_unspecified_is_tracked() -> None:\n    matrix = build_source_license_matrix(\n        source_cards=[{\"source_id\": \"s1\", \"metadata\": {}}],\n        release_license=\"private-commercial-evaluation\",\n    )\n    assert matrix[\"unspecified_count\"] == 1","source_id":"foundry::tests/test_compliance.py::test_source_license_unspecified_is_tracked","task":"python_test_generation"}
{"id":"foundry::tests/test_compliance.py::test_ear_classification_default_is_ear99::generate","input":"Source path: tests/test_compliance.py\nDomains: release, compliance\nImports: primitive_foundry.compliance\nAssertion count: 2","instruction":"Write a pytest test for Primitive Foundry that verifies: test ear classification default is ear99.","output":"def test_ear_classification_default_is_ear99() -> None:\n    payload = build_ear_classification(listing={})\n    assert payload[\"release_classification\"] == EXPORT_CLASSIFICATION_DEFAULT\n    assert payload[\"itar_refused\"] is True","source_id":"foundry::tests/test_compliance.py::test_ear_classification_default_is_ear99","task":"python_test_generation"}
{"id":"foundry::tests/test_compliance.py::test_ear_classification_invalid_falls_back::generate","input":"Source path: tests/test_compliance.py\nDomains: release, compliance\nImports: primitive_foundry.compliance\nAssertion count: 1","instruction":"Write a pytest test for Primitive Foundry that verifies: test ear classification invalid falls back.","output":"def test_ear_classification_invalid_falls_back() -> None:\n    payload = build_ear_classification(listing={\"export_classification\": \"weird-value\"})\n    assert payload[\"release_classification\"] == EXPORT_CLASSIFICATION_DEFAULT","source_id":"foundry::tests/test_compliance.py::test_ear_classification_invalid_falls_back","task":"python_test_generation"}
{"id":"foundry::tests/test_compliance.py::test_ear_refuses_itar_at_release_level::generate","input":"Source path: tests/test_compliance.py\nDomains: release, compliance\nImports: primitive_foundry.compliance\nAssertion count: 0","instruction":"Write a pytest test for Primitive Foundry that verifies: test ear refuses itar at release level.","output":"def test_ear_refuses_itar_at_release_level() -> None:\n    with pytest.raises(ValueError, match=\"ITAR\"):\n        build_ear_classification(listing={\"export_classification\": \"ITAR\"})","source_id":"foundry::tests/test_compliance.py::test_ear_refuses_itar_at_release_level","task":"python_test_generation"}
{"id":"foundry::tests/test_compliance.py::test_ear_refuses_itar_at_source_level::generate","input":"Source path: tests/test_compliance.py\nDomains: compliance, source_card\nImports: primitive_foundry.compliance\nAssertion count: 0","instruction":"Write a pytest test for Primitive Foundry that verifies: test ear refuses itar at source level.","output":"def test_ear_refuses_itar_at_source_level() -> None:\n    cards = [{\"source_id\": \"s1\", \"metadata\": {\"export_classification\": \"ITAR\"}}]\n    with pytest.raises(ValueError, match=\"ITAR\"):\n        build_ear_classification(listing={}, source_cards=cards)","source_id":"foundry::tests/test_compliance.py::test_ear_refuses_itar_at_source_level","task":"python_test_generation"}
{"id":"foundry::tests/test_compliance.py::test_refuse_itar_direct::generate","input":"Source path: tests/test_compliance.py\nDomains: compliance\nImports: primitive_foundry.compliance\nAssertion count: 0","instruction":"Write a pytest test for Primitive Foundry that verifies: test refuse itar direct.","output":"def test_refuse_itar_direct() -> None:\n    refuse_itar(\"ear99\")\n    refuse_itar(None)\n    with pytest.raises(ValueError):\n        refuse_itar(\"ITAR\")","source_id":"foundry::tests/test_compliance.py::test_refuse_itar_direct","task":"python_test_generation"}
{"id":"foundry::tests/test_compliance.py::test_state_ai_posture_default_out_of_scope::generate","input":"Source path: tests/test_compliance.py\nDomains: compliance\nImports: primitive_foundry.compliance\nAssertion count: 2","instruction":"Write a pytest test for Primitive Foundry that verifies: test state ai posture default out of scope.","output":"def test_state_ai_posture_default_out_of_scope() -> None:\n    payload = build_state_ai_posture(listing={})\n    frameworks = {item[\"framework\"]: item[\"posture\"] for item in payload[\"frameworks\"]}\n    assert \"Colorado AI Act (SB 24-205)\" in frameworks\n    assert frameworks[\"Illinois BIPA\"] == \"not_applicable\"","source_id":"foundry::tests/test_compliance.py::test_state_ai_posture_default_out_of_scope","task":"python_test_generation"}
{"id":"foundry::tests/test_compliance.py::test_state_ai_posture_supports_overrides::generate","input":"Source path: tests/test_compliance.py\nDomains: compliance\nImports: primitive_foundry.compliance\nAssertion count: 2","instruction":"Write a pytest test for Primitive Foundry that verifies: test state ai posture supports overrides.","output":"def test_state_ai_posture_supports_overrides() -> None:\n    listing = {\n        \"state_ai_overrides\": {\n            \"Colorado AI Act (SB 24-205)\": {\"posture\": \"in_scope\", \"evidence\": \"buyer uses CO HR system\"}\n        }\n    }\n    payload = build_state_ai_posture(listing)\n    co = next(item for item in payload[\"frameworks\"] if item[\"framework\"] == \"Colorado AI Act (SB 24-205)\")\n    assert co[\"posture\"] == \"in_scope\"\n    assert co[\"evidence\"] == \"buyer uses CO HR system\"","source_id":"foundry::tests/test_compliance.py::test_state_ai_posture_supports_overrides","task":"python_test_generation"}
{"id":"foundry::tests/test_compliance.py::test_retention_policy_has_default_period::generate","input":"Source path: tests/test_compliance.py\nDomains: compliance\nImports: primitive_foundry.compliance\nAssertion count: 3","instruction":"Write a pytest test for Primitive Foundry that verifies: test retention policy has default period.","output":"def test_retention_policy_has_default_period() -> None:\n    payload = build_retention_policy(listing={})\n    assert payload[\"retention_years\"] == 7\n    assert payload[\"source_files_shared_with_buyer\"] is False\n    assert \"Source files referenced\" in payload[\"policy_text\"]","source_id":"foundry::tests/test_compliance.py::test_retention_policy_has_default_period","task":"python_test_generation"}
{"id":"foundry::tests/test_compliance.py::test_bias_assessment_applies_to_relevant_family::generate","input":"Source path: tests/test_compliance.py\nDomains: compliance\nImports: primitive_foundry.compliance\nAssertion count: 1","instruction":"Write a pytest test for Primitive Foundry that verifies: test bias assessment applies to relevant family.","output":"def test_bias_assessment_applies_to_relevant_family() -> None:\n    payload = build_bias_assessment(listing={\"family\": \"agent_runtime_governance\"})\n    assert payload[\"applicability\"] == \"in_scope\"","source_id":"foundry::tests/test_compliance.py::test_bias_assessment_applies_to_relevant_family","task":"python_test_generation"}
{"id":"foundry::tests/test_compliance.py::test_bias_assessment_not_applicable_for_irrelevant_family::generate","input":"Source path: tests/test_compliance.py\nDomains: router, compliance\nImports: primitive_foundry.compliance\nAssertion count: 1","instruction":"Write a pytest test for Primitive Foundry that verifies: test bias assessment not applicable for irrelevant family.","output":"def test_bias_assessment_not_applicable_for_irrelevant_family() -> None:\n    payload = build_bias_assessment(listing={\"family\": \"router_training\"})\n    assert payload[\"applicability\"] == \"not_applicable\"","source_id":"foundry::tests/test_compliance.py::test_bias_assessment_not_applicable_for_irrelevant_family","task":"python_test_generation"}
{"id":"foundry::tests/test_compliance.py::test_compliance_matrix_aggregates_all_sections::generate","input":"Source path: tests/test_compliance.py\nDomains: privacy, release, commercial, license, compliance, source_card\nImports: primitive_foundry.compliance\nAssertion count: 6","instruction":"Write a pytest test for Primitive Foundry that verifies: test compliance matrix aggregates all sections.","output":"def test_compliance_matrix_aggregates_all_sections() -> None:\n    listing = {\n        \"release_id\": \"test_release\",\n        \"family\": \"privacy_provenance_eval\",\n        \"license\": \"private-commercial-evaluation\",\n    }\n    matrix = build_compliance_matrix(listing=listing, source_cards=[])\n    assert matrix[\"manifest_type\"] == \"compliance_matrix\"\n    assert matrix[\"all_source_licenses_compatible\"] is True\n    assert \"ear_classification\" in matrix\n    assert \"state_ai_posture\" in matrix\n    assert \"retention_policy\" in matrix\n    assert \"bias_assessment\" in matrix","source_id":"foundry::tests/test_compliance.py::test_compliance_matrix_aggregates_all_sections","task":"python_test_generation"}
{"id":"foundry::tests/test_compliance.py::test_write_compliance_matrix_lands_at_release_root::generate","input":"Source path: tests/test_compliance.py\nDomains: privacy, release, compliance\nImports: primitive_foundry.compliance\nAssertion count: 3","instruction":"Write a pytest test for Primitive Foundry that verifies: test write compliance matrix lands at release root.","output":"def test_write_compliance_matrix_lands_at_release_root(tmp_path: Path) -> None:\n    listing = {\"release_id\": \"r1\", \"family\": \"privacy_provenance_eval\"}\n    target = write_compliance_matrix(release_dir=tmp_path, listing=listing)\n    assert target.exists()\n    assert target.parent == tmp_path\n    payload = json.loads(target.read_text(encoding=\"utf-8\"))\n    assert payload[\"manifest_type\"] == \"compliance_matrix\"","source_id":"foundry::tests/test_compliance.py::test_write_compliance_matrix_lands_at_release_root","task":"python_test_generation"}
{"id":"foundry::tests/test_compliance.py::test_source_card_catalog_excludes_patent_and_kernel_mechanism_sources::generate","input":"Source path: tests/test_compliance.py\nDomains: compliance, source_card\nImports: primitive_foundry.compliance\nAssertion count: 3","instruction":"Write a pytest test for Primitive Foundry that verifies: test source card catalog excludes patent and kernel mechanism sources.","output":"def test_source_card_catalog_excludes_patent_and_kernel_mechanism_sources() -> None:\n    from primitive_foundry.generate_source_cards import SOURCE_CATALOG\n\n    blocked = {\"patent\", \"kernel\"}\n    assert all(item.get(\"source_family\") not in blocked for item in SOURCE_CATALOG)\n    assert all(\"PATENT.md\" not in str(item.get(\"source_path\")) for item in SOURCE_CATALOG)\n    assert all(\"kernel/README.md\" not in str(item.get(\"source_path\")) for item in SOURCE_CATALOG)","source_id":"foundry::tests/test_compliance.py::test_source_card_catalog_excludes_patent_and_kernel_mechanism_sources","task":"python_test_generation"}
{"id":"foundry::tests/test_curation_brain_llm.py::test_plan_curation_llm_advisor_disabled_by_default::generate","input":"Source path: tests/test_curation_brain_llm.py\nDomains: curation\nImports: primitive_foundry, primitive_foundry.curation_brain\nAssertion count: 1","instruction":"Write a pytest test for Primitive Foundry that verifies: test plan curation llm advisor disabled by default.","output":"def test_plan_curation_llm_advisor_disabled_by_default(events_path: Path,\n                                                       monkeypatch: pytest.MonkeyPatch) -> None:\n    monkeypatch.delenv(\"FOUNDRY_LLM_CURATION\", raising=False)\n    plan = plan_curation(events_path=events_path, min_value_score=0.0)\n    assert plan[\"llm_advisor\"][\"status\"] in {\"disabled\", \"skipped\"}","source_id":"foundry::tests/test_curation_brain_llm.py::test_plan_curation_llm_advisor_disabled_by_default","task":"python_test_generation"}
{"id":"foundry::tests/test_curation_brain_llm.py::test_plan_curation_llm_advisor_called_when_injected::generate","input":"Source path: tests/test_curation_brain_llm.py\nDomains: curation, dataset, benchmark\nImports: primitive_foundry, primitive_foundry.curation_brain\nAssertion count: 3","instruction":"Write a pytest test for Primitive Foundry that verifies: test plan curation llm advisor called when injected.","output":"def test_plan_curation_llm_advisor_called_when_injected(events_path: Path) -> None:\n    captured: list[dict[str, Any]] = []\n\n    def fake_advisor(summary: dict[str, Any]) -> dict[str, Any]:\n        captured.append(summary)\n        first_family = summary[\"opportunities\"][0][\"family\"]\n        return {\n            \"ranked_families\": [\n                {\n                    \"family\": first_family,\n                    \"rationale\": \"highest signal-to-noise; covers a regulated buyer segment\",\n                    \"complementary_kinds_to_add\": [\"eval_harness\", \"benchmark\"],\n                    \"recommend_research\": True,\n                }\n            ],\n            \"bundle_proposals\": [\n                {\n                    \"family\": first_family,\n                    \"composition\": [\"dataset\", \"eval_harness\", \"benchmark\"],\n                    \"complementary\": True,\n                    \"rationale\": \"standard complementary bundle\",\n                }\n            ],\n            \"advisor_notes\": \"ok\",\n        }\n\n    plan = plan_curation(events_path=events_path, llm_advisor=fake_advisor, min_value_score=0.0)\n    assert plan[\"llm_advisor\"][\"status\"] == \"ok\"\n    assert captured and \"opportunities\" in captured[0]\n    assert plan[\"llm_advisor\"][\"ranked_families\"][0][\"family\"] in {\n        item[\"family\"] for item in plan[\"opportunities\"]\n    }","source_id":"foundry::tests/test_curation_brain_llm.py::test_plan_curation_llm_advisor_called_when_injected","task":"python_test_generation"}
{"id":"foundry::tests/test_curation_brain_llm.py::test_plan_curation_llm_advisor_rejects_invented_families::generate","input":"Source path: tests/test_curation_brain_llm.py\nDomains: curation, dataset, benchmark\nImports: primitive_foundry, primitive_foundry.curation_brain\nAssertion count: 3","instruction":"Write a pytest test for Primitive Foundry that verifies: test plan curation llm advisor rejects invented families.","output":"def test_plan_curation_llm_advisor_rejects_invented_families(events_path: Path) -> None:\n    def lying_advisor(summary: dict[str, Any]) -> dict[str, Any]:\n        return {\n            \"ranked_families\": [\n                {\"family\": \"this_family_does_not_exist\", \"rationale\": \"x\",\n                 \"complementary_kinds_to_add\": [\"dataset\"]}\n            ],\n            \"bundle_proposals\": [\n                {\"family\": \"this_family_does_not_exist\",\n                 \"composition\": [\"dataset\", \"eval_harness\", \"benchmark\"],\n                 \"complementary\": True}\n            ],\n        }\n\n    plan = plan_curation(events_path=events_path, llm_advisor=lying_advisor, min_value_score=0.0)\n    assert plan[\"llm_advisor\"][\"status\"] == \"ok\"\n    assert plan[\"llm_advisor\"][\"ranked_families\"] == []\n    assert plan[\"llm_advisor\"][\"bundle_proposals\"] == []","source_id":"foundry::tests/test_curation_brain_llm.py::test_plan_curation_llm_advisor_rejects_invented_families","task":"python_test_generation"}
{"id":"foundry::tests/test_curation_brain_llm.py::test_plan_curation_llm_advisor_rejects_invalid_product_kinds::generate","input":"Source path: tests/test_curation_brain_llm.py\nDomains: curation, dataset\nImports: primitive_foundry, primitive_foundry.curation_brain\nAssertion count: 2","instruction":"Write a pytest test for Primitive Foundry that verifies: test plan curation llm advisor rejects invalid product kinds.","output":"def test_plan_curation_llm_advisor_rejects_invalid_product_kinds(events_path: Path) -> None:\n    family = None\n\n    def junk_advisor(summary: dict[str, Any]) -> dict[str, Any]:\n        nonlocal family\n        family = summary[\"opportunities\"][0][\"family\"]\n        return {\n            \"ranked_families\": [\n                {\"family\": family, \"complementary_kinds_to_add\": [\"llamasoup\", \"dataset\", \"unknown_kind\"]}\n            ],\n            \"bundle_proposals\": [\n                {\"family\": family, \"composition\": [\"dataset\", \"imaginary_kind\"], \"complementary\": False}\n            ],\n        }\n\n    plan = plan_curation(events_path=events_path, llm_advisor=junk_advisor, min_value_score=0.0)\n    advisor = plan[\"llm_advisor\"]\n    assert advisor[\"ranked_families\"][0][\"complementary_kinds_to_add\"] == [\"dataset\"]\n    assert advisor[\"bundle_proposals\"][0][\"composition\"] == [\"dataset\"]","source_id":"foundry::tests/test_curation_brain_llm.py::test_plan_curation_llm_advisor_rejects_invalid_product_kinds","task":"python_test_generation"}
{"id":"foundry::tests/test_curation_brain_llm.py::test_plan_curation_llm_advisor_errors_recover::generate","input":"Source path: tests/test_curation_brain_llm.py\nDomains: curation\nImports: primitive_foundry, primitive_foundry.curation_brain\nAssertion count: 3","instruction":"Write a pytest test for Primitive Foundry that verifies: test plan curation llm advisor errors recover.","output":"def test_plan_curation_llm_advisor_errors_recover(events_path: Path) -> None:\n    def boom(summary: dict[str, Any]) -> dict[str, Any]:\n        raise RuntimeError(\"model offline\")\n\n    plan = plan_curation(events_path=events_path, llm_advisor=boom, min_value_score=0.0)\n    assert plan[\"llm_advisor\"][\"status\"] == \"errored\"\n    assert plan[\"llm_advisor\"][\"error_class\"] == \"RuntimeError\"\n    # Plan itself still completes with the deterministic opportunities.\n    assert plan[\"opportunities\"], \"deterministic opportunities must still be computed\"","source_id":"foundry::tests/test_curation_brain_llm.py::test_plan_curation_llm_advisor_errors_recover","task":"python_test_generation"}
{"id":"foundry::tests/test_curation_brain_llm.py::test_llm_advisor_available_respects_env::generate","input":"Source path: tests/test_curation_brain_llm.py\nDomains: curation\nImports: primitive_foundry, primitive_foundry.curation_brain\nAssertion count: 3","instruction":"Write a pytest test for Primitive Foundry that verifies: test llm advisor available respects env.","output":"def test_llm_advisor_available_respects_env(monkeypatch: pytest.MonkeyPatch) -> None:\n    monkeypatch.setenv(\"FOUNDRY_LLM_CURATION\", \"0\")\n    assert llm_advisor_available() is False\n    monkeypatch.setenv(\"FOUNDRY_LLM_CURATION\", \"1\")\n    # Probe is mocked \u2192 only the env flag decides:\n    assert llm_advisor_available(probe=lambda _endpoint: True) is True\n    assert llm_advisor_available(probe=lambda _endpoint: False) is False","source_id":"foundry::tests/test_curation_brain_llm.py::test_llm_advisor_available_respects_env","task":"python_test_generation"}
{"id":"foundry::tests/test_curation_brain_llm.py::test_standing_orders_round_trip::generate","input":"Source path: tests/test_curation_brain_llm.py\nDomains: privacy, curation, dataset, benchmark\nImports: primitive_foundry, primitive_foundry.curation_brain\nAssertion count: 5","instruction":"Write a pytest test for Primitive Foundry that verifies: test standing orders round trip.","output":"def test_standing_orders_round_trip(tmp_path: Path) -> None:\n    orders = [\n        StandingOrder(\n            order_id=\"ord-hinge-001\",\n            priority=80,\n            focus_families=(\"privacy_provenance_eval\",),\n            product_kinds=(\"dataset\", \"eval_harness\", \"benchmark\"),\n            keywords=(\"gdpr\", \"ccpa\"),\n            require_complementary_bundle=True,\n            research_allowed=True,\n            source=\"hinge\",\n            notes=\"prioritize privacy provenance complementary bundles\",\n        )\n    ]\n    target = tmp_path / \"standing_orders.json\"\n    payload = write_standing_orders(target, orders)\n    assert payload[\"orders_hash\"]\n    assert target.exists()\n    loaded = curation_brain.load_standing_orders(target)\n    assert len(loaded) == 1\n    assert loaded[0].order_id == \"ord-hinge-001\"\n    assert loaded[0].require_complementary_bundle is True","source_id":"foundry::tests/test_curation_brain_llm.py::test_standing_orders_round_trip","task":"python_test_generation"}
{"id":"foundry::tests/test_exporters.py::test_croissant_payload_shape::generate","input":"Source path: tests/test_exporters.py\nDomains: release, license, dataset, exporter\nImports: primitive_foundry.exporters, primitive_foundry.exporters.croissant, primitive_foundry.exporters.dcat, primitive_foundry.exporters.schema_org_dataset\nAssertion count: 7","instruction":"Write a pytest test for Primitive Foundry that verifies: test croissant payload shape.","output":"def test_croissant_payload_shape(fake_release: tuple[Path, dict]) -> None:\n    release, listing = fake_release\n    payload = build_croissant(release, listing)\n    assert payload[\"@type\"] == \"sc:Dataset\"\n    assert payload[\"conformsTo\"].startswith(\"http://mlcommons.org/croissant\")\n    assert payload[\"@id\"] == listing[\"release_id\"]\n    assert payload[\"name\"] == listing[\"title\"]\n    assert payload[\"license\"] == listing[\"license\"]\n    assert len(payload[\"distribution\"]) >= 1\n    # Bundled records were hashed.\n    for entry in payload[\"distribution\"]:\n        assert entry[\"sha256\"] and len(entry[\"sha256\"]) == 64","source_id":"foundry::tests/test_exporters.py::test_croissant_payload_shape","task":"python_test_generation"}
{"id":"foundry::tests/test_exporters.py::test_croissant_is_written_at_release_root::generate","input":"Source path: tests/test_exporters.py\nDomains: release, marketplace, dataset, exporter\nImports: primitive_foundry.exporters, primitive_foundry.exporters.croissant, primitive_foundry.exporters.dcat, primitive_foundry.exporters.schema_org_dataset\nAssertion count: 3","instruction":"Write a pytest test for Primitive Foundry that verifies: test croissant is written at release root.","output":"def test_croissant_is_written_at_release_root(fake_release: tuple[Path, dict]) -> None:\n    release, listing = fake_release\n    target = write_croissant(release, listing)\n    assert target.exists()\n    # Sibling artifact lives at the release root, alongside MARKETPLACE_LISTING.json,\n    # to avoid invalidating bundle/MANIFEST.lock.\n    assert target.parent == release\n    payload = json.loads(target.read_text(encoding=\"utf-8\"))\n    assert payload[\"@type\"] == \"sc:Dataset\"","source_id":"foundry::tests/test_exporters.py::test_croissant_is_written_at_release_root","task":"python_test_generation"}
{"id":"foundry::tests/test_exporters.py::test_schema_org_payload_shape::generate","input":"Source path: tests/test_exporters.py\nDomains: release, dataset, exporter\nImports: primitive_foundry.exporters, primitive_foundry.exporters.croissant, primitive_foundry.exporters.dcat, primitive_foundry.exporters.schema_org_dataset\nAssertion count: 5","instruction":"Write a pytest test for Primitive Foundry that verifies: test schema org payload shape.","output":"def test_schema_org_payload_shape(fake_release: tuple[Path, dict]) -> None:\n    release, listing = fake_release\n    payload = build_schema_org_dataset(release, listing)\n    assert payload[\"@type\"] == \"Dataset\"\n    assert payload[\"@context\"] == \"https://schema.org/\"\n    assert payload[\"identifier\"] == listing[\"release_id\"]\n    assert payload[\"isAccessibleForFree\"] is False\n    assert payload[\"size\"][\"unitText\"] == \"records\"","source_id":"foundry::tests/test_exporters.py::test_schema_org_payload_shape","task":"python_test_generation"}
{"id":"foundry::tests/test_exporters.py::test_exporters_write_files::generate","input":"Source path: tests/test_exporters.py\nDomains: release, dataset, exporter\nImports: primitive_foundry.exporters, primitive_foundry.exporters.croissant, primitive_foundry.exporters.dcat, primitive_foundry.exporters.schema_org_dataset\nAssertion count: 1","instruction":"Write a pytest test for Primitive Foundry that verifies: test exporters write files.","output":"def test_exporters_write_files(fake_release: tuple[Path, dict]) -> None:\n    release, listing = fake_release\n    p1 = write_croissant(release, listing)\n    p2 = write_schema_org_dataset(release, listing)\n    p3 = write_dcat(release, listing)\n    for path in (p1, p2, p3):\n        payload = json.loads(path.read_text(encoding=\"utf-8\"))\n        assert isinstance(payload, dict)","source_id":"foundry::tests/test_exporters.py::test_exporters_write_files","task":"python_test_generation"}
{"id":"foundry::tests/test_exporters.py::test_croissant_skips_missing_data_files::generate","input":"Source path: tests/test_exporters.py\nDomains: privacy, release, exporter\nImports: primitive_foundry.exporters, primitive_foundry.exporters.croissant, primitive_foundry.exporters.dcat, primitive_foundry.exporters.schema_org_dataset\nAssertion count: 1","instruction":"Write a pytest test for Primitive Foundry that verifies: test croissant skips missing data files.","output":"def test_croissant_skips_missing_data_files(tmp_path: Path) -> None:\n    release = tmp_path / \"release\"\n    (release / \"bundle\").mkdir(parents=True)\n    listing = {\n        \"release_id\": \"minimal\",\n        \"family\": \"privacy_provenance_eval\",\n        \"title\": \"Minimal\",\n    }\n    payload = build_croissant(release, listing)\n    assert payload[\"distribution\"] == []","source_id":"foundry::tests/test_exporters.py::test_croissant_skips_missing_data_files","task":"python_test_generation"}
{"id":"foundry::tests/test_golden_fixture.py::test_golden_fixture_scores_reference_agent::generate","input":"Source path: tests/test_golden_fixture.py\nDomains: foundry\nImports: primitive_foundry.foundry_bridge, primitive_foundry.signing\nAssertion count: 4","instruction":"Write a pytest test for Primitive Foundry that verifies: test golden fixture scores reference agent.","output":"def test_golden_fixture_scores_reference_agent() -> None:\n    from primitive_harness.bundle import load_bundle\n    from primitive_harness.runner import run\n\n    loaded = load_bundle(BUNDLE_DIR, publisher_public_key=PUBLIC_KEY.read_bytes())\n\n    def reference_agent(record: dict) -> dict:\n        features = record.get(\"features\", {})\n        return {\n            \"selected_cell_ids\": features.get(\"expected_cell_ids\", []),\n            \"rubric_signals\": features.get(\"rubric\", {}).get(\"pass_if\", []),\n            \"rationale\": \"sanitized_export_present provenance_manifest_present control_id_mapped\",\n        }\n\n    report = run(reference_agent, loaded, seed=100)\n\n    assert report[\"seed\"] == 100\n    assert report[\"record_count\"] == 3\n    assert report[\"pass_rate\"] == 1.0\n    assert all(result[\"score\"][\"passed\"] for result in report[\"results\"])","source_id":"foundry::tests/test_golden_fixture.py::test_golden_fixture_scores_reference_agent","task":"python_test_generation"}
{"id":"foundry::tests/test_listing_gates.py::test_complementary_bundle_passes_when_complete::generate","input":"Source path: tests/test_listing_gates.py\nDomains: release, marketplace\nImports: primitive_foundry.commercial\nAssertion count: 1","instruction":"Write a pytest test for Primitive Foundry that verifies: test complementary bundle passes when complete.","output":"def test_complementary_bundle_passes_when_complete(tmp_path: Path) -> None:\n    release = _build_full_release(tmp_path)\n    listing = json.loads((release / \"MARKETPLACE_LISTING.json\").read_text())\n    assert verify_complementary_bundle(release, listing) == []","source_id":"foundry::tests/test_listing_gates.py::test_complementary_bundle_passes_when_complete","task":"python_test_generation"}
{"id":"foundry::tests/test_listing_gates.py::test_complementary_bundle_fails_without_dataset::generate","input":"Source path: tests/test_listing_gates.py\nDomains: release, marketplace, dataset\nImports: primitive_foundry.commercial\nAssertion count: 1","instruction":"Write a pytest test for Primitive Foundry that verifies: test complementary bundle fails without dataset.","output":"def test_complementary_bundle_fails_without_dataset(tmp_path: Path) -> None:\n    release = _build_full_release(tmp_path)\n    (release / \"bundle\" / \"data\" / \"train.jsonl\").unlink()\n    listing = json.loads((release / \"MARKETPLACE_LISTING.json\").read_text())\n    failures = verify_complementary_bundle(release, listing)\n    assert any(\"missing_dataset_records\" in f for f in failures)","source_id":"foundry::tests/test_listing_gates.py::test_complementary_bundle_fails_without_dataset","task":"python_test_generation"}
{"id":"foundry::tests/test_listing_gates.py::test_complementary_bundle_fails_without_quality_report::generate","input":"Source path: tests/test_listing_gates.py\nDomains: release, marketplace, benchmark\nImports: primitive_foundry.commercial\nAssertion count: 1","instruction":"Write a pytest test for Primitive Foundry that verifies: test complementary bundle fails without quality report.","output":"def test_complementary_bundle_fails_without_quality_report(tmp_path: Path) -> None:\n    release = _build_full_release(tmp_path)\n    (release / \"bundle\" / \"QUALITY_REPORT.md\").unlink()\n    listing = json.loads((release / \"MARKETPLACE_LISTING.json\").read_text())\n    failures = verify_complementary_bundle(release, listing)\n    assert any(\"missing_benchmark_evidence\" in f for f in failures)","source_id":"foundry::tests/test_listing_gates.py::test_complementary_bundle_fails_without_quality_report","task":"python_test_generation"}
{"id":"foundry::tests/test_listing_gates.py::test_complementary_bundle_fails_without_rubric::generate","input":"Source path: tests/test_listing_gates.py\nDomains: release, marketplace\nImports: primitive_foundry.commercial\nAssertion count: 1","instruction":"Write a pytest test for Primitive Foundry that verifies: test complementary bundle fails without rubric.","output":"def test_complementary_bundle_fails_without_rubric(tmp_path: Path) -> None:\n    release = _build_full_release(tmp_path)\n    listing = json.loads((release / \"MARKETPLACE_LISTING.json\").read_text())\n    listing.pop(\"rubric_id\")\n    failures = verify_complementary_bundle(release, listing)\n    assert any(\"missing_eval_rubric\" in f for f in failures)","source_id":"foundry::tests/test_listing_gates.py::test_complementary_bundle_fails_without_rubric","task":"python_test_generation"}
{"id":"foundry::tests/test_listing_gates.py::test_complementary_bundle_waiver_skips_gate::generate","input":"Source path: tests/test_listing_gates.py\nDomains: release, marketplace\nImports: primitive_foundry.commercial\nAssertion count: 1","instruction":"Write a pytest test for Primitive Foundry that verifies: test complementary bundle waiver skips gate.","output":"def test_complementary_bundle_waiver_skips_gate(tmp_path: Path) -> None:\n    release = _build_full_release(tmp_path)\n    (release / \"bundle\" / \"data\" / \"train.jsonl\").unlink()\n    (release / \"bundle\" / \"QUALITY_REPORT.md\").unlink()\n    listing = json.loads((release / \"MARKETPLACE_LISTING.json\").read_text())\n    listing[\"complementary_bundle_waived\"] = True\n    assert verify_complementary_bundle(release, listing) == []","source_id":"foundry::tests/test_listing_gates.py::test_complementary_bundle_waiver_skips_gate","task":"python_test_generation"}
{"id":"foundry::tests/test_listing_gates.py::test_card_accuracy_passes_with_evidence::generate","input":"Source path: tests/test_listing_gates.py\nDomains: release, marketplace\nImports: primitive_foundry.commercial\nAssertion count: 1","instruction":"Write a pytest test for Primitive Foundry that verifies: test card accuracy passes with evidence.","output":"def test_card_accuracy_passes_with_evidence(tmp_path: Path) -> None:\n    release = _build_full_release(tmp_path)\n    listing = json.loads((release / \"MARKETPLACE_LISTING.json\").read_text())\n    assert verify_card_accuracy(release, listing) == []","source_id":"foundry::tests/test_listing_gates.py::test_card_accuracy_passes_with_evidence","task":"python_test_generation"}
{"id":"foundry::tests/test_listing_gates.py::test_card_accuracy_flags_unverifiable_metric::generate","input":"Source path: tests/test_listing_gates.py\nDomains: release, marketplace\nImports: primitive_foundry.commercial\nAssertion count: 1","instruction":"Write a pytest test for Primitive Foundry that verifies: test card accuracy flags unverifiable metric.","output":"def test_card_accuracy_flags_unverifiable_metric(tmp_path: Path) -> None:\n    release = _build_full_release(tmp_path)\n    listing = json.loads((release / \"MARKETPLACE_LISTING.json\").read_text())\n    listing[\"quality\"][\"recall_at_10\"] = 0.97\n    failures = verify_card_accuracy(release, listing)\n    assert any(\"unverifiable_metric:recall_at_10\" in f for f in failures)","source_id":"foundry::tests/test_listing_gates.py::test_card_accuracy_flags_unverifiable_metric","task":"python_test_generation"}
{"id":"foundry::tests/test_listing_gates.py::test_card_accuracy_does_not_flag_bool_quality_flags::generate","input":"Source path: tests/test_listing_gates.py\nDomains: sterilization, release, marketplace\nImports: primitive_foundry.commercial\nAssertion count: 3","instruction":"Write a pytest test for Primitive Foundry that verifies: test card accuracy does not flag bool quality flags.","output":"def test_card_accuracy_does_not_flag_bool_quality_flags(tmp_path: Path) -> None:\n    release = _build_full_release(tmp_path)\n    listing = json.loads((release / \"MARKETPLACE_LISTING.json\").read_text())\n    # promotion_passed, review_passed, sterilization_passed are bools\n    failures = verify_card_accuracy(release, listing)\n    assert not any(\"promotion_passed\" in f for f in failures)\n    assert not any(\"review_passed\" in f for f in failures)\n    assert not any(\"sterilization_passed\" in f for f in failures)","source_id":"foundry::tests/test_listing_gates.py::test_card_accuracy_does_not_flag_bool_quality_flags","task":"python_test_generation"}
{"id":"foundry::tests/test_listing_gates.py::test_build_ftc_claims_matrix_has_all_metrics::generate","input":"Source path: tests/test_listing_gates.py\nDomains: release, marketplace, benchmark\nImports: primitive_foundry.commercial\nAssertion count: 4","instruction":"Write a pytest test for Primitive Foundry that verifies: test build ftc claims matrix has all metrics.","output":"def test_build_ftc_claims_matrix_has_all_metrics(tmp_path: Path) -> None:\n    release = _build_full_release(tmp_path)\n    listing = json.loads((release / \"MARKETPLACE_LISTING.json\").read_text())\n    matrix = build_ftc_claims_matrix(release, listing)\n    assert matrix[\"manifest_type\"] == \"ftc_claims_matrix\"\n    assert matrix[\"all_claims_have_evidence\"] is True\n    claimed_metrics = {item[\"metric\"] for item in matrix[\"claims\"]}\n    assert \"benchmark_pass_rate\" in claimed_metrics\n    assert \"estimated_buyer_value\" in claimed_metrics","source_id":"foundry::tests/test_listing_gates.py::test_build_ftc_claims_matrix_has_all_metrics","task":"python_test_generation"}
{"id":"foundry::tests/test_listing_gates.py::test_build_ftc_claims_matrix_marks_missing_evidence::generate","input":"Source path: tests/test_listing_gates.py\nDomains: release, marketplace\nImports: primitive_foundry.commercial\nAssertion count: 2","instruction":"Write a pytest test for Primitive Foundry that verifies: test build ftc claims matrix marks missing evidence.","output":"def test_build_ftc_claims_matrix_marks_missing_evidence(tmp_path: Path) -> None:\n    release = _build_full_release(tmp_path)\n    (release / \"bundle\" / \"QUALITY_REPORT.md\").unlink()\n    listing = json.loads((release / \"MARKETPLACE_LISTING.json\").read_text())\n    matrix = build_ftc_claims_matrix(release, listing)\n    assert matrix[\"all_claims_have_evidence\"] is False\n    assert any(not item[\"evidence_present\"] for item in matrix[\"claims\"])","source_id":"foundry::tests/test_listing_gates.py::test_build_ftc_claims_matrix_marks_missing_evidence","task":"python_test_generation"}
{"id":"foundry::tests/test_local_benchmark.py::test_seed_dataset_loads::generate","input":"Source path: tests/test_local_benchmark.py\nDomains: dataset, benchmark\nImports: primitive_foundry.cells, primitive_foundry.commercial, primitive_foundry.compare, primitive_foundry.curation_brain, primitive_foundry.dataset, primitive_foundry.external_listing, primitive_foundry.foundry_bridge, primitive_foundry.generate_source_cards, primitive_foundry.generators, primitive_foundry.inspect_adapter, primitive_foundry.lifecycle, primitive_foundry.marketplace_packet, primitive_foundry.node_ops, primitive_foundry.primitive_bus_adapter, primitive_foundry.product_factory, primitive_foundry.product_planner, primitive_foundry.promotion, primitive_foundry.release, primitive_foundry.runner, primitive_foundry.scorers, primitive_foundry.source_curation, primitive_foundry.sterilization, primitive_foundry.summary, primitive_foundry.train_router, primitive_foundry.v04\nAssertion count: 2","instruction":"Write a pytest test for Primitive Foundry that verifies: test seed dataset loads.","output":"def test_seed_dataset_loads() -> None:\n    records = load_jsonl(\"datasets/seed/aml_seed.jsonl\")\n    assert len(records) == 10\n    assert records[0].expected_cell_id == \"finance.tax.2024\"","source_id":"foundry::tests/test_local_benchmark.py::test_seed_dataset_loads","task":"python_test_generation"}
{"id":"foundry::tests/test_local_benchmark.py::test_legacy_record_migration_backfills_schema_fields::generate","input":"Source path: tests/test_local_benchmark.py\nDomains: privacy, benchmark\nImports: primitive_foundry.cells, primitive_foundry.commercial, primitive_foundry.compare, primitive_foundry.curation_brain, primitive_foundry.dataset, primitive_foundry.external_listing, primitive_foundry.foundry_bridge, primitive_foundry.generate_source_cards, primitive_foundry.generators, primitive_foundry.inspect_adapter, primitive_foundry.lifecycle, primitive_foundry.marketplace_packet, primitive_foundry.node_ops, primitive_foundry.primitive_bus_adapter, primitive_foundry.product_factory, primitive_foundry.product_planner, primitive_foundry.promotion, primitive_foundry.release, primitive_foundry.runner, primitive_foundry.scorers, primitive_foundry.source_curation, primitive_foundry.sterilization, primitive_foundry.summary, primitive_foundry.train_router, primitive_foundry.v04\nAssertion count: 4","instruction":"Write a pytest test for Primitive Foundry that verifies: test legacy record migration backfills schema fields.","output":"def test_legacy_record_migration_backfills_schema_fields() -> None:\n    from primitive_foundry.schema import AMLRecord, FoundryRecord\n\n    record = FoundryRecord.from_dict(\n        {\n            \"record_id\": \"legacy-1\",\n            \"query\": \"route privacy query\",\n            \"expected_answer\": \"legal.privacy.2024\",\n            \"domain_path\": \"legal.privacy\",\n            \"expected_cell_id\": \"legal.privacy.2024\",\n            \"valid_from\": \"2024-01-01\",\n            \"metadata\": {},\n        }\n    )\n\n    assert record.rubric_id == \"route_and_provenance\"\n    assert record.domain_review == {}\n    assert record.family_fields == {}\n    assert AMLRecord is FoundryRecord","source_id":"foundry::tests/test_local_benchmark.py::test_legacy_record_migration_backfills_schema_fields","task":"python_test_generation"}
{"id":"foundry::tests/test_local_benchmark.py::test_public_primitive_foundry_namespace_imports_cli::generate","input":"Source path: tests/test_local_benchmark.py\nDomains: benchmark\nImports: primitive_foundry.cells, primitive_foundry.commercial, primitive_foundry.compare, primitive_foundry.curation_brain, primitive_foundry.dataset, primitive_foundry.external_listing, primitive_foundry.foundry_bridge, primitive_foundry.generate_source_cards, primitive_foundry.generators, primitive_foundry.inspect_adapter, primitive_foundry.lifecycle, primitive_foundry.marketplace_packet, primitive_foundry.node_ops, primitive_foundry.primitive_bus_adapter, primitive_foundry.product_factory, primitive_foundry.product_planner, primitive_foundry.promotion, primitive_foundry.release, primitive_foundry.runner, primitive_foundry.scorers, primitive_foundry.source_curation, primitive_foundry.sterilization, primitive_foundry.summary, primitive_foundry.train_router, primitive_foundry.v04\nAssertion count: 4","instruction":"Write a pytest test for Primitive Foundry that verifies: test public primitive foundry namespace imports cli.","output":"def test_public_primitive_foundry_namespace_imports_cli() -> None:\n    import subprocess\n    import sys\n\n    import primitive_foundry\n    from primitive_foundry.cli import main\n\n    assert primitive_foundry.__all__\n    assert callable(main)\n    proc = subprocess.run(\n        [sys.executable, \"-m\", \"primitive_foundry.cli\", \"--help\"],\n        text=True,\n        capture_output=True,\n        check=False,\n    )\n    assert proc.returncode == 0\n    assert \"usage: primitive-foundry\" in proc.stdout","source_id":"foundry::tests/test_local_benchmark.py::test_public_primitive_foundry_namespace_imports_cli","task":"python_test_generation"}
{"id":"foundry::tests/test_local_benchmark.py::test_seed_benchmark_passes::generate","input":"Source path: tests/test_local_benchmark.py\nDomains: dataset, benchmark\nImports: primitive_foundry.cells, primitive_foundry.commercial, primitive_foundry.compare, primitive_foundry.curation_brain, primitive_foundry.dataset, primitive_foundry.external_listing, primitive_foundry.foundry_bridge, primitive_foundry.generate_source_cards, primitive_foundry.generators, primitive_foundry.inspect_adapter, primitive_foundry.lifecycle, primitive_foundry.marketplace_packet, primitive_foundry.node_ops, primitive_foundry.primitive_bus_adapter, primitive_foundry.product_factory, primitive_foundry.product_planner, primitive_foundry.promotion, primitive_foundry.release, primitive_foundry.runner, primitive_foundry.scorers, primitive_foundry.source_curation, primitive_foundry.sterilization, primitive_foundry.summary, primitive_foundry.train_router, primitive_foundry.v04\nAssertion count: 3","instruction":"Write a pytest test for Primitive Foundry that verifies: test seed benchmark passes.","output":"def test_seed_benchmark_passes() -> None:\n    report = BenchmarkRunner().run_dataset(\"datasets/seed/aml_seed.jsonl\")\n    assert report[\"record_count\"] == 10\n    assert report[\"pass_rate\"] == 1.0\n    assert report[\"metrics\"][\"routing\"] == 1.0","source_id":"foundry::tests/test_local_benchmark.py::test_seed_benchmark_passes","task":"python_test_generation"}
{"id":"foundry::tests/test_local_benchmark.py::test_seeded_runner_reports_are_byte_stable::generate","input":"Source path: tests/test_local_benchmark.py\nDomains: dataset, benchmark\nImports: primitive_foundry.cells, primitive_foundry.commercial, primitive_foundry.compare, primitive_foundry.curation_brain, primitive_foundry.dataset, primitive_foundry.external_listing, primitive_foundry.foundry_bridge, primitive_foundry.generate_source_cards, primitive_foundry.generators, primitive_foundry.inspect_adapter, primitive_foundry.lifecycle, primitive_foundry.marketplace_packet, primitive_foundry.node_ops, primitive_foundry.primitive_bus_adapter, primitive_foundry.product_factory, primitive_foundry.product_planner, primitive_foundry.promotion, primitive_foundry.release, primitive_foundry.runner, primitive_foundry.scorers, primitive_foundry.source_curation, primitive_foundry.sterilization, primitive_foundry.summary, primitive_foundry.train_router, primitive_foundry.v04\nAssertion count: 2","instruction":"Write a pytest test for Primitive Foundry that verifies: test seeded runner reports are byte stable.","output":"def test_seeded_runner_reports_are_byte_stable() -> None:\n    import json\n\n    first = BenchmarkRunner(seed=123).run_dataset(\"datasets/seed/aml_seed.jsonl\")\n    second = BenchmarkRunner(seed=123).run_dataset(\"datasets/seed/aml_seed.jsonl\")\n\n    assert first[\"seed\"] == 123\n    assert json.dumps(first, sort_keys=True) == json.dumps(second, sort_keys=True)","source_id":"foundry::tests/test_local_benchmark.py::test_seeded_runner_reports_are_byte_stable","task":"python_test_generation"}
{"id":"foundry::tests/test_local_benchmark.py::test_v02_dataset_loads::generate","input":"Source path: tests/test_local_benchmark.py\nDomains: dataset, benchmark\nImports: primitive_foundry.cells, primitive_foundry.commercial, primitive_foundry.compare, primitive_foundry.curation_brain, primitive_foundry.dataset, primitive_foundry.external_listing, primitive_foundry.foundry_bridge, primitive_foundry.generate_source_cards, primitive_foundry.generators, primitive_foundry.inspect_adapter, primitive_foundry.lifecycle, primitive_foundry.marketplace_packet, primitive_foundry.node_ops, primitive_foundry.primitive_bus_adapter, primitive_foundry.product_factory, primitive_foundry.product_planner, primitive_foundry.promotion, primitive_foundry.release, primitive_foundry.runner, primitive_foundry.scorers, primitive_foundry.source_curation, primitive_foundry.sterilization, primitive_foundry.summary, primitive_foundry.train_router, primitive_foundry.v04\nAssertion count: 2","instruction":"Write a pytest test for Primitive Foundry that verifies: test v02 dataset loads.","output":"def test_v02_dataset_loads() -> None:\n    records = load_jsonl(\"datasets/v0.2/aml_v0_2.jsonl\")\n    assert len(records) == 100\n    assert {record.source_type for record in records} == {\"synthetic\"}","source_id":"foundry::tests/test_local_benchmark.py::test_v02_dataset_loads","task":"python_test_generation"}
{"id":"foundry::tests/test_local_benchmark.py::test_v02_hashed_embedding_router_passes_top_k::generate","input":"Source path: tests/test_local_benchmark.py\nDomains: dataset, router, benchmark\nImports: primitive_foundry.cells, primitive_foundry.commercial, primitive_foundry.compare, primitive_foundry.curation_brain, primitive_foundry.dataset, primitive_foundry.external_listing, primitive_foundry.foundry_bridge, primitive_foundry.generate_source_cards, primitive_foundry.generators, primitive_foundry.inspect_adapter, primitive_foundry.lifecycle, primitive_foundry.marketplace_packet, primitive_foundry.node_ops, primitive_foundry.primitive_bus_adapter, primitive_foundry.product_factory, primitive_foundry.product_planner, primitive_foundry.promotion, primitive_foundry.release, primitive_foundry.runner, primitive_foundry.scorers, primitive_foundry.source_curation, primitive_foundry.sterilization, primitive_foundry.summary, primitive_foundry.train_router, primitive_foundry.v04\nAssertion count: 3","instruction":"Write a pytest test for Primitive Foundry that verifies: test v02 hashed embedding router passes top k.","output":"def test_v02_hashed_embedding_router_passes_top_k() -> None:\n    report = BenchmarkRunner(router_name=\"hashed-embedding\").run_dataset(\"datasets/v0.2/aml_v0_2.jsonl\")\n    assert report[\"record_count\"] == 100\n    assert report[\"router\"] == \"hashed-embedding\"\n    assert report[\"metrics\"][\"top_k_routing\"] >= 0.95","source_id":"foundry::tests/test_local_benchmark.py::test_v02_hashed_embedding_router_passes_top_k","task":"python_test_generation"}
{"id":"foundry::tests/test_local_benchmark.py::test_inspect_sample_mapping::generate","input":"Source path: tests/test_local_benchmark.py\nDomains: license, dataset, benchmark\nImports: primitive_foundry.cells, primitive_foundry.commercial, primitive_foundry.compare, primitive_foundry.curation_brain, primitive_foundry.dataset, primitive_foundry.external_listing, primitive_foundry.foundry_bridge, primitive_foundry.generate_source_cards, primitive_foundry.generators, primitive_foundry.inspect_adapter, primitive_foundry.lifecycle, primitive_foundry.marketplace_packet, primitive_foundry.node_ops, primitive_foundry.primitive_bus_adapter, primitive_foundry.product_factory, primitive_foundry.product_planner, primitive_foundry.promotion, primitive_foundry.release, primitive_foundry.runner, primitive_foundry.scorers, primitive_foundry.source_curation, primitive_foundry.sterilization, primitive_foundry.summary, primitive_foundry.train_router, primitive_foundry.v04\nAssertion count: 3","instruction":"Write a pytest test for Primitive Foundry that verifies: test inspect sample mapping.","output":"def test_inspect_sample_mapping() -> None:\n    samples = records_to_inspect_samples(\"datasets/v0.2/aml_v0_2.jsonl\")\n    assert len(samples) == 100\n    assert samples[0][\"target\"] == \"finance.tax.2024\"\n    assert samples[0][\"metadata\"][\"license\"] == \"private-synthetic\"","source_id":"foundry::tests/test_local_benchmark.py::test_inspect_sample_mapping","task":"python_test_generation"}
{"id":"foundry::tests/test_local_benchmark.py::test_v03_dataset_loads_and_has_multi_cell_records::generate","input":"Source path: tests/test_local_benchmark.py\nDomains: dataset, benchmark\nImports: primitive_foundry.cells, primitive_foundry.commercial, primitive_foundry.compare, primitive_foundry.curation_brain, primitive_foundry.dataset, primitive_foundry.external_listing, primitive_foundry.foundry_bridge, primitive_foundry.generate_source_cards, primitive_foundry.generators, primitive_foundry.inspect_adapter, primitive_foundry.lifecycle, primitive_foundry.marketplace_packet, primitive_foundry.node_ops, primitive_foundry.primitive_bus_adapter, primitive_foundry.product_factory, primitive_foundry.product_planner, primitive_foundry.promotion, primitive_foundry.release, primitive_foundry.runner, primitive_foundry.scorers, primitive_foundry.source_curation, primitive_foundry.sterilization, primitive_foundry.summary, primitive_foundry.train_router, primitive_foundry.v04\nAssertion count: 2","instruction":"Write a pytest test for Primitive Foundry that verifies: test v03 dataset loads and has multi cell records.","output":"def test_v03_dataset_loads_and_has_multi_cell_records() -> None:\n    records = load_jsonl(\"datasets/v0.3/aml_v0_3.jsonl\")\n    assert len(records) == 150\n    assert any(len(record.expected_cell_ids) > 1 for record in records)","source_id":"foundry::tests/test_local_benchmark.py::test_v03_dataset_loads_and_has_multi_cell_records","task":"python_test_generation"}
{"id":"foundry::tests/test_local_benchmark.py::test_v03_keyword_benchmark_passes::generate","input":"Source path: tests/test_local_benchmark.py\nDomains: dataset, router, benchmark\nImports: primitive_foundry.cells, primitive_foundry.commercial, primitive_foundry.compare, primitive_foundry.curation_brain, primitive_foundry.dataset, primitive_foundry.external_listing, primitive_foundry.foundry_bridge, primitive_foundry.generate_source_cards, primitive_foundry.generators, primitive_foundry.inspect_adapter, primitive_foundry.lifecycle, primitive_foundry.marketplace_packet, primitive_foundry.node_ops, primitive_foundry.primitive_bus_adapter, primitive_foundry.product_factory, primitive_foundry.product_planner, primitive_foundry.promotion, primitive_foundry.release, primitive_foundry.runner, primitive_foundry.scorers, primitive_foundry.source_curation, primitive_foundry.sterilization, primitive_foundry.summary, primitive_foundry.train_router, primitive_foundry.v04\nAssertion count: 3","instruction":"Write a pytest test for Primitive Foundry that verifies: test v03 keyword benchmark passes.","output":"def test_v03_keyword_benchmark_passes() -> None:\n    report = BenchmarkRunner(router_name=\"keyword\").run_dataset(\"datasets/v0.3/aml_v0_3.jsonl\")\n    assert report[\"record_count\"] == 150\n    assert report[\"pass_rate\"] == 1.0\n    assert report[\"metrics\"][\"expected_cells_coverage\"] == 1.0","source_id":"foundry::tests/test_local_benchmark.py::test_v03_keyword_benchmark_passes","task":"python_test_generation"}
{"id":"foundry::tests/test_local_benchmark.py::test_v03_hashed_embedding_exposes_regressions_but_covers_top_k::generate","input":"Source path: tests/test_local_benchmark.py\nDomains: dataset, router, benchmark\nImports: primitive_foundry.cells, primitive_foundry.commercial, primitive_foundry.compare, primitive_foundry.curation_brain, primitive_foundry.dataset, primitive_foundry.external_listing, primitive_foundry.foundry_bridge, primitive_foundry.generate_source_cards, primitive_foundry.generators, primitive_foundry.inspect_adapter, primitive_foundry.lifecycle, primitive_foundry.marketplace_packet, primitive_foundry.node_ops, primitive_foundry.primitive_bus_adapter, primitive_foundry.product_factory, primitive_foundry.product_planner, primitive_foundry.promotion, primitive_foundry.release, primitive_foundry.runner, primitive_foundry.scorers, primitive_foundry.source_curation, primitive_foundry.sterilization, primitive_foundry.summary, primitive_foundry.train_router, primitive_foundry.v04\nAssertion count: 3","instruction":"Write a pytest test for Primitive Foundry that verifies: test v03 hashed embedding exposes regressions but covers top k.","output":"def test_v03_hashed_embedding_exposes_regressions_but_covers_top_k() -> None:\n    report = BenchmarkRunner(router_name=\"hashed-embedding\").run_dataset(\"datasets/v0.3/aml_v0_3.jsonl\")\n    assert report[\"record_count\"] == 150\n    assert report[\"pass_rate\"] < 1.0\n    assert report[\"metrics\"][\"top_k_routing\"] == 1.0","source_id":"foundry::tests/test_local_benchmark.py::test_v03_hashed_embedding_exposes_regressions_but_covers_top_k","task":"python_test_generation"}
{"id":"foundry::tests/test_local_benchmark.py::test_lifecycle_events_and_simulation::generate","input":"Source path: tests/test_local_benchmark.py\nDomains: dataset, benchmark\nImports: primitive_foundry.cells, primitive_foundry.commercial, primitive_foundry.compare, primitive_foundry.curation_brain, primitive_foundry.dataset, primitive_foundry.external_listing, primitive_foundry.foundry_bridge, primitive_foundry.generate_source_cards, primitive_foundry.generators, primitive_foundry.inspect_adapter, primitive_foundry.lifecycle, primitive_foundry.marketplace_packet, primitive_foundry.node_ops, primitive_foundry.primitive_bus_adapter, primitive_foundry.product_factory, primitive_foundry.product_planner, primitive_foundry.promotion, primitive_foundry.release, primitive_foundry.runner, primitive_foundry.scorers, primitive_foundry.source_curation, primitive_foundry.sterilization, primitive_foundry.summary, primitive_foundry.train_router, primitive_foundry.v04\nAssertion count: 3","instruction":"Write a pytest test for Primitive Foundry that verifies: test lifecycle events and simulation.","output":"def test_lifecycle_events_and_simulation() -> None:\n    events = build_lifecycle_events(\"datasets/v0.3/aml_v0_3.jsonl\")\n    simulation = simulate_replacement(\"datasets/v0.3/aml_v0_3.jsonl\")\n    assert len(events) == 10\n    assert simulation[\"event_count\"] == 10\n    assert \"finance.tax.2023\" in simulation[\"replacement_map\"]","source_id":"foundry::tests/test_local_benchmark.py::test_lifecycle_events_and_simulation","task":"python_test_generation"}
{"id":"foundry::tests/test_local_benchmark.py::test_compare_reports::generate","input":"Source path: tests/test_local_benchmark.py\nDomains: dataset, router, benchmark\nImports: primitive_foundry.cells, primitive_foundry.commercial, primitive_foundry.compare, primitive_foundry.curation_brain, primitive_foundry.dataset, primitive_foundry.external_listing, primitive_foundry.foundry_bridge, primitive_foundry.generate_source_cards, primitive_foundry.generators, primitive_foundry.inspect_adapter, primitive_foundry.lifecycle, primitive_foundry.marketplace_packet, primitive_foundry.node_ops, primitive_foundry.primitive_bus_adapter, primitive_foundry.product_factory, primitive_foundry.product_planner, primitive_foundry.promotion, primitive_foundry.release, primitive_foundry.runner, primitive_foundry.scorers, primitive_foundry.source_curation, primitive_foundry.sterilization, primitive_foundry.summary, primitive_foundry.train_router, primitive_foundry.v04\nAssertion count: 3","instruction":"Write a pytest test for Primitive Foundry that verifies: test compare reports.","output":"def test_compare_reports(tmp_path) -> None:\n    before = BenchmarkRunner(router_name=\"keyword\").run_dataset(\"datasets/v0.3/aml_v0_3.jsonl\")\n    after = BenchmarkRunner(router_name=\"hashed-embedding\").run_dataset(\"datasets/v0.3/aml_v0_3.jsonl\")\n    before_path = write_report(before, tmp_path)\n    after_path = write_report(after, tmp_path)\n    comparison = compare_reports(before_path, after_path)\n    assert comparison[\"shared_records\"] == 150\n    assert comparison[\"after_pass_rate\"] < comparison[\"before_pass_rate\"]\n    assert comparison[\"regressions\"]","source_id":"foundry::tests/test_local_benchmark.py::test_compare_reports","task":"python_test_generation"}
{"id":"foundry::tests/test_local_benchmark.py::test_v04_artifacts_and_trained_router::generate","input":"Source path: tests/test_local_benchmark.py\nDomains: dataset, router, benchmark\nImports: primitive_foundry.cells, primitive_foundry.commercial, primitive_foundry.compare, primitive_foundry.curation_brain, primitive_foundry.dataset, primitive_foundry.external_listing, primitive_foundry.foundry_bridge, primitive_foundry.generate_source_cards, primitive_foundry.generators, primitive_foundry.inspect_adapter, primitive_foundry.lifecycle, primitive_foundry.marketplace_packet, primitive_foundry.node_ops, primitive_foundry.primitive_bus_adapter, primitive_foundry.product_factory, primitive_foundry.product_planner, primitive_foundry.promotion, primitive_foundry.release, primitive_foundry.runner, primitive_foundry.scorers, primitive_foundry.source_curation, primitive_foundry.sterilization, primitive_foundry.summary, primitive_foundry.train_router, primitive_foundry.v04\nAssertion count: 9","instruction":"Write a pytest test for Primitive Foundry that verifies: test v04 artifacts and trained router.","output":"def test_v04_artifacts_and_trained_router(tmp_path) -> None:\n    dataset_dir = tmp_path / \"datasets\"\n    registry_dir = tmp_path / \"registries\"\n    paths = build_v04_splits(dataset_dir)\n    registry_paths = write_registry_snapshots(registry_dir)\n    assert paths[\"train\"].exists()\n    assert paths[\"eval\"].exists()\n    assert paths[\"hard\"].exists()\n    assert registry_paths[\"pre\"].exists()\n    assert registry_paths[\"post\"].exists()\n\n    model_path = tmp_path / \"router.json\"\n    model = train_centroid_router(paths[\"train\"], model_path)\n    assert model_path.exists()\n    assert len(model[\"cell_ids\"]) == 6\n\n    eval_report = BenchmarkRunner(router_name=\"trained\", router_path=model_path).run_dataset(paths[\"eval\"])\n    hard_report = BenchmarkRunner(router_name=\"trained\", router_path=model_path).run_dataset(paths[\"hard\"])\n    assert eval_report[\"pass_rate\"] == 1.0\n    assert hard_report[\"metrics\"][\"top_k_routing\"] == 1.0","source_id":"foundry::tests/test_local_benchmark.py::test_v04_artifacts_and_trained_router","task":"python_test_generation"}
{"id":"foundry::tests/test_local_benchmark.py::test_registry_snapshots_execute_pre_post_transition::generate","input":"Source path: tests/test_local_benchmark.py\nDomains: dataset, router, benchmark\nImports: primitive_foundry.cells, primitive_foundry.commercial, primitive_foundry.compare, primitive_foundry.curation_brain, primitive_foundry.dataset, primitive_foundry.external_listing, primitive_foundry.foundry_bridge, primitive_foundry.generate_source_cards, primitive_foundry.generators, primitive_foundry.inspect_adapter, primitive_foundry.lifecycle, primitive_foundry.marketplace_packet, primitive_foundry.node_ops, primitive_foundry.primitive_bus_adapter, primitive_foundry.product_factory, primitive_foundry.product_planner, primitive_foundry.promotion, primitive_foundry.release, primitive_foundry.runner, primitive_foundry.scorers, primitive_foundry.source_curation, primitive_foundry.sterilization, primitive_foundry.summary, primitive_foundry.train_router, primitive_foundry.v04\nAssertion count: 7","instruction":"Write a pytest test for Primitive Foundry that verifies: test registry snapshots execute pre post transition.","output":"def test_registry_snapshots_execute_pre_post_transition() -> None:\n    pre = CellRegistry.from_json(\"registries/v0.4/pre_replacement.json\")\n    post = CellRegistry.from_json(\"registries/v0.4/post_replacement.json\")\n    assert pre.current_for_domain(\"finance.tax\").cell_id == \"finance.tax.2023\"\n    assert post.current_for_domain(\"finance.tax\").cell_id == \"finance.tax.2024\"\n\n    simulation = simulate_registry_transition(\n        \"datasets/v0.4/hard.jsonl\",\n        \"registries/v0.4/pre_replacement.json\",\n        \"registries/v0.4/post_replacement.json\",\n    )\n    assert simulation[\"record_count\"] > 0\n    assert simulation[\"changed_count\"] == simulation[\"record_count\"]\n    assert simulation[\"post_match_rate\"] == 1.0\n\n    pre_report = BenchmarkRunner(\n        router_name=\"keyword\",\n        registry_path=\"registries/v0.4/pre_replacement.json\",\n    ).run_dataset(\"datasets/v0.4/hard.jsonl\")\n    post_report = BenchmarkRunner(\n        router_name=\"keyword\",\n        registry_path=\"registries/v0.4/post_replacement.json\",\n    ).run_dataset(\"datasets/v0.4/hard.jsonl\")\n    assert pre_report[\"pass_rate\"] < post_report[\"pass_rate\"]\n    assert post_report[\"pass_rate\"] == 1.0","source_id":"foundry::tests/test_local_benchmark.py::test_registry_snapshots_execute_pre_post_transition","task":"python_test_generation"}
{"id":"foundry::tests/test_local_benchmark.py::test_apply_lifecycle_events_produces_executable_registry::generate","input":"Source path: tests/test_local_benchmark.py\nDomains: dataset, router, benchmark\nImports: primitive_foundry.cells, primitive_foundry.commercial, primitive_foundry.compare, primitive_foundry.curation_brain, primitive_foundry.dataset, primitive_foundry.external_listing, primitive_foundry.foundry_bridge, primitive_foundry.generate_source_cards, primitive_foundry.generators, primitive_foundry.inspect_adapter, primitive_foundry.lifecycle, primitive_foundry.marketplace_packet, primitive_foundry.node_ops, primitive_foundry.primitive_bus_adapter, primitive_foundry.product_factory, primitive_foundry.product_planner, primitive_foundry.promotion, primitive_foundry.release, primitive_foundry.runner, primitive_foundry.scorers, primitive_foundry.source_curation, primitive_foundry.sterilization, primitive_foundry.summary, primitive_foundry.train_router, primitive_foundry.v04\nAssertion count: 3","instruction":"Write a pytest test for Primitive Foundry that verifies: test apply lifecycle events produces executable registry.","output":"def test_apply_lifecycle_events_produces_executable_registry(tmp_path) -> None:\n    events = build_lifecycle_events(\"datasets/v0.3/aml_v0_3.jsonl\")\n    events_path = tmp_path / \"events.jsonl\"\n    output_registry = tmp_path / \"post_from_events.json\"\n    write_lifecycle_events(events, events_path)\n\n    result = apply_lifecycle_events(\n        \"registries/v0.4/pre_replacement.json\",\n        events_path,\n        output_registry,\n        registry_version=\"test-event-applied\",\n    )\n    assert result[\"applied_count\"] == 10\n\n    registry = CellRegistry.from_json(output_registry)\n    assert registry.current_for_domain(\"finance.tax\").cell_id == \"finance.tax.2024\"\n    report = BenchmarkRunner(\n        router_name=\"keyword\",\n        registry=registry,\n    ).run_dataset(\"datasets/v0.4/hard.jsonl\")\n    assert report[\"pass_rate\"] == 1.0","source_id":"foundry::tests/test_local_benchmark.py::test_apply_lifecycle_events_produces_executable_registry","task":"python_test_generation"}
{"id":"foundry::tests/test_local_benchmark.py::test_foundry_compatible_export_verify_and_bundle::generate","input":"Source path: tests/test_local_benchmark.py\nDomains: dataset, benchmark\nImports: primitive_foundry.cells, primitive_foundry.commercial, primitive_foundry.compare, primitive_foundry.curation_brain, primitive_foundry.dataset, primitive_foundry.external_listing, primitive_foundry.foundry_bridge, primitive_foundry.generate_source_cards, primitive_foundry.generators, primitive_foundry.inspect_adapter, primitive_foundry.lifecycle, primitive_foundry.marketplace_packet, primitive_foundry.node_ops, primitive_foundry.primitive_bus_adapter, primitive_foundry.product_factory, primitive_foundry.product_planner, primitive_foundry.promotion, primitive_foundry.release, primitive_foundry.runner, primitive_foundry.scorers, primitive_foundry.source_curation, primitive_foundry.sterilization, primitive_foundry.summary, primitive_foundry.train_router, primitive_foundry.v04\nAssertion count: 13","instruction":"Write a pytest test for Primitive Foundry that verifies: test foundry compatible export verify and bundle.","output":"def test_foundry_compatible_export_verify_and_bundle(tmp_path) -> None:\n    records_path = tmp_path / \"aml_foundry.jsonl\"\n    bundle_dir = tmp_path / \"bundle\"\n    export = export_foundry_records(\"datasets/v0.4/hard.jsonl\", records_path)\n    verify = verify_foundry_records(records_path)\n    bundle = build_foundry_bundle(records_path, bundle_dir)\n    assert export[\"record_count\"] == 72\n    assert export[\"quality\"][\"passed\"]\n    assert verify[\"passed\"]\n    assert bundle[\"quality\"][\"passed\"]\n    assert verify_foundry_bundle(bundle_dir)[\"passed\"]\n    exported_rows = read_jsonl(records_path)\n    assert all(row[\"rubric_id\"] for row in exported_rows)\n    assert all(\"family_fields\" in row for row in exported_rows)\n    assert (bundle_dir / \"PROVENANCE_MANIFEST.json\").exists()\n    provenance = json.loads((bundle_dir / \"PROVENANCE_MANIFEST.json\").read_text(encoding=\"utf-8\"))\n    assert provenance[\"source_file\"] == \"source_foundry_records.jsonl\"\n    assert (bundle_dir / \"CHECKSUMS.sha256\").exists()\n    assert (bundle_dir / \"HARNESS_VERSION.json\").exists()\n    assert (bundle_dir / \"RUBRIC.json\").exists()\n    assert (bundle_dir / \"DOMAIN_REVIEW.json\").exists()","source_id":"foundry::tests/test_local_benchmark.py::test_foundry_compatible_export_verify_and_bundle","task":"python_test_generation"}
{"id":"foundry::tests/test_local_benchmark.py::test_golden_seed_bundle_hash_stays_stable::generate","input":"Source path: tests/test_local_benchmark.py\nDomains: dataset, benchmark\nImports: primitive_foundry.cells, primitive_foundry.commercial, primitive_foundry.compare, primitive_foundry.curation_brain, primitive_foundry.dataset, primitive_foundry.external_listing, primitive_foundry.foundry_bridge, primitive_foundry.generate_source_cards, primitive_foundry.generators, primitive_foundry.inspect_adapter, primitive_foundry.lifecycle, primitive_foundry.marketplace_packet, primitive_foundry.node_ops, primitive_foundry.primitive_bus_adapter, primitive_foundry.product_factory, primitive_foundry.product_planner, primitive_foundry.promotion, primitive_foundry.release, primitive_foundry.runner, primitive_foundry.scorers, primitive_foundry.source_curation, primitive_foundry.sterilization, primitive_foundry.summary, primitive_foundry.train_router, primitive_foundry.v04\nAssertion count: 2","instruction":"Write a pytest test for Primitive Foundry that verifies: test golden seed bundle hash stays stable.","output":"def test_golden_seed_bundle_hash_stays_stable(tmp_path) -> None:\n    records_path = tmp_path / \"seed_foundry.jsonl\"\n    bundle_dir = tmp_path / \"seed_bundle\"\n    export_foundry_records(\"datasets/seed/aml_seed.jsonl\", records_path)\n    build_foundry_bundle(records_path, bundle_dir)\n\n    assert sha256_bytes((bundle_dir / \"source_foundry_records.jsonl\").read_bytes()) == (\n        \"ec1532b0fc084cbe0fc90f1f230bee802e194fc7536c6f2c40ba9a07561caae8\"\n    )\n    assert verify_foundry_bundle(bundle_dir)[\"passed\"]","source_id":"foundry::tests/test_local_benchmark.py::test_golden_seed_bundle_hash_stays_stable","task":"python_test_generation"}
{"id":"foundry::tests/test_local_benchmark.py::test_primitive_harness_scores_real_foundry_bundle::generate","input":"Source path: tests/test_local_benchmark.py\nDomains: dataset, benchmark\nImports: primitive_foundry.cells, primitive_foundry.commercial, primitive_foundry.compare, primitive_foundry.curation_brain, primitive_foundry.dataset, primitive_foundry.external_listing, primitive_foundry.foundry_bridge, primitive_foundry.generate_source_cards, primitive_foundry.generators, primitive_foundry.inspect_adapter, primitive_foundry.lifecycle, primitive_foundry.marketplace_packet, primitive_foundry.node_ops, primitive_foundry.primitive_bus_adapter, primitive_foundry.product_factory, primitive_foundry.product_planner, primitive_foundry.promotion, primitive_foundry.release, primitive_foundry.runner, primitive_foundry.scorers, primitive_foundry.source_curation, primitive_foundry.sterilization, primitive_foundry.summary, primitive_foundry.train_router, primitive_foundry.v04\nAssertion count: 5","instruction":"Write a pytest test for Primitive Foundry that verifies: test primitive harness scores real foundry bundle.","output":"def test_primitive_harness_scores_real_foundry_bundle(tmp_path) -> None:\n    records_path = tmp_path / \"aml_foundry.jsonl\"\n    bundle_dir = tmp_path / \"bundle\"\n    export_foundry_records(\"datasets/v0.4/hard.jsonl\", records_path)\n    build_foundry_bundle(records_path, bundle_dir)\n\n    harness_src = Path(\"primitive-harness/src\").resolve()\n    if str(harness_src) not in sys.path:\n        sys.path.insert(0, str(harness_src))\n    from primitive_harness.bundle import load_bundle\n    from primitive_harness.runner import run\n\n    def reference_agent(record: dict) -> dict:\n        features = record.get(\"features\", {})\n        return {\n            \"selected_cell_ids\": features.get(\"expected_cell_ids\", []),\n            \"rationale\": \"buyer-side reference agent answer\",\n            \"rubric_signals\": features.get(\"rubric\", {}).get(\"pass_conditions\", []),\n        }\n\n    loaded = load_bundle(bundle_dir)\n    report = run(reference_agent, loaded, seed=7)\n\n    assert loaded.harness_version[\"package\"] == \"primitive-harness\"\n    assert report[\"seed\"] == 7\n    assert report[\"record_count\"] == 72\n    assert report[\"pass_rate\"] == 1.0\n    assert report[\"harness_version\"][\"version\"] == loaded.harness_version[\"version\"]","source_id":"foundry::tests/test_local_benchmark.py::test_primitive_harness_scores_real_foundry_bundle","task":"python_test_generation"}
{"id":"foundry::tests/test_local_benchmark.py::test_delivery_shapes_write_from_foundry_bundle::generate","input":"Source path: tests/test_local_benchmark.py\nDomains: release, dataset, benchmark\nImports: primitive_foundry.cells, primitive_foundry.commercial, primitive_foundry.compare, primitive_foundry.curation_brain, primitive_foundry.dataset, primitive_foundry.external_listing, primitive_foundry.foundry_bridge, primitive_foundry.generate_source_cards, primitive_foundry.generators, primitive_foundry.inspect_adapter, primitive_foundry.lifecycle, primitive_foundry.marketplace_packet, primitive_foundry.node_ops, primitive_foundry.primitive_bus_adapter, primitive_foundry.product_factory, primitive_foundry.product_planner, primitive_foundry.promotion, primitive_foundry.release, primitive_foundry.runner, primitive_foundry.scorers, primitive_foundry.source_curation, primitive_foundry.sterilization, primitive_foundry.summary, primitive_foundry.train_router, primitive_foundry.v04\nAssertion count: 6","instruction":"Write a pytest test for Primitive Foundry that verifies: test delivery shapes write from foundry bundle.","output":"def test_delivery_shapes_write_from_foundry_bundle(tmp_path) -> None:\n    from primitive_foundry.delivery import verify_delivery_shapes, write_delivery_shapes\n\n    records_path = tmp_path / \"aml_foundry.jsonl\"\n    release_dir = tmp_path / \"release\"\n    bundle_dir = release_dir / \"bundle\"\n    export_foundry_records(\"datasets/v0.4/hard.jsonl\", records_path)\n    build_foundry_bundle(records_path, bundle_dir)\n\n    result = write_delivery_shapes(release_dir, [\"tar_gz\", \"parquet\", \"delta\", \"s3_manifest\"])\n    verify = verify_delivery_shapes(release_dir, [\"tar_gz\", \"parquet\", \"delta\", \"s3_manifest\"])\n\n    assert verify[\"passed\"]\n    assert Path(result[\"shapes\"][\"tar_gz\"][\"artifact\"]).exists()\n    assert Path(result[\"shapes\"][\"parquet\"][\"artifact\"]).suffix == \".parquet\"\n    assert result[\"shapes\"][\"parquet\"][\"record_count\"] == 72\n    assert result[\"shapes\"][\"delta\"][\"cloud_upload_performed\"] is False\n    assert result[\"shapes\"][\"s3_manifest\"][\"asset_count\"] > 0","source_id":"foundry::tests/test_local_benchmark.py::test_delivery_shapes_write_from_foundry_bundle","task":"python_test_generation"}
{"id":"foundry::tests/test_local_benchmark.py::test_buyer_preview_redacts_ground_truth::generate","input":"Source path: tests/test_local_benchmark.py\nDomains: release, dataset, benchmark\nImports: primitive_foundry.cells, primitive_foundry.commercial, primitive_foundry.compare, primitive_foundry.curation_brain, primitive_foundry.dataset, primitive_foundry.external_listing, primitive_foundry.foundry_bridge, primitive_foundry.generate_source_cards, primitive_foundry.generators, primitive_foundry.inspect_adapter, primitive_foundry.lifecycle, primitive_foundry.marketplace_packet, primitive_foundry.node_ops, primitive_foundry.primitive_bus_adapter, primitive_foundry.product_factory, primitive_foundry.product_planner, primitive_foundry.promotion, primitive_foundry.release, primitive_foundry.runner, primitive_foundry.scorers, primitive_foundry.source_curation, primitive_foundry.sterilization, primitive_foundry.summary, primitive_foundry.train_router, primitive_foundry.v04\nAssertion count: 5","instruction":"Write a pytest test for Primitive Foundry that verifies: test buyer preview redacts ground truth.","output":"def test_buyer_preview_redacts_ground_truth(tmp_path) -> None:\n    from primitive_foundry.sample import build_buyer_preview\n\n    records_path = tmp_path / \"aml_foundry.jsonl\"\n    release_dir = tmp_path / \"release\"\n    bundle_dir = release_dir / \"bundle\"\n    export_foundry_records(\"datasets/v0.4/hard.jsonl\", records_path)\n    build_foundry_bundle(records_path, bundle_dir)\n\n    preview_dir = build_buyer_preview(release_dir, preview_records=3)\n    rows = read_jsonl(preview_dir / \"preview_records.jsonl\")\n    manifest = json_load(preview_dir / \"PREVIEW_MANIFEST.json\")\n\n    assert manifest[\"record_count\"] == 3\n    assert rows[0][\"buyer_task\"]\n    assert \"expected_cell_id\" not in rows[0][\"features\"]\n    assert \"expected_cell_ids\" not in rows[0][\"features\"]\n    assert verify_foundry_bundle(bundle_dir)[\"passed\"]","source_id":"foundry::tests/test_local_benchmark.py::test_buyer_preview_redacts_ground_truth","task":"python_test_generation"}
{"id":"foundry::tests/test_local_benchmark.py::test_bundle_signing_verifies_in_foundry_and_harness::generate","input":"Source path: tests/test_local_benchmark.py\nDomains: signature, dataset, benchmark\nImports: primitive_foundry.cells, primitive_foundry.commercial, primitive_foundry.compare, primitive_foundry.curation_brain, primitive_foundry.dataset, primitive_foundry.external_listing, primitive_foundry.foundry_bridge, primitive_foundry.generate_source_cards, primitive_foundry.generators, primitive_foundry.inspect_adapter, primitive_foundry.lifecycle, primitive_foundry.marketplace_packet, primitive_foundry.node_ops, primitive_foundry.primitive_bus_adapter, primitive_foundry.product_factory, primitive_foundry.product_planner, primitive_foundry.promotion, primitive_foundry.release, primitive_foundry.runner, primitive_foundry.scorers, primitive_foundry.source_curation, primitive_foundry.sterilization, primitive_foundry.summary, primitive_foundry.train_router, primitive_foundry.v04\nAssertion count: 3","instruction":"Write a pytest test for Primitive Foundry that verifies: test bundle signing verifies in foundry and harness.","output":"def test_bundle_signing_verifies_in_foundry_and_harness(tmp_path) -> None:\n    from cryptography.hazmat.primitives import serialization\n    from cryptography.hazmat.primitives.asymmetric.ed25519 import Ed25519PrivateKey\n\n    from primitive_foundry.signing import sign_bundle, verify_signature\n\n    records_path = tmp_path / \"aml_foundry.jsonl\"\n    bundle_dir = tmp_path / \"bundle\"\n    export_foundry_records(\"datasets/v0.4/hard.jsonl\", records_path)\n    build_foundry_bundle(records_path, bundle_dir)\n    private = Ed25519PrivateKey.generate()\n    private_path = tmp_path / \"publisher_private.pem\"\n    public_pem = private.public_key().public_bytes(\n        encoding=serialization.Encoding.PEM,\n        format=serialization.PublicFormat.SubjectPublicKeyInfo,\n    )\n    private_path.write_bytes(\n        private.private_bytes(\n            encoding=serialization.Encoding.PEM,\n            format=serialization.PrivateFormat.PKCS8,\n            encryption_algorithm=serialization.NoEncryption(),\n        )\n    )\n\n    sign_bundle(bundle_dir, private_path)\n    verified = verify_signature(bundle_dir, public_pem)\n    harness_src = Path(\"primitive-harness/src\").resolve()\n    if str(harness_src) not in sys.path:\n        sys.path.insert(0, str(harness_src))\n    from primitive_harness.bundle import load_bundle\n\n    loaded = load_bundle(bundle_dir, publisher_public_key=public_pem)\n\n    assert verified[\"passed\"]\n    assert loaded.records\n    assert verify_foundry_bundle(bundle_dir)[\"passed\"]","source_id":"foundry::tests/test_local_benchmark.py::test_bundle_signing_verifies_in_foundry_and_harness","task":"python_test_generation"}
{"id":"foundry::tests/test_local_benchmark.py::test_bundle_signing_refreshes_checksums_for_new_files::generate","input":"Source path: tests/test_local_benchmark.py\nDomains: signature, dataset, benchmark\nImports: primitive_foundry.cells, primitive_foundry.commercial, primitive_foundry.compare, primitive_foundry.curation_brain, primitive_foundry.dataset, primitive_foundry.external_listing, primitive_foundry.foundry_bridge, primitive_foundry.generate_source_cards, primitive_foundry.generators, primitive_foundry.inspect_adapter, primitive_foundry.lifecycle, primitive_foundry.marketplace_packet, primitive_foundry.node_ops, primitive_foundry.primitive_bus_adapter, primitive_foundry.product_factory, primitive_foundry.product_planner, primitive_foundry.promotion, primitive_foundry.release, primitive_foundry.runner, primitive_foundry.scorers, primitive_foundry.source_curation, primitive_foundry.sterilization, primitive_foundry.summary, primitive_foundry.train_router, primitive_foundry.v04\nAssertion count: 1","instruction":"Write a pytest test for Primitive Foundry that verifies: test bundle signing refreshes checksums for new files.","output":"def test_bundle_signing_refreshes_checksums_for_new_files(tmp_path) -> None:\n    from cryptography.hazmat.primitives import serialization\n    from cryptography.hazmat.primitives.asymmetric.ed25519 import Ed25519PrivateKey\n\n    from primitive_foundry.signing import sign_bundle, verify_signature\n\n    records_path = tmp_path / \"aml_foundry.jsonl\"\n    bundle_dir = tmp_path / \"bundle\"\n    export_foundry_records(\"datasets/v0.4/hard.jsonl\", records_path)\n    build_foundry_bundle(records_path, bundle_dir)\n    (bundle_dir / \"preview\").mkdir()\n    (bundle_dir / \"preview\" / \"PREVIEW_MANIFEST.json\").write_text('{\"record_count\": 1}\\n', encoding=\"utf-8\")\n\n    private = Ed25519PrivateKey.generate()\n    private_path = tmp_path / \"publisher_private.pem\"\n    public_pem = private.public_key().public_bytes(\n        encoding=serialization.Encoding.PEM,\n        format=serialization.PublicFormat.SubjectPublicKeyInfo,\n    )\n    private_path.write_bytes(\n        private.private_bytes(\n            encoding=serialization.Encoding.PEM,\n            format=serialization.PrivateFormat.PKCS8,\n            encryption_algorithm=serialization.NoEncryption(),\n        )\n    )\n\n    sign_bundle(bundle_dir, private_path)\n\n    assert verify_signature(bundle_dir, public_pem)[\"passed\"]","source_id":"foundry::tests/test_local_benchmark.py::test_bundle_signing_refreshes_checksums_for_new_files","task":"python_test_generation"}
{"id":"foundry::tests/test_local_benchmark.py::test_shippability_payloads_examples_runtime_and_sale_binding::generate","input":"Source path: tests/test_local_benchmark.py\nDomains: privacy, release, marketplace, commercial, license, signature, dataset, benchmark\nImports: primitive_foundry.cells, primitive_foundry.commercial, primitive_foundry.compare, primitive_foundry.curation_brain, primitive_foundry.dataset, primitive_foundry.external_listing, primitive_foundry.foundry_bridge, primitive_foundry.generate_source_cards, primitive_foundry.generators, primitive_foundry.inspect_adapter, primitive_foundry.lifecycle, primitive_foundry.marketplace_packet, primitive_foundry.node_ops, primitive_foundry.primitive_bus_adapter, primitive_foundry.product_factory, primitive_foundry.product_planner, primitive_foundry.promotion, primitive_foundry.release, primitive_foundry.runner, primitive_foundry.scorers, primitive_foundry.source_curation, primitive_foundry.sterilization, primitive_foundry.summary, primitive_foundry.train_router, primitive_foundry.v04\nAssertion count: 5","instruction":"Write a pytest test for Primitive Foundry that verifies: test shippability payloads examples runtime and sale binding.","output":"def test_shippability_payloads_examples_runtime_and_sale_binding(tmp_path) -> None:\n    from cryptography.hazmat.primitives import serialization\n    from cryptography.hazmat.primitives.asymmetric.ed25519 import Ed25519PrivateKey\n\n    from primitive_foundry.channel_payloads import render_all\n    from primitive_foundry.commercial import write_commercial_artifacts\n    from primitive_foundry.sale_binding import bind_sale, verify_sale_binding\n    from primitive_foundry.signing import sign_bundle\n\n    records_path = tmp_path / \"aml_foundry.jsonl\"\n    release_dir = tmp_path / \"release\"\n    bundle_dir = release_dir / \"bundle\"\n    export_foundry_records(\"datasets/v0.4/hard.jsonl\", records_path)\n    build_foundry_bundle(records_path, bundle_dir)\n    commercial = write_commercial_artifacts(\n        release_dir=release_dir,\n        release_id=\"privacy_provenance_eval_000001\",\n        family=\"privacy_provenance_eval\",\n        target_size=\"micro\",\n        target_count=25,\n        record_count=72,\n        source_diversity=3,\n        candidate={\"product_economics\": {\"estimated_buyer_value\": 0.75}},\n    )\n    private = Ed25519PrivateKey.generate()\n    private_path = tmp_path / \"publisher_private.pem\"\n    public_pem = private.public_key().public_bytes(\n        encoding=serialization.Encoding.PEM,\n        format=serialization.PublicFormat.SubjectPublicKeyInfo,\n    )\n    private_path.write_bytes(\n        private.private_bytes(\n            encoding=serialization.Encoding.PEM,\n            format=serialization.PrivateFormat.PKCS8,\n            encryption_algorithm=serialization.NoEncryption(),\n        )\n    )\n    sign_bundle(bundle_dir, private_path)\n    channel_payloads = render_all(release_dir)\n    binding = bind_sale(\n        bundle_signature=bundle_dir / \"SIGNATURE.json\",\n        private_key_path=private_path,\n        buyer_name=\"ACME Corp\",\n        buyer_email_hash=\"abc123\",\n        transaction_id=\"po-tx-000123\",\n        channel=\"aws_data_exchange\",\n        license_tier=\"internal_eval_only\",\n        output_dir=tmp_path / \"delivery\",\n    )\n\n    harness_src = Path(\"primitive-harness/src\").resolve()\n    if str(harness_src) not in sys.path:\n        sys.path.insert(0, str(harness_src))\n    from primitive_harness.runtime import doctor\n\n    assert commercial[\"listing\"].endswith(\"MARKETPLACE_LISTING.json\")\n    assert (bundle_dir / \"examples\" / \"agent_perfect.py\").exists()\n    assert all(Path(path).exists() for path in channel_payloads.values())\n    assert verify_sale_binding(binding, public_pem)[\"passed\"]\n    assert doctor(bundle_dir, publisher_public_key=public_pem)[\"passed\"]","source_id":"foundry::tests/test_local_benchmark.py::test_shippability_payloads_examples_runtime_and_sale_binding","task":"python_test_generation"}
{"id":"foundry::tests/test_local_benchmark.py::test_build_context_makes_signing_sale_and_commercial_times_deterministic::generate","input":"Source path: tests/test_local_benchmark.py\nDomains: privacy, release, commercial, license, signature, dataset, benchmark\nImports: primitive_foundry.cells, primitive_foundry.commercial, primitive_foundry.compare, primitive_foundry.curation_brain, primitive_foundry.dataset, primitive_foundry.external_listing, primitive_foundry.foundry_bridge, primitive_foundry.generate_source_cards, primitive_foundry.generators, primitive_foundry.inspect_adapter, primitive_foundry.lifecycle, primitive_foundry.marketplace_packet, primitive_foundry.node_ops, primitive_foundry.primitive_bus_adapter, primitive_foundry.product_factory, primitive_foundry.product_planner, primitive_foundry.promotion, primitive_foundry.release, primitive_foundry.runner, primitive_foundry.scorers, primitive_foundry.source_curation, primitive_foundry.sterilization, primitive_foundry.summary, primitive_foundry.train_router, primitive_foundry.v04\nAssertion count: 3","instruction":"Write a pytest test for Primitive Foundry that verifies: test build context makes signing sale and commercial times deterministic.","output":"def test_build_context_makes_signing_sale_and_commercial_times_deterministic(tmp_path) -> None:\n    from cryptography.hazmat.primitives import serialization\n    from cryptography.hazmat.primitives.asymmetric.ed25519 import Ed25519PrivateKey\n\n    from primitive_foundry.build_context import BuildContext\n    from primitive_foundry.commercial import write_commercial_artifacts\n    from primitive_foundry.sale_binding import bind_sale\n    from primitive_foundry.signing import sign_bundle\n\n    records_path = tmp_path / \"aml_foundry.jsonl\"\n    bundle_dir = tmp_path / \"bundle\"\n    release_dir = tmp_path / \"release\"\n    export_foundry_records(\"datasets/v0.4/hard.jsonl\", records_path)\n    build_foundry_bundle(records_path, bundle_dir)\n    private = Ed25519PrivateKey.generate()\n    private_path = tmp_path / \"private.pem\"\n    private_path.write_bytes(\n        private.private_bytes(\n            encoding=serialization.Encoding.PEM,\n            format=serialization.PrivateFormat.PKCS8,\n            encryption_algorithm=serialization.NoEncryption(),\n        )\n    )\n    context = BuildContext(deterministic=True, build_time=\"2026-05-13T12:00:00+00:00\", seed=44)\n    signature = sign_bundle(bundle_dir, private_path, build_context=context)\n    commercial = write_commercial_artifacts(\n        release_dir=release_dir,\n        release_id=\"privacy_provenance_eval_000001\",\n        family=\"privacy_provenance_eval\",\n        target_size=\"micro\",\n        target_count=25,\n        record_count=72,\n        source_diversity=3,\n        candidate={\"product_economics\": {\"estimated_buyer_value\": 0.75}},\n        build_context=context,\n    )\n    binding = bind_sale(\n        bundle_signature=bundle_dir / \"SIGNATURE.json\",\n        private_key_path=private_path,\n        buyer_name=\"ACME Corp\",\n        buyer_email_hash=\"abc123\",\n        transaction_id=\"po-tx-000123\",\n        channel=\"aws_data_exchange\",\n        license_tier=\"internal_eval_only\",\n        output_dir=tmp_path / \"delivery\",\n        build_context=context,\n    )\n\n    assert signature[\"signed_at\"] == \"2026-05-13T12:00:00+00:00\"\n    assert commercial[\"listing_payload\"][\"created_at\"] == \"2026-05-13T12:00:00+00:00\"\n    assert json_load(binding)[\"sold_at\"] == \"2026-05-13T12:00:00+00:00\"","source_id":"foundry::tests/test_local_benchmark.py::test_build_context_makes_signing_sale_and_commercial_times_deterministic","task":"python_test_generation"}
{"id":"foundry::tests/test_local_benchmark.py::test_legacy_source_paths_resolve_to_current_ecosystem::generate","input":"Source path: tests/test_local_benchmark.py\nDomains: benchmark\nImports: primitive_foundry.cells, primitive_foundry.commercial, primitive_foundry.compare, primitive_foundry.curation_brain, primitive_foundry.dataset, primitive_foundry.external_listing, primitive_foundry.foundry_bridge, primitive_foundry.generate_source_cards, primitive_foundry.generators, primitive_foundry.inspect_adapter, primitive_foundry.lifecycle, primitive_foundry.marketplace_packet, primitive_foundry.node_ops, primitive_foundry.primitive_bus_adapter, primitive_foundry.product_factory, primitive_foundry.product_planner, primitive_foundry.promotion, primitive_foundry.release, primitive_foundry.runner, primitive_foundry.scorers, primitive_foundry.source_curation, primitive_foundry.sterilization, primitive_foundry.summary, primitive_foundry.train_router, primitive_foundry.v04\nAssertion count: 2","instruction":"Write a pytest test for Primitive Foundry that verifies: test legacy source paths resolve to current ecosystem.","output":"def test_legacy_source_paths_resolve_to_current_ecosystem() -> None:\n    public_resolved = resolve_source_path(\n        \"/home/[USER] is the context primitive core ecosystem with tennets/foundry/README.md\",\n        source_id=\"foundry-readme-primitive-foundry::001\",\n    )\n    assert public_resolved.exists()\n    assert str(public_resolved).endswith(\"README.md\")","source_id":"foundry::tests/test_local_benchmark.py::test_legacy_source_paths_resolve_to_current_ecosystem","task":"python_test_generation"}
{"id":"foundry::tests/test_local_benchmark.py::test_promotion_reverify_detects_bundle_tamper::generate","input":"Source path: tests/test_local_benchmark.py\nDomains: dataset, benchmark, source_card\nImports: primitive_foundry.cells, primitive_foundry.commercial, primitive_foundry.compare, primitive_foundry.curation_brain, primitive_foundry.dataset, primitive_foundry.external_listing, primitive_foundry.foundry_bridge, primitive_foundry.generate_source_cards, primitive_foundry.generators, primitive_foundry.inspect_adapter, primitive_foundry.lifecycle, primitive_foundry.marketplace_packet, primitive_foundry.node_ops, primitive_foundry.primitive_bus_adapter, primitive_foundry.product_factory, primitive_foundry.product_planner, primitive_foundry.promotion, primitive_foundry.release, primitive_foundry.runner, primitive_foundry.scorers, primitive_foundry.source_curation, primitive_foundry.sterilization, primitive_foundry.summary, primitive_foundry.train_router, primitive_foundry.v04\nAssertion count: 3","instruction":"Write a pytest test for Primitive Foundry that verifies: test promotion reverify detects bundle tamper.","output":"def test_promotion_reverify_detects_bundle_tamper(tmp_path) -> None:\n    cards_path = tmp_path / \"cards_60.jsonl\"\n    dataset_path = tmp_path / \"source_backed_60.jsonl\"\n    foundry_path = tmp_path / \"source_backed_60_foundry.jsonl\"\n    bundle_dir = tmp_path / \"source_bundle_60\"\n    manifest_path = tmp_path / \"promotion.json\"\n    generate_source_cards(60, cards_path)\n    curate_source_cards(cards_path, dataset_path)\n    export_foundry_records(dataset_path, foundry_path)\n    build_foundry_bundle(foundry_path, bundle_dir)\n    promote_bundle(\n        dataset_path=dataset_path,\n        foundry_records=foundry_path,\n        bundle_dir=bundle_dir,\n        output_manifest=manifest_path,\n        require_audit=False,\n    )\n    assert verify_promotion_manifest(manifest_path)[\"passed\"]\n\n    readme = bundle_dir / \"README.md\"\n    readme.write_text(readme.read_text(encoding=\"utf-8\") + \"\\nTampered.\\n\", encoding=\"utf-8\")\n    verified = verify_promotion_manifest(manifest_path)\n    assert not verified[\"passed\"]\n    assert \"bundle_snapshot_mismatch\" in verified[\"failures\"]","source_id":"foundry::tests/test_local_benchmark.py::test_promotion_reverify_detects_bundle_tamper","task":"python_test_generation"}
{"id":"foundry::tests/test_local_benchmark.py::test_review_and_release_index::generate","input":"Source path: tests/test_local_benchmark.py\nDomains: release, dataset, benchmark, source_card\nImports: primitive_foundry.cells, primitive_foundry.commercial, primitive_foundry.compare, primitive_foundry.curation_brain, primitive_foundry.dataset, primitive_foundry.external_listing, primitive_foundry.foundry_bridge, primitive_foundry.generate_source_cards, primitive_foundry.generators, primitive_foundry.inspect_adapter, primitive_foundry.lifecycle, primitive_foundry.marketplace_packet, primitive_foundry.node_ops, primitive_foundry.primitive_bus_adapter, primitive_foundry.product_factory, primitive_foundry.product_planner, primitive_foundry.promotion, primitive_foundry.release, primitive_foundry.runner, primitive_foundry.scorers, primitive_foundry.source_curation, primitive_foundry.sterilization, primitive_foundry.summary, primitive_foundry.train_router, primitive_foundry.v04\nAssertion count: 7","instruction":"Write a pytest test for Primitive Foundry that verifies: test review and release index.","output":"def test_review_and_release_index(tmp_path) -> None:\n    cards_path = tmp_path / \"cards_60.jsonl\"\n    dataset_path = tmp_path / \"source_backed_60.jsonl\"\n    foundry_path = tmp_path / \"source_backed_60_foundry.jsonl\"\n    bundle_dir = tmp_path / \"source_bundle_60\"\n    promotions_dir = tmp_path / \"promotions\"\n    reviews_dir = tmp_path / \"reviews\"\n    promotion_path = promotions_dir / \"candidate.promotion.json\"\n    review_path = reviews_dir / \"candidate.review.json\"\n    index_path = tmp_path / \"RELEASE_INDEX.json\"\n    generate_source_cards(60, cards_path)\n    curate_source_cards(cards_path, dataset_path)\n    export_foundry_records(dataset_path, foundry_path)\n    build_foundry_bundle(foundry_path, bundle_dir)\n    promote_bundle(\n        dataset_path=dataset_path,\n        foundry_records=foundry_path,\n        bundle_dir=bundle_dir,\n        output_manifest=promotion_path,\n        require_audit=False,\n    )\n    review = review_promotion(\n        manifest_path=promotion_path,\n        reviewer=\"local-owner\",\n        decision=\"approved\",\n        notes=\"test approval\",\n        output_path=review_path,\n    )\n    index = build_release_index(\n        promotions_dir=promotions_dir,\n        reviews_dir=reviews_dir,\n        output_path=index_path,\n    )\n    assert review[\"decision\"] == \"approved\"\n    assert verify_review_manifest(review_path)[\"passed\"]\n    assert index[\"promotions\"]\n    assert index[\"reviews\"]\n    assert verify_release_index(index_path)[\"passed\"]\n    assert not review_path.with_name(f\".{review_path.name}.lock\").exists()\n    assert not index_path.with_name(f\".{index_path.name}.lock\").exists()","source_id":"foundry::tests/test_local_benchmark.py::test_review_and_release_index","task":"python_test_generation"}
{"id":"foundry::tests/test_local_benchmark.py::test_aws_data_exchange_package_for_promoted_release::generate","input":"Source path: tests/test_local_benchmark.py\nDomains: release, dataset, benchmark, compliance, source_card\nImports: primitive_foundry.cells, primitive_foundry.commercial, primitive_foundry.compare, primitive_foundry.curation_brain, primitive_foundry.dataset, primitive_foundry.external_listing, primitive_foundry.foundry_bridge, primitive_foundry.generate_source_cards, primitive_foundry.generators, primitive_foundry.inspect_adapter, primitive_foundry.lifecycle, primitive_foundry.marketplace_packet, primitive_foundry.node_ops, primitive_foundry.primitive_bus_adapter, primitive_foundry.product_factory, primitive_foundry.product_planner, primitive_foundry.promotion, primitive_foundry.release, primitive_foundry.runner, primitive_foundry.scorers, primitive_foundry.source_curation, primitive_foundry.sterilization, primitive_foundry.summary, primitive_foundry.train_router, primitive_foundry.v04\nAssertion count: 8","instruction":"Write a pytest test for Primitive Foundry that verifies: test aws data exchange package for promoted release.","output":"def test_aws_data_exchange_package_for_promoted_release(tmp_path) -> None:\n    from primitive_foundry.aws_data_exchange import verify_aws_data_exchange_package, write_aws_data_exchange_package\n    from primitive_foundry.sample import build_buyer_preview\n\n    cards_path = tmp_path / \"cards_60.jsonl\"\n    dataset_path = tmp_path / \"source_backed_60.jsonl\"\n    release_dir = tmp_path / \"source_backed_60_release\"\n    foundry_path = release_dir / \"source_backed_60_foundry.jsonl\"\n    bundle_dir = release_dir / \"bundle\"\n    promotion_path = release_dir / \"promotions\" / \"candidate.promotion.json\"\n    review_path = release_dir / \"reviews\" / \"candidate.review.json\"\n    index_path = release_dir / \"RELEASE_INDEX.json\"\n    generate_source_cards(60, cards_path)\n    curate_source_cards(cards_path, dataset_path)\n    export_foundry_records(dataset_path, foundry_path)\n    build_foundry_bundle(foundry_path, bundle_dir)\n    build_buyer_preview(release_dir, preview_records=5)\n    promote_bundle(\n        dataset_path=dataset_path,\n        foundry_records=foundry_path,\n        bundle_dir=bundle_dir,\n        output_manifest=promotion_path,\n        require_audit=False,\n    )\n    review_promotion(\n        manifest_path=promotion_path,\n        reviewer=\"local-owner\",\n        decision=\"approved\",\n        notes=\"approved for aws package fixture\",\n        output_path=review_path,\n    )\n    build_release_index(promotions_dir=promotion_path.parent, reviews_dir=review_path.parent, output_path=index_path)\n\n    package = write_aws_data_exchange_package(\n        release_dir=release_dir,\n        provider_account_ready=True,\n        support_contact=\"[REDACTED_EMAIL]\",\n    )\n    verify = verify_aws_data_exchange_package(package[\"package_dir\"])\n\n    assert package[\"passed\"]\n    assert package[\"artifact_ready\"]\n    assert package[\"aws_publish_ready\"]\n    assert verify[\"passed\"]\n    assert Path(package[\"assets\"][0]).exists()\n    listing = json_load(Path(package[\"package_dir\"]) / \"aws_listing_fields.json\")\n    assert listing[\"delivery_method\"] == \"Files\"\n    assert listing[\"compliance_claims\"][\"raw_sources_included\"] is False\n    assert listing[\"subscription_verification_enabled\"] is True","source_id":"foundry::tests/test_local_benchmark.py::test_aws_data_exchange_package_for_promoted_release","task":"python_test_generation"}
{"id":"foundry::tests/test_local_benchmark.py::test_family_ontology_builders_emit_loadable_registries::generate","input":"Source path: tests/test_local_benchmark.py\nDomains: privacy, benchmark\nImports: primitive_foundry.cells, primitive_foundry.commercial, primitive_foundry.compare, primitive_foundry.curation_brain, primitive_foundry.dataset, primitive_foundry.external_listing, primitive_foundry.foundry_bridge, primitive_foundry.generate_source_cards, primitive_foundry.generators, primitive_foundry.inspect_adapter, primitive_foundry.lifecycle, primitive_foundry.marketplace_packet, primitive_foundry.node_ops, primitive_foundry.primitive_bus_adapter, primitive_foundry.product_factory, primitive_foundry.product_planner, primitive_foundry.promotion, primitive_foundry.release, primitive_foundry.runner, primitive_foundry.scorers, primitive_foundry.source_curation, primitive_foundry.sterilization, primitive_foundry.summary, primitive_foundry.train_router, primitive_foundry.v04\nAssertion count: 4","instruction":"Write a pytest test for Primitive Foundry that verifies: test family ontology builders emit loadable registries.","output":"def test_family_ontology_builders_emit_loadable_registries(tmp_path) -> None:\n    from primitive_foundry.ontologies.agent_runtime_governance import build_registry as build_governance_registry\n    from primitive_foundry.ontologies.privacy_provenance import build_registry as build_privacy_registry\n    from primitive_foundry.ontologies.verified_agentic_build import build_registry as build_build_registry\n\n    privacy_cards = tmp_path / \"privacy.jsonl\"\n    governance_cards = tmp_path / \"governance.jsonl\"\n    build_cards = tmp_path / \"build.jsonl\"\n    import json\n\n    privacy_cards.write_text(\n        json.dumps(\n            {\n                \"record_id\": \"p1\",\n                \"metadata\": {\"regulation_family\": \"GDPR\", \"control_id\": \"Art.5.1.b\"},\n                \"buyer_task\": {},\n            }\n        )\n        + \"\\n\",\n        encoding=\"utf-8\",\n    )\n    governance_cards.write_text(\n        json.dumps({\"record_id\": \"g1\", \"metadata\": {\"scenario_kind\": \"human_override\"}, \"buyer_task\": {}}) + \"\\n\",\n        encoding=\"utf-8\",\n    )\n    build_cards.write_text(\n        json.dumps({\"record_id\": \"b1\", \"metadata\": {\"spec_id\": \"rust-fix-1\"}, \"buyer_task\": {}}) + \"\\n\",\n        encoding=\"utf-8\",\n    )\n\n    privacy = build_privacy_registry(privacy_cards, tmp_path / \"privacy_registry.json\")\n    governance = build_governance_registry(governance_cards, tmp_path / \"governance_registry.json\")\n    build = build_build_registry(build_cards, tmp_path / \"build_registry.json\")\n\n    assert privacy[\"cells\"][0][\"cell_id\"] == \"legal.privacy.gdpr.art_5_1_b\"\n    assert governance[\"cells\"][0][\"domain_path\"] == \"governance.human_override\"\n    assert build[\"cells\"][0][\"cell_id\"] == \"build.python.test_repair.rust_fix_1\"\n    assert CellRegistry.from_json(tmp_path / \"privacy_registry.json\").all()","source_id":"foundry::tests/test_local_benchmark.py::test_family_ontology_builders_emit_loadable_registries","task":"python_test_generation"}
{"id":"foundry::tests/test_local_benchmark.py::test_router_summary_with_trained_router::generate","input":"Source path: tests/test_local_benchmark.py\nDomains: dataset, router, benchmark\nImports: primitive_foundry.cells, primitive_foundry.commercial, primitive_foundry.compare, primitive_foundry.curation_brain, primitive_foundry.dataset, primitive_foundry.external_listing, primitive_foundry.foundry_bridge, primitive_foundry.generate_source_cards, primitive_foundry.generators, primitive_foundry.inspect_adapter, primitive_foundry.lifecycle, primitive_foundry.marketplace_packet, primitive_foundry.node_ops, primitive_foundry.primitive_bus_adapter, primitive_foundry.product_factory, primitive_foundry.product_planner, primitive_foundry.promotion, primitive_foundry.release, primitive_foundry.runner, primitive_foundry.scorers, primitive_foundry.source_curation, primitive_foundry.sterilization, primitive_foundry.summary, primitive_foundry.train_router, primitive_foundry.v04\nAssertion count: 1","instruction":"Write a pytest test for Primitive Foundry that verifies: test router summary with trained router.","output":"def test_router_summary_with_trained_router() -> None:\n    summary = router_summary(\"datasets/v0.4/eval.jsonl\", \"models/router_v0_1.json\")\n    routers = {row[\"router\"] for row in summary[\"rows\"]}\n    assert routers == {\"keyword\", \"hashed-embedding\", \"trained\"}","source_id":"foundry::tests/test_local_benchmark.py::test_router_summary_with_trained_router","task":"python_test_generation"}
{"id":"foundry::tests/test_local_benchmark.py::test_product_event_classifier_keeps_medium_high_value::generate","input":"Source path: tests/test_local_benchmark.py\nDomains: release, bus, dataset, benchmark\nImports: primitive_foundry.cells, primitive_foundry.commercial, primitive_foundry.compare, primitive_foundry.curation_brain, primitive_foundry.dataset, primitive_foundry.external_listing, primitive_foundry.foundry_bridge, primitive_foundry.generate_source_cards, primitive_foundry.generators, primitive_foundry.inspect_adapter, primitive_foundry.lifecycle, primitive_foundry.marketplace_packet, primitive_foundry.node_ops, primitive_foundry.primitive_bus_adapter, primitive_foundry.product_factory, primitive_foundry.product_planner, primitive_foundry.promotion, primitive_foundry.release, primitive_foundry.runner, primitive_foundry.scorers, primitive_foundry.source_curation, primitive_foundry.sterilization, primitive_foundry.summary, primitive_foundry.train_router, primitive_foundry.v04\nAssertion count: 3","instruction":"Write a pytest test for Primitive Foundry that verifies: test product event classifier keeps medium high value.","output":"def test_product_event_classifier_keeps_medium_high_value(tmp_path) -> None:\n    source = tmp_path / \"source.md\"\n    source.write_text(\"private foundry benchmark dataset event bus provenance\", encoding=\"utf-8\")\n    event = ProductEvent(\n        event_id=\"evt-1\",\n        text=\"Private Foundry dataset benchmark with provenance and event bus release quality gates.\",\n        source_path=str(source),\n        tags=[\"dataset\", \"benchmark\"],\n    )\n    classification = classify_event(event)\n    assert classification.accepted\n    assert classification.value_tier in {\"medium\", \"high\"}\n    assert classification.product_kind in {\"dataset\", \"benchmark\", \"eval_harness\"}","source_id":"foundry::tests/test_local_benchmark.py::test_product_event_classifier_keeps_medium_high_value","task":"python_test_generation"}
{"id":"foundry::tests/test_local_benchmark.py::test_family_registry_controls_planner_and_commercial_names::generate","input":"Source path: tests/test_local_benchmark.py\nDomains: privacy, marketplace, commercial, planner, dataset, benchmark\nImports: primitive_foundry.cells, primitive_foundry.commercial, primitive_foundry.compare, primitive_foundry.curation_brain, primitive_foundry.dataset, primitive_foundry.external_listing, primitive_foundry.foundry_bridge, primitive_foundry.generate_source_cards, primitive_foundry.generators, primitive_foundry.inspect_adapter, primitive_foundry.lifecycle, primitive_foundry.marketplace_packet, primitive_foundry.node_ops, primitive_foundry.primitive_bus_adapter, primitive_foundry.product_factory, primitive_foundry.product_planner, primitive_foundry.promotion, primitive_foundry.release, primitive_foundry.runner, primitive_foundry.scorers, primitive_foundry.source_curation, primitive_foundry.sterilization, primitive_foundry.summary, primitive_foundry.train_router, primitive_foundry.v04\nAssertion count: 8","instruction":"Write a pytest test for Primitive Foundry that verifies: test family registry controls planner and commercial names.","output":"def test_family_registry_controls_planner_and_commercial_names() -> None:\n    from primitive_foundry.commercial import FAMILY_TITLES, marketplace_category\n    from primitive_foundry.families import FAMILY_BY_KIND, PLANNER_FAMILIES, REGISTRY, canonical_family\n    from primitive_foundry.product_planner import PRODUCT_FAMILIES\n\n    assert FAMILY_BY_KIND == {\n        \"dataset\": \"privacy_provenance_eval\",\n        \"eval_harness\": \"agent_runtime_governance\",\n        \"benchmark\": \"verified_agentic_build\",\n    }\n    assert {\"privacy_provenance_eval\", \"agent_runtime_governance\", \"verified_agentic_build\"}.issubset(REGISTRY)\n    assert \"agent_runtime_governance\" in PRODUCT_FAMILIES\n    assert \"verified_agentic_build\" in PRODUCT_FAMILIES\n    assert \"agent_trace_eval\" not in PLANNER_FAMILIES\n    assert canonical_family(\"agent_trace_eval\") == \"agent_runtime_governance\"\n    assert FAMILY_TITLES[\"agent_runtime_governance\"] == \"Agent Runtime Governance Benchmark\"\n    assert marketplace_category(\"verified_agentic_build\") == \"benchmarks\"","source_id":"foundry::tests/test_local_benchmark.py::test_family_registry_controls_planner_and_commercial_names","task":"python_test_generation"}
{"id":"foundry::tests/test_local_benchmark.py::test_pricing_multipliers_move_price_and_manifest_fields::generate","input":"Source path: tests/test_local_benchmark.py\nDomains: commercial, license, benchmark\nImports: primitive_foundry.cells, primitive_foundry.commercial, primitive_foundry.compare, primitive_foundry.curation_brain, primitive_foundry.dataset, primitive_foundry.external_listing, primitive_foundry.foundry_bridge, primitive_foundry.generate_source_cards, primitive_foundry.generators, primitive_foundry.inspect_adapter, primitive_foundry.lifecycle, primitive_foundry.marketplace_packet, primitive_foundry.node_ops, primitive_foundry.primitive_bus_adapter, primitive_foundry.product_factory, primitive_foundry.product_planner, primitive_foundry.promotion, primitive_foundry.release, primitive_foundry.runner, primitive_foundry.scorers, primitive_foundry.source_curation, primitive_foundry.sterilization, primitive_foundry.summary, primitive_foundry.train_router, primitive_foundry.v04\nAssertion count: 5","instruction":"Write a pytest test for Primitive Foundry that verifies: test pricing multipliers move price and manifest fields.","output":"def test_pricing_multipliers_move_price_and_manifest_fields() -> None:\n    from primitive_foundry.commercial import estimate_price, pricing_evidence\n\n    economics = {\"estimated_buyer_value\": 0.75}\n    base = estimate_price(100, economics, 100, 100)\n    publication = estimate_price(\n        100,\n        economics,\n        100,\n        100,\n        license_tier=\"internal_plus_publication\",\n        review_level=\"founder_attested\",\n    )\n    custom_sme = estimate_price(\n        100,\n        economics,\n        100,\n        100,\n        license_tier=\"private_custom_pack\",\n        review_level=\"sme_paid_review\",\n    )\n    evidence = pricing_evidence(\n        profile={\"base_price_usd\": 100, \"commercial_tier\": \"test\"},\n        economics=economics,\n        record_count=100,\n        profile_records=100,\n        price=publication,\n        license_tier=\"internal_plus_publication\",\n        review_level=\"founder_attested\",\n    )\n\n    assert base == 150\n    assert publication > base\n    assert custom_sme > publication\n    assert evidence[\"license_tier_multiplier\"] == 2.5\n    assert evidence[\"review_level_multiplier\"] == 1.4","source_id":"foundry::tests/test_local_benchmark.py::test_pricing_multipliers_move_price_and_manifest_fields","task":"python_test_generation"}
{"id":"foundry::tests/test_local_benchmark.py::test_source_card_classifier_prefers_tags_and_adapter_origin::generate","input":"Source path: tests/test_local_benchmark.py\nDomains: privacy, planner, benchmark, source_card\nImports: primitive_foundry.cells, primitive_foundry.commercial, primitive_foundry.compare, primitive_foundry.curation_brain, primitive_foundry.dataset, primitive_foundry.external_listing, primitive_foundry.foundry_bridge, primitive_foundry.generate_source_cards, primitive_foundry.generators, primitive_foundry.inspect_adapter, primitive_foundry.lifecycle, primitive_foundry.marketplace_packet, primitive_foundry.node_ops, primitive_foundry.primitive_bus_adapter, primitive_foundry.product_factory, primitive_foundry.product_planner, primitive_foundry.promotion, primitive_foundry.release, primitive_foundry.runner, primitive_foundry.scorers, primitive_foundry.source_curation, primitive_foundry.sterilization, primitive_foundry.summary, primitive_foundry.train_router, primitive_foundry.v04\nAssertion count: 3","instruction":"Write a pytest test for Primitive Foundry that verifies: test source card classifier prefers tags and adapter origin.","output":"def test_source_card_classifier_prefers_tags_and_adapter_origin() -> None:\n    from primitive_foundry.product_planner import classify_source_card\n\n    assert classify_source_card({\"tags\": [\"verified_agentic_build\"], \"metadata\": {\"adapter\": \"privacy_regulatory\"}}) == (\n        \"verified_agentic_build\"\n    )\n    assert classify_source_card({\"tags\": [], \"metadata\": {\"adapter\": \"agent_eval_scenarios\"}}) == (\n        \"agent_runtime_governance\"\n    )\n    assert classify_source_card({\"source_summary\": \"GDPR provenance control mapping\", \"metadata\": {}}) == (\n        \"privacy_provenance_eval\"\n    )","source_id":"foundry::tests/test_local_benchmark.py::test_source_card_classifier_prefers_tags_and_adapter_origin","task":"python_test_generation"}
{"id":"foundry::tests/test_local_benchmark.py::test_lab_scenario_run_exports_to_governance_source_card::generate","input":"Source path: tests/test_local_benchmark.py\nDomains: benchmark, source_card\nImports: primitive_foundry.cells, primitive_foundry.commercial, primitive_foundry.compare, primitive_foundry.curation_brain, primitive_foundry.dataset, primitive_foundry.external_listing, primitive_foundry.foundry_bridge, primitive_foundry.generate_source_cards, primitive_foundry.generators, primitive_foundry.inspect_adapter, primitive_foundry.lifecycle, primitive_foundry.marketplace_packet, primitive_foundry.node_ops, primitive_foundry.primitive_bus_adapter, primitive_foundry.product_factory, primitive_foundry.product_planner, primitive_foundry.promotion, primitive_foundry.release, primitive_foundry.runner, primitive_foundry.scorers, primitive_foundry.source_curation, primitive_foundry.sterilization, primitive_foundry.summary, primitive_foundry.train_router, primitive_foundry.v04\nAssertion count: 4","instruction":"Write a pytest test for Primitive Foundry that verifies: test lab scenario run exports to governance source card.","output":"def test_lab_scenario_run_exports_to_governance_source_card(tmp_path) -> None:\n    lab_root = Path(\"/home/[USER] is the context primitive core ecosystem with tennets/lab\")\n    if str(lab_root) not in sys.path:\n        sys.path.insert(0, str(lab_root))\n    from primitive_foundry.source_adapters.agent_eval_scenarios import build_source_cards\n\n    run_dir = tmp_path / \"lab_runs\" / \"run-001\"\n    run_dir.mkdir(parents=True)\n    (run_dir / \"summary.json\").write_text(\n        '{\"scenario_name\":\"override-check\",\"task_id\":\"task-1\",\"event_count\":2}',\n        encoding=\"utf-8\",\n    )\n    (run_dir / \"normalized_config.json\").write_text(\n        '{'\n        '\"scenario_name\":\"override-check\",'\n        '\"task_text\":\"preserve human override for model escalation\",'\n        '\"expected_authority_events\":[\"override_seen\",\"escalation_blocked\"]'\n        '}',\n        encoding=\"utf-8\",\n    )\n    (run_dir / \"packet.json\").write_text('{\"authority\":\"human_override\"}', encoding=\"utf-8\")\n\n    cards = build_source_cards(tmp_path / \"lab_runs\", tmp_path / \"lab_cards.jsonl\")\n\n    assert cards[0][\"source_family\"] == \"agent_runtime_governance\"\n    assert cards[0][\"buyer_task\"][\"scenario_kind\"] == \"human_override\"\n    assert cards[0][\"metadata\"][\"origin_adapter\"] == \"lab_scenario_run\"\n    assert cards[0][\"metadata\"][\"expected_authority_events\"] == [\"override_seen\", \"escalation_blocked\"]","source_id":"foundry::tests/test_local_benchmark.py::test_lab_scenario_run_exports_to_governance_source_card","task":"python_test_generation"}
{"id":"foundry::tests/test_local_benchmark.py::test_kairos_build_run_exports_to_build_source_card::generate","input":"Source path: tests/test_local_benchmark.py\nDomains: signature, benchmark, source_card\nImports: primitive_foundry.cells, primitive_foundry.commercial, primitive_foundry.compare, primitive_foundry.curation_brain, primitive_foundry.dataset, primitive_foundry.external_listing, primitive_foundry.foundry_bridge, primitive_foundry.generate_source_cards, primitive_foundry.generators, primitive_foundry.inspect_adapter, primitive_foundry.lifecycle, primitive_foundry.marketplace_packet, primitive_foundry.node_ops, primitive_foundry.primitive_bus_adapter, primitive_foundry.product_factory, primitive_foundry.product_planner, primitive_foundry.promotion, primitive_foundry.release, primitive_foundry.runner, primitive_foundry.scorers, primitive_foundry.source_curation, primitive_foundry.sterilization, primitive_foundry.summary, primitive_foundry.train_router, primitive_foundry.v04\nAssertion count: 4","instruction":"Write a pytest test for Primitive Foundry that verifies: test kairos build run exports to build source card.","output":"def test_kairos_build_run_exports_to_build_source_card(tmp_path) -> None:\n    builder_root = Path(\"/home/[USER] is the context primitive core ecosystem with tennets/builder\")\n    if str(builder_root) not in sys.path:\n        sys.path.insert(0, str(builder_root))\n    from primitive_foundry.source_adapters.agentic_build_traces import build_source_cards\n\n    run_dir = tmp_path / \"kairos_runs\" / \"run-001\"\n    run_dir.mkdir(parents=True)\n    (run_dir / \"trace.json\").write_text(\n        '{\"run_id\":\"run-001\",\"expected_outcome\":\"tests_pass\",\"environment\":{\"language\":\"python\",\"runtime\":\"3.12\"}}',\n        encoding=\"utf-8\",\n    )\n    (run_dir / \"spec.md\").write_text(\"Fix validation and preserve the public function signature.\", encoding=\"utf-8\")\n    (run_dir / \"starter.tar.gz\").write_text(\"starter archive placeholder\", encoding=\"utf-8\")\n    (run_dir / \"hidden_tests.tar.gz\").write_text(\"hidden test archive placeholder\", encoding=\"utf-8\")\n\n    cards = build_source_cards(tmp_path / \"kairos_runs\", tmp_path / \"build_cards.jsonl\")\n\n    assert cards[0][\"source_family\"] == \"verified_agentic_build\"\n    assert cards[0][\"buyer_task\"][\"spec_id\"] == \"run-001\"\n    assert cards[0][\"metadata\"][\"origin_adapter\"] == \"kairos_build_run\"\n    assert cards[0][\"metadata\"][\"environment\"][\"language\"] == \"python\"","source_id":"foundry::tests/test_local_benchmark.py::test_kairos_build_run_exports_to_build_source_card","task":"python_test_generation"}
{"id":"foundry::tests/test_local_benchmark.py::test_family_generator_registry_shapes::generate","input":"Source path: tests/test_local_benchmark.py\nDomains: sterilization, privacy, dataset, benchmark, compliance\nImports: primitive_foundry.cells, primitive_foundry.commercial, primitive_foundry.compare, primitive_foundry.curation_brain, primitive_foundry.dataset, primitive_foundry.external_listing, primitive_foundry.foundry_bridge, primitive_foundry.generate_source_cards, primitive_foundry.generators, primitive_foundry.inspect_adapter, primitive_foundry.lifecycle, primitive_foundry.marketplace_packet, primitive_foundry.node_ops, primitive_foundry.primitive_bus_adapter, primitive_foundry.product_factory, primitive_foundry.product_planner, primitive_foundry.promotion, primitive_foundry.release, primitive_foundry.runner, primitive_foundry.scorers, primitive_foundry.source_curation, primitive_foundry.sterilization, primitive_foundry.summary, primitive_foundry.train_router, primitive_foundry.v04\nAssertion count: 9","instruction":"Write a pytest test for Primitive Foundry that verifies: test family generator registry shapes.","output":"def test_family_generator_registry_shapes() -> None:\n    source = SourceCard(\n        record_id=\"shape-001\",\n        source_id=\"source-001\",\n        source_path=\"/tmp/source.md\",\n        source_summary=\"sanitized source summary\",\n        source_line_hint=\"test\",\n        domain_path=\"legal.privacy\",\n        tags=[\"test\"],\n        sterilization={\"status\": \"clean\"},\n    )\n    privacy = GENERATOR_REGISTRY[\"dataset\"].build_record(source, 1)\n    governance = GENERATOR_REGISTRY[\"eval_harness\"].build_record(source, 2)\n    build = GENERATOR_REGISTRY[\"benchmark\"].build_record(source, 3)\n\n    assert privacy[\"task\"] == \"verify_provenance_compliance\"\n    assert privacy[\"expected_evaluation\"][\"rubric_id\"] == \"rubric.privacy.v1\"\n    assert privacy[\"regulation_family\"] == \"GDPR\"\n    assert governance[\"task\"] == \"honor_governance_rule\"\n    assert governance[\"expected_authority_events\"]\n    assert governance[\"rubric_id\"] == \"rubric.governance.v1\"\n    assert build[\"task\"] == \"spec_to_verified_patch\"\n    assert build[\"repair_budget\"][\"max_iterations\"] == 3\n    assert build[\"rubric_id\"] == \"rubric.build.v1\"","source_id":"foundry::tests/test_local_benchmark.py::test_family_generator_registry_shapes","task":"python_test_generation"}
{"id":"foundry::tests/test_local_benchmark.py::test_family_scorers_return_structured_scores::generate","input":"Source path: tests/test_local_benchmark.py\nDomains: privacy, benchmark\nImports: primitive_foundry.cells, primitive_foundry.commercial, primitive_foundry.compare, primitive_foundry.curation_brain, primitive_foundry.dataset, primitive_foundry.external_listing, primitive_foundry.foundry_bridge, primitive_foundry.generate_source_cards, primitive_foundry.generators, primitive_foundry.inspect_adapter, primitive_foundry.lifecycle, primitive_foundry.marketplace_packet, primitive_foundry.node_ops, primitive_foundry.primitive_bus_adapter, primitive_foundry.product_factory, primitive_foundry.product_planner, primitive_foundry.promotion, primitive_foundry.release, primitive_foundry.runner, primitive_foundry.scorers, primitive_foundry.source_curation, primitive_foundry.sterilization, primitive_foundry.summary, primitive_foundry.train_router, primitive_foundry.v04\nAssertion count: 6","instruction":"Write a pytest test for Primitive Foundry that verifies: test family scorers return structured scores.","output":"def test_family_scorers_return_structured_scores() -> None:\n    privacy_record = {\n        \"expected_evaluation\": {\n            \"pass_if\": [\"sanitized_export_present\", \"provenance_manifest_present\"],\n            \"fail_if\": [\"raw_private_source\"],\n        },\n        \"ground_truth\": {\"label\": \"pass\"},\n    }\n    privacy = SCORER_REGISTRY[\"rubric.privacy.v1\"](\n        \"sanitized_export_present provenance_manifest_present\",\n        privacy_record,\n    )\n    governance = SCORER_REGISTRY[\"rubric.governance.v1\"](\n        \"authority_decision_point_detected governance_rule_checked approval_or_escalation_recorded rule_honored trace_complete no_silent_override\",\n        {\n            \"expected_authority_events\": [\n                \"authority_decision_point_detected\",\n                \"governance_rule_checked\",\n                \"approval_or_escalation_recorded\",\n            ],\n            \"rubric\": {\"pass_conditions\": [\"rule_honored\", \"trace_complete\", \"no_silent_override\"]},\n        },\n    )\n    build = SCORER_REGISTRY[\"rubric.build.v1\"](\n        {\"status\": \"tests_pass\", \"patch_trace\": \"trace_matches_patch\", \"repair_iterations\": 2},\n        {\"repair_budget\": {\"max_iterations\": 3}},\n    )\n\n    assert privacy.passed\n    assert privacy.rubric_id == \"rubric.privacy.v1\"\n    assert governance.passed\n    assert governance.rubric_id == \"rubric.governance.v1\"\n    assert build.passed\n    assert build.sub_scores[\"budget_not_exceeded\"] == 1.0","source_id":"foundry::tests/test_local_benchmark.py::test_family_scorers_return_structured_scores","task":"python_test_generation"}
{"id":"foundry::tests/test_local_benchmark.py::test_autonomous_stream_is_idempotent_and_batches::generate","input":"Source path: tests/test_local_benchmark.py\nDomains: release, bus, dataset, router, benchmark\nImports: primitive_foundry.cells, primitive_foundry.commercial, primitive_foundry.compare, primitive_foundry.curation_brain, primitive_foundry.dataset, primitive_foundry.external_listing, primitive_foundry.foundry_bridge, primitive_foundry.generate_source_cards, primitive_foundry.generators, primitive_foundry.inspect_adapter, primitive_foundry.lifecycle, primitive_foundry.marketplace_packet, primitive_foundry.node_ops, primitive_foundry.primitive_bus_adapter, primitive_foundry.product_factory, primitive_foundry.product_planner, primitive_foundry.promotion, primitive_foundry.release, primitive_foundry.runner, primitive_foundry.scorers, primitive_foundry.source_curation, primitive_foundry.sterilization, primitive_foundry.summary, primitive_foundry.train_router, primitive_foundry.v04\nAssertion count: 9","instruction":"Write a pytest test for Primitive Foundry that verifies: test autonomous stream is idempotent and batches.","output":"def test_autonomous_stream_is_idempotent_and_batches(tmp_path) -> None:\n    source_paths = []\n    for index in range(3):\n        source = tmp_path / f\"source_{index}.md\"\n        source.write_text(\n            \"private foundry dataset benchmark eval provenance release quality router event bus\",\n            encoding=\"utf-8\",\n        )\n        source_paths.append(source)\n    events_path = tmp_path / \"events.jsonl\"\n    families = [\"alpha\", \"bravo\", \"charlie\"]\n    rows = [\n        {\n            \"event_id\": f\"evt-{index}\",\n            \"text\": (\n                \"High value private dataset benchmark eval with Foundry provenance release quality \"\n                f\"and router lifecycle gates for distinct product family {family}.\"\n            ),\n            \"source_path\": str(source),\n            \"tags\": [\"dataset\", \"benchmark\", \"eval\", f\"family-{family}\"],\n        }\n        for index, (source, family) in enumerate(zip(source_paths, families), start=1)\n    ]\n    low_source = tmp_path / \"low.md\"\n    low_source.write_text(\"low value note\", encoding=\"utf-8\")\n    rows.append({\"event_id\": \"evt-low\", \"text\": \"small note\", \"source_path\": str(low_source), \"tags\": []})\n    with events_path.open(\"w\", encoding=\"utf-8\") as handle:\n        for row in rows:\n            import json\n\n            handle.write(json.dumps(row, sort_keys=True) + \"\\n\")\n\n    state_path = tmp_path / \"products\" / \"STREAM_STATE.json\"\n    first = run_event_stream(\n        events_path=events_path,\n        output_root=tmp_path / \"products\",\n        state_path=state_path,\n        batch_size=2,\n        iterations=1,\n        poll_seconds=0,\n        dedupe_threshold=1.0,\n    )\n    second = run_event_stream(\n        events_path=events_path,\n        output_root=tmp_path / \"products\",\n        state_path=state_path,\n        batch_size=2,\n        iterations=1,\n        poll_seconds=0,\n        dedupe_threshold=1.0,\n    )\n    third = run_event_stream(\n        events_path=events_path,\n        output_root=tmp_path / \"products\",\n        state_path=state_path,\n        batch_size=2,\n        iterations=1,\n        poll_seconds=0,\n        dedupe_threshold=1.0,\n    )\n\n    assert first[\"candidates_created\"] == 1\n    assert second[\"candidates_created\"] == 1\n    assert third[\"candidates_created\"] == 0\n    state = verify_stream_state(state_path)\n    assert state[\"passed\"]\n    assert state[\"processed_event_count\"] == 4\n    assert state[\"candidate_count\"] == 2\n    assert verify_manifest_lock(tmp_path / \"products\" / \"aml_stream_000001\" / \"MANIFEST.lock\")[\"passed\"]\n    assert verify_manifest_lock(tmp_path / \"products\" / \"aml_stream_000002\" / \"MANIFEST.lock\")[\"passed\"]\n    assert (tmp_path / \"products\" / \"REJECTED_EVENTS.jsonl\").exists()","source_id":"foundry::tests/test_local_benchmark.py::test_autonomous_stream_is_idempotent_and_batches","task":"python_test_generation"}
{"id":"foundry::tests/test_local_benchmark.py::test_node_ops_inbox_health_package_and_service::generate","input":"Source path: tests/test_local_benchmark.py\nDomains: release, bus, dataset, router, benchmark\nImports: primitive_foundry.cells, primitive_foundry.commercial, primitive_foundry.compare, primitive_foundry.curation_brain, primitive_foundry.dataset, primitive_foundry.external_listing, primitive_foundry.foundry_bridge, primitive_foundry.generate_source_cards, primitive_foundry.generators, primitive_foundry.inspect_adapter, primitive_foundry.lifecycle, primitive_foundry.marketplace_packet, primitive_foundry.node_ops, primitive_foundry.primitive_bus_adapter, primitive_foundry.product_factory, primitive_foundry.product_planner, primitive_foundry.promotion, primitive_foundry.release, primitive_foundry.runner, primitive_foundry.scorers, primitive_foundry.source_curation, primitive_foundry.sterilization, primitive_foundry.summary, primitive_foundry.train_router, primitive_foundry.v04\nAssertion count: 20","instruction":"Write a pytest test for Primitive Foundry that verifies: test node ops inbox health package and service.","output":"def test_node_ops_inbox_health_package_and_service(tmp_path) -> None:\n    source = tmp_path / \"source.md\"\n    source.write_text(\"private foundry dataset benchmark eval provenance release quality router event bus\", encoding=\"utf-8\")\n    inbox = tmp_path / \"events\" / \"inbox.jsonl\"\n    appended = append_inbox_event(\n        inbox=inbox,\n        text=\"High value private dataset source for Foundry provenance release quality and benchmark routing.\",\n        source_path=source,\n        event_id=\"evt-node-1\",\n        tags=[\"dataset\", \"foundry\"],\n    )\n    assert appended[\"event\"][\"event_id\"] == \"evt-node-1\"\n    assert validate_inbox(inbox)[\"passed\"]\n\n    output_root = tmp_path / \"products\"\n    state = output_root / \"STREAM_STATE.json\"\n    stream = run_event_stream(\n        events_path=inbox,\n        output_root=output_root,\n        state_path=state,\n        iterations=1,\n        poll_seconds=0,\n    )\n    assert stream[\"passed\"]\n    candidate_dir = output_root / \"aml_stream_000001\"\n    write_release_policy(output_root / \"PRIVATE_RELEASE_POLICY.json\")\n    assert verify_product_catalog(output_root / \"PRODUCT_CATALOG.json\")[\"passed\"]\n    health = node_health(output_root=output_root, state_path=state, inbox=inbox)\n    assert health[\"passed\"]\n    (output_root / \"PRIVATE_RELEASE_POLICY.json\").unlink()\n    missing_policy_health = node_health(output_root=output_root, state_path=state, inbox=inbox)\n    assert not missing_policy_health[\"passed\"]\n    assert missing_policy_health[\"checks\"][\"release_policy\"][\"failures\"] == [\"missing_release_policy\"]\n    assert node_health(output_root=output_root, state_path=state, inbox=inbox, require_policy=False)[\"passed\"]\n    write_release_policy(output_root / \"PRIVATE_RELEASE_POLICY.json\")\n\n    package = package_product(candidate_dir=candidate_dir, output_dir=tmp_path / \"packages\")\n    assert package[\"raw_sources_included\"] is False\n    assert (tmp_path / \"packages\" / \"aml_stream_000001.tar.gz\").exists()\n    assert verify_package(package[\"manifest\"])[\"passed\"]\n    report_card = candidate_dir / \"REPORT_CARD.md\"\n    report_card.write_text(report_card.read_text(encoding=\"utf-8\") + \"\\nLock repair test.\\n\", encoding=\"utf-8\")\n    assert not verify_manifest_lock(candidate_dir / \"MANIFEST.lock\")[\"passed\"]\n    lock_repair = repair_product_manifest_lock(candidate_dir)\n    assert lock_repair[\"repaired\"]\n    assert verify_manifest_lock(candidate_dir / \"MANIFEST.lock\")[\"passed\"]\n\n    service = write_service_files(\n        output_dir=tmp_path / \"node\",\n        repo_dir=\".\",\n        events=inbox,\n        output_root=output_root,\n        state=state,\n        poll_seconds=0,\n        batch_size=1,\n    )\n    assert (tmp_path / \"node\" / \"run-primitive-foundry-node.sh\").exists()\n    assert (tmp_path / \"node\" / \"primitive-foundry-node.service\").exists()\n    assert service[\"runner\"].endswith(\"run-primitive-foundry-node.sh\")\n\n    installed = install_node_service(\n        service_file=service[\"service\"],\n        runner_file=service[\"runner\"],\n        systemd_dir=tmp_path / \"systemd-user\",\n    )\n    assert (tmp_path / \"systemd-user\" / \"primitive-foundry-node.service\").exists()\n    assert installed[\"installed\"]\n    removed = uninstall_node_service(systemd_dir=tmp_path / \"systemd-user\")\n    assert removed[\"removed\"]","source_id":"foundry::tests/test_local_benchmark.py::test_node_ops_inbox_health_package_and_service","task":"python_test_generation"}
{"id":"foundry::tests/test_local_benchmark.py::test_cli_failed_verify_exits_nonzero::generate","input":"Source path: tests/test_local_benchmark.py\nDomains: benchmark\nImports: primitive_foundry.cells, primitive_foundry.commercial, primitive_foundry.compare, primitive_foundry.curation_brain, primitive_foundry.dataset, primitive_foundry.external_listing, primitive_foundry.foundry_bridge, primitive_foundry.generate_source_cards, primitive_foundry.generators, primitive_foundry.inspect_adapter, primitive_foundry.lifecycle, primitive_foundry.marketplace_packet, primitive_foundry.node_ops, primitive_foundry.primitive_bus_adapter, primitive_foundry.product_factory, primitive_foundry.product_planner, primitive_foundry.promotion, primitive_foundry.release, primitive_foundry.runner, primitive_foundry.scorers, primitive_foundry.source_curation, primitive_foundry.sterilization, primitive_foundry.summary, primitive_foundry.train_router, primitive_foundry.v04\nAssertion count: 3","instruction":"Write a pytest test for Primitive Foundry that verifies: test cli failed verify exits nonzero.","output":"def test_cli_failed_verify_exits_nonzero(tmp_path) -> None:\n    import json\n    import subprocess\n    import sys\n\n    manifest = tmp_path / \"bad.package.json\"\n    payload = {\n        \"manifest_type\": \"aml_product_package\",\n        \"candidate_id\": \"bad\",\n        \"package\": str(tmp_path / \"missing.tar.gz\"),\n        \"package_hash\": \"missing\",\n        \"raw_sources_included\": False,\n        \"package_manifest_hash\": \"bad-hash\",\n    }\n    manifest.write_text(json.dumps(payload, sort_keys=True) + \"\\n\", encoding=\"utf-8\")\n    result = subprocess.run(\n        [\n            sys.executable,\n            \"-m\",\n            \"primitive_foundry.cli\",\n            \"verify-package\",\n            \"--manifest\",\n            str(manifest),\n        ],\n        cwd=\".\",\n        text=True,\n        capture_output=True,\n        check=False,\n    )\n    assert result.returncode == 1\n    assert '\"passed\": false' in result.stdout\n    assert \"Traceback\" not in result.stderr","source_id":"foundry::tests/test_local_benchmark.py::test_cli_failed_verify_exits_nonzero","task":"python_test_generation"}
{"id":"foundry::tests/test_local_benchmark.py::test_bus_adapter_policy_and_recovery::generate","input":"Source path: tests/test_local_benchmark.py\nDomains: release, bus, dataset, router, benchmark\nImports: primitive_foundry.cells, primitive_foundry.commercial, primitive_foundry.compare, primitive_foundry.curation_brain, primitive_foundry.dataset, primitive_foundry.external_listing, primitive_foundry.foundry_bridge, primitive_foundry.generate_source_cards, primitive_foundry.generators, primitive_foundry.inspect_adapter, primitive_foundry.lifecycle, primitive_foundry.marketplace_packet, primitive_foundry.node_ops, primitive_foundry.primitive_bus_adapter, primitive_foundry.product_factory, primitive_foundry.product_planner, primitive_foundry.promotion, primitive_foundry.release, primitive_foundry.runner, primitive_foundry.scorers, primitive_foundry.source_curation, primitive_foundry.sterilization, primitive_foundry.summary, primitive_foundry.train_router, primitive_foundry.v04\nAssertion count: 7","instruction":"Write a pytest test for Primitive Foundry that verifies: test bus adapter policy and recovery.","output":"def test_bus_adapter_policy_and_recovery(tmp_path) -> None:\n    source = tmp_path / \"source.md\"\n    source.write_text(\"private foundry dataset benchmark eval provenance release quality router event bus\", encoding=\"utf-8\")\n    bus = tmp_path / \"bus.jsonl\"\n    inbox = tmp_path / \"inbox.jsonl\"\n    adapter = tmp_path / \"adapter.json\"\n    import json\n\n    bus.write_text(\n        json.dumps(\n            {\n                \"event_id\": \"bus-1\",\n                \"text\": \"High value private dataset benchmark for Foundry provenance release quality and router lifecycle gates.\",\n                \"source_path\": str(source),\n                \"tags\": [\"dataset\", \"benchmark\", \"foundry\"],\n            },\n            sort_keys=True,\n        )\n        + \"\\n\",\n        encoding=\"utf-8\",\n    )\n    adapter.write_text(json.dumps({\"adapter_type\": \"jsonl\", \"source\": str(bus)}, sort_keys=True), encoding=\"utf-8\")\n    imported = import_bus_events(adapter=adapter, inbox=inbox)\n    assert imported[\"imported_count\"] == 1\n    assert validate_inbox(inbox)[\"passed\"]\n\n    output_root = tmp_path / \"products\"\n    state = output_root / \"STREAM_STATE.json\"\n    first = run_event_stream(events_path=inbox, output_root=output_root, state_path=state, iterations=1, poll_seconds=0)\n    assert first[\"candidates_created\"] == 1\n    with inbox.open(\"a\", encoding=\"utf-8\") as handle:\n        handle.write(\n            json.dumps(\n                {\n                    \"event_id\": \"bus-2\",\n                    \"text\": \"High value private eval harness for provenance quality gates and release review.\",\n                    \"source_path\": str(source),\n                    \"tags\": [\"eval\", \"quality\"],\n                },\n                sort_keys=True,\n            )\n            + \"\\n\"\n        )\n    second = run_event_stream(events_path=inbox, output_root=output_root, state_path=state, iterations=1, poll_seconds=0)\n    assert second[\"candidates_created\"] == 1\n    third = run_event_stream(events_path=inbox, output_root=output_root, state_path=state, iterations=1, poll_seconds=0)\n    assert third[\"candidates_created\"] == 0\n\n    policy = write_release_policy(output_root / \"PRIVATE_RELEASE_POLICY.json\")\n    assert policy[\"external_upload_allowed\"] is False\n    assert verify_release_policy(output_root / \"PRIVATE_RELEASE_POLICY.json\")[\"passed\"]","source_id":"foundry::tests/test_local_benchmark.py::test_bus_adapter_policy_and_recovery","task":"python_test_generation"}
{"id":"foundry::tests/test_local_benchmark.py::test_primitive_bus_messages_map_to_product_inbox_and_release::generate","input":"Source path: tests/test_local_benchmark.py\nDomains: sterilization, privacy, release, marketplace, commercial, bus, planner, dataset, benchmark\nImports: primitive_foundry.cells, primitive_foundry.commercial, primitive_foundry.compare, primitive_foundry.curation_brain, primitive_foundry.dataset, primitive_foundry.external_listing, primitive_foundry.foundry_bridge, primitive_foundry.generate_source_cards, primitive_foundry.generators, primitive_foundry.inspect_adapter, primitive_foundry.lifecycle, primitive_foundry.marketplace_packet, primitive_foundry.node_ops, primitive_foundry.primitive_bus_adapter, primitive_foundry.product_factory, primitive_foundry.product_planner, primitive_foundry.promotion, primitive_foundry.release, primitive_foundry.runner, primitive_foundry.scorers, primitive_foundry.source_curation, primitive_foundry.sterilization, primitive_foundry.summary, primitive_foundry.train_router, primitive_foundry.v04\nAssertion count: 7","instruction":"Write a pytest test for Primitive Foundry that verifies: test primitive bus messages map to product inbox and release.","output":"def test_primitive_bus_messages_map_to_product_inbox_and_release(tmp_path) -> None:\n    import json\n\n    messages = [\n        PrimitiveMessageView(\n            subject=\"primitive.dataset.sanitized\",\n            message_id=\"js-1\",\n            timestamp=1770000000.0,\n            source_node_id=\"node-a\",\n            payload={\n                \"event_id\": \"kernel-dataset-1\",\n                \"dataset_family\": \"privacy_provenance_eval\",\n                \"summary\": (\n                    \"High value private Foundry dataset benchmark with sterilization, provenance, \"\n                    \"quality report, release review, and marketplace package evidence.\"\n                ),\n                \"tags\": [\"dataset\", \"benchmark\", \"foundry\"],\n            },\n        ),\n        PrimitiveMessageView(\n            subject=\"primitive.receipt.emitted\",\n            message_id=\"js-2\",\n            timestamp=1770000001.0,\n            source_node_id=\"node-a\",\n            payload={\n                \"event_id\": \"kernel-receipt-1\",\n                \"summary\": (\n                    \"High value eval harness receipt for provenance checks, commercial readiness, \"\n                    \"privacy gates, release verification, and buyer audit evidence.\"\n                ),\n                \"tags\": [\"eval\", \"provenance\", \"quality\"],\n            },\n        ),\n    ]\n    rows = primitive_messages_to_product_rows(messages, source_cache_dir=tmp_path / \"primitive_sources\")\n    inbox = tmp_path / \"kernel_events.jsonl\"\n    with inbox.open(\"w\", encoding=\"utf-8\") as handle:\n        for row in rows:\n            handle.write(json.dumps(row, sort_keys=True) + \"\\n\")\n\n    assert len(rows) == 2\n    assert validate_inbox(inbox)[\"passed\"]\n    assert all((tmp_path / \"primitive_sources\").joinpath(Path(row[\"source_path\"]).name).exists() for row in rows)\n\n    output_root = tmp_path / \"products\"\n    result = run_product_node(\n        events_path=inbox,\n        output_root=output_root,\n        state_path=output_root / \"PRODUCT_PLANNER_STATE.json\",\n        target_size=\"micro\",\n        target_count=2,\n        min_source_diversity=2,\n        iterations=1,\n        poll_seconds=0,\n        dedupe_threshold=1.1,\n    )\n    assert result[\"passed\"]\n    assert result[\"releases_created\"] == 1\n    release_dir = Path(result[\"results\"][0][\"releases\"][0][\"candidate_dir\"])\n    assert verify_autonomous_release(release_dir / \"AUTONOMOUS_RELEASE.json\")[\"passed\"]\n    assert json_load(release_dir / \"MARKETPLACE_CHANNEL_PLAN.json\")[\"primary_channel\"] == \"aws_data_exchange\"","source_id":"foundry::tests/test_local_benchmark.py::test_primitive_bus_messages_map_to_product_inbox_and_release","task":"python_test_generation"}
{"id":"foundry::tests/test_local_benchmark.py::test_primitive_bus_source_card_events_map_to_foundry_source_cards::generate","input":"Source path: tests/test_local_benchmark.py\nDomains: bus, benchmark, source_card\nImports: primitive_foundry.cells, primitive_foundry.commercial, primitive_foundry.compare, primitive_foundry.curation_brain, primitive_foundry.dataset, primitive_foundry.external_listing, primitive_foundry.foundry_bridge, primitive_foundry.generate_source_cards, primitive_foundry.generators, primitive_foundry.inspect_adapter, primitive_foundry.lifecycle, primitive_foundry.marketplace_packet, primitive_foundry.node_ops, primitive_foundry.primitive_bus_adapter, primitive_foundry.product_factory, primitive_foundry.product_planner, primitive_foundry.promotion, primitive_foundry.release, primitive_foundry.runner, primitive_foundry.scorers, primitive_foundry.source_curation, primitive_foundry.sterilization, primitive_foundry.summary, primitive_foundry.train_router, primitive_foundry.v04\nAssertion count: 9","instruction":"Write a pytest test for Primitive Foundry that verifies: test primitive bus source card events map to foundry source cards.","output":"def test_primitive_bus_source_card_events_map_to_foundry_source_cards(tmp_path) -> None:\n    import json\n\n    message = PrimitiveMessageView(\n        subject=SOURCE_CARD_EVENT_TYPE,\n        message_id=\"js-source-card-1\",\n        timestamp=1770000002.0,\n        source_node_id=\"lab-node\",\n        source_agent_id=\"lab\",\n        payload={\n            \"event_type\": SOURCE_CARD_EVENT_TYPE,\n            \"source\": \"lab\",\n            \"payload\": {\n                \"record_id\": \"lab-governance-abc123\",\n                \"source_id\": \"lab::override-check::abc123\",\n                \"source_family\": \"agent_runtime_governance\",\n                \"domain_path\": \"operations.governance\",\n                \"rubric_id\": \"rubric.governance.v1\",\n                \"task\": \"honor_governance_rule\",\n                \"tags\": [\"agent_runtime_governance\", \"human_override\"],\n                \"adapter\": \"agent_eval_scenarios\",\n                \"raw_private\": True,\n                \"export_allowed\": False,\n                \"coordination\": \"event-bus-only\",\n            },\n        },\n    )\n\n    cards = primitive_messages_to_source_cards([message], source_cache_dir=tmp_path / \"primitive_sources\")\n    cards_path = tmp_path / \"source_cards.jsonl\"\n    with cards_path.open(\"w\", encoding=\"utf-8\") as handle:\n        for card in cards:\n            handle.write(json.dumps(card, sort_keys=True) + \"\\n\")\n    curated = curate_source_cards(cards_path, tmp_path / \"curated.jsonl\")\n\n    assert len(cards) == 1\n    assert cards[0][\"source_family\"] == \"agent_runtime_governance\"\n    assert cards[0][\"metadata\"][\"origin_adapter\"] == \"primitive_event_bus_source_card\"\n    assert cards[0][\"metadata\"][\"coordination\"] == \"event-bus-only\"\n    assert \"source_path\" not in message.payload[\"payload\"]\n    assert Path(cards[0][\"source_path\"]).exists()\n    assert curated[\"record_count\"] == 1\n    loaded = load_jsonl(tmp_path / \"curated.jsonl\")[0]\n    assert loaded.rubric_id == \"rubric.governance.v1\"\n    assert loaded.metadata[\"source_family\"] == \"agent_runtime_governance\"","source_id":"foundry::tests/test_local_benchmark.py::test_primitive_bus_source_card_events_map_to_foundry_source_cards","task":"python_test_generation"}
{"id":"foundry::tests/test_local_benchmark.py::test_product_planner_state_writes_are_locked_and_atomic::generate","input":"Source path: tests/test_local_benchmark.py\nDomains: privacy, release, planner, benchmark\nImports: primitive_foundry.cells, primitive_foundry.commercial, primitive_foundry.compare, primitive_foundry.curation_brain, primitive_foundry.dataset, primitive_foundry.external_listing, primitive_foundry.foundry_bridge, primitive_foundry.generate_source_cards, primitive_foundry.generators, primitive_foundry.inspect_adapter, primitive_foundry.lifecycle, primitive_foundry.marketplace_packet, primitive_foundry.node_ops, primitive_foundry.primitive_bus_adapter, primitive_foundry.product_factory, primitive_foundry.product_planner, primitive_foundry.promotion, primitive_foundry.release, primitive_foundry.runner, primitive_foundry.scorers, primitive_foundry.source_curation, primitive_foundry.sterilization, primitive_foundry.summary, primitive_foundry.train_router, primitive_foundry.v04\nAssertion count: 4","instruction":"Write a pytest test for Primitive Foundry that verifies: test product planner state writes are locked and atomic.","output":"def test_product_planner_state_writes_are_locked_and_atomic(tmp_path) -> None:\n    import concurrent.futures\n\n    from primitive_foundry.product_planner import save_planner_state\n\n    state_path = tmp_path / \"PRODUCT_PLANNER_STATE.json\"\n\n    def write_state(index: int) -> None:\n        save_planner_state(\n            state_path,\n            {\n                \"manifest_type\": \"aml_product_planner_state\",\n                \"created_at\": \"2026-05-13T00:00:00+00:00\",\n                \"updated_at\": f\"2026-05-13T00:00:{index:02d}+00:00\",\n                \"processed_event_ids\": [f\"event-{index}\"],\n                \"family_sequences\": {\"privacy_provenance_eval\": index},\n                \"releases\": [],\n            },\n        )\n\n    with concurrent.futures.ThreadPoolExecutor(max_workers=8) as pool:\n        list(pool.map(write_state, range(20)))\n\n    verify = verify_planner_state(state_path)\n    assert verify[\"passed\"]\n    assert verify[\"processed_event_count\"] == 1\n    assert (tmp_path / \".PRODUCT_PLANNER_STATE.json.lock\").exists()\n    assert not list(tmp_path.glob(\".PRODUCT_PLANNER_STATE.json.*.tmp\"))","source_id":"foundry::tests/test_local_benchmark.py::test_product_planner_state_writes_are_locked_and_atomic","task":"python_test_generation"}
{"id":"foundry::tests/test_local_benchmark.py::test_release_ledger_prevents_reusing_deleted_release_id::generate","input":"Source path: tests/test_local_benchmark.py\nDomains: privacy, release, planner, dataset, benchmark\nImports: primitive_foundry.cells, primitive_foundry.commercial, primitive_foundry.compare, primitive_foundry.curation_brain, primitive_foundry.dataset, primitive_foundry.external_listing, primitive_foundry.foundry_bridge, primitive_foundry.generate_source_cards, primitive_foundry.generators, primitive_foundry.inspect_adapter, primitive_foundry.lifecycle, primitive_foundry.marketplace_packet, primitive_foundry.node_ops, primitive_foundry.primitive_bus_adapter, primitive_foundry.product_factory, primitive_foundry.product_planner, primitive_foundry.promotion, primitive_foundry.release, primitive_foundry.runner, primitive_foundry.scorers, primitive_foundry.source_curation, primitive_foundry.sterilization, primitive_foundry.summary, primitive_foundry.train_router, primitive_foundry.v04\nAssertion count: 4","instruction":"Write a pytest test for Primitive Foundry that verifies: test release ledger prevents reusing deleted release id.","output":"def test_release_ledger_prevents_reusing_deleted_release_id(tmp_path) -> None:\n    import json\n    import shutil\n\n    sources = []\n    for index in range(2):\n        source = tmp_path / f\"privacy_source_{index}.md\"\n        source.write_text(\n            \"private privacy provenance dataset eval benchmark release quality foundry source\",\n            encoding=\"utf-8\",\n        )\n        sources.append(source)\n\n    events = tmp_path / \"events.jsonl\"\n    names = [\"alpha\", \"bravo\"]\n    with events.open(\"w\", encoding=\"utf-8\") as handle:\n        for index, (source, name) in enumerate(zip(sources, names), start=1):\n            handle.write(\n                json.dumps(\n                    {\n                        \"event_id\": f\"ledger-{index}\",\n                        \"text\": f\"High value privacy provenance eval dataset release {name} source for quality gates.\",\n                        \"source_path\": str(source),\n                        \"tags\": [\"privacy\", \"provenance\", \"eval\", name],\n                    },\n                    sort_keys=True,\n                )\n                + \"\\n\"\n            )\n\n    output_root = tmp_path / \"autonomous\"\n    result = run_product_node(\n        events_path=events,\n        output_root=output_root,\n        state_path=output_root / \"PRODUCT_PLANNER_STATE.json\",\n        target_size=\"micro\",\n        target_count=2,\n        min_source_diversity=2,\n        iterations=1,\n        poll_seconds=0,\n        dedupe_threshold=1.0,\n    )\n    release_dir = output_root / \"releases\" / \"privacy_provenance_eval_000001\"\n    ledger = json_load(output_root / \"releases\" / \"RELEASE_LEDGER.json\")\n    assert result[\"passed\"]\n    assert ledger[\"releases\"][\"privacy_provenance_eval_000001\"][\"claimed\"] is True\n\n    shutil.rmtree(release_dir)\n    (output_root / \"PRODUCT_PLANNER_STATE.json\").unlink()\n    events2 = tmp_path / \"events2.jsonl\"\n    names2 = [\"delta\", \"echo\"]\n    with events2.open(\"w\", encoding=\"utf-8\") as handle:\n        for index, (source, name) in enumerate(zip(sources, names2), start=1):\n            handle.write(\n                json.dumps(\n                    {\n                        \"event_id\": f\"ledger-reuse-{index}\",\n                        \"text\": f\"Different high value privacy provenance eval dataset release {name} source for quality gates.\",\n                        \"source_path\": str(source),\n                        \"tags\": [\"privacy\", \"provenance\", \"eval\", name],\n                    },\n                    sort_keys=True,\n                )\n                + \"\\n\"\n            )\n\n    try:\n        run_product_node(\n            events_path=events2,\n            output_root=output_root,\n            state_path=output_root / \"PRODUCT_PLANNER_STATE.json\",\n            target_size=\"micro\",\n            target_count=2,\n            min_source_diversity=2,\n            iterations=1,\n            poll_seconds=0,\n            dedupe_threshold=1.0,\n        )\n        assert False, \"ledger should prevent release_id reuse after release directory deletion\"\n    except RuntimeError as error:\n        assert \"ReleaseImmutabilityViolation:privacy_provenance_eval_000001\" in str(error)","source_id":"foundry::tests/test_local_benchmark.py::test_release_ledger_prevents_reusing_deleted_release_id","task":"python_test_generation"}
{"id":"foundry::tests/test_local_benchmark.py::test_curation_plan_uses_standing_orders_and_preserves_bus_boundary::generate","input":"Source path: tests/test_local_benchmark.py\nDomains: sterilization, privacy, release, bus, curation, dataset, benchmark, source_card\nImports: primitive_foundry.cells, primitive_foundry.commercial, primitive_foundry.compare, primitive_foundry.curation_brain, primitive_foundry.dataset, primitive_foundry.external_listing, primitive_foundry.foundry_bridge, primitive_foundry.generate_source_cards, primitive_foundry.generators, primitive_foundry.inspect_adapter, primitive_foundry.lifecycle, primitive_foundry.marketplace_packet, primitive_foundry.node_ops, primitive_foundry.primitive_bus_adapter, primitive_foundry.product_factory, primitive_foundry.product_planner, primitive_foundry.promotion, primitive_foundry.release, primitive_foundry.runner, primitive_foundry.scorers, primitive_foundry.source_curation, primitive_foundry.sterilization, primitive_foundry.summary, primitive_foundry.train_router, primitive_foundry.v04\nAssertion count: 10","instruction":"Write a pytest test for Primitive Foundry that verifies: test curation plan uses standing orders and preserves bus boundary.","output":"def test_curation_plan_uses_standing_orders_and_preserves_bus_boundary(tmp_path) -> None:\n    import json\n\n    privacy_source = tmp_path / \"privacy.md\"\n    privacy_source.write_text(\"privacy provenance sterilization dataset source\", encoding=\"utf-8\")\n    governance_source = tmp_path / \"governance.md\"\n    governance_source.write_text(\"agent governance override eval harness source\", encoding=\"utf-8\")\n    events = tmp_path / \"events.jsonl\"\n    rows = [\n        {\n            \"event_id\": \"curate-privacy-1\",\n            \"text\": \"Rare privacy provenance dataset for sterilized source-card release with buyer value.\",\n            \"source_path\": str(privacy_source),\n            \"tags\": [\"privacy\", \"provenance\", \"dataset\"],\n        },\n        {\n            \"event_id\": \"curate-governance-1\",\n            \"text\": \"Agent runtime governance eval harness for override and scheduler behavior.\",\n            \"source_path\": str(governance_source),\n            \"tags\": [\"agent\", \"governance\", \"eval\"],\n        },\n    ]\n    with events.open(\"w\", encoding=\"utf-8\") as handle:\n        for row in rows:\n            handle.write(json.dumps(row, sort_keys=True) + \"\\n\")\n\n    orders_path = tmp_path / \"standing_orders.json\"\n    write_standing_orders(\n        orders_path,\n        [\n            StandingOrder(\n                order_id=\"hinge-focus-governance\",\n                priority=95,\n                focus_families=(\"agent_runtime_governance\",),\n                keywords=(\"governance\", \"override\"),\n                research_allowed=True,\n                source=\"hinge\",\n            )\n        ],\n    )\n\n    plan = plan_curation(\n        events_path=events,\n        standing_orders_path=orders_path,\n        output_path=tmp_path / \"plan.json\",\n        min_value_score=0.5,\n    )\n\n    assert plan[\"local_private_only\"] is True\n    assert plan[\"coordination\"] == \"event-bus-only\"\n    assert plan[\"direct_agent_call\"] is False\n    assert plan[\"standing_order_count\"] == 1\n    assert plan[\"opportunities\"][0][\"family\"] == \"agent_runtime_governance\"\n    assert plan[\"opportunities\"][0][\"standing_order_ids\"] == [\"hinge-focus-governance\"]\n    assert plan[\"opportunities\"][0][\"missing_complementary_kinds\"]\n    assert plan[\"research_requests\"][0][\"payload\"][\"external_lookup_allowed\"] is False\n    assert plan[\"research_requests\"][0][\"payload\"][\"approval_required_before_network\"] is True\n    assert (tmp_path / \"plan.json\").exists()","source_id":"foundry::tests/test_local_benchmark.py::test_curation_plan_uses_standing_orders_and_preserves_bus_boundary","task":"python_test_generation"}
{"id":"foundry::tests/test_local_benchmark.py::test_customer_install_uses_current_cli_and_excludes_private_outputs::generate","input":"Source path: tests/test_local_benchmark.py\nDomains: release, benchmark\nImports: primitive_foundry.cells, primitive_foundry.commercial, primitive_foundry.compare, primitive_foundry.curation_brain, primitive_foundry.dataset, primitive_foundry.external_listing, primitive_foundry.foundry_bridge, primitive_foundry.generate_source_cards, primitive_foundry.generators, primitive_foundry.inspect_adapter, primitive_foundry.lifecycle, primitive_foundry.marketplace_packet, primitive_foundry.node_ops, primitive_foundry.primitive_bus_adapter, primitive_foundry.product_factory, primitive_foundry.product_planner, primitive_foundry.promotion, primitive_foundry.release, primitive_foundry.runner, primitive_foundry.scorers, primitive_foundry.source_curation, primitive_foundry.sterilization, primitive_foundry.summary, primitive_foundry.train_router, primitive_foundry.v04\nAssertion count: 3","instruction":"Write a pytest test for Primitive Foundry that verifies: test customer install uses current cli and excludes private outputs.","output":"def test_customer_install_uses_current_cli_and_excludes_private_outputs() -> None:\n    install_root = Path(\"deploy/customer-install\")\n    dockerfile = (install_root / \"Dockerfile.foundry\").read_text(encoding=\"utf-8\")\n    compose = (install_root / \"docker-compose.yml\").read_text(encoding=\"utf-8\")\n    verify = (install_root / \"scripts\" / \"verify_install.sh\").read_text(encoding=\"utf-8\")\n    dockerignore = Path(\".dockerignore\").read_text(encoding=\"utf-8\")\n\n    install_text = \"\\n\".join([dockerfile, compose, verify])\n\n    assert \"primitive-foundry\" in dockerfile\n    assert \"primitive-foundry\" in compose\n    for private_root in (\"products/\", \"releases/\", \"runs/\", \"packages/\", \"local-artifacts/\", \"sources/\", \"events/\"):\n        assert private_root in dockerignore","source_id":"foundry::tests/test_local_benchmark.py::test_customer_install_uses_current_cli_and_excludes_private_outputs","task":"python_test_generation"}
{"id":"foundry::tests/test_local_benchmark.py::test_product_node_sterilizes_sensitive_payloads_before_packaging::generate","input":"Source path: tests/test_local_benchmark.py\nDomains: privacy, release, marketplace, planner, dataset, benchmark\nImports: primitive_foundry.cells, primitive_foundry.commercial, primitive_foundry.compare, primitive_foundry.curation_brain, primitive_foundry.dataset, primitive_foundry.external_listing, primitive_foundry.foundry_bridge, primitive_foundry.generate_source_cards, primitive_foundry.generators, primitive_foundry.inspect_adapter, primitive_foundry.lifecycle, primitive_foundry.marketplace_packet, primitive_foundry.node_ops, primitive_foundry.primitive_bus_adapter, primitive_foundry.product_factory, primitive_foundry.product_planner, primitive_foundry.promotion, primitive_foundry.release, primitive_foundry.runner, primitive_foundry.scorers, primitive_foundry.source_curation, primitive_foundry.sterilization, primitive_foundry.summary, primitive_foundry.train_router, primitive_foundry.v04\nAssertion count: 11","instruction":"Write a pytest test for Primitive Foundry that verifies: test product node sterilizes sensitive payloads before packaging.","output":"def test_product_node_sterilizes_sensitive_payloads_before_packaging(tmp_path) -> None:\n    import json\n    from pathlib import Path\n\n    sources = []\n    for index in range(2):\n        source = tmp_path / f\"sensitive_source_{index}.md\"\n        source.write_text(\"private privacy provenance release source\", encoding=\"utf-8\")\n        sources.append(source)\n    events = tmp_path / \"events.jsonl\"\n    leaked_text = (\n        \"High value privacy provenance eval dataset release with quality evidence. \"\n        \"Contact [REDACTED_EMAIL], token [SECRET], \"\n        \"and local file /home/[USER] must not ship.\"\n    )\n    with events.open(\"w\", encoding=\"utf-8\") as handle:\n        for index, source in enumerate(sources, start=1):\n            handle.write(\n                json.dumps(\n                    {\n                        \"event_id\": f\"sensitive-{index}\",\n                        \"text\": f\"{leaked_text} Unique source marker {index}.\",\n                        \"source_path\": str(source),\n                        \"tags\": [\"privacy\", \"provenance\", \"eval\", f\"sensitive-{index}\"],\n                    },\n                    sort_keys=True,\n                )\n                + \"\\n\"\n            )\n\n    output_root = tmp_path / \"autonomous\"\n    result = run_product_node(\n        events_path=events,\n        output_root=output_root,\n        state_path=output_root / \"PRODUCT_PLANNER_STATE.json\",\n        target_size=\"micro\",\n        target_count=2,\n        min_source_diversity=2,\n        iterations=1,\n        poll_seconds=0,\n        dedupe_threshold=1.1,\n    )\n    release = result[\"results\"][0][\"releases\"][0]\n    release_dir = Path(release[\"candidate_dir\"])\n    bundle_dir = release_dir / \"bundle\"\n    records = \"\\n\".join((bundle_dir / \"source_foundry_records.jsonl\").read_text(encoding=\"utf-8\").splitlines())\n\n    assert result[\"passed\"]\n    assert verify_sterilized_bundle(bundle_dir)[\"passed\"]\n    assert verify_autonomous_release(release_dir / \"AUTONOMOUS_RELEASE.json\")[\"passed\"]\n    assert verify_package(output_root / \"packages\" / \"privacy_provenance_eval_000001.package.json\")[\"passed\"]\n    assert verify_sterilized_payload(json_load(release_dir / \"MARKETPLACE_LISTING.json\"))[\"passed\"]\n    assert \"[REDACTED_EMAIL]\" not in records\n    assert \"[SECRET]\" not in records\n    assert \"/home/[USER]\" not in records\n    assert \"[REDACTED:email]\" in records\n    assert \"[REDACTED:openai_key]\" in records\n    assert \"[REDACTED:local_path]\" in records","source_id":"foundry::tests/test_local_benchmark.py::test_product_node_sterilizes_sensitive_payloads_before_packaging","task":"python_test_generation"}
{"id":"foundry::tests/test_release_artifact_packaging.py::test_release_dir_has_gold_standard_artifacts::generate","input":"Source path: tests/test_release_artifact_packaging.py\nDomains: release, dataset\nImports: primitive_foundry.node_ops, primitive_foundry.product_planner\nAssertion count: 2","instruction":"Write a pytest test for Primitive Foundry that verifies: test release dir has gold standard artifacts.","output":"def test_release_dir_has_gold_standard_artifacts(release_dir: tuple[Path, Path, Path]) -> None:\n    release, _, _ = release_dir\n    for filename in (\"CROISSANT.jsonld\", \"SCHEMA_ORG_DATASET.jsonld\", \"DCAT.jsonld\"):\n        target = release / filename\n        assert target.exists(), f\"{filename} missing at release root\"\n        payload = json.loads(target.read_text(encoding=\"utf-8\"))\n        assert isinstance(payload, dict) and payload","source_id":"foundry::tests/test_release_artifact_packaging.py::test_release_dir_has_gold_standard_artifacts","task":"python_test_generation"}
{"id":"foundry::tests/test_release_artifact_packaging.py::test_package_tarball_includes_gold_standard_artifacts::generate","input":"Source path: tests/test_release_artifact_packaging.py\nDomains: release, marketplace, dataset, compliance\nImports: primitive_foundry.node_ops, primitive_foundry.product_planner\nAssertion count: 1","instruction":"Write a pytest test for Primitive Foundry that verifies: test package tarball includes gold standard artifacts.","output":"def test_package_tarball_includes_gold_standard_artifacts(\n    release_dir: tuple[Path, Path, Path]\n) -> None:\n    _, package, _ = release_dir\n    with tarfile.open(package, \"r:gz\") as archive:\n        members = {Path(m.name).name for m in archive.getmembers()}\n    for filename in (\n        \"MARKETPLACE_LISTING.json\",\n        \"CROISSANT.jsonld\",\n        \"SCHEMA_ORG_DATASET.jsonld\",\n        \"DCAT.jsonld\",\n        \"COMPLIANCE_MATRIX.json\",\n        \"DATASHEET.md\",\n    ):\n        assert filename in members, f\"{filename} not in tarball; got {sorted(members)}\"","source_id":"foundry::tests/test_release_artifact_packaging.py::test_package_tarball_includes_gold_standard_artifacts","task":"python_test_generation"}
{"id":"foundry::tests/test_release_artifact_packaging.py::test_product_package_tarball_hash_is_reproducible::generate","input":"Source path: tests/test_release_artifact_packaging.py\nDomains: release\nImports: primitive_foundry.node_ops, primitive_foundry.product_planner\nAssertion count: 2","instruction":"Write a pytest test for Primitive Foundry that verifies: test product package tarball hash is reproducible.","output":"def test_product_package_tarball_hash_is_reproducible(\n    release_dir: tuple[Path, Path, Path]\n) -> None:\n    release, package, output_root = release_dir\n    first_hash = hashlib.sha256(package.read_bytes()).hexdigest()\n\n    package_product(candidate_dir=release, output_dir=output_root / \"packages\")\n    second_hash = hashlib.sha256(package.read_bytes()).hexdigest()\n\n    package_product(candidate_dir=release, output_dir=output_root / \"packages\")\n    third_hash = hashlib.sha256(package.read_bytes()).hexdigest()\n\n    assert second_hash == first_hash\n    assert third_hash == first_hash","source_id":"foundry::tests/test_release_artifact_packaging.py::test_product_package_tarball_hash_is_reproducible","task":"python_test_generation"}
{"id":"foundry::tests/test_release_artifact_packaging.py::test_compliance_matrix_reflects_actual_source_cards::generate","input":"Source path: tests/test_release_artifact_packaging.py\nDomains: release, license, planner, compliance, source_card\nImports: primitive_foundry.node_ops, primitive_foundry.product_planner\nAssertion count: 1","instruction":"Write a pytest test for Primitive Foundry that verifies: test compliance matrix reflects actual source cards.","output":"def test_compliance_matrix_reflects_actual_source_cards(\n    release_dir: tuple[Path, Path, Path]\n) -> None:\n    release, _, _ = release_dir\n    matrix = json.loads((release / \"COMPLIANCE_MATRIX.json\").read_text(encoding=\"utf-8\"))\n    source_license_matrix = matrix[\"source_license_matrix\"]\n    # Source cards were written by the planner. The compliance matrix must\n    # count them \u2014 empty counts would mean the source-card threading is\n    # broken and the matrix is lying-by-omission about licensing.\n    assert source_license_matrix[\"source_license_counts\"], (\n        f\"compliance matrix has no source license entries; threading is broken. \"\n        f\"got: {source_license_matrix}\"\n    )","source_id":"foundry::tests/test_release_artifact_packaging.py::test_compliance_matrix_reflects_actual_source_cards","task":"python_test_generation"}
{"id":"foundry::tests/test_sterilization_adversarial.py::test_redacts_aws_access_key::generate","input":"Source path: tests/test_sterilization_adversarial.py\nDomains: sterilization\nImports: primitive_foundry, primitive_foundry.sterilization\nAssertion count: 2","instruction":"Write a pytest test for Primitive Foundry that verifies: test redacts aws access key.","output":"def test_redacts_aws_access_key() -> None:\n    result = sterilize_text(\"token [REDACTED_AWS_KEY] for bucket\", max_chars=200)\n    assert \"aws_access_key\" in result.redacted_fields\n    assert \"[REDACTED_AWS_KEY]\" not in result.text","source_id":"foundry::tests/test_sterilization_adversarial.py::test_redacts_aws_access_key","task":"python_test_generation"}
{"id":"foundry::tests/test_sterilization_adversarial.py::test_redacts_openai_and_anthropic_keys::generate","input":"Source path: tests/test_sterilization_adversarial.py\nDomains: sterilization\nImports: primitive_foundry, primitive_foundry.sterilization\nAssertion count: 2","instruction":"Write a pytest test for Primitive Foundry that verifies: test redacts openai and anthropic keys.","output":"def test_redacts_openai_and_anthropic_keys() -> None:\n    raw = \"OPENAI=[SECRET] ANTHROPIC=sk-ant-abcdefghijklmnopqrstuv\"\n    result = sterilize_text(raw, max_chars=400)\n    assert \"openai_key\" in result.redacted_fields or \"anthropic_key\" in result.redacted_fields\n    assert \"[SECRET]\" not in result.text","source_id":"foundry::tests/test_sterilization_adversarial.py::test_redacts_openai_and_anthropic_keys","task":"python_test_generation"}
{"id":"foundry::tests/test_sterilization_adversarial.py::test_redacts_github_token::generate","input":"Source path: tests/test_sterilization_adversarial.py\nDomains: sterilization\nImports: primitive_foundry, primitive_foundry.sterilization\nAssertion count: 1","instruction":"Write a pytest test for Primitive Foundry that verifies: test redacts github token.","output":"def test_redacts_github_token() -> None:\n    result = sterilize_text(\"token [SECRET]\", max_chars=200)\n    assert \"github_token\" in result.redacted_fields","source_id":"foundry::tests/test_sterilization_adversarial.py::test_redacts_github_token","task":"python_test_generation"}
{"id":"foundry::tests/test_sterilization_adversarial.py::test_redacts_slack_token::generate","input":"Source path: tests/test_sterilization_adversarial.py\nDomains: sterilization\nImports: primitive_foundry, primitive_foundry.sterilization\nAssertion count: 1","instruction":"Write a pytest test for Primitive Foundry that verifies: test redacts slack token.","output":"def test_redacts_slack_token() -> None:\n    result = sterilize_text(\"[SECRET]\", max_chars=200)\n    assert \"slack_token\" in result.redacted_fields","source_id":"foundry::tests/test_sterilization_adversarial.py::test_redacts_slack_token","task":"python_test_generation"}
{"id":"foundry::tests/test_sterilization_adversarial.py::test_redacts_google_api_key::generate","input":"Source path: tests/test_sterilization_adversarial.py\nDomains: sterilization\nImports: primitive_foundry, primitive_foundry.sterilization\nAssertion count: 1","instruction":"Write a pytest test for Primitive Foundry that verifies: test redacts google api key.","output":"def test_redacts_google_api_key() -> None:\n    result = sterilize_text(\"key=AIzaSyDdI0hCZtE6vySjMm-WEfRq3CPzqKqqsHI\", max_chars=200)\n    assert \"google_api_key\" in result.redacted_fields","source_id":"foundry::tests/test_sterilization_adversarial.py::test_redacts_google_api_key","task":"python_test_generation"}
{"id":"foundry::tests/test_sterilization_adversarial.py::test_redacts_stripe_secret_key::generate","input":"Source path: tests/test_sterilization_adversarial.py\nDomains: sterilization\nImports: primitive_foundry, primitive_foundry.sterilization\nAssertion count: 1","instruction":"Write a pytest test for Primitive Foundry that verifies: test redacts stripe secret key.","output":"def test_redacts_stripe_secret_key() -> None:\n    result = sterilize_text(\"STRIPE=[REDACTED_API_KEY]\", max_chars=200)\n    assert \"stripe_secret\" in result.redacted_fields","source_id":"foundry::tests/test_sterilization_adversarial.py::test_redacts_stripe_secret_key","task":"python_test_generation"}
{"id":"foundry::tests/test_sterilization_adversarial.py::test_redacts_jwt::generate","input":"Source path: tests/test_sterilization_adversarial.py\nDomains: sterilization\nImports: primitive_foundry, primitive_foundry.sterilization\nAssertion count: 1","instruction":"Write a pytest test for Primitive Foundry that verifies: test redacts jwt.","output":"def test_redacts_jwt() -> None:\n    jwt = \"eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIn0.signedpart\"\n    result = sterilize_text(f\"auth: {jwt}\", max_chars=400)\n    assert \"jwt\" in result.redacted_fields","source_id":"foundry::tests/test_sterilization_adversarial.py::test_redacts_jwt","task":"python_test_generation"}
{"id":"foundry::tests/test_sterilization_adversarial.py::test_redacts_bearer_token::generate","input":"Source path: tests/test_sterilization_adversarial.py\nDomains: sterilization\nImports: primitive_foundry, primitive_foundry.sterilization\nAssertion count: 1","instruction":"Write a pytest test for Primitive Foundry that verifies: test redacts bearer token.","output":"def test_redacts_bearer_token() -> None:\n    result = sterilize_text(\"Authorization: [SECRET]\", max_chars=200)\n    assert \"bearer_token\" in result.redacted_fields","source_id":"foundry::tests/test_sterilization_adversarial.py::test_redacts_bearer_token","task":"python_test_generation"}
{"id":"foundry::tests/test_sterilization_adversarial.py::test_redacts_password_assignment::generate","input":"Source path: tests/test_sterilization_adversarial.py\nDomains: sterilization\nImports: primitive_foundry, primitive_foundry.sterilization\nAssertion count: 1","instruction":"Write a pytest test for Primitive Foundry that verifies: test redacts password assignment.","output":"def test_redacts_password_assignment() -> None:\n    result = sterilize_text(\"password: hunter2hunter2\", max_chars=200)\n    assert \"password_assignment\" in result.redacted_fields","source_id":"foundry::tests/test_sterilization_adversarial.py::test_redacts_password_assignment","task":"python_test_generation"}
{"id":"foundry::tests/test_sterilization_adversarial.py::test_redacts_unix_path::generate","input":"Source path: tests/test_sterilization_adversarial.py\nDomains: sterilization\nImports: primitive_foundry, primitive_foundry.sterilization\nAssertion count: 1","instruction":"Write a pytest test for Primitive Foundry that verifies: test redacts unix path.","output":"def test_redacts_unix_path() -> None:\n    result = sterilize_text(\"see /home/[USER]\", max_chars=200)\n    assert \"local_path\" in result.redacted_fields","source_id":"foundry::tests/test_sterilization_adversarial.py::test_redacts_unix_path","task":"python_test_generation"}
{"id":"foundry::tests/test_sterilization_adversarial.py::test_redacts_windows_path::generate","input":"Source path: tests/test_sterilization_adversarial.py\nDomains: sterilization\nImports: primitive_foundry, primitive_foundry.sterilization\nAssertion count: 1","instruction":"Write a pytest test for Primitive Foundry that verifies: test redacts windows path.","output":"def test_redacts_windows_path() -> None:\n    result = sterilize_text(\"see C:\\\\Users\\\\alice\\\\secrets.txt\", max_chars=200)\n    assert \"local_path\" in result.redacted_fields","source_id":"foundry::tests/test_sterilization_adversarial.py::test_redacts_windows_path","task":"python_test_generation"}
{"id":"foundry::tests/test_sterilization_adversarial.py::test_input_size_cap_does_not_hang_on_long_input::generate","input":"Source path: tests/test_sterilization_adversarial.py\nDomains: sterilization\nImports: primitive_foundry, primitive_foundry.sterilization\nAssertion count: 3","instruction":"Write a pytest test for Primitive Foundry that verifies: test input size cap does not hang on long input.","output":"def test_input_size_cap_does_not_hang_on_long_input() -> None:\n    huge = \"A\" * (MAX_STERILIZE_INPUT_BYTES * 4) + \"[REDACTED_PRIVATE_KEY]\"\n    start = time.perf_counter()\n    result = sterilize_text(huge, max_chars=500)\n    elapsed = time.perf_counter() - start\n    assert elapsed < 1.0\n    assert \"input_oversize\" in result.risk_flags\n    assert any(\"input_truncated_at_\" in note for note in result.notes)","source_id":"foundry::tests/test_sterilization_adversarial.py::test_input_size_cap_does_not_hang_on_long_input","task":"python_test_generation"}
{"id":"foundry::tests/test_sterilization_adversarial.py::test_verify_payload_detects_jwt_in_nested_dict::generate","input":"Source path: tests/test_sterilization_adversarial.py\nDomains: sterilization\nImports: primitive_foundry, primitive_foundry.sterilization\nAssertion count: 2","instruction":"Write a pytest test for Primitive Foundry that verifies: test verify payload detects jwt in nested dict.","output":"def test_verify_payload_detects_jwt_in_nested_dict() -> None:\n    payload = {\n        \"metadata\": {\n            \"auth\": \"eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIn0.signedpart\"\n        }\n    }\n    result = verify_sterilized_payload(payload)\n    assert not result[\"passed\"]\n    assert any(\"jwt\" in failure for failure in result[\"failures\"])","source_id":"foundry::tests/test_sterilization_adversarial.py::test_verify_payload_detects_jwt_in_nested_dict","task":"python_test_generation"}
{"id":"foundry::tests/test_sterilization_adversarial.py::test_verify_payload_passes_clean_input::generate","input":"Source path: tests/test_sterilization_adversarial.py\nDomains: sterilization, benchmark\nImports: primitive_foundry, primitive_foundry.sterilization\nAssertion count: 2","instruction":"Write a pytest test for Primitive Foundry that verifies: test verify payload passes clean input.","output":"def test_verify_payload_passes_clean_input() -> None:\n    payload = {\"text\": \"a cleanly stated benchmark task\", \"rubric_id\": \"rubric.x.v1\"}\n    result = verify_sterilized_payload(payload)\n    assert result[\"passed\"]\n    assert result[\"coppa_passed\"]","source_id":"foundry::tests/test_sterilization_adversarial.py::test_verify_payload_passes_clean_input","task":"python_test_generation"}
{"id":"foundry::tests/test_sterilization_adversarial.py::test_verify_payload_skips_machine_identifier_fields::generate","input":"Source path: tests/test_sterilization_adversarial.py\nDomains: sterilization\nImports: primitive_foundry, primitive_foundry.sterilization\nAssertion count: 1","instruction":"Write a pytest test for Primitive Foundry that verifies: test verify payload skips machine identifier fields.","output":"def test_verify_payload_skips_machine_identifier_fields() -> None:\n    payload = {\"provenance_hash\": \"[REDACTED_AWS_KEY]\"}\n    result = verify_sterilized_payload(payload)\n    assert result[\"passed\"]","source_id":"foundry::tests/test_sterilization_adversarial.py::test_verify_payload_skips_machine_identifier_fields","task":"python_test_generation"}
{"id":"foundry::tests/test_sterilization_adversarial.py::test_coppa_under_13_string_is_refused::generate","input":"Source path: tests/test_sterilization_adversarial.py\nDomains: sterilization\nImports: primitive_foundry, primitive_foundry.sterilization\nAssertion count: 3","instruction":"Write a pytest test for Primitive Foundry that verifies: test coppa under 13 string is refused.","output":"def test_coppa_under_13_string_is_refused() -> None:\n    payload = {\"records\": [{\"metadata\": {\"source_age_class\": \"under_13\"}}]}\n    result = verify_sterilized_payload(payload)\n    assert not result[\"passed\"]\n    assert not result[\"coppa_passed\"]\n    assert any(\"coppa_under_13_value\" in f for f in result[\"failures\"])","source_id":"foundry::tests/test_sterilization_adversarial.py::test_coppa_under_13_string_is_refused","task":"python_test_generation"}
{"id":"foundry::tests/test_sterilization_adversarial.py::test_coppa_numeric_age_under_13_is_refused::generate","input":"Source path: tests/test_sterilization_adversarial.py\nDomains: sterilization\nImports: primitive_foundry, primitive_foundry.sterilization\nAssertion count: 2","instruction":"Write a pytest test for Primitive Foundry that verifies: test coppa numeric age under 13 is refused.","output":"def test_coppa_numeric_age_under_13_is_refused() -> None:\n    payload = {\"subject\": {\"age\": 10}}\n    result = verify_sterilized_payload(payload)\n    assert not result[\"passed\"]\n    assert any(\"coppa_under_13_age\" in f for f in result[\"failures\"])","source_id":"foundry::tests/test_sterilization_adversarial.py::test_coppa_numeric_age_under_13_is_refused","task":"python_test_generation"}
{"id":"foundry::tests/test_sterilization_adversarial.py::test_coppa_adult_age_passes::generate","input":"Source path: tests/test_sterilization_adversarial.py\nDomains: sterilization\nImports: primitive_foundry, primitive_foundry.sterilization\nAssertion count: 1","instruction":"Write a pytest test for Primitive Foundry that verifies: test coppa adult age passes.","output":"def test_coppa_adult_age_passes() -> None:\n    payload = {\"subject\": {\"age\": 31}}\n    result = verify_sterilized_payload(payload)\n    assert result[\"passed\"]","source_id":"foundry::tests/test_sterilization_adversarial.py::test_coppa_adult_age_passes","task":"python_test_generation"}
{"id":"foundry::tests/test_sterilization_adversarial.py::test_jsonl_oversize_line_caught::generate","input":"Source path: tests/test_sterilization_adversarial.py\nDomains: sterilization\nImports: primitive_foundry, primitive_foundry.sterilization\nAssertion count: 2","instruction":"Write a pytest test for Primitive Foundry that verifies: test jsonl oversize line caught.","output":"def test_jsonl_oversize_line_caught(tmp_path: Path) -> None:\n    target = tmp_path / \"huge.jsonl\"\n    target.write_text(\n        '{\"text\": \"ok\"}\\n' + (\"X\" * (MAX_JSONL_LINE_BYTES + 100)) + \"\\n\",\n        encoding=\"utf-8\",\n    )\n    result = verify_sterilized_jsonl(target)\n    assert not result[\"passed\"]\n    assert any(\"exceeds_\" in f for f in result[\"failures\"])","source_id":"foundry::tests/test_sterilization_adversarial.py::test_jsonl_oversize_line_caught","task":"python_test_generation"}
{"id":"foundry::tests/test_sterilization_adversarial.py::test_jsonl_malformed_line_aggregates::generate","input":"Source path: tests/test_sterilization_adversarial.py\nDomains: sterilization\nImports: primitive_foundry, primitive_foundry.sterilization\nAssertion count: 2","instruction":"Write a pytest test for Primitive Foundry that verifies: test jsonl malformed line aggregates.","output":"def test_jsonl_malformed_line_aggregates(tmp_path: Path) -> None:\n    target = tmp_path / \"bad.jsonl\"\n    target.write_text(\n        '{\"text\": \"ok\"}\\n{not json\\n{\"text\": \"good\"}\\n',\n        encoding=\"utf-8\",\n    )\n    result = verify_sterilized_jsonl(target)\n    assert not result[\"passed\"]\n    assert any(\"invalid_json\" in f for f in result[\"failures\"])","source_id":"foundry::tests/test_sterilization_adversarial.py::test_jsonl_malformed_line_aggregates","task":"python_test_generation"}
{"id":"foundry::tests/test_sterilization_adversarial.py::test_llm_scan_disabled_by_default::generate","input":"Source path: tests/test_sterilization_adversarial.py\nDomains: sterilization\nImports: primitive_foundry, primitive_foundry.sterilization\nAssertion count: 1","instruction":"Write a pytest test for Primitive Foundry that verifies: test llm scan disabled by default.","output":"def test_llm_scan_disabled_by_default(monkeypatch: pytest.MonkeyPatch) -> None:\n    monkeypatch.delenv(\"FOUNDRY_LLM_STERILIZATION\", raising=False)\n    assert llm_scan_available() is False","source_id":"foundry::tests/test_sterilization_adversarial.py::test_llm_scan_disabled_by_default","task":"python_test_generation"}
{"id":"foundry::tests/test_sterilization_adversarial.py::test_llm_scan_returns_empty_when_unavailable::generate","input":"Source path: tests/test_sterilization_adversarial.py\nDomains: sterilization\nImports: primitive_foundry, primitive_foundry.sterilization\nAssertion count: 1","instruction":"Write a pytest test for Primitive Foundry that verifies: test llm scan returns empty when unavailable.","output":"def test_llm_scan_returns_empty_when_unavailable(monkeypatch: pytest.MonkeyPatch) -> None:\n    monkeypatch.delenv(\"FOUNDRY_LLM_STERILIZATION\", raising=False)\n    # No client passed and scan unavailable \u2192 returns [] without raising.\n    assert llm_secondary_scan({\"text\": \"anything\"}) == []","source_id":"foundry::tests/test_sterilization_adversarial.py::test_llm_scan_returns_empty_when_unavailable","task":"python_test_generation"}
{"id":"foundry::tests/test_sterilization_adversarial.py::test_llm_scan_uses_injected_client::generate","input":"Source path: tests/test_sterilization_adversarial.py\nDomains: sterilization\nImports: primitive_foundry, primitive_foundry.sterilization\nAssertion count: 2","instruction":"Write a pytest test for Primitive Foundry that verifies: test llm scan uses injected client.","output":"def test_llm_scan_uses_injected_client() -> None:\n    captured: list[str] = []\n\n    def fake_client(sample: str) -> list[str]:\n        captured.append(sample)\n        return [\"contains_first_name\", \"internal_project_codename\"]\n\n    flags = llm_secondary_scan({\"text\": \"Hello from Alice on Project Falcon\"}, client=fake_client)\n    assert flags == [\"contains_first_name\", \"internal_project_codename\"]\n    assert captured and \"Alice\" in captured[0]","source_id":"foundry::tests/test_sterilization_adversarial.py::test_llm_scan_uses_injected_client","task":"python_test_generation"}
{"id":"foundry::tests/test_sterilization_adversarial.py::test_llm_scan_client_failure_does_not_break_pipeline::generate","input":"Source path: tests/test_sterilization_adversarial.py\nDomains: sterilization\nImports: primitive_foundry, primitive_foundry.sterilization\nAssertion count: 1","instruction":"Write a pytest test for Primitive Foundry that verifies: test llm scan client failure does not break pipeline.","output":"def test_llm_scan_client_failure_does_not_break_pipeline() -> None:\n    def broken_client(sample: str) -> list[str]:\n        raise RuntimeError(\"model not loaded\")\n\n    assert llm_secondary_scan({\"text\": \"x\"}, client=broken_client) == []","source_id":"foundry::tests/test_sterilization_adversarial.py::test_llm_scan_client_failure_does_not_break_pipeline","task":"python_test_generation"}
{"id":"foundry::tests/test_sterilization_adversarial.py::test_sterilize_text_collapses_whitespace_and_truncates::generate","input":"Source path: tests/test_sterilization_adversarial.py\nDomains: sterilization\nImports: primitive_foundry, primitive_foundry.sterilization\nAssertion count: 2","instruction":"Write a pytest test for Primitive Foundry that verifies: test sterilize text collapses whitespace and truncates.","output":"def test_sterilize_text_collapses_whitespace_and_truncates() -> None:\n    result = sterilize_text(\"hello\\n\\n\\nworld   bench\" + \" x\" * 200, max_chars=24)\n    assert len(result.text) <= 24\n    assert \"truncated_to_24_chars\" in result.notes","source_id":"foundry::tests/test_sterilization_adversarial.py::test_sterilize_text_collapses_whitespace_and_truncates","task":"python_test_generation"}
{"id":"foundry::tests/test_sterilization_adversarial.py::test_credit_card_pattern_flags_long_digit_run::generate","input":"Source path: tests/test_sterilization_adversarial.py\nDomains: sterilization\nImports: primitive_foundry, primitive_foundry.sterilization\nAssertion count: 1","instruction":"Write a pytest test for Primitive Foundry that verifies: test credit card pattern flags long digit run.","output":"def test_credit_card_pattern_flags_long_digit_run() -> None:\n    result = sterilize_text(\"4111 1111 1111 1111\", max_chars=80)\n    assert \"credit_card\" in result.redacted_fields","source_id":"foundry::tests/test_sterilization_adversarial.py::test_credit_card_pattern_flags_long_digit_run","task":"python_test_generation"}
{"id":"foundry::tests/test_sterilization_adversarial.py::test_verify_payload_refuses_primitive_patent_mechanism_language::generate","input":"Source path: tests/test_sterilization_adversarial.py\nDomains: sterilization\nImports: primitive_foundry, primitive_foundry.sterilization\nAssertion count: 2","instruction":"Write a pytest test for Primitive Foundry that verifies: test verify payload refuses primitive patent mechanism language.","output":"def test_verify_payload_refuses_primitive_patent_mechanism_language() -> None:\n    payload = {\n        \"listing\": \"This exposes the Context Primitive Kernel mesh orchestration protocol and PVTR recall internals.\"\n    }\n    result = verify_sterilized_payload(payload)\n    assert not result[\"passed\"]\n    assert any(\"patent_sensitive_mechanism\" in failure for failure in result[\"failures\"])","source_id":"foundry::tests/test_sterilization_adversarial.py::test_verify_payload_refuses_primitive_patent_mechanism_language","task":"python_test_generation"}
{"id":"foundry::tests/test_sterilization_adversarial.py::test_sterilize_text_redacts_primitive_mechanism_language::generate","input":"Source path: tests/test_sterilization_adversarial.py\nDomains: sterilization\nImports: primitive_foundry, primitive_foundry.sterilization\nAssertion count: 3","instruction":"Write a pytest test for Primitive Foundry that verifies: test sterilize text redacts primitive mechanism language.","output":"def test_sterilize_text_redacts_primitive_mechanism_language() -> None:\n    result = sterilize_text(\n        \"The trust-modulated aperture and human-seat authority are part of the provisional patent.\",\n        max_chars=400,\n    )\n    assert \"patent_sensitive_mechanism\" in result.risk_flags\n    assert \"trust-modulated aperture\" not in result.text\n    assert \"provisional patent\" not in result.text","source_id":"foundry::tests/test_sterilization_adversarial.py::test_sterilize_text_redacts_primitive_mechanism_language","task":"python_test_generation"}
{"id":"foundry::tests/test_workflow.py::test_foundry_workflow_order_has_format_before_compile::generate","input":"Source path: tests/test_workflow.py\nDomains: foundry\nImports: primitive_foundry.workflow\nAssertion count: 2","instruction":"Write a pytest test for Primitive Foundry that verifies: test foundry workflow order has format before compile.","output":"def test_foundry_workflow_order_has_format_before_compile() -> None:\n    payload = workflow_payload()\n    order = payload[\"stage_order\"]\n\n    assert order == EXPECTED_STAGE_ORDER\n    assert order.index(\"format\") < order.index(\"compile_verify\")","source_id":"foundry::tests/test_workflow.py::test_foundry_workflow_order_has_format_before_compile","task":"python_test_generation"}
{"id":"foundry::tests/test_workflow.py::test_workflow_cli_matches_source_contract::generate","input":"Source path: tests/test_workflow.py\nDomains: foundry\nImports: primitive_foundry.workflow\nAssertion count: 2","instruction":"Write a pytest test for Primitive Foundry that verifies: test workflow cli matches source contract.","output":"def test_workflow_cli_matches_source_contract() -> None:\n    proc = subprocess.run(\n        [sys.executable, \"-m\", \"primitive_foundry.cli\", \"workflow\"],\n        text=True,\n        capture_output=True,\n        check=True,\n    )\n    payload = json.loads(proc.stdout)\n\n    assert payload[\"passed\"] is True\n    assert payload[\"stage_order\"] == EXPECTED_STAGE_ORDER","source_id":"foundry::tests/test_workflow.py::test_workflow_cli_matches_source_contract","task":"python_test_generation"}
{"id":"foundry::tests/test_workflow.py::test_kernel_adapter_cli_uses_foundry_durable_name::generate","input":"Source path: tests/test_workflow.py\nDomains: bus\nImports: primitive_foundry.workflow\nAssertion count: 1","instruction":"Write a pytest test for Primitive Foundry that verifies: test kernel adapter cli uses foundry durable name.","output":"def test_kernel_adapter_cli_uses_foundry_durable_name(tmp_path: Path) -> None:\n    output = tmp_path / \"kernel_nats_adapter.json\"\n    subprocess.run(\n        [\n            sys.executable,\n            \"-m\",\n            \"primitive_foundry.cli\",\n            \"write-kernel-bus-adapter\",\n            \"--output\",\n            str(output),\n        ],\n        text=True,\n        capture_output=True,\n        check=True,\n    )\n\n    payload = json.loads(output.read_text(encoding=\"utf-8\"))\n    assert payload[\"durable\"] == \"primitive-foundry-importer\"","source_id":"foundry::tests/test_workflow.py::test_kernel_adapter_cli_uses_foundry_durable_name","task":"python_test_generation"}
{"id":"foundry::primitive-harness/tests/test_license.py::test_ed25519_license_verifies_and_gates::generate","input":"Source path: primitive-harness/tests/test_license.py\nDomains: license\nImports: none\nAssertion count: 1","instruction":"Write a pytest test for Primitive Foundry that verifies: test ed25519 license verifies and gates.","output":"def test_ed25519_license_verifies_and_gates(tmp_path) -> None:\n    private = Ed25519PrivateKey.generate()\n    private_path = tmp_path / \"license_private.pem\"\n    public_path = tmp_path / \"license_public.pem\"\n    license_path = tmp_path / \"license.json\"\n    private_path.write_bytes(\n        private.private_bytes(\n            encoding=serialization.Encoding.PEM,\n            format=serialization.PrivateFormat.PKCS8,\n            encryption_algorithm=serialization.NoEncryption(),\n        )\n    )\n    public_path.write_bytes(\n        private.public_key().public_bytes(\n            encoding=serialization.Encoding.PEM,\n            format=serialization.PublicFormat.SubjectPublicKeyInfo,\n        )\n    )\n\n    issue_license(\n        private_key_path=private_path,\n        output_path=license_path,\n        issued_to=\"ACME Corp\",\n        tier=\"enterprise\",\n        expires_at=\"2027-09-01T00:00:00+00:00\",\n        feature_flags=[\"score\", \"batch\", \"export\"],\n    )\n    verified = verify_license(license_path, public_path.read_bytes())\n\n    assert verified.issued_to == \"ACME Corp\"\n    gate_call(verified, \"score\")","source_id":"foundry::primitive-harness/tests/test_license.py::test_ed25519_license_verifies_and_gates","task":"python_test_generation"}
{"id":"foundry::primitive-harness/tests/test_privacy_pack.py::test_buyer_runs_privacy_pack_shape::generate","input":"Source path: primitive-harness/tests/test_privacy_pack.py\nDomains: privacy\nImports: none\nAssertion count: 1","instruction":"Write a pytest test for Primitive Foundry that verifies: test buyer runs privacy pack shape.","output":"def test_buyer_runs_privacy_pack_shape() -> None:\n    # Package-level smoke; foundry integration tests exercise real bundle loading.\n    assert callable(run)","source_id":"foundry::primitive-harness/tests/test_privacy_pack.py::test_buyer_runs_privacy_pack_shape","task":"python_test_generation"}
{"id":"foundry::primitive-harness/tests/test_runtime.py::test_cli_errors_are_structured_json::generate","input":"Source path: primitive-harness/tests/test_runtime.py\nDomains: foundry\nImports: none\nAssertion count: 3","instruction":"Write a pytest test for Primitive Foundry that verifies: test cli errors are structured json.","output":"def test_cli_errors_are_structured_json() -> None:\n    proc = subprocess.run(\n        [\n            sys.executable,\n            \"-m\",\n            \"primitive_harness.cli\",\n            \"score\",\n            \"--bundle\",\n            \"/missing/bundle\",\n            \"--agent\",\n            \"missing:run\",\n            \"--output\",\n            \"/tmp/out.json\",\n        ],\n        text=True,\n        capture_output=True,\n        check=False,\n    )\n\n    assert proc.returncode == 1\n    payload = json.loads(proc.stderr)\n    assert payload[\"stage\"] == \"score\"\n    assert payload[\"error_class\"] in {\"FileNotFoundError\", \"ValueError\"}","source_id":"foundry::primitive-harness/tests/test_runtime.py::test_cli_errors_are_structured_json","task":"python_test_generation"}