EpicGames/lore

Lore is a distributed revision control system designed for large-scale code repositories, featuring a modular architecture with a Rust-based server and a C-compatible client library. It manages repository state through a content-addressed storage backend that supports AWS S3 and DynamoDB, utilizing QUIC and gRPC for high-performance, low-latency communication between clients and servers. The system provides comprehensive version control capabilities including branch management, file locking, nested repository linking, and sparse checkout views, while enforcing strict access control via JWT-based authentication and authorization policies.

New scripts have been added to the \scripts/allocations\ directory to help users measure and analyze memory allocation behavior. The C library \allocount.c\ interposes standard allocator functions (malloc, calloc, realloc, free, posix\_memalign) to count calls and report totals to a file or stderr, while the Python script \attribute.py\ parses allocation dump files to attribute memory usage to specific source lines within the \lore-revision\ codebase.

scripts/allocations · high confidence

The Lore service now supports local inter-process communication via Unix domain sockets on Linux, macOS, and Windows. This change introduces platform-specific network modules (\unix.rs\, \windows.rs\, and a \stub.rs\ fallback) that handle socket lifecycle, binding, and connection. On Linux and macOS, sockets are stored in user-specific runtime directories (using \XDG\_RUNTIME\_DIR\ or \TMPDIR\) with restricted permissions to ensure security. On Windows, the implementation uses WinSock to emulate Unix domain sockets via named pipes, ensuring compatibility with the existing service architecture. This enables the Lore client to reliably detect and connect to a running background service on all supported operating systems.

lore/src/remote/network · high confidence

The lore-io crate now includes a suite of examples for performance analysis and debugging. The \bench\ example provides a comprehensive micro-benchmarking harness that compares the lore-io library against standard blocking I/O and tokio-fs, supporting warm and cold read/write workloads with configurable concurrency and data sizes. Additional tools include \handle-fanout\ to diagnose file handle contention by varying the number of open handles, \pool-sweep\ to analyze the impact of the syscall thread pool size on throughput, and \build-ab\ to facilitate interleaved A/B testing of different binary builds. These examples are designed to help users measure and optimize I/O performance on their specific hardware and workloads.

lore-io/examples · high confidence

The CLI now manages a dedicated background service process that listens for connections via Unix domain sockets. This entry adds the core logic for starting the service, registering termination signal handlers before the socket becomes reachable to ensure graceful shutdown, and handling stop requests via IPC. It also includes a check to warn users if the running service executable differs from the one configured in the global settings.

lore-client/src/cli/commands/service · high confidence

Added the \RevisionService\ gRPC definition in \lore-proto/proto/lore/revision/v1/revision.proto\, establishing the contract for branch lifecycle and revision history operations. The service exposes RPCs for creating, deleting, and retrieving branches (\BranchCreate\, \BranchDelete\, \BranchGet\), listing branches with filtering support (\BranchList\), updating branch tips with force or fast-forward merge semantics (\BranchPush\), and managing branch metadata via compare-and-swap (\BranchMetadataGet\, \BranchMetadataSet\). It also includes \RevisionList\ for paginating through a branch's revision history. This proto file defines the request and response message structures for these operations, serving as the interface specification for the revision graph service.

lore-proto/proto/lore/revision · high confidence

Lore Server can now be run in Docker containers using two provided images: a source-build image (Dockerfile) and a pre-compiled release image (Dockerfile.release). The configuration is set up for local filesystem storage by default, with data persisted in /data. The server exposes ports 41337 (gRPC/QUIC) and 41339 (HTTP). Documentation is provided in DOCKER.md.

lore-server · high confidence

The Lore HTTP server is introduced, providing a new API surface for repository content management, health monitoring, and presigned URL operations. The server includes a health check endpoint that reports service availability based on store status, and a presigned URL system that uses HMAC-SHA256 for token signing and verification. To mitigate stored XSS risks, the server enforces a strict Content-Type allowlist for redeemed presigned content, coercing disallowed types to application/octet-stream and blocking executable document types like HTML and JavaScript. The implementation also adds structured HTTP tracing with correlation IDs and user-agent filtering, and configures transport-level limits for request timeouts and body sizes.

lore-server/src/http · high confidence

The lore-server now includes a comprehensive telemetry module that initializes OpenTelemetry providers for logs, metrics, and traces, exporting data via OTLP. This change introduces a \TelemetryInitializer\ that configures log output (file, stdout, or stderr) with JSON, text, or ANSI formatting, sets up batched log and trace processors, and configures periodic metric readers. It also bridges Tokio runtime metrics (task scheduling, queue depths, I/O stats) to OpenTelemetry gauges and histograms, and supports environment-specific resource detection via a pluggable \ResourceDetectorProvider\ trait to attach infrastructure metadata to telemetry signals.

lore-server/src/telemetry · high confidence

Introduces the QUIC transport layer in lore-transport, providing a new client implementation that establishes connections to remote endpoints using the Quinn library. This change adds support for Happy Eyeballs-style connection fallback across resolved addresses, allows SNI overrides for TLS validation when connecting via IP addresses, and implements a dedicated network runtime to ensure QUIC tasks are spawned on the correct thread pool. The transport includes a custom command header protocol (supporting v2 and v4 formats with session IDs), handles authentication error codes (mapping QUIC error 2 to NotAuthorized), and exposes detailed connection statistics such as RTT, congestion window, and packet loss.

lore-transport/src/quic · high confidence

This change introduces the \RepositoryService\ and \ForwardedRepositoryService\ definitions in the Lore repository protocol. The \RepositoryService\ exposes RPCs for creating, deleting, listing, and retrieving repositories, as well as compare-and-swap operations for managing repository metadata pointers. The \ForwardedRepositoryService\ defines endpoints for \RepositoryCreate\ and \RepositoryGet\ to support request forwarding between Lore Servers.

lore-proto/proto/lore/repository · high confidence

This change introduces the core authentication logic for the lore-revision module, adding new files for login handling and user information resolution. It enables users to authenticate by exchanging external tokens for internal ones, storing credentials securely, and resolving user identities to display names via local cached tokens or remote user services.

lore-revision/src/auth · high confidence

The \lore-revision\ crate now includes the core implementation for branch lifecycle operations, introducing new source files for creating, merging, pushing, resetting, and inspecting branches. This adds the ability to create new branches with force-retry logic, perform three-way diffs and merges with conflict resolution, push revisions and fragments to remotes with deduplication, reset branches to specific revisions, and retrieve branch metadata and history. These changes establish the foundational behavior for branch manipulation within the revision system.

lore-revision/src/branch · high confidence

The lore-storage crate has been introduced, providing the core storage engine for the Lore system. This includes a streaming content-defined chunker that processes files in windows to minimize memory usage, a compression module supporting Zstd and LZ4 (with Oodle deprecated), and a concurrency system that budgets memory and file counts via semaphores. The crate also defines a conformance battery to verify store implementations against a strict contract, handles fragment tree defragmentation with pipelined reads, and manages storage errors and content sources.

lore-storage · high confidence

