zeroclaw-labs/zeroclaw

ZeroClaw is a Rust-based, self-hosted agent runtime that orchestrates AI interactions across diverse channels, including messaging platforms, hardware devices, and local terminals. It provides a secure, modular architecture featuring agent-to-agent communication, fine-grained authorization, and deterministic evaluation, while supporting physical hardware integration via GPIO and serial protocols. The system offers a comprehensive operator interface through a web dashboard and a terminal client, enabling users to manage multi-agent workspaces, configure skills, and monitor costs and health in real-time.

A new example application (\esp32\_sim\) is available that simulates an ESP32 device for development and testing without physical hardware. It implements the same JSON-over-serial protocol as the real firmware, allowing the host ZeroClaw daemon to control virtual GPIO pins. The example includes a built-in web frontend that visualizes a 'smart room' with interactive devices (lights, fan, heater) and logs events, providing a complete local environment for testing hardware interactions.

crates/zeroclaw-hardware/examples · high confidence

Users on FreeBSD can now install and manage ZeroClaw as a system service using provided rc.d scripts (basic and hardened variants) and a helper script to provision a thick jail. The hardened variant ensures reliable unattended and remote operation by detaching standard file descriptors, preventing duplicate supervisor instances, and robustly handling process termination. A sample jail configuration and an end-to-end setup script are also included to automate jail creation and service installation.

dist/freebsd · high confidence

The apps/tauri/icons directory now contains a placeholder SVG icon (a red square with a white 'Z') and a .gitkeep file, establishing the initial asset structure for the Tauri desktop application.

apps/tauri/icons · high confidence

The macOS desktop application now includes a system tray icon that reflects the agent's connection and status (Idle, Working, Error, or Disconnected) with corresponding icons and tooltips. Users can interact with the app via the tray menu, which provides options to Show Dashboard, open Agent Chat, view the current status, or Quit ZeroClaw. Left-clicking the tray icon also brings the main window to focus.

apps/tauri/src/tray · high confidence

New Tauri commands \take\_screenshot\ and \run\_applescript\ are now available on macOS, allowing the application to capture the screen (returning a base64-encoded PNG) and execute arbitrary AppleScript code. These capabilities are gated by macOS system permissions (Screen Recording and Automation TCC prompts) and are restricted to macOS; they return an error on other platforms. The implementation includes automatic cleanup of temporary screenshot files and is designed with security boundaries in mind, noting that gateway-served content cannot invoke these commands.

apps/tauri/src/capabilities · high confidence

New shell scripts have been added to the scripts/browser directory to facilitate headless browser automation. start-vnc.sh initializes a virtual display using Xvfb, runs a fluxbox window manager, and exposes the session via x11vnc and noVNC for remote viewing. start-browser.sh launches Google Chrome on the specified virtual display, while stop-vnc.sh provides a mechanism to terminate the virtual display and VNC services.

scripts/browser · high confidence

The runtime now includes a \TrustTracker\ module that monitors trust scores per domain, allowing the system to adjust operational autonomy based on reliability. The implementation provides types for trust scores, correction events, and regression alerts, along with logic to record corrections (which reduce scores), record successes (which boost scores), and apply time-based decay. If a domain's score drops below a configured regression threshold, the tracker can reduce the effective autonomy level (e.g., from 'full' to 'supervised'), ensuring that less reliable domains operate under stricter constraints. This module also includes comprehensive tests for configuration defaults, serialization, score updates, and regression detection.

crates/zeroclaw-runtime/src/trust · high confidence

The agent runtime module now includes the core implementation files for the agent loop, including agent.rs, approval\_bridge.rs, classifier.rs, context\_analyzer.rs, cost.rs, dispatcher.rs, eval.rs, and history.rs. These files establish the foundational components for agent turn processing, tool dispatching, cost tracking, and history management.

crates/zeroclaw-runtime/src/agent · high confidence

The memory system now enforces strict agent-scoped isolation: each agent writes only to its own namespace and can only recall entries from itself and explicitly granted sibling agents, with optional per-category allowlists. This is implemented via the \AgentScopedMemory\ wrapper for SQL-backed stores and \AgentScopedMarkdownMemory\ for file-based stores, which merge and attribute peer entries during recall. Additionally, a new \AuditedMemory\ decorator logs all memory operations (store, recall, forget, etc.) to a hardened SQLite audit database, providing an immutable trail for compliance and observability.

crates/zeroclaw-memory · high confidence

The documentation build process is now fully automated via the \xtask mdbook\ tooling, which generates reference content directly from the codebase to prevent drift. New modules produce feature-matrix tables from channel and provider registries, hardware references from the board registry, and keybinding tables from the default keymap. The build pipeline also introduces a custom \llms\ backend that generates \llms.txt\ and \llms-full.txt\ files for AI agent ingestion, and includes a rigorous check phase that validates translation files for format errors, protected literal integrity, and local path leaks.

xtask/src/cmd/mdbook · high confidence

The service module now provides a unified entry point for managing the application's lifecycle. Users can install, start, stop, restart, check the status, and view logs of the service through a consolidated command handler. Internal daemons for launchd, desktop, and OpenRC logging are explicitly separated to ensure they dispatch before configuration loading, preventing errors during startup.

src/service · high confidence

The Discord channel now supports rich interactive elements, including tool-approval buttons (Allow once, Allow session, Always allow, Deny), SOP-gate prompts with modal input, slash-command autocomplete, and rich embeds. Outbound messages are intelligently chunked to respect Discord's 2000-character limit while preserving paragraph and code-fence boundaries, and embeds are automatically trimmed to fit Discord's structural constraints. All interactive components use a secure, versioned custom\_id encoding to prevent misrouting and ensure stateless resolution of approvals and gates.

crates/zeroclaw-channels/src/discord · high confidence

The runtime now persists delegated and subagent task lifecycle state in a local SQLite database (\control\_plane.db\) instead of relying solely on in-memory or flat-file storage. This ensures that tasks survive daemon restarts: a background reaper automatically reclaims orphaned or hung tasks left behind by a crashed or restarted process, and the system distinguishes between live and recycled process owners to prevent split-brain conflicts. Additionally, goal-mode tasks now support structured pause states—including reasons like operator pause, budget exhaustion, or external dependencies—and machine-readable blockers, allowing the control plane to track and resume complex, multi-step objectives with precise policy routing.

_crates/zeroclaw-runtime/src/control\plane · high confidence

The \crates/zeroclaw-tools\ crate has been extracted to house the complete tool registry, including implementations for browser automation, file operations, web search, MCP integration, and session management. This change introduces a dedicated localization layer (\locales/en/tools.ftl\) for all tool descriptions and error messages, ensuring consistent user-facing text. The crate also centralizes attribution logic for every tool, enabling precise tracking of tool activity by kind (e.g., Plugin, Search, Shell) and provenance (Native vs. Extension).

crates/zeroclaw-tools · high confidence

The application now supports hardware-related CLI commands (discover, introspect, info) when the hardware feature is enabled. These commands are restricted to Linux, macOS, and Windows platforms; attempting to use them on unsupported operating systems or without the hardware feature enabled will result in a clear error message guiding the user on how to build with the feature or noting platform limitations.

src/hardware · high confidence

Added the initial firmware scaffold for the ESP32 device, introducing a JSON-over-serial peripheral that communicates via UART0 at 115200 baud. This firmware supports basic GPIO control (writing to pins 2 and 13) and capability reporting, while also including a UI application scaffold for the ESP32.

firmware/esp32 · high confidence

The runtime now includes the initial English and Spanish translation catalogs for the command-line interface and tool descriptions, enabling localized help text, status messages, and error strings for users of these languages.

crates/zeroclaw-runtime/locales · high confidence

The new \Configurable\ derive macro in \crates/zeroclaw-macros\ allows config structs to automatically generate methods for secret management (encryption/decryption), property enumeration, and value retrieval/set operations. By using attributes like \\#\[secret\]\, \\#\[nested\]\, and \\#\[prefix\]\, developers can define config sections that support per-field editing, secret redaction, and CLI/property access without writing boilerplate code.

crates/zeroclaw-macros · high confidence

The platform module now supports a Docker runtime environment, allowing users to configure containerized execution with isolated workspace mounts, resource limits, and network settings. Additionally, the native runtime automatically detects the platform's default shell (e.g., PowerShell on Windows, zsh/bash on macOS/Linux) when no explicit shell is configured, and validates shell paths and permissions at startup to ensure reliable execution.

crates/zeroclaw-config/src/platform · high confidence

NixOS users can now deploy ZeroClaw via a new \services.zeroclaw.instances\ multi-instance module that manages systemd units, per-instance users, and state directories. The module supports a secrets pattern where \environmentFile\ variables are expanded into the rendered TOML configuration at startup, ensuring secrets do not persist in the Nix store. It also bundles the web dashboard via \webUiPackage\, which automatically configures the gateway's static file directory unless explicitly overridden. Comprehensive evaluation and integration tests verify instance isolation, secret substitution, and dashboard integration.

nix · high confidence

The web dashboard now features a redesigned Operator Console that consolidates agent management, configuration, and interaction into a unified interface. Users can now manage multiple agents via the Agents List and toggle their enabled status, while the new Config page provides a schema-driven editor for browsing and modifying system settings. The Agent Chat workspace supports multi-agent conversations with persistent history, draft preservation, and slash commands, and includes a Workspace Explorer for browsing agent file systems. Additionally, the new AcpConsole page offers a dedicated interface for managing ACP sessions and permissions, and the Canvas page has been updated with stricter iframe sandboxing to prevent XSS vulnerabilities.

web/src/pages · high confidence

