Skip to content

Make Codex and Claude Code subscriptions go further: a local model router that gives routine agent work to economical models and keeps your strongest model for the hard parts.

46.6 KB
Raw Blame
use super::*;
use hiroute_domain::{
    AgentCapability, AgentCollaborationSelectionV2, AgentCollaborationTriggerModeV2,
    CapabilityEvidence, CapabilityState,
};
use serde_json::json;
fn facts() -> AgentSettingsFacts {
    let dependency_digest = CanonicalDigest::of_bytes(b"context/all-consumed-dependencies/v1");
    let capabilities = AgentCapabilitySet::new(
        [
            AgentCapability::AtomicManagedReplace,
            AgentCapability::SkillLoading,
            AgentCapability::TrustedCliExecution,
        ]
        .into_iter()
        .map(|capability| CapabilityEvidence {
            capability,
            state: CapabilityState::Proven,
            adapter_contract: "isolated-test/1".into(),
            observed_at_unix_ms: 1,
            dependency_digest: dependency_digest.clone(),
            reason: None,
        }),
    )
    .unwrap();
    AgentSettingsFacts {
        reference_only_skill_restores: BTreeSet::new(),
        management_file_conflict: false,
        native_target: None,
        context_id: "agent-context/test".into(),
        dependency_digest,
        capabilities,
        collaboration_file_conflict: false,
        restore_points: BTreeMap::new(),
        model: Some(SettingsModelFacts {
            common: SettingsModelCommonFacts {
                ingress: hiroute_domain::AgentIngressProtocolV1::Messages,
                available_surfaces: [
                    hiroute_domain::AgentModelSurfaceV2::CodexCli,
                    hiroute_domain::AgentModelSurfaceV2::CodexDesktop,
                    hiroute_domain::AgentModelSurfaceV2::ClaudeCli,
                ]
                .into(),
                model_publication: None,
                login_item_required: false,
                login_item_removal_required: false,
                fixed_candidate_facts: Vec::new(),
            },
            native: SettingsModelNativeFacts::Claude(SettingsClaudeNativeFacts {
                context_override: false,
                plan_capability_unavailable: false,
                native_default_model: None,
                presets: None,
            }),
        }),
    }
}
fn model(facts: &mut AgentSettingsFacts) -> &mut SettingsModelFacts {
    facts
        .model
        .as_mut()
        .expect("this fixture supports model settings")
}

fn codex(facts: &mut AgentSettingsFacts) -> &mut SettingsCodexModelFacts {
    if !matches!(model(facts).native, SettingsModelNativeFacts::Codex(_)) {
        model(facts).native = SettingsModelNativeFacts::Codex(Box::default());
    }
    match &mut model(facts).native {
        SettingsModelNativeFacts::Codex(facts) => facts,
        _ => unreachable!(),
    }
}
fn claude(facts: &mut AgentSettingsFacts) -> &mut SettingsClaudeNativeFacts {
    match &mut model(facts).native {
        SettingsModelNativeFacts::Claude(facts) => facts,
        _ => panic!("Claude fixture required"),
    }
}

#[test]
fn claude_default_coverage_resolves_all_three_presets_without_changing_selection() {
    use hiroute_domain::{
        AgentClaudePresetMappingsV2, AgentClaudePresetSelectionV2, AgentClaudePresetValuesV2,
        AgentModelSurfaceV2, AgentPlanId, ModelAlias,
    };
    let plan_id = AgentPlanId::parse("plan/shared").unwrap();
    let grant = AgentModelGrantV2::seal(
        AgentIngressProtocolV1::Messages,
        BTreeMap::from([(
            "hiroute-shared".into(),
            AgentModelRouteV2::Plan {
                plan_id: plan_id.clone(),
                alias: ModelAlias::parse_custom("hiroute-shared").unwrap(),
                revision: 1,
                semantic_digest: CanonicalDigest::of_bytes(b"shared-plan"),
            },
        )]),
    )
    .unwrap();
    let mapped = AgentClaudePresetSelectionV2::Plan { plan_id };
    let mut selection = AgentModelSelectionV2::ClaudeLauncher {
        surfaces: [AgentModelSurfaceV2::ClaudeCli].into(),
        fixed_models: Vec::new(),
        preset_mappings: AgentClaudePresetMappingsV2 {
            opus: mapped.clone(),
            sonnet: mapped.clone(),
            haiku: mapped,
        },
    };
    let mut current = facts();
    claude(&mut current).presets = Some(AgentClaudePresetValuesV2 {
        opus: Some("native-opus".into()),
        sonnet: None,
        haiku: Some("native-haiku".into()),
    });
    for default in ["opus", "sonnet", "haiku", "hiroute-shared", "default"] {
        claude(&mut current).native_default_model = Some(default.into());
        assert_eq!(
            validate_model_default(&selection, current.model.as_ref().unwrap(), &grant),
            Ok(())
        );
        assert_eq!(
            claude(&mut current).native_default_model.as_deref(),
            Some(default)
        );
    }
    claude(&mut current).native_default_model = None;
    assert_eq!(
        validate_model_default(&selection, current.model.as_ref().unwrap(), &grant),
        Ok(())
    );
    for default in [Some("uncovered-native"), Some("opus[1m]")] {
        claude(&mut current).native_default_model = default.map(str::to_owned);
        assert_eq!(
            validate_model_default(&selection, current.model.as_ref().unwrap(), &grant),
            Err(SettingsPlanningError::InvalidSelection)
        );
    }
    if let AgentModelSelectionV2::ClaudeLauncher {
        preset_mappings, ..
    } = &mut selection
    {
        preset_mappings.opus = AgentClaudePresetSelectionV2::PreserveNative;
        preset_mappings.sonnet = AgentClaudePresetSelectionV2::PreserveNative;
    }
    for default in ["opus", "sonnet"] {
        claude(&mut current).native_default_model = Some(default.into());
        assert_eq!(
            validate_model_default(&selection, current.model.as_ref().unwrap(), &grant),
            Err(SettingsPlanningError::InvalidSelection)
        );
    }
    claude(&mut current).native_default_model = Some("haiku".into());
    assert_eq!(
        validate_model_default(&selection, current.model.as_ref().unwrap(), &grant),
        Ok(())
    );
    claude(&mut current).presets = None;
    assert_eq!(
        validate_model_default(&selection, current.model.as_ref().unwrap(), &grant),
        Err(SettingsPlanningError::InvalidSelection)
    );
}

