From f5d77405125640402eca41551407e79c21627f39 Mon Sep 17 00:00:00 2001 From: principalwater Date: Fri, 21 Aug 2026 15:53:51 +0300 Subject: [PATCH] edition 2024 for 12 of 14 crates artesian-process-agent and artesian-bench stay on 2021. Edition 2024 makes std::env::set_var unsafe because it is not thread safe, and the workspace sets unsafe_code = forbid deliberately. Wrapping the calls would punch a hole in that invariant to satisfy a test, so the two crates keep the old edition and carry a note. The real fix is to make those env reads injectable instead of global; the production path reads std::env::var directly, so the test has no other way in. That is a separate change, not an edition bump. 492 tests green, unchanged. --- Cargo.toml | 2 +- crates/aquifer/src/backend.rs | 6 +- crates/aquifer/src/backfill.rs | 4 +- crates/aquifer/src/chunking.rs | 8 +- crates/aquifer/src/compat.rs | 4 +- crates/aquifer/src/dream.rs | 2 +- crates/aquifer/src/event.rs | 2 +- crates/aquifer/src/eviction.rs | 52 ++++++++----- crates/aquifer/src/files.rs | 11 ++- crates/aquifer/src/graph.rs | 4 +- crates/aquifer/src/harness_import.rs | 6 +- crates/aquifer/src/lib.rs | 73 +++++++++--------- crates/aquifer/src/pgvector.rs | 4 +- crates/aquifer/src/qdrant.rs | 26 ++++--- crates/aquifer/src/reconcile.rs | 3 +- crates/aquifer/src/semantic_cache.rs | 4 +- crates/aquifer/src/session.rs | 2 +- crates/aquifer/src/sqlite_vec.rs | 6 +- crates/aquifer/src/temporal.rs | 4 +- crates/aquifer/src/txn.rs | 4 +- crates/aquifer/src/types.rs | 4 +- crates/aquifer/src/upgrade.rs | 6 +- crates/aquifer/src/vector.rs | 4 +- crates/aquifer/src/vector_memory.rs | 27 +++---- crates/aquifer/tests/anchor.rs | 16 ++-- crates/aquifer/tests/backfill.rs | 18 +++-- crates/aquifer/tests/concurrency.rs | 26 ++++--- .../aquifer/tests/decay_reconcile_eviction.rs | 18 +++-- .../aquifer/tests/memory_backend_contract.rs | 42 +++++----- crates/aquifer/tests/qdrant.rs | 22 +++--- crates/aquifer/tests/rechunk.rs | 6 +- crates/aquifer/tests/rrf.rs | 2 +- crates/aquifer/tests/survivability.rs | 10 +-- crates/artesian-bench/Cargo.toml | 5 +- crates/artesian-cli/src/artesiand.rs | 2 +- crates/artesian-cli/src/import.rs | 4 +- crates/artesian-cli/src/main.rs | 77 ++++++++++--------- crates/artesian-cli/src/mcp_doctor.rs | 21 +++-- crates/artesian-cli/src/runs.rs | 2 +- crates/artesian-cli/src/runtime.rs | 6 +- crates/artesian-cli/src/update.rs | 2 +- crates/artesian-cli/tests/cli.rs | 46 ++++++----- crates/artesian-core/src/agent.rs | 2 +- crates/artesian-core/src/lib.rs | 6 +- crates/artesian-core/tests/agent_contract.rs | 2 +- crates/artesian-core/tests/config_contract.rs | 2 +- crates/artesian-mcp/src/lib.rs | 47 ++++++----- crates/artesian-mcp/tests/memory_tools.rs | 54 +++++++------ crates/artesian-process-agent/Cargo.toml | 5 +- crates/basin/src/lib.rs | 2 +- crates/basin/tests/orchestrator.rs | 16 ++-- crates/flume/examples/emit_receipts.rs | 4 +- crates/flume/src/consolidation.rs | 15 ++-- crates/flume/src/lib.rs | 8 +- crates/flume/src/loop_core.rs | 24 +++--- crates/flume/src/quota.rs | 20 +++-- crates/flume/src/receipts.rs | 2 +- crates/gauge/src/agentic.rs | 8 +- crates/gauge/src/bench.rs | 6 +- crates/gauge/src/bin/gauge_ci_eval.rs | 4 +- crates/gauge/src/bin/gauge_eval.rs | 2 +- crates/gauge/src/eval.rs | 10 +-- crates/gauge/src/lib.rs | 20 ++--- crates/gauge/src/retrieval_regression.rs | 38 +++++---- crates/headgate/src/bundle.rs | 10 ++- crates/headgate/src/compressor.rs | 4 +- crates/headgate/src/controller.rs | 2 +- crates/headgate/src/council.rs | 7 +- crates/headgate/src/gate.rs | 2 +- crates/headgate/src/headroom.rs | 2 +- crates/headgate/src/judge.rs | 6 +- crates/headgate/src/lib.rs | 22 +++--- crates/headgate/src/llm.rs | 2 +- crates/headgate/src/metrics.rs | 2 +- crates/headgate/src/position.rs | 2 +- crates/headgate/src/recall.rs | 2 +- crates/headgate/src/tier.rs | 4 +- crates/headrace/src/files.rs | 2 +- crates/headrace/src/vector.rs | 2 +- crates/headrace/src/verifier.rs | 2 +- crates/headrace/tests/task_store.rs | 10 ++- crates/sandbox/src/lib.rs | 2 +- 82 files changed, 535 insertions(+), 440 deletions(-) diff --git a/Cargo.toml b/Cargo.toml index 88169e2..f04ea51 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -21,7 +21,7 @@ members = [ [workspace.package] version = "0.5.11" -edition = "2021" +edition = "2024" rust-version = "1.85" license = "Apache-2.0" readme = "README.md" diff --git a/crates/aquifer/src/backend.rs b/crates/aquifer/src/backend.rs index eafff56..2565be7 100644 --- a/crates/aquifer/src/backend.rs +++ b/crates/aquifer/src/backend.rs @@ -1,10 +1,10 @@ // SPDX-License-Identifier: Apache-2.0 -use futures_util::{future::BoxFuture, FutureExt}; +use futures_util::{FutureExt, future::BoxFuture}; use crate::{ - reciprocal_rank_fusion, MemoryQuery, MemoryRecord, MemoryResult, RetractReport, RrfOptions, - SearchHit, StoreMemory, + MemoryQuery, MemoryRecord, MemoryResult, RetractReport, RrfOptions, SearchHit, StoreMemory, + reciprocal_rank_fusion, }; /// Aggregate counts returned by `MemoryBackend::bulk_store`. diff --git a/crates/aquifer/src/backfill.rs b/crates/aquifer/src/backfill.rs index 59b9847..e2e1739 100644 --- a/crates/aquifer/src/backfill.rs +++ b/crates/aquifer/src/backfill.rs @@ -9,8 +9,8 @@ use chrono::{DateTime, NaiveDate, Utc}; use serde::{Deserialize, Serialize}; use crate::{ - files::parse_record, identity::stable_memory_id, normalize_project, MemoryBackend, - MemoryRecord, MemoryResult, MemoryTier, StoreMemory, + MemoryBackend, MemoryRecord, MemoryResult, MemoryTier, StoreMemory, files::parse_record, + identity::stable_memory_id, normalize_project, }; const MAX_SECTION_CHARS: usize = 8_000; diff --git a/crates/aquifer/src/chunking.rs b/crates/aquifer/src/chunking.rs index ccfa485..7228e98 100644 --- a/crates/aquifer/src/chunking.rs +++ b/crates/aquifer/src/chunking.rs @@ -219,9 +219,11 @@ mod tests { fn headings_are_attached() { let text = "# Caching\nTTL is 90 seconds.\n\n# Auth\nTokens expire in 15 minutes."; let chunks = chunk_text(text, &ChunkConfig::default()); - assert!(chunks - .iter() - .any(|c| c.heading.as_deref() == Some("Caching"))); + assert!( + chunks + .iter() + .any(|c| c.heading.as_deref() == Some("Caching")) + ); assert!(chunks.iter().any(|c| c.heading.as_deref() == Some("Auth"))); } } diff --git a/crates/aquifer/src/compat.rs b/crates/aquifer/src/compat.rs index 1bbd77b..794289c 100644 --- a/crates/aquifer/src/compat.rs +++ b/crates/aquifer/src/compat.rs @@ -5,8 +5,8 @@ use std::sync::Once; use serde::{Deserialize, Serialize}; use crate::{ - Distance, MemoryError, MemoryResult, VectorMemoryConfig, PINNED_FASTEMBED_DIMENSIONS, - PINNED_FASTEMBED_MODEL, + Distance, MemoryError, MemoryResult, PINNED_FASTEMBED_DIMENSIONS, PINNED_FASTEMBED_MODEL, + VectorMemoryConfig, }; pub const HEADWATER_VERSION: &str = "1"; diff --git a/crates/aquifer/src/dream.rs b/crates/aquifer/src/dream.rs index 9e2f9e5..c7d5783 100644 --- a/crates/aquifer/src/dream.rs +++ b/crates/aquifer/src/dream.rs @@ -45,8 +45,8 @@ use chrono::{DateTime, Utc}; use serde::{Deserialize, Serialize}; use crate::{ - consolidation::{consolidation_pass, ConsolidationOptions}, MemoryRecord, MemoryTier, + consolidation::{ConsolidationOptions, consolidation_pass}, }; // ── OCF on-disk constants ──────────────────────────────────────────────────── diff --git a/crates/aquifer/src/event.rs b/crates/aquifer/src/event.rs index a603210..92b31e6 100644 --- a/crates/aquifer/src/event.rs +++ b/crates/aquifer/src/event.rs @@ -13,7 +13,7 @@ use std::{collections::HashMap, time::Duration}; use chrono::{DateTime, Utc}; -use crate::{entity::extract_entities, MemoryRecord}; +use crate::{MemoryRecord, entity::extract_entities}; /// A coherent temporal group of related atomic memory records. /// diff --git a/crates/aquifer/src/eviction.rs b/crates/aquifer/src/eviction.rs index d256305..6452a80 100644 --- a/crates/aquifer/src/eviction.rs +++ b/crates/aquifer/src/eviction.rs @@ -24,8 +24,8 @@ use chrono::{DateTime, Utc}; use serde::{Deserialize, Serialize}; use crate::{ - decay::{retrieval_strength, DecayConfig}, MemoryRecord, MemoryState, + decay::{DecayConfig, retrieval_strength}, }; /// One line of the eviction audit log (`~/.artesian/eviction.jsonl`). @@ -340,10 +340,12 @@ mod tests { let report = evict(&[archived, active], &policy); assert_eq!(report.deleted, 1); assert_eq!(report.archived, 0); // hard does not re-archive - assert!(report - .log_entries - .iter() - .any(|e| e.record_id == "old-archived" && e.action == EvictionAction::Delete)); + assert!( + report + .log_entries + .iter() + .any(|e| e.record_id == "old-archived" && e.action == EvictionAction::Delete) + ); } #[test] @@ -371,14 +373,18 @@ mod tests { let report = evict(&[old_useful, fresh_unused], &policy); assert_eq!(report.archived, 1); - assert!(report - .log_entries - .iter() - .any(|entry| entry.record_id == "fresh-unused")); - assert!(!report - .log_entries - .iter() - .any(|entry| entry.record_id == "old-useful")); + assert!( + report + .log_entries + .iter() + .any(|entry| entry.record_id == "fresh-unused") + ); + assert!( + !report + .log_entries + .iter() + .any(|entry| entry.record_id == "old-useful") + ); } #[test] @@ -393,14 +399,18 @@ mod tests { let report = evict(&[old_useful, old_unused], &policy); assert_eq!(report.archived, 1); - assert!(report - .log_entries - .iter() - .any(|entry| entry.record_id == "old-unused")); - assert!(!report - .log_entries - .iter() - .any(|entry| entry.record_id == "old-useful")); + assert!( + report + .log_entries + .iter() + .any(|entry| entry.record_id == "old-unused") + ); + assert!( + !report + .log_entries + .iter() + .any(|entry| entry.record_id == "old-useful") + ); } #[test] diff --git a/crates/aquifer/src/files.rs b/crates/aquifer/src/files.rs index 80025c3..5c1e2c8 100644 --- a/crates/aquifer/src/files.rs +++ b/crates/aquifer/src/files.rs @@ -8,18 +8,17 @@ use std::{ }; use chrono::{DateTime, Utc}; -use futures_util::{future::BoxFuture, FutureExt}; +use futures_util::{FutureExt, future::BoxFuture}; use serde::{Deserialize, Serialize}; use tokio::{fs, io::AsyncWriteExt}; use crate::{ - annotate_session_distances, - decay::{retrieval_strength, DecayConfig}, + MemoryBackend, MemoryError, MemoryId, MemoryQuery, MemoryRecord, MemoryResult, MemoryScope, + MemoryState, MemoryTier, Relation, RetractReport, SHARED_PROJECT, SearchHit, SearchSource, + SessionLaneLock, StoreMemory, annotate_session_distances, + decay::{DecayConfig, retrieval_strength}, graph::{by_entity_node_ids, neighbor_node_ids, normalize_relations, records_by_node_ids}, identity::stable_memory_id, - MemoryBackend, MemoryError, MemoryId, MemoryQuery, MemoryRecord, MemoryResult, MemoryScope, - MemoryState, MemoryTier, Relation, RetractReport, SearchHit, SearchSource, SessionLaneLock, - StoreMemory, SHARED_PROJECT, }; #[derive(Debug, Clone)] diff --git a/crates/aquifer/src/graph.rs b/crates/aquifer/src/graph.rs index 28fe59f..0a16b7c 100644 --- a/crates/aquifer/src/graph.rs +++ b/crates/aquifer/src/graph.rs @@ -2,11 +2,11 @@ use std::collections::{BTreeMap, BTreeSet}; -use futures_util::{future::BoxFuture, FutureExt}; +use futures_util::{FutureExt, future::BoxFuture}; use serde::{Deserialize, Serialize}; use crate::{ - entity::extract_entities, MemoryBackend, MemoryRecord, MemoryResult, SearchHit, SearchSource, + MemoryBackend, MemoryRecord, MemoryResult, SearchHit, SearchSource, entity::extract_entities, }; pub const DEFAULT_GRAPH_HOPS: usize = 1; diff --git a/crates/aquifer/src/harness_import.rs b/crates/aquifer/src/harness_import.rs index 9601347..3b7369d 100644 --- a/crates/aquifer/src/harness_import.rs +++ b/crates/aquifer/src/harness_import.rs @@ -693,11 +693,7 @@ fn durable_fact_score(content: &str) -> f32 { ) { return 1.0; } - if word_count >= 5 { - 0.8 - } else { - 0.0 - } + if word_count >= 5 { 0.8 } else { 0.0 } } fn contains_any(haystack: &str, needles: &[&str]) -> bool { diff --git a/crates/aquifer/src/lib.rs b/crates/aquifer/src/lib.rs index fbb5a9c..ace3222 100644 --- a/crates/aquifer/src/lib.rs +++ b/crates/aquifer/src/lib.rs @@ -39,55 +39,56 @@ mod vector; mod vector_memory; mod working; -pub use anchor::{recover_after_compaction, AnchorAnchorStore, RecoveryContext, SessionAnchor}; +pub use anchor::{AnchorAnchorStore, RecoveryContext, SessionAnchor, recover_after_compaction}; pub use backend::{BulkStoreReport, MemoryBackend}; pub use backfill::{ - backfill_directory, backfill_directory_with_options, backfill_directory_with_project, - collect_memory_paths, parse_memory_path, BackfillFailure, BackfillOptions, BackfillStats, + BackfillFailure, BackfillOptions, BackfillStats, backfill_directory, + backfill_directory_with_options, backfill_directory_with_project, collect_memory_paths, + parse_memory_path, }; -pub use chunking::{chunk_text, Chunk, ChunkConfig}; +pub use chunking::{Chunk, ChunkConfig, chunk_text}; #[allow(deprecated)] pub use compat::OKF_VERSION; -pub use compat::{CollectionCompat, COMPAT_POINT_ID, HEADWATER_VERSION}; -pub use decay::{retrieval_strength, DecayConfig}; -pub use entity::{extract_entities, EntityIndex}; +pub use compat::{COMPAT_POINT_ID, CollectionCompat, HEADWATER_VERSION}; +pub use decay::{DecayConfig, retrieval_strength}; +pub use entity::{EntityIndex, extract_entities}; pub use episode::EpisodeIndex; -pub use event::{assemble_events, Event}; +pub use event::{Event, assemble_events}; pub use eviction::{ - append_eviction_log, evict, EvictionAction, EvictionLogEntry, EvictionPolicy, EvictionReport, + EvictionAction, EvictionLogEntry, EvictionPolicy, EvictionReport, append_eviction_log, evict, }; pub use files::{ - parse_record as files_parse_record, render_record as files_render_record, FilesBackend, + FilesBackend, parse_record as files_parse_record, render_record as files_render_record, }; pub use graph::{ - expand_hits_with_neighbors, Relation, DEFAULT_GRAPH_HOPS, GRAPH_EXPANSION_LIMIT, - GRAPH_SCAN_LIMIT, MAX_GRAPH_HOPS, + DEFAULT_GRAPH_HOPS, GRAPH_EXPANSION_LIMIT, GRAPH_SCAN_LIMIT, MAX_GRAPH_HOPS, Relation, + expand_hits_with_neighbors, }; pub use harness_import::{ - parse_harness_candidates, HarnessKind, HarnessMemoryCandidate, HarnessParseReport, + HarnessKind, HarnessMemoryCandidate, HarnessParseReport, parse_harness_candidates, }; pub use identity::stable_memory_id; pub use lane_lock::{SessionLaneGuard, SessionLaneLock}; -pub use mmr::{mmr_diversify, mmr_diversify_when_large, MMR_DEFAULT_LAMBDA, MMR_MIN_CANDIDATES}; +pub use mmr::{MMR_DEFAULT_LAMBDA, MMR_MIN_CANDIDATES, mmr_diversify, mmr_diversify_when_large}; #[cfg(feature = "pgvector")] pub use pgvector::{PgVectorBackend, PgVectorStore}; #[cfg(feature = "qdrant")] pub use qdrant::{ - preflight_qdrant, replicate_collection, replicate_collection_incremental, QdrantBackend, - QdrantEndpoints, QdrantPreflightReport, QdrantVectorStore, QdrantVectorStoreConfig, - ReplicateReport, + QdrantBackend, QdrantEndpoints, QdrantPreflightReport, QdrantVectorStore, + QdrantVectorStoreConfig, ReplicateReport, preflight_qdrant, replicate_collection, + replicate_collection_incremental, }; -pub use reconcile::{reconcile, ReconcileConfig, ReconcileDecision, DEFAULT_RECONCILE_THRESHOLD}; +pub use reconcile::{DEFAULT_RECONCILE_THRESHOLD, ReconcileConfig, ReconcileDecision, reconcile}; #[cfg(feature = "vector")] pub use retrieval::FastembedReranker; pub use retrieval::{LocalLexicalReranker, Reranker}; pub use rrf::reciprocal_rank_fusion; #[cfg(feature = "vector")] pub use semantic_cache::EmbedderVectorizer; -pub use semantic_cache::{cosine_similarity, CachingMemoryBackend, QueryVectorizer, SemanticCache}; +pub use semantic_cache::{CachingMemoryBackend, QueryVectorizer, SemanticCache, cosine_similarity}; pub use session::{ - Session, SessionKey, SessionListFilter, SessionStore, SessionSummary, - DEFAULT_SESSION_COMPONENT, SESSION_RECORD_SOURCE, SESSION_RECORD_TAG, + DEFAULT_SESSION_COMPONENT, SESSION_RECORD_SOURCE, SESSION_RECORD_TAG, Session, SessionKey, + SessionListFilter, SessionStore, SessionSummary, }; #[cfg(feature = "sqlite-vec")] pub use sqlite_vec::{SqliteVecBackend, SqliteVecVectorStore, SqliteVecVectorStoreConfig}; @@ -97,24 +98,24 @@ pub use temporal::{ #[allow(deprecated)] pub use txn::sync_okf_directory; pub use txn::{ - sync_headwater_directory, CommitLog, SyncReport, TransactionalMemory, TxnError, TxnSeq, + CommitLog, SyncReport, TransactionalMemory, TxnError, TxnSeq, sync_headwater_directory, }; pub use types::{ + MemoryError, MemoryId, MemoryQuery, MemoryRecord, MemoryResult, MemoryScope, MemoryState, + MemoryTier, ProcedureStep, RecallTelemetry, RetractReport, RrfOptions, SHARED_PROJECT, + SKILL_PROCEDURE_METADATA_KEY, SearchHit, SearchSource, StoreMemory, UNTAGGED_PROJECT_LABEL, annotate_session_distances, insert_skill_procedure_metadata, normalize_project, - skill_procedure_from_metadata, MemoryError, MemoryId, MemoryQuery, MemoryRecord, MemoryResult, - MemoryScope, MemoryState, MemoryTier, ProcedureStep, RecallTelemetry, RetractReport, - RrfOptions, SearchHit, SearchSource, StoreMemory, SHARED_PROJECT, SKILL_PROCEDURE_METADATA_KEY, - UNTAGGED_PROJECT_LABEL, + skill_procedure_from_metadata, }; pub use upgrade::{ - default_migration_collection, export_headwater_bundle, migrate_headwater_bundle, - migration_manifest_path, rechunk_oversized_sqlite, verify_headwater_bundle, HeadwaterExportReport, HeadwaterVerifyReport, MigrationPlan, MigrationReport, RechunkReport, - SnapshotReport, VectorCollectionAdmin, + SnapshotReport, VectorCollectionAdmin, default_migration_collection, export_headwater_bundle, + migrate_headwater_bundle, migration_manifest_path, rechunk_oversized_sqlite, + verify_headwater_bundle, }; #[allow(deprecated)] pub use upgrade::{ - export_okf_bundle, migrate_okf_bundle, verify_okf_bundle, OkfExportReport, OkfVerifyReport, + OkfExportReport, OkfVerifyReport, export_okf_bundle, migrate_okf_bundle, verify_okf_bundle, }; #[cfg(feature = "vector")] pub use vector::{ @@ -124,8 +125,8 @@ pub use vector::{ }; #[cfg(feature = "vector")] pub use vector_memory::{ - FastembedTextEmbedder, TextEmbedder, VectorMemoryBackend, VectorMemoryConfig, - PINNED_FASTEMBED_DIMENSIONS, PINNED_FASTEMBED_MODEL, + FastembedTextEmbedder, PINNED_FASTEMBED_DIMENSIONS, PINNED_FASTEMBED_MODEL, TextEmbedder, + VectorMemoryBackend, VectorMemoryConfig, }; pub use working::{ InMemoryWorkingMemory, WorkingMemory, WorkingMemoryMode, WorkingMemoryView, WorkingTurn, @@ -133,12 +134,12 @@ pub use working::{ pub mod consolidation; pub use consolidation::{ - consolidation_pass, ConsolidationClaim, ConsolidationOptions, ConsolidationReport, - GovernanceFields, + ConsolidationClaim, ConsolidationOptions, ConsolidationReport, GovernanceFields, + consolidation_pass, }; pub mod dream; pub use dream::{ - dream, render_diary, write_dream_bundle, DreamDecision, DreamError, DreamOptions, - DreamQualifyRecord, DreamResult, DreamSnapshotEntry, + DreamDecision, DreamError, DreamOptions, DreamQualifyRecord, DreamResult, DreamSnapshotEntry, + dream, render_diary, write_dream_bundle, }; diff --git a/crates/aquifer/src/pgvector.rs b/crates/aquifer/src/pgvector.rs index 1700da0..d302522 100644 --- a/crates/aquifer/src/pgvector.rs +++ b/crates/aquifer/src/pgvector.rs @@ -18,16 +18,16 @@ use std::sync::Arc; -use futures_util::{future::BoxFuture, FutureExt}; +use futures_util::{FutureExt, future::BoxFuture}; use pgvector::Vector; use serde_json::Value; use tokio_postgres::{Client, NoTls}; use crate::{ - vector::{is_safe_field_path, must_string_eq, payload_matches_filter}, Distance, Filter, MemoryError, MemoryResult, PayloadIndex, VectorCollection, VectorMemoryBackend, VectorMemoryConfig, VectorPoint, VectorSearch, VectorSearchHit, VectorSearchSource, VectorStore, VectorStoreCapabilities, + vector::{is_safe_field_path, must_string_eq, payload_matches_filter}, }; pub type PgVectorBackend = VectorMemoryBackend; diff --git a/crates/aquifer/src/qdrant.rs b/crates/aquifer/src/qdrant.rs index d279ee7..4017601 100644 --- a/crates/aquifer/src/qdrant.rs +++ b/crates/aquifer/src/qdrant.rs @@ -5,8 +5,9 @@ use std::path::Path; use std::sync::{Once, OnceLock}; use std::time::Duration; -use futures_util::{future::BoxFuture, FutureExt}; +use futures_util::{FutureExt, future::BoxFuture}; use qdrant_client::{ + Payload, Qdrant, qdrant::{ Condition, CreateCollectionBuilder, CreateFieldIndexCollectionBuilder, DeletePointsBuilder, FieldType, Filter, GetPointsBuilder, HnswConfigDiffBuilder, PointId, PointStruct, @@ -14,17 +15,16 @@ use qdrant_client::{ ScalarQuantizationBuilder, ScoredPoint, ScrollPointsBuilder, UpsertPointsBuilder, Value, VectorParamsBuilder, VectorsOutput, }, - Payload, Qdrant, }; use serde_json::Value as JsonValue; use sha2::{Digest, Sha256}; use crate::{ - vector::payload_matches_filter, Distance, Filter as MemoryFilter, FilterCondition, FilterValue, - MemoryError, MemoryResult, PayloadIndex, RangeFilter, SnapshotReport, VectorCollection, - VectorCollectionAdmin, VectorMemoryBackend, VectorMemoryConfig, VectorPoint, - VectorQuantization, VectorSearch, VectorSearchHit, VectorSearchSource, VectorStore, - VectorStoreCapabilities, + Distance, Filter as MemoryFilter, FilterCondition, FilterValue, MemoryError, MemoryResult, + PayloadIndex, RangeFilter, SnapshotReport, VectorCollection, VectorCollectionAdmin, + VectorMemoryBackend, VectorMemoryConfig, VectorPoint, VectorQuantization, VectorSearch, + VectorSearchHit, VectorSearchSource, VectorStore, VectorStoreCapabilities, + vector::payload_matches_filter, }; pub type QdrantBackend = VectorMemoryBackend; @@ -1051,7 +1051,7 @@ fn value_to_match(value: &FilterValue) -> Option Option { - use qdrant_client::qdrant::{condition::ConditionOneOf, FieldCondition, Range}; + use qdrant_client::qdrant::{FieldCondition, Range, condition::ConditionOneOf}; Some(Condition { condition_one_of: Some(ConditionOneOf::Field(FieldCondition { @@ -1396,7 +1396,7 @@ impl std::fmt::Display for QdrantEndpoints { #[cfg(test)] mod tests { use super::{ - is_transient_connect_error, retry_transient, QdrantEndpoints, QdrantVectorStoreConfig, + QdrantEndpoints, QdrantVectorStoreConfig, is_transient_connect_error, retry_transient, }; use std::sync::atomic::{AtomicUsize, Ordering}; @@ -1428,9 +1428,11 @@ mod tests { let error = QdrantVectorStoreConfig::new("http://qdrant.local:7000") .endpoints() .expect_err("custom port without REST URL should fail"); - assert!(error - .to_string() - .contains("pass --qdrant-rest-url explicitly")); + assert!( + error + .to_string() + .contains("pass --qdrant-rest-url explicitly") + ); } #[test] diff --git a/crates/aquifer/src/reconcile.rs b/crates/aquifer/src/reconcile.rs index 91cf488..6f1dd9b 100644 --- a/crates/aquifer/src/reconcile.rs +++ b/crates/aquifer/src/reconcile.rs @@ -265,8 +265,7 @@ mod tests { // Existing and incoming share the same core tokens AND incoming is much longer → Supersede. // Use low threshold so the shared tokens register above the similarity floor. let existing = "The team chose Rust for performance and safety requirements"; - let incoming = - "The team chose Rust for performance and safety requirements and additionally \ + let incoming = "The team chose Rust for performance and safety requirements and additionally \ for memory safety zero-cost abstractions type system and lack of garbage \ collector which was critical for audio processing latency requirements"; let record = make_candidate("a", existing); diff --git a/crates/aquifer/src/semantic_cache.rs b/crates/aquifer/src/semantic_cache.rs index 5c2bfee..c7a01f0 100644 --- a/crates/aquifer/src/semantic_cache.rs +++ b/crates/aquifer/src/semantic_cache.rs @@ -16,7 +16,7 @@ use std::collections::VecDeque; use std::sync::Mutex; use std::time::{Duration, Instant}; -use futures_util::{future::BoxFuture, FutureExt}; +use futures_util::{FutureExt, future::BoxFuture}; use crate::{MemoryBackend, MemoryQuery, MemoryRecord, MemoryResult, SearchHit, StoreMemory}; @@ -254,8 +254,8 @@ impl MemoryBackend for CachingMemoryBacken #[cfg(test)] mod tests { use std::collections::BTreeMap; - use std::sync::atomic::{AtomicUsize, Ordering}; use std::sync::Arc; + use std::sync::atomic::{AtomicUsize, Ordering}; use crate::{MemoryId, MemoryTier, SearchSource}; diff --git a/crates/aquifer/src/session.rs b/crates/aquifer/src/session.rs index f1b6e1a..68cf6ac 100644 --- a/crates/aquifer/src/session.rs +++ b/crates/aquifer/src/session.rs @@ -2,7 +2,7 @@ use std::{ cmp::Reverse, - collections::{btree_map::Entry, BTreeMap}, + collections::{BTreeMap, btree_map::Entry}, sync::Arc, }; diff --git a/crates/aquifer/src/sqlite_vec.rs b/crates/aquifer/src/sqlite_vec.rs index 0f5d233..c7230cc 100644 --- a/crates/aquifer/src/sqlite_vec.rs +++ b/crates/aquifer/src/sqlite_vec.rs @@ -6,15 +6,15 @@ use std::{ time::Duration, }; -use futures_util::{future::BoxFuture, FutureExt}; -use rusqlite::{params, Connection, OptionalExtension}; +use futures_util::{FutureExt, future::BoxFuture}; +use rusqlite::{Connection, OptionalExtension, params}; use serde_json::Value; use crate::{ - vector::{is_safe_field_path, must_string_eq, payload_matches_filter}, Distance, Filter, MemoryError, MemoryResult, PayloadIndex, VectorCollection, VectorMemoryBackend, VectorMemoryConfig, VectorPoint, VectorSearch, VectorSearchHit, VectorSearchSource, VectorStore, VectorStoreCapabilities, + vector::{is_safe_field_path, must_string_eq, payload_matches_filter}, }; pub type SqliteVecBackend = VectorMemoryBackend; diff --git a/crates/aquifer/src/temporal.rs b/crates/aquifer/src/temporal.rs index 2b5200e..fce042a 100644 --- a/crates/aquifer/src/temporal.rs +++ b/crates/aquifer/src/temporal.rs @@ -5,9 +5,9 @@ use std::collections::HashMap; use chrono::{DateTime, Utc}; use crate::{ - entity::{extract_entities, EntityIndex}, - event::Event, MemoryRecord, SearchHit, + entity::{EntityIndex, extract_entities}, + event::Event, }; /// Apply exponential recency decay to retrieval scores. diff --git a/crates/aquifer/src/txn.rs b/crates/aquifer/src/txn.rs index 86b859d..c59a26a 100644 --- a/crates/aquifer/src/txn.rs +++ b/crates/aquifer/src/txn.rs @@ -36,13 +36,13 @@ //! races (two agents updating the "current plan" simultaneously). use std::sync::{ - atomic::{AtomicU64, Ordering}, Arc, + atomic::{AtomicU64, Ordering}, }; use crate::{ - backfill::{collect_memory_paths, parse_memory_path}, MemoryBackend, MemoryError, MemoryQuery, MemoryRecord, MemoryResult, SearchHit, StoreMemory, + backfill::{collect_memory_paths, parse_memory_path}, }; use futures_util::future::BoxFuture; diff --git a/crates/aquifer/src/types.rs b/crates/aquifer/src/types.rs index 3885e61..2b7732b 100644 --- a/crates/aquifer/src/types.rs +++ b/crates/aquifer/src/types.rs @@ -58,7 +58,9 @@ pub enum MemoryError { Backend(String), #[error("backend is not available in this build: {0}")] BackendUnavailable(String), - #[error("collection embedding metadata mismatch: collection={collection_model}/{collection_dimensions}, configured={configured_model}/{configured_dimensions}; run artesian migrate before reading or writing")] + #[error( + "collection embedding metadata mismatch: collection={collection_model}/{collection_dimensions}, configured={configured_model}/{configured_dimensions}; run artesian migrate before reading or writing" + )] CompatMismatch { collection_model: String, collection_dimensions: usize, diff --git a/crates/aquifer/src/upgrade.rs b/crates/aquifer/src/upgrade.rs index aa614bd..92d92c8 100644 --- a/crates/aquifer/src/upgrade.rs +++ b/crates/aquifer/src/upgrade.rs @@ -10,9 +10,9 @@ use futures_util::future::BoxFuture; use serde::{Deserialize, Serialize}; use crate::{ - backfill_directory, chunking::ChunkConfig, files::parse_record, CollectionCompat, - MemoryBackend, MemoryError, MemoryResult, SqliteVecVectorStore, StoreMemory, TextEmbedder, - VectorMemoryBackend, VectorMemoryConfig, VectorStore, + CollectionCompat, MemoryBackend, MemoryError, MemoryResult, SqliteVecVectorStore, StoreMemory, + TextEmbedder, VectorMemoryBackend, VectorMemoryConfig, VectorStore, backfill_directory, + chunking::ChunkConfig, files::parse_record, }; #[derive(Debug, Clone, Default, PartialEq, Eq, Serialize, Deserialize)] diff --git a/crates/aquifer/src/vector.rs b/crates/aquifer/src/vector.rs index c5a082a..5b5511d 100644 --- a/crates/aquifer/src/vector.rs +++ b/crates/aquifer/src/vector.rs @@ -1,6 +1,6 @@ // SPDX-License-Identifier: Apache-2.0 -use futures_util::{future::BoxFuture, FutureExt}; +use futures_util::{FutureExt, future::BoxFuture}; use serde::{Deserialize, Serialize}; use serde_json::Value; @@ -244,7 +244,7 @@ pub trait VectorStore: Send + Sync { ) -> BoxFuture<'_, MemoryResult<()>>; fn upsert(&self, collection: &str, points: Vec) - -> BoxFuture<'_, MemoryResult<()>>; + -> BoxFuture<'_, MemoryResult<()>>; /// Upsert points without waiting for the index to finish building. Returns immediately after /// the server accepts the batch. Call `flush_upsert` once after all batches are sent. diff --git a/crates/aquifer/src/vector_memory.rs b/crates/aquifer/src/vector_memory.rs index 14d9687..74818ec 100644 --- a/crates/aquifer/src/vector_memory.rs +++ b/crates/aquifer/src/vector_memory.rs @@ -7,27 +7,26 @@ use std::{ use chrono::Utc; use fastembed::{EmbeddingModel, TextEmbedding, TextInitOptions}; -use futures_util::{future::BoxFuture, FutureExt}; +use futures_util::{FutureExt, future::BoxFuture}; use serde::{Deserialize, Serialize}; use crate::{ - annotate_session_distances, + COMPAT_POINT_ID, CollectionCompat, Distance, Filter, FilterCondition, FilterValue, + MemoryBackend, MemoryError, MemoryId, MemoryQuery, MemoryRecord, MemoryResult, MemoryScope, + MemoryState, MemoryTier, PayloadIndex, Relation, RetractReport, RrfOptions, SearchHit, + SearchSource, SessionLaneLock, StoreMemory, VectorCollection, VectorPoint, VectorSearch, + VectorSearchHit, VectorSearchSource, VectorStore, annotate_session_distances, backend::BulkStoreReport, - chunking::{chunk_text, ChunkConfig}, + chunking::{ChunkConfig, chunk_text}, entity::EntityIndex, episode::EpisodeIndex, graph::{ - by_entity_node_ids, extract_entity_relations, neighbor_node_ids, normalize_relations, - records_by_node_ids, GRAPH_SCAN_LIMIT, + GRAPH_SCAN_LIMIT, by_entity_node_ids, extract_entity_relations, neighbor_node_ids, + normalize_relations, records_by_node_ids, }, identity::stable_memory_id, reciprocal_rank_fusion, temporal::{apply_knowledge_supersession, apply_recency_decay}, - CollectionCompat, Distance, Filter, FilterCondition, FilterValue, MemoryBackend, MemoryError, - MemoryId, MemoryQuery, MemoryRecord, MemoryResult, MemoryScope, MemoryState, MemoryTier, - PayloadIndex, Relation, RetractReport, RrfOptions, SearchHit, SearchSource, SessionLaneLock, - StoreMemory, VectorCollection, VectorPoint, VectorSearch, VectorSearchHit, VectorSearchSource, - VectorStore, COMPAT_POINT_ID, }; pub const PINNED_FASTEMBED_MODEL: &str = "intfloat/multilingual-e5-small"; @@ -184,9 +183,11 @@ fn spawn_idle_unloader(embedder: Arc) { let sweep = EMBEDDER_SWEEP_INTERVAL.min(idle_window); if let Err(error) = std::thread::Builder::new() .name("artesian-embedder-unload".to_string()) - .spawn(move || loop { - std::thread::sleep(sweep); - embedder.unload_if_idle(idle_window); + .spawn(move || { + loop { + std::thread::sleep(sweep); + embedder.unload_if_idle(idle_window); + } }) { // Say so rather than silently running without the unloader the operator asked for. diff --git a/crates/aquifer/tests/anchor.rs b/crates/aquifer/tests/anchor.rs index 7cc7ae3..6323de2 100644 --- a/crates/aquifer/tests/anchor.rs +++ b/crates/aquifer/tests/anchor.rs @@ -1,8 +1,8 @@ // SPDX-License-Identifier: Apache-2.0 use aquifer::{ - recover_after_compaction, AnchorAnchorStore, FilesBackend, MemoryBackend, MemoryTier, - SessionAnchor, SessionKey, StoreMemory, + AnchorAnchorStore, FilesBackend, MemoryBackend, MemoryTier, SessionAnchor, SessionKey, + StoreMemory, recover_after_compaction, }; use artesian_test_support::TempDir; @@ -69,11 +69,13 @@ async fn keyed_anchor_does_not_replace_default_anchor() { Some("session-a".to_string()), Some("other-task".to_string()), ); - assert!(store - .get_for_session(&other_key) - .await - .expect("other key should read") - .is_none()); + assert!( + store + .get_for_session(&other_key) + .await + .expect("other key should read") + .is_none() + ); } #[tokio::test] diff --git a/crates/aquifer/tests/backfill.rs b/crates/aquifer/tests/backfill.rs index f0315aa..d2f0e3b 100644 --- a/crates/aquifer/tests/backfill.rs +++ b/crates/aquifer/tests/backfill.rs @@ -3,8 +3,8 @@ use std::sync::Arc; use aquifer::{ - backfill_directory, backfill_directory_with_project, FilesBackend, MemoryBackend, MemoryQuery, - MemoryResult, SqliteVecVectorStore, TextEmbedder, VectorMemoryBackend, VectorMemoryConfig, + FilesBackend, MemoryBackend, MemoryQuery, MemoryResult, SqliteVecVectorStore, TextEmbedder, + VectorMemoryBackend, VectorMemoryConfig, backfill_directory, backfill_directory_with_project, }; use artesian_test_support::TempDir; @@ -218,12 +218,14 @@ async fn backfill_chunks_markdown_by_heading() { assert_eq!(stats.scanned, 1); assert_eq!(stats.imported, 2); assert_eq!(hits.len(), 2); - assert!(hits - .iter() - .any(|hit| hit.record.metadata.get("heading") == Some(&"Alpha".to_string()))); - assert!(hits - .iter() - .any(|hit| hit.record.metadata.get("heading") == Some(&"Beta".to_string()))); + assert!( + hits.iter() + .any(|hit| hit.record.metadata.get("heading") == Some(&"Alpha".to_string())) + ); + assert!( + hits.iter() + .any(|hit| hit.record.metadata.get("heading") == Some(&"Beta".to_string())) + ); } const TEST_DIMENSIONS: usize = 8; diff --git a/crates/aquifer/tests/concurrency.rs b/crates/aquifer/tests/concurrency.rs index 7db9641..b138fc2 100644 --- a/crates/aquifer/tests/concurrency.rs +++ b/crates/aquifer/tests/concurrency.rs @@ -43,10 +43,12 @@ async fn session_lane_lock_serializes_and_times_out() { let blocked = lock.acquire("shared-collection", Some("session-a")).await; assert!(blocked.is_err()); - assert!(blocked - .expect_err("lane should time out") - .to_string() - .contains("timed out acquiring session lane lock")); + assert!( + blocked + .expect_err("lane should time out") + .to_string() + .contains("timed out acquiring session lane lock") + ); guard.release().expect("release should succeed"); lock.acquire("shared-collection", Some("session-a")) @@ -109,18 +111,22 @@ async fn sqlite_vec_multi_writer_integrity_and_tenant_isolation() { query.user_id = Some("user-0".to_string()); let user_zero = backend.find(query).await.expect("find should succeed"); assert_eq!(user_zero.len(), writer_count / 2); - assert!(user_zero - .iter() - .all(|hit| hit.record.user_id.as_deref() == Some("user-0"))); + assert!( + user_zero + .iter() + .all(|hit| hit.record.user_id.as_deref() == Some("user-0")) + ); let mut query = MemoryQuery::new("contention memory tenant").with_limit(writer_count); query.scope = Some(MemoryScope::Session); query.user_id = Some("user-1".to_string()); let user_one = backend.find(query).await.expect("find should succeed"); assert_eq!(user_one.len(), writer_count / 2); - assert!(user_one - .iter() - .all(|hit| hit.record.user_id.as_deref() == Some("user-1"))); + assert!( + user_one + .iter() + .all(|hit| hit.record.user_id.as_deref() == Some("user-1")) + ); } async fn assert_concurrent_scope_isolation(backend: Arc) { diff --git a/crates/aquifer/tests/decay_reconcile_eviction.rs b/crates/aquifer/tests/decay_reconcile_eviction.rs index 7faf598..bae235c 100644 --- a/crates/aquifer/tests/decay_reconcile_eviction.rs +++ b/crates/aquifer/tests/decay_reconcile_eviction.rs @@ -10,12 +10,12 @@ use std::sync::Arc; use aquifer::{ - decay::{retrieval_strength, DecayConfig}, - eviction::{evict, EvictionAction, EvictionPolicy}, - files_parse_record, files_render_record, - reconcile::{reconcile, ReconcileConfig, ReconcileDecision}, FilesBackend, MemoryBackend, MemoryId, MemoryQuery, MemoryRecord, MemoryState, MemoryTier, StoreMemory, + decay::{DecayConfig, retrieval_strength}, + eviction::{EvictionAction, EvictionPolicy, evict}, + files_parse_record, files_render_record, + reconcile::{ReconcileConfig, ReconcileDecision, reconcile}, }; use artesian_test_support::TempDir; use chrono::{Duration, Utc}; @@ -410,10 +410,12 @@ fn eviction_hard_deletes_previously_archived() { report.archived, 0, "hard does not archive additional records" ); - assert!(report - .log_entries - .iter() - .any(|e| e.record_id == "archived-old" && e.action == EvictionAction::Delete)); + assert!( + report + .log_entries + .iter() + .any(|e| e.record_id == "archived-old" && e.action == EvictionAction::Delete) + ); } /// Eviction with max_keep=1 archives all but the strongest record. diff --git a/crates/aquifer/tests/memory_backend_contract.rs b/crates/aquifer/tests/memory_backend_contract.rs index c818bf3..db7407a 100644 --- a/crates/aquifer/tests/memory_backend_contract.rs +++ b/crates/aquifer/tests/memory_backend_contract.rs @@ -6,13 +6,13 @@ use std::{ }; use aquifer::{ - expand_hits_with_neighbors, FilesBackend, MemoryBackend, MemoryId, MemoryQuery, MemoryRecord, + DEFAULT_GRAPH_HOPS, FilesBackend, MemoryBackend, MemoryId, MemoryQuery, MemoryRecord, MemoryResult, MemoryScope, MemoryState, MemoryTier, Relation, RrfOptions, SearchHit, SqliteVecVectorStore, StoreMemory, TextEmbedder, VectorMemoryBackend, VectorMemoryConfig, - DEFAULT_GRAPH_HOPS, + expand_hits_with_neighbors, }; use artesian_test_support::TempDir; -use futures_util::{future::BoxFuture, FutureExt}; +use futures_util::{FutureExt, future::BoxFuture}; #[derive(Debug, Default)] struct MockMemoryBackend { @@ -605,11 +605,13 @@ async fn assert_mark_used_and_retract(backend: &B) { .expect("record should exist"); assert_eq!(report.retracted.state, MemoryState::Retracted); assert_eq!(report.supersede.source.as_deref(), Some("artesian.retract")); - assert!(report - .supersede - .relations - .iter() - .any(|relation| relation.predicate == "superseded_by")); + assert!( + report + .supersede + .relations + .iter() + .any(|relation| relation.predicate == "superseded_by") + ); let default_hits = backend .find(MemoryQuery::new("critical architecture").with_limit(10)) @@ -674,16 +676,20 @@ async fn assert_session_distance(backend: &B) { async fn default_graph_methods_are_empty_for_non_indexing_backends() { let backend = MockMemoryBackend::default(); - assert!(backend - .neighbors("node:any", 1) - .await - .expect("neighbors should succeed") - .is_empty()); - assert!(backend - .by_entity("AnyEntity") - .await - .expect("by_entity should succeed") - .is_empty()); + assert!( + backend + .neighbors("node:any", 1) + .await + .expect("neighbors should succeed") + .is_empty() + ); + assert!( + backend + .by_entity("AnyEntity") + .await + .expect("by_entity should succeed") + .is_empty() + ); } #[tokio::test] diff --git a/crates/aquifer/tests/qdrant.rs b/crates/aquifer/tests/qdrant.rs index 31f0529..ede74f9 100644 --- a/crates/aquifer/tests/qdrant.rs +++ b/crates/aquifer/tests/qdrant.rs @@ -5,9 +5,9 @@ use std::{collections::BTreeMap, env}; use aquifer::{ - preflight_qdrant, MemoryBackend, MemoryQuery, MemoryTier, QdrantEndpoints, QdrantVectorStore, - QdrantVectorStoreConfig, RrfOptions, StoreMemory, VectorCollectionAdmin, VectorMemoryBackend, - VectorMemoryConfig, PINNED_FASTEMBED_DIMENSIONS, PINNED_FASTEMBED_MODEL, + MemoryBackend, MemoryQuery, MemoryTier, PINNED_FASTEMBED_DIMENSIONS, PINNED_FASTEMBED_MODEL, + QdrantEndpoints, QdrantVectorStore, QdrantVectorStoreConfig, RrfOptions, StoreMemory, + VectorCollectionAdmin, VectorMemoryBackend, VectorMemoryConfig, preflight_qdrant, }; use chrono::Utc; @@ -40,9 +40,11 @@ fn qdrant_endpoint_normalization_names_custom_port_error() { let error = QdrantVectorStoreConfig::new("http://127.0.0.1:7444") .endpoints() .expect_err("custom single port should be actionable"); - assert!(error - .to_string() - .contains("pass --qdrant-rest-url explicitly")); + assert!( + error + .to_string() + .contains("pass --qdrant-rest-url explicitly") + ); } #[tokio::test] @@ -50,9 +52,11 @@ async fn qdrant_preflight_reports_actionable_custom_port_error_without_network() let error = preflight_qdrant(QdrantVectorStoreConfig::new("http://127.0.0.1:7444")) .await .expect_err("custom single port should fail before probing network"); - assert!(error - .to_string() - .contains("pass --qdrant-rest-url explicitly")); + assert!( + error + .to_string() + .contains("pass --qdrant-rest-url explicitly") + ); } #[tokio::test] diff --git a/crates/aquifer/tests/rechunk.rs b/crates/aquifer/tests/rechunk.rs index 534cd70..bdb7044 100644 --- a/crates/aquifer/tests/rechunk.rs +++ b/crates/aquifer/tests/rechunk.rs @@ -11,9 +11,9 @@ use std::sync::Arc; use aquifer::{ - rechunk_oversized_sqlite, Distance, MemoryBackend, MemoryQuery, MemoryResult, - SqliteVecVectorStore, SqliteVecVectorStoreConfig, StoreMemory, TextEmbedder, VectorCollection, - VectorMemoryBackend, VectorMemoryConfig, VectorPoint, VectorStore, + Distance, MemoryBackend, MemoryQuery, MemoryResult, SqliteVecVectorStore, + SqliteVecVectorStoreConfig, StoreMemory, TextEmbedder, VectorCollection, VectorMemoryBackend, + VectorMemoryConfig, VectorPoint, VectorStore, rechunk_oversized_sqlite, }; use artesian_test_support::TempDir; diff --git a/crates/aquifer/tests/rrf.rs b/crates/aquifer/tests/rrf.rs index eb411e6..1083910 100644 --- a/crates/aquifer/tests/rrf.rs +++ b/crates/aquifer/tests/rrf.rs @@ -5,7 +5,7 @@ use std::collections::BTreeMap; use chrono::Utc; use aquifer::{ - reciprocal_rank_fusion, MemoryId, MemoryRecord, MemoryState, MemoryTier, RrfOptions, SearchHit, + MemoryId, MemoryRecord, MemoryState, MemoryTier, RrfOptions, SearchHit, reciprocal_rank_fusion, }; fn record(id: &str, node_id: &str) -> MemoryRecord { diff --git a/crates/aquifer/tests/survivability.rs b/crates/aquifer/tests/survivability.rs index 03ae7e3..c319d63 100644 --- a/crates/aquifer/tests/survivability.rs +++ b/crates/aquifer/tests/survivability.rs @@ -7,13 +7,13 @@ use std::{ }; use aquifer::{ - migrate_headwater_bundle, verify_headwater_bundle, Distance, MemoryBackend, MemoryError, - MemoryResult, MigrationPlan, SnapshotReport, SqliteVecVectorStore, TextEmbedder, - VectorCollection, VectorCollectionAdmin, VectorMemoryBackend, VectorMemoryConfig, VectorPoint, - VectorSearch, VectorSearchHit, VectorStore, VectorStoreCapabilities, + Distance, MemoryBackend, MemoryError, MemoryResult, MigrationPlan, SnapshotReport, + SqliteVecVectorStore, TextEmbedder, VectorCollection, VectorCollectionAdmin, + VectorMemoryBackend, VectorMemoryConfig, VectorPoint, VectorSearch, VectorSearchHit, + VectorStore, VectorStoreCapabilities, migrate_headwater_bundle, verify_headwater_bundle, }; use artesian_test_support::TempDir; -use futures_util::{future::BoxFuture, FutureExt}; +use futures_util::{FutureExt, future::BoxFuture}; #[tokio::test] async fn old_schema_bundle_still_verifies() { diff --git a/crates/artesian-bench/Cargo.toml b/crates/artesian-bench/Cargo.toml index 76b163e..e7897fa 100644 --- a/crates/artesian-bench/Cargo.toml +++ b/crates/artesian-bench/Cargo.toml @@ -3,7 +3,10 @@ [package] name = "artesian-bench" version.workspace = true -edition.workspace = true +# Stays on edition 2021: these crates set process env vars, which edition 2024 +# makes unsafe, and the workspace forbids unsafe on purpose. Finish the move +# once the env reads are injectable rather than global. +edition = "2021" rust-version.workspace = true license.workspace = true diff --git a/crates/artesian-cli/src/artesiand.rs b/crates/artesian-cli/src/artesiand.rs index 3e91346..6185f21 100644 --- a/crates/artesian-cli/src/artesiand.rs +++ b/crates/artesian-cli/src/artesiand.rs @@ -2,7 +2,7 @@ use std::{env, path::PathBuf, time::Duration}; -use anyhow::{bail, Result}; +use anyhow::{Result, bail}; use artesian_core::Mode; use clap::Parser; use serde_json::json; diff --git a/crates/artesian-cli/src/import.rs b/crates/artesian-cli/src/import.rs index 5e6d8f0..eb4bc41 100644 --- a/crates/artesian-cli/src/import.rs +++ b/crates/artesian-cli/src/import.rs @@ -8,9 +8,9 @@ use std::{ use anyhow::Result; use aquifer::{ - collect_memory_paths, parse_harness_candidates, parse_memory_path, stable_memory_id, BackfillFailure, FilesBackend, HarnessKind, MemoryBackend, MemoryQuery, MemoryScope, - StoreMemory, + StoreMemory, collect_memory_paths, parse_harness_candidates, parse_memory_path, + stable_memory_id, }; use headgate::{ CcsSchema, CommittedContextState, CommittedEntry, DefaultQualifyGate, HeadgateConfig, diff --git a/crates/artesian-cli/src/main.rs b/crates/artesian-cli/src/main.rs index 67c3908..a3da151 100644 --- a/crates/artesian-cli/src/main.rs +++ b/crates/artesian-cli/src/main.rs @@ -13,51 +13,52 @@ use std::{ time::Duration, }; -use anyhow::{bail, Context, Result}; +use anyhow::{Context, Result, bail}; use aquifer::{ - append_eviction_log, consolidation_pass, default_migration_collection, entity_timeline, evict, + AnchorAnchorStore, CollectionCompat, ConsolidationOptions, DecayConfig, EvictionPolicy, + MemoryBackend, MemoryQuery, MemoryRecord, MemoryScope, MemoryState, MemoryTier, MigrationPlan, + ProcedureStep, SHARED_PROJECT, SearchHit, SessionAnchor, SessionKey, SessionListFilter, + SessionStore, StoreMemory, UNTAGGED_PROJECT_LABEL, VectorMemoryConfig, append_eviction_log, + consolidation_pass, default_migration_collection, entity_timeline, evict, export_headwater_bundle, insert_skill_procedure_metadata, normalize_project, - recover_after_compaction, verify_headwater_bundle, AnchorAnchorStore, CollectionCompat, - ConsolidationOptions, DecayConfig, EvictionPolicy, MemoryBackend, MemoryQuery, MemoryRecord, - MemoryScope, MemoryState, MemoryTier, MigrationPlan, ProcedureStep, SearchHit, SessionAnchor, - SessionKey, SessionListFilter, SessionStore, StoreMemory, VectorMemoryConfig, SHARED_PROJECT, - UNTAGGED_PROJECT_LABEL, + recover_after_compaction, verify_headwater_bundle, }; use artesian_core::{ Agent, AgentBinding, ArtesianConfig, MemoryBackendKind, MemoryConfig, Mode, Role, SpawnRequest, }; use artesian_mcp::{ - build_session_bundle_for_cli, checkpoint_anchor_for_cli, qualify_memory_candidate, - session_scoped_hits_for_cli, QualifyResponse, SessionCheckpointRequest, + QualifyResponse, SessionCheckpointRequest, build_session_bundle_for_cli, + checkpoint_anchor_for_cli, qualify_memory_candidate, session_scoped_hits_for_cli, }; use artesian_process_agent::{ - fallback_agent_catalog, refresh_agent_catalog, ProcessAgent, ProcessAgentConfig, - ProcessSupervisor, + ProcessAgent, ProcessAgentConfig, ProcessSupervisor, fallback_agent_catalog, + refresh_agent_catalog, }; use clap::{Parser, Subcommand, ValueEnum}; use flume::loop_core::{ + LOOP_SKILL_TAG, LoopCommandFuture, LoopCommands, LoopRunOptions, assemble_goal_packet_with_project, loop_recall_for_project, loop_run_id, loop_run_log_dir, - loop_stop_file, run_loop_core, stable_content_hash, LoopCommandFuture, LoopCommands, - LoopRunOptions, LOOP_SKILL_TAG, + loop_stop_file, run_loop_core, stable_content_hash, }; -use flume::quota::{read_local_quota, QuotaLoopConfig, QuotaStatusKind}; +use flume::quota::{QuotaLoopConfig, QuotaStatusKind, read_local_quota}; use flume::{ - load_role_definitions, role_summaries, TeamCreate, TeamGcOptions, TeamMessage, TeamMessageKind, - TeamRuntime, TeamRuntimeConfig, TeamSpawn, TeamTaskAdd, TeamTaskClaim, TeamTaskComplete, - TeamWorkerEvent, + TeamCreate, TeamGcOptions, TeamMessage, TeamMessageKind, TeamRuntime, TeamRuntimeConfig, + TeamSpawn, TeamTaskAdd, TeamTaskClaim, TeamTaskComplete, TeamWorkerEvent, + load_role_definitions, role_summaries, }; use headgate::{ - count_tokens, load_savings_rollup, record_savings, Headgate, HeadgateConfig, LifecycleEntry, - MemoryRecallStore, RecallStore, SnapshotEntry, WorkingContextBundle, WorkingContextSnapshot, + Headgate, HeadgateConfig, LifecycleEntry, MemoryRecallStore, RecallStore, SnapshotEntry, + WorkingContextBundle, WorkingContextSnapshot, count_tokens, load_savings_rollup, + record_savings, }; use headrace::{ ClaimRequest, CommandVerifier, FilesTaskStore, NewTask, TaskKind, TaskStore, VectorTaskStore, Verifier, VerifierGate, }; use serde::Deserialize; -use serde_json::{json, Value}; +use serde_json::{Value, json}; use tokio::process::Command as TokioCommand; -use toml_edit::{value, Array, DocumentMut, Item, Table}; +use toml_edit::{Array, DocumentMut, Item, Table, value}; const DEFAULT_CONFIG: &str = "artesian.toml"; const ROUTING_SNIPPET_MARKER: &str = "Memory & Context — via Artesian"; @@ -92,7 +93,7 @@ mod mcp_doctor; mod runs; mod runtime; mod update; -use import::{import_directory, import_harness, HarnessImportOptions, ImportOptions}; +use import::{HarnessImportOptions, ImportOptions, import_directory, import_harness}; use runtime::{ build_orchestrator, ensure_memory_collection, load_config, open_memory_backend, open_memory_backend_with_relations, process_supervisor_from_config, shutdown_signal, @@ -1880,8 +1881,8 @@ async fn run_replicate( batch: u32, ) -> Result<()> { use aquifer::{ - replicate_collection, replicate_collection_incremental, QdrantVectorStore, - QdrantVectorStoreConfig, + QdrantVectorStore, QdrantVectorStoreConfig, replicate_collection, + replicate_collection_incremental, }; let target_collection = to_collection.unwrap_or_else(|| collection.clone()); let mut from_cfg = QdrantVectorStoreConfig::new(from_url); @@ -2119,8 +2120,8 @@ async fn doctor( } else { println!(" qdrant: UNREACHABLE — {error}"); println!( - " fix: check the URL + API key env, and that the server is up" - ); + " fix: check the URL + API key env, and that the server is up" + ); } } }, @@ -5065,9 +5066,11 @@ async fn migrate_headwater( async fn migrate_rechunk(config_path: PathBuf) -> Result<()> { let config = load_config(&config_path)?; if config.memory.backend != MemoryBackendKind::SqliteVec { - bail!("artesian migrate rechunk currently requires backend = sqlite-vec; for Qdrant use artesian migrate headwater-bundle"); + bail!( + "artesian migrate rechunk currently requires backend = sqlite-vec; for Qdrant use artesian migrate headwater-bundle" + ); } - use aquifer::{rechunk_oversized_sqlite, SqliteVecVectorStore, SqliteVecVectorStoreConfig}; + use aquifer::{SqliteVecVectorStore, SqliteVecVectorStoreConfig, rechunk_oversized_sqlite}; use std::path::PathBuf as SPath; let db_path = SPath::from(&config.memory.root).join(format!("{}.sqlite", config.memory.collection)); @@ -5324,7 +5327,7 @@ async fn migrate_qdrant( memory: &MemoryConfig, plan: MigrationPlan, ) -> Result { - use aquifer::{migrate_headwater_bundle, FastembedTextEmbedder, QdrantVectorStore}; + use aquifer::{FastembedTextEmbedder, QdrantVectorStore, migrate_headwater_bundle}; let store = QdrantVectorStore::connect(qdrant_config(memory)?)?; Ok(migrate_headwater_bundle(&store, plan, Arc::new(FastembedTextEmbedder::new()?)).await?) @@ -6302,16 +6305,20 @@ mod tests { let mut skill_query = MemoryQuery::new("cargo test").with_limit(10); skill_query.tags = vec![SKILL_TAG.to_string()]; let skills = backend.find(skill_query).await.expect("find skills"); - assert!(skills - .iter() - .any(|hit| hit.record.content.contains("verified approach"))); + assert!( + skills + .iter() + .any(|hit| hit.record.content.contains("verified approach")) + ); let mut spec_query = MemoryQuery::new("cargo test").with_limit(10); spec_query.tags = vec![SPEC_TAG.to_string()]; let specs = backend.find(spec_query).await.expect("find specs"); - assert!(specs - .iter() - .any(|hit| hit.record.content.contains("sharper spec"))); + assert!( + specs + .iter() + .any(|hit| hit.record.content.contains("sharper spec")) + ); let _ = fs::remove_dir_all(&tmp); } diff --git a/crates/artesian-cli/src/mcp_doctor.rs b/crates/artesian-cli/src/mcp_doctor.rs index cf0fad8..e394b6f 100644 --- a/crates/artesian-cli/src/mcp_doctor.rs +++ b/crates/artesian-cli/src/mcp_doctor.rs @@ -23,11 +23,11 @@ use std::{ }; use anyhow::{Context, Result}; -use serde_json::{json, Value}; +use serde_json::{Value, json}; use tokio::process::Command as TokioCommand; use crate::update::{ - discover_running_mcp_processes, probe_binary_version, resolve_on_path, VersionProbe, + VersionProbe, discover_running_mcp_processes, probe_binary_version, resolve_on_path, }; use crate::{home_dir, zed_settings_path}; @@ -851,7 +851,9 @@ fn check_path_health(reg: &McpRegistrationEntry, problems: &mut usize) { "{label}: command '{}' was not found (not on PATH, not a file)", reg.entry.command ), - Some("re-run `artesian init --register-mcp`, or repoint the registration at an installed artesian-mcp"), + Some( + "re-run `artesian init --register-mcp`, or repoint the registration at an installed artesian-mcp", + ), problems, ); return; @@ -983,14 +985,19 @@ async fn check_handshake(entry: &RawServerEntry, problems: &mut usize) { match probe_handshake(&entry.command, &entry.args, &entry.env).await { Ok(ok) => report( Level::Ok, - &format!("{label}: responded in {}ms with {} tool(s)", ok.elapsed_ms, ok.tools_count), + &format!( + "{label}: responded in {}ms with {} tool(s)", + ok.elapsed_ms, ok.tools_count + ), None, problems, ), Err(error) => report( Level::Fail, &format!("{label}: {error}"), - Some("run the command manually and check stderr, or re-run `artesian init --register-mcp`"), + Some( + "run the command manually and check stderr, or re-run `artesian init --register-mcp`", + ), problems, ), } @@ -1017,7 +1024,9 @@ fn check_stale_resume(cwd: &Path, problems: &mut usize) { finding.session_file.display(), finding.server_name, ), - Some("start a NEW chat (do not resume this session) — this is an upstream Claude Code resume limitation"), + Some( + "start a NEW chat (do not resume this session) — this is an upstream Claude Code resume limitation", + ), problems, ); } diff --git a/crates/artesian-cli/src/runs.rs b/crates/artesian-cli/src/runs.rs index fb18c38..94ceab9 100644 --- a/crates/artesian-cli/src/runs.rs +++ b/crates/artesian-cli/src/runs.rs @@ -7,7 +7,7 @@ use std::{ time::{Duration, SystemTime}, }; -use anyhow::{bail, Context, Result}; +use anyhow::{Context, Result, bail}; use chrono::{DateTime, SecondsFormat, Utc}; use serde_json::Value; diff --git a/crates/artesian-cli/src/runtime.rs b/crates/artesian-cli/src/runtime.rs index 9775ac7..f33cc87 100644 --- a/crates/artesian-cli/src/runtime.rs +++ b/crates/artesian-cli/src/runtime.rs @@ -10,7 +10,7 @@ use std::{ #[cfg(feature = "qdrant")] use std::env; -use anyhow::{bail, Context, Result}; +use anyhow::{Context, Result, bail}; use aquifer::{ FilesBackend, MemoryBackend, PayloadIndex, SqliteVecVectorStore, SqliteVecVectorStoreConfig, VectorCollection, VectorMemoryBackend, VectorMemoryConfig, VectorStore, @@ -95,7 +95,7 @@ pub fn process_supervisor_from_config( pub async fn shutdown_signal() -> Result<&'static str> { #[cfg(unix)] { - use tokio::signal::unix::{signal, SignalKind}; + use tokio::signal::unix::{SignalKind, signal}; let mut terminate = signal(SignalKind::terminate()).context("listen for sigterm")?; tokio::select! { @@ -447,8 +447,8 @@ fn sqlite_path(root: &str) -> PathBuf { #[cfg(test)] mod tests { use std::sync::{ - atomic::{AtomicBool, Ordering}, Arc, + atomic::{AtomicBool, Ordering}, }; use aquifer::{MemoryResult, SearchHit}; diff --git a/crates/artesian-cli/src/update.rs b/crates/artesian-cli/src/update.rs index 6042655..c72e86a 100644 --- a/crates/artesian-cli/src/update.rs +++ b/crates/artesian-cli/src/update.rs @@ -14,7 +14,7 @@ use artesian_process_agent::ProcessSupervisor; #[cfg(unix)] use nix::{ errno::Errno, - sys::signal::{kill, Signal}, + sys::signal::{Signal, kill}, unistd::Pid, }; diff --git a/crates/artesian-cli/tests/cli.rs b/crates/artesian-cli/tests/cli.rs index ffb8a6f..c8b6b7b 100644 --- a/crates/artesian-cli/tests/cli.rs +++ b/crates/artesian-cli/tests/cli.rs @@ -130,9 +130,11 @@ fn cli_memory_mode_round_trip_and_spawn_alias_work() { .output() .expect("init should run"); assert!(init.status.success(), "{}", stderr(&init)); - assert!(std::fs::read_to_string(tempdir.join(".mcp.json")) - .expect("Claude MCP config should be written") - .contains("artesian-mcp")); + assert!( + std::fs::read_to_string(tempdir.join(".mcp.json")) + .expect("Claude MCP config should be written") + .contains("artesian-mcp") + ); isolated.assert_registration_isolated(tempdir.path()); let mut spawn_cmd = isolated.command(binary); @@ -194,10 +196,12 @@ fn cli_memory_mode_round_trip_and_spawn_alias_work() { serde_json::from_str(&stdout(&answer)).expect("answer should be JSON"); assert_eq!(answer_json["extractive"], true); assert_eq!(answer_json["sources"][0], "node:cli"); - assert!(answer_json["answer"] - .as_str() - .expect("answer should be a string") - .contains("[node:cli]")); + assert!( + answer_json["answer"] + .as_str() + .expect("answer should be a string") + .contains("[node:cli]") + ); let mut commit_cmd = isolated.command(binary); let commit = commit_cmd @@ -237,9 +241,11 @@ fn cli_memory_mode_round_trip_and_spawn_alias_work() { >= 2 ); assert!(qualify_admit_json["agreement"].as_f64().is_some()); - assert!(qualify_admit_json["chance_corrected_agreement"] - .as_f64() - .is_some()); + assert!( + qualify_admit_json["chance_corrected_agreement"] + .as_f64() + .is_some() + ); let confidence = qualify_admit_json["confidence"] .as_f64() .expect("confidence should be numeric"); @@ -259,10 +265,12 @@ fn cli_memory_mode_round_trip_and_spawn_alias_work() { let qualify_reject_json: serde_json::Value = serde_json::from_str(&stdout(&qualify_reject)).expect("qualify reject should be JSON"); assert_eq!(qualify_reject_json["admitted"], false); - assert!(qualify_reject_json["reason"] - .as_str() - .expect("reason should be text") - .contains("redundant")); + assert!( + qualify_reject_json["reason"] + .as_str() + .expect("reason should be text") + .contains("redundant") + ); let import_dir = tempdir.join("import"); std::fs::create_dir_all(&import_dir).expect("import dir should be created"); @@ -586,10 +594,12 @@ fn cli_handoff_and_session_list_read_committed_session() { let packet: serde_json::Value = serde_json::from_str(&stdout(&handoff)).expect("handoff should print JSON"); assert_eq!(packet["session"]["handed_off_from"], "codex"); - assert!(packet["restored_working_state"] - .as_str() - .expect("state should be text") - .contains("cli handoff restores this state")); + assert!( + packet["restored_working_state"] + .as_str() + .expect("state should be text") + .contains("cli handoff restores this state") + ); let list = Command::new(binary) .args(["session", "list", "--user", "user-a"]) diff --git a/crates/artesian-core/src/agent.rs b/crates/artesian-core/src/agent.rs index a603368..1bb6807 100644 --- a/crates/artesian-core/src/agent.rs +++ b/crates/artesian-core/src/agent.rs @@ -3,7 +3,7 @@ use std::pin::Pin; use futures_core::Stream; -use futures_util::{future::BoxFuture, FutureExt}; +use futures_util::{FutureExt, future::BoxFuture}; use schemars::JsonSchema; use serde::{Deserialize, Serialize}; use thiserror::Error; diff --git a/crates/artesian-core/src/lib.rs b/crates/artesian-core/src/lib.rs index 669cb2c..f1915ed 100644 --- a/crates/artesian-core/src/lib.rs +++ b/crates/artesian-core/src/lib.rs @@ -14,9 +14,9 @@ pub use agent::{ AgentSession, AgentUnreachableReason, SpawnRequest, }; pub use config::{ - AccConfig, AccLlmConfig, AgentBinding, ArtesianConfig, CoordinationConfig, MemoryBackendKind, - MemoryConfig, Mode, ResourceQuotaConfig, SemanticCacheConfig, VerifierCommandConfig, - DEFAULT_RERANK_CANDIDATES, + AccConfig, AccLlmConfig, AgentBinding, ArtesianConfig, CoordinationConfig, + DEFAULT_RERANK_CANDIDATES, MemoryBackendKind, MemoryConfig, Mode, ResourceQuotaConfig, + SemanticCacheConfig, VerifierCommandConfig, }; pub use coordination::{Barrier, ResourceQuota, TokenAccounting}; pub use event::{EventEnvelope, EventSender, EventType}; diff --git a/crates/artesian-core/tests/agent_contract.rs b/crates/artesian-core/tests/agent_contract.rs index d80dd6e..6e94d68 100644 --- a/crates/artesian-core/tests/agent_contract.rs +++ b/crates/artesian-core/tests/agent_contract.rs @@ -1,6 +1,6 @@ // SPDX-License-Identifier: Apache-2.0 -use futures_util::{future::BoxFuture, stream, FutureExt, StreamExt}; +use futures_util::{FutureExt, StreamExt, future::BoxFuture, stream}; use artesian_core::{ Agent, AgentCapabilities, AgentEvent, AgentEventStream, AgentMessage, AgentResponse, diff --git a/crates/artesian-core/tests/config_contract.rs b/crates/artesian-core/tests/config_contract.rs index 4cb0165..e2c98d2 100644 --- a/crates/artesian-core/tests/config_contract.rs +++ b/crates/artesian-core/tests/config_contract.rs @@ -1,7 +1,7 @@ // SPDX-License-Identifier: Apache-2.0 use artesian_core::{ - AccConfig, AccLlmConfig, AgentBinding, ArtesianConfig, Role, DEFAULT_RERANK_CANDIDATES, + AccConfig, AccLlmConfig, AgentBinding, ArtesianConfig, DEFAULT_RERANK_CANDIDATES, Role, }; #[test] diff --git a/crates/artesian-mcp/src/lib.rs b/crates/artesian-mcp/src/lib.rs index dcf69d7..a3177be 100644 --- a/crates/artesian-mcp/src/lib.rs +++ b/crates/artesian-mcp/src/lib.rs @@ -16,39 +16,40 @@ use std::{ use std::env; use aquifer::{ - insert_skill_procedure_metadata, normalize_project, skill_procedure_from_metadata, AnchorAnchorStore, FilesBackend, MemoryBackend, MemoryQuery, MemoryRecord, MemoryScope, - MemoryTier, ProcedureStep, Relation, SearchHit, SessionAnchor, SessionKey, SessionStore, + MemoryTier, ProcedureStep, Relation, SESSION_RECORD_TAG, SHARED_PROJECT, + SKILL_PROCEDURE_METADATA_KEY, SearchHit, SessionAnchor, SessionKey, SessionStore, SessionSummary, SqliteVecVectorStore, SqliteVecVectorStoreConfig, StoreMemory, - VectorMemoryBackend, VectorMemoryConfig, SESSION_RECORD_TAG, SHARED_PROJECT, - SKILL_PROCEDURE_METADATA_KEY, UNTAGGED_PROJECT_LABEL, + UNTAGGED_PROJECT_LABEL, VectorMemoryBackend, VectorMemoryConfig, + insert_skill_procedure_metadata, normalize_project, skill_procedure_from_metadata, }; use artesian_core::{ AccConfig, Agent, AgentBinding, AgentCatalog, AgentMessage, ArtesianConfig, MemoryBackendKind, MemoryConfig, Mode, Role, SpawnRequest, }; use artesian_process_agent::{ - fallback_agent_catalog, load_or_refresh_agent_catalog, validate_binding_model, ProcessAgent, - ProcessAgentConfig, ProcessSupervisor, + ProcessAgent, ProcessAgentConfig, ProcessSupervisor, fallback_agent_catalog, + load_or_refresh_agent_catalog, validate_binding_model, }; use flume::{ - classify_task_difficulty, covers_capabilities, load_role_definitions, loop_core, - normalize_capabilities, role_summaries, strip_mutating_tools, AgentRoutingProfile, Lane, - LaneBudget, LaneContract, RoutingConfig, RoutingTier, TeamCreate, TeamGcOptions, TeamLaneAdd, - TeamLaneAssignTask, TeamMessage, TeamMessageKind, TeamRuntime, TeamRuntimeConfig, TeamSpawn, - TeamTaskAdd, TeamTaskClaim, TeamTaskComplete, ROUTING_TRACE_TAG, + AgentRoutingProfile, Lane, LaneBudget, LaneContract, ROUTING_TRACE_TAG, RoutingConfig, + RoutingTier, TeamCreate, TeamGcOptions, TeamLaneAdd, TeamLaneAssignTask, TeamMessage, + TeamMessageKind, TeamRuntime, TeamRuntimeConfig, TeamSpawn, TeamTaskAdd, TeamTaskClaim, + TeamTaskComplete, classify_task_difficulty, covers_capabilities, load_role_definitions, + loop_core, normalize_capabilities, role_summaries, strip_mutating_tools, }; use headgate::{ - count_tokens, load_savings_rollup, record_savings, CcsSchema, CommittedContextState, - CommittedEntry, DefaultQualifyGate, Headgate, HeadgateConfig, JudgeCostSavings, LifecycleEntry, - MemoryRecallStore, OpSavings, QualifyAudit, QualifyDecision, QualifyGate, QualifySignal, - RecallItem, RecallStore, Resolution, SnapshotEntry, TokenSavingsRollup, WorkingContextBundle, - WorkingContextSnapshot, + CcsSchema, CommittedContextState, CommittedEntry, DefaultQualifyGate, Headgate, HeadgateConfig, + JudgeCostSavings, LifecycleEntry, MemoryRecallStore, OpSavings, QualifyAudit, QualifyDecision, + QualifyGate, QualifySignal, RecallItem, RecallStore, Resolution, SnapshotEntry, + TokenSavingsRollup, WorkingContextBundle, WorkingContextSnapshot, count_tokens, + load_savings_rollup, record_savings, }; use headrace::{ ClaimRequest, FilesTaskStore, NewTask, Task, TaskStatus, TaskStore, TransitionTask, }; use rmcp::{ + ErrorData, Peer, RoleServer, ServerHandler, ServiceExt, handler::server::{ router::tool::ToolRouter, wrapper::{Json, Parameters}, @@ -56,7 +57,6 @@ use rmcp::{ model::{Meta, ProgressNotificationParam, ProgressToken, ServerCapabilities, ServerInfo}, schemars, tool, tool_handler, tool_router, transport::stdio, - ErrorData, Peer, RoleServer, ServerHandler, ServiceExt, }; use serde::{Deserialize, Serialize}; use tokio::sync::Mutex as AsyncMutex; @@ -5110,7 +5110,7 @@ pub async fn run_http_with_routing( bind: std::net::SocketAddr, ) -> anyhow::Result<()> { use rmcp::transport::streamable_http_server::{ - session::local::LocalSessionManager, StreamableHttpService, + StreamableHttpService, session::local::LocalSessionManager, }; let memory_config = config.memory.clone(); let router_enabled = config.coordination.router_enabled; @@ -5305,18 +5305,15 @@ fn tool_registry() -> &'static [RegisteredTool] { }, RegisteredTool { name: "memory.anchor.set", - description: - "Write current task, plan pointer, decisions, and next step to headwater log.md.", + description: "Write current task, plan pointer, decisions, and next step to headwater log.md.", }, RegisteredTool { name: "memory.session.checkpoint", - description: - "Checkpoint a resumable OCF session before yielding to another agent.", + description: "Checkpoint a resumable OCF session before yielding to another agent.", }, RegisteredTool { name: "memory.session.resume", - description: - "Resume a committed OCF session by user_id/session_id/task_id without matching agent_id.", + description: "Resume a committed OCF session by user_id/session_id/task_id without matching agent_id.", }, RegisteredTool { name: "agents.list", @@ -6059,8 +6056,8 @@ fn first_line_or_default(input: &str) -> String { #[cfg(test)] mod tests { use std::sync::{ - atomic::{AtomicBool, Ordering}, Arc, + atomic::{AtomicBool, Ordering}, }; use aquifer::{MemoryResult, SearchHit}; diff --git a/crates/artesian-mcp/tests/memory_tools.rs b/crates/artesian-mcp/tests/memory_tools.rs index abc39a1..3ac703d 100644 --- a/crates/artesian-mcp/tests/memory_tools.rs +++ b/crates/artesian-mcp/tests/memory_tools.rs @@ -22,7 +22,7 @@ use artesian_mcp::{ ToolsFindRequest, }; use artesian_test_support::TempDir; -use flume::{AgentRoutingProfile, RoutingConfig, ROUTING_TRACE_TAG}; +use flume::{AgentRoutingProfile, ROUTING_TRACE_TAG, RoutingConfig}; use rmcp::handler::server::wrapper::Parameters; use tokio_util::sync::CancellationToken; @@ -355,10 +355,12 @@ async fn memory_qualify_returns_audited_admit_and_reject_decisions() { .0; assert!(!rejected.admitted, "{rejected:?}"); assert!(rejected.reason.contains("redundant")); - assert!(rejected - .signals - .iter() - .any(|signal| signal.name == "novelty" && !signal.passed)); + assert!( + rejected + .signals + .iter() + .any(|signal| signal.name == "novelty" && !signal.passed) + ); } #[tokio::test] @@ -529,10 +531,12 @@ async fn memory_session_default_key_round_trips_when_identity_is_unset() { .await .expect("default resume should succeed") .0; - assert!(resumed.packet["restored_working_state"] - .as_str() - .expect("state should be text") - .contains("default session task")); + assert!( + resumed.packet["restored_working_state"] + .as_str() + .expect("state should be text") + .contains("default session task") + ); } #[tokio::test] @@ -562,10 +566,12 @@ async fn tools_find_is_opt_in_and_reports_token_delta() { assert!(!response.tools.is_empty()); assert!(response.prompt_tokens_delta > 0); - assert!(response - .tools - .iter() - .any(|tool| tool.name == "memory.anchor.get" || tool.name == "memory.find")); + assert!( + response + .tools + .iter() + .any(|tool| tool.name == "memory.anchor.get" || tool.name == "memory.find") + ); } #[tokio::test] @@ -640,11 +646,13 @@ async fn agents_list_surfaces_role_definitions() { .expect("agents.list should run") .0; - assert!(response - .catalog - .roles - .iter() - .any(|role| role.name == "security-reviewer" && role.kind == Role::Worker)); + assert!( + response + .catalog + .roles + .iter() + .any(|role| role.name == "security-reviewer" && role.kind == Role::Worker) + ); } #[tokio::test] @@ -1273,10 +1281,12 @@ async fn team_run_blocks_returns_all_results_and_emits_progress() { assert_eq!(response.outcome, "completed"); assert_eq!(response.await_outcome, "completed"); assert_eq!(response.results.len(), 2); - assert!(response - .results - .iter() - .all(|result| result.status == "done")); + assert!( + response + .results + .iter() + .all(|result| result.status == "done") + ); assert!(response.results.iter().all(|result| { result .output diff --git a/crates/artesian-process-agent/Cargo.toml b/crates/artesian-process-agent/Cargo.toml index 2f7d119..13d745e 100644 --- a/crates/artesian-process-agent/Cargo.toml +++ b/crates/artesian-process-agent/Cargo.toml @@ -3,7 +3,10 @@ [package] name = "artesian-process-agent" version.workspace = true -edition.workspace = true +# Stays on edition 2021: these crates set process env vars, which edition 2024 +# makes unsafe, and the workspace forbids unsafe on purpose. Finish the move +# once the env reads are injectable rather than global. +edition = "2021" rust-version.workspace = true license.workspace = true diff --git a/crates/basin/src/lib.rs b/crates/basin/src/lib.rs index 3c347a0..affe135 100644 --- a/crates/basin/src/lib.rs +++ b/crates/basin/src/lib.rs @@ -14,7 +14,7 @@ use artesian_core::{ TokenAccounting, }; use chrono::Utc; -use futures_util::{future::BoxFuture, stream, FutureExt}; +use futures_util::{FutureExt, future::BoxFuture, stream}; use headrace::{ ClaimRequest, Task, TaskError, TaskStatus, TaskStore, TransitionTask, VerifierGate, }; diff --git a/crates/basin/tests/orchestrator.rs b/crates/basin/tests/orchestrator.rs index 05b0f33..344cb1e 100644 --- a/crates/basin/tests/orchestrator.rs +++ b/crates/basin/tests/orchestrator.rs @@ -2,8 +2,8 @@ use std::{ sync::{ - atomic::{AtomicUsize, Ordering}, Arc, + atomic::{AtomicUsize, Ordering}, }, time::Duration, }; @@ -15,7 +15,7 @@ use artesian_core::{ }; use artesian_test_support::TempDir; use basin::{Orchestrator, OrchestratorConfig, OrchestratorError}; -use futures_util::{future::BoxFuture, stream, FutureExt}; +use futures_util::{FutureExt, future::BoxFuture, stream}; use headrace::{ FilesTaskStore, NewTask, Task, TaskResult, TaskStatus, TaskStore, Verifier, VerifierGate, VerifierOutcome, @@ -158,11 +158,13 @@ async fn concurrency_limit_and_resource_quota_are_honored() { let report = orchestrator.run_once().await.expect("tick should run"); assert_eq!(report.dispatched, 1); - assert!(orchestrator - .run_log() - .events - .iter() - .any(|event| event.event_type == EventType::Status)); + assert!( + orchestrator + .run_log() + .events + .iter() + .any(|event| event.event_type == EventType::Status) + ); } #[tokio::test] diff --git a/crates/flume/examples/emit_receipts.rs b/crates/flume/examples/emit_receipts.rs index 6b448a0..3f0c984 100644 --- a/crates/flume/examples/emit_receipts.rs +++ b/crates/flume/examples/emit_receipts.rs @@ -12,8 +12,8 @@ use std::env; use chrono::Utc; use flume::{ - task_boundary_from_instruction, BudgetEnvelope, Consumed, Distilled, GateDecision, - ReceiptWriter, ReturnReceipt, SpawnReceipt, StopReason, + BudgetEnvelope, Consumed, Distilled, GateDecision, ReceiptWriter, ReturnReceipt, SpawnReceipt, + StopReason, task_boundary_from_instruction, }; use serde_json::Map; diff --git a/crates/flume/src/consolidation.rs b/crates/flume/src/consolidation.rs index 5230462..f602499 100644 --- a/crates/flume/src/consolidation.rs +++ b/crates/flume/src/consolidation.rs @@ -19,9 +19,8 @@ use std::{ use aquifer::{MemoryBackend, SessionKey, SessionListFilter, SessionStore, SessionSummary}; use headgate::{ - count_tokens, CcsSchema, CommittedContextState, CommittedEntry, LifecycleEntry, - QualifyDecision, QualifyGate, RecallItem, SnapshotEntry, WorkingContextBundle, - WorkingContextSnapshot, + CcsSchema, CommittedContextState, CommittedEntry, LifecycleEntry, QualifyDecision, QualifyGate, + RecallItem, SnapshotEntry, WorkingContextBundle, WorkingContextSnapshot, count_tokens, }; use serde::{Deserialize, Serialize}; use serde_json::Value; @@ -798,10 +797,12 @@ async fn write_skill_ocf_session( token_count, entries, }; - let lifecycle = vec![decision - .audit - .map(|audit| LifecycleEntry::commit_with_audit(edit.id.clone(), audit)) - .unwrap_or_else(|| LifecycleEntry::commit(edit.id.clone()))]; + let lifecycle = vec![ + decision + .audit + .map(|audit| LifecycleEntry::commit_with_audit(edit.id.clone(), audit)) + .unwrap_or_else(|| LifecycleEntry::commit(edit.id.clone())), + ]; let bundle = WorkingContextBundle::new(snapshot, lifecycle); let key = SessionKey::new( Some("flume".to_string()), diff --git a/crates/flume/src/lib.rs b/crates/flume/src/lib.rs index a70e900..9ccadec 100644 --- a/crates/flume/src/lib.rs +++ b/crates/flume/src/lib.rs @@ -13,9 +13,9 @@ pub use lane::{ TeammatePresence, }; pub use receipts::{ - check_admission, task_boundary_from_instruction, BudgetEnvelope, Consumed, Distilled, - GateDecision, ReceiptWriter, ReceiptsConfig, ReturnReceipt, SpawnReceipt, StopReason, - ARTESIAN_RECEIPTS_FAIL_CLOSED_ENV, RECEIPT_TASK_BOUNDARY_CHARS, + ARTESIAN_RECEIPTS_FAIL_CLOSED_ENV, BudgetEnvelope, Consumed, Distilled, GateDecision, + RECEIPT_TASK_BOUNDARY_CHARS, ReceiptWriter, ReceiptsConfig, ReturnReceipt, SpawnReceipt, + StopReason, check_admission, task_boundary_from_instruction, }; use std::{ @@ -33,9 +33,9 @@ use artesian_core::{ EventEnvelope, EventSender, EventType, Role, SpawnRequest, }; use artesian_process_agent::{ - apply_native_subagent_runtime_hints, detect_native_subagent_runtime, validate_binding_model, GcOptions, NativeSubagentDetection, NativeSubagentRuntimeKind, ProcessAgent, ProcessAgentConfig, ProcessSupervisor, ReapReport, WorkerEvent, + apply_native_subagent_runtime_hints, detect_native_subagent_runtime, validate_binding_model, }; pub use artesian_process_agent::{GcOptions as TeamGcOptions, ReapReport as TeamReapReport}; use headgate::count_tokens; diff --git a/crates/flume/src/loop_core.rs b/crates/flume/src/loop_core.rs index 9df943a..6c4274a 100644 --- a/crates/flume/src/loop_core.rs +++ b/crates/flume/src/loop_core.rs @@ -31,11 +31,11 @@ use aquifer::{ StoreMemory, }; use headgate::{count_tokens, record_savings}; -use serde_json::{json, Value}; +use serde_json::{Value, json}; use crate::quota::{ + QUOTA_CONTINUATION_NOTE, QuotaContinuationContext, QuotaLoopConfig, QuotaThresholdEvent, quota_threshold_events, read_local_quota_with_options, write_quota_continuation, - QuotaContinuationContext, QuotaLoopConfig, QuotaThresholdEvent, QUOTA_CONTINUATION_NOTE, }; // ── Brakes / constants ───────────────────────────────────────────────────────────────────────── @@ -1529,10 +1529,12 @@ mod tests { .expect("quota anchor should exist"); assert_eq!(anchor.current_task, "Loop goal: goal-cmd"); assert!(anchor.next_step.contains(QUOTA_CONTINUATION_NOTE)); - assert!(anchor - .last_decisions - .iter() - .any(|decision| decision == QUOTA_CONTINUATION_NOTE)); + assert!( + anchor + .last_decisions + .iter() + .any(|decision| decision == QUOTA_CONTINUATION_NOTE) + ); let session = SessionStore::new(Arc::new(backend)) .load(&key) @@ -1542,10 +1544,12 @@ mod tests { let packet = headgate::WorkingContextBundle::resume_packet_from_session(&session) .expect("resume packet should render"); assert_eq!(packet["goal"], "Loop goal: goal-cmd"); - assert!(packet["restored_working_state"] - .as_str() - .unwrap() - .contains(QUOTA_CONTINUATION_NOTE)); + assert!( + packet["restored_working_state"] + .as_str() + .unwrap() + .contains(QUOTA_CONTINUATION_NOTE) + ); } // ── Remediation arc tests ───────────────────────────────────────────────────────────────── diff --git a/crates/flume/src/quota.rs b/crates/flume/src/quota.rs index c4ebfdb..845105d 100644 --- a/crates/flume/src/quota.rs +++ b/crates/flume/src/quota.rs @@ -14,8 +14,8 @@ use std::{ }; use aquifer::{ - MemoryBackend, MemoryScope, MemoryTier, Session, SessionAnchor, SessionKey, SessionSummary, - StoreMemory, SESSION_RECORD_SOURCE, SESSION_RECORD_TAG, + MemoryBackend, MemoryScope, MemoryTier, SESSION_RECORD_SOURCE, SESSION_RECORD_TAG, Session, + SessionAnchor, SessionKey, SessionSummary, StoreMemory, }; use chrono::{DateTime, TimeZone, Utc}; use headgate::{SnapshotEntry, WorkingContextBundle, WorkingContextSnapshot}; @@ -1119,9 +1119,11 @@ mod tests { .expect("fixture should parse"); let statuses = materialize_agent_windows("codex", None, parsed); - assert!(statuses - .iter() - .all(|status| status.status == QuotaStatusKind::Known)); + assert!( + statuses + .iter() + .all(|status| status.status == QuotaStatusKind::Known) + ); assert!(statuses.iter().all(|status| status.pct == Some(0.0))); assert!(quota_threshold_events(&statuses, 1.0, 95.0).is_empty()); } @@ -1134,9 +1136,11 @@ mod tests { }; let statuses = read_local_quota_with_options(&options); assert_eq!(statuses.len(), 4); - assert!(statuses - .iter() - .all(|status| status.status == QuotaStatusKind::Unknown)); + assert!( + statuses + .iter() + .all(|status| status.status == QuotaStatusKind::Unknown) + ); } #[test] diff --git a/crates/flume/src/receipts.rs b/crates/flume/src/receipts.rs index 909d476..75b12a3 100644 --- a/crates/flume/src/receipts.rs +++ b/crates/flume/src/receipts.rs @@ -18,8 +18,8 @@ use std::{ fs, io, path::{Path, PathBuf}, sync::{ - atomic::{AtomicU64, Ordering}, Arc, Mutex, OnceLock, PoisonError, + atomic::{AtomicU64, Ordering}, }, }; diff --git a/crates/gauge/src/agentic.rs b/crates/gauge/src/agentic.rs index ed3fa10..8b28e11 100644 --- a/crates/gauge/src/agentic.rs +++ b/crates/gauge/src/agentic.rs @@ -30,8 +30,8 @@ mod runner { use std::sync::Arc; use headgate::{ - count_tokens, Headgate, HeadgateConfig, LlmClient, LlmRequest, RecallItem, RecallStore, - StaticRecallStore, + Headgate, HeadgateConfig, LlmClient, LlmRequest, RecallItem, RecallStore, + StaticRecallStore, count_tokens, }; use serde::{Deserialize, Serialize}; @@ -201,7 +201,7 @@ Context:\n{committed}\n\nQuestion: {query}\n\nChoices:\n{joined}\n\nYour choice mod tests { use super::*; use crate::agentic::{AgentTask, TaskSession}; - use futures_util::{future::BoxFuture, FutureExt}; + use futures_util::{FutureExt, future::BoxFuture}; use headgate::HeadgateResult; struct PickFirstClient; @@ -372,7 +372,7 @@ pub fn load_agent_tasks(json: &str) -> Result, serde_json::Error> } #[cfg(feature = "llm")] -pub use runner::{run_agent_task, run_agentic_eval, AgentTaskOutcome, AgenticEvalSummary}; +pub use runner::{AgentTaskOutcome, AgenticEvalSummary, run_agent_task, run_agentic_eval}; #[cfg(test)] mod unit_tests { diff --git a/crates/gauge/src/bench.rs b/crates/gauge/src/bench.rs index d40acac..e236819 100644 --- a/crates/gauge/src/bench.rs +++ b/crates/gauge/src/bench.rs @@ -27,8 +27,8 @@ use std::collections::HashMap; use std::sync::Arc; use headgate::{ - count_tokens, DefaultQualifyGate, Headgate, HeadgateConfig, HeadgateResult, QualifyGate, - RecallItem, StaticRecallStore, + DefaultQualifyGate, Headgate, HeadgateConfig, HeadgateResult, QualifyGate, RecallItem, + StaticRecallStore, count_tokens, }; use serde::{Deserialize, Serialize}; @@ -275,7 +275,7 @@ mod tests { #[cfg(feature = "llm")] #[tokio::test] async fn judge_gate_eliminates_the_admitted_fabrication() { - use futures_util::{future::BoxFuture, FutureExt}; + use futures_util::{FutureExt, future::BoxFuture}; use headgate::{HeadgateResult, JudgeQualifyGate, LlmClient, LlmRequest}; // A scripted judge: flags content mentioning Mars/quantum as high-drift fabrication, diff --git a/crates/gauge/src/bin/gauge_ci_eval.rs b/crates/gauge/src/bin/gauge_ci_eval.rs index 42fac28..e538d78 100644 --- a/crates/gauge/src/bin/gauge_ci_eval.rs +++ b/crates/gauge/src/bin/gauge_ci_eval.rs @@ -16,8 +16,8 @@ fn main() { #[tokio::main] async fn main() -> Result<(), Box> { use gauge::{ - compare_to_baseline, load_report, render_regression_markdown, run_regression_suite, - write_report, DEFAULT_K, DEFAULT_TOLERANCE, + DEFAULT_K, DEFAULT_TOLERANCE, compare_to_baseline, load_report, render_regression_markdown, + run_regression_suite, write_report, }; use std::path::PathBuf; diff --git a/crates/gauge/src/bin/gauge_eval.rs b/crates/gauge/src/bin/gauge_eval.rs index 3736198..91f6d1f 100644 --- a/crates/gauge/src/bin/gauge_eval.rs +++ b/crates/gauge/src/bin/gauge_eval.rs @@ -19,7 +19,7 @@ fn main() { #[tokio::main] async fn main() -> Result<(), Box> { use gauge::{ - load_locomo, load_longmemeval, run_qa_eval, ExpandingRecall, LexicalRecall, RecallFactory, + ExpandingRecall, LexicalRecall, RecallFactory, load_locomo, load_longmemeval, run_qa_eval, }; use headgate::{CommandLlmClient, HeadgateConfig, LlmClient}; use std::sync::Arc; diff --git a/crates/gauge/src/eval.rs b/crates/gauge/src/eval.rs index 54ed127..8727148 100644 --- a/crates/gauge/src/eval.rs +++ b/crates/gauge/src/eval.rs @@ -22,8 +22,8 @@ mod runner { use std::sync::Arc; use headgate::{ - count_tokens, Headgate, HeadgateConfig, LlmClient, LlmRequest, RecallItem, RecallStore, - StaticRecallStore, + Headgate, HeadgateConfig, LlmClient, LlmRequest, RecallItem, RecallStore, + StaticRecallStore, count_tokens, }; use serde::{Deserialize, Serialize}; @@ -516,7 +516,7 @@ was phrased. One per line, no numbering, preserve meaning.\n\nQuestion: {query}" mod tests { use super::*; use crate::eval::QaCase; - use futures_util::{future::BoxFuture, FutureExt}; + use futures_util::{FutureExt, future::BoxFuture}; use headgate::HeadgateResult; /// Answers with a canned string and grades every answer "yes". @@ -641,8 +641,8 @@ was phrased. One per line, no numbering, preserve meaning.\n\nQuestion: {query}" pub use runner::VectorRecall; #[cfg(feature = "llm")] pub use runner::{ - run_case, run_qa_eval, CaseOutcome, EvalSummary, ExpandingRecall, ExpandingRecallStore, - LexicalRecall, RecallFactory, + CaseOutcome, EvalSummary, ExpandingRecall, ExpandingRecallStore, LexicalRecall, RecallFactory, + run_case, run_qa_eval, }; use serde::{Deserialize, Serialize}; diff --git a/crates/gauge/src/lib.rs b/crates/gauge/src/lib.rs index dc7e24a..fbf2491 100644 --- a/crates/gauge/src/lib.rs +++ b/crates/gauge/src/lib.rs @@ -9,26 +9,26 @@ pub mod eval; #[cfg(feature = "ci-eval")] pub mod retrieval_regression; -pub use agentic::{load_agent_tasks, AgentTask, ScaleLane, TaskSession}; +pub use agentic::{AgentTask, ScaleLane, TaskSession, load_agent_tasks}; #[cfg(feature = "llm")] -pub use agentic::{run_agent_task, run_agentic_eval, AgentTaskOutcome, AgenticEvalSummary}; +pub use agentic::{AgentTaskOutcome, AgenticEvalSummary, run_agent_task, run_agentic_eval}; pub use bench::{ - demo_case, render_markdown, run_bench, run_default_arm, BenchCase, BenchResult, FactLabel, - LabeledFact, + BenchCase, BenchResult, FactLabel, LabeledFact, demo_case, render_markdown, run_bench, + run_default_arm, }; #[cfg(all(feature = "llm", feature = "vector"))] pub use eval::VectorRecall; -pub use eval::{load_locomo, load_longmemeval, LoadReport, QaCase}; #[cfg(feature = "llm")] pub use eval::{ - run_case, run_qa_eval, CaseOutcome, EvalSummary, ExpandingRecall, ExpandingRecallStore, - LexicalRecall, RecallFactory, + CaseOutcome, EvalSummary, ExpandingRecall, ExpandingRecallStore, LexicalRecall, RecallFactory, + run_case, run_qa_eval, }; +pub use eval::{LoadReport, QaCase, load_locomo, load_longmemeval}; #[cfg(feature = "ci-eval")] pub use retrieval_regression::{ - compare_to_baseline, load_report, render_regression_markdown, run_regression_suite, - write_report, BackendMetrics, BaselineComparison, CaseMetrics, LeakGateReport, - RegressionReport, DEFAULT_K, DEFAULT_TOLERANCE, + BackendMetrics, BaselineComparison, CaseMetrics, DEFAULT_K, DEFAULT_TOLERANCE, LeakGateReport, + RegressionReport, compare_to_baseline, load_report, render_regression_markdown, + run_regression_suite, write_report, }; use serde::{Deserialize, Serialize}; diff --git a/crates/gauge/src/retrieval_regression.rs b/crates/gauge/src/retrieval_regression.rs index 4f25d25..4342574 100644 --- a/crates/gauge/src/retrieval_regression.rs +++ b/crates/gauge/src/retrieval_regression.rs @@ -15,9 +15,9 @@ use std::{ }; use aquifer::{ - FilesBackend, MemoryBackend, MemoryQuery, MemoryResult, MemoryTier, SearchHit, - SqliteVecVectorStore, StoreMemory, TextEmbedder, VectorMemoryBackend, VectorMemoryConfig, - PINNED_FASTEMBED_DIMENSIONS, + FilesBackend, MemoryBackend, MemoryQuery, MemoryResult, MemoryTier, + PINNED_FASTEMBED_DIMENSIONS, SearchHit, SqliteVecVectorStore, StoreMemory, TextEmbedder, + VectorMemoryBackend, VectorMemoryConfig, }; use serde::{Deserialize, Serialize}; @@ -808,18 +808,26 @@ mod tests { let report = run_files_leak_gate().await.expect("leak gate passes"); assert!(report.passed); - assert!(report - .project_hits - .contains(&"node:partition-a".to_string())); - assert!(!report - .project_hits - .contains(&"node:partition-b".to_string())); - assert!(!report - .default_hits - .contains(&"node:partition-a".to_string())); - assert!(!report - .default_hits - .contains(&"node:partition-b".to_string())); + assert!( + report + .project_hits + .contains(&"node:partition-a".to_string()) + ); + assert!( + !report + .project_hits + .contains(&"node:partition-b".to_string()) + ); + assert!( + !report + .default_hits + .contains(&"node:partition-a".to_string()) + ); + assert!( + !report + .default_hits + .contains(&"node:partition-b".to_string()) + ); } #[tokio::test] diff --git a/crates/headgate/src/bundle.rs b/crates/headgate/src/bundle.rs index b10a168..caf2b9c 100644 --- a/crates/headgate/src/bundle.rs +++ b/crates/headgate/src/bundle.rs @@ -1138,10 +1138,12 @@ mod tests { let packet = WorkingContextBundle::resume_packet_from_session(&session) .expect("resume packet should render"); assert_eq!(packet["session"]["handed_off_from"], "codex"); - assert!(packet["restored_working_state"] - .as_str() - .expect("state should be text") - .contains("ship the working-context bundle first")); + assert!( + packet["restored_working_state"] + .as_str() + .expect("state should be text") + .contains("ship the working-context bundle first") + ); } #[test] diff --git a/crates/headgate/src/compressor.rs b/crates/headgate/src/compressor.rs index 92cfb27..acdd5c5 100644 --- a/crates/headgate/src/compressor.rs +++ b/crates/headgate/src/compressor.rs @@ -1,8 +1,8 @@ // SPDX-License-Identifier: Apache-2.0 -use futures_util::{future::BoxFuture, FutureExt}; +use futures_util::{FutureExt, future::BoxFuture}; -use crate::{metrics::count_tokens, HeadgateResult}; +use crate::{HeadgateResult, metrics::count_tokens}; /// Compresses committed content to fit the saturation budget — the "cognitive compressor". /// diff --git a/crates/headgate/src/controller.rs b/crates/headgate/src/controller.rs index 5d4999f..9fe5cf6 100644 --- a/crates/headgate/src/controller.rs +++ b/crates/headgate/src/controller.rs @@ -6,7 +6,7 @@ use serde::{Deserialize, Serialize}; use crate::metrics::count_tokens; use crate::savings::{ - record_savings_to_dir_with_metadata, record_savings_with_metadata, TokenSavingsMetadata, + TokenSavingsMetadata, record_savings_to_dir_with_metadata, record_savings_with_metadata, }; use crate::{ CcsSchema, CommittedContextState, CommittedEntry, Compressor, DefaultQualifyGate, diff --git a/crates/headgate/src/council.rs b/crates/headgate/src/council.rs index 236e5b1..91a1a70 100644 --- a/crates/headgate/src/council.rs +++ b/crates/headgate/src/council.rs @@ -17,14 +17,13 @@ use std::sync::Arc; -use futures_util::{future::BoxFuture, FutureExt}; +use futures_util::{FutureExt, future::BoxFuture}; use serde_json::json; use crate::{ - count_tokens, - judge::{parse_verdict_pub, JudgeVerdict}, CommittedContextState, JudgeTokenCost, LlmClient, LlmRequest, QualifyAudit, QualifyDecision, - QualifyGate, QualifySignal, ReasonCode, RecallItem, + QualifyGate, QualifySignal, ReasonCode, RecallItem, count_tokens, + judge::{JudgeVerdict, parse_verdict_pub}, }; const PANEL_SYSTEM: &str = "You are a memory-control judge for an AI agent. Score whether a \ diff --git a/crates/headgate/src/gate.rs b/crates/headgate/src/gate.rs index 58be3a0..b1e1eba 100644 --- a/crates/headgate/src/gate.rs +++ b/crates/headgate/src/gate.rs @@ -1,6 +1,6 @@ // SPDX-License-Identifier: Apache-2.0 -use futures_util::{future::BoxFuture, FutureExt}; +use futures_util::{FutureExt, future::BoxFuture}; use serde::{Deserialize, Deserializer, Serialize, Serializer}; use crate::{CommittedContextState, JudgeTokenCost, RecallItem}; diff --git a/crates/headgate/src/headroom.rs b/crates/headgate/src/headroom.rs index 12cd757..b00f531 100644 --- a/crates/headgate/src/headroom.rs +++ b/crates/headgate/src/headroom.rs @@ -57,7 +57,7 @@ //! back to the inner `Compressor` transparently. headroom is never in the failure path of the //! ACC control loop. -use futures_util::{future::BoxFuture, FutureExt}; +use futures_util::{FutureExt, future::BoxFuture}; use crate::{Compressor, HeadgateResult}; diff --git a/crates/headgate/src/judge.rs b/crates/headgate/src/judge.rs index 688a2bc..32cffae 100644 --- a/crates/headgate/src/judge.rs +++ b/crates/headgate/src/judge.rs @@ -12,12 +12,12 @@ use std::sync::Arc; -use futures_util::{future::BoxFuture, FutureExt}; +use futures_util::{FutureExt, future::BoxFuture}; use serde::{Deserialize, Serialize}; use crate::{ - count_tokens, CommittedContextState, JudgeTokenCost, LlmClient, LlmRequest, QualifyAudit, - QualifyDecision, QualifyGate, QualifySignal, ReasonCode, RecallItem, + CommittedContextState, JudgeTokenCost, LlmClient, LlmRequest, QualifyAudit, QualifyDecision, + QualifyGate, QualifySignal, ReasonCode, RecallItem, count_tokens, }; const JUDGE_SYSTEM: &str = "You are a memory-control judge for an AI agent. You score whether a \ diff --git a/crates/headgate/src/lib.rs b/crates/headgate/src/lib.rs index 4b6972b..3d3b0ee 100644 --- a/crates/headgate/src/lib.rs +++ b/crates/headgate/src/lib.rs @@ -52,9 +52,9 @@ mod savings; mod tier; pub use bundle::{ - BundleError, BundleManifest, Decision, LifecycleEntry, LifecycleReason, OcfSession, - QualifyRecord, Resolution, SnapshotEntry, Status, WorkingContextBundle, WorkingContextSnapshot, - BUNDLE_FORMAT, BUNDLE_VERSION, + BUNDLE_FORMAT, BUNDLE_VERSION, BundleError, BundleManifest, Decision, LifecycleEntry, + LifecycleReason, OcfSession, QualifyRecord, Resolution, SnapshotEntry, Status, + WorkingContextBundle, WorkingContextSnapshot, }; pub use ccs::{CcsSchema, CommittedContextState, CommittedEntry}; pub use compressor::{Compressor, ExtractiveCompressor, NoopCompressor}; @@ -62,16 +62,16 @@ pub use controller::{Headgate, HeadgateConfig}; pub use gate::{ DefaultQualifyGate, QualifyAudit, QualifyDecision, QualifyGate, QualifySignal, ReasonCode, }; -pub use metrics::{count_tokens, GaugeMetrics}; +pub use metrics::{GaugeMetrics, count_tokens}; pub use position::{ - position_swap_debias, PairwiseChoice, PairwiseDecision, PairwiseJudge, PositionSwapAudit, - StaticPairwiseJudge, DEFAULT_POSITION_BIAS_THRESHOLD, + DEFAULT_POSITION_BIAS_THRESHOLD, PairwiseChoice, PairwiseDecision, PairwiseJudge, + PositionSwapAudit, StaticPairwiseJudge, position_swap_debias, }; pub use recall::{MemoryRecallStore, RecallItem, RecallStore, StaticRecallStore}; pub use savings::{ - load_savings_rollup, record_savings, record_savings_with_metadata, stats_dir, JudgeCostSavings, - JudgeTokenCost, OpSavings, TokenSavingsEntry, TokenSavingsMetadata, TokenSavingsRollup, - ARTESIAN_STATS_DIR_ENV, + ARTESIAN_STATS_DIR_ENV, JudgeCostSavings, JudgeTokenCost, OpSavings, TokenSavingsEntry, + TokenSavingsMetadata, TokenSavingsRollup, load_savings_rollup, record_savings, + record_savings_with_metadata, stats_dir, }; pub use tier::{JudgeTier, JudgeTierConfig, TieredQualifyGate}; @@ -87,8 +87,8 @@ pub use headroom::HeadroomCompressor; pub use judge::{JudgeQualifyGate, JudgeVerdict}; #[cfg(feature = "llm")] pub use llm::{ - llm_client_from_config, CommandLlmClient, LlmClient, LlmRequest, OpenAiCompatibleClient, - StaticLlmClient, + CommandLlmClient, LlmClient, LlmRequest, OpenAiCompatibleClient, StaticLlmClient, + llm_client_from_config, }; use thiserror::Error; diff --git a/crates/headgate/src/llm.rs b/crates/headgate/src/llm.rs index 7e23053..162c925 100644 --- a/crates/headgate/src/llm.rs +++ b/crates/headgate/src/llm.rs @@ -13,7 +13,7 @@ use std::collections::HashMap; use std::process::Stdio; use std::time::Duration; -use futures_util::{future::BoxFuture, FutureExt}; +use futures_util::{FutureExt, future::BoxFuture}; use serde::{Deserialize, Serialize}; use tokio::io::AsyncWriteExt; diff --git a/crates/headgate/src/metrics.rs b/crates/headgate/src/metrics.rs index 46a647d..f42ca56 100644 --- a/crates/headgate/src/metrics.rs +++ b/crates/headgate/src/metrics.rs @@ -3,7 +3,7 @@ use std::sync::OnceLock; use serde::{Deserialize, Serialize}; -use tiktoken_rs::{cl100k_base, CoreBPE}; +use tiktoken_rs::{CoreBPE, cl100k_base}; fn tokenizer() -> Option<&'static CoreBPE> { static TOKENIZER: OnceLock> = OnceLock::new(); diff --git a/crates/headgate/src/position.rs b/crates/headgate/src/position.rs index 461644c..0ded200 100644 --- a/crates/headgate/src/position.rs +++ b/crates/headgate/src/position.rs @@ -2,7 +2,7 @@ //! Position-swap debiasing for order-sensitive pairwise judges. -use futures_util::{future::BoxFuture, FutureExt}; +use futures_util::{FutureExt, future::BoxFuture}; use serde::{Deserialize, Serialize}; use crate::{CommittedContextState, RecallItem}; diff --git a/crates/headgate/src/recall.rs b/crates/headgate/src/recall.rs index 792139a..409bb4f 100644 --- a/crates/headgate/src/recall.rs +++ b/crates/headgate/src/recall.rs @@ -1,6 +1,6 @@ // SPDX-License-Identifier: Apache-2.0 -use futures_util::{future::BoxFuture, FutureExt}; +use futures_util::{FutureExt, future::BoxFuture}; use aquifer::{MemoryBackend, MemoryQuery}; diff --git a/crates/headgate/src/tier.rs b/crates/headgate/src/tier.rs index 1605c10..ea4e02a 100644 --- a/crates/headgate/src/tier.rs +++ b/crates/headgate/src/tier.rs @@ -4,7 +4,7 @@ use std::sync::Arc; -use futures_util::{future::BoxFuture, FutureExt}; +use futures_util::{FutureExt, future::BoxFuture}; use serde::{Deserialize, Serialize}; use crate::{CommittedContextState, QualifyAudit, QualifyDecision, QualifyGate, RecallItem}; @@ -146,7 +146,7 @@ impl QualifyGate for TieredQualifyGate { #[cfg(test)] mod tests { use super::*; - use futures_util::{future::BoxFuture, FutureExt}; + use futures_util::{FutureExt, future::BoxFuture}; use crate::CcsSchema; diff --git a/crates/headrace/src/files.rs b/crates/headrace/src/files.rs index 76cdf99..05592d7 100644 --- a/crates/headrace/src/files.rs +++ b/crates/headrace/src/files.rs @@ -7,7 +7,7 @@ use std::{ }; use chrono::{DateTime, Utc}; -use futures_util::{future::BoxFuture, FutureExt}; +use futures_util::{FutureExt, future::BoxFuture}; use serde::{Deserialize, Serialize}; use sha2::{Digest, Sha256}; diff --git a/crates/headrace/src/vector.rs b/crates/headrace/src/vector.rs index db2bdc5..2e26ac8 100644 --- a/crates/headrace/src/vector.rs +++ b/crates/headrace/src/vector.rs @@ -3,7 +3,7 @@ use std::sync::Arc; use aquifer::{MemoryBackend, MemoryQuery, MemoryTier, StoreMemory}; -use futures_util::{future::BoxFuture, FutureExt}; +use futures_util::{FutureExt, future::BoxFuture}; use crate::{ ClaimRequest, FilesTaskStore, NewTask, Task, TaskImportOutcome, TaskResult, TaskStore, diff --git a/crates/headrace/src/verifier.rs b/crates/headrace/src/verifier.rs index 2012b50..9ced719 100644 --- a/crates/headrace/src/verifier.rs +++ b/crates/headrace/src/verifier.rs @@ -2,7 +2,7 @@ use std::{path::PathBuf, sync::Arc}; -use futures_util::{future::BoxFuture, FutureExt}; +use futures_util::{FutureExt, future::BoxFuture}; use tokio::process::Command; use crate::{Task, TaskError, TaskResult, TaskStatus, TaskStore, TransitionTask}; diff --git a/crates/headrace/tests/task_store.rs b/crates/headrace/tests/task_store.rs index d1335d6..961295b 100644 --- a/crates/headrace/tests/task_store.rs +++ b/crates/headrace/tests/task_store.rs @@ -4,7 +4,7 @@ use std::sync::Arc; use aquifer::FilesBackend; use artesian_test_support::TempDir; -use futures_util::{future::BoxFuture, FutureExt}; +use futures_util::{FutureExt, future::BoxFuture}; use headrace::{ ClaimRequest, FilesTaskStore, NewTask, Task, TaskKind, TaskStatus, TaskStore, VectorTaskStore, Verifier, VerifierGate, VerifierOutcome, @@ -382,8 +382,10 @@ async fn claims_and_transitions_a_task_whose_file_name_carries_a_slug() { }) .await .expect("transition should find the file by id, not by name"); - assert!(tempdir - .join("tasks/done/0034-unified-vps-management.md") - .exists()); + assert!( + tempdir + .join("tasks/done/0034-unified-vps-management.md") + .exists() + ); assert!(!tempdir.join("tasks/done/0034.md").exists()); } diff --git a/crates/sandbox/src/lib.rs b/crates/sandbox/src/lib.rs index ec8b2ae..9c9d1af 100644 --- a/crates/sandbox/src/lib.rs +++ b/crates/sandbox/src/lib.rs @@ -7,7 +7,7 @@ use std::{ time::{SystemTime, UNIX_EPOCH}, }; -use futures_util::{future::BoxFuture, FutureExt}; +use futures_util::{FutureExt, future::BoxFuture}; use serde::{Deserialize, Serialize}; use thiserror::Error;