Skip to content
CAI
Software that uses CAICheck a score

astrid-runtime/astrid

49.4

Weak · 27 October 2026

375k

lines of production code

Rust

primary language

3

measurements over time

CAI band scale
CAI trend line
CAI lens gauges

What this system is

Astrid is a secure, multi-tenant agent runtime that executes untrusted code in WebAssembly capsules with strict isolation and auditability. It manages agent lifecycles, enforces granular capability-based access control, and provides a sandboxed environment for tool execution and file system interactions. The system includes a CLI and HTTP gateway for administration, along with a cryptographically signed audit trail to ensure operational transparency and integrity.

Features

Add macOS FSKit filesystem extension

Added the AstridFSKit Xcode project for macOS, which builds a hidden background app and an FSKit extension (AstridFSAppEx) to expose Astrid storage as a native macOS filesystem. The extension implements file read/write, directory listing, and metadata operations via a Unix socket RPC client, and requires a signed lease file to mount. This enables mounting Astrid storage on macOS through the standard \astrid storage\ CLI commands.

native · high confidence

Added example to print the OpenAPI specification

A new example script, print-openapi.rs, has been added to the astrid-gateway crate. This utility allows users to generate and print the API's OpenAPI documentation in pretty-printed JSON format to the standard output, facilitating easier inspection or export of the API schema.

crates/astrid-gateway/examples · high confidence

Added sandbox verification probe example

A new example program, sandbox\_probe, has been added to help verify the sandbox policy enforcement. This tool allows users to test how the system responds to different sandbox configurations by reading the ASTRID\_SANDBOX\_POLICY environment variable and reporting whether the sandbox is applied, bypassed, or refused.

crates/astrid-workspace/examples · high confidence

Admin API handlers for agent lifecycle, capability tokens, and distro provenance

The kernel's admin router now includes dedicated handlers for managing agent creation, deletion, and derivation, as well as issuing and revoking capability tokens and controlling distro provenance locks. Agent creation and derivation now support cloning profiles and inheriting capsule state, while deletion properly retires capabilities and reclaims resources. Capability tokens allow operators to pre-grant tool access to principals, and distro provenance handlers enable atomic, hash-verified locking of capsule sets with self-grant capabilities. These changes enhance the admin interface for managing agent lifecycles and access control.

_crates/astrid-kernel/src/kernel\router/admin · high confidence

Astrid CLI Mockup: Standalone TUI Design Prototype with Scripted Demos

The \astrid-cli-mockup\ crate provides a self-contained, zero-runtime-dependency ratatui prototype for designing the Astrid OS terminal interface, decoupled from the live kernel daemon. It features nine navigable views (Operate, Control, Monitor, Utility) and includes ten scripted demo scenarios—such as approval flows, error recovery, and multi-agent operations—that simulate agent streaming, tool execution, and user interactions. The mockup supports interactive mode, auto-playing demos via \--demo\, and non-interactive snapshot testing via \--snapshot\ to validate the UX at the speed of \cargo run\.

crates/astrid-cli-mockup · high confidence

Astrid MCP introduces secure, sandboxed server execution with capability-based authorization

The MCP subsystem now enforces security and isolation for external server processes. Untrusted servers are launched inside OS-level sandboxes (using bwrap on Linux) with configurable network and filesystem restrictions, and binary integrity is verified using BLAKE3 hashes instead of the previous SHA-256. A new \SecureMcpClient\ gates tool invocations on capability tokens and audit logging, while the \McpRegistry\ provides a unified interface that merges global and workspace tool layers. The crate has been renamed from \astralis-mcp\ to \astrid-mcp\, and the underlying \rmcp\ transport has been upgraded to support the MCP 2026 protocol with modern lifecycle negotiation and elicitation handling.

crates/astrid-mcp/src · high confidence

Audit log now supports per-principal chain splitting and batched appends

The audit log now maintains separate, independently verifiable chains for each principal within a session, rather than a single monolithic log. This change introduces batched append operations that sign multiple entries against a single authoritative snapshot, improving throughput and consistency. It also includes a robust migration path to move legacy audit data into this new native structure, along with comprehensive tests to verify chain integrity and handle edge cases like storage capacity limits.

crates/astrid-audit/src · high confidence

Authenticated Streamable HTTP transport for MCP

The CLI now exposes an authenticated Streamable HTTP endpoint for the Model Context Protocol (MCP) on a loopback address. This new transport layer supports two authentication modes: static Bearer tokens read from a private file (with strict Unix permission and size validation) and OAuth 2.1 resource-server mode, which validates JWTs against a remote JWKS and enforces scope/audience/issuer checks. The HTTP handler routes requests to the existing MCP broker, preserving tool execution and subscription capabilities while ensuring that browser-origin requests are rejected and that the selected workspace and principal are correctly bound to the session.

crates/astrid-cli/src/commands/mcp/http · high confidence

Build-time provenance capture for gateway metrics

The gateway now embeds build-time provenance data into the \astrid\_build\_info\ metric. A new \build.rs\ script captures the git short SHA and the \rustc\ version during compilation, exposing them as environment variables for the metrics module. This ensures that the gateway's metrics endpoint reflects the exact build environment, with fallbacks to 'unknown' if git or rustc are unavailable.

crates/astrid-gateway · high confidence

Extracted astrid-types crate with typed IPC topics and host-stamped message provenance

The \astrid-types\ crate has been extracted as a standalone, kernel-free library for shared data types, enabling capsule SDK consumption on \wasm32-unknown-unknown\ without pulling in the runtime. This introduces a \Topic\ newtype with typed constructors (e.g., \elicit\_response\, \approval\_request\) to prevent ad-hoc string formatting errors while maintaining wire compatibility. IPC messages now include a \MessageOrigin\ field (\LocalSocket\, \RemoteGateway\, or \System\) stamped by the host at ingress to distinguish local operator requests from remote API calls, defaulting to \System\ (fail-closed) for legacy or unattributed frames. Additionally, \IpcMessage\ deserialization now defaults the \timestamp\ and \signature\ fields when missing to ensure robust handling of legacy peers, and LLM types have been migrated into this crate with added serialization support and safe arithmetic for token usage.

crates/astrid-types/src · high confidence

Introduce astrid-build for capsule compilation and packaging

The new \astrid-build\ crate provides the tooling to compile Rust and legacy MCP/Gemini projects into \.capsule\ archives. It supports building Rust crates to WASM (including \wasm32-unknown-unknown\ and \wasm32-wasip2\), converting legacy \mcp.json\ or \gemini-extension.json\ manifests into \Capsule.toml\, and bundling opaque assets. The build process includes signing archives with the runtime identity, verifying provenance, and injecting WIT schemas for IPC topic resolution.

crates/astrid-build · high confidence

Introduce astrid-emit as an agent-agnostic stdio-to-bus pipe

Added the \astrid-emit\ crate and binary, which provides a generic mechanism for agent hook processes to publish raw stdin data to the kernel event bus. This tool reads from stdin, wraps the content in a fixed six-field JSON envelope (including hook name, payload, correlation ID, principal ID, session ID, and token), and publishes it to a specified topic. It ensures agents always receive a \{"continue":true}\ signal on stdout, while handling publish failures by exiting with code 1 rather than blocking or failing closed, effectively decoupling the transport layer from specific agent protocols.

crates/astrid-emit · high confidence

Introduce capability-based virtual file system with per-principal sandboxing

The VFS layer now enforces strict security boundaries and multi-tenant isolation. A new \IgnoreBoundary\ component enforces \.astridignore\ rules to prevent agents from accessing host secrets or local state. Filesystem operations are mediated through capability handles (\DirHandle\, \FileHandle\) rather than raw paths, and a new \OverlayVfs\ implementation provides copy-on-write isolation backed by temporary directories. Additionally, an \OverlayVfsRegistry\ ensures that each principal gets its own isolated overlay, preventing cross-principal data leakage while maintaining a bounded, LRU-cached registry.

