atuinsh/atuin

Atuin is a command-line history tool that captures shell commands, their output, and AI agent sessions, storing them in an encrypted local database. It features a background daemon that manages history lifecycle, provides high-performance in-memory search with frecency ranking, and handles synchronization with a self-hosted server. The system supports syncing of shell aliases and environment variables across devices and offers a rich interactive interface with syntax highlighting and detailed command inspection.

32 changes.

The project underwent a major architectural shift by introducing a background gRPC daemon to handle history and search, replacing direct database access. This period also saw the addition of a new dotfiles sync feature for shell aliases and environment variables, alongside a comprehensive restructuring of the server, client, and shared crates to support these new capabilities.

33 changes.

This period focused on restructuring the Atuin daemon to handle command history, search, and AI session synchronization via a new gRPC interface and in-memory indexing. Significant work was done to implement terminal output capture using PTY proxies and OSC 133 parsing, enabling users to search and view command stdout/stderr. The release also included comprehensive testing, benchmarking, and infrastructure improvements such as a standalone server binary and CI migration.

The daemon now captures AI agent sessions (from supported harnesses) into the synced record store. This adds a new gRPC service under \grpc/ai\ to list, search, retrieve, and stream session transcripts, and introduces a background capture engine that listens for harness events, enriches messages, and persists them. An import tool is also included to backfill existing local session files, and captured content is sanitized to redact secrets and strip tool execution payloads.

_crates/atuin-daemon/src/grpc/ai, crates/atuin-daemon/src/session\capture · high confidence

Atuin AI now captures and stores AI agent sessions in a local SQLite database, making them browsable and searchable via the new \atuin ai session\ command. This change introduces a new schema with tables for sessions, session events, session metadata, and usage snapshots, along with a build script to ensure migrations are correctly embedded at compile time. The \atuin ai session\ command provides subcommands to list, show, search, and tail these captured sessions, allowing users to review past AI interactions and their outcomes.

crates/atuin-ai · high confidence

Users can now search through previously captured command output using the new \atuin output search\ command. This feature allows filtering by query text and supports three output formats: plain text, pretty-printed (with theme-aware coloring and metadata like duration and exit code), and machine-readable JSON/NDJSON. The search interacts with the daemon to retrieve stored output lines, handling connection retries and respecting configured output limits.

crates/atuin/src/command/client/output · high confidence

The server now exposes a /healthz endpoint that returns a 200 OK status with a JSON body indicating 'healthy', allowing external monitoring systems to verify service availability. Additionally, the handler module has been reorganized to include user management endpoints (register, login, delete, change password) and an API index endpoint that can optionally advertise a fake version string to clients, while introducing a standardized error response wrapper for consistent HTTP status reporting.

crates/atuin-server/src/handlers · high confidence

The repository now includes standard configuration and documentation files to improve development workflow and community guidelines. This adds \.editorconfig\ for consistent editor settings, \.rustfmt.toml\ for Rust formatting rules, \.codespellrc\ for spell-checking, \.vale.ini\ for prose linting, \.gitattributes\ for line-ending consistency, \.mailmap\ for author normalization, and \.dockerignore\ for build context. It also introduces \AGENTS.md\ as a developer guide for AI assistants and workspace conventions, \CODE\_OF\_CONDUCT.md\ for community standards, and \CONTRIBUTORS\ for listing contributors.

(repo-wide) · high confidence

The \atuin dotfiles alias list\ and \atuin dotfiles var list\ commands now support sorting by name or value, reversing the output order, and filtering results by name or value patterns. For variables, users can also restrict the output to only exported variables or only shell-only variables using the \--exports-only\ and \--shell-only\ flags.

crates/atuin/src/command/client/dotfiles · high confidence

Users can now deploy the Atuin server using systemd. A new service unit file (atuin-server.service) is provided to manage the server process, running it as a dedicated 'atuin' user with strict security hardening options such as protected system paths and no new privileges. A corresponding sysusers configuration file (atuin-server.sysusers) is included to automatically create the 'atuin' system user upon installation.

systemd · high confidence

The search benchmark crate now includes a deterministic synthetic shell-history generator (corpus.rs) that produces realistic command-line data with a Zipf-like frequency distribution, allowing for reproducible and comparable benchmark results across different runs and machines.