#[test]
fn agent_settings_skill_only_needs_no_model_default_publication_or_upstream() {
    let spec: AgentSettingsSpecV2 = serde_json::from_value(json!({
        "schema_version": {"major": 2, "minor": 0}, "context_id": "agent-context/test",
        "collaboration": {"intent": "configure", "settings": {"trigger_mode": "explicit"}}
    }))
    .unwrap();
    assert_eq!(spec.model, AgentFacetIntent::Keep);
    let preview = preview_agent_settings(spec, &facts()).unwrap();
    assert!(preview.blockers.is_empty());
    assert!(preview.model_grant.is_none());
    assert_eq!(
        preview.collaboration_trigger_mode,
        Some(AgentCollaborationTriggerModeV2::Explicit)
    );
    assert_eq!(
        preview.changed_facets,
        BTreeSet::from([AgentSettingsFacet::Collaboration])
    );
}
#[test]
fn legacy_collaboration_fields_are_rejected_and_capability_drift_still_blocks() {
    assert!(
        serde_json::from_value::<AgentSettingsSpecV2>(json!({
            "schema_version": {"major": 2, "minor": 0},
            "context_id": "agent-context/test",
            "collaboration": {"intent": "configure", "settings": {"allowed_plan_ids": []}}
        }))
        .is_err()
    );
    let spec = AgentSettingsSpecV2 {
        native_target: None,
        management_skill: None,
        schema_version: AGENT_SETTINGS_SCHEMA_V2,
        context_id: "agent-context/test".into(),
        model: AgentFacetIntent::Keep,
        collaboration: AgentFacetIntent::Configure {
            settings: AgentCollaborationSelectionV2 {
                trigger_mode: AgentCollaborationTriggerModeV2::DelegateByDefault,
            },
        },
        restore_native_model: None,
        protected_native_model_ids: Vec::new(),
        access_token: hiroute_domain::AgentAccessTokenIntentV1::Keep,
    };
    assert!(
        preview_agent_settings(spec.clone(), &facts())
            .unwrap()
            .blockers
            .is_empty()
    );
    let mut changed = facts();
    changed.dependency_digest = CanonicalDigest::of_bytes(b"new-context-revision");
    let preview = preview_agent_settings(spec, &changed).unwrap();
    assert!(
        preview
            .blockers
            .iter()
            .all(|block| block.facet == AgentSettingsFacet::Collaboration)
    );
    assert!(
        preview
            .blockers
            .iter()
            .any(|block| block.reason == SettingsBlockReason::CapabilityUnavailable)
    );
}
#[test]
fn agent_settings_restore_reference_cannot_cross_context_or_facet() {
    let spec = AgentSettingsSpecV2 {
        native_target: None,
        management_skill: None,
        schema_version: AGENT_SETTINGS_SCHEMA_V2,
        context_id: "agent-context/test".into(),
        model: AgentFacetIntent::Restore {
            restore_point_ref: "restore/from-other-context".into(),
        },
        collaboration: AgentFacetIntent::Keep,
        restore_native_model: None,
        protected_native_model_ids: Vec::new(),
        access_token: hiroute_domain::AgentAccessTokenIntentV1::Keep,
    };
    let preview = preview_agent_settings(spec, &facts()).unwrap();
    assert!(
        preview
            .blockers
            .iter()
            .any(|block| block.reason == SettingsBlockReason::RestorePointUnavailable)
    );
    assert!(
        !preview
            .changed_facets
            .contains(&AgentSettingsFacet::Collaboration)
    );
}

#[test]
fn codex_restore_requires_an_original_catalog_model_for_a_stale_alias() {
    let mut facts = facts();
    model(&mut facts).common.ingress = AgentIngressProtocolV1::Responses;
    facts
        .restore_points
        .insert("restore/owned".into(), AgentSettingsFacet::Model);
    codex(&mut facts).restore_native_model_ids =
        Some(vec!["gpt-5.6-sol".into(), "gpt-5.6-luna".into()]);
    codex(&mut facts).restored_native_model = Some("hiroute-fanyi".into());
    let mut spec: AgentSettingsSpecV2 = serde_json::from_value(json!({
        "schema_version": {"major": 2, "minor": 0},
        "context_id": "agent-context/test",
        "model": {"intent": "restore", "restore_point_ref": "restore/owned"}
    }))
    .unwrap();
    let blocked = preview_agent_settings(spec.clone(), &facts).unwrap();
    assert!(blocked.blockers.iter().any(|block| {
        block.reason == SettingsBlockReason::RestoreNativeModelInvalid
            && block.model_ids == ["hiroute-fanyi"]
    }));
    spec.restore_native_model = Some("gpt-5.6-sol".into());
    let repaired = preview_agent_settings(spec.clone(), &facts).unwrap();
    assert!(
        !repaired
            .blockers
            .iter()
            .any(|block| block.reason == SettingsBlockReason::RestoreNativeModelInvalid)
    );
    spec.restore_native_model = Some("other-account-model".into());
    let wrong = preview_agent_settings(spec, &facts).unwrap();
    assert!(
        wrong
            .blockers
            .iter()
            .any(|block| block.reason == SettingsBlockReason::RestoreNativeModelInvalid)
    );

    codex(&mut facts).restored_native_model = None;
    codex(&mut facts).restore_native_model_ids = Some(Vec::new());
    let restore_default = serde_json::from_value(json!({
        "schema_version": {"major": 2, "minor": 0},
        "context_id": "agent-context/test",
        "model": {"intent": "restore", "restore_point_ref": "restore/owned"}
    }))
    .unwrap();
    assert!(
        !preview_agent_settings(restore_default, &facts)
            .unwrap()
            .blockers
            .iter()
            .any(|block| block.reason == SettingsBlockReason::RestoreNativeModelInvalid)
    );
}

