akitaonrails/ai-memory

This system is a local-first, multi-user memory service designed to capture, store, and retrieve context from AI coding agent sessions. It integrates with a wide variety of CLI agents via lifecycle hooks to ingest transcripts and tool usage, while providing a read-only web interface and JSON API for browsing the resulting wiki. The platform supports complex memory management features including cross-agent handoffs, automated wiki consolidation, and granular retention policies, all secured with multi-user authentication and API credential management.

New shell and PowerShell hook scripts have been added for the Codex and OpenCode agents to integrate with the local AI memory service (defaulting to port 49374). These hooks automatically forward session events—such as tool usage, prompts, and session start/end—to the memory server. Additionally, the session-start hooks now support cross-agent handoffs, allowing context to be automatically retrieved and prepended to new sessions without human intervention.

hooks/codex, hooks/opencode · high confidence

New shell and PowerShell hook scripts are added for the Cursor and Gemini CLI agents, enabling the AI memory system to track agent activity. These hooks capture key lifecycle events—including session start and end, tool use, user prompts, and stop signals—and forward them to the local AI memory server. The session-start hooks specifically support cross-agent handoffs, allowing context to be passed between agents automatically when a new session begins.

hooks/antigravity-cli, hooks/cursor, hooks/gemini-cli · high confidence

Added shell and PowerShell hook scripts for the Devin agent to integrate with the AI memory system. These hooks capture session lifecycle events (start, end, stop), tool usage (pre- and post-tool-use), user prompts, and post-compaction summaries. The session-start hook specifically fetches and injects any pending handoff context into the session, ensuring continuity across empty sessions.

hooks/devin · high confidence

This change introduces a complete set of shell and PowerShell hooks for the Grok agent, enabling the capture of session lifecycle events (start, end, stop, compact) and tool interactions (pre/post tool-use, user prompt submission). The hooks forward these events to a local memory service, with specific logic in the subagent-start and subagent-stop hooks to support the opt-in \drop\_subagent\_captures\ feature, allowing nested subagent sessions to be selectively excluded from memory storage.

hooks/grok · high confidence

New shell and PowerShell scripts have been added to the Kiro CLI hooks directory to integrate with the AI memory system. These hooks capture agent lifecycle events—including session start, tool use (pre and post), user prompt submission, and stop—by forwarding event payloads to a local AI memory server. The session-start hook additionally handles fetching cross-agent handoffs and delivering a one-time project briefing, while other hooks operate in a fail-open, capture-only mode to ensure they do not block or alter the agent's execution context.

hooks/kiro-cli · high confidence

The project now includes a \flake.nix\ that provides a self-contained build environment for ai-memory. It pins all flake inputs (nixpkgs, flake-utils, rust-overlay) to explicit revisions to ensure deterministic builds across different machines and times. The build process bundles SQLite, libgit2, and uses rustls for TLS, avoiding system library dependencies. It also configures the build to skip the Tailwind CLI download by using a vendored static CSS file, which is necessary for sandboxed Nix builds. The flake supports building the release binary, running smoke tests, and entering a development shell with the pinned Rust toolchain.

(repo-wide) · high confidence

Added shell and PowerShell hook scripts for the Poolside Agent CLI (Pool) to capture agent lifecycle events. These hooks forward JSON payloads for session-start, user-prompt-submit, pre-tool-use, post-tool-use, and stop events to the AI memory server, enabling context tracking and session finalization for this specific agent integration.

hooks/pool · high confidence

Added shell and PowerShell hook scripts for the command-code agent to capture session boundaries and tool usage events. These hooks (session-start, pre-tool-use, post-tool-use, stop) send telemetry to the AI memory service and, in the case of session-start, support cross-agent handoffs to maintain context continuity.

hooks/command-code · high confidence

A new environment file (ai-memory.env) has been added to the packaging directory to support the ai-memory systemd service. This file serves as a template for configuring essential runtime settings, including authentication tokens, allowed hosts, LLM provider selection (e.g., Anthropic, OpenAI), API keys, reasoning effort levels, and custom operator headers.

packaging/env · high confidence