The \verifiable\_intent\ module in \zeroclaw-runtime\ now provides a Rust implementation of the Verifiable Intent specification, introducing L2 and L3 credential issuance and verification. This change enforces strict JSON parsing to reject duplicate object members, ensuring consistent signature verification across all entry points. It also hardens boundary checks by requiring \cnf.jwk.kid\ identifiers in Autonomous mode mandates and failing closed when constraint subjects are absent from fulfillments. The module exposes a structured error taxonomy (\ViErrorKind\) to allow policy engines to distinguish between credential structure errors, signature failures, and constraint violations.

_crates/zeroclaw-runtime/src/verifiable\intent · high confidence

Adds the Skill Creator skill, providing a structured workflow for creating, modifying, and optimizing skills. This includes an iterative evaluation loop with test case generation and a blind comparison system featuring a Comparator agent (to judge output quality without bias) and an Analyzer agent (to diagnose why one skill outperformed another and suggest improvements). The package also includes an eval-viewer tool that generates a self-contained HTML review page for inspecting run outputs, grading results, and managing eval sets.

.claude/skills/skill-creator · high confidence

The ZeroClaw Desktop application is now available as a Tauri-based native client. It automatically locates and launches the ZeroClaw daemon if one is not already running, and handles automatic pairing with the gateway to secure a valid authentication token before opening the dashboard. The app includes a background health poller that updates the system tray icon and tooltip based on gateway connectivity and agent status. On macOS, it provides native permission checks and request flows for Accessibility, Screen Recording, Camera, Microphone, Input Monitoring, and Full Disk Access.

apps/tauri/src · high confidence

The desktop application is now a thin Tauri shell that launches a splash screen, polls the local ZeroClaw gateway for health, and opens the web dashboard once the daemon is ready. First-time users are redirected to a web-based Quickstart, while returning users see the dashboard directly. The app bundles the ZeroClaw kernel as a sidecar binary, allowing it to run on machines without a pre-installed kernel. macOS builds now include standard privacy usage descriptions (camera, microphone, speech recognition, automation, screen recording, and input monitoring) to ensure smooth permission prompts.

apps/tauri · high confidence

This change introduces the ZeroCode terminal user interface, a new TUI built on ratatui and crossterm that provides a multi-pane experience including a Code/Chat pane (acp.rs), an agent sidebar for session management (agent\_sidebar.rs), and a central application loop (app.rs). The interface supports file attachments (attachment.rs), transcript text selection (chat.rs), and integrates with a new JSON-RPC client (client.rs) for daemon communication. It also includes client-side cryptographic helpers (client\_crypto.rs) for secure relay enrollment and platform-specific clipboard handling (clipboard.rs) for image and text pasting, along with terminal color-depth detection (color\_depth.rs) to ensure correct rendering across different terminal capabilities.

apps/zerocode/src · high confidence

The new \zeroclaw-eval\ crate provides a Phase 0 evaluation harness that runs the real agent loop against scripted LLM response traces (\LlmTrace\ fixtures) to verify agent machinery behavior deterministically. It includes a CLI (\zeroclaw eval run\) to execute suites of JSON fixtures, a \TraceLlmProvider\ to replay fixed model outputs, and a \RecordingObserver\ to capture tool dispatch boundaries (arguments and results) for grading. The harness supports declarative expectations—such as \response\_contains\, \tools\_used\, and \tool\_arguments\_contain\—and produces pass/fail reports suitable for CI gating. It ships with a default \echo\ tool for testing and excludes the regression suite from the published crate to keep the library lightweight while ensuring the agent's tool parsing, dispatch, and multi-turn looping remain correct against known inputs.

crates/zeroclaw-eval · high confidence

The cron subsystem now includes a durable outbox for plugin-host services, providing instance-scoped, at-least-once delivery with idempotency keys and lease-based locking to prevent duplicate launches. Additionally, the cron delivery schema has been expanded to support WhatsApp, DingTalk, WeChat, Signal, and Email channels alongside the existing integrations, and shell command execution is now validated against the agent's security policy before scheduling.

crates/zeroclaw-runtime/src/cron · high confidence

The gateway now ships with an embedded web dashboard built on React, Vite, and Tailwind CSS, replacing the previous terminal-only interface. This new UI provides a visual Operator Console for managing gateway configuration, multi-agent chat, and tool calls, featuring a dark theme with CSS variables, locale support (including Chinese and Turkish), and a pairing dialog that displays codes directly in the browser. It includes robust error handling with an error boundary to prevent black-screen crashes and automatic recovery from Vite chunk-load errors, while respecting reverse-proxy deployment paths via a configurable base path.

web/src · high confidence

The new \zeroclaw-hardware\ crate provides the foundation for hardware interaction, including USB device discovery, a device registry for managing connected boards (Pico, Arduino, ESP32, Nucleo), and built-in tools for GPIO read/write, code execution, and firmware flashing. It also introduces a plugin system that scans \\~/.zeroclaw/tools/\ for \tool.toml\ manifests to load external tools, and adds a datasheet manager that securely downloads PDFs from approved vendor hosts.

crates/zeroclaw-hardware/src · high confidence

The \crates/zeroclaw-runtime/src/rag\ module now provides a RAG (Retrieval-Augmented Generation) pipeline specifically for hardware datasheets. It loads \.md\ and \.txt\ datasheet files, chunks their content, and extracts pin aliases (e.g., mapping "red\_led" to pin 13) from structured sections within the documents. This allows the system to inject specific pin-context into queries, enabling more accurate retrieval for hardware-specific questions.

crates/zeroclaw-runtime/src/rag · high confidence

The \zeroclaw-plugins\ crate now provides a read-only package catalog that merges installed plugin metadata with registry availability, allowing users to see version differences between local and remote packages. It also establishes the core WASM component-model execution bridge, introducing host-mediated inbound message queues, per-call execution limits (fuel, memory, timeouts), and a structured egress policy system that governs outbound HTTP, WebSocket, and raw TCP/TLS traffic through explicit grants and TLS profiles.

crates/zeroclaw-plugins/src · high confidence

The \zeroclaw-commands\ crate now provides a centralized definition of built-in slash commands (such as help, clear, new, stop, model, config, thinking, and goal). This catalogue standardizes command metadata, including stable identifiers, canonical names, aliases, usage strings, localized description keys, and the specific surfaces (CLI, Web, TUI, Channel) where each command is available, enabling consistent command discovery and handling across different client interfaces.

crates/zeroclaw-commands · high confidence

The runtime's \doctor\ module now provides a structured diagnostic engine that validates configuration semantics, checks workspace and daemon state, verifies CLI tools, and probes model provider catalogs. It introduces a \DiagResult\ type with severity levels (Ok, Warn, Error) for programmatic consumption by web dashboards or APIs, and includes logic to collapse redundant model probe results and handle provider credential wiring issues.

crates/zeroclaw-runtime/src/doctor · high confidence

The quickstart module now implements a structured apply path that tracks the invocation surface (Web, TUI, CLI, or Test) via a \RunCtx\ and \Surface\ enum, attaching correlation IDs to all events for better observability. It introduces a \QuickstartStep\ enum to define the sequential stages of configuration (Model Provider, Risk Profile, Runtime Profile, Memory, Channels, Peer Groups, Agent) and provides a \validate\_only\ function to check submissions against the current config without committing changes, returning structured \QuickstartError\ objects that support localization for CLI users.

crates/zeroclaw-runtime/src/quickstart · high confidence

The runtime now tracks the provenance of tool calls through a new \attribution.rs\ module that implements the \Attributable\ trait for all built-in tools (e.g., \CronAddTool\, \ShellTool\, \SkillHttpTool\), categorizing them by kind (Plugin, Shell, SopAdvance) and provenance (Extension). Additionally, a new \coding\_cli\_executor.rs\ module provides a sandboxed execution path for coding CLI tools, handling environment isolation, timeout enforcement, and shell escaping to ensure safe execution within the runtime's security boundaries.

crates/zeroclaw-runtime/src/tools · high confidence

The \crates/zeroclaw-providers\ crate has been extracted to centralize model provider logic and authentication. This location now provides the \AuthService\ for managing OAuth and token-based auth profiles (persisted in \auth-profiles.json\) and implements the \AnthropicModelProvider\ with support for native tool calls, prompt caching, and extended thinking. It also includes dedicated OAuth2 flows for OpenAI Codex, Google Gemini, xAI, and email providers, along with shared utilities for PKCE, token refresh retries, and credential storage.

crates/zeroclaw-providers · high confidence

This change introduces the new \zeroclaw-tool-call-parser\ crate, which centralizes the logic for parsing tool calls from LLM responses. It provides utilities to extract structured \ParsedToolCall\ objects from various JSON formats (including standard \tool\_calls\ arrays, function call objects, and tagged wrappers like \\<tools\>\ or \\<tool\_calls\>\). The crate also includes a helper to strip provider-specific terminal markers (such as \\<eom\>\ and \\<\|eom\|\>\) from response text to ensure clean user-visible output, and normalizes tool name aliases for compatibility across different model providers.

crates/zeroclaw-tool-call-parser · high confidence

Adds the zerorelay application, a standalone blind forwarder that terminates outer TLS and WebSocket sessions to route inner mTLS traffic between clients and daemons without decrypting it. The relay supports open or allowlist admission keyed on daemon public key fingerprints, self-provisions its own TLS certificates, and includes a Dockerfile and Docker Compose configuration for easy deployment. An opt-in browser enrollment frontdoor (disabled by default) allows browsers to pair with a daemon by having the relay perform the enrollment exchange on their behalf; this makes the relay a trusted code origin and enrollment principal for that specific flow, though the relay remains blind to the actual data traffic.

apps/zerorelay · high confidence