This change introduces the \lore-notification\ module, providing the client-side infrastructure for real-time repository notifications. The new \NotificationClient\ establishes gRPC connections to notification services, implementing automatic retry logic for connection and subscription attempts to handle transient failures. It supports multiple URL schemes (https, lore, lores, urc, urcs, grpc, grpcs) via a registered service factory, ensuring compatibility with various endpoint configurations. The client manages subscription lifecycles using cancellation tokens and integrates with the existing error handling and execution context systems.

lore-notification · high confidence

The repository now includes the foundational documentation and governance artifacts required for public open-source contribution. This includes a Code of Conduct, Contributor Guide, Governance model, Security policy (with HackerOne integration), and a Maintainers list. To support these standards, the project has added pre-commit hooks for Rust linting (clippy, fmt) and documentation quality (markdownlint, Vale, lychee), along with configuration files for these tools and a license compliance generator (cargo-about).

(repo-wide) · high confidence

This change introduces the core protocol buffer definitions and generated Rust code for the Lore system, establishing the foundational API surface. It adds service contracts for administration, authentication, environment discovery, locking, notifications, and replication, alongside comprehensive data models for repositories, branches, and revisions. The included Rust bindings in \lore-proto/src\ provide the necessary serialization and client stubs to interact with these services.

lore-proto/src · high confidence

The \lore-capi\ crate is introduced, providing the public C interface for the Lore library. This change adds the build infrastructure (\build.rs\, \cbindgen.toml\) to automatically generate \lore.h\ from Rust source code using cbindgen, including post-processing to ensure C/C++ compatibility and naming conventions. The resulting API exposes core repository operations (clone, commit, branch management), revision control verbs (add, delete, modify, move, cherry-pick), and storage access, along with event-driven callbacks for progress and error reporting.

lore-capi · high confidence

The \lore-client\ CLI is now available, providing a command-line interface to the Lore version control system. It supports global options for authentication (identity and access tokens), logging, and resource limits, as well as subcommands for managing branches, files, links, and repository status. The client features a pager for long output, progress bars, and machine-readable JSON output, and it runs as a client to a background Lore service.

lore-client/src/cli · high confidence

This change introduces the Lore revision control system, providing a comprehensive API for managing code repositories. The \lore/src\ module exposes a C-compatible interface for core version control operations, including branch management (create, info, diff, merge, push), file operations (info, diff, stage, unstage, reset, write), and repository configuration (layers, dependencies, links). It also includes authentication handling (login, user info), analytics event reporting, and a background service architecture to manage repository state and remote synchronization.

lore/src · high confidence

This change introduces the \lore.model.v1\ protobuf schema, defining the core data structures for the Lore system. It establishes the wire format for storage fragments (\Fragment\, \Address\), revision identifiers (\RevisionIdentifier\, \BranchPoint\), and repository metadata (\Repository\, \Branch\). The schema also defines \ItemStatus\ to handle per-item outcomes in streaming RPCs, ensuring that routine failures (like missing fragments) do not terminate the entire stream. This file serves as the foundational contract for the Lore v1 API.

lore-proto/proto/lore/model · high confidence

The lore-base crate is introduced as the foundational library for the Lore system, providing core infrastructure for error handling, runtime management, and utility functions. It establishes a consolidated FFI error type system with structured exit codes for CLI and library consumers, implements a configurable retry mechanism with exponential back-off and jitter for remote operations, and defines a task lifecycle observer to track spawned tasks. Additionally, it includes utilities for cross-platform directory resolution, UTF-8 validation for FFI arguments, and a versioning system that supports post-build stamping of build names into artifacts.

lore-base/src · high confidence

This change introduces the \lore-macro\ crate, providing procedural macros for the Lore system. It adds the \LoreCommand\ derive macro to generate command dispatching logic (including optimized local execution paths), the \LoreArgs\ derive macro to implement argument handling and validation, and the \ValidateText\ derive macro to enforce UTF-8 constraints on text fields. It also includes the \VariantTypeSize\ derive macro for calculating enum variant sizes and the \lore\_instrument\ attribute macro for integrating tracing spans into async and sync functions.

lore-macro · high confidence

This entry introduces the core repository management capabilities for the lore-revision module, including operations for cloning, creating, deleting, and listing repositories, as well as querying repository status, metadata, and storage state. The implementation adds a write-token system to serialize write operations per repository path, ensuring thread safety for local modifications. It also introduces a filesystem provider abstraction to route file I/O and hashing through a unified interface, supporting features like dry-run modes, parallelized status counting, and view-filtered directory materialization during clones.

lore-revision/src/repository · high confidence

The \lore-telemetry\ crate introduces a new foundational library for observability, providing structured configuration for exporters, loggers, metrics, and distributed traces (including sample rates and validation). It supplies lightweight, RAII-based instrumentation helpers such as \DropRecord\ and \DropTimeMs\ for automatic metric recording, along with \ObserveFuture\ and \timed!\ macros to measure execution latency and success status of operations. The library also defines standard tracing field constants (e.g., correlation ID, repository ID) and an \InstrumentProvider\ trait to standardize metric namespace and label handling across the system.

lore-telemetry/src · high confidence

The \lore-transport\ crate introduces the core networking infrastructure for the Lore system, establishing how clients connect to remote services. It implements a connection caching system that reuses existing connections based on remote URL, identity, and credential source to optimize performance and manage authentication state. The transport layer supports multiple protocol schemes (including \lore\, \lores\, \grpc\, and \grpcs\) and provides a unified error handling system that maps internal protocol errors to specific gRPC status codes (e.g., mapping \NotAuthenticated\ to \Unauthenticated\). It also includes a lazy session management system for storage operations, allowing sessions to be established on-demand to avoid unnecessary network overhead, and supports customizable user-agent strings for client identification in traces.

lore-transport/src · high confidence

This change adds the \lore-aws\ crate, providing the concrete AWS implementations for the Lore storage and locking systems. It introduces wrappers for S3 and DynamoDB that include telemetry, error handling, and a custom HTTP client to ensure network requests run on the dedicated net runtime. The crate implements the \ImmutableStore\ and \MutableStore\ traits for persistent data storage, a \LockStore\ for distributed locking via DynamoDB, and a \MetadataMigrator\ to handle the migration of legacy fragment metadata from DynamoDB to the new S3-backed state table.

lore-aws · high confidence

Added a new OS-backed filesystem provider (\OsFilesystem\) in \lore-revision/src/fs/os\ that delegates file system operations directly to the operating system via the \lore-io\ driver. This implementation supports reading directory listings, retrieving file metadata, checking name existence, and comparing file content against stored hashes, enabling the revision system to interact with the local file system for operations such as diffing and state synchronization.

lore-revision/src/fs/os · high confidence

This change adds a new \SwfsFilesystem\ implementation that acts as a filesystem provider backed by the SWFS (Snapshot Write File System) library. It introduces a \SwfsInterface\ to wrap the SWFS C API, enabling the system to freeze the filesystem during operations and thaw it upon completion to apply changes. The implementation includes a \MountManager\ to handle the lifecycle of SWFS mounts for instances, \MountResources\ to manage the necessary context for mounting, and specific file handling via \SwfsFile\ wrappers. This allows the revision system to utilize SWFS for file operations, with the provider delegating untracked or specific operations to the underlying OS filesystem.

