Crate aivcs_core 

AIVCS Core Library

Re-exports core components for programmatic access to AIVCS functionality.

Re-exports

pub use domain::validate_run_event;

pub use domain::AgentSpec;

pub use domain::AgentSpecFields;

pub use domain::AivcsError;

pub use domain::DeterministicEvalRunner;

pub use domain::EvalCaseResult;

pub use domain::EvalRunReport;

pub use domain::EvalSuite;

pub use domain::EvalTestCase;

pub use domain::EvalThresholds;

pub use domain::Event;

pub use domain::EventKind;

pub use domain::Release;

pub use domain::ReleaseEnvironment;

pub use domain::ReleasePointer;

pub use domain::Result;

pub use domain::Run;

pub use domain::RunStatus;

pub use domain::ScorerConfig;

pub use domain::ScorerType;

pub use domain::SnapshotMeta;

pub use domain::ValidationError;

pub use event_adapter::subscribe_ledger_to_bus;

pub use event_adapter::LedgerHandler;

pub use git::capture_head_sha;

pub use git::is_git_repo;

pub use memory::DecisionRecorder;

pub use memory::DecisionRecorderConfig;

pub use cas::fs::FsCasStore;

pub use cas::CasError;

pub use cas::CasStore;

pub use cas::Digest;

pub use compat::evaluate_compat;

pub use compat::CompatRule;

pub use compat::CompatRuleSet;

pub use compat::CompatVerdict;

pub use compat::CompatViolation;

pub use compat::PromoteContext;

pub use deploy::deploy_by_digest;

pub use deploy::DeployResult;

pub use deploy_runner::DeployByDigestRunner;

pub use deploy_runner::DeployRunOutput;

pub use diff::lcs_diff::diff_tool_calls as diff_tool_calls_lcs;

pub use diff::lcs_diff::DiffSummary;

pub use diff::lcs_diff::ParamChange;

pub use diff::lcs_diff::ToolCallChange as LcsToolCallChange;

pub use diff::lcs_diff::ToolCallEntry;

pub use diff::state_diff::diff_run_states;

pub use diff::state_diff::diff_scoped_state;

pub use diff::state_diff::extract_last_checkpoint;

pub use diff::state_diff::ScopedStateDiff;

pub use diff::state_diff::StateDelta;

pub use diff::state_diff::CHECKPOINT_SAVED_KIND;

pub use orchestration::default_role_templates;

pub use orchestration::deterministic_role_order;

pub use orchestration::merge_role_outputs;

pub use orchestration::validate_handoff;

pub use orchestration::validate_parallel_roles;

pub use orchestration::AgentRole;

pub use orchestration::HandoffValidationError;

pub use orchestration::MergeConflict;

pub use orchestration::MergeConflictStrategy;

pub use orchestration::MergeOutcome;

pub use orchestration::ParallelPlanError;

pub use orchestration::RoleHandoff;

pub use orchestration::RoleOutput;

pub use orchestration::RoleTemplate;

pub use parallel::fork_agent_parallel;

pub use parallel::BranchStatus;

pub use parallel::ForkResult;

pub use parallel::ParallelConfig;

pub use parallel::ParallelManager;

pub use planning_autonomy::compute_progress;

pub use planning_autonomy::decompose_goal_to_dag;

pub use planning_autonomy::evaluate_replan;

pub use planning_autonomy::schedule_next_ready_tasks;

pub use planning_autonomy::EpicPlan;

pub use planning_autonomy::ExecutionDag;

pub use planning_autonomy::GoalPlan;

pub use planning_autonomy::PlanTask;

pub use planning_autonomy::PlanTaskStatus;

pub use planning_autonomy::PlanningError;

pub use planning_autonomy::ProgressReport;

pub use planning_autonomy::ReplanDecision;

pub use planning_autonomy::ReplanPolicy;

pub use planning_autonomy::ReplanReason;

pub use planning_autonomy::SchedulerConstraints;

pub use planning_autonomy::TaskPlan;