The runtime now exposes a JSON-RPC 2.0 interface over local IPC sockets, enabling the ZeroCode TUI to interact with the daemon. This includes a new \RpcApprovalChannel\ that bridges tool-call approvals and elicitation requests to the client, a \SessionStore\ for managing active agent sessions, and a \RpcContext\ that centralizes shared daemon state (config, sessions, cost tracking, and event broadcasting). The implementation adds strict security measures, including inbound authentication via native pairing tokens, peer credentials, or OIDC, and enforces file-attachment and directory-listing safety using cap-std to prevent path traversal and symlink-swap attacks.

crates/zeroclaw-runtime/src/rpc · high confidence

The platform module now includes a new WASM-based runtime that executes tool modules in an isolated environment using the \wasmi\ interpreter. This runtime enforces strict resource limits, including configurable memory caps (with a 4 GB safety limit for 32-bit WASM) and fuel metering to prevent infinite loops. It supports capabilities such as controlled workspace read/write access and restricted HTTP host access, ensuring that external tools run securely within defined boundaries.

crates/zeroclaw-runtime/src/platform · high confidence

This change adds the \wit/v0\ directory containing the WebAssembly Interface Types (WIT) definitions for the ZeroClaw plugin system. These files establish the contract between the host runtime and plugins, defining interfaces for tools, channels, memory, configuration, secrets, logging, durable state, and network access (sockets and WebSockets). The interfaces are marked as experimental and gated behind the \plugins-wit-v0\ feature flag, providing the foundational schema for plugin capabilities like inbound message handling, tool execution, and secure secret access.

wit/v0 · high confidence

The tunnel module now exposes a factory-based system that allows users to select from multiple tunnel providers via configuration. This change adds support for OpenVPN and Pinggy alongside existing providers like Cloudflare, Ngrok, Tailscale, and Custom. The implementation re-exports the core tunnel logic from the \zeroclaw\_runtime\ crate and includes a comprehensive test suite verifying that the factory correctly instantiates the appropriate tunnel type based on the \tunnel\_provider\ field and validates required configuration sections for each provider.

src/tunnel · high confidence

The service module now implements bounded log files for the ZeroClaw daemon across macOS (launchd), Linux (OpenRC), and Windows. Logs are capped at 8 MB, with a compact tail retention of 4 MB when the limit is exceeded, preventing unbounded disk usage. The implementation includes specific log paths for OpenRC and launchd, and handles private desktop directories on Windows and macOS.

crates/zeroclaw-runtime/src/service · high confidence

A new \zeroclaw-dist\ crate establishes the single source of truth for ZeroClaw's release targets, defining the specific platform families (Linux, macOS, Windows, Android), archive formats (tar.gz, zip), and release tiers (Required vs. Experimental) for each of the ten supported target triples. This registry centralizes identity data previously scattered across the release workflow matrix, install scripts, and the self-updater, and includes parity tests to ensure that any changes to these targets are consistently reflected across all consuming surfaces.

crates/zeroclaw-dist · high confidence

The cost module in zeroclaw-config now provides a persistent, JSONL-backed ledger for tracking token usage and USD costs. Users can configure daily and monthly spending limits, with the system checking budgets before requests and supporting hot-reload of these limits without restarting the daemon. The tracker supports attributing usage to specific agents or tasks, caching input token pricing, and handling cache-write costs, while exposing session-level aggregates for immediate visibility.

crates/zeroclaw-config/src/cost · high confidence

The \zeroclaw-api\ crate now provides the foundational wire types and domain models for the platform. This includes \a2a\_wire.rs\ with the shared A2A v1.0 protocol DTOs for agent-to-agent communication, \attribution.rs\ defining the \Attributable\ trait and role taxonomy for tracing tool and channel provenance, and \grants.rs\ implementing the \ResolvedGrants\ structure for fine-grained, deny-by-default authorization. Additionally, \agent.rs\ introduces structured \TurnEvent\ variants for detailed runtime telemetry, \channel.rs\ defines the \ChannelApprovalRequest\ and \AttributedApprovalResponse\ for tool-call approvals, and \elicitation.rs\ adds the primitives for ACP multiple-choice prompts.

crates/zeroclaw-api · high confidence

The security module now includes a Merkle-hashed audit trail (\audit.rs\) that records security events like command execution, file access, and certificate lifecycle changes, ensuring the log cannot be modified without detection. Additionally, a new authentication seam (\auth\_provider/\) allows the system to verify credentials from multiple sources, including native pairing tokens, local peer credentials, and OIDC providers (supporting Device Authorization, PKCE, and client credentials flows), with a default-deny registry that requires explicit provider configuration.

crates/zeroclaw-runtime/src/security · high confidence

The web directory now contains a new React frontend application built with Vite and Tailwind CSS, replacing the previous static structure. This change introduces a modern development workflow with hot-reload and TypeScript support, while enforcing a minimum browser version (Chrome 111+, Edge 111+, Firefox 113+, Safari 16.2+) via a client-side feature check that displays an unsupported-browser banner if requirements are not met. The Vite configuration includes proxy rules for API, WebSocket, and gateway endpoints, and mirrors the production asset path stripping behavior to ensure consistent URL handling between development and production environments.

web · high confidence

The approval module now provides a pre-execution hook that prompts the user before tool calls in supervised mode, supporting session-scoped allowlists and audit logging. Users can respond with Yes, No, Always (to add to the allowlist), or ReplaceWith (to provide a custom result). The system includes sanitization for replacement text to prevent context window blowups and supports both interactive CLI and non-interactive channel-driven runs.

crates/zeroclaw-runtime/src/approval · high confidence

The gateway now exposes an Agent-to-Agent (A2A) discovery surface, serving a well-known catalog card and per-agent cards that list available agents and their skills. It also introduces a new ACP-over-WebSocket endpoint, allowing clients to connect via a dedicated WebSocket protocol for agent communication. These additions provide new API routes for agent discovery and real-time agent-to-agent interaction.

crates/zeroclaw-gateway/src · high confidence

The \crates/zeroclaw-channels/src/orchestrator\ module now includes the ACP (Agent Control Protocol) server implementation (\acp\_server.rs\ and \acp\_embedded.rs\), a media understanding pipeline (\media\_pipeline.rs\) for processing inbound images, audio, and video, and an MQTT listener (\mqtt.rs\) for SOP event fan-in. These additions provide the orchestrator with the ability to handle ACP JSON-RPC sessions, automatically transcribe/describe media attachments, and ingest SOP triggers via MQTT, expanding the channel subsystem's capabilities beyond standard chat integrations.

crates/zeroclaw-channels/src/orchestrator · high confidence

The web dashboard now includes a new \api.ts\ type file that defines TypeScript interfaces for core runtime and dashboard data. This adds type support for system health snapshots (CPU, RAM, uptime), cron job management (schedules, runs, delivery configs), integration registry details, memory entries, cost summaries broken down by model and agent, and session/channel readiness states. These types enable the frontend to correctly consume and display real-time system stats, scheduled task history, and agent usage metrics from the backend API.

web/src/types · high confidence

The CI pipeline now includes three new validation scripts to enforce quality standards. The binary size gate (check\_binary\_size.sh) fails builds if release binaries exceed 20MB, warning at 15MB and 5MB thresholds. The documentation link gate (check\_internal\_docs\_links.py and collect\_changed\_links.py) validates internal Markdown links in PRs, ensuring they resolve correctly and stay within the docs source tree. The comment hygiene gate (comment\_hygiene\_gate.sh and .py) scans source code comments to reject issue/PR references, dated notes, and review-process leakage artifacts.

scripts/ci · high confidence

Users can now configure, list, and flash connected hardware boards directly from the command line. The new \peripherals list\ command displays currently configured boards and provides setup hints if none are found, while \peripherals add\ allows users to register new boards (specifying board type, transport, and path) in the configuration file. Additionally, the \peripherals flash\ command enables flashing firmware to Arduino devices, and specific commands like \setup-uno-q\ and \flash-nucleo\ support Uno Q bridge setup and Nucleo board flashing respectively; these hardware-specific actions are gated behind the \hardware\ feature flag, ensuring the CLI remains functional without physical hardware attached.

src/peripherals · high confidence

The CLI now includes three new commands: \self-test\ runs diagnostic checks on configuration, workspace, SQLite, and model/tool registries (with optional network checks); \update\ implements a six-phase self-update pipeline with rollback, checksum verification, and support for specific target versions; and \eval\ runs an agent evaluation harness and outputs results as a human-readable table or machine-readable JSON. These commands are gated by the \agent-runtime\ feature flag.

src/commands · high confidence

The demo area now includes a complete, self-contained harness for the ESP32 Smart Room scenario, allowing users to run the simulation via Docker or directly on the host. This update adds a Dockerfile and docker-compose.yml to package the simulator and agent, alongside shell scripts (run-sim.sh, run-agent-host.sh, etc.) to launch the environment. It introduces Telegram channel support for host-mode testing, requiring a bot token configured via a new .env.template file. The demo is secured by a zeroclaw.toml.example that restricts the agent to smart-room tools (set\_device, read\_device) and disables other surfaces like shell and browser access. Documentation (README.md, PROMPTS.md) and a .gitignore are also provided to guide users through setup and interaction.

demo · high confidence

Added new Fluent translation catalogs (zerocode.ftl) for English, Spanish, French, Japanese, and Chinese in the ZeroCode application. These files provide the localized strings for the ZeroCode UI, covering panes (Dashboard, Config, Doctor, Code, Chat, Logs, Quickstart, SOPs), agent sidebar management, theme and keybinding settings, connection configuration, the todo tracker, message queue controls, and log viewing.

apps/zerocode/locales · high confidence