crates/astrid-vfs/src · high confidence

The uplink module in astrid-core now provides a unified type system for components that send or receive messages on behalf of the runtime. This introduces UplinkId for unique identification, UplinkCapabilities to define supported features (such as sending, receiving, rich media, and buttons), and UplinkSource to distinguish between native, WASM, and bridge origins. The module also defines UplinkError for operation-specific failures and UplinkProfile to categorize behavioral modes like chat, interactive, notify, or bridge. This change establishes the foundational types and validation logic for the new uplink architecture.

crates/astrid-core/src/uplink · high confidence

The \astrid-uplink\ crate now provides the local transport layer for both the CLI and the HTTP gateway, replacing ad-hoc socket handling. It introduces \AdminClient\ for the \astrid.v1.admin.\\ surface and \KernelClient\ for the \astrid.v1.request.\\ surface, both using length-prefixed JSON framing over a local socket. The native server enforces per-connection authentication via a session token and optional principal keypair challenge, stamps every outbound message with the caller's \PrincipalId\, and implements bounded input admission, egress filtering by request owner, and inactivity/ceiling timeouts for kernel requests. This change standardizes how local administrative and kernel operations are routed, authenticated, and timed out across all local consumers.

crates/astrid-uplink · high confidence

Introduce granular, capsule-scoped allowance system for pre-approved actions

Users can now grant pre-approved access for specific action patterns, allowing repeated actions to bypass approval prompts. The new \AllowanceStore\ manages these allowances with strict multi-tenancy, ensuring that an allowance granted to one principal (e.g., an agent) cannot authorize actions for another. Allowances support various granular patterns, including exact tool calls, server-wide tool access, file access via glob patterns, and network access scoped to specific capsules. They can be configured as session-only (cleared when the session ends) or persistent, with optional expiration dates and use limits. This system provides a secure, fine-grained way to streamline workflows while maintaining strict isolation between different principals and capsules.

crates/astrid-approval/src/allowance · high confidence

Introduce persistent MCP gateway with authenticated Streamable HTTP transport

The CLI now runs a persistent per-user MCP gateway that manages a single authenticated uplink to the daemon, allowing multiple short-lived \mcp attach\ processes to share the connection without accumulating orphaned processes. This gateway supports a new authenticated Streamable HTTP transport (listening on loopback with Bearer token auth) alongside the existing stdio proxy, and enforces strict consent flows: it elicits binary grant-on-use consent for ungranted capsule tools and relays capability approval prompts to the MCP client, ensuring fail-secure behavior when consent is declined or unavailable.

crates/astrid-cli/src/commands/mcp · high confidence

Introduce signed, offline-installable distro bundles

The CLI now supports creating and installing curated distro bundles via a new \.shuttle\ archive format. Maintainers can use \astrid distro seal\ to package a \Distro.toml\ manifest, a resolved \Distro.lock\ (pinning exact capsule versions and BLAKE3 hashes), and an ed25519 signature into a deterministic, offline-installable archive. End users can install these bundles offline; the CLI verifies the signature, checks the manifest hash binding, and validates capsule integrity before installation, ensuring that only trusted, tamper-proof distro configurations are applied.

crates/astrid-cli/src/commands/distro · high confidence

Introduces astrid-runtime to enable WebAssembly (wasm32-unknown-unknown) support

A new \astrid-runtime\ crate has been added to provide a portable facade for task spawning and time management, allowing the application to run in web browsers. This crate uses compile-time configuration to select the underlying implementation: on native targets, it re-exports \tokio\ and \std\ types directly with zero overhead, while on the \wasm32-unknown-unknown\ target, it maps these operations to JavaScript equivalents (using \wasm-bindgen-futures\ for tasks and \wasmtimer\/\web-time\ for timing). This change enables the kernel to function in browser environments by abstracting away platform-specific runtime primitives.

crates/astrid-runtime · high confidence

Introduces stable, durable identity and ownership models for users and fleets

The identity subsystem now distinguishes between mutable execution principals and stable, durable ownership identities. Users are identified by an \AstridUserId\ that maps platform-specific logins (Discord, Telegram, etc.) to a single canonical user via \FrontendLink\, with principals auto-derived from display names or explicitly set. For authority, the system introduces \UserUid\ and \FleetUid\ derived from immutable genesis records (\UserGenesis\, \PrincipalGenesis\) using Blake3 hashing, ensuring that identity records remain stable even if authentication keys or display names change. This change provides a robust foundation for user and fleet ownership that persists across platform links and key rotations.

crates/astrid-core/src/identity · high confidence

The kernel now includes a passive bus-activity monitor that tracks event publish rates over a 5-second window and logs a warning naming the hottest topics if a sustained rate exceeds 100 events/second, helping operators quickly identify runaway event loops. Additionally, the kernel implements a grant-on-first-use consent handler that intercepts ungranted capsule access attempts, publishes a \GrantRequired\ signal, and waits for an approval response to grant the capsule to the caller, replacing the previous behavior of silently dropping ungranted calls.

crates/astrid-kernel/src · high confidence

Linux FUSE storage provider implementation

The \astrid-storage-provider-fuse\ crate introduces a Linux FUSE filesystem provider that mounts storage volumes via a detached service. It implements the core filesystem operations (stat, read, write, create, remove, rename, sync) by communicating with an authenticated kernel callback client over a Unix socket, using version-2 protocol framing with bounded message sizes. The provider manages its own lifecycle through a private control socket, maintaining a registry of mount records for persistence and cleanup. It exposes volume metadata (name, capacity, timestamps) from the kernel and handles mountpoint preparation, validation, and lazy unmounting. The implementation includes comprehensive tests for the callback transport, control protocol, volume info parsing, and mountpoint handling.

crates/astrid-storage-provider-fuse · high confidence

MCP client capability handlers for sampling, roots, and elicitation

The MCP client now supports server-initiated capabilities defined in the MCP Nov 2025 spec. This includes sampling (allowing servers to request LLM completions), roots (allowing servers to query accessible directories/URIs), and elicitation (allowing servers to request user input, including URL-based flows for OAuth and payments). The implementation introduces dedicated handler traits and composite routing in \crates/astrid-mcp/src/capabilities\, along with conversion logic to bridge the \rmcp\ library's elicitation schema format with the application's canonical types.

crates/astrid-mcp/src/capabilities · high confidence

Migration of legacy principal homes and introduction of host-audit logging

The kernel now supports migrating legacy 'layout-1' principal home directories into the new authoritative storage format. This includes automatically minting durable identities for leftover, unbound principal directories that lack a profile (admitting them so their files import) and quarantining directories with invalid names. The migration process uses durable receipts to track progress, ensuring idempotency and preventing data loss if an alias is renamed or reused. Additionally, a new host-audit sink has been added to the kernel to record sensitive host calls (file, network, and process operations) from WASM capsules. This sink implements a bounded writer that coalesces events, caps guest-controlled string lengths to prevent amplification attacks, and produces a signed, hash-chained audit log.

_crates/astrid-kernel/src/principal\_home\migration · high confidence

New CLI commands for agent lifecycle, capabilities, auditing, and capsule development

The CLI now exposes a comprehensive set of new commands for managing agents, capabilities, audit logs, and capsule development. \astrid agent\ provides full lifecycle management including \create\, \spawn\ (for atomic, throwaway sessions with explicit resource caps and teardown), \claim\, \list\, \show\, \delete\, \enable\, \disable\, and \modify\. \astrid caps\ allows inspection and management of capabilities via \show\, \grant\, \revoke\, \check\, and signed capability tokens (\mint\, \revoke\, \list\). \astrid audit\ offers operator-level accounting and retention controls with \stats\, \prune\, \health\, \heads\, \export\, and \anchor-status\. For developers, \astrid capsule\ includes \build\ (via a companion binary), \check\ (a static CI-friendly linter for tool wiring and manifest correctness), \config\ (for viewing/editing typed env config), and \deps\ (for visualizing the capsule import/export dependency graph). Also in this area: Fixes performance and reliability in workspace cleanup and daemon startup; Fix provisioning lock release on guard drop; Setup now fails on Linux if FUSE prerequisites are missing.