crates/atuin-search-bench/src · high confidence

The Atuin server is now distributed as a dedicated binary crate, allowing users to run the server independently. The new binary exposes a command-line interface with a 'start' subcommand to launch the sync server (accepting optional host and port arguments) and a 'default-config' subcommand to print the example configuration, simplifying deployment and configuration management.

crates/atuin-server/src/bin · high confidence

The server crate has been reorganized to introduce a dedicated metrics endpoint (exposed on a separate listener to avoid public exposure), a \/healthz\ health-check route, and a capabilities-driven negotiation protocol that allows clients and servers to agree on features like page size. The server now advertises a configurable fake version to prevent unnecessary client update prompts, supports polymorphic database backends (SQLite, Postgres, MySQL) via a unified interface, and includes improved HTTP tracing and logging for operational visibility.

crates/atuin-server/src · high confidence

The daemon now includes a dedicated search component that maintains an in-memory fuzzy search index of command history using the Nucleo library. This component loads history from the database on startup, supports dynamic filtering (such as by shell), and applies frecency-based ranking to prioritize results. It exposes a gRPC service for search requests and runs background tasks to periodically refresh the frecency map and handle index updates, replacing previous search mechanisms with this more performant, daemon-owned approach.

crates/atuin-daemon/src/components · high confidence

The interactive history search now highlights commands with syntax coloring (using tree-sitter for bash, zsh, fish, and PowerShell) and supports configurable word-jump navigation (Emacs or Sublime Text modes) for faster cursor movement. An interactive inspector panel provides detailed statistics and context for selected history entries, while the search UI also introduces ultracompact mode and customizable columns.

crates/atuin/src/command/client/search · high confidence

The atuin-pty-proxy crate now parses OSC 133 escape sequences to distinguish between prompt, input, and output zones, enabling the capture of command output for history storage. This includes a streaming parser for OSC 133 markers, a capture tracker that stores terminal scrollback and output (with size limits to preserve start and end chunks), and a debug mode to highlight these zones. Additionally, the proxy now mirrors the child shell's current working directory to the parent process and forwards stdout via raw file descriptor writes for improved performance under load.

crates/atuin-pty-proxy · high confidence

The daemon's protobuf interface now includes new services and message types to support AI coding agent session tracking and full-text search of captured command output. The \ai/agent.proto\ and \ai/session.proto\ files define the data structures for recording AI interactions (including tool calls, reasoning, and token usage) and provide RPCs to list, search, stream, and import these sessions. Additionally, \search.proto\ adds a \SearchCommandOutput\ RPC to query the full-text index of command output, while \history.proto\ is updated with \AuthorKind\ to distinguish between human and agent command execution.

crates/atuin-daemon/proto · high confidence

The new \atuin-dotfiles\ crate adds the ability to sync shell aliases and environment variables across devices. It defines data structures for aliases and variables (distinguishing between shell and environment variables) and provides storage logic using SQLite and Paseto encryption. The implementation includes formatters to generate configuration snippets for POSIX shells, Xonsh, and PowerShell, enabling users to maintain consistent shell environments via Atuin.

crates/atuin-dotfiles/src · high confidence

Developers can now use the provided \.devcontainer\ setup to launch a consistent development environment in VS Code or compatible editors. The configuration installs a Rust-based image with essential build tools (protoc, mold linker, clang), sets up the \dev\ user with passwordless sudo, and pre-installs the Claude Code CLI. It also includes a custom devcontainer feature for Atuin (with sandbox-safe daemon configuration) and GitHub CLI, while temporarily disabling Tailscale and Atuin in the entrypoint to prevent startup hangs in automated sandbox environments.

.devcontainer · high confidence

This change adds a new \atuin-scripts\ crate that enables users to store, sync, and execute scripts. It introduces a SQLite-backed database with \scripts\ and \script\_tags\ tables, a \ScriptStore\ for managing script records (create, update, delete) via encrypted sync, and an execution engine that supports interactive script running with stdin/stdout handling and template rendering via MiniJinja. The implementation includes serialization/deserialization of script records for sync and ensures unique script names.

crates/atuin-scripts · high confidence

