{"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"}