crates/astrid-cli/src/commands, crates/astrid-cli/src/commands/daemon · high confidence

New HTTP API endpoints for agent interaction, audit history, and system administration

The gateway now exposes several new HTTP routes to support dashboard and external client integration. Users can invoke the AI agent via \POST /api/agent/prompt\ (streaming responses via SSE) and handle agent follow-up requests through \POST /api/agent/elicit-response\. System administrators can query historical audit logs via \GET /api/sys/audit\ with pagination and filtering, manage principal capabilities via \POST/DELETE /api/sys/principals/{id}/caps\, and install capsules from GitHub sources via \POST /api/capsules\. Additionally, new endpoints \GET /api/distribution\ and \GET /api/distribution/onboarding\ allow clients to discover deployment branding and invite configuration without authentication.

crates/astrid-gateway/src/routes · high confidence

New HTTP gateway with bearer auth, in-process IPC, and Prometheus metrics

The \astrid-gateway\ crate introduces a new HTTP front-end for the Astrid admin API, replacing the previous socket-only CLI path for local management. It implements v2 ed25519-signed bearer tokens (including device-scoped variants) for authentication, with cryptographically bound revocation via \issued\_at\ timestamps. The gateway communicates with the kernel in-process via a shared \EventBus\ (using \BusAdminClient\ and \BusKernelClient\) to avoid socket-proxy bottlenecks, while preserving principal and device-scope context. It exposes a \/metrics\ endpoint with Prometheus-style counters, histograms, and build-info gauges, and supports native TLS termination via rustls. The default listen port is 2787, and configuration is loaded from \gateway-http.toml\.

crates/astrid-gateway/src · high confidence

New WIT interface definitions for capsule host capabilities

The \astrid-capsule/wit-staging\ directory now includes the formal WIT (WebAssembly Interface Types) definitions for the host interfaces that capsules can import. This adds the contract specifications for core capabilities including filesystem access (\astrid:fs\), HTTP client operations with SSRF protection (\astrid:http\), inter-process communication via an event bus (\astrid:ipc\), key-value storage (\astrid:kv\), networking primitives (\astrid:net\), and user interaction flows like human-in-the-loop approval (\astrid:approval\) and interactive input elicitation (\astrid:elicit\). It also defines the guest export contracts (\astrid:guest\) that the kernel uses to invoke capsule lifecycle hooks (install, upgrade, interceptor, background run). These files establish the API surface and data shapes for the capsule runtime environment.

crates/astrid-capsule/wit-staging · high confidence

New agent lifecycle commands with secure, ephemeral session spawning

The CLI now includes a comprehensive set of commands for managing agent identities, including \create\, \spawn\, \list\, \current\, \switch\, \show\, \delete\, \enable\, \disable\, \modify\, \link\, and \unlink\. The \agent create\ command supports provisioning agents with specific groups, egress rules, and resource limits, and introduces \--clone\ for full profile/state replication and \--inherit-from\ for selective state inheritance. A new \agent spawn\ command allows users to derive a restricted, throwaway principal with explicit capsule loads, allowed egress, and inherited state, execute a single bounded job, and automatically tear down the session. Remote agent features (discover, add, card, export, import, delegate) are present as stubs and currently rejected until future implementation.

crates/astrid-cli/src/commands/agent · high confidence

New capability grammar and content-addressed registry for management API policies

The system introduces a strict, colon-delimited grammar for static capability identifiers used in the management API, replacing the previous ad-hoc handling. This includes a new \capability\_grammar\ module that validates capability strings (enforcing ASCII-only, no double-globs, and specific wildcard rules) and defines core exemption capabilities like \system:resources:unbounded\, \net\_bind\, and \uplink\. Alongside this, a content-addressed capability registry (\capability\_registry\) has been added, featuring two schema revisions (v1 with 51 IDs, v2 adding \self:distro:grant\) that map capabilities to their scope, danger level, and target kinds. This registry serves as the authoritative source for kernel-enforced policy, ensuring that capability definitions are immutable per revision and cryptographically verifiable via BLAKE3 digests. Also in this area: Improved macOS private-path ACL checks using file descriptors.

_crates/astrid-core/src, crates/astrid-core/src/platform\fs · high confidence

New capsule management subcommands and static validation

The CLI now includes a suite of new \astrid capsule\ subcommands to manage the capsule lifecycle and verify correctness. \astrid capsule build\ delegates compilation to a standalone companion binary. \astrid capsule check\ provides a static, CI-friendly linter that validates tool wiring (ensuring advertised tools are routed and handlers match) and mandatory publish patterns without requiring a running daemon. \astrid capsule config\ allows viewing and editing capsule environment variables via the daemon admin API. \astrid capsule deps\ visualizes the dependency graph of installed capsules, showing imports, exports, and unsatisfied dependencies. \astrid capsule install\ has been expanded to support GitHub sources, batch installation, and operator-consent authority checks for untrusted capsules, including live hot-loading of newly installed capsules into a running daemon.

crates/astrid-cli/src/commands/capsule · high confidence

New chunker evidence benchmarking tool

A new standalone Rust binary, \astrid-storage-chunker-evidence\, has been added to measure and report on content-addressed storage chunking algorithms. It evaluates FastCDC v2020, MinCDC, and MothCaterpillar against real and synthetic corpora, producing JSON reports that include throughput, edit stability, and bottom-k sketch evidence to help select optimal chunking profiles.

crates/astrid-storage-chunker-evidence · high confidence

New distro-neutral OCI container images for Linux amd64 and arm64

Astrid Runtime now provides official, distro-neutral OCI container images for both Linux amd64 and arm64 architectures. These images package the authenticated release archives into a minimal Ubuntu 24.04 base, running as an unprivileged user (UID/GID 65532) with a read-only root filesystem and all Linux capabilities dropped. The container entrypoint enforces strict security by requiring an operator-supplied SHA-256 pin for the signed distro, staging it in a private temporary directory to prevent symlink attacks, and rejecting unauthorized daemon arguments like ephemeral mode. Each architecture has its own dedicated build configuration and test suite to verify daemon readiness and runtime restrictions.

container · high confidence

New event bus with IPC rate limiting and per-principal routing

The \astrid-events\ crate now provides a new event bus that broadcasts events to async subscribers and notifies synchronous observers, while introducing IPC rate limiting and per-(capsule, topic, principal) routing. The bus uses a broadcast channel for async delivery and a subscriber registry for synchronous handlers, with a reentrant mutex ensuring ordered publication. IPC messages are stamped with a monotonic sequence number for ordered delivery. A new IPC rate limiter enforces per-principal throughput ceilings and a hard payload size cap to prevent DoS. The routing demux fans out events to per-principal FIFO queues with deficit round-robin fairness and byte-budget eviction to prevent starvation. Event types have been renamed from \AstralisEvent\ to \AstridEvent\, with new events for prompt building, message sending, context compaction, session reset, model resolving, agent loop completion, tool result persisting, and capsule lifecycle. The prelude has been updated to reflect these changes.

crates/astrid-events/src · high confidence

New kernel API surface for agent derivation, audit anchoring, and capsule installation