Users can now connect the agent to Git repositories via a new \git\ channel. This feature introduces a provider-agnostic channel implementation that ingests events from GitHub, Gitea, and Forgejo instances. It supports polling for issue comments, pull requests, releases, and workflow runs, allowing the agent to interact with code review and CI workflows directly through forge comments. Configuration requires specifying the provider type (e.g., \github\ or \gitea\), authentication credentials (GitHub App keys or Gitea/Forgejo access tokens), and the API base URL for self-hosted instances.

crates/zeroclaw-channels/src/git · high confidence

Added three new Python scripts in the scripts/github directory to automate repository maintenance workflows. pr\_review\_queue.py introduces report-only pull-request review queues (such as near-ready, maintainer, and second-core lanes) that surface approval carry-forward candidates and help maintainers prioritize reviews based on specific label and status criteria. pr\_size\_label.py automates the application of PR size labels (XS through XL) by calculating effective changed lines while excluding documentation-like files and Cargo.lock, ensuring consistent sizing metadata. project\_dashboard\_plan.py provides a dry-run planner for GitHub Project dashboards, mapping issue labels to status values (e.g., Idea, Backlog, In Progress) according to a configurable contract without mutating live project data. Comprehensive unit tests accompany each script to validate search queries, label logic, and status classification rules.

scripts/github · high confidence

The firmware/nucleo directory now contains a new Rust-based firmware for the Nucleo-F401RE board that communicates via JSON-over-serial on USART2 at 115200 baud. Users can send commands to ping the device, query capabilities (reporting GPIO pins 0–13 and LED pin 13), read GPIO pins, and write to the onboard LED (PA5) or other valid GPIO pins, receiving structured JSON responses.

firmware/nucleo · high confidence

This change introduces a complete set of scripts and configuration files to cross-compile and deploy ZeroClaw to a Raspberry Pi. It includes \deploy-rpi.sh\ for automated building (via \cargo-zigbuild\ or \cross\) and SSH deployment, a \zeroclaw.service\ systemd unit, and \rpi-config.toml\ with a production-ready configuration (including hardware features and security settings). Additionally, it adds \99-act-led.rules\ to allow the \gpio\ group to control the Pi's ACT LED without \sudo\, and \migrate-skill-toml.py\ to migrate legacy SkillForge provenance data to the new \\[forge\]\ table layout. CI validation is also added via \check-pr-title.sh\ and its test suite.

scripts · high confidence

The web dashboard now includes a suite of new React hooks in \web/src/hooks\ to manage frontend state and communication. \useApi\ provides typed wrappers for fetching agent status, tools, cron jobs, integrations, memory, CLI tools, and health data. \useAuth\ handles authentication state, token management, and pairing logic. \useSSE\ and \useWebSocket\ enable real-time event streaming and agent chat messaging. Additional hooks include \useDevices\ for device management, \useDraft\ for preserving message drafts across view switches, \useFocusTrap\ for modal accessibility, \usePolling\ for efficient data fetching, \useRunOverlay\ for SOP run status, \useTheme\ for UI theming, and \useVersionCheck\ for release notifications.

web/src/hooks · high confidence

The CLI now supports exporting an agent to a portable bundle via \zeroclaw agents export\, which stages the bundle in a temporary directory and atomically swaps it into place to ensure consistency. Additionally, the CLI provides full CRUD operations (create, list, rename, delete) for agents, providers, and channels, including validation that prevents creating a reserved \default\ agent and detailed impact reporting for deletions.

_src/alias\cli · high confidence

The runtime now includes two new built-in hooks: a \CommandLoggerHook\ that records tool call details (name, duration, success status) to the log, and a \WebhookAuditHook\ that exports tool call data to external webhooks. The webhook audit implementation enforces strict security policies, requiring HTTPS for non-localhost URLs, blocking private/local host destinations, disabling HTTP redirects, and scrubbing sensitive credentials from the exported payload before transmission.

crates/zeroclaw-runtime/src/hooks/builtin · high confidence

The daemon now exposes a dedicated, server-authenticated TLS endpoint for initial client certificate enrollment, allowing certless clients to bootstrap a mutually authenticated RPC plane. This process involves fetching the daemon CA, confirming it via a short-auth-string (SAS) pairing code, and submitting a certificate signing request (CSR) to receive a signed client certificate and relay profile. The implementation includes a file-based admin interface for operators to generate new pairing codes and SAS values, along with rate-limiting logic to protect against brute-force attempts on the enrollment path.

crates/zeroclaw-runtime/src/enroll · high confidence

The \zeroclaw-channels\ crate now includes implementations for several new communication channels, including ACP (Agent Client Protocol), AMQP, Bluesky, ClawdTalk, DingTalk, and Email. It also introduces shared infrastructure such as a centralized allowlist matching module (\allowlist.rs\) and persisted state management for Discord slash commands (\discord\_slash\_state.rs\). These additions expand the system's ability to integrate with diverse messaging platforms and standardize access control logic across channels.

crates/zeroclaw-channels/src · high confidence

The runtime now exposes a dedicated health registry module that allows individual components to report their status (starting, ok, error) and restart counts. This enables the dashboard and monitoring systems to query a structured health snapshot including per-component details, uptime, and error history, rather than relying on generic process liveness checks.

crates/zeroclaw-runtime/src/health · high confidence

Developers can now use a fully containerized sandbox to build, test, and debug the ZeroClaw agent without modifying the host system. This includes a Docker Compose setup with an agent container and a simulated user sandbox, managed via helper scripts (\cli.sh\, \ci.sh\). The environment supports local CI/CD validation (linting, testing, security audits) entirely within Docker, isolating the Rust toolchain and build artifacts from the host. It also provides configuration templates and test harnesses for validating memory, sessions, and skills.

dev · high confidence

The runtime now ships with a complete set of default personality files (SOUL.md, IDENTITY.md, USER.md, MEMORY.md, TOOLS.md, HEARTBEAT.md, and AGENTS.md) that are automatically seeded into new agent workspaces. These templates define the agent's identity, communication style, safety boundaries, and memory behavior, with a configurable option to disable persistent memory (which switches the AGENTS template to a no-memory variant and omits MEMORY.md). This ensures every new agent starts with a consistent, opinionated baseline for how it interacts with the user and manages context.

_crates/zeroclaw-runtime/src/agent/personality\templates · high confidence

Added several new scripts under scripts/dev to improve local development workflows: act-local.sh enables safe local execution of GitHub Actions workflows with artifact compatibility checks and a fail-closed allowlist; fuzz.sh provides a smoke runner for cargo-fuzz targets; mtls-relay-testbed.sh stands up an isolated mTLS WSS testbed with relay support; generate-vi-reference-vectors.py and its test generate SD-JWT reference vectors with provenance verification; and refresh-nix-hashes.sh updates NAR hashes for nix builds.

scripts/dev · high confidence

A new CLI tool at tools/fill-translations has been added to automatically fill empty or fuzzy entries in .po translation files using a configured model provider. The tool supports batched API calls, allows forcing re-translation of all entries, and includes built-in safety checks to detect and reject local path leaks or generated TOML blocks in model responses. Failed translation attempts are logged to a file for debugging, and the tool preserves protected literals and handles standard .po string escaping.

tools/fill-translations · high confidence

This update introduces firmware support for new hardware platforms and a bridge utility. Users can now flash Rust-based firmware to ESP32 (RISC-V and Xtensa) and Raspberry Pi Pico (RP2040) microcontrollers, which communicate via a JSON-over-serial protocol for GPIO control. A new Slint-based UI scaffold is provided for ESP32 edge scenarios. Additionally, a new Uno-Q Bridge allows agent control of GPIO pins on an Arduino Uno Q via a local socket server, exposing digital read/write commands.

firmware · high confidence

The \zeroclaw-hardware\ crate now exposes a suite of tools for interacting with physical hardware. Users can flash firmware to Arduino Uno boards via \arduino-cli\ (using the \arduino\_flash\ and \arduino\_upload\ modules) and to Nucleo boards via \probe-rs\. GPIO read/write capabilities are available for Raspberry Pi (via \rppal\), Arduino Uno Q (via a local socket bridge), and generic serial boards like STM32 and ESP32. Additionally, the \hardware\_capabilities\ tool now surfaces detailed device information including \pin\_devices\ and descriptions, and ESP32 boards gain high-level \set\_device\ and \read\_device\ tools for smart-room device management.

crates/zeroclaw-hardware/src/peripherals · high confidence

The runtime now includes a new heartbeat engine that periodically executes tasks defined in HEARTBEAT.md, featuring adaptive scheduling that increases intervals after consecutive failures and prioritizes high-priority tasks. Execution history is persisted in a local SQLite database (heartbeat/history.db), which automatically prunes old records to a configurable limit and truncates large outputs to 16KB. The system exposes live health metrics (uptime, success/failure counts, average tick duration) and provides APIs to list recent runs and view aggregate statistics, enabling users to monitor and troubleshoot background task execution.

crates/zeroclaw-runtime/src/heartbeat · high confidence

The runtime now includes a new hook system (crates/zeroclaw-runtime/src/hooks) that allows for extensible event handling. This introduces a HookRunner that manages registered handlers, supporting events like gateway start/stop, session start/end, LLM input/output, and tool calls. Built-in hooks for command logging and webhook auditing are integrated into this runner, with configuration-driven activation and error handling for invalid network policies.

crates/zeroclaw-runtime/src/hooks · high confidence

The xtask now includes a dedicated Fluent pipeline for managing internationalization catalogs. This adds commands to check FTL syntax validity, scan for stale or missing translation keys by cross-referencing source code, and generate translation statistics. A new 'fill' command enables AI-assisted translation, allowing users to automatically generate localized strings for non-English locales using a configured model provider, with support for batch processing and incremental updates.

xtask/src/cmd/fluent · high confidence