#[test]
fn agent_settings_confirmation_rebuilds_preview_and_rejects_drift_or_changed_facets() {
    use hiroute_application_api::AgentSettingsApplyV2;
    let spec: AgentSettingsSpecV2 = serde_json::from_value(json!({
        "schema_version": {"major":2,"minor":0}, "context_id":"agent-context/test",
        "collaboration":{"intent":"configure","settings":{"trigger_mode":"explicit"}}
    }))
    .unwrap();
    let fresh = facts();
    let preview = preview_agent_settings(spec.clone(), &fresh).unwrap();
    let request = AgentSettingsApplyV2 {
        expected_revisions: hiroute_domain::RevisionSetV1 {
            target: 0,
            dependencies: Default::default(),
        },
        spec,
        accept_digest: preview.accept_digest,
        dependency_digest: preview.dependency_digest,
        idempotency_key: "settings-once".into(),
        login_item: None,
    };
    let confirmed = confirm_agent_settings(request.clone(), &fresh).unwrap();
    assert_eq!(confirmed.preview().spec.model, AgentFacetIntent::Keep);
    assert_eq!(confirmed.idempotency_key(), "settings-once");
    let mut changed = request.clone();
    changed.spec.model = AgentFacetIntent::Restore {
        restore_point_ref: "restore/not-confirmed".into(),
    };
    assert!(matches!(
        confirm_agent_settings(changed, &fresh),
        Err(SettingsConfirmationError::Stale)
    ));
    let mut drift = facts();
    drift.dependency_digest = CanonicalDigest::of_bytes(b"replaced-native-file");
    assert!(matches!(
        confirm_agent_settings(request.clone(), &drift),
        Err(SettingsConfirmationError::Stale)
    ));
    let mut unavailable = facts();
    unavailable.capabilities = AgentCapabilitySet::new([]).unwrap();
    let blocked = preview_agent_settings(request.spec.clone(), &unavailable).unwrap();
    assert_eq!(blocked.blockers[0].capabilities.len(), 3);
    let blocked_request = AgentSettingsApplyV2 {
        expected_revisions: hiroute_domain::RevisionSetV1 {
            target: 0,
            dependencies: Default::default(),
        },
        accept_digest: blocked.accept_digest,
        ..request
    };
    assert!(matches!(
        confirm_agent_settings(blocked_request, &unavailable),
        Err(SettingsConfirmationError::Blocked)
    ));
}

#[test]
fn confirmed_skill_only_settings_seal_exact_effects_and_confirmation_dependencies() {
    use hiroute_application_api::AgentSettingsApplyV2;
    use hiroute_domain::{
        AgentConnectionEffectRoleV1, AgentConnectionTransactionSubjectV1, ExternalEffectIntentV1,
    };
    let fresh = facts();
    let spec: AgentSettingsSpecV2 = serde_json::from_value(json!({
        "schema_version":{"major":2,"minor":0}, "context_id":"agent-context/test",
        "collaboration":{"intent":"configure","settings":{"trigger_mode":"explicit"}}
    }))
    .unwrap();
    let preview = preview_agent_settings(spec.clone(), &fresh).unwrap();
    let confirmed = confirm_agent_settings(
        AgentSettingsApplyV2 {
            expected_revisions: hiroute_domain::RevisionSetV1 {
                target: 0,
                dependencies: Default::default(),
            },
            spec,
            accept_digest: preview.accept_digest.clone(),
            dependency_digest: preview.dependency_digest.clone(),
            idempotency_key: "settings-sealed".into(),
            login_item: None,
        },
        &fresh,
    )
    .unwrap();
    let subject = || {
        AgentConnectionTransactionSubjectV1::from_registered_profile(
            "agent.codex",
            "default",
            "codex.profile.v1",
        )
        .unwrap()
    };
    let plan = confirmed
        .seal_effects(subject(), &json!({"revision":1}), true, vec![], |control| {
            Ok(vec![ExternalEffectIntentV1::from_agent_connection_planner(
                control,
                AgentConnectionEffectRoleV1::RoutingSkill,
                None,
                &json!({"content_digest":CanonicalDigest::of_bytes(b"shared-template"), "context_id":"agent-context/test", "action":"install"}),
                0o644,
            )?])
        })
        .unwrap();
    assert_eq!(plan.spec().command_id, "agents.settings.apply");
    assert!(plan.agent_access_grants().is_empty());
    assert_eq!(
        plan.control()["payload"]["state"]["accept_digest"],
        json!(preview.accept_digest)
    );
    assert_eq!(
        plan.control()["payload"]["state"]["dependency_digest"],
        json!(fresh.dependency_digest)
    );
    assert!(
        confirmed
            .seal_effects(subject(), &json!({"revision":1}), true, vec![], |_| Ok(
                vec![]
            ))
            .is_err()
    );
    assert!(
        confirmed
            .seal_effects(
                subject(),
                &json!({"api_key":"must-not-be-journaled"}),
                false,
                vec![],
                |_| Ok(vec![])
            )
            .is_err()
    );
}