The kernel management API now exposes new wire types and request methods to support restricted agent derivation, signed audit anchoring, and bounded capsule installation. Users can now atomically provision restricted derived agents with explicit capsule and network controls via the new \AgentDeriveRequest\ and \BeginCapsuleInstallBatch\/\FinishCapsuleInstallBatch\ methods. Audit retention is strengthened with \audit.anchor\_mark\ and \audit.anchor\_status\ endpoints that allow external services to certify chain watermarks and report anchoring lag, alongside a paged \audit.export\ for raw chain data. Capsule installation is now batched and provenance-bound, with explicit authority decisions (Automatic, ExplicitApproval, OperatorDistribution) and crash-safe resume receipts, while device pairing tokens support attenuated capability scopes (Full, Preset, Explicit) to limit what redeemed devices can do.

_crates/astrid-core/src/kernel\api · high confidence

New macOS FSKit build, certification, and release infrastructure scripts

The scripts directory now includes a comprehensive set of tooling to build, sign, notarize, and certify the macOS FSKit application and release archives. build-macos-fskit.sh automates the Xcode build of the AstridFS app and extension, enforcing code signing with a specific team identifier, verifying bundle versions and architectures, and optionally submitting the app to Apple Notary. certify\_fskit\_local.py provides a supervised runtime verification of the installed app, ensuring the archive matches the installed binary and that mount, write, sync, and unmount operations function correctly. Additional scripts enforce release integrity: certify\_musl\_release\_archive.sh validates Linux musl archives for correct members and static linking; channel\_metadata.py and channel\_publication.py manage and validate signed release-channel pointers (stable, dev, nightly) with strict schema and lifetime checks; check-macos-fskit.sh validates the Swift source and Xcode project constraints for the FSKit extension; check-wasm-portability.sh ensures core crates compile for wasm32-unknown-unknown; check\_dco.py enforces Developer Certificate of Origin sign-offs; check\_glibc.py and check\_static\_elf.py validate binary compatibility and static linking for Linux releases; and ci/diff-gateway-openapi.sh detects unintended OpenAPI contract changes. ci/import\_macos\_signing.sh securely imports signing identities and notary credentials into the CI environment.

scripts · high confidence

Operator tooling to attribute agent execution costs to specific users

The CLI now includes commands to manage resource attribution: \assign-user\ allows an operator to explicitly link a principal (agent) to a specific user for billing purposes, while \users\ lists registered users and their identities. On the kernel side, resource execution now enforces that principals have an assigned resource user, refusing to run with unlimited budgets if unassigned, and correctly applies per-user CPU fuel policies from the runtime home configuration.

_crates/astrid-cli/src/commands/quota, crates/astrid-kernel/src/user\resources · high confidence

Per-principal profile system with device-scoped authentication and resource quotas

A new per-principal profile system has been introduced, storing policy in \\~/.astrid/etc/profiles/{principal}.toml\ to ensure capsules cannot read or write their own policy. This system defines resource quotas (memory, CPU fuel, timeouts, IPC throughput, background processes) with strict validation and legacy zero-CPU-fuel coercion. Authentication is enhanced with per-device capability scoping: registered device keys now carry a \DeviceScope\ (either \Full\ or \Scoped\ with allow/deny patterns), allowing operators to restrict device capabilities beyond the principal's base permissions. The profile also manages group memberships, direct capability grants/revokes, capsule access lists, egress policies, and process allowlists, with atomic file saves on Unix and robust error handling for malformed or versioned profiles.

crates/astrid-core/src/profile · high confidence

Persistent group configuration with secure on-disk storage

Users can now define custom groups in \groups.toml\ that persist across restarts. The system introduces built-in groups (admin, agent, restricted) which are baked into the kernel and never serialized to disk, while only custom groups are written to the configuration file. To prevent privilege escalation, custom groups cannot grant the universal \\*\ capability unless they explicitly opt in via the \unsafe\_admin\ flag. The implementation ensures security by writing the configuration file atomically with restricted permissions (mode 0600 on Unix) and cleaning up temporary files on failure.

crates/astrid-core/src/groups · high confidence

Support for publishing astrid-capsule as a standalone crate

The astrid-capsule crate is now publishable to crates.io and usable via \cargo install astrid\. A new build script stages the required WIT (WebAssembly Interface Types) files from the workspace submodule into a committed \wit-staging\ directory, ensuring that consumers installing the crate do not need the git submodule or the full workspace source to compile. This change also adds a \.gitignore\ to manage the staging directory and updates the README to reflect the current architecture and MSRV of 1.94.

crates/astrid-capsule · high confidence

Unified prelude for Astrid secure agent runtime

A new \astrid-prelude\ crate has been introduced to provide a single import point for commonly used types across the Astrid ecosystem. Users can now access types from core, crypto, capabilities, audit, MCP, events, hooks, and workspace crates via \use astrid\prelude::\\, simplifying dependency management and reducing boilerplate in applications that need functionality from multiple subsystems.

crates/astrid-prelude/src · high confidence

Windows filesystem provider via WinFsp

A new \astrid-storage-provider-winfsp\ crate introduces a native Windows filesystem provider backed by WinFsp, enabling Astrid storage volumes to be mounted as standard Windows drives. The implementation includes a daemon and service mode for lifecycle management, a callback-based filesystem interface that translates Win32 I/O operations into Astrid's storage protocol, and a build script to link the WinFsp runtime. This allows Windows users to interact with Astrid storage using familiar file explorer operations.

crates/astrid-storage · high confidence

Workspace boundary enforcement and sandboxing architecture

The workspace crate now enforces strict operational boundaries for agent actions, introducing a configurable path-checking system that distinguishes between allowed, auto-allowed, and never-allowed paths based on workspace mode (Safe, Guided, or Autonomous) and escape policies. This includes new pre-defined profiles (safe, power\_user, autonomous, ci) to simplify configuration, and a dedicated sandbox module that generates host-level process sandboxes with read-only file injection capabilities. Additionally, agent sessions now utilize isolated Git worktrees to prevent cross-session interference, with automatic cleanup and WIP preservation upon session completion. The crate has also been renamed from 'astralis' to 'astrid' and internal modules have been restricted to crate-private visibility to enforce architectural boundaries.

crates/astrid-workspace/src · high confidence

macOS FSKit storage provider implementation

Added a new storage provider component for macOS that manages FSKit-based filesystem mounts. This includes the main service entry point handling mount, sync, status, and unmount operations via the storage provider protocol, along with specialized logic to classify and report native mount failures (such as missing or disabled FSKit extensions) and a hidden service mode for kernel-created broker interactions. This change introduces the specific macOS storage lifecycle companion without altering other platform providers.

crates/astrid-storage-provider-fskit · high confidence

Removals

Gateway daemon layer removed

The \astralis-gateway\ crate has been completely removed from the codebase. This eliminates the daemon-side runtime layer that previously handled configuration loading, multi-agent management, message routing, health checks, and IPC-based CLI communication (including approval/elicitation workflows). Users no longer interact with a persistent gateway daemon; the functionality provided by this crate is no longer available.

crates/astralis-gateway · high confidence

Removal of astralis-core crate

The \astralis-core\ crate, which previously provided the foundational types, traits, and utilities for the Astralis secure agent runtime SDK, has been removed. This deletion eliminates the core abstractions for security operations, identity management (\AstralisUserId\), the \Frontend\ trait for UI implementations, input classification (\TaggedMessage\), and common types such as \SessionId\, \Permission\, and \Version\. Users relying on this crate for these foundational components will need to migrate to the new architecture.

crates/astralis-core, crates/astralis-mcp · high confidence

Removal of core Astralis crates

The audit logging, capability token, and LLM provider subsystems have been removed from the repository. This deletion eliminates the chain-linked cryptographic audit trail, the ed25519-signed capability authorization system, and the multi-provider LLM abstraction (including Claude, OpenAI-compatible, and Z.AI implementations).

(repo-wide) · high confidence

Removal of initial SDK crate scaffolding