Users on Arch Linux can now install ai-memory via the Arch User Repository. Two packages are provided: \ai-memory\ builds the application from source using the local Rust toolchain, while \ai-memory-bin\ installs prebuilt binaries for x86\_64 and aarch64 architectures. The packaging includes systemd service files for both system and user-level execution, along with helper scripts to guide post-installation configuration.

packaging/aur · high confidence

This change introduces native packaging support for Arch Linux by adding systemd service files for the ai-memory MCP server. It defines both a system-level service (running as the dedicated 'ai-memory' user with strict security restrictions like PrivateTmp and ProtectSystem) and a user-level service for local deployment. Additionally, it includes configuration files to automatically create the 'ai-memory' system user and the required data directory at /var/lib/ai-memory during installation.

packaging/systemd, packaging/sysusers, packaging/tmpfiles · high confidence

Introduces a new optional companion tool for importing data into ai-memory. It supports two modes: importing an 'oh-my-claudecode' (OMC) flat markdown wiki directory and replaying generic external conversations via a JSON envelope. The tool parses OMC frontmatter (handling CRLF/BOM), enforces size limits on messages and files, and writes a durable manifest to track import status (planned, imported, or failed).

companions/ai-memory-importer · high confidence

A new launchd user agent plist has been added to the packaging directory, providing the macOS equivalent of the systemd user service. This configuration ensures the ai-memory binary runs as an interactive, persistent background service that starts at login and keeps the process alive, with output directed to user-specific log files.

packaging/launchd · high confidence

The Claude Code integration now includes hooks for session-start, session-end, tool-use, and subagent lifecycle events, enabling automatic context transfer between agents and the ability to drop nested subagent captures. The session-start hook specifically fetches and injects pending cross-agent handoffs into the session context, while new subagent-start and subagent-stop hooks allow the server to manage subagent session lifecycles for capture control. All hooks are implemented for both POSIX shell and PowerShell, default to port 49374, and ensure clean debug logs by emitting JSON acknowledgments.

hooks/claude-code · high confidence

The ai-memory store now uses a versioned SQL migration system (V01–V27) to manage its SQLite data model. The initial schema (V01) establishes core tables for workspaces, projects, pages, sessions, observations, links, and audit logs, with full-text search on pages and observations. Subsequent migrations introduce agent handoffs (V02), page decay/retention tracking (V03), vector embeddings (V04), and performance indexes (V05–V08). The schema supports multi-agent environments by enumerating supported agent kinds (V09, V11, V20, V25, V26) and enforces data integrity through workspace-project pairing triggers (V18). It also adds multi-user attribution (V14–V16), path-based search indexing (V17), and data-repair migrations for orphaned observations (V19, V27). Finally, it introduces a comprehensive auto-improvement subsystem with pending proposals, scheduler state, patch support, and rejection buffers (V21–V24).

crates/ai-memory-store/migrations · high confidence

The store layer now supports native \aim\_\ API credentials with generation, rotation, and revocation, allowing users to authenticate via API keys separate from passwords. It also adds a full audit trail for the auto-improvement loop, enabling operators to stage, approve, reject, or fail page-edit proposals with conflict detection. Additionally, retention decay is upgraded to support per-tier half-life curves (working, episodic, semantic, procedural) and access-breadth reinforcement, giving users more granular control over how long content persists based on its tier and how many distinct operators interact with it.

crates/ai-memory-store/src · high confidence

The CLI now resolves authentication for server requests using a unified bearer-token strategy: static tokens from configuration take precedence, followed by automatic OIDC device-flow token loading and refreshing from a local \auth.json\ file. This logic is implemented in a new \auth\_bearer\ module and consumed by the \http\_client\ module, which centralizes URL resolution, base-path handling, and error formatting for all thin-client subcommands. Additionally, the marker discovery logic in \marker.rs\ has been hardened to prevent capture-only markers from resetting project scope, and the process guard in \process\_guard.rs\ now safely detects sibling processes to prevent race conditions during destructive operations.

crates/ai-memory-cli/src · high confidence