A new \atuin-domain\ crate has been added to centralize shared domain types across the client, daemon, and server. This includes a capability negotiation system that allows clients and servers to exchange supported features (such as packfiles and page sizes) via a token-based protocol, ensuring compatibility during sync. The crate also introduces strongly-typed models for history records, including \RecordVersion\, \RecordTag\, and \CmdOrigin\ (replacing the previous \host:user\ string parsing with explicit host and user types), along with API request/response structures for authentication and account management.

crates/atuin-domain · high confidence

The output capture module now exposes explicit data structures for handling captured terminal output, including \OutputMatch\ and \OutputLine\. These types define how search results are represented, with \OutputMatch\ containing a history ID, a relevance score, and a vector of \OutputLine\ objects that track line positions (including support for negative indices to represent discarded middle sections of large outputs) and highlighted content. This establishes the core data contract for the output capture engine and persistence layer.

_crates/atuin-daemon/src/output\capture · high confidence

The Atuin client now communicates with a new background daemon process via gRPC instead of accessing the database directly. This daemon manages command history lifecycle (start, finish, cancel, delete), maintains an in-memory search index, and handles output capture, exposing these capabilities through a new client library and a configurable socket (Unix socket on Linux/macOS, TCP on Windows).

crates/atuin-daemon/src · high confidence

The daemon now includes a new \grpc/common\ module providing shared utilities for handling gRPC requests. This adds a \TryCollectResultsCappedExt\ trait that safely drains client-streamed, chunked requests into a validated vector while enforcing a maximum item limit, returning a specific error if the cap is exceeded. It also includes protobuf conversion implementations for mapping domain record IDs to \RecordId\ and handling unsigned index ranges, along with comprehensive tests for the collection logic.

crates/atuin-daemon/src/grpc/common · high confidence

This change introduces a new background daemon service (\atuin-daemon\) that exposes Atuin's functionality via a gRPC interface. The implementation includes a build script that compiles Protocol Buffers (using \protox\) for core modules (common, history, search) and AI session tracking, along with Rust source files defining the gRPC transport layer, versioned reply traits, and error handling macros. This establishes the foundational communication channel between the client and the daemon for history management and AI session capture.

crates/atuin-daemon · high confidence

A new \atuin account\ subcommand has been added to manage user accounts, providing subcommands for login, register, logout, delete, change password, and link. The implementation introduces a \PasswordArg\ type that allows passwords to be passed directly or read securely from stdin (using \-\), with a fallback to the \ATUIN\_PASSWORD\ environment variable. This centralizes account operations and improves security by avoiding password exposure in command-line arguments.

crates/atuin/src/command/client · high confidence

The client now exposes dedicated CLI commands to change passwords, delete accounts, and link an existing CLI session to an Atuin Hub account. The \change\_password\ command supports two-factor authentication via TOTP and validates that the user is logged in before attempting the update. The \delete\ command removes the account on the server, cleans up local CLI and Hub session metadata, and also supports TOTP. The \link\ command allows users who already have a CLI session to authenticate with Atuin Hub via a browser flow and associate their CLI identity with their Hub account. These commands integrate with the existing i18n system for user-facing messages and use secrecy types for sensitive inputs.

crates/atuin/src/command/client/account · high confidence

The new \atuin-history\ crate introduces a smart sorting algorithm for search results that prioritizes commands starting with the query and favors more recent history, alongside a statistics module that calculates command usage counts while intelligently ignoring leading environment variables and handling pipe-separated commands.

crates/atuin-history/src · high confidence

A new \scripts/release.sh\ script has been added to automate the Atuin CLI release process. This tool handles dependency checks (git, cargo, gh, etc.), creates a temporary working directory, detects the current version, suggests the next version based on conventional commits, and guides the user through confirming and executing the release steps.

scripts · high confidence

The \atuin\ CLI has been restructured into a modular command system under \crates/atuin/src/command\, introducing a unified entry point that manages subcommands (such as \search\, \stats\, \history\, \config\, and \daemon\) and handles process initialization, including daemonization and runtime selection. Additionally, the application now supports OpenTelemetry tracing; when compiled with the \profiling-traced\ feature, users can enable span export to an OTLP collector by setting the \ATUIN\_OTEL\ environment variable, with the system automatically handling log file rotation and cleanup.