The initial commit has removed the source code and documentation for several core SDK crates, including \astralis-cli-mockup\ (demo scenarios), \astralis-config\ (configuration loading), \astralis-crypto\ (cryptographic primitives), \astralis-events\ (event bus), and \astralis-workspace\ (operational boundaries). This deletion removes the foundational components for secure agent runtime operations, configuration management, and user-controlled workspace boundaries.

(repo-wide) · high confidence

Removal of legacy approval and runtime crates

The \astralis-approval\ and \astralis-runtime\ crates have been removed from the codebase. This deletion eliminates the previous allowance-based permission system, the security interceptor, and the agent orchestration runtime that coordinated LLM, MCP, and audit components. Users will no longer have access to the legacy session management, context summarization, or the specific policy and budget enforcement logic defined in these modules.

crates/astralis-approval, crates/astralis-runtime · high confidence

Security

Native process sandboxing now enforces strict credential masking and profile injection validation

The sandbox layer for spawned native processes now actively masks sensitive operator credentials (such as SSH keys, AWS/GCP credentials, and Docker tokens) and Astrid internal secrets by overlaying them with empty tmpfs or /dev/null, preventing agent processes from reading host-level secrets. On Linux, the implementation uses bubblewrap with a new probe to detect user-namespace restrictions (e.g., on Ubuntu 24.04+) and provides clear installation hints if unavailable. On macOS, it generates and validates Seatbelt (SBPL) profiles, rejecting paths with forbidden characters (quotes, backslashes, null bytes) to prevent profile injection attacks. These changes ensure that agent-executed tools are strictly confined to the worktree and cannot access the operator's home directory secrets.

crates/astrid-workspace/src/sandbox · high confidence

Per-principal capsule access control with grant-on-use prompting

Capsule tool and CLI command invocations are now gated by the principal's explicit grant set, preventing unauthorized access to installed capsule tools. When a principal attempts to invoke a capsule they do not have permission to use, the system emits a \GrantRequired\ approval prompt, which is committed to the audit log before being published, allowing the user to grant access for that specific capsule. This change introduces the \CapsuleAccessResolver\ and \HostAuditSink\ to enforce this security boundary at the dispatch hot path while maintaining performance through lock-free reads.

crates/astrid-capsule/src · high confidence

Behavioural changes

Approval system hardening: per-capsule scoping, new action types, and risk model simplification

The approval system now enforces stricter isolation and security for agent actions. Network requests and other sensitive operations are scoped to a specific \capsule\_id\, ensuring that allowances granted to one capsule cannot be reused by another. New action types have been added to cover capsule-specific operations: \CapsuleExecution\, \CapsuleHttpRequest\, \CapsuleFileAccess\, and \CapsuleNetBind\. The previous \RiskLevel\ enum and automatic risk assessment logic have been removed from the approval request types; risk is now communicated via a human-readable reason string instead. Additionally, the budget tracker now supports refunding costs for failed or reversed actions, and the approval manager's \check\_approval\ method requires a \PrincipalId\ to correctly scope allowance lookups.

crates/astrid-approval/src · high confidence

CLI redesign with noun-verb structure and per-principal scoping

The \astrid\ CLI has been restructured to follow a noun-verb command model (e.g., \astrid agent\, \astrid capsule\, \astrid quota\) and now enforces a single process-wide principal identity for all IPC messages. This change introduces a new \--principal\ flag and \ASTRID\_PRINCIPAL\ environment variable to stamp every request with a verified identity, while adding a \cli-context.toml\ file to persist the active agent for per-agent commands. The CLI also now co-installs companion binaries like \astrid-daemon\ and \astrid-build\ alongside the main binary, and includes a new \astrid mcp\ surface for Model Context Protocol integration.

crates/astrid-cli/src · high confidence

CLI renamed to Astrid

The command-line interface has been renamed from Astralis to Astrid. This change is reflected in the crate's documentation and internal module structure, marking the rebranding of the CLI frontend.

crates/astralis-cli · high confidence

Capsule installation authority and provenance enforcement

The capsule installer now enforces strict provenance classification and authority receipts for every installed capsule. Archives are unpacked with path-traversal and symlink hardening, and their manifests are validated before installation. The system classifies artifacts as signed by the local runtime, signed by a foreign runtime, or unsigned, and requires an explicit \AuthorityDecision\ (automatic for local builds, explicit approval for others) to persist an \InstalledAuthority\ receipt. This receipt pins the approved content digest, manifest digest, and WASM executable hash, preventing post-install tampering. Legacy authority receipts from previous layouts are automatically rebound to new targets or quarantined if ambiguous. Additionally, the installer detects and warns about WIT contracts skew between installed capsules and the daemon's canonical contracts, ensuring runtime compatibility without blocking installation.

crates/astrid-capsule-install · high confidence

Configuration system renamed to Astrid with new client, gateway, and filesystem settings

The configuration crate has been renamed from Astralis to Astrid, updating all environment variable prefixes (e.g., \ASTRALIS\\\ to \ASTRID\\\) and config file paths (e.g., \\~/.astralis/\ to \\~/.astrid/\). This change introduces a new pre-mount client configuration module (\client.rs\) that manages local CLI settings like \run\_idle\_secs\ and \admin\_timeout\_secs\ with strict file validation, and a new gateway configuration module (\gateway.rs\) for MCP HTTP listener and state directory settings. The default configuration (\defaults.toml\) removes the monolithic \\[model\]\ section in favor of a \\[filesystem\]\ section for volume naming, adds \\[http\]\ host limits for operator-configurable timeouts and caps, and introduces \\[capsule\]\ concurrency settings. The configuration loader now supports explicit home directory and workspace layout overrides, and the \config show\ command reflects these structural changes.

crates/astrid-config/src · high confidence

Daemon lifecycle and signal handling improvements

The daemon now includes a standalone binary entry point that detaches into its own process session to prevent orphaning when the CLI exits, and implements a robust signal watchdog that ensures graceful shutdown even under high load by forcing an exit after a grace period if the async runtime is starved. Additionally, the daemon supports an ephemeral mode that automatically shuts down when the last client disconnects, and allows routing logs to standard error via the ASTRID\_DAEMON\_LOG\_TARGET environment variable for better integration with process supervisors and containers.

crates/astrid-daemon · high confidence

Domain-separated identifiers and atomic key storage

The crypto crate now introduces \IdentifierHash\ and \PublicKeyFingerprint\ types that use BLAKE3 domain separation to prevent cross-protocol collisions, and replaces the previous \KeyPair::load\_or\_generate\ method with a new \load\_or\_generate\_keypair\ function in \key\_storage.rs\ that atomically creates Ed25519 keys with owner-only permissions. The \ContentHash\ API is simplified by removing \hash\_multi\ and \hash\_with\_domain\ in favor of the new typed identifier wrappers, and the crate is renamed from \astralis\ to \astrid\ with stricter compiler lints enforced.

crates/astrid-crypto/src · high confidence

Extracted wasm-clean capsule types and added semantic capability presentation

The \astrid-capsule-types\ crate has been extracted into a standalone, wasm-clean library to provide a shared vocabulary for capsule manifests, identifiers, and resource limits without pulling in engine-specific runtimes like Wasmtime or Tokio. This change introduces a new \capability\_presentation\ module that translates raw manifest capability fields into human-readable actions, scopes, and impacts for CLI and dashboard consent surfaces. It also refactors the \CapabilitiesDef\ merge logic to be exhaustive, ensuring that component-level capability grants are correctly merged into the root manifest without silent drops.

crates/astrid-capsule-types · high confidence

Hooks system renamed to Astrid and event model expanded