The new \zeroclaw-infra\ crate centralizes cross-cutting channel infrastructure. It introduces a unified \SessionBackend\ trait with SQLite and JSONL implementations, including automatic migration from legacy JSONL files and full-text search support. ACP (Agent Control Plane) sessions are now persisted in a dedicated SQLite database with schema migrations for ownership and history trimming. Network safety is enforced via a shared \net\_guard\ module that validates egress destinations against allowlists and blocks SSRF/private IP access. Additionally, the crate provides a \MessageDebouncer\ to aggregate rapid inbound messages and a \SessionActorQueue\ to serialize concurrent access to session transcripts.

crates/zeroclaw-infra · high confidence

Zerocode now supports local, user-editable configuration via a new \zerocode-config.toml\ file, allowing users to customize keybindings and themes independently of the server connection. The system introduces named keybinding presets (including Emacs and Vim-style motion keys) that layer on top of defaults, and a theme section that supports per-agent overrides so different agents can use distinct visual styles. It also includes automatic migration logic to update legacy control-key syntax (e.g., \ctrl+c\ to \primary+c\) and restore deprecated help/copy bindings to their current defaults.

apps/zerocode/src/config · high confidence

The \zeroclaw-config\ crate has been extracted to provide a structured, type-driven configuration surface. It introduces a stable HTTP/CLI CRUD API with typed error codes (e.g., \path\_not\_found\, \dangling\_reference\) and supports atomic JSON Patch operations. Deletion of agents, providers, and channels now uses a cascade mechanism that discovers all references, blocks removal if hard dependencies exist, and safely scrubs soft references. Additionally, a new agent bundle export feature allows operators to package an agent’s config closure, skills, and workspace into a portable directory while stripping credentials and host-specific state, with a manifest that reports dropped references and risk flags.

crates/zeroclaw-config/src · high confidence

The agent turn loop now uses a set of new, dedicated modules in \crates/zeroclaw-runtime/src/agent/turn\ to handle the per-call lifecycle. \approval\_gate.rs\ manages tool-call approvals, supporting interactive CLI prompts, channel-based inline approvals (with fallback to auto-deny), and explicit decision recording. \call\_prep.rs\ orchestrates per-call preparation, including \before\_tool\_call\ hooks, duplicate-call detection, and the approval gate, producing a set of executable tool calls. \context.rs\ defines the \TurnCtx\ struct, which bundles immutable turn-level state (observer, provider, model, approval manager, channel, hooks) and provides a \for\_route\ method to create iteration-scoped views for vision routing. \context\_recovery.rs\ handles LLM failure recording and in-loop context-overflow recovery by trimming oldest whole turns. \delivery\_defaults.rs\ injects channel-specific delivery defaults for \cron\_add\ and originating-channel defaults for interactive tools like \ask\_user\. \events.rs\ defines the \StreamDelta\ event types and pacing constants for draft updates and progress. \execution.rs\ introduces \ResolvedModelAccess\ and \ResolvedAgentExecution\, bundling model provider access, tool registry, and observer into a sealed execution context, with \run\_model\_query\ handling multimodal sanitization and cost settlement.

crates/zeroclaw-runtime/src/agent/turn · high confidence

This change introduces the \zeroclaw-relay-proto\ crate, which defines the wire protocol for the blind relay (control frames and data framing), and the \zeroclaw-tls\ crate, which provides mutual-TLS (mTLS) certificate generation, CSR handling, and secure TLS configuration. These crates establish the foundational protocol and security primitives for the relay and daemon components.

crates/zeroclaw-relay-proto, crates/zeroclaw-tls · high confidence

The release pipeline now includes dedicated scripts to automate and harden version bumps and crate publishing. The \bump-version.sh\ script synchronizes version references across the repository (including README badges, Tauri config, Windows installers, and workspace Cargo.toml) and supports a strict release mode that validates prerequisites and runs generators like Nix hash refresh and installer generation before mutating files. A new \publish-crates.sh\ script manages publishing the workspace to crates.io with a dry-run default, dependency-order publishing to respect rate limits, and preflight checks for credential completeness and existing registry state. Additionally, \apple\_preflight.py\ validates Apple signing and notarization credentials early in the desktop build process to fail fast before expensive compilation, and \aur\_version\_guard.sh\ ensures AUR package versions are correctly compared to prevent downgrades.

scripts/release · high confidence

The firmware/zeroclaw-fw-protocol crate now provides a shared, no\_std Rust implementation for parsing and responding to firmware commands over JSON. It introduces a Command enum supporting ping, capabilities, gpio\_read, and gpio\_write operations, along with lightweight JSON parsing utilities (parse\_arg, has\_cmd, copy\_id) and response writers (write\_ok, write\_err). This enables consistent command handling across different hardware targets (such as ESP32 and Pico) by centralizing the protocol logic.

firmware/zeroclaw-fw-protocol · high confidence

The web UI now supports a comprehensive theme system with 24 color palettes, accent colors, and font choices, persisted via localStorage and applied through CSS variables. Additionally, the chat interface now allows multiple independent conversations per agent, with session management handled through a new AgentContext that tracks session IDs, hydration state, and reserved sessions to prevent cross-pane interference.

web/src/contexts · high confidence

The web/src/lib directory now contains the core library for the new Operator Console dashboard, introducing multi-agent chat capabilities and a schema-driven configuration interface. This includes an ACP WebSocket client for agent communication, session management that persists active conversations per agent, and chat history storage with local caching. The library also provides agent summary loading, channel resolution for cron job configuration, and a draft store for the config editor. Additionally, it features a command palette for config search, context bar utilities for token usage visualization, and entity link resolution for navigating between configuration sections.

web/src/lib · high confidence

Developers can now use \cargo fluent\ to scan, fill, and validate Fluent translation files; \cargo generate\ to render installers, PR-review policies, SOP syntax references, and feature lists from canonical specs; \cargo mdbook\ to build, serve, and manage versioned documentation (including SEO, themes, and llms.txt generation); and \cargo web\ to build the web dashboard, generate the TypeScript client from the OpenAPI spec, and handle npm dependencies. These commands replace manual scripts and ensure deterministic, drift-checked outputs for docs, translations, and the web UI.

xtask/src/bin · high confidence

The xtask module has been restructured to provide a dedicated command-line interface for managing the project's documentation and localization pipelines. This change introduces a new \cmd\ module that exposes subcommands for Fluent-based internationalization and mdBook processing, supported by a \util\ module that handles repository path resolution, automatic installation of required tools (such as mdBook and mdbook-mermaid), and management of the translations git submodule. Users interacting with the build system will now use these xtask commands to generate localized documentation and manage locale assets, replacing previous ad-hoc or manual processes.

xtask/src · high confidence

The web UI for configuration has been redesigned to use a schema-driven approach, replacing the previous section-list drill-down with a new master-detail layout. This introduces a unified SectionNavigator for browsing and searching all configuration sections and their entities, alongside a new AddEntityDialog for creating new items. Core editing is now handled by a shared FieldForm component that dynamically renders inputs based on the configuration schema, supporting features like typed alias pickers, secret masking, and inline drift detection. The redesign also adds specialized editors for specific domains, including a DirectoryPicker for skill-bundle paths, a PersonalityEditor for workspace markdown files, a CostRatesEditor for provider pricing, and a BindChannelForm for authorizing users on messaging channels without a code round-trip.

web/src/components/sections · high confidence

The SOP runtime now supports a structured approval workflow for gates, allowing runs to pause and require human authorization before proceeding. This change introduces an approval broker that enforces group membership and configurable quorum (N distinct approvers) on gate resolution, ensuring that approvals are authorized and audited via an append-only ledger. It also adds a channel route adapter that delivers approval notices to external communication channels (such as Discord or Slack) so operators can approve or deny runs from outside the daemon, with support for escalation routes and fail-closed timeouts.

crates/zeroclaw-runtime/src/sop · high confidence

The gateway build script now attempts to automatically build the embedded web dashboard when installing via \cargo install\. This ensures the dashboard is available out of the box for users who install the binary directly, while silently skipping the process if Node.js/npm is missing or the build fails, so the binary remains functional without it.

crates/zeroclaw-gateway · high confidence

The repository now includes a comprehensive set of configuration files to standardize the development environment and improve cross-platform consistency. A \.env.example\ file documents the new V0.8.0 environment variable schema, replacing legacy fallbacks with a strict \ZEROCLAW\_\ prefix convention. Developer workflows are supported by \.actrc\ for local GitHub Actions emulation, \.nvmrc\ to pin Node.js 24, and \.envrc\ for flake integration. Code quality and consistency are enforced through \.editorconfig\, \.gitattributes\ (standardizing line endings and GitHub language stats), \.dockerignore\, and linting configurations for markdown and Semgrep. Additionally, \AGENTS.md\ establishes core instructions for AI coding assistants, and \CHANGELOG-next.md\ provides the release notes for v0.8.5.

(repo-wide) · high confidence

The runtime crate now provides a scoped directory browser for the shared workspace and agent workspaces, protecting system directories and files from accidental deletion via the dashboard. It adds a calendar no-show detection system that polls upstream events and emits SOP triggers when attendees miss scheduled meetings. Additionally, a migration tool is available to import memory entries from legacy OpenClaw workspaces (SQLite and Markdown) into the current memory backend, with support for dry runs and reindexing.

crates/zeroclaw-runtime/src · high confidence

The runtime now supports ephemeral sub-agents that automatically inherit their parent agent's identity, security policy, and memory allowlist. When a sub-agent is spawned, it operates within the parent's permissions envelope by default, ensuring that policy overrides can only narrow (not escalate) permissions and that memory access is restricted to the parent's allowed aliases. This provides an auditable, secure way to delegate tasks while maintaining strict security boundaries.