crates/atuin/src/command · high confidence

The daemon now exposes a dedicated gRPC service to manage command history lifecycle events. Clients can start, end, cancel, and delete history entries, as well as rebuild or compact the underlying store. A streaming endpoint allows subscribers to tail history events in real-time, receiving notifications for command state changes or stream lag. This implementation moves history management logic into the daemon, utilizing a local journal for event tracking and ensuring that history operations are handled asynchronously to prevent client disconnects from interrupting long-running tasks.

crates/atuin-daemon/src/grpc/history · high confidence

The daemon now uses a new in-memory search index (crates/atuin-daemon/src/search) that deduplicates commands and ranks results using a frecency algorithm (frequency + recency). This enables efficient fuzzy matching and dynamic filtering by directory, host, and session, while allowing users to tune the relative weights of recency and frequency via multipliers.

crates/atuin-daemon/src/search · high confidence

The atuin-common crate now provides a comprehensive SQLite abstraction layer, including a builder for connection options (WAL mode, journaling, permissions), a background WAL compactor to manage disk usage under high concurrency, and full-text search (FTS5) helpers with text highlighting. It also introduces ANSI terminal rendering utilities that convert terminal output to plain text using the vt100 parser, along with benchmarking infrastructure and configuration to ban error-handling crates like eyre and anyhow for library safety.

crates/atuin-common · high confidence

The client now includes a new set of commands under the \store\ subcommand to manage the underlying record store used for syncing. Users can pull records from the server (\store pull\), push local records to the server (\store push\), and purge undecryptable records (\store purge\). Additionally, the \store rebuild\ command allows users to rebuild the local search index for history or scripts, while \store rekey\ enables re-encrypting the local store with a new key, and \store verify\ checks that the current key can successfully decrypt the local store.

crates/atuin/src/command/client/store · high confidence

The server now exposes a new v0 API module containing handlers for retrieving the authenticated user's profile (\me\), uploading and retrieving encrypted records (\record\), and deleting the user's store (\store\). The record handler enforces a configurable maximum record size, rejects oversized uploads with a 400 error, and tracks upload/download metrics. The store handler allows users to delete their entire store data. These endpoints rely on the new \atuin-domain\ types for request/response structures and the polymorphic database interface.

crates/atuin-server/src/handlers/v0 · high confidence

The shell initialization scripts for Bash, Fish, Nushell, PowerShell, Xonsh, and Zsh are now included directly in the \crates/atuin/src/shell\ directory. This change ensures that the correct versions of these scripts are always available for users to source, replacing any previous reliance on external or dynamically generated files. The scripts include updated logic for session management, history recording, and prompt integration across all supported shells.

crates/atuin/src/shell · high confidence

Atuin now generates shell-specific configuration files for aliases and environment variables, supporting Bash, Fish, PowerShell, Xonsh, and Zsh. Each shell module provides functions to read cached configurations or generate them on the fly, ensuring that shell startup is not prevented even if Atuin fails to generate the config. PowerShell support includes specific handling for aliases with implicit arguments and secure command execution via Invoke-Expression.

crates/atuin-dotfiles/src/shell · high confidence

The dotfiles store now includes a dedicated module for managing shell environment variables, allowing users to sync their env vars across devices. This change introduces a \VarStore\ that handles the creation and deletion of variable records, and provides methods to export these variables in formats compatible with POSIX shells (bash, zsh), Fish, Xonsh, and PowerShell, ensuring proper escaping of special characters for each environment.

crates/atuin-dotfiles/src/store · high confidence

All user-facing strings in the CLI (commands, arguments, prompts, and error messages) are now defined in a Fluent resource file (en-US/atuin.ftl). This establishes the infrastructure for internationalization, allowing these messages to be translated into other languages in future updates.

crates/atuin/i18n · high confidence

The original \src/main.rs\ file, which implemented the initial command-line interface for the 'Shync' tool using Clap and a local SQLite database, has been deleted. This change removes the legacy codebase that handled basic history management (add, list) and server initialization, indicating a significant architectural shift or replacement of the application's core entry logic.

src · high confidence

The local history storage mechanism using SQLite has been removed from the application. The \SqliteDatabase\ struct and its associated \Database\ trait, which handled saving and listing history records to a local SQLite file, have been deleted along with the \History\ data structure definition. This indicates a shift away from the previous local-only, synchronous SQLite-based persistence model.