pub use diff::node_paths::diff_node_paths;

pub use diff::node_paths::extract_node_path;

pub use diff::node_paths::NodeDivergence;

pub use diff::node_paths::NodePathDiff;

pub use diff::node_paths::NodeStep;

pub use diff::tool_calls::diff_tool_calls;

pub use diff::tool_calls::ParamDelta;

pub use diff::tool_calls::ToolCall;

pub use diff::tool_calls::ToolCallChange;

pub use diff::tool_calls::ToolCallDiff;

pub use gate::evaluate_gate;

pub use gate::CaseResult;

pub use gate::EvalReport;

pub use gate::GateRule;

pub use gate::GateRuleSet;

pub use gate::GateVerdict;

pub use gate::Violation;

pub use recording::GraphRunRecorder;

pub use release_registry::ReleaseRegistryApi;

pub use replay::find_resume_point;

pub use replay::replay_run;

pub use replay::verify_spec_digest;

pub use replay::ReplaySummary;

pub use replay::ResumePoint;

pub use reporting::render_diff_summary_md;

pub use reporting::write_diff_summary_md;

pub use reporting::write_eval_results_json;

pub use reporting::DiffSummaryArtifact;

pub use reporting::EvalCaseResultArtifact;

pub use reporting::EvalResultsArtifact;

pub use reporting::EvalSummaryArtifact;

pub use trace_artifact::read_trace_artifact;

pub use trace_artifact::write_trace_artifact;

pub use trace_artifact::RetentionPolicy;

pub use trace_artifact::RunTraceArtifact;

pub use quality_guardrails::evaluate_quality_guardrails;

pub use quality_guardrails::read_guardrail_artifact;

pub use quality_guardrails::release_block_reason;

pub use quality_guardrails::write_guardrail_artifact;

pub use quality_guardrails::CheckFinding;

pub use quality_guardrails::CheckResult;

pub use quality_guardrails::GuardrailArtifact;

pub use quality_guardrails::GuardrailCoverage;

pub use quality_guardrails::GuardrailPolicyProfile;

pub use quality_guardrails::GuardrailVerdict;

pub use quality_guardrails::QualityCheck;

pub use quality_guardrails::QualitySeverity;

pub use quality_guardrails::ReleaseAction;

pub use role_orchestration::error::RoleError;

pub use role_orchestration::error::RoleResult;

pub use role_orchestration::executor::execute_roles_parallel;

pub use role_orchestration::executor::token_from_result;

pub use role_orchestration::executor::ParallelRoleConfig;

pub use role_orchestration::executor::RoleRunResult;

pub use role_orchestration::merge::merge_parallel_outputs;

pub use role_orchestration::merge::MergedRoleOutput;

pub use role_orchestration::merge::RoleConflict;

pub use role_orchestration::roles::HandoffToken;

pub use role_orchestration::router::build_execution_plan;

pub use role_orchestration::router::validate_handoff_sequence;

pub use role_orchestration::router::ExecutionPlan;

pub use role_orchestration::router::RoleStep;

pub use self_healing::classify_failure;

pub use self_healing::execute_recovery_loop;

pub use self_healing::read_recovery_artifact;

pub use self_healing::write_recovery_artifact;

pub use self_healing::FailureClass;

pub use self_healing::FailureSignal;

pub use self_healing::RecoveryAction;

pub use self_healing::RecoveryAttemptResult;

pub use self_healing::RecoveryDecision;

pub use self_healing::RecoveryLog;

pub use self_healing::RecoveryOutcome;

pub use self_healing::RecoveryPolicy;

pub use sandbox::evaluate_tool_request;

pub use sandbox::execute_with_controls;

pub use sandbox::CircuitBreaker;

pub use sandbox::PolicyVerdict;

pub use sandbox::SandboxConfig;

pub use sandbox::SandboxError;

pub use sandbox::SandboxResult;

pub use sandbox::ToolExecutionResult;

pub use sandbox::ToolPolicyRule;