crates/zeroclaw-runtime/src/subagent · high confidence

The desktop application now bundles the \zeroclaw\ kernel binary as a Tauri sidecar, allowing the installer to be fully self-contained. A new \prepare-kernel.sh\ script builds the kernel for the host or specified target architectures (including universal macOS support) and places it in the expected directory for Tauri's external binary bundling. This ensures that users can double-click the installer and the app will start its own daemon without requiring any pre-installed system components.

scripts/desktop · high confidence

The runtime now exposes a single, schema-driven registry that aggregates all integrations—chat channels, AI model providers, built-in tools, and platform availability—into a unified catalog. This enables the \zeroclaw integration info \<name\>\ CLI command to display localized status, category labels, and actionable setup guidance for each integration. The registry maps configuration keys to entries, ensuring that config deep links route correctly based on the canonical schema key rather than human-readable names, and supports filtering by platform availability at compile time.

crates/zeroclaw-runtime/src/integrations · high confidence

The runtime now provides a unified observability system that supports multiple export backends, including OpenTelemetry (traces, metrics, and logs), Prometheus, and local logging. Users can configure the backend via the \ObservabilityConfig\ schema, enabling authenticated OTLP exports, content privacy policies for LLM/tool I/O, and a process-wide broadcast hook to fan out events to SSE endpoints. The system introduces a lifecycle guard for agent turns to ensure balanced start/end events and adds detailed metrics for memory, RAG, and cache operations.

crates/zeroclaw-runtime/src/observability · high confidence

The \zeroclaw-log\ crate has been rewritten to provide a unified, structured logging surface that replaces ad-hoc logging with a typed \record!\ macro and a \tracing\-based capture layer. This change introduces configurable log persistence policies (rolling, full, or rotating with size/date/entry-count limits) and strict security controls for third-party dependencies: the \log\ facade bridge now redacts all message bodies and restricts target names to a reviewed allowlist to prevent credential leakage. Additionally, the system supports an optional export bridge for external telemetry (e.g., OTLP) and a broadcast channel for real-time log consumption, while ensuring backward compatibility through an in-place JSONL schema migration tool.

crates/zeroclaw-log · high confidence

The \src/runtime\ module has been removed, eliminating the \RuntimeAdapter\ trait and the \NativeRuntime\ implementation that previously abstracted platform differences (such as shell access, filesystem access, and storage paths) for environments like native, Docker, and Cloudflare. This change removes the factory logic that selected runtime instances based on configuration, indicating a shift away from supporting multiple runtime environments through this abstraction.

src/runtime · high confidence

The repository has removed the standalone example files for implementing custom channels (including a Telegram example), memory backends (including an in-memory HashMap backend), LLM providers (including an Ollama example), and tools (including an HTTP GET tool). These files are no longer available as runnable examples or reference implementations for extending the ZeroClaw agent.

examples · high confidence

The agent execution logic previously defined in src/agent/loop\_.rs has been removed from this crate and is now re-exported from the zeroclaw-runtime crate. This change consolidates the agent loop implementation into the runtime module, simplifying the agent module to a re-export layer.

src/agent · high confidence

The new \src/auth\ module now acts as a central facade, re-exporting authentication sub-modules (such as profiles, email OAuth2, Gemini, OpenAI, and xAI OAuth) from the \zeroclaw\_providers\ crate. This change consolidates access to provider-specific authentication logic under a single \auth\ namespace, simplifying how other parts of the application import and use these capabilities.

src/auth · high confidence

The channel implementations (Discord, iMessage, Slack, Telegram) and the core Channel trait have been removed from the local src/channels directory. Instead, the module now re-exports the orchestrator, listing, and session backend logic from the external zeroclaw-channels and zeroclaw-infra crates. This moves the channel wiring and management logic out of the main application crate into a dedicated channels crate.

src/channels · high confidence

The configuration schema, traits, and helpers previously defined in \src/config\ have been extracted into the new \zeroclaw-config\ crate. The \src/config\ module now acts as a pure re-export surface, pulling in types like \Config\, \ChannelsConfig\, and provider-specific schemas from \zeroclaw\_config\ to maintain backward compatibility for existing callers. This change consolidates configuration logic into a dedicated library crate while preserving the public API for the binary.

src/config · high confidence

The daemon module in src/daemon has been refactored to simply re-export the daemon implementation from the zeroclaw\_runtime crate. This change aligns with the broader workspace restructuring that moved core components like the agent, gateway, channels, cron, and daemon into the zeroclaw-runtime package (previously zeroclaw-misc), centralizing the runtime logic while keeping the src/daemon path as a public interface.

src/daemon · high confidence

The doctor module in the application source now acts as a re-exporter for the diagnostics logic defined in the zeroclaw-runtime crate, centralizing the diagnostic capabilities within the runtime package while maintaining the existing public API surface for the doctor component.

src/doctor · high confidence

The gateway module has been refactored to re-export the \zeroclaw\_gateway\ crate instead of using the previous minimal, raw-TCP-based HTTP implementation. This change removes the inline webhook and health-check logic, replacing it with the functionality provided by the extracted \zeroclaw-gateway\ crate, which likely includes the more robust features, security hardening, and configuration options seen in the broader codebase.

src/gateway · high confidence

The heartbeat engine logic has been removed from the local \src/heartbeat/engine.rs\ file and is now re-exported from the \zeroclaw\_runtime\ crate. This change shifts the heartbeat functionality to a shared runtime module, while the local module now primarily serves as a re-export point and includes tests to verify the engine's constructibility and file creation behavior.

src/heartbeat · high confidence

The integration registry, status definitions, and CLI handling logic have been removed from the local \src/integrations\ module and are now re-exported from the \zeroclaw-runtime\ crate. This change consolidates integration metadata and status reporting into the runtime subsystem, meaning the integrations list and info commands now pull their data from the centralized runtime definition rather than the local static registry.

src/integrations · high confidence

The memory implementation has been extracted from the local \src/memory\ directory into the external \zeroclaw-memory\ crate, shifting the module structure to re-export types and logic from that dependency. This change introduces a new \zeroclaw memory\ CLI interface (in \src/memory/cli.rs\) for managing memory entries, including commands to list, get, clear, and reindex data. Additionally, a new \battle\_tests.rs\ file has been added to validate the multi-stage retrieval pipeline, namespace isolation, and caching behavior, while the local \sqlite.rs\ and \traits.rs\ implementations have been removed in favor of the external crate's definitions.

src/memory · high confidence

The provider implementations (Anthropic, OpenAI, Ollama, OpenRouter, and the generic OpenAI-compatible provider) have been removed from the local source tree. The \src/providers\ module now acts as a thin re-export layer, delegating to the external \zeroclaw-providers\ crate. This change consolidates provider logic into a dedicated workspace crate, simplifying the local module structure while maintaining the same public API surface for the rest of the application.

src/providers · high confidence

The local security policy implementation in src/security/policy.rs has been removed and replaced with re-exports from the zeroclaw\_runtime crate. This change shifts the definition of core types like SecurityPolicy and AutonomyLevel, as well as new capabilities such as PairingGuard, SecretStore, and the redact utility, to the runtime layer. Users benefit from a consolidated security architecture where policy enforcement, pairing logic, and secret management are handled by the shared runtime, while the src/security module now primarily serves as a re-export point and includes tests verifying the usability of these re-exported components.

src/security · high confidence

The skills implementation in src/skills has been moved to the zeroclaw-runtime crate, with this module now re-exporting the core types (Skill, SkillTool, etc.) and sub-modules (creator, audit, skill\_tool, skill\_http) from zeroclaw\_runtime::skills. The local logic for loading skills, handling CLI commands, and managing skill bundles has been replaced by calls to the runtime's SkillsService and related utilities, effectively shifting the skills management responsibility to the runtime layer while preserving the public API surface for the CLI.

src/skills · high confidence

The \src/tools\ directory has been refactored so that individual tool modules (such as \file\_read\, \shell\, \memory\_store\, and \file\_write\) are no longer implemented in place. Instead, they now act as thin re-export layers (\pub use zeroclaw\_tools::...\) pointing to the \zeroclaw\_tools\ crate. This change centralizes the actual tool logic and definitions in the \zeroclaw\_tools\ crate, while \src/tools\ serves as the public interface for the rest of the application.

src/tools · high confidence

The configuration system now supports a migration path from the legacy V1 schema through V2 to the new V3 structure. This change reorganizes how provider settings, channels, and agent behaviors are defined: top-level provider globals (like \api\_key\ and \model\) are folded into per-provider entries under \providers.models\, \channels\_config\ is renamed to \channels\, and autonomy/agent settings are split into \risk\_profiles\ and \runtime\_profiles\. Users upgrading from V1 will have their configuration automatically transformed to the new V3 format, ensuring backward compatibility while adopting the new structured schema.

crates/zeroclaw-config/src/schema · high confidence

The cost module in the runtime crate now acts as a re-export layer for cost-related types and modules from the zeroclaw-config crate, simplifying access to these definitions for consumers of the runtime.

crates/zeroclaw-runtime/src/cost · high confidence

The cron CLI in src/cron has been significantly enhanced to support structured job management and better user feedback. Users can now explicitly specify agents via the --agent flag, which validates that the alias exists in the configuration before execution. Delivery options for cron jobs are now fully configurable via CLI flags (channel, recipient, thread, best-effort), with clear logic for creating new jobs versus patching existing ones. The list command now displays detailed job information including last run status and delivery targets. All user-facing messages have been internationalized using i18n strings, and timestamp parsing for --at flags now strictly enforces RFC3339 format with explicit timezone offsets.

src/cron · high confidence