#[test]
fn codex_plan_selections_preview_only_with_catalog_facts() {
    let publication = crate::compiler::test_fixtures::compiled_publication(1);
    let plan = publication
        .published_agent_plans()
        .unwrap()
        .into_iter()
        .find(|plan| plan.active)
        .unwrap();
    let plan_id = serde_json::to_value(&plan.agent_plan_id).unwrap();
    let spec = |settings: serde_json::Value| -> AgentSettingsSpecV2 {
        serde_json::from_value(json!({
            "schema_version": {"major": 2, "minor": 0}, "context_id": "agent-context/test",
            "model": {"intent": "configure", "settings": settings}
        }))
        .unwrap()
    };
    let plan_selection = json!({
        "mode": "codex_default", "native_model_mode": "hiroute_only", "fixed_models": [],
        "allowed_plan_ids": [plan_id.clone()],
        "default_selection": {"kind": "plan", "plan_id": plan_id}
    });
    let codex_facts = |model_catalog: Option<SettingsModelCatalogFacts>| {
        let dependency_digest = CanonicalDigest::of_bytes(b"context/catalog-gate/v1");
        let capabilities = AgentCapabilitySet::new(
            [
                AgentCapability::EffectiveConfiguration,
                AgentCapability::AtomicManagedReplace,
                AgentCapability::IngressAuthentication,
            ]
            .into_iter()
            .map(|capability| CapabilityEvidence {
                capability,
                state: CapabilityState::Proven,
                adapter_contract: "isolated-test/1".into(),
                observed_at_unix_ms: 1,
                dependency_digest: dependency_digest.clone(),
                reason: None,
            }),
        )
        .unwrap();
        AgentSettingsFacts {
            reference_only_skill_restores: BTreeSet::new(),
            management_file_conflict: false,
            native_target: None,
            context_id: "agent-context/test".into(),
            dependency_digest,
            capabilities,
            collaboration_file_conflict: false,
            restore_points: BTreeMap::new(),
            model: Some(SettingsModelFacts {
                common: SettingsModelCommonFacts {
                    ingress: AgentIngressProtocolV1::Responses,
                    available_surfaces: [
                        hiroute_domain::AgentModelSurfaceV2::CodexCli,
                        hiroute_domain::AgentModelSurfaceV2::CodexDesktop,
                    ]
                    .into(),
                    model_publication: Some(publication.clone()),
                    login_item_required: false,
                    login_item_removal_required: false,
                    fixed_candidate_facts: Vec::new(),
                },
                native: SettingsModelNativeFacts::Codex(Box::new(SettingsCodexModelFacts {
                    context_override: false,
                    model_catalog,
                    preserved_codex_models: Vec::new(),
                    preserved_codex_bindings: BTreeMap::new(),
                    required_native_model_ids: None,
                    unproven_native_model_ids: Vec::new(),
                    require_native_model_routes: false,
                    native_default_must_be_original: false,
                    native_default_model: None,
                    restore_native_model_ids: None,
                    restore_inherits_root: false,
                    restored_native_model: None,
                })),
            }),
        }
    };
    let catalog_block = |reason: hiroute_domain::CapabilityBlockReason| AgentSettingsBlock {
        facet: AgentSettingsFacet::Model,
        reason: SettingsBlockReason::CapabilityUnavailable,
        capabilities: vec![hiroute_domain::CapabilityBlock {
            capability: AgentCapability::ModelCatalog,
            reason,
        }],
        model_ids: Vec::new(),
    };

    // An unavailable full-catalog source leaves the catalog underivable; the selection is
    // blocked, not sealed.
    let unproven =
        preview_agent_settings(spec(plan_selection.clone()), &codex_facts(None)).unwrap();
    assert!(unproven.model_grant.is_some());
    assert_eq!(
        unproven.blockers,
        vec![catalog_block(
            hiroute_domain::CapabilityBlockReason::Unknown
        )]
    );

    // Structural catalog support whose source still cannot be derived reports unavailable, not
    // unknown.
    let mut unavailable_facts = codex_facts(None);
    unavailable_facts.capabilities = AgentCapabilitySet::new(
        [
            AgentCapability::EffectiveConfiguration,
            AgentCapability::AtomicManagedReplace,
            AgentCapability::IngressAuthentication,
            AgentCapability::ModelCatalog,
        ]
        .into_iter()
        .map(|capability| CapabilityEvidence {
            capability,
            state: CapabilityState::Proven,
            adapter_contract: "isolated-test/1".into(),
            observed_at_unix_ms: 1,
            dependency_digest: unavailable_facts.dependency_digest.clone(),
            reason: None,
        }),
    )
    .unwrap();
    let unavailable =
        preview_agent_settings(spec(plan_selection.clone()), &unavailable_facts).unwrap();
    assert_eq!(
        unavailable.blockers,
        vec![catalog_block(
            hiroute_domain::CapabilityBlockReason::Unavailable
        )]
    );

    let mut no_detected_surface = codex_facts(Some(SettingsModelCatalogFacts {
        source_revision: "be6e8eac029b183056b7e4402879f15d2c85f61b".into(),
        content_digest: CanonicalDigest::of_bytes(b"merged-catalog"),
        before_fingerprint: None,
        producer_kind: CodexCatalogProducerKindV1::TargetCache,
        producer_path: if cfg!(windows) {
            "C:/target/.codex/models_cache.json"
        } else {
            "/target/.codex/models_cache.json"
        }
        .into(),
        producer_content_digest: CanonicalDigest::of_bytes(b"native-catalog"),
        producer_context_digest: CanonicalDigest::of_bytes(b"codex-context"),
        producer_dependency_digest: CanonicalDigest::of_bytes(b"catalog-dependencies"),
    }));
    model(&mut no_detected_surface)
        .common
        .available_surfaces
        .clear();
    let without_client =
        preview_agent_settings(spec(plan_selection.clone()), &no_detected_surface).unwrap();
    assert!(without_client.blockers.is_empty());
    assert!(without_client.model_grant.is_some());

    codex(&mut no_detected_surface).context_override = true;
    let conflict =
        preview_agent_settings(spec(plan_selection.clone()), &no_detected_surface).unwrap();
    assert!(
        conflict
            .blockers
            .iter()
            .any(|block| block.reason == SettingsBlockReason::CodexContextOverride)
    );

    // Catalog facts make the same plan selection preview cleanly.
    let mut proven_facts = codex_facts(Some(SettingsModelCatalogFacts {
        source_revision: "be6e8eac029b183056b7e4402879f15d2c85f61b".into(),
        content_digest: CanonicalDigest::of_bytes(b"merged-catalog"),
        before_fingerprint: None,
        producer_kind: CodexCatalogProducerKindV1::TargetCache,
        producer_path: if cfg!(windows) {
            "C:/target/.codex/models_cache.json"
        } else {
            "/target/.codex/models_cache.json"
        }
        .into(),
        producer_content_digest: CanonicalDigest::of_bytes(b"native-catalog"),
        producer_context_digest: CanonicalDigest::of_bytes(b"codex-context"),
        producer_dependency_digest: CanonicalDigest::of_bytes(b"catalog-dependencies"),
    }));
    let mut preserve_plan_alias = plan_selection.clone();
    preserve_plan_alias["native_model_mode"] = json!("preserve_available");
    preserve_plan_alias["default_selection"] = json!({"kind": "preserve_native"});
    codex(&mut proven_facts).native_default_model = Some(plan.model_alias.as_str().into());
    let matched_alias =
        preview_agent_settings(spec(preserve_plan_alias.clone()), &proven_facts).unwrap();
    assert!(matched_alias.blockers.is_empty());
    assert!(
        matched_alias
            .model_grant
            .unwrap()
            .permits_name(plan.model_alias.as_str()),
        "an explicitly allowed plan covers the same current Codex default alias"
    );
    codex(&mut proven_facts).native_default_model = Some("hiroute-unpublished".into());
    let unmatched_alias = preview_agent_settings(spec(preserve_plan_alias), &proven_facts).unwrap();
    assert_eq!(
        unmatched_alias.blockers[0].reason,
        SettingsBlockReason::ModelPlanUnavailable,
        "an unrelated default name still cannot be published"
    );
    codex(&mut proven_facts).native_default_model = None;
    let candidates = crate::compiler::test_fixtures::compilation_facts().candidates;
    let candidate = candidates
        .iter()
        .find(|candidate| candidate.binding.binding_id == "binding/primary-a")
        .unwrap()
        .clone();
    let replacement_candidate = candidates
        .iter()
        .find(|candidate| candidate.binding.binding_id == "binding/primary-b")
        .unwrap()
        .clone();
    let preserved = hiroute_domain::AgentFixedModelSelectionV2 {
        client_model_id: candidate.native_transport_model.clone(),
        candidate: hiroute_domain::CandidateSelectionV1 {
            binding_id: candidate.binding.binding_id.clone(),
            reasoning: Some(hiroute_domain::ReasoningSelectionV1::Profile {
                profile: "medium".into(),
            }),
        },
    };
    model(&mut proven_facts).common.fixed_candidate_facts =
        vec![candidate, replacement_candidate.clone()];
    codex(&mut proven_facts).preserved_codex_models = vec![preserved.clone()];
    codex(&mut proven_facts).native_default_model = Some(preserved.client_model_id.clone());
    codex(&mut proven_facts).required_native_model_ids = Some(vec![
        preserved.client_model_id.clone(),
        "native-unselected".into(),
    ]);
    codex(&mut proven_facts).require_native_model_routes = true;
    codex(&mut proven_facts).native_default_must_be_original = true;
    let mut preserve_selection = plan_selection.clone();
    preserve_selection["native_model_mode"] = json!("preserve_available");
    let incomplete =
        preview_agent_settings(spec(preserve_selection.clone()), &proven_facts).unwrap();
    assert!(incomplete.blockers.iter().any(|block| {
        block.reason == SettingsBlockReason::NativeModelCoverageUnavailable
            && block.model_ids == ["native-unselected"]
    }));
    codex(&mut proven_facts).required_native_model_ids =
        Some(vec![preserved.client_model_id.clone()]);
    codex(&mut proven_facts).native_default_model = Some(plan.model_alias.as_str().into());
    let stale_default =
        preview_agent_settings(spec(preserve_selection.clone()), &proven_facts).unwrap();
    assert!(stale_default.blockers.iter().any(|block| {
        block.reason == SettingsBlockReason::NativeDefaultInvalid
            && block.model_ids == [plan.model_alias.as_str()]
    }));
    codex(&mut proven_facts).native_default_model = Some(preserved.client_model_id.clone());
    let mut replacing = preserve_selection.clone();
    let mut replaced = preserved.clone();
    replaced.candidate.binding_id = replacement_candidate.binding.binding_id.clone();
    replacing["fixed_models"] = serde_json::to_value([replaced.clone()]).unwrap();
    let replacement = preview_agent_settings(spec(replacing), &proven_facts).unwrap();
    assert!(replacement.blockers.iter().any(|block| {
        block.reason == SettingsBlockReason::NativeModelCoverageUnavailable
            && block.model_ids == [preserved.client_model_id.as_str()]
    }));
    let AgentFacetIntent::Configure {
        settings: AgentModelSelectionV2::CodexDefault { fixed_models, .. },
    } = &replacement.spec.model
    else {
        panic!("expected Codex model configuration")
    };
    assert_eq!(fixed_models, std::slice::from_ref(&replaced));

    codex(&mut proven_facts).unproven_native_model_ids =
        vec!["cache-name-without-account-proof".into()];
    let proven = preview_agent_settings(spec(preserve_selection.clone()), &proven_facts).unwrap();
    assert!(proven.blockers.is_empty());
    assert_eq!(
        proven.unproven_native_model_ids,
        ["cache-name-without-account-proof"]
    );
    assert!(proven.model_grant.is_some());
    let AgentFacetIntent::Configure {
        settings: AgentModelSelectionV2::CodexDefault { fixed_models, .. },
    } = &proven.spec.model
    else {
        panic!("expected Codex model configuration")
    };
    assert_eq!(fixed_models, std::slice::from_ref(&preserved));

    // A later full-state edit keeps the sealed native route even when the ephemeral
    // connection-only candidate has vanished from current discovery.
    let prior = proven.model_grant.as_ref().unwrap();
    let hiroute_domain::AgentModelRouteV2::Fixed { binding, .. } =
        &prior.routes[&preserved.client_model_id]
    else {
        panic!("fixed route")
    };
    codex(&mut proven_facts)
        .preserved_codex_bindings
        .insert(preserved.client_model_id.clone(), binding.as_ref().clone());
    model(&mut proven_facts)
        .common
        .fixed_candidate_facts
        .clear();
    let later = preview_agent_settings(spec(preserve_selection.clone()), &proven_facts).unwrap();
    assert!(later.blockers.is_empty());
    assert_eq!(
        later.spec.protected_native_model_ids.as_slice(),
        std::slice::from_ref(&preserved.client_model_id)
    );
    assert_eq!(
        later.model_grant.unwrap().routes[&preserved.client_model_id],
        prior.routes[&preserved.client_model_id]
    );
    let mut changed_binding = preserve_selection;
    changed_binding["fixed_models"] = serde_json::to_value([replaced]).unwrap();
    model(&mut proven_facts).common.fixed_candidate_facts = vec![replacement_candidate];
    let rejected = preview_agent_settings(spec(changed_binding), &proven_facts).unwrap();
    assert!(!rejected.blockers.is_empty());
    assert!(
        rejected
            .blockers
            .iter()
            .any(|block| { block.reason == SettingsBlockReason::ModelPlanUnavailable })
    );

    // Plan-only settings without protected native bindings remain a full-state edit.
    codex(&mut proven_facts).preserved_codex_models.clear();
    codex(&mut proven_facts).preserved_codex_bindings.clear();
    codex(&mut proven_facts).required_native_model_ids = None;
    codex(&mut proven_facts).require_native_model_routes = false;
    let removed = preview_agent_settings(spec(plan_selection), &proven_facts).unwrap();
    let AgentFacetIntent::Configure {
        settings: AgentModelSelectionV2::CodexDefault { fixed_models, .. },
    } = &removed.spec.model
    else {
        panic!("expected Codex model configuration")
    };
    assert!(fixed_models.is_empty());
}