lore-revision/src/fs/swfs · high confidence

A new generator in the \notices\ directory now produces the OSS third-party notices file shipped with each Lore binary. It uses \cargo-about\ to render license and attribution data for Rust dependencies, then merges in non-Cargo vendored sources (like \rpmalloc\) and applies license-text overrides for crates where the license text could not be resolved automatically (such as \governor\, \asn1-rs-impl\, and \rs-consul\). The process enforces a strict gate that fails if any dependency renders an unfilled license placeholder, ensuring every redistributed binary includes complete and accurate third-party license notices.

notices · high confidence

The \lore-chaos-client\ library and CLI are added, enabling automated chaos testing of Lore repositories. The tool supports two modes: a single-threaded \Chaos\ runner and a multi-threaded \Parallel\ runner (defaulting to 2 threads). It generates and executes repository operations—such as commits, branch creation, branch switching, and merges—using a seeded \ProbabilityEngine\ to ensure reproducible scenarios. Users can configure iteration counts, time limits, and RNG seeds, and can opt for a \--dry-run\ mode or a \--replay-operations\ mode that executes a sequence of operations from a JSON file. The client also provides an \OperationWriter\ to export generated operations to JSON for later analysis or replay.

lore-chaos-client/src · high confidence

The \lore-error-set\ library provides a new error-handling system for Rust, centered on the \\#\[error\_set\]\ macro which generates enums with automatic cross-set mapping and a mandatory \Internal\ catch-all variant. It introduces \Traced\<E\>\ to wrap errors with source-location traces (feature-gated via \track-locations\), and enforces strict compile-time propagation via \ForwardStrict::forward\, which requires the target error set to declare every variant of the source to prevent silent data loss. The library also includes \WrapInternal\ for mapping foreign errors, \FfiError\ for exposing integer codes at boundaries, and \InternalForbiddenOnErrorSets\ to prevent accidental collapse of handleable variants into \Internal\.

lore-error-set/src · high confidence

The server now exposes a new internal gRPC endpoint (previously the replication server) that handles administrative operations like server info and data obliteration, alongside environment configuration retrieval. This internal server also serves as the foundation for a new request forwarding system, allowing the Lore server to delegate specific Repository and Revision service RPCs (such as branch and repository creation/getting) to remote peers. The forwarding implementation includes a dedicated client layer that manages TLS connections, propagates caller identity and authorization headers, and correctly classifies transport errors to ensure unreachable peers are reported as internal client errors rather than peer responses.

lore-server/src/grpc · high confidence

The revision module now supports tracking file dependencies, allowing users to define and manage relationships between files within a repository. This includes adding, removing, and listing dependencies with optional tagging and transitive resolution. Additionally, a migration helper has been added to read old-style anchor files, ensuring compatibility with previous repository states.

lore-revision/src · high confidence

Added the file-based lock implementation in \lore-revision/src/lock\, providing the core logic for acquiring, releasing, querying, and checking the status of file locks. This change introduces the \acquire\, \release\, \query\, and \status\ modules, along with utility functions for batching and resource assembly, enabling users to manage file locks directly through the revision client.

lore-revision/src/lock · high confidence

The repository's filesystem access is now routed through a new provider architecture defined in \lore-revision/src/fs\. This change introduces traits that separate operation context creation (supporting both OS-backed and VFS-backed/SWFS instances) from actual file operations, allowing repository commands like staging, status, and merging to interact with the filesystem via a unified interface rather than direct I/O calls. This enables the system to support virtual filesystems and improves the consistency of how file metadata, hashes, and modifications are tracked across different storage backends.

lore-revision/src/fs · high confidence

The storage API now uses a gRPC \StorageService\ with streaming RPCs for \Get\, \GetMetadata\, \Put\, \Copy\, and new \GetResolved\/\PutResolved\ operations. This design allows batching multiple item requests over a single long-lived stream, with per-item outcomes reported via an in-band \ItemStatus\ field so that a failure on one item does not terminate the entire stream. The service also includes \Query\, \Verify\, and \MutableLoad\/\MutableStore\/\MutableCompareAndSwap\ RPCs for key management and data integrity.

lore-proto/proto/lore/storage · high confidence

This change adds a new gRPC-based transport implementation for the Lore system, introducing dedicated client modules for administrative, environment, lock, repository, revision, and storage operations. The transport handles authentication and authorization via interceptors, manages connection retries with exponential backoff, and implements streaming logic for storage operations, effectively replacing or supplementing previous transport mechanisms with a structured, protocol-buffer-defined interface.

lore-transport/src/grpc · high confidence

Added a new low-level API for managing in-memory revision trees, exposing verbs to load, close, commit, add, delete, move, and list children, along with metadata and node info operations. The implementation includes a handle-based registry for concurrent access, an atomic commit mechanism that freezes the tree and advances branch tips, and batch operations for adding and deleting subtrees, all exposed via a documented C-compatible interface.

_lore/src/revision\tree · high confidence

The \lore-revision/src/metadata\ module now exposes a complete set of low-level verbs to manage metadata across the system. Users can now retrieve, list, and modify key-value metadata for revisions, files, branches, and repositories. The implementation introduces specific error handling for these operations, enforces read-only constraints on built-in keys (such as branch IDs or repository names), and supports binary payloads by storing them as remote addresses. Clearing metadata is also supported for both revisions and individual files, triggering appropriate state updates and events.

lore-revision/src/metadata · high confidence

The CLI now includes dedicated command modules for authentication (auth), branch operations (branch), and repository management (repository), alongside new subcommands for completions, file dependencies, layers, links, file locking, notifications, and log file info. This restructures the CLI interface to provide more granular control over authentication tokens, branch merging and switching, repository creation with VFS options, and file-level operations like locking and dependency tracking.

lore-client/src/cli/commands · high confidence

Added a new hook infrastructure in \lore-server/src/hooks\ that enables modular, event-driven extensions to the server lifecycle. This system allows third-party or internal plugins to intercept and react to key operations—such as branch pushes, creations, deletions, repository creation, and data obliteration—without modifying core handlers. The implementation includes a \HookContext\ for passing immutable operation metadata (like correlation IDs and user details), a \HookRegistry\ for managing hook factories and configuration, and a \HookDispatcher\ that executes hooks in a three-phase model: synchronous pre-handlers (which can veto operations with semantic status codes like \PermissionDenied\), synchronous response handlers, and asynchronous post-handlers. This provides a foundation for features like access control, compliance auditing, and custom notifications.

lore-server/src/hooks · high confidence