src/local · high confidence

The hook command's wire protocol has been updated to accept \tool\_response\ payloads that are simple strings (e.g., from Codex), in addition to the previous object format containing an \exitCode\. This ensures that agent hook events with string-based responses are correctly parsed and processed without errors, while maintaining support for structured response objects.

crates/atuin/src/command/client/hook · high confidence

The atuin crate has been reorganized into the crates/ directory, with documentation files (README, CHANGELOG) converted to symlinks pointing to the project root. A new build script (build.rs) was added to capture the current Git commit hash at compile time, and an internationalization configuration file (i18n.toml) was introduced to set up Fluent-based localization with English as the fallback language.

crates/atuin · high confidence

The search inspector has been reworked to support a new 'Output' view, allowing users to inspect the captured stdout/stderr of individual command runs directly within the TUI. This change introduces a background-fetching mechanism that retrieves output from the daemon (when available) and renders it with preserved ANSI styling, while also updating the keybindings and UI layout to accommodate this new pane.

crates/atuin/src/command/client/search/inspector · high confidence

User-facing strings are now localized using Fluent, with the application detecting the system locale via standard environment variables. Additionally, sync errors—specifically wrong encryption key issues—now display a prominent, colored banner with clear instructions on how to resolve the key mismatch, rather than a plain error message.

crates/atuin/src · high confidence

The continuous integration system has moved from GitHub Actions to Buildkite, introducing a new pipeline configuration in \.buildkite/pipeline.yml\ that replaces the previous GitHub workflow files. This change brings a comprehensive caching strategy for Rust builds (covering the cargo registry, target directory, and toolchain) to speed up execution, and adds support for running integration tests on an illumos (OmniOS) virtual machine. The new setup also includes specific scripts to handle test result collection, installer testing without a controlling terminal, and linting tools like shellcheck and vale.

.buildkite · high confidence

The search TUI now uses a new keybinding framework that supports conditional rules, multiple modes (Emacs, Vim Normal/Insert, Inspector, Prefix), and a wider range of actions. Users can now bind keys based on context (e.g., cursor position, input state, list position) using boolean expressions, access new actions like 'clear-to-start/end', 'delete-all', 'switch-context', and 'inspect-output', and utilize Vim-style motion keys and media keys. The system also introduces numeric shortcuts (Alt/Ctrl+1-9) for returning selections and supports multi-key sequences.

crates/atuin/src/command/client/search/keybindings · high confidence

The daemon's sync mechanism has been restructured from an event-bus model to a standalone background engine. This change introduces a dedicated sync worker that not only synchronizes history records but also integrates with the AI session database, ensuring that AI agent sessions are captured and synced alongside standard history data. The new engine manages its own lifecycle, handling exponential backoff for failed sync attempts and updating both the search index and AI session store upon successful synchronization.

crates/atuin-daemon/src/sync · high confidence

The output capture subsystem has been refactored into distinct persistence and engine components. The persistence layer now manages durable storage via a Fjall blob store and a contentless SQLite FTS5 search index, while the engine layer orchestrates background tasks for garbage collection (triggered when disk usage exceeds 95% of the configured budget) and index reconciliation. This separation ensures that capture continues to function even if the search index is unavailable, and that disk usage is automatically managed.

_crates/atuin-daemon/src/output\capture/persistence · high confidence

The search subsystem has been restructured to introduce a new \daemon.rs\ engine that communicates with the Atuin daemon for in-memory, ranked search, and a \db.rs\ engine that handles local SQLite queries. The daemon engine automatically attempts to start the daemon if it is not running and includes logic to fall back to the database search for regex patterns or when the daemon is unavailable. The database engine now explicitly supports different search modes (such as FullText and Prefix) and provides specific highlighting logic for full-text matches, replacing the previous unified fuzzy-search approach.

crates/atuin/src/command/client/search/engines · high confidence

The \atuin init\ command has been refactored to generate shell initialization scripts that support tmux popups (configuring width/height for Bash, Fish, and Zsh), optional AI integration (enabled via the \ai\ feature for Bash, Fish, and Zsh), and unique keybinding names in Nushell to prevent conflicts. The init logic also respects the \ATUIN\_NOBIND\ environment variable to disable keybindings and includes a bash-preexec loader for Bash when no other preexec backend is present.