#[test]
fn codex_model_file_journal_binds_the_catalog_to_plan_carrying_grants() {
    use crate::agent_connection::{
        CodexModelFileAction, settings_codex_catalog_intent,
        settings_codex_model_file_for_operation, settings_codex_model_file_intent,
    };
    use hiroute_domain::{
        AgentAccessGrantMutationV1, AgentAccessGrantScopeV1, AgentConnectionControlIntentV1,
        AgentConnectionTransactionSubjectV1, AgentModelRouteV2, AgentPlanId, CHANGE_SPEC_SCHEMA_V1,
        ChangeSpecV1, IdempotencyScopeV1, ModelAlias, OperationId, OperationV1, RevisionSetV1,
        TransactionPlanV1, WorkspaceId,
    };
    const CONTEXT: &str = "agent-context/catalog-journal";
    let plan_id = AgentPlanId::parse("plan/journal").unwrap();
    let grant = AgentModelGrantV2::seal(
        AgentIngressProtocolV1::Responses,
        BTreeMap::from([(
            "hiroute-journal".to_owned(),
            AgentModelRouteV2::Plan {
                plan_id: plan_id.clone(),
                alias: ModelAlias::parse_custom("hiroute-journal").unwrap(),
                revision: 1,
                semantic_digest: CanonicalDigest::of_bytes(b"plan-journal"),
            },
        )]),
    )
    .unwrap();
    let catalog_digest = CanonicalDigest::of_bytes(b"merged-catalog");
    let change = |model_catalog: Option<CanonicalDigest>| CodexModelFileAction::Configure {
        previous_operation: None,
        provider_id: "hiroute".to_owned(),
        endpoint: "http://127.0.0.1:8787/v1".to_owned(),
        model: None,
        model_catalog,
    };
    let operation = |grant: &AgentModelGrantV2,
                     plan_ids: serde_json::Value,
                     change: CodexModelFileAction,
                     catalog: Option<CanonicalDigest>|
     -> OperationV1 {
        let change_spec = ChangeSpecV1 {
            schema_version: CHANGE_SPEC_SCHEMA_V1,
            command_id: "agents.settings.apply".to_owned(),
            resource_id: Some(CONTEXT.to_owned()),
            desired_state: json!({
                "schema_version": {"major": 2, "minor": 0}, "context_id": CONTEXT,
                "model": {"intent": "configure", "settings": {
                    "mode": "codex_default",
                    "native_model_mode": "preserve_available",
                    "fixed_models": [], "allowed_plan_ids": plan_ids,
                    "default_selection": {"kind": "preserve_native"}
                }}
            }),
        };
        let accept = CanonicalDigest::of_bytes(b"catalog-journal-accept");
        let control = AgentConnectionControlIntentV1::from_settings_planner(
            AgentConnectionTransactionSubjectV1::from_registered_profile(
                "agent_codex_default",
                "codex-responses-v1",
                "builtin/codex-responses/v1",
            )
            .unwrap(),
            &change_spec,
            false,
            &json!({"accept_digest": accept, "model_grant": grant}),
        )
        .unwrap();
        let mutation = AgentAccessGrantMutationV1::ensure(
            WorkspaceId::DEFAULT,
            AgentAccessGrantScopeV1::new(format!("agent-connection/{CONTEXT}"), grant.clone())
                .unwrap(),
            0,
        )
        .unwrap();
        let model_file = settings_codex_model_file_intent(
            &control,
            CONTEXT,
            CanonicalDigest::of_bytes(b"model-file"),
            None,
            change,
        )
        .unwrap();
        let mut external = catalog
            .map(|digest| {
                settings_codex_catalog_intent(
                    &control,
                    CONTEXT,
                    &SettingsModelCatalogFacts {
                        source_revision: "be6e8eac029b183056b7e4402879f15d2c85f61b".into(),
                        content_digest: digest,
                        before_fingerprint: None,
                        producer_kind: CodexCatalogProducerKindV1::TargetCache,
                        producer_path: if cfg!(windows) {
                            "C:/target/.codex/models_cache.json"
                        } else {
                            "/target/.codex/models_cache.json"
                        }
                        .into(),
                        producer_content_digest: CanonicalDigest::of_bytes(b"native-catalog"),
                        producer_context_digest: CanonicalDigest::of_bytes(b"codex-context"),
                        producer_dependency_digest: CanonicalDigest::of_bytes(
                            b"catalog-dependencies",
                        ),
                    },
                )
                .unwrap()
            })
            .into_iter()
            .collect::<Vec<_>>();
        external.push(model_file);
        external.push(
            hiroute_domain::settings_model_publication_intent(
                &control,
                CONTEXT,
                CanonicalDigest::of_bytes(b"publication"),
                None,
            )
            .unwrap(),
        );
        let plan = TransactionPlanV1::from_agent_connection_planner_with_agent_access_grants(
            change_spec,
            control,
            vec![mutation],
            external,
        )
        .unwrap();
        let workspace = WorkspaceId::default();
        let idempotency =
            IdempotencyScopeV1::new("interactive-user", "agents.settings.apply", "journal")
                .unwrap();
        let request = CanonicalDigest::of_bytes(b"catalog-journal-request");
        OperationV1::new(
            OperationId::derive(&workspace, &idempotency, &request),
            workspace.clone(),
            idempotency,
            request,
            accept,
            RevisionSetV1 {
                target: 0,
                dependencies: BTreeMap::new(),
            },
            plan,
        )
        .unwrap()
    };
    let model_intent = |operation: &OperationV1| {
        operation
            .plan
            .external()
            .iter()
            .find(|intent| intent.effect_id() == "agent-connection-managed-configuration")
            .unwrap()
            .clone()
    };
    let plan_ids = json!(["plan/journal"]);

    // A plan-carrying grant references its own registered catalog artifact.
    let bound = operation(
        &grant,
        plan_ids.clone(),
        change(Some(catalog_digest.clone())),
        Some(catalog_digest.clone()),
    );
    let payload = settings_codex_model_file_for_operation(&bound, &model_intent(&bound)).unwrap();
    assert!(matches!(
        &payload.change,
        CodexModelFileAction::Configure { model_catalog: Some(digest), .. }
            if digest == &catalog_digest
    ));

    // A plan-carrying grant without any catalog reference is rejected.
    let missing = operation(&grant, plan_ids.clone(), change(None), None);
    assert!(settings_codex_model_file_for_operation(&missing, &model_intent(&missing)).is_err());

    // A reference to a catalog artifact the operation never registered is rejected.
    let dangling = operation(&grant, plan_ids, change(Some(catalog_digest.clone())), None);
    assert!(settings_codex_model_file_for_operation(&dangling, &model_intent(&dangling)).is_err());
}