The authorization layer in lore-server has been refactored to use a unified RepositoryAuthorizer trait, replacing scattered checks with a consistent, configurable policy engine. This change introduces two primary authorization tiers: GlobalGrantsAuthorizer, which grants access based on user roles or groups found in the token's claims (e.g., \realm\_access.roles\), and ResourceGrantsAuthorizer, which enforces per-repository permissions defined in the token's resource claims. The system now supports selecting the active authorizer via configuration, allowing administrators to switch between global role-based access and fine-grained resource-based access. Additionally, a RepositoryCatalog trait has been added to manage repository listing, supporting both baseline access modes (denied or reachable) and integration with external auth services for dynamic permission lookups.

lore-server/src/authnz · high confidence

The Lore client now offloads command execution to a dedicated background service process, communicating via Unix domain sockets (on Unix/macOS) or named pipes (on Windows). This change introduces a new remote API layer that automatically starts the service if it is not already running, relays events and results back to the caller, and resolves relative paths against the caller's working directory. Users benefit from improved performance and resource management, as heavy operations no longer block the main process, and consistent state across multiple concurrent CLI invocations.

lore/src/remote · high confidence

This change adds the foundational type definitions for the lore storage system, including branch management (BranchMetadata, BranchPoint), resource locking (LockResource, LockData), and fragment handling (FragmentFlags for compression and storage states). It also defines store key types (KeyType), verification results (HealResult, VerifyResult), and low-level byte manipulation utilities (TypedBytes) required for the storage layer.

lore-base/src/types · high confidence

The \lore-base\ crate now includes a new logging module (\lore-base/src/log\) that provides a set of logging macros (\lore\_trace\, \lore\_debug\, \lore\_info\, \lore\_warn\, \lore\_error\) and a callback-based dispatch system. A key behavioral detail is that the log level is stored in an atomic variable (\AtomicU32\) rather than behind a lock, allowing for lock-free reads during log emission. The module also introduces a \RotatingLogFile\ writer that supports daily log rotation, multi-process safety via filesystem locking, and automatic cleanup of old log files.

lore-base/src/log · high confidence

The lore-server now includes a local implementation of the lock store mechanism, allowing users to manage locks on repository resources (such as branches and hashes) via an in-memory DashMap. This change introduces the \LocalLockStore\ which supports acquiring, querying, checking status, and unlocking resources, ensuring that resources locked by one owner cannot be locked by another without explicit validation. This provides the foundational infrastructure for resource locking within the revision system.

lore-server/src/lock · high confidence

The Lore Server now supports a compile-time plugin system that allows swappable storage backends and topology discovery mechanisms. This change introduces a \PluginRegistry\ and factory traits for immutable stores, mutable stores, lock stores, and topology services. By default, the server includes built-in plugins for AWS (S3/DynamoDB-backed stores) and HashiCorp Consul (service discovery), enabling operators to configure these backends via TOML settings without modifying server code. This modularization decouples the core server logic from specific infrastructure dependencies.

lore-server/src · high confidence

The \lore-revision/src/event\ module now exposes the C-compatible event data structures for the low-level revision control API. This includes payloads for loading revision trees, resolving paths, listing children, retrieving node and revision information, and handling batch operations (add, delete, modify, commit). These structs define the shape of data returned to callers for both successful outcomes and error conditions, enabling integration with the \lore\_revision\tree\\*\ verb surface.

lore-revision/src/event · high confidence

This change introduces a standalone \lore-aws-migrate\ tool to migrate existing AWS immutable stores from the legacy metadata table layout to the fragment state table layout (introduced in v0.8.7), ensuring fragments are described by their S3 object metadata rather than a separate DynamoDB row. It also adds a comprehensive Terraform example in \contrib/aws\ for deploying Lore on AWS using ECS on EC2 with NVMe-cached edge nodes, including configuration for the new fragment state table and instructions for upgrading pre-v0.8.7 deployments by pointing to the legacy metadata table during the transition.

contrib · high confidence

Clients can now discover server-side configuration and auxiliary service endpoints (storage, revision, lock, notification, and user directory) via a new unauthenticated \EnvironmentService\. This allows the system to decouple the user directory from the authentication service and enables server-tunable settings like compression mode and query batch sizes to be communicated to clients during connection setup.

lore-proto/proto/lore/environment · high confidence

The server now exposes a new API area under \/repositories/{repository\_id}/contents\ to manage repository data. Users can upload content via a PUT request to the root of this path, retrieve specific content items via GET requests to \/{address}\, and request temporary access links via POST to \/{address}/presign\. The presign endpoint is restricted to service accounts and enforces a configurable allowlist of content types to prevent misuse.

lore-server/src/http/repositories/repository · high confidence

The server now supports JWT-based authentication for both HTTP and gRPC endpoints. This change introduces a new \JWKService\ to fetch and cache public keys from JWKS endpoints or via OIDC discovery, handling key rotation and caching with throttling. A \JwtVerifier\ validates tokens, supporting configurable identity claims and resource permission matching via a \ResourceMatcher\. Authentication is enforced through an Axum middleware for HTTP routes and a Tonic interceptor for gRPC services, extracting user identity and permissions into request extensions for downstream authorization checks.

lore-server/src/auth · high confidence

The QUIC transport layer now includes a dedicated client monitor that exposes detailed connection-level metrics (RTT, congestion window, packet loss, MTU, and UDP I/O) and enhanced stream-level telemetry (latency, pending chunk stalls, and user agent). To protect server resources, the stream handler implements admission control with per-stream request limits, a global connection ceiling, and configurable timeouts that reject excess load with a SlowDown response. These capabilities are integrated into the replication store service and the v4 storage service, ensuring consistent observability and flow control for internal replication and client storage traffic.

lore-server/src/quic · high confidence

A new \UserService\ has been defined in the \lore.user.v1\ protocol buffer schema, providing three RPCs for client-side user directory operations: \UserGet\ to resolve user IDs to their details (ID, display name, username), \UserFind\ to search for users by username or display name, and \PartitionList\ to stream the partitions and associated permissions held by the authenticated user. This change introduces the contract for decoupling user and repository list resolution from the authentication layer, allowing clients to independently query user identity and access scopes.

lore-proto/proto/lore/user · high confidence

The \lore-error-set-macro\ crate introduces a new \\#\[error\set\]\ attribute macro that transforms simple Rust enums into comprehensive error types. When applied, the macro automatically generates \Traced\ wrappers for each variant to capture call-site location data, implements standard traits (\std::error::Error\, \Display\, \Debug\), and provides type-safe accessor methods (e.g., \is\\\, \as\\*\). It also includes an \ErrorSet\ trait for cross-error-set mapping and a \FfiError\ derive macro (with \\#\[ffi\_code(N)\]\) to delegate specific integer codes for FFI boundaries, ensuring structured error details and exit-code safety are carried through the application.

lore-error-set-macro · high confidence

The \lore-revision\ store layer now includes a new \CompositeStore\ that aggregates local, durable, and replica storage targets. This store deduplicates concurrent metadata lookups, caches metadata fragments to the local store, and only caches results to the local store if they originated from the durable store. It also introduces scoped read and write handles for mutable store access, defines per-item event data structures for the content-addressed storage API, and adds a seeder to populate the local store with random payloads for capacity testing.