Adds hooks/\_lib.sh, a POSIX-compliant shell library sourced by per-agent lifecycle hook scripts to handle configuration and payload processing without external dependencies like jq. This library provides functions to walk up the directory tree to find and parse .ai-memory.toml markers, distinguishing between capture-only markers and those that define project scope or settings, ensuring that nested capture-only markers do not reset project-level configurations. It also includes linear-time parsers for extracting JSON payload fields such as the current working directory (supporting standard cwd, Antigravity's workspacePaths, and Cursor's workspace\_roots) and session IDs, replacing previous quadratic-time string operations that caused performance issues with large payloads.

hooks · high confidence

Added a new PowerShell library (ai-memory-hook.ps1) that provides core utilities for the hooks system, including resolving the current working directory from various agent payloads, walking up the directory tree to find .ai-memory.toml configuration markers, parsing TOML keys and flags, and handling session-briefing logic. It also includes functions to determine the main git repository root for project identity, ensuring consistent behavior across linked worktrees.

hooks/lib · high confidence

Added a new \ai-memory api-key\ CLI subcommand that allows operators to create, list, rotate, and revoke native \aim\_\ API credentials. The command acts as a thin HTTP client over the server's \/admin/api-credentials\ endpoints, requiring root bearer authentication. It provides human-readable output for listing credentials (showing ID, label, status, and preview) and securely displays the generated token only once upon creation or rotation, with confirmation prompts for destructive actions like revocation.

crates/ai-memory-cli/src/commands · high confidence

Adds a new \bin/ai-memory\ bash wrapper and \bin/ai-memory.ps1\ PowerShell wrapper that invoke the \ai-memory\ binary inside a Docker container, handling volume mounts for configuration and project data, forwarding environment variables, and managing version checks and upgrades. Includes a \bin/deploy\ script for building and pushing the image to a homelab Docker host, with safeguards to prevent overwriting multi-architecture release tags with single-architecture builds.

bin · high confidence

The \ai-memory-workstream\ crate now provides read-only adapters for a broad set of native AI coding tools, enabling the platform to import session transcripts and maintain continuity across managed runs. The new \ManagedHarness\ enum and \harness.rs\ module define support for Anthropic Claude Code, OpenAI Codex CLI, OpenCode (including the 2.0 beta), Pi, Crush, Oh My Pi, Kimi Code, Command Code, Amazon Kiro CLI (both v2 and v3 engines), Grok Build CLI, and Google Antigravity CLI. The \transcript.rs\ module implements incremental, read-only extraction of session data from these tools' local stores, handling specific formats like JSONL journals and SQLite databases, while \repository.rs\ adds stable identity checks to ensure sessions are correctly linked to their source worktrees.

crates/ai-memory-workstream · high confidence

Added a new \assistant\_capture\ module that enables the optional capture of the assistant's final message from agent lifecycle events (specifically Claude Code and Codex \Stop\ events). This feature is disabled by default and requires explicit opt-in on both the client side (via \install-hooks --capture-assistant\) and the server side. The implementation enforces strict privacy by unconditionally stripping the raw assistant message from the wire, sanitizing the content, and truncating it to a 2 KB excerpt before storage. It also includes a new \log\ module for per-project, monthly rolling event logs and a \capture\_policy\ module that introduces an allowlist mode for repository capture, ensuring that only explicitly opted-in repositories are processed.

crates/ai-memory-hooks/src · high confidence

A new read-only HTTP browser and companion JSON API are now available for browsing the wiki. The web UI renders markdown with support for clickable internal wikilinks, respects the system's color scheme, and correctly resolves relative URLs when mounted under a custom base path. The JSON API exposes the same read-only data for use by custom frontends. Both surfaces are mounted on the same server port and share the existing authentication posture, providing a safe, read-only way to access wiki content from any device without requiring direct database or file-system access.

crates/ai-memory-web/src · high confidence

The web interface now includes a read-only browser for viewing wiki content, built with Tailwind CSS (v3.4.17) for a consistent, responsive design that supports dark mode. This adds a new base layout and specific templates for listing projects, browsing namespaces, viewing individual pages with metadata (tier, kind, author, timestamps), performing full-text search, and handling 404 errors. The UI also features a persistent notice on the projects page clarifying that the content is LLM-optimized memory, and a one-time dialog explaining the migration to the Open Knowledge Format (OKF v0.2) if applicable.