crates/atuin/src/command/client/init · high confidence

The \atuin status\ command (specifically the sync status view) now exits with an error if the user is not logged in, rather than potentially displaying incomplete or misleading information. Additionally, all user-facing text in this command has been localized using Fluent, ensuring consistent language support across the interface.

crates/atuin/src/command/client/sync · high confidence

The server's database layer has been refactored to use a single, polymorphic \Database\ trait backed by \DynDatabase\, allowing Postgres, MySQL, and SQLite to share a common interface while handling their specific SQL dialects (ordinal vs. positional binding) via a \Dialect\ abstraction. This change introduces eager connection validation, ensuring that a misconfigured \db\_uri\ fails immediately at startup rather than later during operation, and standardizes migration execution across all supported backends.

crates/atuin-server/src/db · high confidence

The atuin-server crate now includes a dedicated \server.toml\ configuration file that allows users to specify database connection URIs for PostgreSQL, SQLite, or MySQL, along with settings for host, port, registration policies, and record size limits. A new \build.rs\ script ensures that database migrations for all three supported backends are tracked for rebuilds, and a symlinked changelog is in place to ensure distribution tools can locate the changelog file.

crates/atuin-server · high confidence

The vendor directory now includes the axoasset Rust library (v2.0.1) and the bash-preexec script. The axoasset vendoring fixes installation from crates.io by bundling the library directly, ensuring consistent builds. The bash-preexec integration automatically loads the hook if no other preexec backend is present, enabling shell command tracking.

vendor · high confidence

The file at crates/atuin/vendor/bash-preexec was previously missing or incorrect, preventing proper installation from crates.io. This change restores the correct symbolic link pointing to the actual bash-preexec source code, ensuring the dependency is correctly resolved during build and installation.

crates/atuin/vendor · high confidence

Add benchmarks and AI session capture infrastructure; Added benchmark for smart sort performance; Added benchmarks for the output capture engine; Added daemon search benchmark suite; Added end-to-end test suite for shell integration, daemon, and PTY proxy; Added integration tests for server database operations, sync, and user management; Added server test infrastructure for integration testing; Adopt proptest and rstest for daemon test suites; Benchmark added for command cell rendering optimization; New e2e test harness for interactive shell sessions; New shared test harness for the Atuin daemon.

The project has migrated to the Rust 2024 edition and restructured its dependency management by lifting common dependencies into the top-level workspace \Cargo.toml\. This change standardizes versioning across all crates—including \atuin\, \atuin-client\, \atuin-daemon\, and \atuin-ai\—ensuring consistent dependency resolution and reducing maintenance overhead. The update also includes a comprehensive refresh of the dependency tree, updating core libraries such as \tokio\, \clap\, \sqlx\, and \ratatui\ to their latest versions, which improves performance, stability, and compatibility with the new Rust edition.

(dependencies) · high confidence

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

• CAI 37 → 67 (+29.2)
• Rubric changed (rubric-2026.08.15 → rubric-2026.09.15) — scores are not directly comparable.

• Code Health 65 → 87 (+21.9)
• Architecture 69 → 99 (+29.6)
• Maturity 57 → 64 (+7.0)
• Readiness 24 → 59 (+34.9)
• Security 38 → 72 (+33.5)
• Domain Modelling 90 (new)
• Event Sourcing 100 (new)

• Dimension evaluation failed
• High IaC: KSV-0014 (k8s/atuin.yaml)
• High IaC: KSV-0014 (k8s/atuin.yaml)
• High IaC: KSV-0118 (k8s/atuin.yaml)
• High IaC: KSV-0118 (k8s/atuin.yaml)
• High IaC: KSV-0118 (k8s/atuin.yaml)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• …and 78 more