lore-revision/src/store · high confidence

The storage subsystem now exposes a comprehensive set of operations for managing content-addressed data. Users can read content with \lore\_storage\_get\, which supports partial range reads, streaming delivery, and writing directly into caller-supplied buffers. For persistent storage, \lore\_storage\_get\_file\ and \lore\_storage\_get\_file\_resolved\ allow writing content (or resolved mutable keys) to filesystem paths, handling atomic staging via temporary files. The API also includes \lore\_storage\_copy\ for duplicating content between partitions, \lore\_storage\_get\_metadata\ for fetching fragment details without payload bytes, and \lore\_storage\_flush\ for ensuring disk-backed stores are synced. Lifecycle management is handled by \lore\_storage\_close\, which safely drains in-flight operations before flushing and releasing resources.

lore/src/storage · high confidence

The allocator module now introduces \GrowVec\, \HeapBox\, and \HeapBuf\ to manage memory using dedicated rpmalloc heaps instead of the global allocator. This change isolates revision-tree block allocations (node, name, and metadata) into their own heaps to prevent cache churn and allow separate footprint measurement. It also adds an allocation tracking system that records timestamps, pointers, sizes, and call stacks to a file when enabled via the \LORE\_ALLOCATOR=tracking\ environment variable.

lore-base/src/allocator · high confidence

The \lore-revision\ crate now exposes a comprehensive set of file-level operations, including diffing, dirty tracking, history inspection, metadata dumping, hashing, information retrieval, content obliteration, reset, staging, unstaging, and writing. These modules provide the underlying logic for managing file states, tracking changes against the working tree, and interacting with the repository's immutable store, effectively replacing or supplementing previous ad-hoc implementations with a unified, operation-based filesystem provider interface.

lore-revision/src/file · high confidence

The \lore-base/src/fs\ module now exposes two new capabilities: an asynchronous file and directory locking mechanism (\FSLock\) that uses non-blocking retries with exponential backoff to avoid parking runtime threads, and a Windows-specific path helper (\to\_extended\_wide\) that converts paths to the \\\?\\\ verbatim format to bypass the 260-character \MAX\_PATH\ limit. These additions provide robust, cross-platform file locking and long-path support for consumers of the \lore-base\ library.

lore-base/src/fs · high confidence

The server now exposes a new \EnvironmentService\ via gRPC (v1) that allows clients to retrieve the current environment configuration, including endpoint URLs and compression settings. This service is initialized with the server's runtime environment config at startup and supports a maintenance mode, which returns an 'unavailable' status if the server is in maintenance. Notably, if the internal configuration specifies Oodle compression, the service overrides it to Zstd in the response, logging a warning.

lore-server/src/grpc/environment · high confidence

The gRPC storage service now exposes a new v1 API layer that implements streaming handlers for immutable storage operations (Get, Put, Copy, GetMetadata, GetResolved, PutResolved) and non-streaming handlers for mutable key management (MutableLoad, MutableStore, MutableCompareAndSwap). This implementation introduces specific error-handling behaviors, such as carrying per-item failures in-band for GetResolved and PutResolved to prevent stream termination on expected misses, and enforces cross-partition authorization checks for Copy operations.

lore-server/src/grpc/storage · high confidence

The server now exposes a new \lore.thin\_client.v1.ThinClientService\ RPC interface, enabling clients to retrieve revision metadata (\RevisionInfo\), stream file-tree listings (\RevisionTree\), and stream 3-way revision diffs (\RevisionDiff\). This service handles revision resolution by signature or branch identifier, supports streaming responses for large trees and diffs, and includes a configurable source-cap (default 100k items) to prevent excessive memory usage during diff generation.

lore-server/src/grpc/thinclient · high confidence

The \lore-telemetry/src/metrics\ module now provides comprehensive OpenTelemetry-based metrics for both gRPC and HTTP services. This includes dedicated Tower layers (\GrpcMetricsLayer\, \HttpMetricsLayer\) that automatically track request duration, active request counts, and status codes. A key addition is the \UserAgentFilter\, which normalizes the \User-Agent\ header into safe metric labels, replacing unrecognized agents with \\<unknown\>\ to prevent cardinality explosion while optionally sampling them for logging. The histogram buckets for request duration have been tuned with specific boundaries (including 8s and 10s) to better capture RPC handler performance.

lore-telemetry/src/metrics · high confidence

The \lore-server/src/grpc/handlers\ directory now includes new handlers for branch creation, deletion, listing, retrieval, protection, and metadata management (get/set), as well as a diff handler. These handlers expose the underlying \lore\_revision\ branch capabilities via gRPC, implementing input validation (e.g., name length limits), read-only field protection for metadata, and link-aware diffing. The branch push handler has also been added to support pushing revisions to branches, including client IP extraction and hook dispatching.

lore-server/src/grpc/handlers · high confidence

Users can now install the Lore CLI and loreserver on Windows via a new PowerShell script (scripts/install.ps1) alongside the existing Bash installer (scripts/install.sh), both supporting demo mode and GitHub token authentication. A new documentation linting script (scripts/docs-lint.sh) enforces prose, structure, and link standards using Vale, markdownlint, and lychee. Additionally, a build-stamping script (scripts/stamp-artifacts.sh) embeds the current repository revision into release artifacts for version tracking.

scripts · high confidence

The lore-server now exposes a dedicated internal ReplicationStoreService over QUIC, enabling peer-to-peer store replication. This service implements a comprehensive set of operations including immutable Put, Get, Obliterate, Copy, and a new dedicated Query command, while Get and GetMetadata responses now return full StoreGetData information (not just payloads). Clients can identify themselves via a UserAgent field sent during connection initialization, and the service handles connection resilience through automatic client regeneration with congestion window seeding.

_lore-server/src/quic/replication\_store\service · high confidence

The server now includes a local notification subsystem that broadcasts repository events (branch creation, pushes, deletions, and resource locking/unlocking) via Tokio broadcast channels, allowing components to subscribe to specific repository streams. Additionally, the topology module introduces built-in support for static peer configurations through \FixedTopology\ and \RotatingIdFixedTopology\ (which periodically rotates peer IDs to distribute load), as well as \CompositeTopology\ to merge peer sets from multiple underlying topology sources into a single unified view.

lore-server/src/notification, lore-server/src/topology · high confidence

The new \lore-io\ crate introduces a unified file I/O driver that replaces scattered standard library calls with a consistent, asynchronous API. It supports positional reads and writes (no file cursor), allowing safe concurrent operations on disjoint offsets, and offers three backends selectable via the \LORE\_IO\_BACKEND\ environment variable: \psync\ (the portable baseline using a bounded syscall pool), \uring\ (Linux io\_uring), and \iocp\ (Windows overlapped I/O). The API is runtime-independent, relying only on wakers, and manages buffer ownership by returning allocated \Bytes\ for reads and returning the original buffer for writes, ensuring memory stability for kernel operations.

lore-io/src · high confidence

