Текст этого вопроса будет отправлен в OpenAI и может храниться до 30 дней для мониторинга злоупотреблений. Контекст, идентификаторы и секреты Домового не передаются.
+
ВНЕШНИЙ КОГНИТИВНЫЙ ПРОВАЙДЕР
+
Текст вопроса будет передан согласно активной политике данных.
diff --git a/contracts/capability/cognitive_registry.go b/contracts/capability/cognitive_registry.go
new file mode 100644
index 0000000..d8afd58
--- /dev/null
+++ b/contracts/capability/cognitive_registry.go
@@ -0,0 +1,231 @@
+package capability
+
+import (
+ "git.cin.su/m/Assistant/contracts/artifact"
+ "git.cin.su/m/Assistant/contracts/identity"
+ "git.cin.su/m/Assistant/platform/ids"
+)
+
+type ProviderInstanceID ids.ID
+type ModelDescriptorID ids.ID
+type CredentialRef ids.ID
+type EndpointBindingRef ids.ID
+type LimitPolicyRef ids.ID
+type ProviderKind string
+type ProviderModelID string
+type ModelFingerprint string
+type QualificationState string
+type ActivationState string
+type DataPolicy string
+type ModelModality string
+type ModelCapability string
+type OperationalState string
+type EvaluationResult string
+type EvaluationID ids.ID
+type PerformanceEvidenceID ids.ID
+
+const (
+ QualificationDiscovered QualificationState = "DISCOVERED"
+ QualificationProbing QualificationState = "PROBING"
+ QualificationEvaluating QualificationState = "EVALUATING"
+ QualificationValidated QualificationState = "VALIDATED"
+ QualificationRejected QualificationState = "REJECTED"
+
+ ActivationInactive ActivationState = "INACTIVE"
+ ActivationCanary ActivationState = "CANARY"
+ ActivationActive ActivationState = "ACTIVE"
+ ActivationDeprecated ActivationState = "DEPRECATED"
+ ActivationRetired ActivationState = "RETIRED"
+
+ DataPolicyLocalOnly DataPolicy = "LOCAL_ONLY"
+ DataPolicyExternalMessageOnly DataPolicy = "EXTERNAL_MESSAGE_ONLY"
+ DataPolicyExternalMinimizedContext DataPolicy = "EXTERNAL_MINIMIZED_CONTEXT"
+
+ ModalityText ModelModality = "TEXT"
+ CapabilityAdvisory ModelCapability = "ADVISORY"
+ CapabilityUnknown ModelCapability = "UNKNOWN"
+
+ OperationalNotObserved OperationalState = "NOT_OBSERVED"
+ OperationalYes OperationalState = "YES"
+ OperationalNo OperationalState = "NO"
+
+ EvaluationUnknown EvaluationResult = "UNKNOWN"
+ EvaluationSupported EvaluationResult = "SUPPORTED"
+ EvaluationUnsupported EvaluationResult = "UNSUPPORTED"
+)
+
+// ProviderInstance contains only opaque references to endpoint and credentials.
+// Credential material is resolved by the cognitive runtime, never by Core.
+type ProviderInstance struct {
+ ID ProviderInstanceID
+ Revision int64
+ Kind ProviderKind
+ EndpointRef EndpointBindingRef
+ CredentialRef CredentialRef
+ Enabled bool
+ Qualification QualificationState
+ Health HealthState
+ ObservedAtUnixMillis int64
+}
+
+type ModelDescriptor struct {
+ ID ModelDescriptorID
+ Revision int64
+ ProviderInstanceID ProviderInstanceID
+ ProviderModelID ProviderModelID
+ Fingerprint ModelFingerprint
+ MaxContextBytes int64
+ Modalities []ModelModality
+ Capabilities []ModelCapability
+ Qualification QualificationState
+ Health HealthState
+ ObservedAtUnixMillis int64
+}
+
+type ProviderHealthObservation struct {
+ ProviderInstanceID ProviderInstanceID
+ Health HealthState
+ ObservedAtUnixMillis int64
+ FailureClass CognitiveFailureType
+}
+
+type ModelOperationalObservation struct {
+ ProviderInstanceID ProviderInstanceID
+ ModelDescriptorID ModelDescriptorID
+ Installed OperationalState
+ Loaded OperationalState
+ Invokable OperationalState
+ Health HealthState
+ ObservedAtUnixMillis int64
+}
+
+type CognitiveBinding struct {
+ ID CapabilityBindingID
+ Revision int64
+ CapabilityID CapabilityID
+ OwnerPrincipalID identity.PrincipalID
+ ProviderInstanceID ProviderInstanceID
+ ProviderRevision int64
+ ModelDescriptorID ModelDescriptorID
+ ModelRevision int64
+ DataPolicy DataPolicy
+ Qualification QualificationState
+ Activation ActivationState
+ Health HealthState
+ LimitPolicyRef LimitPolicyRef
+}
+
+type CognitiveRequirement struct {
+ CapabilityID CapabilityID
+ OwnerPrincipalID identity.PrincipalID
+ DataPolicy DataPolicy
+ RequiredModalities []ModelModality
+ RequiredCapabilities []ModelCapability
+ AllowCanary bool
+ InputBytes int64
+ MaxOutputBytes int64
+ ExcludedBindingIDs []CapabilityBindingID
+}
+
+// ResolvedCognitiveBinding is a provider-neutral invocation snapshot selected
+// by Capability. It contains references and declared metadata, never secrets.
+type ResolvedCognitiveBinding struct {
+ Binding CognitiveBinding
+ Provider ProviderInstance
+ Model ModelDescriptor
+ Evaluation *EvaluatedCapability
+ Performance *PerformanceEvidence
+}
+
+type CognitiveResultClass string
+type CognitiveFailureType string
+
+type EvaluatedCapability struct {
+ ID EvaluationID
+ BindingID CapabilityBindingID
+ BindingRevision int64
+ CapabilityID CapabilityID
+ Result EvaluationResult
+ QualityScoreMillis *int64
+ CriticalFailureMillis *int64
+ BenchmarkVersion string
+ ArtifactID artifact.ArtifactID
+ ObservedAtUnixMillis int64
+}
+
+type PerformanceEvidence struct {
+ ID PerformanceEvidenceID
+ BindingID CapabilityBindingID
+ BindingRevision int64
+ ModelDescriptorID ModelDescriptorID
+ ModelRevision int64
+ HardwareProfile string
+ Runtime string
+ Quantization string
+ ContextUnits *int64
+ ThinkingEnabled *bool
+ GenerationTPSMillis *int64
+ PromptTPSMillis *int64
+ TTFTMicros *int64
+ LatencyMicros *int64
+ MemoryBytes *int64
+ ReliabilityMillis *int64
+ BenchmarkVersion string
+ ArtifactID artifact.ArtifactID
+ ObservedAtUnixMillis int64
+}
+
+type CognitiveDiscoveryRegistration struct {
+ Provider ProviderInstance
+ Models []ModelDescriptor
+ Bindings []CognitiveBinding
+ ProviderHealth ProviderHealthObservation
+ ModelAvailability []ModelOperationalObservation
+}
+
+// CognitiveDiscoverySnapshot is provider-neutral observed inventory submitted
+// to the Capability owner. The owner assigns immutable revisions and always
+// registers discovered bindings as DISCOVERED/INACTIVE.
+type CognitiveDiscoverySnapshot struct {
+ ProviderInstanceID ProviderInstanceID
+ ProviderKind ProviderKind
+ EndpointRef EndpointBindingRef
+ CredentialRef CredentialRef
+ Enabled bool
+ OwnerPrincipalID identity.PrincipalID
+ CapabilityID CapabilityID
+ DataPolicy DataPolicy
+ LimitPolicyRef LimitPolicyRef
+ Health HealthState
+ FailureClass CognitiveFailureType
+ ObservedAtUnixMillis int64
+ Models []DiscoveredModelSnapshot
+}
+
+type DiscoveredModelSnapshot struct {
+ ProviderModelID ProviderModelID
+ Fingerprint ModelFingerprint
+ MaxContextBytes int64
+ Modalities []ModelModality
+ Capabilities []ModelCapability
+ Installed OperationalState
+ Loaded OperationalState
+ Invokable OperationalState
+}
+
+type CognitiveUsageObservation struct {
+ ObservationID ids.ID
+ RequestID ids.ID
+ BindingID CapabilityBindingID
+ BindingRevision int64
+ ProviderInstanceID ProviderInstanceID
+ ModelDescriptorID ModelDescriptorID
+ ObservedAtUnixMillis int64
+ LatencyMillis int64
+ InputUnits int64
+ OutputUnits int64
+ EstimatedCostMicros *int64
+ ActualCostMicros *int64
+ ResultClass CognitiveResultClass
+ FailureType CognitiveFailureType
+}
diff --git a/contracts/capability/types.go b/contracts/capability/types.go
index d283960..65f464f 100644
--- a/contracts/capability/types.go
+++ b/contracts/capability/types.go
@@ -38,6 +38,7 @@ type Binding struct {
type HealthState string
const (
+ HealthUnknown HealthState = "UNKNOWN"
HealthAvailable HealthState = "AVAILABLE"
HealthDegraded HealthState = "DEGRADED"
HealthUnavailable HealthState = "UNAVAILABLE"
diff --git a/contracts/cognitive/types.go b/contracts/cognitive/types.go
index 497fa97..7fbd852 100644
--- a/contracts/cognitive/types.go
+++ b/contracts/cognitive/types.go
@@ -25,8 +25,16 @@ const (
FinishLengthLimit FinishReason = "LENGTH_LIMIT"
FinishContentRejected FinishReason = "CONTENT_REJECTED"
FinishProviderUnavailable FinishReason = "PROVIDER_UNAVAILABLE"
+ FinishModelUnavailable FinishReason = "MODEL_UNAVAILABLE"
+ FinishRateLimited FinishReason = "RATE_LIMITED"
+ FinishAuthenticationFailed FinishReason = "AUTHENTICATION_FAILED"
+ FinishBillingOrBudgetBlocked FinishReason = "BILLING_OR_BUDGET_BLOCKED"
+ FinishContextTooLarge FinishReason = "CONTEXT_TOO_LARGE"
+ FinishUnsupportedCapability FinishReason = "UNSUPPORTED_CAPABILITY"
FinishTimeout FinishReason = "TIMEOUT"
FinishInvalidProviderResponse FinishReason = "INVALID_PROVIDER_RESPONSE"
+ FinishInvalidStructuredOutput FinishReason = "INVALID_STRUCTURED_OUTPUT"
+ FinishDegraded FinishReason = "DEGRADED"
)
type ContextExcerpt struct {
@@ -52,6 +60,36 @@ type AdvisoryRequest struct {
MaxOutputBytes int
ProviderBindingID capability.CapabilityBindingID
ProviderBindingRevision int64
+ ProviderInstanceID capability.ProviderInstanceID
+ ModelDescriptorID capability.ModelDescriptorID
+ ProviderModelID capability.ProviderModelID
+}
+
+// GatewayAdvisoryRequest describes the task and policy requirement. It cannot
+// name a provider, model or binding; Capability owns that selection.
+type GatewayAdvisoryRequest struct {
+ Version ContractVersion
+ RequestID RequestID
+ ActorID identity.ActorID
+ PrincipalID identity.PrincipalID
+ ScopeID authority.ScopeID
+ Message string
+ Context []ContextExcerpt
+ Locale string
+ MaxOutputBytes int
+ DataPolicy capability.DataPolicy
+ EgressAcknowledged bool
+}
+
+type GatewayAdvisoryPolicyRequest struct {
+ PrincipalID identity.PrincipalID
+ DataPolicy capability.DataPolicy
+}
+
+type GatewayAdvisoryPolicy struct {
+ ExternalEgress bool
+ AcknowledgementRequired bool
+ Disclosure string
}
type ProviderUsage struct {
@@ -69,3 +107,12 @@ type AdvisoryResponse struct {
FinishReason FinishReason
Usage *ProviderUsage
}
+
+type GatewayAdvisoryResponse struct {
+ Version ContractVersion
+ RequestID RequestID
+ AdvisoryText string
+ ReferencedExcerptIDs []ContextExcerptID
+ FinishReason FinishReason
+ Usage *ProviderUsage
+}
diff --git a/database/bootstrap/001_roles_and_schemas.sql b/database/bootstrap/001_roles_and_schemas.sql
index 1bda888..af615f6 100644
--- a/database/bootstrap/001_roles_and_schemas.sql
+++ b/database/bootstrap/001_roles_and_schemas.sql
@@ -185,6 +185,90 @@ CREATE TABLE IF NOT EXISTS capability.notification_binding_heads (
binding_id TEXT NOT NULL, revision BIGINT NOT NULL,
PRIMARY KEY (capability_id, owner_principal_id), CHECK (revision > 0)
);
+CREATE TABLE IF NOT EXISTS capability.cognitive_provider_instances (
+ provider_instance_id TEXT NOT NULL, revision BIGINT NOT NULL, provider_kind TEXT NOT NULL,
+ endpoint_ref TEXT NOT NULL, credential_ref TEXT, enabled BOOLEAN NOT NULL,
+ qualification TEXT NOT NULL, health TEXT NOT NULL, observed_at_unix_millis BIGINT NOT NULL,
+ recorded_at TIMESTAMPTZ NOT NULL DEFAULT CURRENT_TIMESTAMP,
+ PRIMARY KEY (provider_instance_id, revision), CHECK (revision > 0),
+ CHECK (qualification IN ('DISCOVERED','PROBING','EVALUATING','VALIDATED','REJECTED')),
+ CHECK (health IN ('UNKNOWN','AVAILABLE','DEGRADED','UNAVAILABLE')), CHECK (observed_at_unix_millis > 0)
+);
+CREATE TABLE IF NOT EXISTS capability.cognitive_model_descriptors (
+ model_descriptor_id TEXT NOT NULL, revision BIGINT NOT NULL, provider_instance_id TEXT NOT NULL,
+ provider_model_id TEXT NOT NULL, fingerprint TEXT NOT NULL, max_context_bytes BIGINT NOT NULL,
+ modalities TEXT[] NOT NULL, capabilities TEXT[] NOT NULL, qualification TEXT NOT NULL,
+ health TEXT NOT NULL, observed_at_unix_millis BIGINT NOT NULL,
+ recorded_at TIMESTAMPTZ NOT NULL DEFAULT CURRENT_TIMESTAMP,
+ PRIMARY KEY (model_descriptor_id, revision), CHECK (revision > 0), CHECK (max_context_bytes >= 0),
+ CHECK (cardinality(modalities) > 0), CHECK (cardinality(capabilities) > 0),
+ CHECK (qualification IN ('DISCOVERED','PROBING','EVALUATING','VALIDATED','REJECTED')),
+ CHECK (health IN ('UNKNOWN','AVAILABLE','DEGRADED','UNAVAILABLE')), CHECK (observed_at_unix_millis > 0)
+);
+CREATE TABLE IF NOT EXISTS capability.cognitive_bindings (
+ binding_id TEXT NOT NULL, revision BIGINT NOT NULL, capability_id TEXT NOT NULL,
+ owner_principal_id TEXT NOT NULL, provider_instance_id TEXT NOT NULL, provider_revision BIGINT NOT NULL,
+ model_descriptor_id TEXT NOT NULL, model_revision BIGINT NOT NULL,
+ data_policy TEXT NOT NULL, qualification TEXT NOT NULL, activation TEXT NOT NULL,
+ health TEXT NOT NULL, limit_policy_ref TEXT NOT NULL, recorded_at TIMESTAMPTZ NOT NULL DEFAULT CURRENT_TIMESTAMP,
+ PRIMARY KEY (binding_id, revision), CHECK (revision > 0), CHECK (provider_revision > 0), CHECK (model_revision > 0),
+ CHECK (data_policy IN ('LOCAL_ONLY','EXTERNAL_MESSAGE_ONLY','EXTERNAL_MINIMIZED_CONTEXT')),
+ CHECK (qualification IN ('DISCOVERED','PROBING','EVALUATING','VALIDATED','REJECTED')),
+ CHECK (activation IN ('INACTIVE','CANARY','ACTIVE','DEPRECATED','RETIRED')),
+ CHECK (health IN ('UNKNOWN','AVAILABLE','DEGRADED','UNAVAILABLE'))
+);
+CREATE TABLE IF NOT EXISTS capability.cognitive_binding_heads (
+ capability_id TEXT NOT NULL, owner_principal_id TEXT NOT NULL, binding_id TEXT NOT NULL,
+ revision BIGINT NOT NULL, PRIMARY KEY (capability_id, owner_principal_id), CHECK (revision > 0)
+);
+CREATE TABLE IF NOT EXISTS capability.cognitive_usage_observations (
+ observation_id TEXT PRIMARY KEY, request_id TEXT NOT NULL, binding_id TEXT NOT NULL,
+ binding_revision BIGINT NOT NULL, provider_instance_id TEXT NOT NULL, model_descriptor_id TEXT NOT NULL,
+ observed_at_unix_millis BIGINT NOT NULL, latency_millis BIGINT NOT NULL,
+ input_units BIGINT NOT NULL, output_units BIGINT NOT NULL, estimated_cost_micros BIGINT,
+ actual_cost_micros BIGINT, result_class TEXT NOT NULL, failure_type TEXT NOT NULL DEFAULT '',
+ recorded_at TIMESTAMPTZ NOT NULL DEFAULT CURRENT_TIMESTAMP,
+ CHECK (binding_revision > 0), CHECK (observed_at_unix_millis > 0), CHECK (latency_millis >= 0),
+ CHECK (input_units >= 0), CHECK (output_units >= 0),
+ CHECK (estimated_cost_micros IS NULL OR estimated_cost_micros >= 0),
+ CHECK (actual_cost_micros IS NULL OR actual_cost_micros >= 0)
+);
+CREATE TABLE IF NOT EXISTS capability.cognitive_provider_health (
+ provider_instance_id TEXT PRIMARY KEY, health TEXT NOT NULL, observed_at_unix_millis BIGINT NOT NULL,
+ failure_class TEXT NOT NULL DEFAULT '', recorded_at TIMESTAMPTZ NOT NULL DEFAULT CURRENT_TIMESTAMP,
+ CHECK (health IN ('UNKNOWN','AVAILABLE','DEGRADED','UNAVAILABLE')), CHECK (observed_at_unix_millis > 0)
+);
+CREATE TABLE IF NOT EXISTS capability.cognitive_model_availability (
+ provider_instance_id TEXT NOT NULL, model_descriptor_id TEXT NOT NULL,
+ installed TEXT NOT NULL, loaded TEXT NOT NULL, invokable TEXT NOT NULL, health TEXT NOT NULL,
+ observed_at_unix_millis BIGINT NOT NULL, recorded_at TIMESTAMPTZ NOT NULL DEFAULT CURRENT_TIMESTAMP,
+ PRIMARY KEY (provider_instance_id, model_descriptor_id),
+ CHECK (installed IN ('NOT_OBSERVED','YES','NO')), CHECK (loaded IN ('NOT_OBSERVED','YES','NO')),
+ CHECK (invokable IN ('NOT_OBSERVED','YES','NO')), CHECK (health IN ('UNKNOWN','AVAILABLE','DEGRADED','UNAVAILABLE')),
+ CHECK (observed_at_unix_millis > 0)
+);
+CREATE TABLE IF NOT EXISTS capability.cognitive_evaluated_capabilities (
+ evaluation_id TEXT PRIMARY KEY, binding_id TEXT NOT NULL, binding_revision BIGINT NOT NULL,
+ capability_id TEXT NOT NULL, result TEXT NOT NULL, quality_score_millis BIGINT,
+ critical_failure_millis BIGINT, benchmark_version TEXT NOT NULL, artifact_id TEXT NOT NULL,
+ observed_at_unix_millis BIGINT NOT NULL, recorded_at TIMESTAMPTZ NOT NULL DEFAULT CURRENT_TIMESTAMP,
+ CHECK (binding_revision > 0), CHECK (result IN ('UNKNOWN','SUPPORTED','UNSUPPORTED')),
+ CHECK (quality_score_millis IS NULL OR quality_score_millis >= 0),
+ CHECK (critical_failure_millis IS NULL OR critical_failure_millis >= 0), CHECK (observed_at_unix_millis > 0)
+);
+CREATE TABLE IF NOT EXISTS capability.cognitive_performance_evidence (
+ evidence_id TEXT PRIMARY KEY, binding_id TEXT NOT NULL, binding_revision BIGINT NOT NULL,
+ model_descriptor_id TEXT NOT NULL, model_revision BIGINT NOT NULL, hardware_profile TEXT NOT NULL,
+ runtime TEXT NOT NULL, quantization TEXT NOT NULL, context_units BIGINT, thinking_enabled BOOLEAN,
+ generation_tps_millis BIGINT, prompt_tps_millis BIGINT, ttft_micros BIGINT, latency_micros BIGINT,
+ memory_bytes BIGINT, reliability_millis BIGINT, benchmark_version TEXT NOT NULL, artifact_id TEXT NOT NULL,
+ observed_at_unix_millis BIGINT NOT NULL, recorded_at TIMESTAMPTZ NOT NULL DEFAULT CURRENT_TIMESTAMP,
+ CHECK (binding_revision > 0), CHECK (model_revision > 0),
+ CHECK (context_units IS NULL OR context_units >= 0), CHECK (generation_tps_millis IS NULL OR generation_tps_millis >= 0),
+ CHECK (prompt_tps_millis IS NULL OR prompt_tps_millis >= 0), CHECK (ttft_micros IS NULL OR ttft_micros >= 0),
+ CHECK (latency_micros IS NULL OR latency_micros >= 0), CHECK (memory_bytes IS NULL OR memory_bytes >= 0),
+ CHECK (reliability_millis IS NULL OR reliability_millis >= 0), CHECK (observed_at_unix_millis > 0)
+);
RESET ROLE;
SET ROLE continuity_role;
diff --git a/database/migrations/012_capability_cognitive_registry.sql b/database/migrations/012_capability_cognitive_registry.sql
new file mode 100644
index 0000000..75d2adf
--- /dev/null
+++ b/database/migrations/012_capability_cognitive_registry.sql
@@ -0,0 +1,61 @@
+BEGIN;
+SET ROLE capability_role;
+
+CREATE TABLE IF NOT EXISTS capability.cognitive_provider_instances (
+ provider_instance_id TEXT NOT NULL, revision BIGINT NOT NULL, provider_kind TEXT NOT NULL,
+ endpoint_ref TEXT NOT NULL, credential_ref TEXT NOT NULL, enabled BOOLEAN NOT NULL,
+ qualification TEXT NOT NULL, health TEXT NOT NULL, observed_at_unix_millis BIGINT NOT NULL,
+ recorded_at TIMESTAMPTZ NOT NULL DEFAULT CURRENT_TIMESTAMP,
+ PRIMARY KEY (provider_instance_id, revision), CHECK (revision > 0),
+ CHECK (qualification IN ('DISCOVERED','PROBING','EVALUATING','VALIDATED','REJECTED')),
+ CHECK (health IN ('UNKNOWN','AVAILABLE','DEGRADED','UNAVAILABLE')),
+ CHECK (observed_at_unix_millis > 0)
+);
+
+CREATE TABLE IF NOT EXISTS capability.cognitive_model_descriptors (
+ model_descriptor_id TEXT NOT NULL, revision BIGINT NOT NULL, provider_instance_id TEXT NOT NULL,
+ provider_model_id TEXT NOT NULL, fingerprint TEXT NOT NULL, max_context_bytes BIGINT NOT NULL,
+ modalities TEXT[] NOT NULL, capabilities TEXT[] NOT NULL, qualification TEXT NOT NULL,
+ health TEXT NOT NULL, observed_at_unix_millis BIGINT NOT NULL,
+ recorded_at TIMESTAMPTZ NOT NULL DEFAULT CURRENT_TIMESTAMP,
+ PRIMARY KEY (model_descriptor_id, revision), CHECK (revision > 0), CHECK (max_context_bytes > 0),
+ CHECK (cardinality(modalities) > 0), CHECK (cardinality(capabilities) > 0),
+ CHECK (qualification IN ('DISCOVERED','PROBING','EVALUATING','VALIDATED','REJECTED')),
+ CHECK (health IN ('UNKNOWN','AVAILABLE','DEGRADED','UNAVAILABLE')),
+ CHECK (observed_at_unix_millis > 0)
+);
+
+CREATE TABLE IF NOT EXISTS capability.cognitive_bindings (
+ binding_id TEXT NOT NULL, revision BIGINT NOT NULL, capability_id TEXT NOT NULL,
+ owner_principal_id TEXT NOT NULL, provider_instance_id TEXT NOT NULL, provider_revision BIGINT NOT NULL,
+ model_descriptor_id TEXT NOT NULL, model_revision BIGINT NOT NULL,
+ data_policy TEXT NOT NULL, qualification TEXT NOT NULL, activation TEXT NOT NULL,
+ health TEXT NOT NULL, limit_policy_ref TEXT NOT NULL,
+ recorded_at TIMESTAMPTZ NOT NULL DEFAULT CURRENT_TIMESTAMP,
+ PRIMARY KEY (binding_id, revision), CHECK (revision > 0), CHECK (provider_revision > 0), CHECK (model_revision > 0),
+ CHECK (data_policy IN ('LOCAL_ONLY','EXTERNAL_MESSAGE_ONLY','EXTERNAL_MINIMIZED_CONTEXT')),
+ CHECK (qualification IN ('DISCOVERED','PROBING','EVALUATING','VALIDATED','REJECTED')),
+ CHECK (activation IN ('INACTIVE','CANARY','ACTIVE','DEPRECATED','RETIRED')),
+ CHECK (health IN ('UNKNOWN','AVAILABLE','DEGRADED','UNAVAILABLE'))
+);
+
+CREATE TABLE IF NOT EXISTS capability.cognitive_binding_heads (
+ capability_id TEXT NOT NULL, owner_principal_id TEXT NOT NULL, binding_id TEXT NOT NULL,
+ revision BIGINT NOT NULL, PRIMARY KEY (capability_id, owner_principal_id), CHECK (revision > 0)
+);
+
+CREATE TABLE IF NOT EXISTS capability.cognitive_usage_observations (
+ observation_id TEXT PRIMARY KEY, request_id TEXT NOT NULL, binding_id TEXT NOT NULL,
+ binding_revision BIGINT NOT NULL, provider_instance_id TEXT NOT NULL, model_descriptor_id TEXT NOT NULL,
+ observed_at_unix_millis BIGINT NOT NULL, latency_millis BIGINT NOT NULL,
+ input_units BIGINT NOT NULL, output_units BIGINT NOT NULL, estimated_cost_micros BIGINT,
+ actual_cost_micros BIGINT, result_class TEXT NOT NULL,
+ recorded_at TIMESTAMPTZ NOT NULL DEFAULT CURRENT_TIMESTAMP,
+ CHECK (binding_revision > 0), CHECK (observed_at_unix_millis > 0), CHECK (latency_millis >= 0),
+ CHECK (input_units >= 0), CHECK (output_units >= 0),
+ CHECK (estimated_cost_micros IS NULL OR estimated_cost_micros >= 0),
+ CHECK (actual_cost_micros IS NULL OR actual_cost_micros >= 0)
+);
+
+RESET ROLE;
+COMMIT;
diff --git a/database/migrations/013_capability_cognitive_discovery_evidence.sql b/database/migrations/013_capability_cognitive_discovery_evidence.sql
new file mode 100644
index 0000000..93f0d7e
--- /dev/null
+++ b/database/migrations/013_capability_cognitive_discovery_evidence.sql
@@ -0,0 +1,51 @@
+BEGIN;
+SET ROLE capability_role;
+
+ALTER TABLE capability.cognitive_provider_instances ALTER COLUMN credential_ref DROP NOT NULL;
+ALTER TABLE capability.cognitive_model_descriptors DROP CONSTRAINT IF EXISTS cognitive_model_descriptors_max_context_bytes_check;
+ALTER TABLE capability.cognitive_model_descriptors ADD CONSTRAINT cognitive_model_descriptors_max_context_bytes_check CHECK (max_context_bytes >= 0);
+
+CREATE TABLE IF NOT EXISTS capability.cognitive_provider_health (
+ provider_instance_id TEXT PRIMARY KEY, health TEXT NOT NULL, observed_at_unix_millis BIGINT NOT NULL,
+ failure_class TEXT NOT NULL DEFAULT '', recorded_at TIMESTAMPTZ NOT NULL DEFAULT CURRENT_TIMESTAMP,
+ CHECK (health IN ('UNKNOWN','AVAILABLE','DEGRADED','UNAVAILABLE')), CHECK (observed_at_unix_millis > 0)
+);
+
+CREATE TABLE IF NOT EXISTS capability.cognitive_model_availability (
+ provider_instance_id TEXT NOT NULL, model_descriptor_id TEXT NOT NULL,
+ installed TEXT NOT NULL, loaded TEXT NOT NULL, invokable TEXT NOT NULL, health TEXT NOT NULL,
+ observed_at_unix_millis BIGINT NOT NULL, recorded_at TIMESTAMPTZ NOT NULL DEFAULT CURRENT_TIMESTAMP,
+ PRIMARY KEY (provider_instance_id, model_descriptor_id),
+ CHECK (installed IN ('NOT_OBSERVED','YES','NO')), CHECK (loaded IN ('NOT_OBSERVED','YES','NO')),
+ CHECK (invokable IN ('NOT_OBSERVED','YES','NO')), CHECK (health IN ('UNKNOWN','AVAILABLE','DEGRADED','UNAVAILABLE')),
+ CHECK (observed_at_unix_millis > 0)
+);
+
+CREATE TABLE IF NOT EXISTS capability.cognitive_evaluated_capabilities (
+ evaluation_id TEXT PRIMARY KEY, binding_id TEXT NOT NULL, binding_revision BIGINT NOT NULL,
+ capability_id TEXT NOT NULL, result TEXT NOT NULL, quality_score_millis BIGINT,
+ critical_failure_millis BIGINT, benchmark_version TEXT NOT NULL, artifact_id TEXT NOT NULL,
+ observed_at_unix_millis BIGINT NOT NULL, recorded_at TIMESTAMPTZ NOT NULL DEFAULT CURRENT_TIMESTAMP,
+ CHECK (binding_revision > 0), CHECK (result IN ('UNKNOWN','SUPPORTED','UNSUPPORTED')),
+ CHECK (quality_score_millis IS NULL OR quality_score_millis >= 0),
+ CHECK (critical_failure_millis IS NULL OR critical_failure_millis >= 0), CHECK (observed_at_unix_millis > 0)
+);
+
+CREATE TABLE IF NOT EXISTS capability.cognitive_performance_evidence (
+ evidence_id TEXT PRIMARY KEY, binding_id TEXT NOT NULL, binding_revision BIGINT NOT NULL,
+ model_descriptor_id TEXT NOT NULL, model_revision BIGINT NOT NULL, hardware_profile TEXT NOT NULL,
+ runtime TEXT NOT NULL, quantization TEXT NOT NULL, context_units BIGINT, thinking_enabled BOOLEAN,
+ generation_tps_millis BIGINT, prompt_tps_millis BIGINT, ttft_micros BIGINT, latency_micros BIGINT,
+ memory_bytes BIGINT, reliability_millis BIGINT, benchmark_version TEXT NOT NULL, artifact_id TEXT NOT NULL,
+ observed_at_unix_millis BIGINT NOT NULL, recorded_at TIMESTAMPTZ NOT NULL DEFAULT CURRENT_TIMESTAMP,
+ CHECK (binding_revision > 0), CHECK (model_revision > 0),
+ CHECK (context_units IS NULL OR context_units >= 0), CHECK (generation_tps_millis IS NULL OR generation_tps_millis >= 0),
+ CHECK (prompt_tps_millis IS NULL OR prompt_tps_millis >= 0), CHECK (ttft_micros IS NULL OR ttft_micros >= 0),
+ CHECK (latency_micros IS NULL OR latency_micros >= 0), CHECK (memory_bytes IS NULL OR memory_bytes >= 0),
+ CHECK (reliability_millis IS NULL OR reliability_millis >= 0), CHECK (observed_at_unix_millis > 0)
+);
+
+ALTER TABLE capability.cognitive_usage_observations ADD COLUMN IF NOT EXISTS failure_type TEXT NOT NULL DEFAULT '';
+
+RESET ROLE;
+COMMIT;
diff --git a/deploy/docker-compose.dev.yml b/deploy/docker-compose.dev.yml
index 79c0a2a..c2217d8 100644
--- a/deploy/docker-compose.dev.yml
+++ b/deploy/docker-compose.dev.yml
@@ -95,7 +95,12 @@ services:
context: ..
dockerfile: deploy/images/runtime.Dockerfile
args: { TARGET: cognitive-worker }
- environment: { LISTEN_ADDR: ":8083" }
+ environment:
+ LISTEN_ADDR: ":8083"
+ CORE_RUNTIME_URL: http://core-runtime:8080
+ LOCAL_CPU_PROVIDER_URL: http://docker.cin.su:18082/v1
+ LOCAL_GPU_PROVIDER_URL: http://192.168.220.91:11434
+ COGNITIVE_OWNER_PRINCIPAL_ID: domovoy-creator-principal
ports: ["19083:8083"]
creator-web:
diff --git a/deploy/docker-compose.prod.yml b/deploy/docker-compose.prod.yml
index cfed193..7c5eb6e 100644
--- a/deploy/docker-compose.prod.yml
+++ b/deploy/docker-compose.prod.yml
@@ -112,7 +112,13 @@ services:
cognitive-worker:
build: { context: .., dockerfile: deploy/images/runtime.Dockerfile, args: { TARGET: cognitive-worker, SOURCE_REVISION: "${ASSISTANT_SOURCE_REVISION:-unknown}" } }
restart: unless-stopped
- environment: { LISTEN_ADDR: ":8083" }
+ environment:
+ LISTEN_ADDR: ":8083"
+ CORE_RUNTIME_URL: http://core-runtime:8080
+ LOCAL_CPU_PROVIDER_URL: http://docker.cin.su:18082/v1
+ LOCAL_GPU_PROVIDER_URL: http://192.168.220.91:11434
+ COGNITIVE_OWNER_PRINCIPAL_ID: domovoy-creator-principal
+ depends_on: [core-runtime]
creator-web:
build: { context: .., dockerfile: deploy/images/runtime.Dockerfile, args: { TARGET: creator-web, SOURCE_REVISION: "${ASSISTANT_SOURCE_REVISION:-unknown}" } }
diff --git a/dev/ACTIVE_TASK.json b/dev/ACTIVE_TASK.json
index 25e814f..4e49f9a 100644
--- a/dev/ACTIVE_TASK.json
+++ b/dev/ACTIVE_TASK.json
@@ -1,5 +1,5 @@
{
- "task_file": "dev/tasks/DEV-000054-promote-creator-advisory-routing.json",
- "task_id": "DEV-000054",
+ "task_file": "dev/tasks/DEV-000056-local-cognitive-providers.json",
+ "task_id": "DEV-000056",
"task_revision": 1
}
diff --git a/dev/tasks/DEV-000055-cognitive-registry-foundation.json b/dev/tasks/DEV-000055-cognitive-registry-foundation.json
new file mode 100644
index 0000000..2f780d0
--- /dev/null
+++ b/dev/tasks/DEV-000055-cognitive-registry-foundation.json
@@ -0,0 +1,23 @@
+{
+ "task_id": "DEV-000055",
+ "task_revision": 1,
+ "architecture_revision": "ADR-0007",
+ "base_repo_revision": "9e99a04c767833476df09f5e65016a5ad2fc47d9",
+ "risk_tier": "E",
+ "intent": "Implement the first bounded Cognitive Provider/Model Registry foundation under Capability ownership: typed provider, model and cognitive binding state; deterministic gateway selection; provider-neutral Creator routing; expanded failures; credential references; and usage observations, without adaptive routing, Ollama discovery, production activation or new authority.",
+ "requirement_ids": ["INV-OWN-001", "INV-EPI-001", "ADR-0006", "ADR-0007", "MODEL-ARCH-AUDIT-STAGE-1"],
+ "allowed_change_scope": {"modules": ["capability"], "paths": ["contracts/capability/**", "contracts/cognitive/**", "modules/capability/**", "adapters/postgres/**", "adapters/models/**", "database/bootstrap/**", "database/migrations/**", "cmd/core-runtime/**", "cmd/cognitive-worker/**", "cmd/creator-web/**", "tests/cognitive_registry/**", "tests/cognitive_advisory/**", "docs/PROJECT_STATUS.md", "dev/ACTIVE_TASK.json", "dev/tasks/DEV-000055-cognitive-registry-foundation.json"]},
+ "forbidden_change_scope": {"paths": ["architecture/**", "ci/**", ".gitea/**", "modules/identity/**", "modules/authority/**", "modules/situation/**", "modules/work/**", "modules/continuity/**", "modules/commit/**", "modules/epistemics/**", "modules/artifact/**", "deploy/**", "security/**"]},
+ "allowed_architecture_delta": {"new_cross_module_dependencies": 0, "new_canonical_owners": 0, "new_privileges": 0, "new_third_party_dependencies": 0},
+ "contracts": {"consume": ["CreatorSession", "Situation FocusBinding", "Capability owner repository", "creator-advisory-v1"], "may_change": ["contracts.capability cognitive registry types", "contracts.cognitive routing/failure/usage types"]},
+ "semantic_owner": "capability",
+ "canonical_state": ["ProviderInstance", "ModelDescriptor", "CognitiveBinding", "CognitiveUsageObservation"],
+ "state_transitions": ["provider/model qualification transitions remain independent from activation and health", "discovery never activates", "binding invocation requires current ACTIVE or explicitly eligible CANARY revision", "retired/deprecated/rejected bindings are not invocable"],
+ "side_effects_and_privileges": ["owner-local capability persistence only", "provider invocation remains non-canonical advisory", "no production credential, egress activation, automatic installation or external mutation"],
+ "persistence_and_migrations": ["typed capability.provider_instances", "typed capability.model_descriptors", "typed capability.cognitive_bindings and active heads", "prompt-free capability.cognitive_usage_observations", "capability_role remains sole writer"],
+ "failure_retry_restart": ["typed provider/model/rate/auth/budget/context/capability/timeout/refusal/invalid/degraded failures", "no automatic retry", "no active binding returns provider unavailable while deterministic Assistant remains functional", "registry persists independently of cognitive worker restart"],
+ "assumptions": ["Capability ownership of registry/bindings is explicit in Core Semantic Model and Architecture Registry", "initial selection is deterministic explicit/default policy", "OpenAI remains disabled in production", "Ollama discovery and adaptive optimization are later tasks", "docker-test remains prohibited"],
+ "acceptance_scenarios": ["Creator Web contains no OpenAI, Ollama or concrete model identifiers", "discovered but inactive provider/model cannot be invoked", "current active binding can be invoked", "retired or stale binding cannot be invoked", "rate limited remains rate limited", "no cognitive bindings preserves deterministic Assistant behavior", "persisted registry types expose only CredentialRef and never credential plaintext", "qualification activation and health are independent typed state"],
+ "required_tests": ["unit", "contract", "gateway adversarial", "migration and DB ACL", "LLM-free regression", "go test ./...", "go vet ./...", "architecture sentinel", "exact diff scope", "CI"],
+ "terminal_gap_states": ["BLOCKED_BY_ARCHITECTURE_GAP", "BLOCKED_BY_SPEC_GAP", "BLOCKED_BY_MISSING_CAPABILITY", "BLOCKED_BY_CONFLICT"]
+}
diff --git a/dev/tasks/DEV-000056-local-cognitive-providers.json b/dev/tasks/DEV-000056-local-cognitive-providers.json
new file mode 100644
index 0000000..b1c25e1
--- /dev/null
+++ b/dev/tasks/DEV-000056-local-cognitive-providers.json
@@ -0,0 +1,26 @@
+{
+ "task_id": "DEV-000056",
+ "task_revision": 1,
+ "architecture_revision": "ADR-0008",
+ "base_repo_revision": "9e99a04c767833476df09f5e65016a5ad2fc47d9",
+ "risk_tier": "E",
+ "intent": "Extend the provider-neutral Cognitive Registry foundation with bounded evaluation evidence, deterministic multi-binding routing, read-only discovery and adapters for the real unauthenticated local CPU OpenAI-compatible endpoint and opportunistic Ollama endpoint, while registering all discoveries as INACTIVE and preserving full LLM-free production behavior.",
+ "requirement_ids": ["INV-OWN-001", "INV-EPI-001", "ADR-0006", "ADR-0007", "ADR-0008", "LOCAL-COGNITIVE-PROVIDERS-STAGE-2"],
+ "allowed_change_scope": {
+ "modules": ["capability"],
+ "paths": ["architecture/adrs/ADR-0008-cognitive-evaluation-ownership.md", "contracts/capability/**", "contracts/cognitive/**", "modules/capability/**", "adapters/postgres/**", "adapters/models/**", "database/bootstrap/**", "database/migrations/**", "cmd/core-runtime/**", "cmd/cognitive-worker/**", "cmd/creator-web/**", "tests/cognitive_registry/**", "tests/cognitive_providers/**", "tests/cognitive_router/**", "tests/cognitive_advisory/**", "docs/PROJECT_STATUS.md", "docs/evidence/**", "deploy/**", "dev/ACTIVE_TASK.json", "dev/tasks/DEV-000055-cognitive-registry-foundation.json", "dev/tasks/DEV-000056-local-cognitive-providers.json"]
+ },
+ "forbidden_change_scope": {"paths": ["architecture/ARCHITECTURE_CONSTITUTION.md", "architecture/architecture-registry.yaml", "architecture/architecture-registry.json", "ci/**", ".gitea/**", "cmd/devctl/**", "modules/identity/**", "modules/authority/**", "modules/situation/**", "modules/work/**", "modules/continuity/**", "modules/commit/**", "security/**"]},
+ "allowed_architecture_delta": {"new_cross_module_dependencies": 0, "new_canonical_owners": 0, "new_privileges": 0, "new_third_party_dependencies": 0, "new_provider_adapters": 2},
+ "contracts": {"consume": ["CreatorSession", "Situation FocusBinding", "contracts.artifact ArtifactID", "Capability cognitive registry", "creator-advisory-v1"], "may_change": ["contracts.capability cognitive evaluation, discovery, health and routing types", "contracts.cognitive provider-neutral routing and usage types"]},
+ "semantic_owner": "capability",
+ "canonical_state": ["ProviderInstance revisions", "ModelDescriptor revisions", "CognitiveBinding revisions", "EvaluatedCapability", "PerformanceEvidenceReference", "CognitiveUsageObservation"],
+ "state_transitions": ["discovery appends DISCOVERED and INACTIVE records only", "model digest change creates a new immutable descriptor revision", "health observations may move UNKNOWN AVAILABLE DEGRADED UNAVAILABLE without changing activation", "only explicit later promotion may move EVALUATING VALIDATED CANARY ACTIVE"],
+ "side_effects_and_privileges": ["read-only HTTP probes and inventory discovery against the two named local endpoints", "owner-local Capability registration through Core", "no model download deletion activation or paid OpenAI request", "no Commit Executor credential or canonical mutation authority for models"],
+ "persistence_and_migrations": ["Capability-owned typed discovery and evaluation tables", "ArtifactRef for immutable benchmark provenance", "no cross-owner FK JOIN write", "capability_role remains sole database writer"],
+ "failure_retry_restart": ["bounded HTTP timeout and no automatic retry loops", "provider loss maps to typed cognitive failure", "discovery is idempotent", "startup never depends on either provider", "no active binding preserves deterministic behavior"],
+ "assumptions": ["DEV-000055 candidate changes are the immediate foundation for this task", "the CPU endpoint is intentionally unauthenticated", "the Ollama endpoint is opportunistic", "docker-test remains prohibited", "all discovered local models remain INACTIVE"],
+ "acceptance_scenarios": ["A-T from the attached local cognitive provider task", "Creator Web remains free of provider and model identifiers", "OpenAI remains credential-free and inactive", "GPU benchmark evidence is imported only through a typed artifact-referenced boundary"],
+ "required_tests": ["unit", "provider adapter fake transport", "live read-only discovery", "router", "health loss and recovery", "idempotency", "DB ownership", "LLM-free regression", "go test ./...", "go vet ./...", "architecture sentinel", "exact diff scope"],
+ "terminal_gap_states": ["BLOCKED_BY_ARCHITECTURE_GAP", "BLOCKED_BY_SPEC_GAP", "BLOCKED_BY_MISSING_CAPABILITY", "BLOCKED_BY_CONFLICT"]
+}
diff --git a/docs/PROJECT_STATUS.md b/docs/PROJECT_STATUS.md
index 27a3ec5..4d1521d 100644
--- a/docs/PROJECT_STATUS.md
+++ b/docs/PROJECT_STATUS.md
@@ -1,6 +1,15 @@
# Assistant project status
-Audit date: 2026-08-16. Active implementation: DEV-000053 revision 1.
+Audit date: 2026-08-17. Active implementation: DEV-000056 revision 1.
+
+## Current milestone
+
+**Provider-neutral Cognitive Architecture + Local AI integration.**
+
+- Docker production baseline at `9e99a04c…` is completed and healthy.
+- The OpenAI integration is a bootstrap adapter only. Real OpenAI credentials and production traffic are intentionally deferred.
+- The current milestone integrates one normally available local CPU provider and one opportunistic local Ollama/GPU provider through typed discovery, health and routing boundaries.
+- Discovery never activates a provider, model or binding. Until a later benchmark and explicit promotion task, all discovered bindings remain `INACTIVE` and production remains fully LLM-free.
## Delivered
@@ -20,7 +29,7 @@ Audit date: 2026-08-16. Active implementation: DEV-000053 revision 1.
## Remaining work requiring a new task decision
-1. **Cognitive provider:** the cognitive worker intentionally remains the deterministic fake. Selecting a real model/provider, data policy and allowed proposal contract requires a separate capability/architecture decision; it must not gain canonical mutation authority.
+1. **Cognitive qualification and promotion:** DEV-000056 discovers and registers local providers/models without activation. A later benchmark decision must establish demonstrated capabilities and explicitly promote exact binding revisions through `EVALUATING → VALIDATED → CANARY → ACTIVE`.
2. **Product breadth:** notification delivery is the only accepted real external operation. Any additional operation needs its own proposal, authority model, idempotency/reconciliation semantics and Capability binding.
3. **Artifact and Epistemics product behavior:** their ownership boundaries exist, but no product task has yet specified durable user-facing workflows for them.
diff --git a/docs/evidence/gpu-sustained-benchmark-2026-08-17-v1.json b/docs/evidence/gpu-sustained-benchmark-2026-08-17-v1.json
new file mode 100644
index 0000000..bad0a2f
--- /dev/null
+++ b/docs/evidence/gpu-sustained-benchmark-2026-08-17-v1.json
@@ -0,0 +1,39 @@
+{
+ "artifact_id": "gpu-sustained-benchmark-2026-08-17-v1",
+ "artifact_version": 1,
+ "source": "user-provided sustained benchmark",
+ "observed_at": "2026-08-17T00:00:00+03:00",
+ "hardware_profile": "NVIDIA RTX 4090 24 GB VRAM",
+ "runtime": "Ollama",
+ "settings": {
+ "temperature": 0,
+ "seed": 42,
+ "context_units": 4096,
+ "thinking_enabled": false
+ },
+ "results": [
+ {
+ "provider_model_id": "qwen3:30b",
+ "parameter_size": "30.5B",
+ "quantization": "Q4_K_M",
+ "memory_bytes": 18870000000,
+ "generation_tps": [
+ {"output_units": 128, "median": 224.99},
+ {"output_units": 512, "median": 219.40},
+ {"output_units": 1024, "median": 208.43}
+ ]
+ },
+ {
+ "provider_model_id": "gemma4:26b",
+ "parameter_size": "25.8B",
+ "quantization": "Q4_K_M",
+ "memory_bytes": 17350000000,
+ "generation_tps": [
+ {"output_units": 128, "median": 168.10},
+ {"output_units": 512, "median": 165.54},
+ {"output_units": 1024, "median": 164.12}
+ ]
+ }
+ ],
+ "interpretation": "performance evidence only; no quality or activation conclusion"
+}
diff --git a/modules/capability/domain/cognitive_registry.go b/modules/capability/domain/cognitive_registry.go
new file mode 100644
index 0000000..5e34dfe
--- /dev/null
+++ b/modules/capability/domain/cognitive_registry.go
@@ -0,0 +1,201 @@
+package domain
+
+import (
+ "crypto/sha256"
+ "encoding/binary"
+ "encoding/hex"
+ "errors"
+ "fmt"
+ "slices"
+ "sort"
+
+ "git.cin.su/m/Assistant/contracts/capability"
+)
+
+var ErrInvalidCognitiveRegistryRecord = errors.New("invalid cognitive registry record")
+var ErrNoInvocableCognitiveBinding = errors.New("no invocable cognitive binding")
+
+func BuildDiscoveryRegistration(snapshot capability.CognitiveDiscoverySnapshot) (capability.CognitiveDiscoveryRegistration, error) {
+ if snapshot.ProviderInstanceID == "" || snapshot.ProviderKind == "" || snapshot.EndpointRef == "" || snapshot.OwnerPrincipalID == "" || snapshot.CapabilityID == "" || snapshot.LimitPolicyRef == "" || snapshot.ObservedAtUnixMillis < 1 || !validHealth(snapshot.Health) {
+ return capability.CognitiveDiscoveryRegistration{}, ErrInvalidCognitiveRegistryRecord
+ }
+ providerRevision := stableRevision(string(snapshot.ProviderKind), string(snapshot.EndpointRef), string(snapshot.CredentialRef), fmt.Sprint(snapshot.Enabled))
+ provider := capability.ProviderInstance{ID: snapshot.ProviderInstanceID, Revision: providerRevision, Kind: snapshot.ProviderKind, EndpointRef: snapshot.EndpointRef, CredentialRef: snapshot.CredentialRef, Enabled: snapshot.Enabled, Qualification: capability.QualificationDiscovered, Health: capability.HealthUnknown, ObservedAtUnixMillis: snapshot.ObservedAtUnixMillis}
+ registration := capability.CognitiveDiscoveryRegistration{Provider: provider, ProviderHealth: capability.ProviderHealthObservation{ProviderInstanceID: provider.ID, Health: snapshot.Health, ObservedAtUnixMillis: snapshot.ObservedAtUnixMillis, FailureClass: snapshot.FailureClass}}
+ for _, discovered := range snapshot.Models {
+ if discovered.ProviderModelID == "" || discovered.MaxContextBytes < 0 || len(discovered.Modalities) == 0 || len(discovered.Capabilities) == 0 || !validOperational(discovered.Installed) || !validOperational(discovered.Loaded) || !validOperational(discovered.Invokable) {
+ return capability.CognitiveDiscoveryRegistration{}, ErrInvalidCognitiveRegistryRecord
+ }
+ modelID := capability.ModelDescriptorID(stableID("model", string(snapshot.ProviderInstanceID), string(discovered.ProviderModelID)))
+ modelRevision := stableRevision(string(discovered.Fingerprint), fmt.Sprint(discovered.MaxContextBytes), fmt.Sprint(discovered.Modalities), fmt.Sprint(discovered.Capabilities))
+ model := capability.ModelDescriptor{ID: modelID, Revision: modelRevision, ProviderInstanceID: provider.ID, ProviderModelID: discovered.ProviderModelID, Fingerprint: discovered.Fingerprint, MaxContextBytes: discovered.MaxContextBytes, Modalities: append([]capability.ModelModality(nil), discovered.Modalities...), Capabilities: append([]capability.ModelCapability(nil), discovered.Capabilities...), Qualification: capability.QualificationDiscovered, Health: capability.HealthUnknown, ObservedAtUnixMillis: snapshot.ObservedAtUnixMillis}
+ bindingID := capability.CapabilityBindingID(stableID("binding", string(snapshot.OwnerPrincipalID), string(snapshot.CapabilityID), string(provider.ID), string(model.ID)))
+ bindingRevision := stableRevision(fmt.Sprint(provider.Revision), fmt.Sprint(model.Revision), string(snapshot.DataPolicy), string(snapshot.LimitPolicyRef))
+ binding := capability.CognitiveBinding{ID: bindingID, Revision: bindingRevision, CapabilityID: snapshot.CapabilityID, OwnerPrincipalID: snapshot.OwnerPrincipalID, ProviderInstanceID: provider.ID, ProviderRevision: provider.Revision, ModelDescriptorID: model.ID, ModelRevision: model.Revision, DataPolicy: snapshot.DataPolicy, Qualification: capability.QualificationDiscovered, Activation: capability.ActivationInactive, Health: capability.HealthUnknown, LimitPolicyRef: snapshot.LimitPolicyRef}
+ registration.Models = append(registration.Models, model)
+ registration.Bindings = append(registration.Bindings, binding)
+ registration.ModelAvailability = append(registration.ModelAvailability, capability.ModelOperationalObservation{ProviderInstanceID: provider.ID, ModelDescriptorID: model.ID, Installed: discovered.Installed, Loaded: discovered.Loaded, Invokable: discovered.Invokable, Health: snapshot.Health, ObservedAtUnixMillis: snapshot.ObservedAtUnixMillis})
+ }
+ return registration, nil
+}
+
+func stableID(kind string, parts ...string) string {
+ hash := sha256.New()
+ _, _ = hash.Write([]byte(kind))
+ for _, part := range parts {
+ _, _ = hash.Write([]byte{0})
+ _, _ = hash.Write([]byte(part))
+ }
+ return kind + "-" + hex.EncodeToString(hash.Sum(nil))[:24]
+}
+
+func stableRevision(parts ...string) int64 {
+ hash := sha256.New()
+ for _, part := range parts {
+ _, _ = hash.Write([]byte{0})
+ _, _ = hash.Write([]byte(part))
+ }
+ return int64(binary.BigEndian.Uint64(hash.Sum(nil)[:8])&0x3fffffffffffffff) + 1
+}
+
+func ValidateProviderInstance(value capability.ProviderInstance) error {
+ if value.ID == "" || value.Revision < 1 || value.Kind == "" || value.EndpointRef == "" || !validQualification(value.Qualification) || !validHealth(value.Health) || value.ObservedAtUnixMillis < 1 {
+ return ErrInvalidCognitiveRegistryRecord
+ }
+ return nil
+}
+
+func ValidateModelDescriptor(value capability.ModelDescriptor) error {
+ if value.ID == "" || value.Revision < 1 || value.ProviderInstanceID == "" || value.ProviderModelID == "" || value.MaxContextBytes < 0 || len(value.Modalities) == 0 || len(value.Capabilities) == 0 || !validQualification(value.Qualification) || !validHealth(value.Health) || value.ObservedAtUnixMillis < 1 {
+ return ErrInvalidCognitiveRegistryRecord
+ }
+ return nil
+}
+
+func ValidateCognitiveBinding(value capability.CognitiveBinding) error {
+ if value.ID == "" || value.Revision < 1 || value.CapabilityID == "" || value.OwnerPrincipalID == "" || value.ProviderInstanceID == "" || value.ProviderRevision < 1 || value.ModelDescriptorID == "" || value.ModelRevision < 1 || value.LimitPolicyRef == "" || !validQualification(value.Qualification) || !validActivation(value.Activation) || !validHealth(value.Health) {
+ return ErrInvalidCognitiveRegistryRecord
+ }
+ switch value.DataPolicy {
+ case capability.DataPolicyLocalOnly, capability.DataPolicyExternalMessageOnly, capability.DataPolicyExternalMinimizedContext:
+ return nil
+ default:
+ return ErrInvalidCognitiveRegistryRecord
+ }
+}
+
+func SelectCognitiveBinding(requirement capability.CognitiveRequirement, candidates []capability.ResolvedCognitiveBinding) (capability.ResolvedCognitiveBinding, error) {
+ eligible := make([]capability.ResolvedCognitiveBinding, 0, len(candidates))
+ for _, candidate := range candidates {
+ binding, provider, model := candidate.Binding, candidate.Provider, candidate.Model
+ if slices.Contains(requirement.ExcludedBindingIDs, binding.ID) {
+ continue
+ }
+ if ValidateCognitiveBinding(binding) != nil || ValidateProviderInstance(provider) != nil || ValidateModelDescriptor(model) != nil {
+ continue
+ }
+ if binding.CapabilityID != requirement.CapabilityID || binding.OwnerPrincipalID != requirement.OwnerPrincipalID || !dataPolicySatisfies(binding.DataPolicy, requirement.DataPolicy) || binding.Qualification != capability.QualificationValidated || binding.Health != capability.HealthAvailable || !provider.Enabled || provider.Qualification != capability.QualificationValidated || provider.Health != capability.HealthAvailable || model.Qualification != capability.QualificationValidated || model.Health != capability.HealthAvailable {
+ continue
+ }
+ if binding.ProviderInstanceID != provider.ID || binding.ProviderRevision != provider.Revision || binding.ModelDescriptorID != model.ID || binding.ModelRevision != model.Revision || model.ProviderInstanceID != provider.ID || requirement.InputBytes+requirement.MaxOutputBytes > model.MaxContextBytes {
+ continue
+ }
+ if binding.Activation != capability.ActivationActive && !(requirement.AllowCanary && binding.Activation == capability.ActivationCanary) {
+ continue
+ }
+ if !containsAll(model.Modalities, requirement.RequiredModalities) || !supportsCapabilities(candidate, requirement.RequiredCapabilities) {
+ continue
+ }
+ if candidate.Evaluation != nil && candidate.Evaluation.Result == capability.EvaluationUnsupported {
+ continue
+ }
+ eligible = append(eligible, candidate)
+ }
+ if len(eligible) > 0 {
+ sort.SliceStable(eligible, func(i, j int) bool { return betterCandidate(eligible[i], eligible[j]) })
+ return eligible[0], nil
+ }
+ return capability.ResolvedCognitiveBinding{}, ErrNoInvocableCognitiveBinding
+}
+
+func dataPolicySatisfies(actual, allowed capability.DataPolicy) bool {
+ return actual == capability.DataPolicyLocalOnly || actual == allowed
+}
+
+func supportsCapabilities(candidate capability.ResolvedCognitiveBinding, required []capability.ModelCapability) bool {
+ for _, item := range required {
+ if slices.Contains(candidate.Model.Capabilities, item) {
+ continue
+ }
+ if candidate.Evaluation == nil || candidate.Evaluation.CapabilityID != candidate.Binding.CapabilityID || candidate.Evaluation.Result != capability.EvaluationSupported {
+ return false
+ }
+ }
+ return true
+}
+
+func betterCandidate(left, right capability.ResolvedCognitiveBinding) bool {
+ le, re := left.Evaluation, right.Evaluation
+ if le != nil && le.Result == capability.EvaluationSupported && (re == nil || re.Result != capability.EvaluationSupported) {
+ return true
+ }
+ if re != nil && re.Result == capability.EvaluationSupported && (le == nil || le.Result != capability.EvaluationSupported) {
+ return false
+ }
+ if le != nil && re != nil && le.QualityScoreMillis != nil && re.QualityScoreMillis != nil && *le.QualityScoreMillis != *re.QualityScoreMillis {
+ return *le.QualityScoreMillis > *re.QualityScoreMillis
+ }
+ if le != nil && re != nil && le.CriticalFailureMillis != nil && re.CriticalFailureMillis != nil && *le.CriticalFailureMillis != *re.CriticalFailureMillis {
+ return *le.CriticalFailureMillis < *re.CriticalFailureMillis
+ }
+ lp, rp := left.Performance, right.Performance
+ if lp != nil && rp != nil && lp.ReliabilityMillis != nil && rp.ReliabilityMillis != nil && *lp.ReliabilityMillis != *rp.ReliabilityMillis {
+ return *lp.ReliabilityMillis > *rp.ReliabilityMillis
+ }
+ if lp != nil && rp != nil && lp.LatencyMicros != nil && rp.LatencyMicros != nil && *lp.LatencyMicros != *rp.LatencyMicros {
+ return *lp.LatencyMicros < *rp.LatencyMicros
+ }
+ if lp != nil && rp != nil && lp.GenerationTPSMillis != nil && rp.GenerationTPSMillis != nil && *lp.GenerationTPSMillis != *rp.GenerationTPSMillis {
+ return *lp.GenerationTPSMillis > *rp.GenerationTPSMillis
+ }
+ return string(left.Binding.ID) < string(right.Binding.ID)
+}
+
+func containsAll[T comparable](actual, required []T) bool {
+ for _, item := range required {
+ if !slices.Contains(actual, item) {
+ return false
+ }
+ }
+ return true
+}
+
+func validQualification(value capability.QualificationState) bool {
+ switch value {
+ case capability.QualificationDiscovered, capability.QualificationProbing, capability.QualificationEvaluating, capability.QualificationValidated, capability.QualificationRejected:
+ return true
+ }
+ return false
+}
+func validActivation(value capability.ActivationState) bool {
+ switch value {
+ case capability.ActivationInactive, capability.ActivationCanary, capability.ActivationActive, capability.ActivationDeprecated, capability.ActivationRetired:
+ return true
+ }
+ return false
+}
+func validHealth(value capability.HealthState) bool {
+ switch value {
+ case capability.HealthUnknown, capability.HealthAvailable, capability.HealthDegraded, capability.HealthUnavailable:
+ return true
+ }
+ return false
+}
+
+func validOperational(value capability.OperationalState) bool {
+ switch value {
+ case capability.OperationalNotObserved, capability.OperationalYes, capability.OperationalNo:
+ return true
+ }
+ return false
+}
diff --git a/modules/capability/ports/repository.go b/modules/capability/ports/repository.go
index 3b2aa12..aed2006 100644
--- a/modules/capability/ports/repository.go
+++ b/modules/capability/ports/repository.go
@@ -14,4 +14,12 @@ type Repository interface {
SaveBinding(context.Context, capability.Binding) error
LoadBinding(context.Context, capability.CapabilityBindingID, int64) (capability.Binding, error)
LoadActiveBinding(context.Context, capability.CapabilityID, identity.PrincipalID) (capability.Binding, error)
+ SaveProviderInstance(context.Context, capability.ProviderInstance) error
+ SaveModelDescriptor(context.Context, capability.ModelDescriptor) error
+ SaveCognitiveBinding(context.Context, capability.CognitiveBinding) error
+ LoadCognitiveCandidates(context.Context, capability.CapabilityID, identity.PrincipalID) ([]capability.ResolvedCognitiveBinding, error)
+ SaveCognitiveUsageObservation(context.Context, capability.CognitiveUsageObservation) error
+ SaveCognitiveDiscovery(context.Context, capability.CognitiveDiscoveryRegistration) error
+ SaveEvaluatedCapability(context.Context, capability.EvaluatedCapability) error
+ SavePerformanceEvidence(context.Context, capability.PerformanceEvidence) error
}
diff --git a/tests/cognitive_providers/live_test.go b/tests/cognitive_providers/live_test.go
new file mode 100644
index 0000000..9b8d8f0
--- /dev/null
+++ b/tests/cognitive_providers/live_test.go
@@ -0,0 +1,37 @@
+package cognitive_providers_test
+
+import (
+ "context"
+ "os"
+ "testing"
+ "time"
+
+ "git.cin.su/m/Assistant/adapters/models"
+ "git.cin.su/m/Assistant/contracts/capability"
+)
+
+func TestLiveReadOnlyDiscovery(t *testing.T) {
+ if os.Getenv("ASSISTANT_LIVE_LOCAL_DISCOVERY") != "1" {
+ t.Skip("set ASSISTANT_LIVE_LOCAL_DISCOVERY=1 for read-only local provider probes")
+ }
+ ctx, cancel := context.WithTimeout(context.Background(), 15*time.Second)
+ defer cancel()
+ cpu, err := models.NewOpenAICompatibleLocalAdapter("http://docker.cin.su:18082/v1", nil)
+ if err != nil {
+ t.Fatal(err)
+ }
+ cpuModels, cpuProbe := cpu.Discover(ctx)
+ if cpuProbe.Health != capability.HealthAvailable || len(cpuModels) == 0 {
+ t.Fatalf("CPU probe=%+v models=%+v", cpuProbe, cpuModels)
+ }
+ t.Logf("CPU probe=%+v models=%+v", cpuProbe, cpuModels)
+ gpu, err := models.NewOllamaAdapter("http://192.168.220.91:11434", nil)
+ if err != nil {
+ t.Fatal(err)
+ }
+ gpuModels, gpuProbe := gpu.Discover(ctx)
+ if gpuProbe.Health != capability.HealthAvailable || len(gpuModels) == 0 {
+ t.Fatalf("GPU probe=%+v models=%+v", gpuProbe, gpuModels)
+ }
+ t.Logf("GPU probe=%+v models=%+v", gpuProbe, gpuModels)
+}
diff --git a/tests/cognitive_providers/providers_test.go b/tests/cognitive_providers/providers_test.go
new file mode 100644
index 0000000..41a3752
--- /dev/null
+++ b/tests/cognitive_providers/providers_test.go
@@ -0,0 +1,86 @@
+package cognitive_providers_test
+
+import (
+ "context"
+ "io"
+ "net/http"
+ "net/http/httptest"
+ "strings"
+ "testing"
+
+ "git.cin.su/m/Assistant/adapters/models"
+ "git.cin.su/m/Assistant/contracts/capability"
+ capabilitydomain "git.cin.su/m/Assistant/modules/capability/domain"
+)
+
+func TestCPUDiscoveryIsReadOnlyAndCredentialFree(t *testing.T) {
+ requests := 0
+ server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+ requests++
+ if r.Method != http.MethodGet || r.URL.Path != "/v1/models" || r.Header.Get("Authorization") != "" {
+ t.Fatalf("unexpected request %s %s auth=%q", r.Method, r.URL.Path, r.Header.Get("Authorization"))
+ }
+ _, _ = io.WriteString(w, `{"data":[{"id":"same-name","created":1,"owned_by":"local","meta":{"n_ctx":2048,"n_params":3,"size":10,"ftype":"Q4"}}]}`)
+ }))
+ defer server.Close()
+ adapter, err := models.NewOpenAICompatibleLocalAdapter(server.URL+"/v1", nil)
+ if err != nil {
+ t.Fatal(err)
+ }
+ discovered, probe := adapter.Discover(context.Background())
+ if probe.Health != capability.HealthAvailable || len(discovered) != 1 || requests != 1 {
+ t.Fatalf("probe=%+v models=%+v requests=%d", probe, discovered, requests)
+ }
+}
+
+func TestOllamaDiscoveryDoesNotRunInference(t *testing.T) {
+ paths := []string{}
+ server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+ paths = append(paths, r.URL.Path)
+ switch r.URL.Path {
+ case "/api/version":
+ _, _ = io.WriteString(w, `{"version":"1.2.3"}`)
+ case "/api/tags":
+ _, _ = io.WriteString(w, `{"models":[{"name":"same-name","model":"same-name","size":20,"digest":"digest-a","details":{"format":"gguf","quantization_level":"Q4","context_length":4096},"capabilities":["completion"]}]}`)
+ default:
+ t.Fatalf("unexpected expensive endpoint %s", r.URL.Path)
+ }
+ }))
+ defer server.Close()
+ adapter, err := models.NewOllamaAdapter(server.URL, nil)
+ if err != nil {
+ t.Fatal(err)
+ }
+ discovered, probe := adapter.Discover(context.Background())
+ if probe.Health != capability.HealthAvailable || len(discovered) != 1 || strings.Join(paths, ",") != "/api/version,/api/tags" {
+ t.Fatalf("probe=%+v models=%+v paths=%v", probe, discovered, paths)
+ }
+}
+
+func TestDiscoveryIsIdempotentAndProviderScoped(t *testing.T) {
+ base := capability.CognitiveDiscoverySnapshot{ProviderInstanceID: "cpu", ProviderKind: "kind", EndpointRef: "endpoint", Enabled: true, OwnerPrincipalID: "owner", CapabilityID: "creator-advisory", DataPolicy: capability.DataPolicyLocalOnly, LimitPolicyRef: "limits", Health: capability.HealthAvailable, ObservedAtUnixMillis: 1, Models: []capability.DiscoveredModelSnapshot{{ProviderModelID: "same-name", Fingerprint: "digest-a", MaxContextBytes: 100, Modalities: []capability.ModelModality{capability.ModalityText}, Capabilities: []capability.ModelCapability{capability.CapabilityUnknown}, Installed: capability.OperationalYes, Loaded: capability.OperationalNotObserved, Invokable: capability.OperationalNotObserved}}}
+ first, err := capabilitydomain.BuildDiscoveryRegistration(base)
+ if err != nil {
+ t.Fatal(err)
+ }
+ second, err := capabilitydomain.BuildDiscoveryRegistration(base)
+ if err != nil {
+ t.Fatal(err)
+ }
+ if first.Models[0].ID != second.Models[0].ID || first.Models[0].Revision != second.Models[0].Revision || first.Bindings[0].Activation != capability.ActivationInactive {
+ t.Fatalf("discovery not idempotent/inactive: %+v %+v", first, second)
+ }
+ gpu := base
+ gpu.ProviderInstanceID = "gpu"
+ other, _ := capabilitydomain.BuildDiscoveryRegistration(gpu)
+ if first.Models[0].ID == other.Models[0].ID {
+ t.Fatal("same model name collided across providers")
+ }
+ changed := base
+ changed.Models = append([]capability.DiscoveredModelSnapshot(nil), base.Models...)
+ changed.Models[0].Fingerprint = "digest-b"
+ revision, _ := capabilitydomain.BuildDiscoveryRegistration(changed)
+ if revision.Models[0].Revision == first.Models[0].Revision {
+ t.Fatal("digest change silently reused revision")
+ }
+}
diff --git a/tests/cognitive_registry/registry_test.go b/tests/cognitive_registry/registry_test.go
new file mode 100644
index 0000000..2e11fa6
--- /dev/null
+++ b/tests/cognitive_registry/registry_test.go
@@ -0,0 +1,147 @@
+package cognitive_registry_test
+
+import (
+ "os"
+ "path/filepath"
+ "strings"
+ "testing"
+
+ "git.cin.su/m/Assistant/contracts/capability"
+ capabilitydomain "git.cin.su/m/Assistant/modules/capability/domain"
+)
+
+func validCandidate() capability.ResolvedCognitiveBinding {
+ return capability.ResolvedCognitiveBinding{
+ Binding: capability.CognitiveBinding{ID: "binding-1", Revision: 3, CapabilityID: "creator-advisory", OwnerPrincipalID: "principal-1", ProviderInstanceID: "provider-1", ProviderRevision: 2, ModelDescriptorID: "model-1", ModelRevision: 4, DataPolicy: capability.DataPolicyExternalMessageOnly, Qualification: capability.QualificationValidated, Activation: capability.ActivationActive, Health: capability.HealthAvailable, LimitPolicyRef: "limits-1"},
+ Provider: capability.ProviderInstance{ID: "provider-1", Revision: 2, Kind: "external-responses-v1", EndpointRef: "endpoint-1", CredentialRef: "credential-1", Enabled: true, Qualification: capability.QualificationValidated, Health: capability.HealthAvailable, ObservedAtUnixMillis: 1},
+ Model: capability.ModelDescriptor{ID: "model-1", Revision: 4, ProviderInstanceID: "provider-1", ProviderModelID: "snapshot-1", Fingerprint: "fingerprint-1", MaxContextBytes: 32768, Modalities: []capability.ModelModality{capability.ModalityText}, Capabilities: []capability.ModelCapability{capability.CapabilityAdvisory}, Qualification: capability.QualificationValidated, Health: capability.HealthAvailable, ObservedAtUnixMillis: 1},
+ }
+}
+
+func requirement() capability.CognitiveRequirement {
+ return capability.CognitiveRequirement{CapabilityID: "creator-advisory", OwnerPrincipalID: "principal-1", DataPolicy: capability.DataPolicyExternalMessageOnly, RequiredModalities: []capability.ModelModality{capability.ModalityText}, RequiredCapabilities: []capability.ModelCapability{capability.CapabilityAdvisory}, InputBytes: 100, MaxOutputBytes: 1000}
+}
+
+func TestRegisteredButDisabledProviderCannotBeInvoked(t *testing.T) {
+ candidate := validCandidate()
+ candidate.Provider.Enabled = false
+ if _, err := capabilitydomain.SelectCognitiveBinding(requirement(), []capability.ResolvedCognitiveBinding{candidate}); err == nil {
+ t.Fatal("disabled provider was selected")
+ }
+}
+
+func TestDiscoveredInactiveBindingCannotBeInvoked(t *testing.T) {
+ candidate := validCandidate()
+ candidate.Binding.Qualification = capability.QualificationDiscovered
+ candidate.Binding.Activation = capability.ActivationInactive
+ if _, err := capabilitydomain.SelectCognitiveBinding(requirement(), []capability.ResolvedCognitiveBinding{candidate}); err == nil {
+ t.Fatal("discovered inactive binding was selected")
+ }
+}
+
+func TestValidatedActiveBindingCanBeSelected(t *testing.T) {
+ selected, err := capabilitydomain.SelectCognitiveBinding(requirement(), []capability.ResolvedCognitiveBinding{validCandidate()})
+ if err != nil || selected.Binding.ID != "binding-1" {
+ t.Fatalf("selected=%+v err=%v", selected, err)
+ }
+}
+
+func TestRetiredBindingCannotBeInvoked(t *testing.T) {
+ candidate := validCandidate()
+ candidate.Binding.Activation = capability.ActivationRetired
+ if _, err := capabilitydomain.SelectCognitiveBinding(requirement(), []capability.ResolvedCognitiveBinding{candidate}); err == nil {
+ t.Fatal("retired binding was selected")
+ }
+}
+
+func TestHealthTransitionsChangeEligibility(t *testing.T) {
+ for _, state := range []capability.HealthState{capability.HealthUnknown, capability.HealthDegraded, capability.HealthUnavailable} {
+ candidate := validCandidate()
+ candidate.Binding.Health = state
+ if _, err := capabilitydomain.SelectCognitiveBinding(requirement(), []capability.ResolvedCognitiveBinding{candidate}); err == nil {
+ t.Fatalf("binding health %s was selected", state)
+ }
+ }
+ if _, err := capabilitydomain.SelectCognitiveBinding(requirement(), []capability.ResolvedCognitiveBinding{validCandidate()}); err != nil {
+ t.Fatalf("available binding rejected: %v", err)
+ }
+}
+
+func TestCreatorWebHasNoConcreteProviderModelOrBindingSelection(t *testing.T) {
+ root := filepath.Clean(filepath.Join("..", "..", "cmd", "creator-web"))
+ err := filepath.WalkDir(root, func(path string, entry os.DirEntry, err error) error {
+ if err != nil || entry.IsDir() || strings.HasSuffix(path, "_test.go") {
+ return err
+ }
+ contents, readErr := os.ReadFile(path)
+ if readErr != nil {
+ return readErr
+ }
+ lower := strings.ToLower(string(contents))
+ for _, forbidden := range []string{"openai", "ollama", "providerbindingid", "advisory_binding_mode", "gpt-"} {
+ if strings.Contains(lower, forbidden) {
+ t.Errorf("%s contains concrete selection token %q", path, forbidden)
+ }
+ }
+ return nil
+ })
+ if err != nil {
+ t.Fatal(err)
+ }
+}
+
+func TestRegistryPersistenceContainsReferencesNotCredentialMaterial(t *testing.T) {
+ for _, path := range []string{filepath.Join("..", "..", "database", "migrations", "012_capability_cognitive_registry.sql"), filepath.Join("..", "..", "contracts", "capability", "cognitive_registry.go")} {
+ contents, err := os.ReadFile(path)
+ if err != nil {
+ t.Fatal(err)
+ }
+ lower := strings.ToLower(string(contents))
+ if !strings.Contains(lower, "credentialref") && !strings.Contains(lower, "credential_ref") {
+ t.Fatalf("%s lacks credential reference", path)
+ }
+ for _, forbidden := range []string{"api_key", "access_token", "credential_bytes", "plaintext_password"} {
+ if strings.Contains(lower, forbidden) {
+ t.Fatalf("%s stores forbidden credential material field %q", path, forbidden)
+ }
+ }
+ }
+}
+
+func TestMigrationUsesOnlyCapabilityOwnerRoleAndSchema(t *testing.T) {
+ path := filepath.Join("..", "..", "database", "migrations", "012_capability_cognitive_registry.sql")
+ contents, err := os.ReadFile(path)
+ if err != nil {
+ t.Fatal(err)
+ }
+ lower := strings.ToLower(string(contents))
+ if strings.Count(lower, "set role capability_role") != 1 {
+ t.Fatal("migration must execute under capability_role")
+ }
+ for _, schema := range []string{"authority.", "commit.", "continuity.", "identity.", "situation.", "work."} {
+ if strings.Contains(lower, schema) {
+ t.Fatalf("migration touches foreign owner schema %s", schema)
+ }
+ }
+}
+
+func TestAuthorityAndCommitRemainCognitiveIndependent(t *testing.T) {
+ for _, directory := range []string{"authority", "commit"} {
+ for _, parent := range []string{"contracts", "modules"} {
+ root := filepath.Join("..", "..", parent, directory)
+ _ = filepath.WalkDir(root, func(path string, entry os.DirEntry, err error) error {
+ if err != nil || entry.IsDir() {
+ return err
+ }
+ contents, readErr := os.ReadFile(path)
+ if readErr != nil {
+ return readErr
+ }
+ if strings.Contains(string(contents), "contracts/cognitive") || strings.Contains(string(contents), "cognitive_registry") {
+ t.Errorf("%s depends on cognitive registry", path)
+ }
+ return nil
+ })
+ }
+ }
+}
diff --git a/tests/cognitive_router/router_test.go b/tests/cognitive_router/router_test.go
new file mode 100644
index 0000000..3b911f9
--- /dev/null
+++ b/tests/cognitive_router/router_test.go
@@ -0,0 +1,46 @@
+package cognitive_router_test
+
+import (
+ "testing"
+
+ "git.cin.su/m/Assistant/contracts/capability"
+ capabilitydomain "git.cin.su/m/Assistant/modules/capability/domain"
+)
+
+func candidate(id string, health capability.HealthState) capability.ResolvedCognitiveBinding {
+ return capability.ResolvedCognitiveBinding{Binding: capability.CognitiveBinding{ID: capability.CapabilityBindingID(id), Revision: 1, CapabilityID: "creator-advisory", OwnerPrincipalID: "owner", ProviderInstanceID: capability.ProviderInstanceID("provider-" + id), ProviderRevision: 1, ModelDescriptorID: capability.ModelDescriptorID("model-" + id), ModelRevision: 1, DataPolicy: capability.DataPolicyLocalOnly, Qualification: capability.QualificationValidated, Activation: capability.ActivationActive, Health: capability.HealthAvailable, LimitPolicyRef: "limits"}, Provider: capability.ProviderInstance{ID: capability.ProviderInstanceID("provider-" + id), Revision: 1, Kind: "kind", EndpointRef: capability.EndpointBindingRef("endpoint-" + id), Enabled: true, Qualification: capability.QualificationValidated, Health: health, ObservedAtUnixMillis: 1}, Model: capability.ModelDescriptor{ID: capability.ModelDescriptorID("model-" + id), Revision: 1, ProviderInstanceID: capability.ProviderInstanceID("provider-" + id), ProviderModelID: "snapshot", Fingerprint: "digest", MaxContextBytes: 10000, Modalities: []capability.ModelModality{capability.ModalityText}, Capabilities: []capability.ModelCapability{capability.CapabilityAdvisory}, Qualification: capability.QualificationValidated, Health: capability.HealthAvailable, ObservedAtUnixMillis: 1}}
+}
+
+func requirement() capability.CognitiveRequirement {
+ return capability.CognitiveRequirement{CapabilityID: "creator-advisory", OwnerPrincipalID: "owner", DataPolicy: capability.DataPolicyExternalMessageOnly, RequiredModalities: []capability.ModelModality{capability.ModalityText}, RequiredCapabilities: []capability.ModelCapability{capability.CapabilityAdvisory}, InputBytes: 10, MaxOutputBytes: 100}
+}
+
+func TestUnavailableGPUFallsBackToCPU(t *testing.T) {
+ gpu := candidate("gpu", capability.HealthUnavailable)
+ cpu := candidate("cpu", capability.HealthAvailable)
+ selected, err := capabilitydomain.SelectCognitiveBinding(requirement(), []capability.ResolvedCognitiveBinding{gpu, cpu})
+ if err != nil || selected.Binding.ID != "cpu" {
+ t.Fatalf("selected=%+v err=%v", selected, err)
+ }
+}
+
+func TestObservedQualityRanksOnlyComparableEvidence(t *testing.T) {
+ left, right := candidate("left", capability.HealthAvailable), candidate("right", capability.HealthAvailable)
+ low, high := int64(600), int64(900)
+ left.Evaluation = &capability.EvaluatedCapability{CapabilityID: "creator-advisory", Result: capability.EvaluationSupported, QualityScoreMillis: &low}
+ right.Evaluation = &capability.EvaluatedCapability{CapabilityID: "creator-advisory", Result: capability.EvaluationSupported, QualityScoreMillis: &high}
+ selected, err := capabilitydomain.SelectCognitiveBinding(requirement(), []capability.ResolvedCognitiveBinding{left, right})
+ if err != nil || selected.Binding.ID != "right" {
+ t.Fatalf("selected=%+v err=%v", selected, err)
+ }
+}
+
+func TestExcludedFailedBindingSelectsAlternative(t *testing.T) {
+ gpu, cpu := candidate("gpu", capability.HealthAvailable), candidate("cpu", capability.HealthAvailable)
+ req := requirement()
+ req.ExcludedBindingIDs = []capability.CapabilityBindingID{"gpu"}
+ selected, err := capabilitydomain.SelectCognitiveBinding(req, []capability.ResolvedCognitiveBinding{gpu, cpu})
+ if err != nil || selected.Binding.ID != "cpu" {
+ t.Fatalf("selected=%+v err=%v", selected, err)
+ }
+}