The daemon now tracks and exposes startup readiness for the gateway and local IPC socket, allowing external observers to know when the service is fully operational. It also introduces fast-fail behavior for fatal socket binding errors—such as address-in-use conflicts or Unix socket paths exceeding platform limits—preventing the daemon from entering a broken or restarting loop in these scenarios.

crates/zeroclaw-runtime/src/daemon · high confidence

The \crates/zeroclaw-runtime\ crate is now explicitly defined as a temporary holding area for subsystems extracted from the original monolith, with a roadmap to decompose these into dedicated crates or WASM plugins starting in v0.8.0. An \AGENTS.md\ file establishes the governance policy for this crate, requiring Core Team approval for any exceptions to the extraction rule, and records four specific bounded exceptions for agent-loop, peer-inbox, tool-elicitation, and instrumentation code. Additionally, a \firmware\ symlink has been added to point to the parent \firmware\ directory.

crates/zeroclaw-runtime · high confidence

Developers now have automated checks enforced before committing and pushing code. The new pre-commit hook runs a staged secret scan using gitleaks (if available) to prevent accidental secret leaks. The pre-push hook ensures code quality by running the Rust quality gate (fmt and clippy), the firmware protocol gate, and the full test suite (excluding the desktop component). Additionally, when specific environment variables are set (ZEROCLAW\_STRICT\_LINT, ZEROCLAW\_STRICT\_DELTA\_LINT, ZEROCLAW\_DOCS\_LINT, ZEROCLAW\_DOCS\_LINKS), the hook enforces stricter linting rules and validates documentation and links.

.githooks · high confidence

The src/cost module now re-exports the cost-related types and functions from the zeroclaw\_runtime crate, making the budget tracking core available to consumers of this module.

src/cost · high confidence

The new \src/hooks\ module now acts as a re-export layer, exposing all hook-related types and functions from the \zeroclaw\_runtime\ crate. This centralizes access to the hook system for other parts of the application without requiring direct dependencies on the runtime crate.

src/hooks · medium confidence

The AUR package has been migrated from the 'zeroclaw' name to 'zeroclawlabs' (version 0.8.5). The new PKGBUILD builds both the main 'zeroclaw' and 'zerocode' binaries, includes the web dashboard assets, and declares that it provides the 'zeroclaw' and 'zerocode' names while conflicting with any existing packages using those names.

dist/aur · high confidence

The \cargo generate installers\ command now drives the generation of installation scripts, container images, Nix flakes, and packaging manifests from a single canonical feature registry. This ensures that the \install.sh\ script, \Dockerfile\/\Containerfile\ feature sets, Nix flake package definitions, and AUR/Scoop packaging metadata are always consistent with the project's official feature selections (such as \Dist\ or \All\), eliminating manual drift and ensuring that build artifacts reflect the current canonical state.

xtask/src/generate · high confidence

The CLI has been significantly restructured, consolidating command definitions into \lib.rs\ and introducing new modules for browsing, plugin management, and security posture. Users now have access to a \security status\ command that provides a detailed report on agent risk profiles, sandbox configurations, workspace restrictions, and credential encryption. The plugin system has been enhanced with a dedicated catalog and registry module, allowing users to view installed and available plugins with version comparisons. Additionally, the CLI now supports a \browse\ command for listing directory contents and includes improved input handling with UTF-8 safe line capping to prevent panics on large stdin inputs.

src · high confidence

The approval subsystem has been replaced with a new \ApprovalManager\ that enforces risk profiles (Supervised, Full, ReadOnly) to determine when user interaction is required. In supervised mode, users can configure specific tools to be automatically approved or always questioned. The system now supports session-based allowlists, where approving a specific action once (e.g., 'Always') skips future prompts for that action within the same session, while 'always\_ask' entries remain persistent. Additionally, all approval decisions are recorded in an audit log that captures the tool name, decision, timestamp, and execution channel (e.g., CLI, Telegram), and argument summaries are safely truncated to prevent log flooding.

src/approval · high confidence

The ZeroCode TUI now uses a structured keymap system where actions are defined in typed enums (GlobalAction, ChatTabAction, etc.) with compile-time default chords and runtime override support. Key bindings are now platform-aware: the 'primary' modifier maps to Command on macOS and Control elsewhere, and display labels adjust accordingly (e.g., ⌘ vs Ctrl). The system includes a guard that prevents handlers from using raw key codes, enforcing that all key handling goes through the action enum registry. Runtime overrides allow users to customize bindings via config or the UI, with conflict detection to prevent chord collisions. Reserved chords (Esc, Enter, Space) are protected from user rebinding to prevent soft-locking the interface.

apps/zerocode/src/keymap · high confidence

The skills module now includes a comprehensive security audit system that validates installed skills by scanning for symlinks, blocking unsupported script files, enforcing file size limits, and auditing markdown links and manifest structures. This audit system is integrated with a new content-validated caching layer that computes directory signatures to avoid redundant file system walks, significantly improving skill loading performance. The cache respects an environment variable kill-switch and uses content fingerprints to detect changes, ensuring that cached skill loads remain fresh and secure.

crates/zeroclaw-runtime/src/skills · high confidence

The observability module has been refactored to re-export its public API from the zeroclaw-runtime crate. This change removes the local implementation of the observer traits, the log-based observer, and the factory logic that previously selected backends based on configuration. Users relying on the internal structure of the observability module will need to adjust imports, as the concrete types and factory functions are now provided by the runtime crate.

src/observability · high confidence

The interactive onboarding wizard (src/onboard/wizard.rs) has been removed, eliminating the previous step-by-step CLI flow for configuring workspace, provider, and channels. This change reflects a shift to a new schema-driven, idempotent onboarding approach, meaning users will no longer encounter the legacy wizard prompts during setup.

src/onboard · high confidence

The web interface has been redesigned into the Operator Console, introducing a multi-agent chat workspace where users can open and manage several independent conversations for the same agent simultaneously via a new tab bar. The agent management experience is overhauled with a dense, scannable list view (AgentCard) and a detailed side drawer (AgentDrawer) that displays agent status, channels, sessions, and costs. Configuration management is improved with a new inline 'fix in place' modal on the Doctor page, allowing operators to edit flagged config entities without leaving the diagnostic list, and a unified entity toggle that explicitly handles configuration drift conflicts. Additional UI components include a global command palette for navigation, a markdown editor for SOPs, and a dedicated approval banner for supervised tool execution.

web/src/components · high confidence

The plugin system now enforces a security ceremony where network egress permissions are explicitly granted during installation and reported to the operator. A new \egress\_ceremony\ module generates shell-specific commands (POSIX, PowerShell, or Windows) to safely apply these grants via configuration patches, ensuring that host patterns are quoted to prevent shell injection and that existing entries are never silently widened by package updates.

src/plugins · high confidence

The web dashboard now features a slim, icon-only desktop sidebar rail that collapses into a hamburger-driven drawer on mobile, replacing the previous full-width navigation. This layout introduces a global Command Palette accessible via the header search trigger or the ⌘K/Ctrl+K keyboard shortcut. The header dynamically displays the current section title using i18n keys, and the layout integrates a dismissible Reload Banner to notify users of pending configuration reloads or file drift, alongside an Unsaved Changes Banner for saving or discarding draft edits. The sidebar navigation is now grouped into logical clusters (Home, Chat, Configure, Operations) with improved active-state resolution for nested routes.

web/src/components/layout · high confidence

The web application's navigation structure has been reorganized to improve performance and maintainability. Page components are now lazy-loaded using React's \lazy\ function, meaning they are only fetched from the server when the user actually navigates to that specific section, reducing the initial bundle size. A new central router configuration defines the URL paths for all major features, including the dashboard, agent chat, skills browser, SOPs (Standard Operating Procedures) editor, and the ACP console, while also providing a consistent loading spinner fallback during page transitions.

web/src/router · high confidence

The CLI handler for SOP commands has been updated to resolve SOP definitions against the install root (specifically \\<install\>/shared/sops\) rather than the user's data directory. This ensures that SOPs authored via the web or RPC interfaces are correctly discovered and validated by the CLI, as they are written to the shared location. The change also introduces detailed validation output, reporting load failures and configuration warnings (such as unconfigured decision models) during the \validate\ command.

src/sop · high confidence

The Windows desktop build now includes an explicit app.manifest that forces the use of Common Controls version 6, preventing startup failures on Windows 10/11 where TaskDialogIndirect requires v6. The manifest also enables PerMonitorV2 DPI awareness and long-path support for better display and file-system handling. Additionally, it declares microphone, webcam, and app-broadcast device capabilities to support onboarding and privacy-related features, while maintaining forward compatibility for packaged MSIX/AppX builds.

apps/tauri/windows · high confidence

The ACP bridge binary now handles configuration files that begin with a UTF-8 Byte Order Mark (BOM). Previously, such files would fail to parse; the bridge now automatically strips the BOM before deserializing the TOML configuration, ensuring compatibility with editors that save files with a BOM.

src/bin · high confidence

A new script, check-generated-api.mjs, has been added to verify the presence of critical generated dashboard API files (api-generated.ts, api-descriptions.ts, and api-enums.ts). If any of these files are missing, the script exits with an error and instructs the user to run \cargo web check\ from the repository root, ensuring that the build process fails early if the necessary API contracts have not been generated.

web/scripts · high confidence

The ACP console now buffers incoming thought chunks to ensure they are displayed as coherent paragraphs rather than fragmented text. This change introduces a \ThoughtChunkBuffer\ class that aggregates partial text and trims whitespace, ensuring that consecutive chunks are joined into a single readable unit while preserving paragraph boundaries. A new test suite validates this buffering logic, including handling of whitespace-only chunks and session resets.

web/src/pages/acp-console · high confidence