The \lore-revision\ crate now exposes a comprehensive set of low-level revision management capabilities, including amend, bisect, cherry-pick, diff, history, info, restore, revert, and sync. These additions provide users with granular control over revision metadata, history traversal, and content synchronization, while introducing structured event data for tracking progress and outcomes across these operations.

lore-revision/src/revision · high confidence

The lore-server now includes a persistent cache for revision-list segments in the \lore-server/src/cache\ module. This feature stores parent-chain revisions at defined step boundaries to accelerate revision identifier lookups, reducing the need for slower full parent-chain walks. The cache uses a best-effort write strategy and distinguishes between missing entries and store overload conditions to maintain performance under pressure.

lore-server/src/cache · high confidence

The server now includes new utility modules to improve operational visibility and stability. The \cert\_metrics\ module adds background monitoring that reports the time remaining until TLS certificates expire as metrics, helping operators detect expiring credentials before they cause outages. The \core\_hop\ module introduces a Tower layer that ensures request handling logic runs on the core runtime rather than the network runtime, preventing resource contention and ensuring proper isolation of compute-bound tasks. Additionally, the \local\_store\_monitor\ module provides disk space monitoring for local storage paths, including logic to detect temporary or unconfigured store locations and warn users, ensuring storage health is tracked and misconfigurations are flagged early.

lore-server/src/util · high confidence

The storage protocol layer now includes dedicated handlers for a comprehensive set of operations: connecting to repositories with JWT-based authentication, copying fragments between repositories (including cross-partition copies with authorization checks), retrieving fragment metadata without payloads, resolving mutable keys to immutable addresses in a single round-trip, and performing compare-and-swap operations on mutable keys. A new authorization module parses and validates start/stop session tokens, while the connect handler integrates JWT verification and repository access control into the connection context. Correlation IDs are now explicitly managed to support request tracing across these new and existing message types.

lore-server/src/protocol/storage · high confidence

The \lore-server/src/store\ directory now contains the core implementation for store configuration and replication communication. The new \configuration.rs\ module provides a plugin-based system for creating immutable, mutable, and lock store instances, allowing operators to select storage backends (e.g., AWS, local) via configuration. The \grpc\_replica.rs\ module implements a gRPC-based replication client for write operations, handling streaming requests and response tracking. Additionally, \replica.rs\, \replicated\_store.rs\, and \replica\_factory.rs\ introduce a QUIC-based replication architecture, including a \ReplicatedStore\ that forwards operations to remote servers to reduce cross-region latency, and a \ReplicaFactory\ that manages client connections with locality-aware congestion control (Cubic for same-region, BBR for cross-region).

lore-server/src/store · high confidence

The \lore-revision/src/util\ directory now includes a suite of new helper modules that support core repository operations. \collect\_stream.rs\ provides an async utility to drain streaming producers into a vector while capturing a summary value. \config.rs\ introduces a robust TOML configuration system with atomic writes (using temporary files and rename) to prevent data loss on interruption, along with both async and blocking load methods. \encoding.rs\ adds support for detecting and decoding UTF-8, UTF-16 (with BOM and byte-order detection), and refusing unsupported encodings like UTF-32, which is critical for parsing filter files. \path.rs\ centralizes path resolution logic, including absolute path construction relative to a working directory, validation of paths within the repository, and case-insensitive path handling. \fs.rs\ provides filesystem utilities such as executable bit management and metadata extraction. \inflight.rs\ offers a concurrency primitive for deduplicating in-flight requests using broadcast channels. \task\_queue.rs\ implements a rate-limited and concurrency-limited task queue with OpenTelemetry observability. \time.rs\ and \serde.rs\ add retry policy builders and boolean serialization helpers, while \url.rs\ normalizes remote URLs by stripping protocol schemes.

lore-revision/src/util · high confidence

The repository management capabilities are now exposed via a new \lore.repository.v1.RepositoryService\ gRPC API, replacing the legacy implementation. This service introduces real-time authorization checks for metadata read/write operations (get/set) and repository listing, enforcing access control via the \RepositoryAuthorizer\ and \RepositoryCatalog\ components. It also adds a low-level API for managing repository metadata pointers (get/set/clear) and supports configurable request forwarding, allowing \RepositoryCreate\ and \RepositoryGet\ operations to be delegated to remote Lore Servers when configured.

lore-server/src/grpc/repository · high confidence

The gRPC handlers for BranchCreate, BranchDelete, BranchGet, and BranchList in the RevisionService now check a configuration flag to determine whether to process the request locally or forward it to a peer server via the new ForwardedRevisionService. This allows a Lore server to act as a proxy, delegating branch management operations to a remote backend when configured, while maintaining the same request/response semantics for the client.

lore-server/src/grpc/revision · high confidence

The Lore Server can now delegate RepositoryCreate and RepositoryGet requests to a remote peer when configured. This location implements the server-side handlers for these forwarded calls: RepositoryCreate executes the standard creation logic using the forwarded caller context, while RepositoryGet independently verifies the end-user JWT and injects it into the request extensions so the RepositoryAuthorizer can perform access checks. This enables distributed repository operations where one server forwards specific repository actions to another.

_lore-server/src/grpc/forwarded\repository · high confidence

The \lore-revision\ module now implements full support for nested links, allowing repositories to mount other repositories recursively. This change introduces new operations to add, remove, update, and inspect links, including a new \link info\ command to display link details. It enforces safety by refusing to remove links that have local edits or staged changes, and ensures that link mount points and restores are routed through the filesystem provider operation. The implementation also handles nested link chains, resolves branch tracking across nested scopes, and manages staged states for link additions, removals, and updates.

lore-revision/src/link · high confidence

The new \lore.thin\_client.v1\ protocol definitions introduce a \ThinClientService\ with streaming RPCs (\RevisionTree\, \RevisionDiff\, \RevisionInfo\, \ContentDiff\) designed for clients without local caching. For users, the \RevisionTree\ response now includes \TreeNode\ entries that expose file size, file mode (executable vs. none), and link tracking status, providing richer filesystem context than before. Additionally, \RevisionDiff\ responses now carry full content addresses (\content\_from\, \content\_to\) and support linked repositories via \DiffPartition\ announcements and \link\_repository\_index\ fields, allowing clients to correctly resolve content across partition boundaries during diffs.

_lore-proto/proto/lore/thin\client · high confidence

The lore-revision component has been added to the repository, bringing in the core Rust source code, a Dockerfile for building the service on Debian with LLVM 16, and a build script that conditionally links the SWFS library on Windows. The import includes a protocol specification document detailing QUIC and gRPC implementations for data transfer and command routing, as well as a clippy configuration that enforces the use of internal I/O drivers and context-aware spawning macros over standard library or Tokio equivalents.

lore-revision · high confidence

The lore-base module now includes a build script (build.rs) that compiles the rpmalloc allocator with specific optimizations for ARM64 Linux (Neoverse 512TVB) and MSVC, and adds a new CLI tool (lore-stamp) that writes the build name into finished binary artifacts. This stamping process modifies files in-place to include version information while preserving file size, and handles macOS ad-hoc code signing re-application after stamping.

lore-base · high confidence