#[test]
fn login_item_intent_binds_only_active_host_declarations() {
    use crate::agent_connection::{settings_login_item_effect, settings_login_item_intent};
    use hiroute_application_api::{
        AgentLoginItemDeclarationV2 as Declaration, AgentLoginItemStatusV2 as Status,
    };
    use hiroute_domain::{
        AgentConnectionControlIntentV1, AgentConnectionTransactionSubjectV1, CHANGE_SPEC_SCHEMA_V1,
        ChangeSpecV1,
    };
    const CONTEXT: &str = "agent-context/test";
    let change_spec = ChangeSpecV1 {
        schema_version: CHANGE_SPEC_SCHEMA_V1,
        command_id: "agents.settings.apply".to_owned(),
        resource_id: Some(CONTEXT.to_owned()),
        desired_state: json!({
            "schema_version": {"major": 2, "minor": 0}, "context_id": CONTEXT,
            "model": {"intent": "configure", "settings": {
                "mode": "codex_default",
                "native_model_mode": "hiroute_only",
                "fixed_models": [], "allowed_plan_ids": ["plan/login-item"],
                "default_selection": {"kind": "plan", "plan_id": "plan/login-item"}
            }}
        }),
    };
    let control = AgentConnectionControlIntentV1::from_settings_planner(
        AgentConnectionTransactionSubjectV1::from_registered_profile(
            "agent_codex_default",
            "codex-responses-v1",
            "builtin/codex-responses/v1",
        )
        .unwrap(),
        &change_spec,
        false,
        &json!({"accept_digest": CanonicalDigest::of_bytes(b"login-item-accept")}),
    )
    .unwrap();
    let created = Declaration {
        before: Status::NotRegistered,
        after: Status::Enabled,
        created: true,
    };
    let intent = settings_login_item_intent(&control, CONTEXT, &created).unwrap();
    assert_eq!(intent.effect_id(), "agent-connection-login-item");
    assert_eq!(intent.kind(), hiroute_domain::OwnedEffectKind::LoginItem);
    let effect = settings_login_item_effect(&intent).unwrap();
    assert_eq!(effect.effect_id, "agent-connection-login-item");
    assert_eq!(effect.kind, hiroute_domain::OwnedEffectKind::LoginItem);
    assert_ne!(effect.before_fingerprint, effect.after_fingerprint);
    assert_eq!(
        *effect.compensation,
        json!({"revert":"unregister","owner":"desktop-host"})
    );
    // A pre-existing user login item is journaled without compensation metadata.
    let present = Declaration {
        before: Status::Enabled,
        after: Status::Enabled,
        created: false,
    };
    let effect = settings_login_item_effect(
        &settings_login_item_intent(&control, CONTEXT, &present).unwrap(),
    )
    .unwrap();
    assert_eq!(*effect.compensation, json!({}));
    // The last managed connection's restore releases only the item this feature owns: the
    // removal declaration proves the host left the item not active, and a definitively failed
    // restore replays the re-registration.
    let released = Declaration {
        before: Status::Enabled,
        after: Status::NotRegistered,
        created: false,
    };
    let effect = settings_login_item_effect(
        &settings_login_item_intent(&control, CONTEXT, &released).unwrap(),
    )
    .unwrap();
    assert_ne!(effect.before_fingerprint, effect.after_fingerprint);
    assert_eq!(
        *effect.compensation,
        json!({"revert":"register","owner":"desktop-host"})
    );
    // A removal declaration that leaves the item active never seals.
    let still_active = Declaration {
        before: Status::Enabled,
        after: Status::RequiresApproval,
        created: false,
    };
    assert!(
        settings_login_item_intent(&control, CONTEXT, &still_active).is_err(),
        "a release that leaves the login item active must not seal"
    );
    // Unapproved or failed registrations never seal: they stay service_unavailable.
    for declaration in [
        Declaration {
            before: Status::NotRegistered,
            after: Status::RequiresApproval,
            created: true,
        },
        Declaration {
            before: Status::RequiresApproval,
            after: Status::RequiresApproval,
            created: false,
        },
        Declaration {
            before: Status::NotRegistered,
            after: Status::Enabled,
            created: false,
        },
    ] {
        assert!(
            settings_login_item_intent(&control, CONTEXT, &declaration).is_err(),
            "an inactive or inconsistent declaration must not seal"
        );
    }
}