The hooks subsystem has been renamed from Astralis to Astrid, updating all public types, environment variables (e.g., ASTRID\_SESSION\_ID), and built-in profile messages. The hook event model has been expanded with new lifecycle stages including SessionReset, ModelResolve, MessageReceived, MessageSent, AgentLoopEnd, ToolResultPersist, KernelStart, and KernelStop. Additionally, the WASM handler is now implemented via Extism rather than being a stub, and hook discovery now uses the project's workspace layout instead of hardcoded config paths.

crates/astrid-hooks/src · high confidence

Integration test crate renamed to Astrid with stricter linting

The integration test crate has been renamed from Astralis to Astrid, and its linting configuration has been tightened. The crate now enforces \missing\_docs\ and \unreachable\_pub\ as hard errors (previously warnings or absent), and explicitly denies the use of \unwrap()\ in non-test code to prevent panics, while allowing \unwrap()\ within test blocks.

crates/astrid-integration-tests/src · high confidence

Introduce secure inbound message handling for MCP client capabilities

The \astrid-mcp\ client capability layer now includes a dedicated handler (\AstridClientHandler\) and supporting modules to process inbound messages from untrusted capsule subprocesses. This change adds strict validation for channel names, payload sizes, and capsule IDs to prevent spoofing and resource exhaustion, while mapping bridge channel definitions to core uplink capabilities. It also implements the \rmcp::ClientHandler\ trait to bridge MCP server requests (sampling, roots, elicitation) to Astrid's internal capability system.

crates/astrid-mcp/src/capabilities/client · high confidence

Kernel router enforces strict caller authentication and connection tracking

The kernel management API now strictly requires an authenticated principal for all management requests, rejecting any request with a missing or invalid principal identity to prevent unauthorized access. Additionally, the router implements a robust connection tracker that accurately accounts for client connections by recognizing both typed IPC payloads and JSON-based topics, ensuring that connection counts are correctly attributed to the authenticated principal rather than defaulting to anonymous or default identities, which fixes previous connection leak issues.

_crates/astrid-kernel/src/kernel\router · high confidence

The MCP server's consent flow has been updated to explicitly show the authenticated ingress principal to the user. This change, implemented in the new \consent.rs\ module, ensures that when a tool invocation requires consent (ingress, grant, or approval), the user can see exactly which identity is requesting access, improving transparency and security awareness during the interaction.

crates/astrid-cli/src/commands/mcp/server · high confidence

OS-level copy-on-write for non-git workspaces

Non-git workspaces now use real OS-level copy-on-write instead of an in-process overlay, ensuring that spawned processes (like cargo or build scripts) see a single merged filesystem view. On macOS, this uses APFS clonefile(2) clones; on Linux, it uses overlayfs mounts (with fuse-overlayfs as a fallback). Changes are isolated in a working tree and only committed to the pristine workspace via an explicit promote, with rollback support to discard uncommitted changes.

_crates/astrid-vfs/src/workspace\cow · high confidence

Principal-scoped capability tokens and static policy enforcement

The capabilities system now enforces strict per-principal isolation: capability tokens are cryptographically bound to the principal they were minted for, preventing cross-principal reuse, and the signing format has been upgraded to version 2 to include this binding. Additionally, a new static policy engine (\CapabilityCheck\) evaluates management-API permissions based on principal profiles, group memberships, and per-device scopes, with revokes taking precedence over grants. The capability store also now supports persistent token storage via \SurrealKvStore\ and introduces cryptographic handles (\DirHandle\, \FileHandle\) for VFS directory and file access.

crates/astrid-capabilities/src · high confidence

Project renamed to Astrid and updated to Rust 1.95

The project has been renamed from Astralis to Astrid, with the README, clippy configuration, and rustfmt configuration updated to reflect the new identity. The Minimum Supported Rust Version (MSRV) has been bumped from 1.93 to 1.95, and the rust-toolchain.toml now specifies channel 1.95.0.

(repo-wide) · high confidence

Refactored config merging into modular submodules with strict security enforcement

The configuration merge logic in \crates/astrid-config/src/merge\ has been decomposed from a single file into focused submodules (\deep.rs\, \enforce.rs\, \restrict.rs\, \servers.rs\, \path.rs\, \types.rs\). This refactoring introduces a robust security model where workspace-level configurations are strictly constrained: they can only tighten security settings (e.g., reducing budget limits, tightening escape policies, or decreasing rate limits) and are blocked from overriding operator-defined critical fields like HTTP host limits, uplink allowlists, and server command/args. Additionally, workspace-injected servers are automatically forced to be untrusted and non-auto-starting, ensuring that project-level configs cannot escalate privileges or alter core runtime behavior.

crates/astrid-config/src/merge · high confidence

Rename astralis to astrid and tighten handler visibility

The hook handler module has been renamed from \astralis-hooks\ to \astrid-hooks\, updating all internal references, environment variable names (e.g., \ASTRID\_HOOK\_EVENT\), and system prompts to reflect the new product name. Additionally, the visibility of the handler modules (\agent\, \command\, \http\, \wasm\) and their public types has been restricted from \pub\ to \pub(crate)\, and the \HandlerExecutor\ trait has been removed, indicating a shift toward internal-only implementation details for hook execution.

crates/astrid-hooks/src/handler · high confidence

Renamed test crate to Astrid and expanded test utilities

The \astralis-test\ crate has been renamed to \astrid-test\ to align with the project's rebranding. This change introduces new test fixtures for core types such as \AgentId\, \SessionId\, \ApprovalRequest\, and \ElicitationRequest\, along with a \TestContext\ harness for managing temporary directories and files. A \MockEventBus\ has been added to capture and verify emitted events during tests. The crate's strictness has also increased by enforcing \deny(missing\_docs)\, \deny(unreachable\_pub)\, and \deny(clippy::unwrap\_used)\ (with a test-only allow), and the public API now exposes these new utilities via a prelude module.

crates/astrid-test/src · high confidence

Routed event subscriptions now support per-principal isolation and strict delivery guarantees

The event bus routing layer has been rewritten to introduce \RouteEntry\ state machines that manage per-principal fan-out, Deficit Round Robin (DRR) scheduling, and byte-budget eviction. Subscriptions can now be scoped to a specific owner principal, ensuring that foreign-principal events are rejected at enqueue time and cannot evict the owner's own messages from the queue. To prevent data loss during high-rate bursts (such as LLM token streams), the per-principal message count cap has been increased from 256 to 16,384, and the system now guarantees loss-free receive by handling concurrent dispatch and preventing event drops during drain operations. Additionally, a new \RouteAdmissionGate\ allows staged runtimes to prepare subscriptions before atomically publishing them, ensuring no events are lost or delivered prematurely during initialization.

crates/astrid-events/src/route · high confidence

TUI restructured with multi-line paste support and terminal color inheritance

The TUI module has been restructured into a new modular layout (headless, input, state, render, theme) within the \astrid-cli\ crate. Users can now paste multi-line text blocks into the input buffer, which are treated as atomic segments for editing. The default color theme has been updated so that primary text and the cursor inherit the terminal's foreground color (using \Color::Reset\) instead of forcing white, ensuring better visibility on light terminal backgrounds. Additionally, a new headless snapshot mode has been added to render TUI frames to an in-memory buffer for automated testing.

crates/astrid-cli/src/tui · high confidence

Telemetry crate renamed to Astrid with stricter linting and logging improvements

The telemetry crate has been renamed from \astralis\_telemetry\ to \astrid\_telemetry\, updating all public API references, documentation, and default log file prefixes to reflect the new product name. The crate now enforces stricter Rust linting by denying \missing\_docs\, \unreachable\_pub\, and \unwrap\_used\ (except in tests), and removes the \setup\_default\_logging\ convenience function. The \RequestGuard\ type has been removed, simplifying the request lifecycle management. Additionally, file logging now explicitly disables ANSI color codes for cleaner log output and uses a builder pattern for rolling file appenders with a configurable maximum file count (defaulting to 7). A new \log\_config\_from\ function is available when the \config\ feature is enabled to convert application configuration into telemetry settings.