crates/ai-memory-web/templates · high confidence

The \ai-memory-core\ crate now defines the foundational data structures that enable multi-user and cross-agent capabilities. \ActorContext\ and \AuthLevel\ provide the identity and authorization tiers (anonymous, root, multi-user) required to attribute writes and scope admin operations. \ActiveProjectMode\ (defaulting to \PerActor\) and \MidSessionRouting\ manage how the active project is resolved and isolated across concurrent sessions and operators. New types for \Handoff\ (with \HandoffState\ and \HandoffAcceptance\) formalize the cross-agent handoff lifecycle, while \AgentMessage\ and \MessageState\ define the cross-project inbox/outbox model. Additionally, \IngestMetrics\ provides process-lifetime counters for hook ingestion health, and \Observation\/\NewObservation\ types structure the raw lifecycle events that feed the memory system.

crates/ai-memory-core/src · high confidence

Added shell and PowerShell hook scripts for the Kimi Code agent to integrate with the AI memory system. These hooks forward lifecycle events (session start/end, tool use, stop, subagent start/stop) to the memory server and implement cross-agent handoff delivery. Specifically, the user-prompt-submit hook fetches pending handoffs and delivers a one-time project briefing on the first prompt of a session, ensuring context continuity between agents.

hooks/kimi-code · high confidence

The \ai-memory\ MCP server now exposes tools over both stdio and HTTP transports, enabling integration with a wider range of coding agents. The server includes a new admin HTTP API for state-touching operations (backup, bootstrap, auto-improve, purge, move-project, etc.) and implements multi-user authentication with Bearer tokens, human password sessions, and CSRF protection. Actor identity is now resolved via middleware-injected context rather than raw headers, and the server supports trusted proxy identity assertion for SSO scenarios.

crates/ai-memory-mcp/src · high confidence

Added several new shell scripts to the \scripts/\ directory to improve release safety and native Linux installation validation. \check-changelog-frozen.sh\ prevents changes from being accidentally merged into already-released CHANGELOG sections, while \check-changelog-sections.sh\ ensures version sections do not contain duplicate subheadings. \check-native-packaging.sh\ validates Arch Linux packaging assets (systemd units, sysusers, tmpfiles) in an isolated temporary root without mutating the host. \install-git-hooks.sh\ and \install-hooks.sh\ provide robust mechanisms for installing pre-push test hooks and agent lifecycle hooks respectively, with improved handling of shell state isolation and checksum verification. Finally, \managed-workstream-acceptance.sh\ and \test-native-arch-systemd-distrobox.sh\ introduce manual acceptance tests for cross-harness workstream logic and native systemd integration in disposable Arch containers.

scripts · high confidence

The docker directory now includes a complete set of deployment files: a multi-stage Dockerfile (pinning the builder to rust:1.95-slim-bookworm), a local development compose file, a production compose example, and templates for TLS termination via Caddy or Cloudflare Tunnel. The container image now runs as a non-root user, exposes port 49374 by default, and enables the web UI in the CMD. Security is improved by defaulting \AI\_MEMORY\_ALLOWED\_HOSTS\ to include \host.docker.internal\ (fixing macOS wrapper connectivity) and \AI\_MEMORY\_IN\_CONTAINER=1\ (suppressing unauthenticated-bind warnings when binding to 0.0.0.0). A new \.env.production.example\ documents all configuration options, including the new \EMBEDDING\_API\_KEY\ for separate embedding credentials and bearer-token auth for LAN deployments.

docker · high confidence

The \ai-memory-llm\ crate now includes dedicated providers for Anthropic (including OAuth subscription support), GitHub Copilot, and the Codex CLI, alongside the existing OpenAI, Gemini, and OpenAI-compatible clients. This change introduces a centralized authentication module (\auth.rs\, \auth\_file.rs\) that manages credential sources (API keys, OAuth token files, and CLI-owned auth files) and persists tokens securely using atomic file writes. The factory (\factory.rs\) exposes these new options via \ProviderChoice\ and \EmbedderChoice\ enums, enabling users to select and configure these providers through the standard configuration interface.