#[test]
fn claude_settings_share_the_smallest_published_window_and_block_overrides() {
    let original = crate::compiler::test_fixtures::compiled_publication(1);
    let mut plans: Vec<_> = original.plans.clone();
    for (plan, window) in plans.iter_mut().zip([100_000, 120_000]) {
        let body = std::sync::Arc::make_mut(&mut plan.body);
        body.materialized.attempt_owned.limits.context_window_tokens = Some(window);
        body.materialized_route_digest = body.materialized.route_digest().unwrap();
        *plan = hiroute_domain::CompiledAgentPlanV1::seal_current(body.clone()).unwrap();
    }
    let ids: Vec<_> = plans
        .iter()
        .map(|plan| plan.agent_plan_id().clone())
        .collect();
    let publication = GatewayPublicationV1::seal(
        original.workspace_id,
        original.authority_id,
        original.authority_epoch,
        original.publication_revision,
        original.catalog_renderer_revision,
        original.alias_registry,
        plans,
        Vec::new(),
    )
    .unwrap();
    let spec: AgentSettingsSpecV2 = serde_json::from_value(json!({
        "schema_version":{"major":2,"minor":0}, "context_id":"agent-context/test",
        "model":{"intent":"configure","settings":{"mode":"claude_launcher","surfaces":["claude_cli"],"fixed_models":[],"preset_mappings":{
            "opus":{"kind":"plan","plan_id":ids[0]},"sonnet":{"kind":"plan","plan_id":ids[1]},"haiku":{"kind":"preserve_native"}}}}
    })).unwrap();
    let mut facts = facts();
    model(&mut facts).common.model_publication = Some(publication);
    claude(&mut facts).presets = Some(hiroute_domain::AgentClaudePresetValuesV2 {
        opus: None,
        sonnet: None,
        haiku: None,
    });
    let preview = preview_agent_settings(spec.clone(), &facts).unwrap();
    assert_eq!(preview.claude_context_window, Some(100_000));
    assert_eq!(
        preview
            .context_windows
            .values()
            .copied()
            .collect::<BTreeSet<_>>(),
        [100_000, 120_000].into()
    );
    claude(&mut facts).context_override = true;
    let blocked = preview_agent_settings(spec.clone(), &facts).unwrap();
    assert!(
        blocked
            .blockers
            .iter()
            .any(|block| block.reason == SettingsBlockReason::ClaudeContextOverride)
    );
    claude(&mut facts).context_override = false;
    claude(&mut facts).plan_capability_unavailable = true;
    let blocked = preview_agent_settings(spec, &facts).unwrap();
    assert!(
        blocked
            .blockers
            .iter()
            .any(|block| block.reason == SettingsBlockReason::ClaudePlanCapabilityUnavailable)
    );
}