pub use sandbox::ToolPolicySet;

pub use sandbox::ToolRequest;

pub use memory::assemble_context;

pub use memory::compact_index;

pub use memory::CompactionPolicy;

pub use memory::CompactionResult;

pub use memory::ContextBudget;

pub use memory::ContextItem;

pub use memory::ContextWindow;

pub use memory::DecisionRationale;

pub use memory::IndexQuery;

pub use memory::IndexResult;

pub use memory::MemoryEntry;

pub use memory::MemoryEntryKind;

pub use memory::MemoryError;

pub use memory::MemoryIndex;

pub use memory::MemoryResult;

pub use memory::RationaleEntry;

pub use memory::RationaleOutcome;

pub use memory_context::estimate_tokens;

pub use memory_context::read_memory_context_artifact;

pub use memory_context::write_memory_context_artifact;

pub use memory_context::AssembledContext;

pub use memory_context::CompactionPolicy as MemoryContextCompactionPolicy;

pub use memory_context::CompactionResult as MemoryContextCompactionResult;

pub use memory_context::CompactionStrategy;

pub use memory_context::ContextAssembler;

pub use memory_context::ContextSegment;

pub use memory_context::DecisionImportance;

pub use memory_context::DecisionRationale as MemoryContextDecisionRationale;

pub use memory_context::MatchStrategy;

pub use memory_context::MemoryContextArtifact;

pub use memory_context::MemoryEntry as MemoryContextEntry;

pub use memory_context::MemoryHit;

pub use memory_context::MemoryIndex as MemoryContextIndex;

pub use memory_context::MemoryQuery;

pub use memory_context::RationaleLedger;

pub use metrics::METRICS;

pub use multi_repo::BackportExecutor;

pub use multi_repo::BackportOutcome;

pub use multi_repo::BackportPolicy;

pub use multi_repo::BackportTask;

pub use multi_repo::CIHealthView;

pub use multi_repo::CiAggregator;

pub use multi_repo::CiHealthReport;

pub use multi_repo::CiRunFetcher;

pub use multi_repo::CrossRepoGraph;

pub use multi_repo::MultiRepoError;

pub use multi_repo::MultiRepoExecutionPlan;

pub use multi_repo::MultiRepoOrchestrator;

pub use multi_repo::MultiRepoResult;

pub use multi_repo::ReleaseProvenance;

pub use multi_repo::ReleaseSequencer;

pub use multi_repo::RepoCIStatus;

pub use multi_repo::RepoDependency;

pub use multi_repo::RepoDependencyGraph;

pub use multi_repo::RepoExecutionPlan;

pub use multi_repo::RepoHealth;

pub use multi_repo::RepoHealthStatus;

pub use multi_repo::RepoId;

pub use multi_repo::RepoNode;

pub use multi_repo::RepoReleaseStatus;

pub use multi_repo::RepoReleaser;

pub use multi_repo::RepoStep;

pub use multi_repo::SequenceItem;

pub use multi_repo::SequenceOutcome;

pub use multi_repo::SequencePlan;

pub use obs::emit_event_appended;

pub use obs::emit_gate_evaluated;

pub use obs::emit_run_finalize_error;

pub use obs::emit_run_finished;

pub use obs::emit_run_started;

pub use obs::RunSpan;

pub use telemetry::init_tracing;

pub use tooling::JsonFieldSchema;

pub use tooling::PolicyAction;

pub use tooling::PolicyMatrix;

pub use tooling::SchemaStage;

pub use tooling::ToolAdapter;

pub use tooling::ToolCallStatus;

pub use tooling::ToolCapability;

pub use tooling::ToolExecutionConfig;

pub use tooling::ToolExecutionError;

pub use tooling::ToolExecutionReport;

pub use tooling::ToolExecutor;

pub use tooling::ToolInvocation;

pub use tooling::ToolRegistry;

pub use tooling::ToolSpec;

pub use tooling::ToolTelemetry;

pub use hitl_controls::apply_intervention;