crates/ai-memory-llm/src · high confidence

The \ai-memory-consolidate\ crate introduces a new auto-improvement capability that automatically reviews completed sessions to generate structured proposals for wiki edits. This system includes a scheduler that periodically claims and reviews sessions, an LLM-driven reviewer that validates proposals against strict confidence and token budgets, and a staging mechanism that writes proposals as sidecar markdown files. The feature supports an optional external evaluation gate to verify proposal quality, a telemetry report to track proposal outcomes, and a configuration-driven approval workflow that can either auto-approve or require manual review before applying changes to the wiki.

crates/ai-memory-consolidate/src · high confidence

A new \evals/\ workspace member introduces the \ai-memory-eval\ binary, providing two evaluation harnesses that are built alongside the project but not shipped in the Docker image or run by CI. The \ab\ subcommand runs the exact production consolidation prompt against two LLM providers in parallel, saving side-by-side outputs for human quality review. The \retrieval\ subcommand implements the LongMemEval benchmark by replaying synthetic session data through a real \ai-memory serve\ subprocess and scoring retrieval accuracy (hit@k/recall@k), latency, and context tokens. This release also adds an opt-in R2 QA-accuracy mode (R2b) that uses a live LLM-as-judge to grade end-to-end answer quality against gold answers, and includes five synthetic fixtures to test edge cases like multi-topic separation and low-signal sessions.

evals · high confidence

Users on macOS can now install a dedicated menu bar app that bundles the ai-memory runtime, manages the background LaunchAgent, and provides quick access to the Web UI, status, configuration, and logs. The app also supports importing external memory corpora—such as OMC wiki directories or generic external conversation JSON files—into the running server via the new optional ai-memory-importer companion.

companions · high confidence

This change introduces a new read-only web interface and a corresponding JSON API (\/api/v1\) for browsing the AI memory system. The web UI provides a project-list homepage, a project view that separates human-authored knowledge from system-generated machinery in the sidebar, and a page viewer that renders markdown with clickable wikilinks and proper favicon support. The JSON API exposes endpoints for workspaces, projects, pages, search, recent activity, briefings, handoffs, sessions, and cross-project dependency graphs, with caching headers (Cache-Control/ETag) applied to optimize performance for third-party frontends.

crates/ai-memory-web/src/routes · high confidence

The \ai-memory-wiki\ crate is established as the new wiki persistence layer, introducing an admission webhook chain that allows external HTTP services to validate or mutate pages before they are saved. File operations are now handled via atomic writes with transient error retries to ensure data integrity, and the wiki tree is versioned using Git with automatic commits. Additionally, a migration framework is included to handle in-place upgrades to OKF v0.2 conformance, featuring a pre-migration backup gate to protect existing data.

crates/ai-memory-wiki · high confidence

The ai-memory-web crate now includes a build script and configuration to manage its own Tailwind CSS styling. By default, the build uses a pre-compiled, vendored stylesheet, ensuring that a standard build requires no network access or external tools. For developers needing to regenerate the styles, a new environment variable (TAILWIND\_BUILD=1) triggers a secure, checksum-verified download of the Tailwind CLI (v3.4.17) to compile styles from the source templates.

crates/ai-memory-web · high confidence

Added Windows PowerShell integration tests for marker lookup and UTF-8 hook transport; Added end-to-end handoff and recall smoke test; Added integration tests for MCP and admin endpoints; Added integration tests for memory consolidation and aging features; Added integration tests for memory-store safety and retention logic; Added integration tests for the web UI routes; Added multi-operator acceptance test harness; Added smoke tests for hooks/\_lib.sh and hook scripts; Added test support for simulating Codex CLI behavior; Added upgrade wrapper tests for container ownership and multi-arch digest handling; Expanded end-to-end test coverage for ai-memory CLI; Integration tests for LLM provider capabilities and reliability.

