Primitive-Origins/context-primitive-code-agent-pack-v0
Context Primitive Code-Agent Pack v0 — Free Funnel Free product-specific instruction / Q&A seed material from Primitive Origins’ Context Primitive / Foundry tests. This is a marketing / companion corpus for the Context Primitive stack — not a general public code-agent marketplace hero SKU. What’s inside JSONL splits under data/: behavior_qa.train.jsonl / .eval.jsonl instruction_test_generation.train.jsonl / .eval.jsonl foundry/python_test_generation.*… See the full description on the dataset page: https://huggingface.co/datasets/Primitive-Origins/context-primitive-code-agent-pack-v0.
067
1{"id":"cp-auth::account_store_authenticates_and_persists_encrypted::generate_test","input":"Crate: cp-auth\nSource path: crates/cp-auth/src/tests.rs\nDomains: auth\nRoutes: no HTTP route\nExpected statuses: no explicit HTTP status\nExpected error codes: no named error code\nRoles/tokens observed: none","instruction":"Write a Rust integration test for Context Primitive that verifies: account store authenticates and persists encrypted.","output":"\n#[test]\nfn account_store_authenticates_and_persists_encrypted() -> Result<(), Box<dyn std::error::Error>> {\n let dir = temp_dir(\"accounts\")?;\n let mut store = AccountStore::open(&dir, &key())?;\n let account = store.create(create_owner(\n \"[REDACTED_EMAIL]\",\n \"correct horse battery staple\",\n ))?;\n let authed = store.authenticate(\"[REDACTED_EMAIL]\", \"correct horse battery staple\")?;\n assert_eq!(authed.account_id, account.account_id);\n assert!(authed.last_login_at.is_some());\n let raw = fs::read_to_string(dir.join(\"auth\").join(\"accounts.json\"))?;\n assert!(!raw.contains(\"correct horse battery staple\"));\n assert!(!raw.contains(\"[REDACTED_EMAIL]\"));\n\n let reopened = AccountStore::open(&dir, &key())?;\n assert_eq!(reopened.list().len(), 1);\n Ok(())\n}","source_test_id":"cp-auth::account_store_authenticates_and_persists_encrypted","task":"rust_integration_test_generation"}2{"id":"cp-auth::saml_subject_maps_to_account::generate_test","input":"Crate: cp-auth\nSource path: crates/cp-auth/src/tests.rs\nDomains: auth\nRoutes: no HTTP route\nExpected statuses: no explicit HTTP status\nExpected error codes: no named error code\nRoles/tokens observed: none","instruction":"Write a Rust integration test for Context Primitive that verifies: saml subject maps to account.","output":"\n#[test]\nfn saml_subject_maps_to_account() -> Result<(), Box<dyn std::error::Error>> {\n let dir = temp_dir(\"saml\")?;\n let mut accounts = AccountStore::open(&dir, &key())?;\n let account = accounts.create(create_owner(\"owner\", \"correct horse battery staple\"))?;\n let mut store = EnterpriseAuthStore::open(&dir, &key())?;\n store.upsert_saml_provider(SamlProviderConfig {\n provider_id: \"corp-saml\".to_owned(),\n entity_id: \"urn:corp:context-primitive\".to_owned(),\n sso_url: \"https://idp.example.test/sso\".to_owned(),\n certificate_fingerprint_sha256: \"a\".repeat(64),\n enabled: true,\n })?;\n let subject = ExternalIdentitySubject {\n provider_kind: IdentityProviderKind::Saml,\n provider_id: \"corp-saml\".to_owned(),\n subject: \"[REDACTED_EMAIL]\".to_owned(),\n };\n store.link_external_subject(subject.clone(), account.account_id.clone())?;\n assert_eq!(\n store.resolve_external_subject(&subject),\n Some(&account.account_id)\n );\n Ok(())\n}","source_test_id":"cp-auth::saml_subject_maps_to_account","task":"rust_integration_test_generation"}3{"id":"cp-auth::mfa_required_account_gets_challenge::generate_test","input":"Crate: cp-auth\nSource path: crates/cp-auth/src/tests.rs\nDomains: auth\nRoutes: no HTTP route\nExpected statuses: no explicit HTTP status\nExpected error codes: no named error code\nRoles/tokens observed: none","instruction":"Write a Rust integration test for Context Primitive that verifies: mfa required account gets challenge.","output":"\n#[test]\nfn mfa_required_account_gets_challenge() -> Result<(), Box<dyn std::error::Error>> {\n let dir = temp_dir(\"mfa\")?;\n let mut accounts = AccountStore::open(&dir, &key())?;\n let account = accounts.create(create_owner(\"owner\", \"correct horse battery staple\"))?;\n let mut store = EnterpriseAuthStore::open(&dir, &key())?;\n store.set_mfa_required(account.account_id.clone(), true)?;\n assert!(store.mfa_required(&account.account_id));\n store.add_passkey(\n account.account_id.clone(),\n \"cred-a\",\n \"cose-public-key-placeholder\",\n \"Owner passkey\",\n )?;\n let issue = store.create_mfa_challenge(account.account_id, 1_000, 60_000)?;\n assert!(!issue.challenge.is_empty());\n let completed =\n store.complete_mfa_challenge(&issue.record.challenge_id, &issue.challenge, 2_000)?;\n assert_eq!(completed.completed_at, Some(2_000));\n Ok(())\n}","source_test_id":"cp-auth::mfa_required_account_gets_challenge","task":"rust_integration_test_generation"}4{"id":"cp-auth::revoked_session_rejected_on_all_nodes::generate_test","input":"Crate: cp-auth\nSource path: crates/cp-auth/src/tests.rs\nDomains: auth\nRoutes: no HTTP route\nExpected statuses: no explicit HTTP status\nExpected error codes: no named error code\nRoles/tokens observed: none","instruction":"Write a Rust integration test for Context Primitive that verifies: revoked session rejected on all nodes.","output":"\n#[test]\nfn revoked_session_rejected_on_all_nodes() -> Result<(), Box<dyn std::error::Error>> {\n let dir = temp_dir(\"revoked-cross-node\")?;\n let mut accounts = AccountStore::open(&dir, &key())?;\n let account = accounts.create(create_owner(\"owner\", \"correct horse battery staple\"))?;\n let mut node_a_sessions = SessionStore::open(&dir, &key())?;\n let mut node_b_sessions = SessionStore::open(&dir, &key())?;\n let (access, _, session) = node_a_sessions.create(&account)?;\n node_b_sessions.reload()?;\n assert!(\n node_b_sessions\n .verify_access_token(access.expose(), session.created_at)\n .is_ok()\n );\n node_a_sessions.revoke(&session.session_id, session.created_at + 1)?;\n node_b_sessions.reload()?;\n assert!(\n node_b_sessions\n .verify_access_token(access.expose(), session.created_at + 2)\n .is_err()\n );\n Ok(())\n}","source_test_id":"cp-auth::revoked_session_rejected_on_all_nodes","task":"rust_integration_test_generation"}5{"id":"cp-bus::append_persists_and_reopens_with_verified_chain::generate_test","input":"Crate: cp-bus\nSource path: crates/cp-bus/src/store.rs\nDomains: task, event\nRoutes: no HTTP route\nExpected statuses: no explicit HTTP status\nExpected error codes: no named error code\nRoles/tokens observed: none","instruction":"Write a Rust integration test for Context Primitive that verifies: append persists and reopens with verified chain.","output":"\n #[test]\n fn append_persists_and_reopens_with_verified_chain() -> Result<(), Box<dyn std::error::Error>> {\n let path = temp_path(\"reopen\");\n let mut store = StreamStore::open(&path)?;\n assert_eq!(store.schema_version(), CURRENT_EVENT_SCHEMA_VERSION);\n append_task(&mut store, \"t1\")?;\n append_task(&mut store, \"t2\")?;\n let reopened = StreamStore::open(&path)?;\n let report = reopened.verify()?;\n assert_eq!(report.checked_records, 2);\n assert_eq!(report.last_sequence, 2);\n fs::remove_file(path)?;\n Ok(())\n }","source_test_id":"cp-bus::append_persists_and_reopens_with_verified_chain","task":"rust_integration_test_generation"}6{"id":"cp-bus::nack_redelivers_record::generate_test","input":"Crate: cp-bus\nSource path: crates/cp-bus/src/store.rs\nDomains: task\nRoutes: no HTTP route\nExpected statuses: no explicit HTTP status\nExpected error codes: no named error code\nRoles/tokens observed: none","instruction":"Write a Rust integration test for Context Primitive that verifies: nack redelivers record.","output":"\n #[test]\n fn nack_redelivers_record() -> Result<(), Box<dyn std::error::Error>> {\n let path = temp_path(\"nack-redelivery\");\n let mut store = StreamStore::open(&path)?;\n append_task(&mut store, \"t1\")?;\n let sub = Subscription::new(\n SubscriptionId::new(\"sub-a\")?,\n \"consumer-a\",\n &NodeId::new(\"node-a\")?,\n SubjectFilter::new(\"task.*\")?,\n )?;\n let first = store.read(&sub, 1);\n assert_eq!(first[0].body.sequence, 1);\n store.decide(\n \"consumer-a\",\n 1,\n AckDecision::Nack {\n reason: \"temporary failure\".to_string(),\n },\n )?;\n let redelivery = store.read(&sub, 1);\n assert_eq!(redelivery.len(), 1);\n assert_eq!(redelivery[0].hash, first[0].hash);\n let reopened = StreamStore::open(&path)?;\n assert_eq!(reopened.ack_records().len(), 1);\n fs::remove_file(path)?;\n Ok(())\n }","source_test_id":"cp-bus::nack_redelivers_record","task":"rust_integration_test_generation"}7{"id":"cp-config::defaults_are_valid::generate_test","input":"Crate: cp-config\nSource path: crates/cp-config/src/loader.rs\nDomains: general\nRoutes: no HTTP route\nExpected statuses: no explicit HTTP status\nExpected error codes: no named error code\nRoles/tokens observed: none","instruction":"Write a Rust integration test for Context Primitive that verifies: defaults are valid.","output":"\n #[test]\n fn defaults_are_valid() -> Result<(), Box<dyn std::error::Error>> {\n let config = ConfigLoader::load(&[ConfigLayer::CompiledDefaults])?;\n assert_eq!(config.mode, RuntimeMode::LocalOnly);\n assert_eq!(config.node_id.as_str(), \"node-local\");\n assert!(config.data_dir.is_absolute());\n Ok(())\n }","source_test_id":"cp-config::defaults_are_valid","task":"rust_integration_test_generation"}8{"id":"cp-config::relay_server_env_loads_peer_directory::generate_test","input":"Crate: cp-config\nSource path: crates/cp-config/src/loader.rs\nDomains: general\nRoutes: no HTTP route\nExpected statuses: no explicit HTTP status\nExpected error codes: no named error code\nRoles/tokens observed: none","instruction":"Write a Rust integration test for Context Primitive that verifies: relay server env loads peer directory.","output":"\n #[test]\n fn relay_server_env_loads_peer_directory() -> Result<(), Box<dyn std::error::Error>> {\n let vars = BTreeMap::from([\n (\"CP_RELAY_SERVER_LISTEN_ADDR\", \"127.0.0.1:7000\".to_owned()),\n (\n \"CP_RELAY_SERVER_PEERS\",\n \"node-peer-a=127.0.0.1:9001,node-peer-b=127.0.0.1:9002\".to_owned(),\n ),\n ]);\n let env_partial = load_environment_from(|name| vars.get(name).cloned())?;\n let merged = env_partial.merge_over(CompiledDefaults.partial());\n let config = ResolvedConfig::from_partial(merged)?;\n let relay = config.relay_server.ok_or(\"missing relay server\")?;\n\n assert_eq!(relay.listen_addr, \"127.0.0.1:7000\".parse()?);\n assert_eq!(relay.peers.len(), 2);\n assert_eq!(relay.peers[1].node_id.as_str(), \"node-peer-b\");\n assert_eq!(relay.peers[1].addr, \"127.0.0.1:9002\".parse()?);\n Ok(())\n }","source_test_id":"cp-config::relay_server_env_loads_peer_directory","task":"rust_integration_test_generation"}9{"id":"cp-core::rejects_missing_known_payload_keys::generate_test","input":"Crate: cp-core\nSource path: crates/cp-core/src/event.rs\nDomains: task, event\nRoutes: no HTTP route\nExpected statuses: no explicit HTTP status\nExpected error codes: no named error code\nRoles/tokens observed: none","instruction":"Write a Rust integration test for Context Primitive that verifies: rejects missing known payload keys.","output":"\n #[test]\n fn rejects_missing_known_payload_keys() -> Result<(), String> {\n let err = match validate_payload(\"task.created\", [\"task_id\"], false) {\n Ok(_) => return Err(\"task.created without goal should fail validation\".to_string()),\n Err(err) => err,\n };\n assert_eq!(\n err,\n PayloadValidationError::MissingKeys {\n event_type: \"task.created\".to_string(),\n missing: vec![\"goal\"],\n }\n );\n Ok(())\n }","source_test_id":"cp-core::rejects_missing_known_payload_keys","task":"rust_integration_test_generation"}10{"id":"cp-core::tenant_event_specs_are_registered::generate_test","input":"Crate: cp-core\nSource path: crates/cp-core/src/event.rs\nDomains: event, agent, tenant\nRoutes: no HTTP route\nExpected statuses: no explicit HTTP status\nExpected error codes: no named error code\nRoles/tokens observed: none","instruction":"Write a Rust integration test for Context Primitive that verifies: tenant event specs are registered.","output":"\n #[test]\n fn tenant_event_specs_are_registered() -> Result<(), PayloadValidationError> {\n let report = validate_payload(\n \"tenant.agent.replacement_needed\",\n [\"tenant_id\", \"agent_id\", \"role\", \"reason\"],\n true,\n )?;\n assert!(report.valid);\n assert_eq!(report.spec.expect(\"missing spec\").source, \"tenant-registry\");\n Ok(())\n }","source_test_id":"cp-core::tenant_event_specs_are_registered","task":"rust_integration_test_generation"}11{"id":"cp-core::hex_encode_lowercase::generate_test","input":"Crate: cp-core\nSource path: crates/cp-core/src/hash.rs\nDomains: general\nRoutes: no HTTP route\nExpected statuses: no explicit HTTP status\nExpected error codes: no named error code\nRoles/tokens observed: none","instruction":"Write a Rust integration test for Context Primitive that verifies: hex encode lowercase.","output":"\n #[test]\n fn hex_encode_lowercase() {\n assert_eq!(hex_encode(&[0x00, 0x0f, 0xa5, 0xff]), \"000fa5ff\");\n }","source_test_id":"cp-core::hex_encode_lowercase","task":"rust_integration_test_generation"}12{"id":"cp-core::rejects_control_characters::generate_test","input":"Crate: cp-core\nSource path: crates/cp-core/src/id.rs\nDomains: general\nRoutes: no HTTP route\nExpected statuses: no explicit HTTP status\nExpected error codes: no named error code\nRoles/tokens observed: none","instruction":"Write a Rust integration test for Context Primitive that verifies: rejects control characters.","output":"\n #[test]\n fn rejects_control_characters() {\n assert_eq!(NodeId::new(\"node\\n1\"), Err(IdError::ControlCharacter));\n }","source_test_id":"cp-core::rejects_control_characters","task":"rust_integration_test_generation"}13{"id":"cp-core::accepts_displayable_identifier::generate_test","input":"Crate: cp-core\nSource path: crates/cp-core/src/id.rs\nDomains: workflow\nRoutes: no HTTP route\nExpected statuses: no explicit HTTP status\nExpected error codes: no named error code\nRoles/tokens observed: none","instruction":"Write a Rust integration test for Context Primitive that verifies: accepts displayable identifier.","output":"\n #[test]\n fn accepts_displayable_identifier() -> Result<(), IdError> {\n let id = WorkflowId::new(\"workflow-alpha\")?;\n assert_eq!(id.as_str(), \"workflow-alpha\");\n Ok(())\n }","source_test_id":"cp-core::accepts_displayable_identifier","task":"rust_integration_test_generation"}14{"id":"cp-daemon::parses_bootstrap_owner_flags::generate_test","input":"Crate: cp-daemon\nSource path: crates/cp-daemon/src/main.rs\nDomains: auth\nRoutes: no HTTP route\nExpected statuses: no explicit HTTP status\nExpected error codes: no named error code\nRoles/tokens observed: none","instruction":"Write a Rust integration test for Context Primitive that verifies: parses bootstrap owner flags.","output":"\n #[test]\n fn parses_bootstrap_owner_flags() -> Result<(), Box<dyn std::error::Error>> {\n let args = CliArgs::parse([\n \"--bootstrap-owner-username\".to_string(),\n \"owner\".to_string(),\n \"--bootstrap-owner-password-file\".to_string(),\n \"/tmp/cp-owner-password\".to_string(),\n \"--auth-key-env\".to_string(),\n \"CP_AUTH_KEY\".to_string(),\n ])?;\n\n assert_eq!(args.bootstrap_owner_username.as_deref(), Some(\"owner\"));\n assert_eq!(\n args.bootstrap_owner_password_file.as_deref(),\n Some(Path::new(\"/tmp/cp-owner-password\"))\n );\n assert_eq!(args.auth_key_env.as_deref(), Some(\"CP_AUTH_KEY\"));\n Ok(())\n }","source_test_id":"cp-daemon::parses_bootstrap_owner_flags","task":"rust_integration_test_generation"}15{"id":"cp-daemon::config_file_builds_daemon_config::generate_test","input":"Crate: cp-daemon\nSource path: crates/cp-daemon/src/main.rs\nDomains: general\nRoutes: no HTTP route\nExpected statuses: no explicit HTTP status\nExpected error codes: no named error code\nRoles/tokens observed: none","instruction":"Write a Rust integration test for Context Primitive that verifies: config file builds daemon config.","output":"\n #[test]\n fn config_file_builds_daemon_config() -> Result<(), Box<dyn std::error::Error>> {\n let data_dir = env::temp_dir().join(\"cp-daemon-config-file-data\");\n let config_path = temp_config_path(\"config-file\")?;\n fs::write(\n &config_path,\n format!(\n \"node_id = \\\"node-from-file\\\"\\ndata_dir = \\\"{}\\\"\\n[relay_server]\\nlisten_addr = \\\"127.0.0.1:0\\\"\\npeers = [{{ node_id = \\\"node-peer\\\", addr = \\\"127.0.0.1:9001\\\" }}]\\n\",\n data_dir.display()\n ),\n )?;\n let args = CliArgs::parse([\n \"--node-id\".to_string(),\n \"node-ignored\".to_string(),\n \"--config-file\".to_string(),\n config_path.display().to_string(),\n ])?;\n\n let config = args.config()?;\n assert_eq!(config.node_id, NodeId::new(\"node-from-file\")?);\n assert_eq!(config.data_dir, data_dir);\n assert_eq!(config.mode, DaemonMode::LocalOnly);\n let relay = config.relay_server.ok_or(\"missing relay server\")?;\n assert_eq!(relay.listen_addr, \"127.0.0.1:0\".parse()?);\n assert_eq!(relay.peers.len(), 1);\n assert_eq!(relay.peers[0].node_id, NodeId::new(\"node-peer\")?);\n assert_eq!(relay.peers[0].addr, \"127.0.0.1:9001\".parse()?);\n Ok(())\n }","source_test_id":"cp-daemon::config_file_builds_daemon_config","task":"rust_integration_test_generation"}16{"id":"cp-daemon::help_documents_transport_manifest_operator_flags::generate_test","input":"Crate: cp-daemon\nSource path: crates/cp-daemon/src/main.rs\nDomains: transport\nRoutes: no HTTP route\nExpected statuses: no explicit HTTP status\nExpected error codes: no named error code\nRoles/tokens observed: none","instruction":"Write a Rust integration test for Context Primitive that verifies: help documents transport manifest operator flags.","output":"\n #[test]\n fn help_documents_transport_manifest_operator_flags() {\n assert!(HELP.contains(\"--config-file\"));\n assert!(HELP.contains(\"--secret-store\"));\n assert!(HELP.contains(\"[relay_server]\"));\n assert!(HELP.contains(\"CP_RELAY_SERVER_LISTEN_ADDR\"));\n assert!(HELP.contains(\"CP_RELAY_SERVER_PEERS\"));\n assert!(HELP.contains(\"--transport-handoff-json\"));\n assert!(HELP.contains(\"--transport-handoff-audit-json\"));\n assert!(HELP.contains(\"--transport-directory-json\"));\n assert!(HELP.contains(\"--transport-runtime-json\"));\n assert!(HELP.contains(\"--transport-add-peer\"));\n assert!(HELP.contains(\"--transport-remove-peer\"));\n }","source_test_id":"cp-daemon::help_documents_transport_manifest_operator_flags","task":"rust_integration_test_generation"}17{"id":"cp-governance::dag_rejects_cycle::generate_test","input":"Crate: cp-governance\nSource path: crates/cp-governance/src/scribe.rs\nDomains: event\nRoutes: no HTTP route\nExpected statuses: no explicit HTTP status\nExpected error codes: no named error code\nRoles/tokens observed: none","instruction":"Write a Rust integration test for Context Primitive that verifies: dag rejects cycle.","output":"\n #[test]\n fn dag_rejects_cycle() -> Result<(), Box<dyn std::error::Error>> {\n let mut scribe = Scribe::new();\n scribe.insert_node(ProvenanceNodeInput {\n node_id: \"a\".to_string(),\n entity_type: \"dataset\".to_string(),\n entity_id: \"a\".to_string(),\n event_type: \"foundry.dataset\".to_string(),\n source: \"test\".to_string(),\n timestamp_unix_ms: 1,\n metadata: json!({}),\n })?;\n scribe.insert_node(ProvenanceNodeInput {\n node_id: \"b\".to_string(),\n entity_type: \"model\".to_string(),\n entity_id: \"b\".to_string(),\n event_type: \"model.outcome\".to_string(),\n source: \"test\".to_string(),\n timestamp_unix_ms: 1,\n metadata: json!({}),\n })?;\n scribe.insert_edge(\n \"a\",\n \"b\",\n DerivationType::DerivedFrom,\n \"event-a\",\n json!({}),\n 1,\n )?;\n\n let result = scribe.insert_edge(\n \"b\",\n \"a\",\n DerivationType::DerivedFrom,\n \"event-b\",\n json!({}),\n 1,\n );\n\n assert_eq!(result, Err(ScribeError::CycleDetected));\n Ok(())\n }","source_test_id":"cp-governance::dag_rejects_cycle","task":"rust_integration_test_generation"}18{"id":"cp-governance::projection_indexes_parent_child_event::generate_test","input":"Crate: cp-governance\nSource path: crates/cp-governance/src/scribe.rs\nDomains: task, event, agent\nRoutes: no HTTP route\nExpected statuses: no explicit HTTP status\nExpected error codes: no named error code\nRoles/tokens observed: none","instruction":"Write a Rust integration test for Context Primitive that verifies: projection indexes parent child event.","output":"\n #[test]\n fn projection_indexes_parent_child_event() -> Result<(), Box<dyn std::error::Error>> {\n let mut scribe = Scribe::new();\n let parent = AcceptedEvent::new(\n EntryId::new(\"event-a\")?,\n EventType::new(\"task.created\")?,\n \"task\",\n json!({\"task_id\":\"task-a\"}),\n 1_000,\n \"task-ledger\",\n None,\n )?;\n let child = AcceptedEvent::new(\n EntryId::new(\"event-b\")?,\n EventType::new(\"task.completed\")?,\n \"task\",\n json!({\"task_id\":\"task-a\",\"agent_id\":\"agent-a\"}),\n 1_100,\n \"task-ledger\",\n Some(EntryId::new(\"event-a\")?),\n )?;\n\n scribe.apply(&parent)?;\n scribe.apply(&child)?;\n\n assert!(\n !scribe\n .lineage_chain(\"event:event-b\")?\n .ordered_edges\n .is_empty()\n );\n Ok(())\n }","source_test_id":"cp-governance::projection_indexes_parent_child_event","task":"rust_integration_test_generation"}19{"id":"cp-installer::linux_plan_validates_default_layout::generate_test","input":"Crate: cp-installer\nSource path: crates/cp-installer/src/lib.rs\nDomains: general\nRoutes: no HTTP route\nExpected statuses: no explicit HTTP status\nExpected error codes: no named error code\nRoles/tokens observed: none","instruction":"Write a Rust integration test for Context Primitive that verifies: linux plan validates default layout.","output":"\n #[test]\n fn linux_plan_validates_default_layout() -> Result<(), Box<dyn std::error::Error>> {\n let plan = plan()?;\n\n plan.validate()?;\n assert_eq!(plan.platform, InstallPlatform::LinuxSystemd);\n assert_eq!(plan.actions.len(), 11);\n assert!(plan.env_file.contains(\"CP_NODE_ID=context-primitive-local\"));\n assert!(plan.service_file.contains(\"NoNewPrivileges=true\"));\n assert!(plan.service_file.contains(\"--request-stop\"));\n Ok(())\n }","source_test_id":"cp-installer::linux_plan_validates_default_layout","task":"rust_integration_test_generation"}20{"id":"cp-installer::setup_generates_node_identity::generate_test","input":"Crate: cp-installer\nSource path: crates/cp-installer/src/setup.rs\nDomains: transport\nRoutes: no HTTP route\nExpected statuses: no explicit HTTP status\nExpected error codes: no named error code\nRoles/tokens observed: none","instruction":"Write a Rust integration test for Context Primitive that verifies: setup generates node identity.","output":"\n #[test]\n fn setup_generates_node_identity() -> Result<(), Box<dyn std::error::Error>> {\n let mut config = config(\"identity\")?;\n config.node_id = None;\n\n let report = run_non_interactive_setup(&config, \"correct horse battery staple\")?;\n let raw = fs::read_to_string(&report.node_identity_file)?;\n let identity: NodeIdentity = serde_json::from_str(&raw)?;\n\n assert_eq!(identity.node_id, report.node_id);\n assert_eq!(identity.transport_private_key_hex.len(), 64);\n assert_eq!(identity.transport_public_key_hex.len(), 64);\n assert_eq!(identity.node_signing_key_hex.len(), 64);\n assert_eq!(\n identity\n .node_id\n .as_str()\n .chars()\n .filter(|ch| *ch == '-')\n .count(),\n 4\n );\n Ok(())\n }","source_test_id":"cp-installer::setup_generates_node_identity","task":"rust_integration_test_generation"}21{"id":"cp-installer::setup_writes_valid_config_toml::generate_test","input":"Crate: cp-installer\nSource path: crates/cp-installer/src/setup.rs\nDomains: general\nRoutes: no HTTP route\nExpected statuses: no explicit HTTP status\nExpected error codes: no named error code\nRoles/tokens observed: none","instruction":"Write a Rust integration test for Context Primitive that verifies: setup writes valid config toml.","output":"\n #[test]\n fn setup_writes_valid_config_toml() -> Result<(), Box<dyn std::error::Error>> {\n let config = config(\"config\")?;\n\n let report = run_non_interactive_setup(&config, \"correct horse battery staple\")?;\n let loaded = ConfigLoader::load(&[\n ConfigLayer::CompiledDefaults,\n ConfigLayer::LocalNodeFile(report.config_file),\n ConfigLayer::SecretStore(config.config_dir.join(\"secrets.toml\")),\n ])?;\n\n assert_eq!(loaded.node_id, report.node_id);\n assert_eq!(loaded.data_dir, config.data_dir);\n assert!(loaded.net.is_some());\n assert!(loaded.api.enabled);\n Ok(())\n }","source_test_id":"cp-installer::setup_writes_valid_config_toml","task":"rust_integration_test_generation"}22{"id":"cp-installer::setup_install_service_writes_reviewable_handoff::generate_test","input":"Crate: cp-installer\nSource path: crates/cp-installer/src/setup.rs\nDomains: general\nRoutes: no HTTP route\nExpected statuses: no explicit HTTP status\nExpected error codes: no named error code\nRoles/tokens observed: none","instruction":"Write a Rust integration test for Context Primitive that verifies: setup install service writes reviewable handoff.","output":"\n #[test]\n fn setup_install_service_writes_reviewable_handoff() -> Result<(), Box<dyn std::error::Error>> {\n let mut config = config(\"service-handoff\")?;\n config.install_service = true;\n\n let report = run_non_interactive_setup(&config, \"correct horse battery staple\")?;\n let path = report\n .service_handoff_file\n .ok_or(\"missing service handoff file\")?;\n let handoff = fs::read_to_string(path)?;\n\n assert!(\n handoff.contains(\"LinuxSystemd\")\n || handoff.contains(\"MacOsLaunchd\")\n || handoff.contains(\"WindowsService\")\n );\n assert!(handoff.contains(\"context-primitive\"));\n Ok(())\n }","source_test_id":"cp-installer::setup_install_service_writes_reviewable_handoff","task":"rust_integration_test_generation"}23{"id":"cp-kernel::cold_context_can_be_recalled::generate_test","input":"Crate: cp-kernel\nSource path: crates/cp-kernel/src/context_lifecycle.rs\nDomains: event\nRoutes: no HTTP route\nExpected statuses: no explicit HTTP status\nExpected error codes: no named error code\nRoles/tokens observed: none","instruction":"Write a Rust integration test for Context Primitive that verifies: cold context can be recalled.","output":"\n #[test]\n fn cold_context_can_be_recalled() -> Result<(), Box<dyn std::error::Error>> {\n let mut manager = ContextLifecycleManager::new(ContextLifecyclePolicy::default());\n let entry_id = EntryId::new(\"entry-a\")?;\n manager.upsert_entry(entry(\"entry-a\", ContextTemperature::Cold)?)?;\n\n let emission = manager.recall_cold(&entry_id, \"operator request\", 2_000)?;\n\n assert_eq!(emission.event_type, \"context.lifecycle.recalled\");\n assert_eq!(\n manager.entry(&entry_id).ok_or(\"missing entry\")?.temperature,\n ContextTemperature::Warm\n );\n Ok(())\n }","source_test_id":"cp-kernel::cold_context_can_be_recalled","task":"rust_integration_test_generation"}24{"id":"cp-kernel::live_seat_requires_non_expired_lease::generate_test","input":"Crate: cp-kernel\nSource path: crates/cp-kernel/src/human.rs\nDomains: general\nRoutes: no HTTP route\nExpected statuses: no explicit HTTP status\nExpected error codes: no named error code\nRoles/tokens observed: none","instruction":"Write a Rust integration test for Context Primitive that verifies: live seat requires non expired lease.","output":"\n #[test]\n fn live_seat_requires_non_expired_lease() -> Result<(), Box<dyn std::error::Error>> {\n let seat = HumanSeat::present(UserId::new(\"operator\")?, 2_000)?;\n assert!(seat.is_live(1_999));\n assert!(!seat.is_live(2_000));\n assert_eq!(seat.effective_state(2_000), HumanSeatState::Hold);\n Ok(())\n }","source_test_id":"cp-kernel::live_seat_requires_non_expired_lease","task":"rust_integration_test_generation"}25{"id":"cp-kernel::stays_when_no_evidence_requires_escalation::generate_test","input":"Crate: cp-kernel\nSource path: crates/cp-kernel/src/model_escalation.rs\nDomains: trust\nRoutes: no HTTP route\nExpected statuses: no explicit HTTP status\nExpected error codes: no named error code\nRoles/tokens observed: none","instruction":"Write a Rust integration test for Context Primitive that verifies: stays when no evidence requires escalation.","output":"\n #[test]\n fn stays_when_no_evidence_requires_escalation() -> Result<(), Box<dyn Error>> {\n let trust = trust()?;\n let engine = ModelEscalationEngine::default();\n let decision = engine.evaluate(&trust, &request()?)?;\n\n assert_eq!(decision.outcome, ModelEscalationOutcome::Stayed);\n assert_eq!(decision.escalation_signal, None);\n assert_eq!(decision.reason, \"current_tier_sufficient\");\n Ok(())\n }","source_test_id":"cp-kernel::stays_when_no_evidence_requires_escalation","task":"rust_integration_test_generation"}26{"id":"cp-kernel::verifier_rejection_triggers_escalation_even_with_high_confidence::generate_test","input":"Crate: cp-kernel\nSource path: crates/cp-kernel/src/model_escalation.rs\nDomains: trust\nRoutes: no HTTP route\nExpected statuses: no explicit HTTP status\nExpected error codes: no named error code\nRoles/tokens observed: none","instruction":"Write a Rust integration test for Context Primitive that verifies: verifier rejection triggers escalation even with high confidence.","output":"\n #[test]\n fn verifier_rejection_triggers_escalation_even_with_high_confidence()\n -> Result<(), Box<dyn Error>> {\n let trust = trust()?;\n let engine = ModelEscalationEngine::default();\n let mut request = request()?;\n request.verification_outcome = VerificationOutcome::Failed;\n\n let decision = engine.evaluate(&trust, &request)?;\n\n assert_eq!(decision.outcome, ModelEscalationOutcome::Escalated);\n assert_eq!(\n decision.escalation_signal,\n Some(EscalationSignal::VerifierRejected)\n );\n assert_eq!(\n decision.reason,\n \"verifier_rejected_completion_triggered_escalation\"\n );\n Ok(())\n }","source_test_id":"cp-kernel::verifier_rejection_triggers_escalation_even_with_high_confidence","task":"rust_integration_test_generation"}27{"id":"cp-kernel::schema_violation_triggers_escalation::generate_test","input":"Crate: cp-kernel\nSource path: crates/cp-kernel/src/model_escalation.rs\nDomains: trust\nRoutes: no HTTP route\nExpected statuses: no explicit HTTP status\nExpected error codes: no named error code\nRoles/tokens observed: none","instruction":"Write a Rust integration test for Context Primitive that verifies: schema violation triggers escalation.","output":"\n #[test]\n fn schema_violation_triggers_escalation() -> Result<(), Box<dyn Error>> {\n let trust = trust()?;\n let engine = ModelEscalationEngine::default();\n let mut request = request()?;\n request.verification_outcome = VerificationOutcome::SchemaViolation;\n\n let decision = engine.evaluate(&trust, &request)?;\n\n assert_eq!(decision.outcome, ModelEscalationOutcome::Escalated);\n assert_eq!(\n decision.escalation_signal,\n Some(EscalationSignal::SchemaValidationFailed)\n );\n assert_eq!(decision.reason, \"schema_validation_triggered_escalation\");\n Ok(())\n }","source_test_id":"cp-kernel::schema_violation_triggers_escalation","task":"rust_integration_test_generation"}28{"id":"cp-kernel::identity_drift_is_rejected::generate_test","input":"Crate: cp-kernel\nSource path: crates/cp-kernel/src/node_lifecycle.rs\nDomains: event, transport\nRoutes: no HTTP route\nExpected statuses: no explicit HTTP status\nExpected error codes: no named error code\nRoles/tokens observed: none","instruction":"Write a Rust integration test for Context Primitive that verifies: identity drift is rejected.","output":"\n #[test]\n fn identity_drift_is_rejected() -> Result<(), Box<dyn std::error::Error>> {\n let mut registry = bootstrapped()?;\n let root = NodeId::new(\"node-root\")?;\n let joining = identity(\"node-b\")?;\n let (invite, _) =\n registry.create_invite(&root, joining.node_id.clone(), \"invite-1\", 10_000, 200)?;\n registry.request_join(\n JoinRequest {\n invitation_code: invite.encode_code(),\n identity: joining.clone(),\n },\n 300,\n )?;\n registry.approve_join(&joining.node_id, 400)?;\n let mut drifted = joining;\n drifted.transport_key_id = \"unexpected-key\".to_string();\n let event = registry.observe_heartbeat(&drifted, 500)?;\n assert_eq!(event.event_type.as_str(), \"node.identity.drift_rejected\");\n Ok(())\n }","source_test_id":"cp-kernel::identity_drift_is_rejected","task":"rust_integration_test_generation"}29{"id":"cp-kernel::rbac_policy_denies_workspace_mismatch::generate_test","input":"Crate: cp-kernel\nSource path: crates/cp-kernel/src/rbac.rs\nDomains: rbac\nRoutes: no HTTP route\nExpected statuses: no explicit HTTP status\nExpected error codes: no named error code\nRoles/tokens observed: Owner, Viewer","instruction":"Write a Rust integration test for Context Primitive that verifies: rbac policy denies workspace mismatch.","output":"\n #[test]\n fn rbac_policy_denies_workspace_mismatch() -> Result<(), Box<dyn std::error::Error>> {\n let other_workspace = WorkspaceId::new(\"workspace-staging\")?;\n let policy = RbacPolicy::new(vec![RoleBinding::new(\n user()?,\n org()?,\n Some(other_workspace),\n Role::Owner,\n )]);\n\n let decision = policy.check(&user()?, &org()?, Some(&workspace()?), Role::Viewer);\n assert_eq!(\n decision,\n RbacDecision::Deny {\n reason: DenyReason::WorkspaceMismatch\n }\n );\n Ok(())\n }","source_test_id":"cp-kernel::rbac_policy_denies_workspace_mismatch","task":"rust_integration_test_generation"}30{"id":"cp-kernel::expired_lease_can_be_reclaimed::generate_test","input":"Crate: cp-kernel\nSource path: crates/cp-kernel/src/task.rs\nDomains: task, agent\nRoutes: no HTTP route\nExpected statuses: no explicit HTTP status\nExpected error codes: no named error code\nRoles/tokens observed: none","instruction":"Write a Rust integration test for Context Primitive that verifies: expired lease can be reclaimed.","output":"\n #[test]\n fn expired_lease_can_be_reclaimed() -> Result<(), Box<dyn std::error::Error>> {\n let mut ledger = TaskLedger::new();\n let task = TaskId::new(\"task-a\")?;\n ledger.create(create_request()?)?;\n ledger.claim(\n &task,\n AgentId::new(\"agent-a\")?,\n NodeId::new(\"node-a\")?,\n &token()?,\n 1_001,\n 100,\n )?;\n\n ledger.reclaim_expired(&task, 1_200)?;\n\n assert_eq!(\n ledger.record(&task).map(|record| &record.status),\n Some(&TaskStatus::ReclaimedExpired)\n );\n Ok(())\n }","source_test_id":"cp-kernel::expired_lease_can_be_reclaimed","task":"rust_integration_test_generation"}31{"id":"cp-kernel::live_lease_check_rejects_wrong_token::generate_test","input":"Crate: cp-kernel\nSource path: crates/cp-kernel/src/task.rs\nDomains: task, agent\nRoutes: no HTTP route\nExpected statuses: no explicit HTTP status\nExpected error codes: no named error code\nRoles/tokens observed: none","instruction":"Write a Rust integration test for Context Primitive that verifies: live lease check rejects wrong token.","output":"\n #[test]\n fn live_lease_check_rejects_wrong_token() -> Result<(), Box<dyn std::error::Error>> {\n let mut ledger = TaskLedger::new();\n let task = TaskId::new(\"task-a\")?;\n let agent = AgentId::new(\"agent-a\")?;\n ledger.create(create_request()?)?;\n ledger.claim(\n &task,\n agent.clone(),\n NodeId::new(\"node-a\")?,\n &token()?,\n 1_001,\n 1_000,\n )?;\n let wrong = LeaseToken::new(\"abcdef0123456789abcdef0123456789\")?;\n\n assert!(!ledger.has_live_lease(&task, &agent, &wrong, 1_100));\n Ok(())\n }","source_test_id":"cp-kernel::live_lease_check_rejects_wrong_token","task":"rust_integration_test_generation"}32{"id":"cp-kernel::failed_primary_does_not_disable_tenant_and_promotes_standby::generate_test","input":"Crate: cp-kernel\nSource path: crates/cp-kernel/src/tenant.rs\nDomains: trust, event, agent, tenant\nRoutes: no HTTP route\nExpected statuses: no explicit HTTP status\nExpected error codes: no named error code\nRoles/tokens observed: none","instruction":"Write a Rust integration test for Context Primitive that verifies: failed primary does not disable tenant and promotes standby.","output":"\n #[test]\n fn failed_primary_does_not_disable_tenant_and_promotes_standby()\n -> Result<(), Box<dyn std::error::Error>> {\n let (mut registry, tenant) = registry_with_tenant()?;\n let primary = AgentId::new(\"agent-primary\")?;\n let standby = AgentId::new(\"agent-standby\")?;\n registry.bind_agent(\n &tenant,\n primary.clone(),\n \"primary\",\n TenantBindingStatus::Active,\n 1_001,\n )?;\n registry.bind_agent(\n &tenant,\n standby.clone(),\n \"primary\",\n TenantBindingStatus::Standby,\n 1_002,\n )?;\n\n let emissions = registry.mark_replacement_needed(&primary, \"trust kill\", 1_003)?;\n let record = registry.tenant(&tenant).ok_or(\"missing tenant\")?;\n\n assert!(record.enabled);\n assert!(!record.suspended);\n assert_eq!(emissions[0].event_type, \"tenant.agent.replacement_needed\");\n assert!(registry.is_agent_eligible_for_tenant(&tenant, &standby));\n assert!(!registry.is_agent_eligible_for_tenant(&tenant, &primary));\n Ok(())\n }","source_test_id":"cp-kernel::failed_primary_does_not_disable_tenant_and_promotes_standby","task":"rust_integration_test_generation"}33{"id":"cp-kernel::registry_persists_and_reloads_tenant_home_and_bindings::generate_test","input":"Crate: cp-kernel\nSource path: crates/cp-kernel/src/tenant.rs\nDomains: agent, tenant\nRoutes: no HTTP route\nExpected statuses: no explicit HTTP status\nExpected error codes: no named error code\nRoles/tokens observed: none","instruction":"Write a Rust integration test for Context Primitive that verifies: registry persists and reloads tenant home and bindings.","output":"\n #[test]\n fn registry_persists_and_reloads_tenant_home_and_bindings()\n -> Result<(), Box<dyn std::error::Error>> {\n let (mut registry, tenant) = registry_with_tenant()?;\n let agent = AgentId::new(\"agent-primary\")?;\n registry.bind_agent(\n &tenant,\n agent.clone(),\n \"primary\",\n TenantBindingStatus::Active,\n 1_001,\n )?;\n let path = temp_registry_path(\"tenant-registry-reload\");\n let store = TenantRegistryStore::new(path.clone());\n\n store.save(®istry)?;\n let loaded = store.load()?;\n let loaded_tenant = loaded\n .tenant(&tenant)\n .ok_or(\"missing tenant after reload\")?;\n\n assert_eq!(loaded_tenant.domain, \"example.test\");\n assert!(loaded.is_agent_eligible_for_tenant(&tenant, &agent));\n let _ = std::fs::remove_file(path);\n Ok(())\n }","source_test_id":"cp-kernel::registry_persists_and_reloads_tenant_home_and_bindings","task":"rust_integration_test_generation"}34{"id":"cp-kernel::registry_emits_expected_event_material::generate_test","input":"Crate: cp-kernel\nSource path: crates/cp-kernel/src/tenant.rs\nDomains: event, agent, tenant\nRoutes: no HTTP route\nExpected statuses: no explicit HTTP status\nExpected error codes: no named error code\nRoles/tokens observed: none","instruction":"Write a Rust integration test for Context Primitive that verifies: registry emits expected event material.","output":"\n #[test]\n fn registry_emits_expected_event_material() -> Result<(), Box<dyn std::error::Error>> {\n let mut registry = TenantRegistry::new();\n let tenant = TenantId::new(\"tenant-a\")?;\n let registered = registry.register(\n tenant.clone(),\n \"example.test\",\n [\"base\"],\n \"/state/tenant-a\",\n BTreeMap::new(),\n 1_000,\n )?;\n\n let bound = registry.bind_agent(\n &tenant,\n AgentId::new(\"agent-primary\")?,\n \"primary\",\n TenantBindingStatus::Active,\n 1_001,\n )?;\n\n assert_eq!(registered.event_type, \"tenant.registered\");\n assert_eq!(\n registered.payload.get(\"tenant_id\"),\n Some(&tenant.to_string())\n );\n assert_eq!(bound.event_type, \"tenant.agent.bound\");\n assert_eq!(bound.payload.get(\"status\"), Some(&\"active\".to_string()));\n Ok(())\n }","source_test_id":"cp-kernel::registry_emits_expected_event_material","task":"rust_integration_test_generation"}35{"id":"cp-mwl::health_returns_200_without_auth::generate_test","input":"Crate: cp-mwl\nSource path: crates/cp-mwl/src/tests.rs\nDomains: auth\nRoutes: GET /health\nExpected statuses: 200\nExpected error codes: no named error code\nRoles/tokens observed: none","instruction":"Write a Rust integration test for Context Primitive that verifies: health returns 200 without auth.","output":"\n#[test]\nfn health_returns_200_without_auth() -> Result<(), Box<dyn std::error::Error>> {\n let response = router()?.handle(ApiRequest::new(\"GET\", \"/health\"));\n assert_eq!(response.status, 200);\n Ok(())\n}","source_test_id":"cp-mwl::health_returns_200_without_auth","task":"rust_integration_test_generation"}36{"id":"cp-mwl::auth_login_refresh_and_logout_use_real_sessions::generate_test","input":"Crate: cp-mwl\nSource path: crates/cp-mwl/src/tests.rs\nDomains: auth, event\nRoutes: POST /auth/login, GET /auth/accounts, POST /auth/token/refresh, POST /auth/logout, GET /auth/accounts\nExpected statuses: 200, 201, 401\nExpected error codes: no named error code\nRoles/tokens observed: none","instruction":"Write a Rust integration test for Context Primitive that verifies: auth login refresh and logout use real sessions.","output":"\n#[test]\nfn auth_login_refresh_and_logout_use_real_sessions() -> Result<(), Box<dyn std::error::Error>> {\n let api = auth_router()?;\n let login = api.handle(ApiRequest::new(\"POST\", \"/auth/login\").json(&json!({\n \"username\": \"owner\",\n \"password\": \"correct horse battery staple\"\n }))?);\n assert_eq!(login.status, 200);\n let parsed: Value = serde_json::from_slice(&login.body)?;\n let access = parsed[\"access_token\"]\n .as_str()\n .ok_or(\"missing access token\")?;\n let refresh = parsed[\"refresh_token\"]\n .as_str()\n .ok_or(\"missing refresh token\")?;\n assert_eq!(parsed[\"expires_in\"], 900);\n {\n let resources = api_state_resources(&api);\n let resources = resources\n .lock()\n .map_err(|_| \"api resources lock poisoned\")?;\n assert!(resources.bus.records().iter().any(|record| {\n record.body.event_type.as_str() == \"auth.login.success\"\n && record.body.payload[\"account_id\"].is_string()\n && record.body.payload[\"session_id\"].is_string()\n }));\n }\n\n let accounts = api.handle(\n ApiRequest::new(\"GET\", \"/auth/accounts\")\n .header(\"authorization\", format!(\"Bearer {access}\")),\n );\n assert_eq!(accounts.status, 200);\n\n let refreshed = api.handle(\n ApiRequest::new(\"POST\", \"/auth/token/refresh\").json(&json!({\"refresh_token\": refresh}))?,\n );\n assert_eq!(refreshed.status, 200);\n let refreshed_body: Value = serde_json::from_slice(&refreshed.body)?;\n let refreshed_access = refreshed_body[\"access_token\"]\n .as_str()\n .ok_or(\"missing refreshed access token\")?;\n assert_ne!(refreshed_access, access);\n\n let logout = api.handle(\n ApiRequest::new(\"POST\", \"/auth/logout\")\n .header(\"authorization\", format!(\"Bearer {refreshed_access}\")),\n );\n assert_eq!(logout.status, 201);\n\n let rejected = api.handle(\n ApiRequest::new(\"GET\", \"/auth/accounts\")\n .header(\"authorization\", format!(\"Bearer {refreshed_access}\")),\n );\n assert_eq!(rejected.status, 401);\n Ok(())\n}","source_test_id":"cp-mwl::auth_login_refresh_and_logout_use_real_sessions","task":"rust_integration_test_generation"}37{"id":"cp-mwl::auth_login_without_accounts_returns_503::generate_test","input":"Crate: cp-mwl\nSource path: crates/cp-mwl/src/tests.rs\nDomains: auth, backup\nRoutes: POST /auth/login\nExpected statuses: 503\nExpected error codes: no named error code\nRoles/tokens observed: none","instruction":"Write a Rust integration test for Context Primitive that verifies: auth login without accounts returns 503.","output":"\n#[test]\nfn auth_login_without_accounts_returns_503() -> Result<(), Box<dyn std::error::Error>> {\n let data_dir = temp_dir(\"auth-empty\")?;\n let key = BackupKeyMaterial::new([23; 32], [24; 12]);\n let auth = AuthService::open(&data_dir, &key)?;\n let api = ApiRouter::new(ApiState::new_with_auth(\n NodeId::new(\"node-local\")?,\n auth,\n ApiResources::open(data_dir)?,\n ));\n let response = api.handle(\n ApiRequest::new(\"POST\", \"/auth/login\")\n .json(&json!({\"username\": \"owner\", \"password\": \"irrelevant\"}))?,\n );\n assert_eq!(response.status, 503);\n Ok(())\n}","source_test_id":"cp-mwl::auth_login_without_accounts_returns_503","task":"rust_integration_test_generation"}38{"id":"cp-mwl::task_completion_rejects_medium_risk_without_verifier_evidence::generate_test","input":"Crate: cp-mwl\nSource path: crates/cp-mwl/src/tests.rs\nDomains: auth, workflow, task, agent, tenant\nRoutes: POST /tasks, POST /tasks/task-complete-needs-verifier/claim, POST /tasks/task-complete-needs-verifier/complete, GET /tasks/task-complete-needs-verifier\nExpected statuses: 200, 201, 403\nExpected error codes: kernel_task_complete_rejected\nRoles/tokens observed: developer","instruction":"Write a Rust integration test for Context Primitive that verifies: task completion rejects medium risk without verifier evidence.","output":"\n#[test]\nfn task_completion_rejects_medium_risk_without_verifier_evidence()\n-> Result<(), Box<dyn std::error::Error>> {\n let api = router()?;\n let task = json!({\n \"task_id\": \"task-complete-needs-verifier\",\n \"status\": \"created\",\n \"assigned_agent_id\": null,\n \"assigned_node_id\": null,\n \"workflow_run_id\": null,\n \"workflow_id\": null,\n \"edge_id\": null,\n \"tenant_id\": null,\n \"binding_role\": \"simple_worker.echo\",\n \"selected_model_tier\": \"Tier3B\",\n \"lease_expires_at_ms\": null,\n \"attempt_count\": 0,\n \"max_attempts\": 1,\n \"retry_reason\": null,\n \"failure_reason\": null,\n \"failed_at_ms\": null,\n \"completed_by_agent_id\": null,\n \"completed_at_ms\": null\n });\n let created = api.handle(\n ApiRequest::new(\"POST\", \"/tasks\")\n .header(\"authorization\", \"Bearer developer\")\n .json(&task)?,\n );\n assert_eq!(created.status, 201);\n let claimed = api.handle(\n ApiRequest::new(\"POST\", \"/tasks/task-complete-needs-verifier/claim\")\n .header(\"authorization\", \"Bearer developer\")\n .json(&json!({\"agent_id\": \"agent-a\", \"node_id\": \"node-local\"}))?,\n );\n assert_eq!(claimed.status, 200);\n let claim: Value = serde_json::from_slice(&claimed.body)?;\n let lease_token = claim[\"lease_token\"].as_str().unwrap_or_default();\n\n let missing_evidence = api.handle(\n ApiRequest::new(\"POST\", \"/tasks/task-complete-needs-verifier/complete\")\n .header(\"authorization\", \"Bearer developer\")\n .json(&json!({\n \"agent_id\": \"agent-a\",\n \"lease_token\": lease_token,\n \"risk_class\": \"medium\",\n \"verification_outcome\": \"passed\"\n }))?,\n );\n assert_eq!(missing_evidence.status, 403);\n let missing_body: Value = serde_json::from_slice(&missing_evidence.body)?;\n assert_eq!(missing_body[\"error\"], \"kernel_task_complete_rejected\");\n\n let task_after = api.handle(\n ApiRequest::new(\"GET\", \"/tasks/task-complete-needs-verifier\")\n .header(\"authorization\", \"Bearer developer\"),\n );\n assert_eq!(task_after.status, 200);\n let task_after_body: Value = serde_json::from_slice(&task_after.body)?;\n assert_eq!(task_after_body[\"status\"], \"leased\");\n Ok(())\n}","source_test_id":"cp-mwl::task_completion_rejects_medium_risk_without_verifier_evidence","task":"rust_integration_test_generation"}39{"id":"cp-mwl::subscription_contract_requires_registered_adapter_contract::generate_test","input":"Crate: cp-mwl\nSource path: crates/cp-mwl/src/tests.rs\nDomains: auth, workflow, event, agent\nRoutes: POST /subscription-contracts, POST /subscription-contracts\nExpected statuses: 201, 409\nExpected error codes: participant_adapter_contract_mismatch\nRoles/tokens observed: developer","instruction":"Write a Rust integration test for Context Primitive that verifies: subscription contract requires registered adapter contract.","output":"\n#[test]\nfn subscription_contract_requires_registered_adapter_contract()\n-> Result<(), Box<dyn std::error::Error>> {\n let api = router()?;\n let created = api.handle(\n ApiRequest::new(\"POST\", \"/subscription-contracts\")\n .header(\"authorization\", \"Bearer developer\")\n .json(&json!({\n \"agent_id\": \"agent-a\",\n \"allowed_event_types\": [\"workflow.started\"],\n \"subject_filters\": [\"api.events\"],\n \"context_visibility\": \"workflow_run\",\n \"reason\": \"test visibility\"\n }))?,\n );\n assert_eq!(created.status, 201);\n let parsed: Value = serde_json::from_slice(&created.body)?;\n assert_eq!(\n parsed[\"contract\"][\"adapter_contract_hash\"].as_str(),\n Some(\"sha256:agentacontract00000000000000000000000000000000000000000000000000000000\")\n );\n\n let mismatch = api.handle(\n ApiRequest::new(\"POST\", \"/subscription-contracts\")\n .header(\"authorization\", \"Bearer developer\")\n .json(&json!({\n \"contract_id\": \"sub-adapter-mismatch\",\n \"agent_id\": \"agent-a\",\n \"allowed_event_types\": [\"workflow.started\"],\n \"subject_filters\": [\"api.events\"],\n \"adapter_contract_hash\": \"sha256:wrongcontract00000000000000000000000000000000000000000000000000000000\",\n \"context_visibility\": \"workflow_run\",\n \"reason\": \"test visibility\"\n }))?,\n );\n assert_eq!(mismatch.status, 409);\n let parsed: Value = serde_json::from_slice(&mismatch.body)?;\n assert_eq!(parsed[\"error\"], \"participant_adapter_contract_mismatch\");\n Ok(())\n}","source_test_id":"cp-mwl::subscription_contract_requires_registered_adapter_contract","task":"rust_integration_test_generation"}40{"id":"cp-mwl::agents_create_and_list_returns_real_data::generate_test","input":"Crate: cp-mwl\nSource path: crates/cp-mwl/src/tests.rs\nDomains: auth, agent\nRoutes: POST /agents, GET /agents\nExpected statuses: 201\nExpected error codes: no named error code\nRoles/tokens observed: developer","instruction":"Write a Rust integration test for Context Primitive that verifies: agents create and list returns real data.","output":"\n#[test]\nfn agents_create_and_list_returns_real_data() -> Result<(), Box<dyn std::error::Error>> {\n let api = router()?;\n let agent = json!({\n \"agent_id\": \"agent-a\",\n \"display_name\": \"Agent A\",\n \"enabled\": true,\n \"org_id\": \"org-local\"\n });\n let create = api.handle(\n ApiRequest::new(\"POST\", \"/agents\")\n .header(\"authorization\", \"Bearer developer\")\n .json(&agent)?,\n );\n assert_eq!(create.status, 201);\n let list =\n api.handle(ApiRequest::new(\"GET\", \"/agents\").header(\"authorization\", \"Bearer developer\"));\n let parsed: Value = serde_json::from_slice(&list.body)?;\n assert_eq!(parsed[0][\"agent_id\"], AgentId::new(\"agent-a\")?.as_str());\n Ok(())\n}","source_test_id":"cp-mwl::agents_create_and_list_returns_real_data","task":"rust_integration_test_generation"}41{"id":"cp-mwl::list_does_not_return_secrets::generate_test","input":"Crate: cp-mwl\nSource path: crates/cp-mwl/src/tests.rs\nDomains: auth, credential\nRoutes: GET /credentials\nExpected statuses: 200\nExpected error codes: no named error code\nRoles/tokens observed: admin","instruction":"Write a Rust integration test for Context Primitive that verifies: list does not return secrets.","output":"\n#[test]\nfn list_does_not_return_secrets() -> Result<(), Box<dyn std::error::Error>> {\n let api = router()?;\n let response =\n api.handle(ApiRequest::new(\"GET\", \"/credentials\").header(\"authorization\", \"Bearer admin\"));\n\n assert_eq!(response.status, 200);\n let body = String::from_utf8(response.body)?;\n assert!(body.contains(\"credential-a\"));\n assert!(!body.contains(\"secret-value\"));\n assert!(!body.contains(\"secret\"));\n Ok(())\n}","source_test_id":"cp-mwl::list_does_not_return_secrets","task":"rust_integration_test_generation"}42{"id":"cp-net::acl_allow_passes_permitted_frame::generate_test","input":"Crate: cp-net\nSource path: crates/cp-net/src/acl.rs\nDomains: task, event\nRoutes: no HTTP route\nExpected statuses: no explicit HTTP status\nExpected error codes: no named error code\nRoles/tokens observed: none","instruction":"Write a Rust integration test for Context Primitive that verifies: acl allow passes permitted frame.","output":"\n #[test]\n fn acl_allow_passes_permitted_frame() -> Result<(), Box<dyn std::error::Error>> {\n let acl = policy(AclAction::Allow)?;\n assert_eq!(\n acl.evaluate(\n &NodeId::new(\"node-a\")?,\n &NodeId::new(\"node-b\")?,\n Some(&EventType::new(\"task.created\")?)\n ),\n AclAction::Allow\n );\n Ok(())\n }","source_test_id":"cp-net::acl_allow_passes_permitted_frame","task":"rust_integration_test_generation"}43{"id":"cp-net::coordinator_discovery_forwards_advertisements::generate_test","input":"Crate: cp-net\nSource path: crates/cp-net/src/discovery/mod.rs\nDomains: general\nRoutes: no HTTP route\nExpected statuses: no explicit HTTP status\nExpected error codes: no named error code\nRoles/tokens observed: none","instruction":"Write a Rust integration test for Context Primitive that verifies: coordinator discovery forwards advertisements.","output":"\n #[tokio::test]\n async fn coordinator_discovery_forwards_advertisements()\n -> Result<(), Box<dyn std::error::Error>> {\n let directory = directory(\"coordinator\", \"node-b\", false)?;\n let store = CoordinatorAdvertisementStore::new();\n store.upsert(CoordinatorAdvertisement::new(\n NodeId::new(\"node-b\")?,\n vec![endpoint()?],\n \"signed-by-node-b\",\n )?)?;\n\n let discovery = CoordinatorDiscovery::new(store, &directory, 1);\n let peers = discovery.discover(CancellationToken::new()).await?;\n\n assert_eq!(peers.len(), 1);\n assert_eq!(peers[0].node_id, NodeId::new(\"node-b\")?);\n assert_eq!(peers[0].source, DiscoverySource::Coordinator);\n Ok(())\n }","source_test_id":"cp-net::coordinator_discovery_forwards_advertisements","task":"rust_integration_test_generation"}44{"id":"cp-net::unadmitted_source_is_silently_dropped::generate_test","input":"Crate: cp-net\nSource path: crates/cp-net/src/dispatch.rs\nDomains: general\nRoutes: no HTTP route\nExpected statuses: no explicit HTTP status\nExpected error codes: no named error code\nRoles/tokens observed: none","instruction":"Write a Rust integration test for Context Primitive that verifies: unadmitted source is silently dropped.","output":"\n #[tokio::test]\n async fn unadmitted_source_is_silently_dropped() -> Result<(), Box<dyn std::error::Error>> {\n let (tx, mut rx) = mpsc::channel(8);\n let admitted = Arc::new(RwLock::new(BTreeSet::new())); // empty \u2014 nobody admitted\n let dispatcher = FrameDispatcher::new(local_id()?, admitted, tx);\n\n let packet = make_wire_packet(&peer_id()?, &local_id()?)?;\n dispatcher.dispatch(peer_addr()?, &packet).await?;\n\n assert!(\n rx.try_recv().is_err(),\n \"unadmitted source must be silently dropped\"\n );\n Ok(())\n }","source_test_id":"cp-net::unadmitted_source_is_silently_dropped","task":"rust_integration_test_generation"}45{"id":"cp-net::acl_allow_passes_permitted_frame::generate_test","input":"Crate: cp-net\nSource path: crates/cp-net/src/dispatch.rs\nDomains: task, event, transport\nRoutes: no HTTP route\nExpected statuses: no explicit HTTP status\nExpected error codes: no named error code\nRoles/tokens observed: none","instruction":"Write a Rust integration test for Context Primitive that verifies: acl allow passes permitted frame.","output":"\n #[tokio::test]\n async fn acl_allow_passes_permitted_frame() -> Result<(), Box<dyn std::error::Error>> {\n let (tx, mut rx) = mpsc::channel(8);\n let (denied_tx, mut denied_rx) = mpsc::channel(8);\n let admitted = Arc::new(RwLock::new(BTreeSet::from([peer_id()?])));\n let dispatcher = FrameDispatcher::new(local_id()?, admitted, tx).with_acl(\n Arc::new(AclPolicy {\n rules: vec![TransportAcl {\n rule_id: \"allow-task\".to_owned(),\n from_node_pattern: NodePattern::Exact(peer_id()?),\n to_node_pattern: NodePattern::Exact(local_id()?),\n allowed_event_type_patterns: vec![\"task.*\".to_owned()],\n action: AclAction::Allow,\n }],\n default_action: AclAction::Deny,\n }),\n denied_tx,\n );\n\n let packet = make_wire_packet(&peer_id()?, &local_id()?)?;\n dispatcher.dispatch(peer_addr()?, &packet).await?;\n\n assert!(rx.try_recv().is_ok());\n assert!(denied_rx.try_recv().is_err());\n Ok(())\n }","source_test_id":"cp-net::acl_allow_passes_permitted_frame","task":"rust_integration_test_generation"}46{"id":"cp-net::handshake_rejects_unknown_initiator::generate_test","input":"Crate: cp-net\nSource path: crates/cp-net/src/handshake_exchange.rs\nDomains: transport\nRoutes: no HTTP route\nExpected statuses: no explicit HTTP status\nExpected error codes: no named error code\nRoles/tokens observed: none","instruction":"Write a Rust integration test for Context Primitive that verifies: handshake rejects unknown initiator.","output":"\n #[tokio::test]\n async fn handshake_rejects_unknown_initiator() -> Result<(), Box<dyn std::error::Error>> {\n let key_b = key_b()?;\n let dir_b = TransportPeerDirectory::open(temp_dir(\"unknown-b\")?, NodeId::new(\"node-b\")?)?;\n let socket_a = UdpListener::bind(&NetConfig::new(\"127.0.0.1:0\".parse()?)).await?;\n let socket_b = UdpListener::bind(&NetConfig::new(\"127.0.0.1:0\".parse()?)).await?;\n let addr_b = socket_b.local_addr()?;\n let raw = encode_init(&UdpHandshakeInitFrame {\n local_node_id: NodeId::new(\"node-a\")?,\n peer_node_id: NodeId::new(\"node-b\")?,\n local_key_id: TransportKeyId::new(\"mesh-key-1\")?,\n local_nonce: [1; 32],\n })?;\n\n socket_a.send_frame(addr_b, &raw).await?;\n let mut buf = Vec::new();\n let (peer_addr, received) = socket_b.receive_frame(&mut buf).await?;\n let exchange = UdpHandshakeExchange::new();\n assert!(matches!(\n exchange\n .accept(\n &socket_b,\n &received,\n peer_addr,\n UdpHandshakeAcceptRequest {\n directory: &dir_b,\n local_transport_key_id: TransportKeyId::new(\"mesh-key-1\")?,\n local_key_pair: &key_b,\n now_ms: 1,\n allow_relay: true,\n allow_loopback: true,\n },\n )\n .await,\n Err(UdpHandshakeError::Directory(_))\n ));\n let mut no_response_buf = Vec::new();\n let no_response = timeout(\n Duration::from_millis(50),\n socket_a.receive_frame(&mut no_response_buf),\n )\n .await;\n assert!(no_response.is_err());\n Ok(())\n }","source_test_id":"cp-net::handshake_rejects_unknown_initiator","task":"rust_integration_test_generation"}47{"id":"cp-net::handshake_rejects_replayed_nonce::generate_test","input":"Crate: cp-net\nSource path: crates/cp-net/src/handshake_exchange.rs\nDomains: transport\nRoutes: no HTTP route\nExpected statuses: no explicit HTTP status\nExpected error codes: no named error code\nRoles/tokens observed: none","instruction":"Write a Rust integration test for Context Primitive that verifies: handshake rejects replayed nonce.","output":"\n #[tokio::test]\n async fn handshake_rejects_replayed_nonce() -> Result<(), Box<dyn std::error::Error>> {\n let key_a = key_a()?;\n let key_b = key_b()?;\n let mut dir_a =\n TransportPeerDirectory::open(temp_dir(\"replay-a\")?, NodeId::new(\"node-a\")?)?;\n let mut dir_b =\n TransportPeerDirectory::open(temp_dir(\"replay-b\")?, NodeId::new(\"node-b\")?)?;\n enroll_pair(&mut dir_a, &mut dir_b, &key_a, &key_b)?;\n let socket_a = UdpListener::bind(&NetConfig::new(\"127.0.0.1:0\".parse()?)).await?;\n let socket_b = UdpListener::bind(&NetConfig::new(\"127.0.0.1:0\".parse()?)).await?;\n let raw = encode_init(&UdpHandshakeInitFrame {\n local_node_id: NodeId::new(\"node-a\")?,\n peer_node_id: NodeId::new(\"node-b\")?,\n local_key_id: TransportKeyId::new(\"mesh-key-1\")?,\n local_nonce: [7; 32],\n })?;\n let exchange = UdpHandshakeExchange::new();\n let peer_addr = socket_a.local_addr()?;\n exchange\n .accept(\n &socket_b,\n &raw,\n peer_addr,\n UdpHandshakeAcceptRequest {\n directory: &dir_b,\n local_transport_key_id: TransportKeyId::new(\"mesh-key-1\")?,\n local_key_pair: &key_b,\n now_ms: 1,\n allow_relay: true,\n allow_loopback: true,\n },\n )\n .await?;\n assert!(matches!(\n exchange\n .accept(\n &socket_b,\n &raw,\n peer_addr,\n UdpHandshakeAcceptRequest {\n directory: &dir_b,\n local_transport_key_id: TransportKeyId::new(\"mesh-key-1\")?,\n local_key_pair: &key_b,\n now_ms: 1,\n allow_relay: true,\n allow_loopback: true,\n },\n )\n .await,\n Err(UdpHandshakeError::Replay)\n ));\n drop(dir_a);\n Ok(())\n }","source_test_id":"cp-net::handshake_rejects_replayed_nonce","task":"rust_integration_test_generation"}48{"id":"cp-net::net_listener_starts_and_cancels_cleanly::generate_test","input":"Crate: cp-net\nSource path: crates/cp-net/src/listener.rs\nDomains: general\nRoutes: no HTTP route\nExpected statuses: no explicit HTTP status\nExpected error codes: no named error code\nRoles/tokens observed: none","instruction":"Write a Rust integration test for Context Primitive that verifies: net listener starts and cancels cleanly.","output":"\n #[tokio::test]\n async fn net_listener_starts_and_cancels_cleanly() -> Result<(), Box<dyn std::error::Error>> {\n let config = NetConfig::new(\"127.0.0.1:0\".parse()?);\n let (tx, _rx) = mpsc::channel(8);\n let admitted = Arc::new(RwLock::new(BTreeSet::new()));\n let dispatcher = FrameDispatcher::new(NodeId::new(\"node-local\")?, admitted, tx);\n let listener = NetListener::bind(&config, dispatcher).await?;\n let bound = listener.local_addr()?;\n assert_eq!(bound.ip().to_string(), \"127.0.0.1\");\n\n let token = CancellationToken::new();\n token.cancel();\n listener.run_until_cancelled(token).await?;\n Ok(())\n }","source_test_id":"cp-net::net_listener_starts_and_cancels_cleanly","task":"rust_integration_test_generation"}49{"id":"cp-net::hole_punch_orchestrator_succeeds_in_loopback_scenario::generate_test","input":"Crate: cp-net\nSource path: crates/cp-net/src/nat/hole_punch.rs\nDomains: general\nRoutes: no HTTP route\nExpected statuses: no explicit HTTP status\nExpected error codes: no named error code\nRoles/tokens observed: none","instruction":"Write a Rust integration test for Context Primitive that verifies: hole punch orchestrator succeeds in loopback scenario.","output":"\n #[tokio::test]\n async fn hole_punch_orchestrator_succeeds_in_loopback_scenario()\n -> Result<(), Box<dyn std::error::Error>> {\n let socket_a = UdpSocket::bind(\"127.0.0.1:0\").await?;\n let socket_b = UdpSocket::bind(\"127.0.0.1:0\").await?;\n let node_a = NodeId::new(\"node-a\")?;\n let node_b = NodeId::new(\"node-b\")?;\n let store = RendezvousStore::default();\n let orchestrator_a = HolePunchOrchestrator::new(store.clone());\n let orchestrator_b = HolePunchOrchestrator::new(store.clone());\n store\n .publish(\n node_a.clone(),\n WanEndpoint {\n addr: socket_a.local_addr()?,\n },\n )\n .await;\n store\n .publish(\n node_b.clone(),\n WanEndpoint {\n addr: socket_b.local_addr()?,\n },\n )\n .await;\n\n let (left, right) = tokio::join!(\n orchestrator_a.punch(\n &socket_a,\n node_a.clone(),\n &node_b,\n WanEndpoint {\n addr: socket_a.local_addr()?\n }\n ),\n orchestrator_b.punch(\n &socket_b,\n node_b.clone(),\n &node_a,\n WanEndpoint {\n addr: socket_b.local_addr()?\n }\n )\n );\n\n assert_eq!(left?.peer_addr, socket_b.local_addr()?);\n assert_eq!(right?.peer_addr, socket_a.local_addr()?);\n Ok(())\n }","source_test_id":"cp-net::hole_punch_orchestrator_succeeds_in_loopback_scenario","task":"rust_integration_test_generation"}50{"id":"cp-net::direct_preferred_over_relay::generate_test","input":"Crate: cp-net\nSource path: crates/cp-net/src/nat/mod.rs\nDomains: general\nRoutes: no HTTP route\nExpected statuses: no explicit HTTP status\nExpected error codes: no named error code\nRoles/tokens observed: none","instruction":"Write a Rust integration test for Context Primitive that verifies: direct preferred over relay.","output":"\n #[test]\n fn direct_preferred_over_relay() -> Result<(), Box<dyn std::error::Error>> {\n let candidates = vec![\n EndpointCandidate::new(EndpointKind::Relay, \"relay://127.0.0.1:7500/node-b\", 0)?,\n EndpointCandidate::new(EndpointKind::Lan, \"udp://10.0.0.8:7400\", 1)?,\n ];\n let planner = ConnectionPlanner::new(ConnectionPlanPolicy {\n relay_enabled: true,\n allow_relay: true,\n hole_punch_enabled: true,\n });\n\n let selected = planner.select_route(&candidates)?;\n\n assert_eq!(selected.kind, ConnectionRouteKind::DirectLan);\n assert_eq!(selected.endpoint.value, \"udp://10.0.0.8:7400\");\n Ok(())\n }","source_test_id":"cp-net::direct_preferred_over_relay","task":"rust_integration_test_generation"}51{"id":"cp-net::socket_binds_to_loopback_port::generate_test","input":"Crate: cp-net\nSource path: crates/cp-net/src/socket.rs\nDomains: general\nRoutes: no HTTP route\nExpected statuses: no explicit HTTP status\nExpected error codes: no named error code\nRoles/tokens observed: none","instruction":"Write a Rust integration test for Context Primitive that verifies: socket binds to loopback port.","output":"\n #[tokio::test]\n async fn socket_binds_to_loopback_port() -> Result<(), Box<dyn std::error::Error>> {\n let config = NetConfig::new(\"127.0.0.1:0\".parse()?);\n let listener = UdpListener::bind(&config).await?;\n let bound = listener.local_addr()?;\n\n assert_eq!(bound.ip().to_string(), \"127.0.0.1\");\n assert_ne!(bound.port(), 0);\n Ok(())\n }","source_test_id":"cp-net::socket_binds_to_loopback_port","task":"rust_integration_test_generation"}52{"id":"cp-participant-sdk::participant_manifest_validates_clean_input::generate_test","input":"Crate: cp-participant-sdk\nSource path: crates/cp-participant-sdk/src/lib.rs\nDomains: general\nRoutes: no HTTP route\nExpected statuses: no explicit HTTP status\nExpected error codes: no named error code\nRoles/tokens observed: none","instruction":"Write a Rust integration test for Context Primitive that verifies: participant manifest validates clean input.","output":"\n #[test]\n fn participant_manifest_validates_clean_input() -> Result<()> {\n manifest()?.validate()\n }","source_test_id":"cp-participant-sdk::participant_manifest_validates_clean_input","task":"rust_integration_test_generation"}53{"id":"cp-participant-sdk::publish_outside_scope_is_rejected::generate_test","input":"Crate: cp-participant-sdk\nSource path: crates/cp-participant-sdk/src/lib.rs\nDomains: auth, event\nRoutes: no HTTP route\nExpected statuses: no explicit HTTP status\nExpected error codes: no named error code\nRoles/tokens observed: none","instruction":"Write a Rust integration test for Context Primitive that verifies: publish outside scope is rejected.","output":"\n #[test]\n fn publish_outside_scope_is_rejected() -> Result<()> {\n let policy = CompiledParticipantPolicy::compile(&manifest()?)?;\n let check = policy_check(\"tool.deleted\", \"tool\", None)?;\n let denial = policy\n .check_publish(&check)\n .err()\n .ok_or_else(|| ParticipantSdkError::Unauthorized(\"publish should deny\".to_owned()))?;\n assert_eq!(denial.reason, \"publish outside compiled policy\");\n let (node, _, _) = ids()?;\n let mut bus = temp_bus(\"policy-denial\")?;\n policy.record_denial(&mut bus, &node, PolicyDirection::Publish, &check, &denial)?;\n assert!(\n bus.records()\n .iter()\n .any(|record| record.body.event_type == \"authority.decision\"\n && record.body.payload[\"allowed\"] == false)\n );\n Ok(())\n }","source_test_id":"cp-participant-sdk::publish_outside_scope_is_rejected","task":"rust_integration_test_generation"}54{"id":"cp-participant-sdk::verified_completion_denies_missing_verifier_and_records_denial::generate_test","input":"Crate: cp-participant-sdk\nSource path: crates/cp-participant-sdk/src/lib.rs\nDomains: auth, task, event, agent\nRoutes: no HTTP route\nExpected statuses: no explicit HTTP status\nExpected error codes: no named error code\nRoles/tokens observed: none","instruction":"Write a Rust integration test for Context Primitive that verifies: verified completion denies missing verifier and records denial.","output":"\n #[test]\n fn verified_completion_denies_missing_verifier_and_records_denial() -> Result<()> {\n let (node, org, workspace) = ids()?;\n let mut bus = temp_bus(\"completion-denied\")?;\n let mut agent_manifest = manifest()?;\n agent_manifest.participant_kind = ParticipantKind::Agent;\n ParticipantRegistration::register(&agent_manifest, &mut bus, &node, &org, &workspace)?;\n\n let mut ledger = TaskLedger::new();\n let task_id = TaskId::new(\"task-a\")?;\n ledger.create(TaskCreateRequest::new(\n task_id.clone(),\n AgentId::new(\"creator\")?,\n [\"tool\"],\n [\"docs\"],\n ModelTier::Tier3B,\n 1,\n )?)?;\n let lease = request_task_lease(\n &TaskLeaseRequest {\n task_id: task_id.clone(),\n worker_id: ProfileId::new(\"worker-a\")?,\n node_id: node.clone(),\n lease_ttl_ms: 30_000,\n },\n &mut ledger,\n &mut bus,\n &node,\n )?;\n let lease_created_at = ledger\n .record(&task_id)\n .and_then(|task| task.lease.as_ref())\n .map(|lease| lease.created_at_unix_ms)\n .ok_or_else(|| ParticipantSdkError::Unauthorized(\"missing task lease\".to_owned()))?;\n\n let result = complete_verified_task(\n &TaskCompletionRequest {\n task_id: task_id.clone(),\n worker_id: ProfileId::new(\"worker-a\")?,\n lease_token: lease.token,\n evidence: TaskCompletionEvidence {\n risk_class: TaskRiskClass::Medium,\n verification_outcome: VerificationOutcome::Passed,\n verifier_agent_id: None,\n },\n completed_at_unix_ms: lease_created_at + 1,\n },\n &mut ledger,\n &mut bus,\n &node,\n );\n\n assert!(matches!(result, Err(ParticipantSdkError::Task(_))));\n assert_eq!(\n ledger\n .record(&task_id)\n .ok_or_else(|| ParticipantSdkError::Unauthorized(\"missing task\".to_owned()))?\n .status,\n TaskStatus::Claimed\n );\n assert!(\n bus.records()\n .iter()\n .any(|record| record.body.event_type == \"participant.task_completion.denied\")\n );\n assert!(\n !bus.records()\n .iter()\n .any(|record| record.body.event_type == \"participant.task_completion.accepted\")\n );\n Ok(())\n }","source_test_id":"cp-participant-sdk::verified_completion_denies_missing_verifier_and_records_denial","task":"rust_integration_test_generation"}55{"id":"cp-participant-sdk::plugin_node_invocation_request_dispatched_via_task_lease::generate_test","input":"Crate: cp-participant-sdk\nSource path: crates/cp-participant-sdk/src/lib.rs\nDomains: task, plugin, event\nRoutes: no HTTP route\nExpected statuses: no explicit HTTP status\nExpected error codes: no named error code\nRoles/tokens observed: none","instruction":"Write a Rust integration test for Context Primitive that verifies: plugin node invocation request dispatched via task lease.","output":"\n #[test]\n fn plugin_node_invocation_request_dispatched_via_task_lease() -> Result<()> {\n let (node, org, workspace) = ids()?;\n let mut bus = temp_bus(\"dispatch\")?;\n let request = invocation_request(org, workspace)?;\n dispatch_via_task_lease(&request, &mut bus, &node)?;\n assert!(\n bus.records()\n .iter()\n .any(|r| r.body.event_type == \"plugin_node.invocation.dispatched\")\n );\n Ok(())\n }","source_test_id":"cp-participant-sdk::plugin_node_invocation_request_dispatched_via_task_lease","task":"rust_integration_test_generation"}56{"id":"cp-participant-sdk::task_state_subscription_closes_focus_after_completion::generate_test","input":"Crate: cp-participant-sdk\nSource path: crates/cp-participant-sdk/src/subscription.rs\nDomains: auth, task, event\nRoutes: no HTTP route\nExpected statuses: no explicit HTTP status\nExpected error codes: no named error code\nRoles/tokens observed: none","instruction":"Write a Rust integration test for Context Primitive that verifies: task state subscription closes focus after completion.","output":"\n #[test]\n fn task_state_subscription_closes_focus_after_completion() -> Result<()> {\n let subscription = EventSubscription::for_task_state(\n [EventType::new(\"task.assigned\")?],\n Some(TaskStatus::Completed),\n true,\n Some(\"task.task-a\"),\n )?;\n\n assert_eq!(subscription.tier(), &SubscriptionTier::BroadAwareness);\n assert!(!subscription.has_authorized_scope());\n Ok(())\n }","source_test_id":"cp-participant-sdk::task_state_subscription_closes_focus_after_completion","task":"rust_integration_test_generation"}57{"id":"cp-participant-sdk::poll_context_drops_blocked_records::generate_test","input":"Crate: cp-participant-sdk\nSource path: crates/cp-participant-sdk/src/subscription.rs\nDomains: auth, task, event\nRoutes: no HTTP route\nExpected statuses: no explicit HTTP status\nExpected error codes: no named error code\nRoles/tokens observed: none","instruction":"Write a Rust integration test for Context Primitive that verifies: poll context drops blocked records.","output":"\n #[test]\n fn poll_context_drops_blocked_records() -> Result<()> {\n let mut bus = temp_bus(\"blocked\")?;\n append_event(\n &mut bus,\n \"secret.unrelated\",\n \"unrelated.subject\",\n json!({\"secret\": \"blocked\"}),\n )?;\n let mut subscription =\n EventSubscription::focused([EventType::new(\"secret.unrelated\")?], \"task.task-a\")?;\n\n let aperture = aperture().map_err(|error| {\n ParticipantSdkError::Unauthorized(format!(\"invalid aperture: {error}\"))\n })?;\n let records = subscription.poll_context(&bus, &aperture, 10);\n\n assert!(records.is_empty());\n Ok(())\n }","source_test_id":"cp-participant-sdk::poll_context_drops_blocked_records","task":"rust_integration_test_generation"}58{"id":"cp-services::rejects_secret_metadata::generate_test","input":"Crate: cp-services\nSource path: crates/cp-services/src/apothecary.rs\nDomains: general\nRoutes: no HTTP route\nExpected statuses: no explicit HTTP status\nExpected error codes: no named error code\nRoles/tokens observed: none","instruction":"Write a Rust integration test for Context Primitive that verifies: rejects secret metadata.","output":"\n #[test]\n fn rejects_secret_metadata() -> Result<(), Box<dyn std::error::Error>> {\n let mut registry = Apothecary::new();\n let mut input = provider_input()?;\n input.metadata = json!({\"api_key\": \"do-not-store\"});\n\n assert_eq!(\n registry.register_provider(input),\n Err(ApothecaryError::SecretMaterialRejected)\n );\n Ok(())\n }","source_test_id":"cp-services::rejects_secret_metadata","task":"rust_integration_test_generation"}59{"id":"cp-services::quarantine_excludes_model_from_selection::generate_test","input":"Crate: cp-services\nSource path: crates/cp-services/src/apothecary.rs\nDomains: general\nRoutes: no HTTP route\nExpected statuses: no explicit HTTP status\nExpected error codes: no named error code\nRoles/tokens observed: none","instruction":"Write a Rust integration test for Context Primitive that verifies: quarantine excludes model from selection.","output":"\n #[test]\n fn quarantine_excludes_model_from_selection() -> Result<(), Box<dyn std::error::Error>> {\n let mut registry = Apothecary::new();\n registry.register_provider(provider_input()?)?;\n registry.register_model(model_input()?)?;\n registry.quarantine_model(&ModelId::new(\"model-7b\")?, \"bad eval\", 1_002)?;\n\n assert!(registry.select_models(&selection_request()?)?.is_empty());\n Ok(())\n }","source_test_id":"cp-services::quarantine_excludes_model_from_selection","task":"rust_integration_test_generation"}60{"id":"cp-services::generates_hash_bound_narrative::generate_test","input":"Crate: cp-services\nSource path: crates/cp-services/src/chronicle.rs\nDomains: event\nRoutes: no HTTP route\nExpected statuses: no explicit HTTP status\nExpected error codes: no named error code\nRoles/tokens observed: none","instruction":"Write a Rust integration test for Context Primitive that verifies: generates hash bound narrative.","output":"\n #[test]\n fn generates_hash_bound_narrative() -> Result<(), Box<dyn std::error::Error>> {\n let mut chronicle = Chronicle::new();\n let record = chronicle.generate(input()?)?;\n\n assert!(record.narrative_hash.starts_with(\"sha256:\"));\n assert_eq!(record.sources[0].source_id, \"event-a\");\n assert_eq!(record.source_event_count, 2);\n Ok(())\n }","source_test_id":"cp-services::generates_hash_bound_narrative","task":"rust_integration_test_generation"}61{"id":"cp-services::workflow_rejects_cycles::generate_test","input":"Crate: cp-services\nSource path: crates/cp-services/src/loom.rs\nDomains: workflow\nRoutes: no HTTP route\nExpected statuses: no explicit HTTP status\nExpected error codes: no named error code\nRoles/tokens observed: none","instruction":"Write a Rust integration test for Context Primitive that verifies: workflow rejects cycles.","output":"\n #[test]\n fn workflow_rejects_cycles() -> Result<(), Box<dyn std::error::Error>> {\n let workflow = WorkflowDefinition::new(\n WorkflowId::new(\"workflow-a\")?,\n \"v1\",\n [\n node(\"a\", WorkflowNodeKind::Trigger)?,\n node(\"b\", WorkflowNodeKind::Action)?,\n ],\n [WorkflowEdge::new(\"a\", \"b\")?, WorkflowEdge::new(\"b\", \"a\")?],\n UserId::new(\"operator\")?,\n 1_000,\n );\n\n assert_eq!(workflow, Err(LoomError::CycleDetected));\n Ok(())\n }","source_test_id":"cp-services::workflow_rejects_cycles","task":"rust_integration_test_generation"}62{"id":"cp-skin::adapter_limit_is_enforced::generate_test","input":"Crate: cp-skin\nSource path: crates/cp-skin/src/registry.rs\nDomains: general\nRoutes: no HTTP route\nExpected statuses: no explicit HTTP status\nExpected error codes: no named error code\nRoles/tokens observed: none","instruction":"Write a Rust integration test for Context Primitive that verifies: adapter limit is enforced.","output":"\n #[test]\n fn adapter_limit_is_enforced() -> Result<(), Box<dyn std::error::Error>> {\n let mut registry = AdapterRegistry::new(SkinLimits {\n max_body_bytes: 100,\n max_adapters: 1,\n max_routing_rules: 1,\n })?;\n registry.register_adapter(config(\"a\")?)?;\n\n let result = registry.register_adapter(config(\"b\")?);\n\n assert_eq!(result, Err(AdapterRegistryError::AdapterLimitExceeded));\n Ok(())\n }","source_test_id":"cp-skin::adapter_limit_is_enforced","task":"rust_integration_test_generation"}63{"id":"cp-transport::admission_book_accepts_valid_peer::generate_test","input":"Crate: cp-transport\nSource path: crates/cp-transport/src/admission.rs\nDomains: transport\nRoutes: no HTTP route\nExpected statuses: no explicit HTTP status\nExpected error codes: no named error code\nRoles/tokens observed: none","instruction":"Write a Rust integration test for Context Primitive that verifies: admission book accepts valid peer.","output":"\n #[test]\n fn admission_book_accepts_valid_peer() -> Result<(), Box<dyn std::error::Error>> {\n let mut book = TransportAdmissionBook::new();\n book.upsert(admission()?);\n\n let decision = book.admit(\n &NodeId::new(\"node-b\")?,\n &TransportKeyId::new(\"mesh-key-1\")?,\n 200,\n )?;\n\n assert_eq!(decision.node_id, NodeId::new(\"node-b\")?);\n assert_eq!(decision.endpoint_hint, \"udp://10.0.0.2:7400\");\n Ok(())\n }","source_test_id":"cp-transport::admission_book_accepts_valid_peer","task":"rust_integration_test_generation"}64{"id":"cp-transport::admission_book_rejects_expired_peer::generate_test","input":"Crate: cp-transport\nSource path: crates/cp-transport/src/admission.rs\nDomains: transport\nRoutes: no HTTP route\nExpected statuses: no explicit HTTP status\nExpected error codes: no named error code\nRoles/tokens observed: none","instruction":"Write a Rust integration test for Context Primitive that verifies: admission book rejects expired peer.","output":"\n #[test]\n fn admission_book_rejects_expired_peer() -> Result<(), Box<dyn std::error::Error>> {\n let mut book = TransportAdmissionBook::new();\n book.upsert(admission()?);\n\n assert!(matches!(\n book.admit(\n &NodeId::new(\"node-b\")?,\n &TransportKeyId::new(\"mesh-key-1\")?,\n 500\n ),\n Err(AdmissionError::Expired { .. })\n ));\n Ok(())\n }","source_test_id":"cp-transport::admission_book_rejects_expired_peer","task":"rust_integration_test_generation"}65{"id":"cp-transport::admission_store_rejects_local_node_mismatch::generate_test","input":"Crate: cp-transport\nSource path: crates/cp-transport/src/admission_store.rs\nDomains: transport\nRoutes: no HTTP route\nExpected statuses: no explicit HTTP status\nExpected error codes: no named error code\nRoles/tokens observed: none","instruction":"Write a Rust integration test for Context Primitive that verifies: admission store rejects local node mismatch.","output":"\n #[test]\n fn admission_store_rejects_local_node_mismatch() -> Result<(), Box<dyn std::error::Error>> {\n let root = temp_dir(\"mismatch\");\n let _store = TransportAdmissionStore::open(&root, NodeId::new(\"node-a\")?)?;\n\n let err = TransportAdmissionStore::open(&root, NodeId::new(\"node-b\")?)\n .err()\n .ok_or(\"local node mismatch should fail\")?;\n assert!(matches!(\n err,\n TransportAdmissionStoreError::LocalNodeMismatch { .. }\n ));\n\n fs::remove_dir_all(root)?;\n Ok(())\n }","source_test_id":"cp-transport::admission_store_rejects_local_node_mismatch","task":"rust_integration_test_generation"}66{"id":"cp-transport::negotiated_link_journals_batch_lifecycle::generate_test","input":"Crate: cp-transport\nSource path: crates/cp-transport/src/directory.rs\nDomains: transport\nRoutes: no HTTP route\nExpected statuses: no explicit HTTP status\nExpected error codes: no named error code\nRoles/tokens observed: none","instruction":"Write a Rust integration test for Context Primitive that verifies: negotiated link journals batch lifecycle.","output":"\n #[test]\n fn negotiated_link_journals_batch_lifecycle() -> Result<(), Box<dyn std::error::Error>> {\n let root_a = temp_dir(\"journaled-batch-a\");\n let root_b = temp_dir(\"journaled-batch-b\");\n let journal_a_path = root_a.join(\"handoff-a.jsonl\");\n let journal_b_path = root_b.join(\"handoff-b.jsonl\");\n let key_a = key_pair_a()?;\n let key_b = key_pair_b()?;\n let mut directory_a = TransportPeerDirectory::open(&root_a, NodeId::new(\"node-a\")?)?;\n let mut directory_b = TransportPeerDirectory::open(&root_b, NodeId::new(\"node-b\")?)?;\n directory_a.enroll_peer(admission_with_key(\"node-b\", &key_b)?)?;\n directory_b.enroll_peer(admission_with_key(\"node-a\", &key_a)?)?;\n let mut link_a = directory_a.open_negotiated_link(session_request(\"node-b\", &key_a)?)?;\n let mut link_b = directory_b.open_negotiated_link(session_request_with_role(\n TransportNegotiationRole::Responder,\n \"node-a\",\n &key_b,\n [2; 32],\n [1; 32],\n )?)?;\n let mut journal_a = TransportPacketHandoffJournal::open(&journal_a_path)?;\n let mut journal_b = TransportPacketHandoffJournal::open(&journal_b_path)?;\n\n link_a.queue_payload(FrameKind::Data, None, b\"journaled-secret\".to_vec())?;\n let peeked = link_a.peek_egress_batch(10)?;\n let journaled_batch = link_a.prepare_journaled_egress_batch(10, &mut journal_a)?;\n\n assert_eq!(journaled_batch.batch, peeked);\n assert_eq!(\n journaled_batch\n .journal_append\n .as_ref()\n .map(|append| append.sequence),\n Some(1)\n );\n assert_eq!(journal_a.records().len(), 1);\n assert_eq!(\n journal_a.records()[0].kind,\n TransportPacketHandoffKind::EgressPrepared\n );\n assert_eq!(link_a.status().outbound_cursor.last_delivered_sequence, 1);\n\n let journaled_receipt =\n link_b.accept_journaled_egress_batch(&journaled_batch.batch, &mut journal_b)?;\n assert_eq!(journal_b.records().len(), 1);\n assert_eq!(\n journal_b.records()[0].kind,\n TransportPacketHandoffKind::IngressAccepted\n );\n let journaled_ack =\n link_a.ack_journaled_egress_receipt(&journaled_receipt.receipt, &mut journal_a)?;\n\n assert!(journaled_ack.acknowledged);\n assert_eq!(journal_a.records().len(), 2);\n assert_eq!(\n journal_a.records()[1].kind,\n TransportPacketHandoffKind::EgressAcknowledged\n );\n assert_eq!(link_a.status().outbound_unacked, 0);\n assert_eq!(journal_a.verify()?.checked_records, 2);\n assert_eq!(journal_b.verify()?.checked_records, 1);\n\n fs::remove_dir_all(root_a)?;\n fs::remove_dir_all(root_b)?;\n Ok(())\n }","source_test_id":"cp-transport::negotiated_link_journals_batch_lifecycle","task":"rust_integration_test_generation"}67{"id":"cp-transport::directory_rejects_registered_peer_without_admission::generate_test","input":"Crate: cp-transport\nSource path: crates/cp-transport/src/directory.rs\nDomains: transport\nRoutes: no HTTP route\nExpected statuses: no explicit HTTP status\nExpected error codes: no named error code\nRoles/tokens observed: none","instruction":"Write a Rust integration test for Context Primitive that verifies: directory rejects registered peer without admission.","output":"\n #[test]\n fn directory_rejects_registered_peer_without_admission()\n -> Result<(), Box<dyn std::error::Error>> {\n let root = temp_dir(\"drift\");\n let mut registry =\n crate::TransportLinkRegistry::open(root.join(REGISTRY_DIR), NodeId::new(\"node-a\")?)?;\n registry.enroll_peer(NodeId::new(\"node-b\")?)?;\n\n let err = TransportPeerDirectory::open(&root, NodeId::new(\"node-a\")?)\n .err()\n .ok_or(\"directory drift should fail\")?;\n assert!(matches!(\n err,\n TransportPeerDirectoryError::MissingAdmissions(_)\n ));\n\n fs::remove_dir_all(root)?;\n Ok(())\n }","source_test_id":"cp-transport::directory_rejects_registered_peer_without_admission","task":"rust_integration_test_generation"}68{"id":"cp-transport::encrypted_loopback_exchanges_wire_packets::generate_test","input":"Crate: cp-transport\nSource path: crates/cp-transport/src/encrypted_loopback.rs\nDomains: task, event, transport\nRoutes: no HTTP route\nExpected statuses: no explicit HTTP status\nExpected error codes: no named error code\nRoles/tokens observed: none","instruction":"Write a Rust integration test for Context Primitive that verifies: encrypted loopback exchanges wire packets.","output":"\n #[test]\n fn encrypted_loopback_exchanges_wire_packets() -> Result<(), Box<dyn std::error::Error>> {\n let (mut a, mut b) = channel_pair()?;\n\n assert_eq!(\n a.send_payload(\n FrameKind::Data,\n Some(EventType::new(\"task.created\")?),\n b\"secret-payload\".to_vec(),\n )?,\n 1\n );\n let packet = a\n .outbound_packets()\n .next()\n .ok_or(\"missing outbound packet\")?\n .to_string();\n\n assert!(!packet.contains(\"secret-payload\"));\n assert_eq!(a.pump_to(&mut b)?, 1);\n let opened = b.recv()?.ok_or(\"missing opened frame\")?;\n\n assert_eq!(opened.payload, b\"secret-payload\");\n assert_eq!(opened.source_node_id, NodeId::new(\"node-a\")?);\n assert_eq!(opened.target_node_id, NodeId::new(\"node-b\")?);\n assert_eq!(a.outbound_len(), 0);\n assert_eq!(b.inbound_len(), 0);\n Ok(())\n }","source_test_id":"cp-transport::encrypted_loopback_exchanges_wire_packets","task":"rust_integration_test_generation"}69{"id":"cp-transport::encrypted_loopback_rejects_wrong_receiver_session::generate_test","input":"Crate: cp-transport\nSource path: crates/cp-transport/src/encrypted_loopback.rs\nDomains: transport\nRoutes: no HTTP route\nExpected statuses: no explicit HTTP status\nExpected error codes: no named error code\nRoles/tokens observed: none","instruction":"Write a Rust integration test for Context Primitive that verifies: encrypted loopback rejects wrong receiver session.","output":"\n #[test]\n fn encrypted_loopback_rejects_wrong_receiver_session() -> Result<(), Box<dyn std::error::Error>>\n {\n let (mut a, mut b) = channel_pair()?;\n a.send_payload(FrameKind::Data, None, b\"payload\".to_vec())?;\n let packet = a\n .outbound_packets()\n .next()\n .ok_or(\"missing outbound packet\")?\n .to_string();\n\n a.queue_inbound_packet(packet.clone())?;\n assert!(matches!(\n a.recv(),\n Err(EncryptedLoopbackError::Session(\n SessionError::UnexpectedSource(_)\n ))\n ));\n b.queue_inbound_packet(packet)?;\n assert!(b.recv()?.is_some());\n Ok(())\n }","source_test_id":"cp-transport::encrypted_loopback_rejects_wrong_receiver_session","task":"rust_integration_test_generation"}70{"id":"cp-transport::handoff_journal_records_rejection_without_packet_summary::generate_test","input":"Crate: cp-transport\nSource path: crates/cp-transport/src/handoff.rs\nDomains: transport\nRoutes: no HTTP route\nExpected statuses: no explicit HTTP status\nExpected error codes: no named error code\nRoles/tokens observed: none","instruction":"Write a Rust integration test for Context Primitive that verifies: handoff journal records rejection without packet summary.","output":"\n #[test]\n fn handoff_journal_records_rejection_without_packet_summary()\n -> Result<(), Box<dyn std::error::Error>> {\n let path = temp_path(\"reject\");\n let mut journal = TransportPacketHandoffJournal::open(&path)?;\n\n journal.append(TransportPacketHandoffInput::rejected(\n NodeId::new(\"node-a\")?,\n NodeId::new(\"node-b\")?,\n \"receipt peer mismatch\",\n )?)?;\n\n assert_eq!(\n journal.records()[0].kind,\n TransportPacketHandoffKind::Rejected\n );\n assert_eq!(\n journal.records()[0].reason.as_deref(),\n Some(\"receipt peer mismatch\")\n );\n\n fs::remove_file(path)?;\n Ok(())\n }","source_test_id":"cp-transport::handoff_journal_records_rejection_without_packet_summary","task":"rust_integration_test_generation"}71{"id":"cp-transport::inbox_rejects_self_peer::generate_test","input":"Crate: cp-transport\nSource path: crates/cp-transport/src/inbox.rs\nDomains: transport\nRoutes: no HTTP route\nExpected statuses: no explicit HTTP status\nExpected error codes: no named error code\nRoles/tokens observed: none","instruction":"Write a Rust integration test for Context Primitive that verifies: inbox rejects self peer.","output":"\n #[test]\n fn inbox_rejects_self_peer() -> Result<(), Box<dyn std::error::Error>> {\n let root = temp_dir(\"self\");\n\n assert!(matches!(\n TransportPeerInbox::open(&root, NodeId::new(\"node-a\")?, NodeId::new(\"node-a\")?),\n Err(TransportPeerInboxError::SelfPeer)\n ));\n\n if root.exists() {\n fs::remove_dir_all(root)?;\n }\n Ok(())\n }","source_test_id":"cp-transport::inbox_rejects_self_peer","task":"rust_integration_test_generation"}72{"id":"cp-transport::two_loopback_endpoints_exchange_frame::generate_test","input":"Crate: cp-transport\nSource path: crates/cp-transport/src/loopback.rs\nDomains: task, event, transport\nRoutes: no HTTP route\nExpected statuses: no explicit HTTP status\nExpected error codes: no named error code\nRoles/tokens observed: none","instruction":"Write a Rust integration test for Context Primitive that verifies: two loopback endpoints exchange frame.","output":"\n #[test]\n fn two_loopback_endpoints_exchange_frame() -> Result<(), Box<dyn std::error::Error>> {\n let a = profile(\"a\")?;\n let b = profile(\"b\")?;\n let policy_a = ConnectionPolicy::local_only(a.node_id.clone());\n let policy_b = ConnectionPolicy::local_only(b.node_id.clone());\n let mut ab = LoopbackTransport::connect(a.clone(), b.clone(), &policy_a)?;\n let mut ba = LoopbackTransport::connect(b.clone(), a.clone(), &policy_b)?;\n\n let frame = TransportFrame::new(\n 1,\n FrameKind::Data,\n a.node_id.clone(),\n b.node_id.clone(),\n Some(EventType::new(\"task.created\")?),\n b\"hello\".to_vec(),\n );\n ab.send(frame.clone())?;\n assert_eq!(ab.pump_to(&mut ba)?, 1);\n assert_eq!(ba.recv(), Some(frame));\n Ok(())\n }","source_test_id":"cp-transport::two_loopback_endpoints_exchange_frame","task":"rust_integration_test_generation"}73{"id":"cp-transport::subnet_access_requires_route_and_acl::generate_test","input":"Crate: cp-transport\nSource path: crates/cp-transport/src/overlay.rs\nDomains: transport\nRoutes: no HTTP route\nExpected statuses: no explicit HTTP status\nExpected error codes: no named error code\nRoles/tokens observed: none","instruction":"Write a Rust integration test for Context Primitive that verifies: subnet access requires route and acl.","output":"\n #[test]\n fn subnet_access_requires_route_and_acl() -> Result<(), Box<dyn std::error::Error>> {\n let mut policy = OverlayPolicy::new();\n let laptop = node(\"laptop\")?;\n let cluster = node(\"cluster\")?;\n let nas_subnet = OverlayCidr::new(Ipv4Addr::new(10, 10, 0, 0), 24)?;\n let mut ad =\n RouteAdvertisement::node_only(cluster, OverlayIp::new(Ipv4Addr::new(100, 90, 0, 2)));\n ad.subnet_routes.push(nas_subnet.clone());\n policy.add_advertisement(ad);\n assert_eq!(\n policy.evaluate(&laptop, &RouteTarget::Subnet(nas_subnet.clone())),\n AclDecision::DenyNoMatchingRule\n );\n policy.add_acl_rule(AclRule::allow(\n AclRuleId::new(\"allow-laptop-nas-subnet\")?,\n laptop.clone(),\n RouteTarget::Subnet(nas_subnet.clone()),\n \"explicit NAS subnet grant\",\n )?);\n assert_eq!(\n policy.evaluate(&laptop, &RouteTarget::Subnet(nas_subnet)),\n AclDecision::Allow\n );\n Ok(())\n }","source_test_id":"cp-transport::subnet_access_requires_route_and_acl","task":"rust_integration_test_generation"}74{"id":"cp-transport::overlay_policy_round_trips_as_config::generate_test","input":"Crate: cp-transport\nSource path: crates/cp-transport/src/overlay.rs\nDomains: transport\nRoutes: no HTTP route\nExpected statuses: no explicit HTTP status\nExpected error codes: no named error code\nRoles/tokens observed: none","instruction":"Write a Rust integration test for Context Primitive that verifies: overlay policy round trips as config.","output":"\n #[test]\n fn overlay_policy_round_trips_as_config() -> Result<(), Box<dyn std::error::Error>> {\n let laptop = node(\"laptop\")?;\n let cluster = node(\"cluster\")?;\n let mut policy = OverlayPolicy::new();\n let mut ad = RouteAdvertisement::node_only(\n cluster.clone(),\n OverlayIp::new(Ipv4Addr::new(100, 90, 0, 2)),\n );\n ad.subnet_routes\n .push(\"10.20.0.0/24\".parse::<OverlayCidr>()?);\n ad.service_routes\n .push(ServiceTarget::new(cluster.clone(), \"mwl-api\", 8080)?);\n policy.add_advertisement(ad);\n policy.add_acl_rule(AclRule::allow(\n AclRuleId::new(\"allow-laptop-cluster\")?,\n laptop.clone(),\n RouteTarget::Node(cluster.clone()),\n \"operator laptop may reach cluster node\",\n )?);\n\n let encoded = serde_json::to_string(&policy)?;\n assert!(encoded.contains(\"10.20.0.0/24\"));\n let decoded: OverlayPolicy = serde_json::from_str(&encoded)?;\n\n assert_eq!(\n decoded.evaluate(&laptop, &RouteTarget::Node(cluster)),\n AclDecision::Allow\n );\n assert_eq!(decoded.advertisements().len(), 1);\n assert_eq!(decoded.allow_rules().len(), 1);\n Ok(())\n }","source_test_id":"cp-transport::overlay_policy_round_trips_as_config","task":"rust_integration_test_generation"}75{"id":"cp-transport::registry_rejects_unknown_peer_link_open::generate_test","input":"Crate: cp-transport\nSource path: crates/cp-transport/src/registry.rs\nDomains: transport\nRoutes: no HTTP route\nExpected statuses: no explicit HTTP status\nExpected error codes: no named error code\nRoles/tokens observed: none","instruction":"Write a Rust integration test for Context Primitive that verifies: registry rejects unknown peer link open.","output":"\n #[test]\n fn registry_rejects_unknown_peer_link_open() -> Result<(), Box<dyn std::error::Error>> {\n let root = temp_dir(\"unknown\");\n let registry = TransportLinkRegistry::open(&root, NodeId::new(\"node-a\")?)?;\n\n assert!(matches!(\n registry.open_link(&NodeId::new(\"node-b\")?),\n Err(TransportLinkRegistryError::UnknownPeer(_))\n ));\n\n fs::remove_dir_all(root)?;\n Ok(())\n }","source_test_id":"cp-transport::registry_rejects_unknown_peer_link_open","task":"rust_integration_test_generation"}76{"id":"cp-transport::runtime_rejects_mismatched_peer_pair_without_mutation::generate_test","input":"Crate: cp-transport\nSource path: crates/cp-transport/src/runtime.rs\nDomains: transport\nRoutes: no HTTP route\nExpected statuses: no explicit HTTP status\nExpected error codes: no named error code\nRoles/tokens observed: none","instruction":"Write a Rust integration test for Context Primitive that verifies: runtime rejects mismatched peer pair without mutation.","output":"\n #[test]\n fn runtime_rejects_mismatched_peer_pair_without_mutation()\n -> Result<(), Box<dyn std::error::Error>> {\n let (root_a, mut link_a, mut journal_a, root_b, link_b, _journal_b) = negotiated_pair()?;\n let (root_c, mut link_c, _journal_c, root_d, _link_d, mut journal_d) =\n negotiated_pair_named(\"node-c\", \"node-d\", \"c\", \"d\")?;\n let runtime = TransportHandoffRuntime::new();\n\n link_a.queue_payload(FrameKind::Data, None, b\"must-not-move\".to_vec())?;\n let err = match runtime.transfer_once(\n &mut link_a,\n &mut journal_a,\n &mut link_c,\n &mut journal_d,\n 10,\n ) {\n Ok(_) => return Err(\"same-direction link was accepted\".into()),\n Err(error) => error,\n };\n\n assert!(matches!(\n err,\n TransportHandoffRuntimeError::PeerPairMismatch { .. }\n ));\n assert!(journal_a.records().is_empty());\n assert!(journal_d.records().is_empty());\n assert_eq!(link_a.status().outbound_cursor.last_delivered_sequence, 0);\n assert_eq!(link_a.status().outbound_unacked, 1);\n assert_eq!(link_b.status().inbound_unacked, 0);\n\n fs::remove_dir_all(root_a)?;\n fs::remove_dir_all(root_b)?;\n fs::remove_dir_all(root_c)?;\n fs::remove_dir_all(root_d)?;\n Ok(())\n }","source_test_id":"cp-transport::runtime_rejects_mismatched_peer_pair_without_mutation","task":"rust_integration_test_generation"}77{"id":"cp-transport::session_rejects_wrong_direction::generate_test","input":"Crate: cp-transport\nSource path: crates/cp-transport/src/session.rs\nDomains: transport\nRoutes: no HTTP route\nExpected statuses: no explicit HTTP status\nExpected error codes: no named error code\nRoles/tokens observed: none","instruction":"Write a Rust integration test for Context Primitive that verifies: session rejects wrong direction.","output":"\n #[test]\n fn session_rejects_wrong_direction() -> Result<(), Box<dyn std::error::Error>> {\n let (mut a, mut b) = session_pair()?;\n let sealed = a.seal_payload(FrameKind::Data, None, b\"payload\".to_vec())?;\n\n assert!(matches!(\n a.open_frame(&sealed),\n Err(SessionError::UnexpectedSource(_))\n ));\n assert!(matches!(\n b.open_frame(&EncryptedTransportFrame {\n target_node_id: NodeId::new(\"node-c\")?,\n ..sealed\n }),\n Err(SessionError::UnexpectedTarget(_))\n ));\n Ok(())\n }","source_test_id":"cp-transport::session_rejects_wrong_direction","task":"rust_integration_test_generation"}78{"id":"cp-transport::session_rejects_nonce_from_wrong_direction::generate_test","input":"Crate: cp-transport\nSource path: crates/cp-transport/src/session.rs\nDomains: transport\nRoutes: no HTTP route\nExpected statuses: no explicit HTTP status\nExpected error codes: no named error code\nRoles/tokens observed: none","instruction":"Write a Rust integration test for Context Primitive that verifies: session rejects nonce from wrong direction.","output":"\n #[test]\n fn session_rejects_nonce_from_wrong_direction() -> Result<(), Box<dyn std::error::Error>> {\n let (mut a, mut b) = session_pair()?;\n let mut sealed = a.seal_payload(FrameKind::Data, None, b\"payload\".to_vec())?;\n sealed.nonce = AeadNonce::from_session_sequence([9; 16], sealed.sequence);\n\n assert_eq!(b.open_frame(&sealed), Err(SessionError::NonceMismatch));\n Ok(())\n }","source_test_id":"cp-transport::session_rejects_nonce_from_wrong_direction","task":"rust_integration_test_generation"}79{"id":"cp-transport::spool_rejects_invalid_wire_packet::generate_test","input":"Crate: cp-transport\nSource path: crates/cp-transport/src/spool.rs\nDomains: transport\nRoutes: no HTTP route\nExpected statuses: no explicit HTTP status\nExpected error codes: no named error code\nRoles/tokens observed: none","instruction":"Write a Rust integration test for Context Primitive that verifies: spool rejects invalid wire packet.","output":"\n #[test]\n fn spool_rejects_invalid_wire_packet() -> Result<(), Box<dyn std::error::Error>> {\n let path = temp_path(\"invalid\");\n let mut spool = TransportPacketSpool::open(&path)?;\n\n assert!(matches!(\n spool.append_packet(\"not-a-wire-packet\"),\n Err(TransportPacketSpoolError::Wire(\n WirePacketError::WrongFieldCount { .. }\n ))\n ));\n assert!(spool.is_empty());\n if path.exists() {\n fs::remove_file(path)?;\n }\n Ok(())\n }","source_test_id":"cp-transport::spool_rejects_invalid_wire_packet","task":"rust_integration_test_generation"}80{"id":"cp-transport::spool_delivery_cursor_persists_ack_progress::generate_test","input":"Crate: cp-transport\nSource path: crates/cp-transport/src/spool.rs\nDomains: transport\nRoutes: no HTTP route\nExpected statuses: no explicit HTTP status\nExpected error codes: no named error code\nRoles/tokens observed: none","instruction":"Write a Rust integration test for Context Primitive that verifies: spool delivery cursor persists ack progress.","output":"\n #[test]\n fn spool_delivery_cursor_persists_ack_progress() -> Result<(), Box<dyn std::error::Error>> {\n let path = temp_path(\"cursor\");\n let packet = packet()?;\n let mut spool = TransportPacketSpool::open(&path)?;\n spool.append_packet(packet.clone())?;\n spool.append_packet(packet)?;\n\n let first_batch = spool.deliver_next(1)?;\n assert_eq!(first_batch.len(), 1);\n assert_eq!(first_batch[0].sequence, 1);\n assert_eq!(spool.cursor().last_delivered_sequence, 1);\n assert_eq!(spool.cursor().last_acked_sequence, 0);\n assert!(spool.ack(1)?);\n assert_eq!(spool.cursor().last_acked_sequence, 1);\n\n let reopened = TransportPacketSpool::open(&path)?;\n assert_eq!(reopened.cursor().last_delivered_sequence, 1);\n assert_eq!(reopened.cursor().last_acked_sequence, 1);\n assert_eq!(reopened.unacked_len(), 1);\n\n fs::remove_file(reopened.cursor_path())?;\n fs::remove_file(path)?;\n Ok(())\n }","source_test_id":"cp-transport::spool_delivery_cursor_persists_ack_progress","task":"rust_integration_test_generation"}81{"id":"cp-upgrade::upgrade_plan_for_no_op_migration::generate_test","input":"Crate: cp-upgrade\nSource path: crates/cp-upgrade/src/tests.rs\nDomains: upgrade, event\nRoutes: no HTTP route\nExpected statuses: no explicit HTTP status\nExpected error codes: no named error code\nRoles/tokens observed: none","instruction":"Write a Rust integration test for Context Primitive that verifies: upgrade plan for no op migration.","output":"\n#[test]\nfn upgrade_plan_for_no_op_migration() -> Result<(), Box<dyn std::error::Error>> {\n let dir = temp_dir(\"plan-no-op\")?;\n let bus_path = dir.join(\"events.jsonl\");\n write_bus(&bus_path)?;\n\n let plan = UpgradePlan::build(&bus_path, &MigrationRegistry::default())?;\n\n assert_eq!(plan.from_version, EventSchemaVersion::new(1, 0));\n assert_eq!(plan.to_version, EventSchemaVersion::new(1, 0));\n assert!(plan.steps.is_empty());\n Ok(())\n}","source_test_id":"cp-upgrade::upgrade_plan_for_no_op_migration","task":"rust_integration_test_generation"}82