crates/astrid-telemetry/src · high confidence

Fixes

Added detection for residual stopped-install runtime keys

The application now includes logic to recognize a specific 'stopped-install' failure state in the user's home directory. This new capability allows the system to identify when a previous installation attempt left behind residual runtime keys and associated directory structures (such as \astrid.volume\, \keys\, \run/system.lock\, and \etc\ sentinel files) without authorizing recovery. By detecting this specific shape, the software can prevent accidental overwrites or unsafe modifications to these leftover artifacts, ensuring that storage initialization fails safely rather than proceeding with potentially corrupted or incomplete state.

crates/astrid-core/src/dirs · high confidence

Audit sink now guarantees ordered, loss-accounted recording of host calls

The kernel's audit sink now ensures that host-call entries (file operations, network connections, process spawns, HTTP exchanges, tool calls, and approvals) are recorded in strict per-principal FIFO order. It introduces a lane-based architecture that folds consecutive identical calls into single signed entries to reduce log volume, while explicitly accounting for any calls lost due to queue overflow in signed loss records. Additionally, the system now detects unclean shutdowns and records signed gap entries upon restart to maintain chain continuity, and it caps guest-controlled string lengths to prevent audit log amplification attacks.

_crates/astrid-kernel/src/audit\sink · high confidence

Fix: locally redeemed invitation credentials are now activated

The \astrid keypair\ command now correctly activates the local ed25519 identity key when it is bound to a principal via \astrid invite redeem\. Previously, the keypair remained in a local, unbound state even after a successful redemption. This fix ensures that the redeemed key is properly written to the operator's credential store (\$ASTRID\_HOME/keys/local/\) and marked as bound, allowing the operator to use it for authentication and signing immediately after redemption.

crates/astrid-cli/src/commands/keypair · high confidence

Fixes for legacy migration barrier and principal environment import

This change introduces a comprehensive set of fixes to the \legacy\_migration\_barrier\ module, ensuring a safe and verifiable cut-over from the legacy layout-one state to layout-two. The new \env\_import.rs\ and \env\_inventory.rs\ modules preserve retained principal environment variables and secret scopes, even for capsules that are no longer installed, by tracking them in a UID-bound inventory. The \legacy\_audit.rs\ module now correctly quarantines non-empty leftover audit trees from layout-1 while retiring empty ones. Additionally, \legacy\_permissions.rs\ and \legacy\_tmp.rs\ normalize file permissions (tightening umask-inherited modes) and directory structures for legacy sources, preventing snapshot failures. The \ledger.rs\ module enforces a canonical migration ledger with destination proofs, ensuring that all native state components are accounted for and retired only after successful import, thereby preventing partial migrations from being served.

_crates/astrid-kernel/src/legacy\_migration\barrier · high confidence

Fixes for storage mount stability, capacity reporting, and large file handling

This update resolves several issues in the storage mount subsystem. It prevents macOS FSKit container resolution from blocking async workers by offloading the operation to a blocking thread, ensuring system responsiveness during privacy permission waits. It also corrects the volume capacity reporting to accurately reflect the physical backing filesystem's available space rather than the logical volume size. Additionally, the storage mount now supports writing files that exceed the callback payload limit by streaming replacements, and it correctly preserves the shared mount parent directory during lease cleanup to avoid unintended removal of active resources.

_crates/astrid-kernel/src/storage\mount · high confidence