pub use hitl_controls::evaluate_checkpoint;

pub use hitl_controls::read_hitl_artifact;

pub use hitl_controls::submit_vote;

pub use hitl_controls::write_hitl_artifact;

pub use hitl_controls::ApprovalCheckpoint;

pub use hitl_controls::ApprovalPolicy;

pub use hitl_controls::ApprovalRule;

pub use hitl_controls::ApprovalVote;

pub use hitl_controls::CheckpointStatus;

pub use hitl_controls::DecisionSummary;

pub use hitl_controls::ExplainabilitySummary;

pub use hitl_controls::HitlArtifact;

pub use hitl_controls::HitlError;

pub use hitl_controls::HitlResult;

pub use hitl_controls::Intervention;

pub use hitl_controls::InterventionAction;

pub use hitl_controls::RiskTier;

pub use hitl_controls::VoteDecision;

Modules

cas

compat

Compatibility validator for release promotions.

deploy

Deploy-by-digest with registry lookup.

deploy_runner

Deploy-by-digest reference runner.

diff

domain

Domain models for AIVCS.

event_adapter

Adapter bridging oxidizedgraph’s EventBus lifecycle events into the AIVCS RunLedger persistence layer.

gate

Merge gate rules engine.

git

Git integration utilities for capturing repository state.

hitl_controls

Human-in-the-Loop (HITL) Controls for AIVCS.

memory

Memory subsystem for agent context, indexing, and retention.

memory_context

Memory, context, and retrieval for EPIC5.

metrics

Global atomic counters for AIVCS observability.

multi_repo

Multi-repo and CI/CD orchestration (EPIC9).

obs

Structured observability hooks for AIVCS run lifecycle events.

orchestration

Agent role orchestration primitives.

parallel

Parallel Simulation Module

planning_autonomy

Planning and long-horizon autonomy primitives.

publish_gate

Publish gate rules engine.

quality_guardrails

Code quality guardrails for release/promotion decisions.

recording

Graph lifecycle adapter: bridges domain Event types to RunLedger persistence.

release_registry

replay

Replay functionality for recorded runs.

reporting

role_orchestration

Agent Role Orchestration — EPIC2.

sandbox

Sandbox: policy-controlled tool execution for autonomous agents.

self_healing

Verification and self-healing orchestration primitives.

telemetry

Centralised tracing initialisation for AIVCS binaries.

tooling

Tooling and sandbox policy core.

trace_artifact

Run trace artifact persistence and retention policy.

Structs

AtticClient

Attic client for binary cache operations

AtticConfig

Attic configuration

AutoResolvedValue

Result of automatic conflict resolution

BranchRecord

Branch record - pointer to a commit

CommitId

Composite Commit ID - hash of (Logic + State + Environment)

CommitRecord

Commit record stored in SurrealDB

DecisionRecord

Decision record - captures agent decisions with rationale and outcomes

FlakeMetadata

Metadata from a Nix Flake

MemoryConflict

A conflict between two memory records

MemoryProvenanceRecord

Memory provenance record - tracks lineage of memories

MemoryRecord

Memory record - agent memory/context for RAG

MergeResult

Result of a semantic merge operation

NixHash

Nix environment hash - content-addressable identifier

SnapshotRecord

Snapshot record - the actual agent state data

SurrealHandle

SurrealDB connection handle for AIVCS

VectorStoreDelta

Difference between two memory vector stores

Enums

HashSource

Source of the Nix hash

ProvenanceSourceType

Provenance source for memory records

Constants

VERSION

AIVCS version

Functions

diff_memory_vectors

Diff memory vectors between two commits

generate_environment_hash

Generate environment hash from a Nix Flake

generate_logic_hash

Generate a hash of Rust source code

is_attic_available

Check if Attic CLI is available

is_nix_available

Check if Nix is available on the system

resolve_conflict_state

Resolve a state conflict using LLM Arbiter

semantic_merge

Perform a semantic merge of two branches

synthesize_memory

Synthesize two memory stores into one