The project has been upgraded to version 2.4.2, introducing several new crates: \ai-memory-web\ (a read-only HTTP wiki browser), \ai-memory-workstream\ (native harness adapters), and \ai-memory-test-support\ (shared test helpers). The workspace now includes \evals\ for live A/B testing. Key dependency updates include \rmcp\ to 2.2.0 for MCP transport security, \rustls\ to 0.23.45 to address RUSTSEC-2026-0285, and \h2\ to 0.4.16 for RUSTSEC-2026-0258. The \reqwest\ client is now configured to use native platform TLS roots instead of bundled webpki roots to support private CAs. Additional dependencies like \clap\_complete\, \crossterm\, \toml\edit\, \jsonc-parser\, \argon2\, \rusqlite\, \refinery\, \notify\, \git2\, and \candle-\\ have been added to support new features such as shell completions, interactive pickers, config file preservation, password hashing, SQLite migrations, file watching, wiki versioning, and local embeddings.

(dependencies) · high confidence

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

• CAI 76 → 74 (-2.1)
• Rubric changed (rubric-2026.09.9 → rubric-2026.09.18) — scores are not directly comparable.

• Code Health 85 → 85 (-0.1)
• Architecture 99 → 95 (-3.8)
• Maturity 83 → 84 (+0.6)
• Readiness 94 → 73 (-20.5)
• Security 75 → 76 (+0.7)
• Accessibility 69 → 69 (+0.0)
• Performance 100 (new)

• Change-coupling hub: cli.rs → mod.rs, workstream.rs, harness.rs (crates/ai-memory-cli/src/cli.rs)
• Documentation: no installation or build instructions (README.md)
• Documentation: no usage examples (README.md)
• Documentation: written for insiders (docs/wiki-migrations.md)
• Duplicated block (11 lines × 2) (crates/ai-memory-workstream/src/transcript.rs)
• Duplicated block (12 lines × 2) (crates/ai-memory-store/src/ops.rs)
• Duplicated block (13 lines × 2) (crates/ai-memory-cli/src/commands/install_hooks.rs)
• Duplicated block (13 lines × 2) (crates/ai-memory-wiki/src/wiki.rs)
• Duplicated block (18 lines × 2) (crates/ai-memory-store/src/reader.rs)
• Duplicated block (20 lines × 2) (crates/ai-memory-wiki/src/wiki.rs)
• Duplicated block (6 lines × 2) (crates/ai-memory-store/src/ops.rs)
• Duplicated block (7 lines × 2) (crates/ai-memory-llm/src/embedding.rs)
• Duplicated block (7–10 lines × 2) (crates/ai-memory-cli/src/config.rs)
• Duplicated block (7–8 lines × 2) (crates/ai-memory-mcp/src/admin.rs)
• Duplicated block (8 lines × 2) (crates/ai-memory-hooks/src/router.rs)
• Duplicated block (8 lines × 2) (crates/ai-memory-llm/src/copilot.rs)
• FunctionTooLong: ai_memory_cli::commands::run::run_from (crates/ai-memory-cli/src/commands/run.rs)
• FunctionTooLong: ai_memory_consolidate::sweep::run_sweep_with_options (crates/ai-memory-consolidate/src/sweep.rs)
• High: security finding (details withheld)
• Hotspot: companions/ai-memory-importer/src/main.rs (companions/ai-memory-importer/src/main.rs)
• …and 23 more