The authentication module now supports separate registries for authentication and user services, allowing the user directory to be decoupled from the auth service. A new \TokenOnlyUserService\ provides a fallback for deployments without a remote user directory, resolving user names directly from JWT tokens. Additionally, the system now accepts external \identity-token\ and \access-token\ arguments; when these are supplied, authorization tokens are used directly without being persisted to the on-disk token store, keeping external identity tokens separate from cached login tokens.

lore-transport/src/auth · high confidence

The lore-client now enforces strict coding standards through a new clippy.toml configuration. Developers must use the custom \lore\_base::lore\_spawn!\ and \lore\_base::lore\_spawn\_blocking!\ macros instead of standard Tokio spawning functions to ensure the \LORE\_CONTEXT\ is correctly propagated across tasks. Additionally, direct calls to \std::env::current\_dir\ are prohibited in favor of \lore\_revision::util::path::make\_absolute\ to prevent issues with unrelated working directories, and standard print macros are replaced by crate-specific equivalents.

lore-client · high confidence

The gRPC server now includes new middleware layers that improve monitoring and error handling. A new \GrpcResponseTraceLayer\ logs response status codes and latency for success, server errors, and user errors, while a \LoreTracingLayer\ creates per-request spans enriched with user agent, correlation ID, repository ID, and user identity. Additionally, a \MalformedRequestLayer\ reclassifies requests with missing gRPC message bodies from \Internal\ to \InvalidArgument\ to better distinguish client errors from server faults, and a \PartitionAccessLayer\ enforces partition-level authorization with a dedicated timeout for the authorization check itself.

lore-server/src/grpc/tower · high confidence

The native build now compiles and links the rpmalloc 2.0.1 memory allocator (version 2.0.1, RPMALLOC\_VERSION\_NUMBER 20001) as a static library via build.rs, using first-class heaps (RPMALLOC\_FIRST\_CLASS\_HEAPS=1) and disabling process-wide malloc overrides (ENABLE\_OVERRIDE=0). Statistics and leak detection are disabled by default, and the build targets Linux aarch64 with -mcpu=neoverse-512tvb and enables C11 atomics on MSVC. This provides a cross-platform, lock-free, thread-caching allocator for the native layer without replacing the system malloc.

lore-base/native · high confidence

The storage transport layer now uses a new QUIC client implementation that explicitly announces the client's user agent to the server upon connection and reconnection via a dedicated ClientIdentify opcode. Authorization is handled by a new StorageClientAuth adapter that performs this identity announcement rather than traditional token exchange during the initial handshake, while per-session authorization is managed separately by the storage service. The protocol defines specific opcodes for storage operations (Get, Put, Query, etc.) and introduces a QueryStatus response that distinguishes between full matches, partition-only matches, and not found, improving clarity for clients checking data existence.

_lore-transport/src/quic/storage\service · high confidence

The lore-server now uses the Quinn library for its QUIC transport layer, replacing the previous implementation. This change introduces a new server configuration system (QuinnConfig) allowing tuning of transport parameters such as idle timeouts, keep-alive intervals, maximum bidirectional streams, and network bandwidth estimates. It also adds detailed per-connection observability, tracking metrics like RTT, congestion window, packet loss, and data volume via OpenTelemetry histograms, ensuring that statistics are aggregated by service and client rather than being overwritten by the last sampled connection.

lore-server/src/quic/quinn · high confidence

The credential store now enforces stricter validation when checking if a JWT is intended for a specific remote domain. Instead of allowing simple string suffix matches, the system now requires a label boundary (e.g., matching \example.com\ will no longer incorrectly match \evilepicgames.net\). This prevents potential token leakage to look-alike domains. Additionally, the client's \name\ claim in the JWT is now optional, allowing tokens from providers like Keycloak that omit this field to be processed correctly without failing.

lore-credential · high confidence

The presigned URL endpoint now sets a Cache-Control header (public, immutable, max-age=\<remaining\_ttl\>) on responses, allowing clients and intermediaries to cache the content for the duration of the token's validity. Additionally, the route now explicitly rejects HEAD requests and any other non-GET methods with a 405 Method Not Allowed response, preventing unintended execution of the redemption pipeline.

lore-server/src/http/presigned · high confidence

The protocol module now includes a \ClientIdentify\ message that allows QUIC clients to report a user agent, which is validated, normalized, and attached to the connection context for improved telemetry and tracing. Additionally, an ingress filter automatically transcodes incoming Oodle-compressed fragments to Zstd (or stores them uncompressed if Zstd is not beneficial) to standardize storage formats, a process that can be disabled via the \LORE\_DISABLE\_CONVERT\_OODLE\_ON\_PUT\ environment variable.

lore-server/src/protocol · high confidence

The replication store service in lore-server now handles replication operations through distinct, typed QUIC message handlers (Copy, Get, GetMetadata, Query, Put, Obliterate) instead of a generic or monolithic request path. Each operation has its own request structure, parsing logic, and response serialization, ensuring that get and get\_metadata requests return full StoreGetData information (including fragment, match\_made, partition, and payload where applicable) and that query requests return precise StoreMatchResult arrays with local/durable storage flags. This change improves protocol clarity, reduces ambiguity for clients, and enforces strict wire-format validation for all replication store interactions.

_lore-server/src/protocol/replication\store · high confidence

The service startup process has been updated to initialize the SWFS (Single-World File System) mount manager. When the service starts, it now explicitly calls \MountManagerState::initialize()\ within the execution context, ensuring that SWFS repositories are mounted and ready before the service becomes fully operational. This change integrates the SWFS infrastructure directly into the service lifecycle.

lore/src/service · high confidence

The lore-proto build system now allows compilation without the protoc compiler installed. If protoc is unavailable, the crate falls back to using pregenerated source files committed under src/grpc, ensuring the library builds in environments where the code generator is not present. When protoc is available, it generates bindings for the full set of proto files (including model, admin, lock, storage, revision, repository, thin\_client, environment, user, auth\_api, and rebac\_api) using prost and tonic.

lore-proto · high confidence

Resolves a bug where merging a branch would silently discard changes located in directories excluded by the current sparse checkout view. The diff logic now correctly processes these out-of-view subtrees during the merge walk, ensuring that modifications in filtered-out paths are no longer lost.

lore-revision/src/state · high confidence

Added backend conformance and Send-safety tests for lore-io; Added comprehensive test suite for lore-revision; Added integration tests for Lore library core behaviors; Added regression tests for Lore service and server behaviors; Added tests for lore-base allocator, runtime, and observability components; Added tests for the lore-error-set error handling library; Added v1 protocol linting and smoke tests; Integration test suite for AWS, DynamoDB, and HashiCorp Consul storage backends; Major overhaul of Python test infrastructure and fixtures.

The project now includes a Cargo.lock file and Cargo.toml manifests for the workspace and its constituent crates (such as lore-io, lore-server, and lore-aws), along with a pyproject.toml for Python test dependencies. This establishes the pinned versions for all Rust and Python dependencies required to build and test the system.

(dependencies) · high confidence