Improved reliability and configuration preservation during \`astrid init\`

The \astrid init\ command now better preserves user-configured values when applying distribution defaults, ensuring that explicit operator inputs are not overwritten by distro defaults during upgrades or resumed installations. It also handles optional credentials correctly by avoiding the creation of empty credential values, and refreshes the selection of authenticated Distro members to ensure the correct capsules are targeted. Additionally, the initialization process now maintains a persistent daemon connection throughout provisioning to support multi-step admin requests, and ensures that migration and provider setup steps are preserved correctly.

crates/astrid-cli/src/commands/init · high confidence

Multiple stability, performance, and security fixes

This release addresses several distinct areas: it applies patched Wasmtime and WebPKI trust dependencies to resolve multiple security advisories (RUSTSEC-2026-0378 through 0383, 0391, 0398, 0403, 0410) and updates ctutils to fix non-constant-time operations (RUSTSEC-2026-0385). It improves storage and runtime performance by recovering object-index deltas and fallback volume commits in linear work, avoiding redundant cache owner-index copies, and reusing validated ownership snapshots during workspace branch cleanup. It also fixes resource leaks and race conditions by releasing the distro provisioning lock when its guard ends, retiring compiled capsule cache keys after final runtime release, purging retired principal KV data, and ensuring the daemon start fence is released correctly. Additionally, it filters routed events by principal admission to avoid foreign-principal allocation churn, inspects and removes macOS extended ACLs through captured descriptors, and ensures canonical user configuration is loaded consistently.

changes · high confidence

Prevent shell profile modifications in isolated Astrid home environments

The self-update and initialization logic now detects when the \ASTRID\_HOME\ environment variable points to a non-default location. In these isolated scenarios, the CLI skips writing to shell configuration files (such as \.bashrc\ or \.zshrc\) to avoid polluting the user's global shell environment with PATH entries intended only for the isolated runtime. This ensures that account-level PATH setup only occurs when using the standard default home directory.

_crates/astrid-cli/src/commands/self\update · high confidence

User configuration now loads both legacy and canonical files with explicit precedence

The configuration loader now discovers and merges two user-level files: the legacy root \config.toml\ and the canonical \etc/config.toml\ (located at \$ASTRID\_HOME/etc/config.toml\ or \\~/.astrid/etc/config.toml\). Both files are treated as part of the same configuration layer, with the canonical file taking precedence for overlapping settings while legacy-only fields are preserved. If either file is malformed, loading fails immediately rather than falling back to the other file. This change ensures consistent loading of user settings and clarifies the precedence rules in the documentation.

crates/astrid-config/src/loader · high confidence

Test coverage

Add structured fuzz testing infrastructure; Added Windows named-pipe security validation tests; Added adversarial capsule fixture for e2e testing; Added integration and contract tests for CLI daemon lifecycle and scenario coverage; Added integration test suite for security, daemon, and gateway components; Added integration tests for gateway CORS, model routing, revocation durability, and router middleware; Added regression tests for BLAKE3 hashing contract; Added test for Windows named-pipe authenticated handshake; Added tests for environment variable handling and refresh logic; New e2e runtime coverage manifests and concurrency verification; New runtime E2E smoke test suite and test infrastructure; Removed integration test suite for agent runtime and security subsystems.

Dependencies

Initial dependency lock and workspace manifest structure

The repository now includes a generated \Cargo.lock\ file and a set of \Cargo.toml\ manifests for the Astrid workspace crates (including \astrid-build\, \astrid-capsule\, \astrid-cli\, \astrid-core\, \astrid-daemon\, \astrid-gateway\, \astrid-kernel\, \astrid-storage\, and others). This establishes the dependency graph and version constraints for the secure agent runtime, CLI, and kernel components.

(dependencies) · high confidence

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

How this codebase got here

Score

  • CAI 50 → 49 (-1.1)

Lenses

  • Code Health 82 → 82 (+0.0)
  • Architecture 92 → 92 (-0.1)
  • Maturity 85 → 92 (+6.5)
  • Readiness 83 → 77 (-6.4)
  • Security 93 → 92 (-0.5)
  • Event-Driven 10 → 10 (+0.0)
  • Event Sourcing 100 → 100 (+0.0)
  • Performance 89 → 89 (+0.0)

Resolved (31)

  • ClassTooLong: EventBus (crates/astrid-events/src/bus.rs)
  • Documentation: written for insiders (crates/astrid-kernel/README.md)
  • Duplicate intent with different return types. has_capability returns a boolean, while find_capability returns the full token. This is a common pattern, but find_capability might be misleading if it only returns the token for checking purposes and doesn't imply usage/consumption. If find_capability is just a lookup, it should be named get_capability or lookup_capability. has is a predicate, find is a retrieval. This is acceptable, but find often implies 'find and use' in some contexts, whereas get is neutral. Given AllowanceStore uses find_matching, this is consistent with that module, but inconsistent with standard library conventions where get is lookup and has is boolean check.
  • Duplicated block (5 lines × 2) (crates/astrid-storage/src/engine/durable/format/mod.rs)
  • Edited copy of a member (13 corresponding lines) (scripts/musl_release_manifest.py)
  • FileTooLong: src/bus.rs (crates/astrid-events/src/bus.rs)
  • FileTooLong: src/platform_fs.rs (crates/astrid-core/src/platform_fs.rs)
  • FunctionTooLong: astrid_config::loader::load_with_layout (crates/astrid-config/src/loader.rs)
  • Hotspot: crates/astrid-cli/src/commands/doctor.rs (crates/astrid-cli/src/commands/doctor.rs)
  • Hotspot: crates/astrid-cli/src/commands/wit.rs (crates/astrid-cli/src/commands/wit.rs)
  • Hotspot: crates/astrid-core/src/capability_registry.rs (crates/astrid-core/src/capability_registry.rs)
  • Hotspot: crates/astrid-storage/src/storage_model/mod.rs (crates/astrid-storage/src/storage_model/mod.rs)
  • Hotspot: scripts/channel_metadata.py (scripts/channel_metadata.py)
  • Inconsistent method naming for parameterized variants. The base method append likely uses a default or implicit principal. The variants use _with_principal and _with_actor. This is inconsistent with common Rust/Go patterns where the base method takes the most common parameters, and optional/extra parameters are handled via builder patterns or distinct names like append_for_principal. Here, append_with_actor includes principal as well, making the hierarchy confusing. Is append the 'simple' case? Does it assume a single principal? The naming doesn't clearly indicate the relationship between the three.
  • Inconsistent naming for retrieving pending items. DeferredResolutionStore uses get_pending (singular return type DeferredResolution), while ApprovalManager uses get_pending_resolutions (plural name, but singular return type DeferredResolution). The plural name suggests a collection, but the return type is a single item. This is confusing.
  • MethodTooLong: WorkspaceBranchStore.rename_batch (crates/astrid-storage/src/content/store/workspace/operations.rs)
  • Near-duplicate member pair (50 shared lines) (crates/astrid-capsule/src/engine/wasm/host/process/mod.rs)
  • No context/problem and no consequences/trade-offs; only a one-line decision with no rationale (changes/2113.fixed.md)
  • No context/problem framing the decision (why trust must persist across reconnections/runtime restarts) and no consequences/trade-offs (changes/2120.fixed.md)
  • No context/problem statement (why this authentication metadata visibility is needed) and no consequences/trade-offs (changes/2118.fixed.md)
  • …and 11 more

New (49)

  • Change coupling: capsule.rs ↔ manifest_gate.rs (crates/astrid-capsule/src/capsule.rs)
  • Classify ADR enforcement: 2182.fixed (changes/2182.fixed.md)
  • Classify ADR enforcement: 2186.security (changes/2186.security.md)
  • Classify ADR enforcement: 2188.fixed (changes/2188.fixed.md)
  • Classify ADR enforcement: 2191.fixed (changes/2191.fixed.md)
  • Classify ADR enforcement: 2194.fixed (changes/2194.fixed.md)
  • Classify ADR enforcement: 2198.fixed (changes/2198.fixed.md)
  • Classify ADR enforcement: 2202.fixed (changes/2202.fixed.md)
  • Classify ADR enforcement: 2208.fixed (changes/2208.fixed.md)
  • Classify ADR enforcement: 2209.fixed (changes/2209.fixed.md)
  • Classify ADR enforcement: 2209.security (changes/2209.security.md)
  • Classify ADR enforcement: 2214.fixed (changes/2214.fixed.md)
  • Classify ADR enforcement: 2243.fixed (changes/2243.fixed.md)
  • Classify ADR enforcement: 2287.fixed (changes/2287.fixed.md)
  • Classify ADR enforcement: 2319.fixed (changes/2319.fixed.md)
  • Duplicated block (10 lines × 2) (crates/astrid-cli/src/commands/daemon/temporary.rs)
  • Duplicated block (14 lines × 2) (crates/astrid-capsule/src/engine/wasm/host/process/mod.rs)
  • Duplicated block (19 lines × 2) (crates/astrid-core/src/platform_fs/macos_acl.rs)
  • Edited copy of a member (13 corresponding lines) (scripts/musl_release_manifest.py)
  • Hotspot: crates/astrid-cli/src/commands/setup.rs (crates/astrid-cli/src/commands/setup.rs)
  • …and 29 more

Changes since last survey

  • 27 commits — 6 feature/other, 21 fixes

By area

  • (root) — 9 commits
  • crates/astrid-capsule — 5 commits
  • crates/astrid-storage — 2 commits
  • .github/workflows — 1 commit
  • changes/2135.fixed.md — 1 commit
  • changes/2144.fixed.md — 1 commit
  • changes/2191.fixed.md — 1 commit
  • changes/2194.fixed.md — 1 commit
  • crates/astrid-cli — 1 commit
  • crates/astrid-config — 1 commit
  • crates/astrid-core — 1 commit
  • crates/astrid-events — 1 commit
  • crates/astrid-kernel — 1 commit
  • crates/astrid-workspace — 1 commit

Notable commits

  • fix: fix(capsule): bound profile invalidation memory during agent churn (#2189)
  • fix: fix(capsule): retire compiled cache keys after final runtime release (#2199)
  • fix: fix(cli): allow separate OS users to share the temporary directory (#2133)
  • fix: fix(cli): release provisioning flock when its guard ends (#2193)
  • fix: fix(config): load canonical user configuration consistently
  • fix: fix(core): use captured descriptors for macOS private-path ACL checks
  • fix: fix(deps): update Rustls to 0.23.46 security patch (#2134)
  • fix: fix(deps): update Wasmtime security patch to 48.0.6 (#2142)
  • fix: fix(events): admit scope before retaining delivery snapshots (#2203)
  • fix: fix(ipc): report nested capsule delivery failures (#2129)
  • fix: fix(mcp): report correlated invocation failures promptly (#2122)
  • fix: fix(release): embed selected source commit in CLI builds (#2125)
  • fix: fix(runtime): avoid repeated cleanup decoding and release start fences (#2209)
  • fix: fix(security): apply ctutils constant-time repair (#2246)
  • fix: fix(security): apply patched runtime and trust dependencies (#2187)
  • fix: fix(storage): avoid redundant cache owner-index copies (#2195)
  • fix: fix(storage): make index and fallback volume recovery linear (#2184)
  • fix: fix(storage): preserve populated workspace renames (#2138)
  • fix: fix(storage): retire principal KV after identity unlink (#2215)
  • fix: fix(workspace): allow metadata traversal to authorized script roots (#2136)
  • …and 7 more

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

Survey your own repository

astrid-runtime/astrid 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.

About this page

  • The score is its most recent published measurement, taken on 27 October 2026 at a pinned commit. It is not a live figure and does not change until the project is measured again.
  • Measured at commit 7c3f2ca81d1854668c3081d28f5f52e4eba6c440 — the exact code this score is about.
  • Scored under rubric-2026.10.5 — the same rubric and the same method as every other entry in this index.
  • Measured by watchdog.canine.dev using codehealth-analyzer measure-2026.10.34+preprod-c12eef3a1477.