#[test]
fn standalone_profile_restore_inherits_root_without_catalog_or_native_override() {
    let mut facts = facts();
    model(&mut facts).common.ingress = AgentIngressProtocolV1::Responses;
    codex(&mut facts).restore_inherits_root = true;
    facts.capabilities = AgentCapabilitySet::new(
        [
            AgentCapability::EffectiveConfiguration,
            AgentCapability::AtomicManagedReplace,
        ]
        .into_iter()
        .map(|capability| CapabilityEvidence {
            capability,
            state: CapabilityState::Proven,
            adapter_contract: "isolated-test/1".into(),
            observed_at_unix_ms: 1,
            dependency_digest: facts.dependency_digest.clone(),
            reason: None,
        }),
    )
    .unwrap();
    facts
        .restore_points
        .insert("restore/owned".into(), AgentSettingsFacet::Model);
    let mut spec: AgentSettingsSpecV2 = serde_json::from_value(json!({
        "schema_version":{"major":2,"minor":0}, "context_id":"agent-context/test",
        "model":{"intent":"restore","restore_point_ref":"restore/owned"}
    }))
    .unwrap();
    assert!(
        preview_agent_settings(spec.clone(), &facts)
            .unwrap()
            .blockers
            .is_empty()
    );
    spec.restore_native_model = Some("gpt-5.6-sol".into());
    assert!(matches!(
        preview_agent_settings(spec, &facts),
        Err(SettingsPlanningError::InvalidSelection)
    ));
}

#[path = "collaboration_only_tests.rs"]
mod collaboration_only_tests;