Added the \glob-match\ library (version 0.2.1) for fast, linear-time glob pattern matching with support for wildcards, character classes, and brace expansion, including a fix for \\\\ backtracking issues. Also vendored \quinn-proto\ (version 0.11.13), the state machine for the QUIC transport protocol, which includes support for various TLS providers (rustls-ring, aws-lc-rs) and features like qlog and bloom filters.

vendor · high confidence

This entry reflects the initial import of the codebase from a private repository. The diff shows the addition of numerous new files across multiple modules, including CLI progress bar logic, HashiCorp Consul integration, server-side correlation ID handling, legacy gRPC service definitions, and test certificates. As this is a raw copy of existing code rather than a specific product change or feature addition, it does not alter user-facing behavior.

(repo-wide) · high confidence

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

• CAI 73 → 78 (+5.3)
• Rubric changed (rubric-2026.09.9 → rubric-2026.09.17) — scores are not directly comparable.

• Code Health 83 → 84 (+0.7)
• Architecture 99 → 96 (-3.7)
• Maturity 82 → 82 (-0.1)
• Readiness 79 → 84 (+5.5)
• Security 61 → 70 (+9.1)
• Domain Modelling 100 → 100 (+0.0)
• Event Sourcing 100 → 100 (+0.0)
• Performance 100 (new)

• Boundary-crossing change coupling: realize.rs ↔ helpers.rs (lore-revision/src/fs/realize.rs)
• Change coupling: realize.rs ↔ status.rs (lore-revision/src/fs/realize.rs)
• Change coupling: reset.rs ↔ stage.rs (lore-revision/src/file/reset.rs)
• Change coupling: unstage.rs ↔ stage.rs (lore-revision/src/file/unstage.rs)
• Change-coupling hub: os.rs → realize.rs, status.rs, stage.rs (lore-revision/src/fs/os.rs)
• ClassTooLong: StreamHandler (lore-server/src/quic/stream_handler.rs)
• CompositeStore::get_metadata (cognitive 25) (lore-revision/src/store/composite.rs)
• Documentation: no architecture or design documentation (docs/README.md)
• Documentation: no installation or build instructions (README.md)
• Duplicated block (10 lines × 2) (lore-revision/src/file/dirty.rs)
• Duplicated block (10 lines × 2) (lore-revision/src/state.rs)
• Duplicated block (10 lines × 3) (lore-client/src/cli/commands/branch.rs)
• Duplicated block (10 lines × 4) (lore/src/storage/put.rs)
• Duplicated block (10–11 lines × 2) (lore-revision/src/stage.rs)
• Duplicated block (10–11 lines × 2) (lore-server/src/grpc/handlers/branch_query.rs)
• Duplicated block (11 lines × 2) (lore-storage/src/write.rs)
• Duplicated block (11 lines × 2) (lore/src/storage/mutable_compare_and_swap.rs)
• Duplicated block (11–12 lines × 2) (lore-base/src/allocator/growvec.rs)
• Duplicated block (11–14 lines × 2) (lore-revision/src/commit.rs)
• Duplicated block (11–15 lines × 2) (lore-revision/src/state.rs)
• …and 141 more

• Change coupling: interface.rs ↔ command.rs (lore/src/interface.rs)
• Change coupling: mod.rs ↔ realize.rs (lore-revision/src/fs/os/mod.rs)
• Change coupling: mod.rs ↔ stage.rs (lore-revision/src/fs/os/mod.rs)
• CompositeStore::get_metadata_from_remotes (cognitive 23) (lore-revision/src/store/composite.rs)
• Connect::handle_auth (cognitive 18) (lore-server/src/protocol/storage/connect.rs)
• Duplicated block (10 lines × 2) (lore-revision/src/file/dirty.rs)
• Duplicated block (10 lines × 29) (lore-client/src/cli/commands/branch.rs)
• Duplicated block (10 lines × 3) (lore-client/src/cli/commands/file.rs)
• Duplicated block (10 lines × 5) (lore/src/branch.rs)
• Duplicated block (11 lines × 2) (lore/src/storage/mutable_compare_and_swap.rs)
• Duplicated block (11 lines × 2) (lore/src/storage/put_file.rs)
• Duplicated block (11–12 lines × 4) (lore-client/src/cli/commands/branch.rs)
• Duplicated block (12 lines × 2) (lore-revision/src/file/dirty.rs)
• Duplicated block (12–13 lines × 2) (lore-revision/src/stage.rs)
• Duplicated block (13 lines × 2) (lore-client/src/cli/commands/repository.rs)
• Duplicated block (13 lines × 2) (lore-storage/src/fragment_engine.rs)
• Duplicated block (13–14 lines × 2) (lore-base/src/allocator/growvec.rs)
• Duplicated block (13–14 lines × 3) (lore-client/src/cli/commands/branch.rs)
• Duplicated block (14 lines × 2) (lore-client/src/cli/commands/repository.rs)
• Duplicated block (14 lines × 2) (lore-client/src/cli/commands/revision.rs)
• …and 161 more

• 135 commits — 128 feature/other, 7 fixes

• lore-revision/src — 55 commits
• lore-server/src — 17 commits
• docs/release-notes.md — 10 commits
• lore/src — 9 commits
• scripts/test — 8 commits
• (root) — 6 commits
• lore-storage/src — 5 commits
• lore-client/src — 3 commits
• docs/developing — 2 commits
• lore-base/src — 2 commits
• lore-integration-tests/compose.yaml — 2 commits
• lore-revision/tests — 2 commits
• lore-transport/src — 2 commits
• (repo) — 1 commit
• .cargo/config.toml — 1 commit
• contrib/helm — 1 commit
• docs/how-to — 1 commit
• docs/reference — 1 commit
• docs/tutorials — 1 commit
• lore-aws/src — 1 commit

• fix: Fix SWFS clones for files in directories, as well as file info
• fix: Fix an empty LoreArray leaking its allocation
• fix: Fix auth-endpoint test setup for strict [server.auth] validation
• fix: lore-base: Fix the undefined behaviour in GrowVec that Miri reports
• fix: lore-revision: Fix test covering a listed name that is not text without a filesystem that holds one
• fix: lore-server: Fix QUIC connection statistics being overwritten by the last connection sampled
• fix: lore-server: Fix the running-task counter drifting when a task ends outside its spawn context
• change: Add engineering principles and refresh the code standards
• change: Add reproduction test for reset --purge on a nested repository
• change: Answer NULL for every empty LoreString, and read a NULL pointer as empty
• change: Attempt at boxing all of lore-revision's public interface futures
• change: Build: Add Linux lib name, matching macOS.
• change: Carry the failing error's own detail on the storage per-item events
• change: Changes to how the service is handled
• change: Fix formatting in release notes after previous change broke it.
• change: Make load_blocking part of the SavableConfig trait
• change: Prep for portable arm builds
• change: SWFS clone
• change: Take a node slot before the block it came from is published
• change: The file reset --last-merged command takes an optional --mine or --theirs
• …and 115 more

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

EpicGames/lore was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.