• AiMemoryServer::memory_read_page (cognitive 20) (crates/ai-memory-mcp/src/server.rs)
• Ambiguous naming for similar discovery operations. 'discover_repo_root' and 'discover_main_repo_root' suggest a hierarchy or fallback mechanism that is not obvious from the signatures. 'collect_sources' is a higher-level operation that likely uses these, but the separation is unclear.
• CapturePolicy::inspect (cognitive 17) (crates/ai-memory-hooks/src/capture_policy.rs)
• CapturePolicy::match_command (cognitive 28) (crates/ai-memory-hooks/src/capture_policy.rs)
• Change coupling: config.rs ↔ embedding.rs (crates/ai-memory-cli/src/config.rs)
• Change-coupling hub: cli.rs → mod.rs, workstream.rs, error.rs, harness.rs (crates/ai-memory-cli/src/cli.rs)
• ClassTooLong: Consolidator (crates/ai-memory-consolidate/src/consolidator.rs)
• Coverage not measured — Swift suite
• Duplicate intent with ambiguous distinction. Similar to the sweep functions, having a base 'run_curator_report' and a 'with_breadth' variant suggests inconsistent parameter handling. It is unclear if 'breadth' is a core parameter or an optional override.
• Duplicate intent with ambiguous distinction. Two methods exist with nearly identical signatures and names, differing only by the suffix '_multi'. It is unclear if this implies a difference in concurrency, batching, or internal implementation detail exposed unnecessarily.
• Duplicated block (10–12 lines × 2) (crates/ai-memory-cli/src/config.rs)
• Duplicated block (11 lines × 2) (crates/ai-memory-cli/src/commands/install_hooks.rs)
• Duplicated block (11 lines × 2) (crates/ai-memory-llm/src/codex.rs)
• Duplicated block (11 lines × 2) (crates/ai-memory-llm/src/copilot.rs)
• Duplicated block (11 lines × 2) (crates/ai-memory-workstream/src/transcript.rs)
• Duplicated block (12 lines × 2) (crates/ai-memory-mcp/src/server.rs)
• Duplicated block (13 lines × 2) (crates/ai-memory-store/src/ops.rs)
• Duplicated block (13 lines × 2) (crates/ai-memory-web/src/markdown.rs)
• Duplicated block (13 lines × 2) (crates/ai-memory-wiki/src/wiki.rs)
• Duplicated block (13–14 lines × 2) (crates/ai-memory-store/src/ops.rs)
• …and 82 more

• 300 commits — 174 feature/other, 126 fixes

• (repo) — 110 commits
• (root) — 87 commits
• crates/ai-memory-cli — 16 commits
• crates/ai-memory-consolidate — 12 commits
• crates/ai-memory-hooks — 11 commits
• crates/ai-memory-store — 9 commits
• docs/llm-providers.md — 7 commits
• .github/workflows — 6 commits
• crates/ai-memory-mcp — 6 commits
• crates/ai-memory-wiki — 5 commits
• crates/ai-memory-web — 4 commits
• docs/examples — 3 commits
• companions/ai-memory-macos — 2 commits
• crates/ai-memory-llm — 2 commits
• docs/benchmarks — 2 commits
• docs/design-memory-aging.md — 2 commits
• docs/design-windows-ci.md — 2 commits
• docs/security-boundaries.md — 2 commits
• tests/hooks — 2 commits
• companions/ai-memory-importer — 1 commit

• fix: Merge #871 and #872 Windows fixes into main
• fix: Merge PR #979: export-okf interoperability (fixes #960)
• fix: Merge PR #982: sanitize observation titles before truncating (fixes #980)
• fix: Merge branch 'main' into fix/directory-link-targets
• fix: Merge fix/885-886-884-consolidation into main
• fix: Merge fix/890-consolidate-job-reconcile into main
• fix: Merge fix/895-894-synth-log into main
• fix: Merge main into #835 (resolve CHANGELOG after the bug batch landed)
• fix: Merge main into release/2.4: bug batch + windows flake fix + auto-improve claim fix (V66)
• fix: Merge main into release/2.4: rmcp 2.x security bump + Windows/sanitize/wiki fixes batch
• fix: Merge pull request #774 from rafaelkenedy/fix/757-scope-observability
• fix: Merge pull request #777 from rafaelkenedy/fix/762-fallback-credential-cli
• fix: Merge pull request #785 from samirhvbr/fix/backfill-dry-run-state
• fix: Merge pull request #786 from samirhvbr/fix/backfill-report-failures
• fix: Merge pull request #790 from akitaonrails/fix/745-serve-lock-test-robustness
• fix: Merge pull request #793 from wslcb: docs: fix broken relative links across docs
• fix: Merge pull request #796 from everton-dgn: fix(run): cancel native session selection on interrupt
• fix: Merge pull request #799 from gb: fix(wiki): refuse page paths that collide on a case-folding filesystem
• fix: Merge pull request #800 from gb: fix(sanitize): redact JSON secrets and Basic auth, strip control sequences
• fix: Merge pull request #803 from kevin9327: fix(wrapper): forward provider env vars from the PowerShell Docker helper
• …and 280 more

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

akitaonrails/ai-memory 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.