The Quickstart web UI now correctly retains values you have typed into channel configuration fields when you switch between creating a new channel and reusing an existing one. Previously, changing the channel mode or type could discard your input; the new \ChannelAddForm\ and \channel-fields\ logic ensures that user-edited values are preserved and merged with schema-defined defaults, preventing accidental data loss during setup.

web/src/pages/quickstart · high confidence

Added fuzz testing harnesses for command validation and input parsing; Added health check component tracking tests; Added live integration tests for provider capabilities and authentication; Added manual test suites for Telegram integration, Docker configuration, and quickstart workflows; Added performance benchmarks for agent hot paths; Added system-level tests for first-run setup, full-stack agent orchestration, and multi-agent migration; Added test coverage for Lark approval actions, MCP scope enforcement, and reply pacing; Added test fixtures for SD-JWT verification and MCP server simulation; Added test to enforce strict webview capability security policies; Added tests for A2A protocol conformance and LAN peer discovery via mDNS; Added tests for config migration, comment writing, and security policies; End-to-end tests for plugin channel activation, scoped secrets, and egress boundaries; Expanded component test coverage for CLI, config, and ACP behavior; Expanded integration test coverage for agent, memory, and channel subsystems; Expanded integration tests for runtime security, reliability, and relay connectivity; New architecture gates enforce security, localization, and release invariants; New end-to-end tests for channel plugin activation and egress security; New test support library for agent integration testing.

This release adds three new application binaries to the workspace: a Tauri-based desktop companion app (zeroclaw-desktop) that provides a system tray interface, a new interactive TUI configuration manager (zerocode) built with ratatui, and a standalone blind relay service (zerorelay) for secure mTLS tunneling. These additions bring in new dependencies including Tauri 2.0, ratatui 0.30, and tokio-tungstenite 0.29, while also updating the Rust edition to 2024 across the API layer.

(dependencies) · high confidence

Added AGENTS.md documentation outlining the scope, dependencies, and extension points for the zeroclaw-plugins crate, which serves as the WASM plugin host handling discovery, signature verification, and execution bridging. Also added a symlink to the shared WIT definitions directory to align with the WIT target architecture.

crates/zeroclaw-plugins · high confidence

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

• CAI 54 → 70 (+16.8)
• Rubric changed (rubric-2026.08.15 → rubric-2026.09.15) — scores are not directly comparable.

• Code Health 89 → 79 (-10.2)
• Architecture 69 → 99 (+30.4)
• Maturity 87 → 84 (-3.2)
• Readiness 39 → 89 (+50.0)
• Security 56 → 79 (+24.0)
• Domain Modelling 100 (new)
• Event Sourcing 100 (new)
• Accessibility 56 (new)

• Change coupling: AgentChat.tsx ↔ Integrations.tsx (web/src/pages/AgentChat.tsx)
• Change coupling: App.tsx ↔ Integrations.tsx (web/src/App.tsx)
• Change coupling: App.tsx ↔ Sidebar.tsx (web/src/App.tsx)
• Change coupling: Config.tsx ↔ Logs.tsx (web/src/pages/Config.tsx)
• Change coupling: Cron.tsx ↔ Tools.tsx (web/src/pages/Cron.tsx)
• Change coupling: Dashboard.tsx ↔ Integrations.tsx (web/src/pages/Dashboard.tsx)
• Change coupling: FieldForm.tsx ↔ i18n.ts (web/src/components/sections/FieldForm.tsx)
• Change coupling: Header.tsx ↔ Integrations.tsx (web/src/components/layout/Header.tsx)
• Change coupling: Header.tsx ↔ i18n.ts (web/src/components/layout/Header.tsx)
• Change coupling: Integrations.tsx ↔ Logs.tsx (web/src/pages/Integrations.tsx)
• Dimension evaluation failed
• High CVE: [GHSA redacted] (web/package-lock.json)
• High CVE: [GHSA redacted] (Cargo.lock)
• High CVE: [GHSA redacted] (web/package-lock.json)
• High CVE: [GHSA redacted] (web/package-lock.json)
• High CVE: [GHSA redacted] (web/package-lock.json)
• High CVE: [GHSA redacted] (web/package-lock.json)
• High IaC: DS-0002 (demo/Dockerfile)
• High IaC: DS-0029 (Dockerfile)
• High IaC: DS-0029 (Dockerfile)
• …and 81 more

• A2aHttpClient::send_message (cognitive 16) (crates/zeroclaw-tools/src/a2a_client.rs)
• AcpServer::handle_session_load (cognitive 25) (crates/zeroclaw-channels/src/orchestrator/acp_server.rs)
• AcpServer::handle_session_load (cyclomatic 20) (crates/zeroclaw-channels/src/orchestrator/acp_server.rs)
• AcpServer::handle_session_prompt (cognitive 45) (crates/zeroclaw-channels/src/orchestrator/acp_server.rs)
• AcpServer::handle_session_prompt (cyclomatic 30) (crates/zeroclaw-channels/src/orchestrator/acp_server.rs)
• AcpServer::materialize_prompt (cognitive 49) (crates/zeroclaw-channels/src/orchestrator/acp_server.rs)
• AcpServer::materialize_prompt (cyclomatic 18) (crates/zeroclaw-channels/src/orchestrator/acp_server.rs)
• AcpSessionStore::load_messages (cognitive 21) (crates/zeroclaw-infra/src/acp_session_store.rs)
• Agent::from_config_with_session_cwd_and_mcp_approval_mode (cognitive 24) (crates/zeroclaw-runtime/src/agent/agent.rs)
• Agent::from_config_with_session_cwd_and_mcp_approval_mode (cyclomatic 18) (crates/zeroclaw-runtime/src/agent/agent.rs)
• Agent::replay_loop_messages (cognitive 26) (crates/zeroclaw-runtime/src/agent/agent.rs)
• Agent::turn (cognitive 19) (crates/zeroclaw-runtime/src/agent/agent.rs)
• Agent::turn (cyclomatic 17) (crates/zeroclaw-runtime/src/agent/agent.rs)
• Agent::turn_streamed_with_steering_state (cognitive 86) (crates/zeroclaw-runtime/src/agent/agent.rs)
• Agent::turn_streamed_with_steering_state (cyclomatic 37) (crates/zeroclaw-runtime/src/agent/agent.rs)
• AgentSidebar::draw_session_rows (cognitive 25) (apps/zerocode/src/agent_sidebar.rs)
• Ambiguous distinction between send and send_final. It is unclear if send_final is a specific type of send (e.g., finalizing a draft) or if it is a deprecated/alternative method. The naming suggests a lifecycle difference that isn't immediately obvious from the signatures.
• Ambiguous intent for collection retrieval. variants() implies getting sub-types or variations of a single action, while all() implies getting the full list of all actions. However, in the context of keymaps, these likely serve similar purposes (iterating over available actions), creating confusion about whether one is a subset of the other or if they are interchangeable in different contexts.
• AnthropicModelProvider::convert_messages (cognitive 55) (crates/zeroclaw-providers/src/anthropic.rs)
• AnthropicModelProvider::convert_messages (cyclomatic 23) (crates/zeroclaw-providers/src/anthropic.rs)
• …and 3422 more

• 300 commits — 156 feature/other, 144 fixes

• crates/zeroclaw-runtime — 86 commits
• crates/zeroclaw-channels — 36 commits
• crates/zeroclaw-providers — 23 commits
• docs/book — 20 commits
• .github/workflows — 19 commits
• crates/zeroclaw-config — 19 commits
• apps/zerocode — 18 commits
• crates/zeroclaw-tools — 12 commits
• (root) — 10 commits
• crates/zeroclaw-plugins — 9 commits
• crates/zeroclaw-gateway — 7 commits
• web/src — 4 commits
• .claude/skills — 3 commits
• apps/zerorelay — 3 commits
• crates/zeroclaw-eval — 3 commits
• crates/zeroclaw-hardware — 3 commits
• scripts/ci — 3 commits
• scripts/release — 3 commits
• crates/zeroclaw-api — 2 commits
• crates/zeroclaw-log — 2 commits

• fix: fix(acp): persist failed and cancelled turn transcripts (#9378)
• fix: fix(agent): cap the no-progress loop detector at Block (#10503)
• fix: fix(anthropic): keep the rolling cache breakpoint when the last message ends with an image (#10895)
• fix: fix(approval): always_ask survives Full autonomy (#9724)
• fix: fix(browser): make full browser automation opt-in, separate from browser_open (#9830)
• fix: fix(channels): alias-aware sender scope keys and lane regressions (#10899)
• fix: fix(channels): create Edge TTS artifact with owner-only permissions (#10449)
• fix: fix(channels): explain permanently dropped voice messages to the sender (#10620)
• fix: fix(channels): implement is_direct_message for WhatsApp Web (#10266)
• fix: fix(channels): include weekday in per-turn context preamble (#10856)
• fix: fix(channels): keep system notices and the Matrix approval prompt out of TTS (#10827)
• fix: fix(channels): read interrupt_on_new_message from any configured alias (#10239)
• fix: fix(channels): require sender authorization for Bluesky and Reddit (#9428)
• fix: fix(channels): require sender authorization for LINE group messages (#9427)
• fix: fix(channels): route every outbound HTTP client through the runtime proxy (#10748)
• fix: fix(channels): use length-prefixed interruption scope keys to prevent boundary collisions (#10948) (#10958)
• fix: fix(channels): voice replies opening with an expressive audio tag (#10733)
• fix: fix(channels/matrix): report real duration on outbound voice notes (#10627)
• fix: fix(channels/qq): probe the bot identity in the health check (#10798)
• fix: fix(channels/telegram): resolve voice peers from sender identity (#10942)
• …and 280 more

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

zeroclaw-labs/zeroclaw 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.