converge-kernel 3.7.6

The curated in-process kernel API for Converge
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110

// Copyright 2024-2026 Reflective Labs
// SPDX-License-Identifier: MIT

//! # Converge Kernel
//!
//! This crate is the curated in-process execution API for Converge.
//! Consumers embed the kernel here; they author packs in `converge-pack`
//! and use `converge-model` for shared semantic types.

pub mod formation {
    //! Grouped offering API for self-assembling formations.
    //!
    //! The stable pattern is:
    //! - semantics in `converge-model`
    //! - authoring in `converge-pack`
    //! - runnable machinery in `converge-kernel`

    pub use converge_model::formation::{
        DeliberatedFormationTemplate, FormationCatalog, FormationKind, FormationPlan,
        FormationRequest, FormationTemplate, FormationTemplateMetadata, FormationTemplateQuery,
        OpenClawFormationTemplate, ProfileSnapshot, RoleAssignment, ScoredFormationTemplate,
        ScoringWeights, StaticFormationTemplate, SuggestorCapability, SuggestorProfile,
        SuggestorRole,
    };
    pub use converge_optimization::suggestors::FormationAssemblySuggestor;
    pub use converge_provider::ProviderSelectionSuggestor;
    pub use converge_provider_api::{
        Capability, CapabilityAssignment, CostClass, LatencyClass, ProviderAssignment,
        ProviderRequest,
    };
}

pub use converge_core::gates::hitl::{
    ContextItem, GateDecision, GateEvent, GateEventKind, GateRequest, GateVerdict, HitlPolicy,
    TimeoutAction, TimeoutPolicy,
};
pub use converge_core::gates::{
    AuthorityLevel, FlowAction, FlowGateAuthorizer, FlowGateContext, FlowGateInput,
    FlowGateOutcome, FlowGatePrincipal, FlowGateResource, FlowPhase, StopReason,
};
pub use converge_core::recall::{
    CandidateProvenance, CandidateSourceType, RecallCandidate, RecallPolicy, RecallQuery,
    RecallUse, RelevanceLevel, recall_from_store,
};
pub use converge_core::{
    ApprovalPointId, BackendId, Budget, BudgetResource, ChainId, ConstraintName, ConstraintValue,
    ContextState, ConvergeError, ConvergeResult, CorrelationId, Criterion, CriterionEvaluator,
    CriterionId, CriterionOutcome, CriterionResult, DecisionStep, Engine, EngineHitlPolicy,
    EventId, EventQuery, ExperienceEvent, ExperienceEventEnvelope, ExperienceEventKind,
    ExperienceEventObserver, ExperienceRecord, ExperienceStore, ExperienceStoreError,
    ExperienceStoreResult, HitlPause, IntegrityProof, Invariant, InvariantClass, InvariantResult,
    LamportClock, MerkleRoot, OverrideTarget, PackId, RunResult, StreamingCallback, SuggestorId,
    TenantId, TraceLinkId, TruthId, TypesBudgets, TypesIntentId, TypesIntentKind, TypesRootIntent,
    TypesRunHooks, UserExperienceEvent, UserExperienceEventEnvelope,
};
pub use converge_pack::{
    AgentEffect, Context, ContextKey, Fact, ProposedFact, Suggestor, ValidationError,
};

#[cfg(test)]
mod tests {
    use super::{
        BudgetResource, StopReason,
        formation::{
            Capability, FormationCatalog, FormationRequest, FormationTemplate,
            FormationTemplateMetadata, ProviderRequest, StaticFormationTemplate, SuggestorRole,
        },
    };

    #[test]
    fn kernel_reexports_runtime_stop_and_budget_types() {
        let stop = StopReason::converged();
        assert!(matches!(stop, StopReason::Converged));
        assert!(matches!(BudgetResource::Tokens, BudgetResource::Tokens));
    }

    #[test]
    fn kernel_groups_formation_offering_api() {
        let formation = FormationRequest {
            id: "req-1".to_string(),
            required_roles: vec![SuggestorRole::Analysis],
            required_capabilities: vec![],
        };
        let provider = ProviderRequest {
            id: "provider-1".to_string(),
            required_capabilities: vec![Capability::Reasoning],
            backend_requirements: None,
        };

        assert_eq!(formation.required_roles, vec![SuggestorRole::Analysis]);
        assert_eq!(provider.required_capabilities, vec![Capability::Reasoning]);
    }

    #[test]
    fn kernel_reexports_template_catalog_surface() {
        let catalog = FormationCatalog::new().with_template(FormationTemplate::static_template(
            StaticFormationTemplate::new(FormationTemplateMetadata::new(
                "analysis-only",
                "Single-role analysis formation",
                [SuggestorRole::Analysis],
            )),
        ));

        assert_eq!(catalog.len(), 1);
        assert_eq!(
            catalog.get("analysis-only").map(FormationTemplate::id),
            Some("analysis-only")
        );
    }
}