• AgentFsm::handle (cognitive 60) (crates/atuin-ai/src/fsm/mod.rs)
• AgentFsm::handle (cyclomatic 62) (crates/atuin-ai/src/fsm/mod.rs)
• AiApp::execute_tool (cognitive 27) (crates/atuin-ai/src/tui/app.rs)
• AiApp::execute_tool (cyclomatic 22) (crates/atuin-ai/src/tui/app.rs)
• AiApp::handle_fsm (cognitive 50) (crates/atuin-ai/src/tui/app.rs)
• AiApp::handle_fsm (cyclomatic 37) (crates/atuin-ai/src/tui/app.rs)
• AiApp::keymap (cognitive 16) (crates/atuin-ai/src/tui/app.rs)
• AiApp::update (cognitive 28) (crates/atuin-ai/src/tui/app.rs)
• AiApp::update (cyclomatic 35) (crates/atuin-ai/src/tui/app.rs)
• AtuinHistoryToolCall::execute (cognitive 16) (crates/atuin-ai/src/tools/mod.rs)
• CI installs an unverified third-party binary (.github/workflows/release.yml)
• Change coupling clique: store.rs, store.rs, store.rs (crates/atuin-dotfiles/src/store.rs)
• Change coupling: mod.rs ↔ mod.rs (crates/atuin-server/src/db/postgres/mod.rs)
• Change coupling: pull.rs ↔ push.rs (crates/atuin/src/command/client/store/pull.rs)
• Change coupling: search.rs ↔ db.rs (crates/atuin/src/command/client/search.rs)
• ClassTooLong: AgentFsm (crates/atuin-ai/src/fsm/mod.rs)
• ClassTooLong: AiApp (crates/atuin-ai/src/tui/app.rs)
• ClassTooLong: AiSessionDatabase (crates/atuin-client/src/ai_session/database.rs)
• ClassTooLong: Settings (crates/atuin-client/src/settings.rs)
• ClassTooLong: Sqlite (crates/atuin-client/src/database.rs)
• …and 363 more

• 237 commits — 168 feature/other, 69 fixes

• crates/atuin — 44 commits
• (root) — 38 commits
• crates/atuin-client — 34 commits
• crates/atuin-common — 32 commits
• crates/atuin-daemon — 29 commits
• crates/atuin-pty-proxy — 12 commits
• .github/workflows — 11 commits
• crates/atuin-ai — 9 commits
• crates/atuin-server — 6 commits
• docs/uv.lock — 4 commits
• crates/atuin-lab-share — 3 commits
• docs/docs — 3 commits
• .buildkite/scripts — 2 commits
• .devcontainer/Dockerfile — 2 commits
• crates/atuin-domain — 2 commits
• .atuin/skills — 1 commit
• .config/nextest.toml — 1 commit
• .devcontainer/features — 1 commit
• crates/atuin-nucleo — 1 commit
• crates/atuin-server-mysql — 1 commit

• fix: Revert AI session capture stack (#4210)
• fix: bug(output-capture): reconcile can no longer crash (#4153)
• fix: bug: avoid rare race condition in sync (#3972)
• fix: bug: deletion state race (#4180)
• fix: bug: fix transaction lock (#4152)
• fix: chore(tests): fix flaky pty-proxy test (#3874)
• fix: chore: fix Clippy warning about time::Duration (#4231)
• fix: chore: revert changes to atuin-pty-proxy from lab share PR / feat: store pty-proxy sockets in /tmp/atuin-$UID (#3988)
• fix: ci(buildkite): fix the installer hang and address #4274 review (#4275)
• fix: ci: emit proptest regression artifacts so CI failures are reproducible (#4084)
• fix: fix(ai): answer unrecognized tool calls with an error result (#3893)
• fix: fix(ai): execute commands from enter in the bash integration (#3892)
• fix: fix(ai): saturate file-tracker mtimes and rebuild on new migrations (#4250)
• fix: fix(ai): start the daemon before ai commands if autostart is enabled (#4269)
• fix: fix(bash): localize "READLINE_{LINE,POINT}" in Bash <= 3.2 (#3926)
• fix: fix(client): bound WAL growth with journal_size_limit + a periodic compactor (#3994)
• fix: fix(common): include the cause in the sqlite pool creation error (#4185)
• fix: fix(common): sleep before each backoff attempt (#4129)
• fix: fix(common): survive wide characters on a one-column screen (#3876)
• fix: fix(daemon): check for socket in /tmp even when $TMPDIR is set (#4036)
• …and 217 more

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

atuinsh/atuin 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.