herdrdev/herdr

Herdr is a terminal workspace manager and client that orchestrates AI agent sessions across local and remote environments. It provides a structured API and UI for managing workspaces, tabs, and panes while integrating with a wide range of AI coding agents to track their state and sessions. The system supports thin-client SSH connections, persistent session recovery, and extensible plugin architectures, all built on a stable wire protocol for reliable terminal communication.

The Devin integration now includes platform-specific hook scripts (PowerShell for Windows, shell/Python for Unix) that automatically report agent session IDs to the Herdr pane. These scripts detect the active Devin session by matching the project directory against the output of \devin list\, ensuring session tracking works correctly even when the session ID is not explicitly provided in the hook input.

src/integration/assets/cursor, src/integration/assets/devin · high confidence

This update introduces a new Zig binding for GTK layer-shell in the \gtk4-layer-shell\ package, enabling proper window layering, anchoring, and keyboard mode configuration for Wayland compositors. It also adds a new \wuffs\ package that provides native Zig bindings for the Wuffs image library, allowing the application to decode PNG and JPEG images and perform pixel format conversions (such as RGB to RGBA) and alpha compositing, with a configurable maximum image size limit to prevent memory overflow.

vendor/libghostty-vt/pkg/gtk4-layer-shell, vendor/libghostty-vt/pkg/wuffs · high confidence

New shell and PowerShell scripts have been added to the Copilot integration to report agent session start events to the Herdr pane. These hooks intercept input, parse session identifiers, and send a \pane.report\_agent\_session\ RPC message via Unix socket, enabling session tracking for GitHub Copilot interactions.

src/integration/assets/copilot · high confidence

Introduces a new Nix flake package (nix/package.nix) that builds the Herdr terminal workspace manager. The package correctly bundles necessary source files including the API schema, portable-pty vendor code, and skill documentation, while configuring the Rust build with specific Zig and libghostty-vt dependencies for both Linux and Darwin platforms.

nix · high confidence

Introduces the \herdr-agent-state.ts\ script for the OMP integration, which manages the lifecycle and state reporting of the OMP agent to the Herdr host. This includes connecting via Unix or Windows named pipes, queuing and retrying state updates (working, blocked, idle) with debouncing, and correctly identifying and ignoring nested OMP sessions to prevent duplicate reports. It also tracks and reports the current agent session ID and path to ensure state continuity across reloads and restarts.

src/integration/assets/omp · high confidence

New shell (herdr-agent-state.sh) and PowerShell (herdr-agent-state.ps1) scripts are installed in the Qoder CLI integration assets to automatically report agent sessions to the Herdr platform. These scripts detect active sessions via environment variables and invoke the herdr CLI to send session details, enabling session tracking for Qoder CLI users.

src/integration/assets/qodercli · high confidence

Added PowerShell and shell scripts in the Qwen integration assets that detect agent sessions and report them to the Herdr platform. These scripts intercept session events (such as startup, resume, clear, compact, or branch) and forward session IDs and metadata to the Herdr CLI, enabling session tracking for Qwen-based interactions.

src/integration/assets/droid, src/integration/assets/qwen · high confidence

The Letta integration now includes platform-specific shell scripts (PowerShell for Windows, POSIX shell for Unix) that detect when a new session starts or an existing one resumes. These hooks silently report session details to the Herdr backend via the \herdr pane report-agent-session\ command, enabling accurate tracking of agent activity without interfering with the user's prompt output.

src/integration/assets/letta · high confidence

Users can now integrate the MastraCode agent with the Herdr platform on both Windows and Unix-like systems. This change introduces platform-specific hook scripts (PowerShell for Windows, shell/Python for Unix) that detect agent states (session, working, idle, blocked) and report them to the Herdr daemon via the local socket or CLI, enabling real-time status tracking for MastraCode sessions.

src/integration/assets/mastracode · high confidence

Introduced a new local Windows input gauntlet in \scripts/windows\_input\ to automate the qualification of keyboard, mouse, and clipboard input behaviors on Windows. This infrastructure uses PowerShell 7 scripts and a C\# native adapter to inject real scan-code gestures into Windows Terminal and capture the resulting console records or VT sequences. It validates input across multiple modes (native, legacy, modifyOtherKeys, Kitty) and paths (direct host, Herdr client, Herdr remote), including specific checks for clipboard image pasting and mixed clipboard content. The suite generates a detailed report with verdicts for each test case, allowing developers to verify input handling without manual intervention.

_scripts/windows\input · high confidence

The workspace now exposes structured agent information for individual panes and aggregates their states to determine the overall workspace status. A new \PaneDetail\ struct provides per-pane data including the agent kind label, current state, and metadata tokens, allowing the UI to display specific agent names and statuses in the sidebar. The \Workspace\ type now calculates an \aggregate\_state\ that prioritizes unattended or blocked agent states (e.g., an idle, unseen pane takes precedence over a working one), ensuring the interface reflects the most critical agent activity across all tabs.

src/workspace · high confidence

Users can now customize the information displayed in the sidebar for both agents and spaces. This change introduces a new token system that allows configuration of metadata such as state, machine, workspace, branch, and git status, along with conditional hiding of tokens and custom styling for different values.

src/ui/sidebar · high confidence

The \crates/ghostty-vt\ crate has been extracted from the monolith into its own workspace crate, providing a dedicated build system (build.rs) to compile the vendored Zig-based libghostty-vt library and exposing Rust bindings for terminal operations, Kitty graphics, and rendering. This change introduces native image source support on Linux, allowing the terminal to retain offscreen Kitty images as kernel Copy-on-Write snapshots instead of resending them on scroll, which improves performance and reduces memory usage. The crate also includes comprehensive tests for PNG forwarding, native image retention, and file-based graphics handling.

crates/ghostty-vt · high confidence

A new extension has been added to provide autocomplete suggestions for GitHub issues and pull requests within the input editor. Users can trigger suggestions by typing \@issue\ or \@pr\ (with optional tokens), which will display open issues and recent PRs from the current repository. The extension caches data locally for immediate display, refreshes in the background, and supports fetching specific items on demand, inserting the reference format (e.g., \owner/repo\#123\) upon selection.

.pi/extensions · high confidence

A new integration asset for the Hermes agent has been added, consisting of a Python module and a plugin manifest. This plugin registers hooks to detect session lifecycle events (startup, reset, and resume) and reports the agent session identity to the Herdr platform, enabling resumable session tracking for interactive platforms like CLI and TUI.

src/integration/assets/hermes · high confidence

The repository is initialized with core documentation and configuration files, including a detailed CONTRIBUTING.md that enforces a strict policy against unsolicited pull requests from unapproved contributors. A new build.rs script warns external contributors to read this policy, and a symlinked CLAUDE.md points to AGENTS.md for AI agent guidance. The project also adds Nix flake support for development and packaging, a rust-toolchain.toml pinning the toolchain to version 1.96.1, and a .gitattributes file to standardize line endings.

(repo-wide) · high confidence

The application now features a complete terminal-based user interface built on ratatui. This includes a multi-pane workspace system with configurable borders, gaps, and scrollbars, a sidebar for managing workspaces and agent panels, and a tab surface for rendering terminal content. The UI also introduces an onboarding flow, a release notes modal, and visual feedback for clipboard actions.

src/ui · high confidence

This change adds the formal JSON schema definitions for the Herdr API, establishing the contract for client-server communication. It defines the request and response structures, including methods for managing workspaces, tabs, panes, and agents, as well as event subscriptions for real-time updates. The schema also covers plugin management, integration states, and server capabilities, providing a structured foundation for API consumers to interact with the terminal environment.

src/api/schema · high confidence

Adds the core Unix PTY actor implementation (src/pty/actor/unix.rs) which manages terminal I/O, user input queuing, and resize events. This new module provides the underlying mechanism for handling pseudo-terminal operations on Unix systems, including buffering writes, managing actor state, and coordinating with the terminal reader.

src/pty/actor · high confidence

Adds src/client/input/windows\_vti.rs, a new Windows-specific input module that reads from the console handle and routes events through a pump and handoff layer. The handoff logic implements backpressure handling to prevent blocking the console read loop when the client loop is busy, ensuring that raw VT reports and other input events are not lost during high-load or idle periods. It also includes diagnostic tracing capabilities for debugging input mapping issues on Windows.

src/client/input · high confidence

The agent panel now supports custom filtering and sorting of agent entries via the new \agent\_view\ module. Users can define view specifications that filter agents based on context (workspace, tab, pane) and state, and sort them by fields such as attention priority or state change sequence. This allows for a more organized and relevant view of active agents, particularly in complex workspaces with multiple tabs and panes.

src/app · high confidence

The client now supports a direct terminal attach mode that parses input locally (using a Ctrl+B prefix) to handle scrolling and mouse actions before forwarding them, improving responsiveness and compatibility with legacy terminals. Additionally, the client can now bridge local image files and clipboard images to remote sessions, allowing users to paste images from their local machine into remote panes via a configurable key combination or terminal drop events.

src/client · high confidence

This change adds the core infrastructure for the headless server mode, including the bootstrap entry point that initializes the API socket, Tokio runtime, and handoff import logic for seamless server restarts. It introduces client shell view management to handle focus transitions, tab topology, and shell location reconciliation for attached clients. The update also implements native graphics rendering via Kitty protocol support, refined retained surface patching for efficient terminal updates, and robust lifecycle handling for live handoffs between server processes.

src/server/headless · high confidence

The application now supports resuming agent sessions across restarts by persisting session references and validating resume arguments to ensure safe shell execution. Additionally, a new agent view evaluation system allows filtering and sorting agent entries by built-in fields (status, workspace, tab, pane, agent, seen state) and custom tokens, enabling more precise management of agent states within the UI.

src · high confidence

This change adds the plugin v1 system, allowing users to install and enable plugins defined by a \herdr-plugin.toml\ manifest. The system supports plugin-defined actions, startup hooks, and event hooks that trigger external commands, as well as plugin-managed panes (popup, overlay, split, or tab) with configurable placement and sizing. Plugins receive a structured invocation context (workspace, tab, pane, and UI state) and environment variables (including plugin root, config/state directories, and the host binary path) when their commands run. The API exposes endpoints to link, list, enable, disable, and unlink plugins, invoke actions, and manage plugin pane lifecycles.

src/app/api/plugins · high confidence

The application now supports connecting to remote hosts via SSH using a new thin-client architecture. Users can launch a remote session with the \--remote\ flag, which establishes an SSH stdio bridge to a remote Herdr server, allowing the local client to act as a display terminal. The system automatically handles remote server installation, protocol version compatibility checks, and server restarts (including live handoffs) when updates are required. Additionally, users can save SSH connection profiles to reuse them later without re-authenticating or re-discovering the remote setup, with connection metadata cached for faster subsequent launches.

src/remote · high confidence

The application now exposes a local socket API that allows external tools to manage workspaces, tabs, panes, and agents via newline-delimited JSON. This includes a dedicated client library for connecting to the socket, an event hub for subscribing to live state changes (such as workspace or pane updates), and a server implementation that routes requests and manages persistent connections. Users can now script interactions with the terminal environment, query runtime status, and receive real-time notifications through this new interface.

src/api · high confidence

The client now manages remote connections through a new activation lifecycle in \src/client/endpoint/activation\, which coordinates surface handoffs, focus changes, and resize events between endpoints while ensuring coherent presentation state. A dedicated health check module (\src/client/endpoint/health\) monitors connection liveness using configurable heartbeat intervals and timeouts. Additionally, the client now caches SSH machine metadata (OS and executable path) in \src/client/endpoint/ssh\_metadata\ to optimize connection setup, and introduces a structured \EndpointCatalog\ in \src/client/endpoint/catalog\ for managing saved SSH profiles and selections.

src/client/endpoint · high confidence

The agent detection system in \src/detect\ has been refactored to use a new manifest-based engine. This change introduces \manifest.rs\ and \manifest\_update.rs\, which define a structured format for agent detection rules (including regex, contains, and region matching) and support remote manifest updates from a catalog. The \mod.rs\ file now exposes a comprehensive list of 24 supported agents (such as Devin, Kilo, Maki, Muse, and Qwen) and replaces previous ad-hoc detection logic with this configurable, extensible framework, allowing for easier addition and maintenance of agent-specific detection patterns.

src/detect · high confidence

A new stable wire protocol (Generation 1) is added for client-owned shells (Local, SSH, and Cloud), decoupling them from the private binary protocol used by same-install CLI and direct-terminal paths. This contract defines a handshake with capability negotiation for optional optimizations like surface reuse, surface delta, and scroll-aware patches, and includes dedicated message types for agent view projections and agent completions. The implementation includes the endpoint definitions, a bounded decoder for the surface-delta codec, and logic for rendering ANSI diffs with synchronized output to prevent cursor artifacts.

src/protocol · high confidence

The agent detection system now uses a manifest-based engine where detection logic is defined via declarative rules (specifying states, priority, and content/regex matching) rather than hardcoded patterns. This allows for more flexible and maintainable detection of agent states (working, idle, blocked, unknown) across different agents like Codex and Claude. The change includes a new test suite validating rule semantics, priority handling, and the loading of remote manifests that can override local or bundled configurations.

src/detect/manifest · high confidence

The Grok integration now natively reports agent session start events to the Herdr platform on both Windows and Unix systems. This is achieved by adding platform-specific hook scripts (PowerShell for Windows, shell/Python for Unix) that intercept session-start payloads, extract the session ID, and send a structured report via the Herdr socket. This enables accurate session tracking and history for Grok conversations without requiring external tooling.

src/integration/assets/grok · high confidence

The API now exposes new endpoints to manage agent views (setting and clearing plugin-driven or builtin views), apply and export workspace layouts programmatically, and capture full session snapshots for state preservation. These additions allow external tools to control agent UI presentation, orchestrate complex terminal layouts, and persist or restore application state via the API.

src/app/api · high confidence

The CLI now exposes several new command groups to manage the application's core capabilities. Users can interact with AI agents via \herdr agent\ (including \explain\, \start\, \wait\, and \attach\), manage third-party AI providers through \herdr integration\ (install, uninstall, and status for targets like Claude, Codex, Copilot, Devin, Grok, and others), and configure remote connections using \herdr machine\ (add, list, status, and reconnect for SSH hosts). Additionally, \herdr api\ allows users to view or export the API schema and capture session snapshots, while \herdr completion\ provides shell completion scripts for bash, zsh, fish, elvish, and powershell.

src/cli · high confidence

Added several new Python scripts to the repository: \scripts/changelog.py\ automates changelog-backed releases by parsing and updating version sections; \scripts/config\_reference\_check.py\ validates the website's config reference documentation against the Rust source model to ensure consistency; \scripts/capture\_agent\_screen.py\ captures pane screen reads for agent detection fixtures; and \scripts/vendor\_libghostty\_vt.py\ manages vendoring of the libghostty-vt source distribution. Additionally, \vendor/libghostty-vt/src/terminal/snapshot/verify-kaitai.py\ was added to verify snapshot fixtures using Kaitai schemas.

python · high confidence

The integration module now supports installing, uninstalling, and reporting lifecycle state for a wide range of AI agents, including Claude, Codex, Copilot, Devin, Droid, Grok, Hermes, Kilo, Kimi, Letta, MastraCode, OMP, OpenCode, Pi, Qoder, and Qwen. This includes platform-specific hook scripts (PowerShell for Windows, shell scripts for Unix, and JavaScript for Kilo) that report session and state changes to the client, as well as configuration management for agents like Claude and Kimi that require specific settings edits.

src/integration · high confidence

The application introduces a new configuration architecture in src/config that significantly expands user customization and improves configuration reliability. Users can now define complex sidebar token styles with conditional rules (matching by equals, contains, starts\_with, or numeric thresholds) to visually distinguish workspace elements. The tab bar supports dynamic right-side entries including zoom, hostname, datetime, text, and executable commands with configurable intervals. Window titles are now fully customizable via a template system supporting tokens like hostname, workspace, tab, and pane. The system also adds granular control over notification sounds per agent, per-mode theme overrides for auto-switching between light and dark appearances, and robust diagnostics that report unknown keys, invalid sections, and file format issues (such as UTF-8 BOM handling) to help users troubleshoot configuration errors.

src/config · high confidence

The distribution folder now includes the installer scripts (install.sh, install.ps1, install.cmd) and the agent guide (agent-guide.md) for Herdr v0.9.1. The installers fetch the latest release manifest from herdr.dev, verify the binary's SHA-256 checksum, and place the executable in the user's local bin directory. The agent guide provides a concept model, setup instructions, and troubleshooting recipes for AI coding agents to understand and control Herdr.

distribution · high confidence

The \src/input\ module has been restructured into dedicated components: \encode.rs\ now handles the translation of key and mouse events into terminal protocols (including Kitty CSI-u sequences and SGR mouse reports), \keybindings.rs\ manages the dispatch logic for direct and prefix key combinations, \keybind\_help.rs\ generates the help text for configured bindings, and \lease.rs\ tracks input lifecycle to prevent duplicate key events. This change provides a unified, protocol-aware input layer that correctly preserves physical key identity, handles Windows dead keys, and supports advanced reporting modes like Kitty's report-all-keys.

src/input · high confidence

The scripts directory now includes a comprehensive suite of automation tools: release.py and preview.py manage stable and preview release lifecycles, validation, and manifest generation; agent\_detection\_manifest\_check.py validates bundled and published agent detection manifests; package\_windows\_conpty.py and its PowerShell wrapper handle Windows ConPTY packaging and signature verification; capture\_keys.py and capture\_key\_matrix.py provide interactive terminal key sequence capture for testing; conventional\_commits.py enforces commit message standards; docs\_translation\_parity.py checks localized documentation structure; build\_vendored\_libghostty\_vt.sh and generate\_libghostty\_bindings.sh handle the libghostty-vt vendor build and Rust binding generation; and release\_perf\_case.sh runs performance benchmarks. These scripts collectively automate release promotion, Windows packaging, key capture for input testing, documentation parity, and build processes.

scripts · high confidence

The server now includes a dedicated client shell subsystem that manages thin-client connections, endpoint command routing, and graphics delivery. This introduces new modules for handling client handshakes and transport (\client\_transport\, \client\_accept\), a command dispatch layer with a strict allowlist of supported API methods (\client\_commands\), and a stateful shell topology that tracks workspace, tab, and pane focus per client (\client\_shell\, \clients\). It also adds specialized handlers for Kitty graphics scene collection (\client\_shell\_graphics\), clipboard image staging with secure file permissions (\clipboard\_image\), and server auto-detection/daemon spawning logic (\autodetect\).

src/server · high confidence

The application now automatically saves and restores your entire workspace layout, pane history, and plugin registry across restarts. Session data is persisted to JSON files in the data directory, with a versioned snapshot format (v3) that handles legacy migrations and prevents corruption from newer versions. A robust recovery system creates timestamped backups in \session-backups\ and \session-snapshots\ directories, ensuring that layout and history are preserved even if a save fails or the application crashes. The plugin registry is also persisted with file locking to prevent corruption during concurrent updates, and symlinks in the configuration directory are correctly resolved during writes to support stow-managed setups.

src/persist · high confidence

Added shell and PowerShell scripts for the Claude integration that detect when a Claude session starts and report the session ID, transcript path, and source to the host application via the \pane.report\_agent\_session\ method. The implementation filters out Cursor sessions, subagent events, and non-session hooks to ensure only native Claude session starts are reported.

src/integration/assets/claude · high confidence

The vendored libghostty-vt library now exposes several new capabilities for host applications. Word selection can be constrained by a cell budget via the new \ghostty\_terminal\_select\_word\_bounded\ API, preventing unbounded searches. A new \ghostty\_terminal\_clear\_screen\ function clears the visible screen and scrollback history while preserving the cursor's active soft-wrapped line, without sending escape sequences to the child process. Additionally, an experimental \GHOSTTY\_TERMINAL\_OPT\_KITTY\_IMAGE\_PRESERVE\_PNG\ option allows retaining encoded PNG data for images, and the \modifyOtherKeys\ mode 2 state is now queryable via \GHOSTTY\_TERMINAL\_DATA\_MODIFY\_OTHER\_KEYS\. Build stability for freestanding targets is also improved by fixing Wuffs libc stub exports.

vendor/patches/libghostty-vt · high confidence

A new Unix-specific backend for the PTY system has been introduced in src/pty/backend/unix.rs, implementing terminal spawning via the portable-pty library. This change enables native PTY support on Unix-like operating systems, allowing the application to create and manage pseudo-terminal sessions on these platforms.

src/pty/backend · high confidence

The \src/pty\ module has been restructured to introduce a new asynchronous I/O actor (\PtyIoActor\) and a dedicated backend layer. This change adds a new \actor.rs\ file that manages terminal input/output via a message-passing architecture, handling user input submission, resize events, and terminal responses. A new \backend.rs\ file provides platform-specific PTY spawning logic (using \portable\_pty\ on Windows), while \fd.rs\ adds low-level Unix file descriptor utilities for non-blocking I/O and wake pipes. This refactoring centralizes PTY file descriptor ownership and improves input handling reliability.

src/pty · high confidence

The client shell has been refactored to support a new architecture, introducing dedicated modules for handling keybindings, agent sidebar rendering, aggregate navigation across multiple endpoints, and frame composition. This change adds a new agent sidebar component that displays agent status and allows sorting by priority or spaces, and updates the shell's action handling to support new worktree and workspace operations. The refactoring also includes improvements to copy mode, context menus, and configuration management to better support multi-machine environments and stable client endpoint compatibility.

src/client/shell · high confidence

The terminal module now manages its own identity and lifecycle state independently of panes. A new \TerminalId\ provides a durable, server-owned identifier for each terminal, decoupling it from pane IDs. A dedicated \TerminalRuntime\ and \TerminalRuntimeRegistry\ handle the underlying PTY and rendering, while \TerminalState\ centralizes agent metadata, hook authority, and lifecycle tracking. This refactoring establishes a cleaner separation between the application's workspace/pane view and the server's terminal runtime, supporting features like agent session restoration and metadata reporting.

src/terminal · high confidence

The pane implementation has been reorganized into specific modules to enhance maintainability and enable new capabilities. Agent detection logic is now isolated in \agent\_detection.rs\, managing state transitions and idle confirmations. Input handling, including key and mouse event encoding, has been moved to \input.rs\. Terminal cursor behavior, including shape tracking and position settling, is now handled by \cursor.rs\. OSC color query parsing is managed in \osc.rs\, while Kitty keyboard protocol support is implemented in \kitty\_keyboard.rs\. Terminal state and core logic are consolidated in \terminal.rs\, with platform-specific fallbacks for Windows recent history in \windows\_recent\_fallback.rs\. Legacy XTGETTCAP query handling is addressed in \xtgettcap.rs\, and general pane state is defined in \state.rs\. This refactoring supports features like direct pane frame streaming, kitty graphics, and improved Windows pane behavior.

src/pane · high confidence

Worktree API requests (list, open, create, remove) are now handled asynchronously via a new deferred request system. This moves filesystem discovery and Git operations off the main thread to prevent UI blocking, introduces concurrency limits to manage pending checks, and adds validation to prevent duplicate operations on the same checkout path.

src/app/api/worktrees · high confidence

The repository now includes pre-commit and commit-msg hooks to enforce code quality and release discipline. The commit-msg hook validates that commit messages follow the conventional commits format using a Python script. The pre-commit hook ensures that changes to the skills/herdr/SKILL.md file are only staged alongside a corresponding version bump in Cargo.toml, preventing out-of-sync skill documentation during non-release commits, and also runs the linter before each commit.

.githooks · high confidence

The graphics subsystem has been replaced with an optimized native kitty rendering implementation. This change introduces a delivery cache that keeps offscreen images loaded rather than resending them on scroll, improving performance for scrolling applications. It also refines overlay behavior by cropping kitty images around overlays instead of hiding them entirely, and ensures that only kitty image placements overlapping overlays are hidden. The new architecture includes dedicated modules for managing graphics output and surface placements, supporting independent multi-client tab views and better management of multiple SSH machines from a single client.

_src/kitty\graphics · medium confidence

The vendored libghostty-vt library has been updated to a newer version that includes fixes for kitty graphics stream freezes and resize overflows, as well as performance improvements for terminal wake work. This update also introduces several new CI workflows for building and publishing Flatpak and Snap packages, alongside scripts for verifying macOS dylib integrity and managing translations. Additionally, new repository tooling has been added, including a Nushell command for branch code reviews, a skill for generating commit messages, and standardized configuration files for code formatting and editor settings.

vendor/libghostty-vt · high confidence

The Windows platform now protects integration configuration files from corruption during failed writes. When updating a config, the system creates a backup copy before truncating the original; if the write fails, the original content is preserved and the user is notified to resolve the backup state. This change also adds validation to reject updates on encrypted files or those with multiple hard links, ensuring data integrity.

src/platform/windows · high confidence

The workspace Git module now includes robust support for reading Git configuration files, handling worktree-specific settings, and managing file dependencies for caching. It rejects oversized Git ref files to prevent potential issues, supports worktree actions from bare repositories, and correctly derives repository names for embedded bare layouts. Additionally, it preserves linked worktree workspace labels and resolves Git branch names in reftable-based repositories, ensuring accurate status reporting across various Git workspace configurations.

src/workspace/git · high confidence

The OpenCode integration now provides more accurate session and state reporting. It correctly tracks child sessions to prevent their events from overwriting the root session's state, ensuring that permission prompts and questions are reported as 'blocked' without losing the main session context. The integration also handles both string and object forms of session status, serializes lifecycle reports to prevent race conditions, and properly manages session selection in the TUI with retry logic for initial detection.

src/integration/assets/opencode · high confidence

This update introduces platform-specific implementations to improve session reliability and data integrity. On Linux, the application now monitors host shutdown signals via D-Bus to preserve session layouts before termination, and ensures that configuration file replacements preserve ownership, ACLs, and extended attributes. On macOS, the server process now adopts the correct per-user Mach bootstrap context to prevent service disruptions. On Windows, private state files are created with strict security descriptors, and file replacements use atomic operations to prevent data loss. Additionally, a new SSH agent registry allows multiple clients to share a single agent socket, and a remote bridge liveness monitor automatically terminates idle connections to free resources.

src/platform · high confidence

The PI integration agent now reliably reports its working, blocked, and idle states to the host environment via a dedicated socket, ensuring that status updates are queued and delivered even during transient connection issues. It also tracks and reports the current agent session ID and path, allowing the system to maintain accurate context across session reloads and replacements. This change improves the visibility and stability of the PI agent's operational status within the integrated development environment.

src/integration/assets/pi · high confidence

The portable-pty library has been updated to version 0.9.0, bringing in fixes for Windows ConPTY handling and custom command keybindings. This update includes a bundled modern ConPTY implementation for Windows, improved rejection of malformed process environments, and support for serial port-based pseudo-terminals.

vendor/portable-pty · high confidence

This update patches the vendored portable-pty library to improve reliability on Windows. It bundles a modern, hash-verified ConPTY implementation to replace the system DLL, preventing unsafe DLL probing. It also fixes custom command execution by allowing raw shell text (unescaped) for Windows command tails, and hardens process environment handling by rejecting malformed registry entries (such as empty names or invalid UTF-16) before they reach the OS.

vendor/patches/portable-pty · high confidence

Added CLI integration tests for agent, pane, plugin, and session workflows; Added comprehensive test coverage for client shell interactions; Added headless server test suite for event fairness, graphics, and surface protocols; Added integration tests for agent state plugins on Windows; Added test fixtures for endpoint protocol and keyboard input parsing; Added test support infrastructure for integration testing; Added tests for subscription socket connection and event handling; Added unit tests for client terminal geometry, graphics profiles, and Windows input modes; Expanded integration test coverage for core server and client behaviors; Integration tests for robust config file writing; Removed herdr integration test suite.

This release updates the project to version 0.9.1 and introduces several significant dependency and structural changes. A new \ghostty-vt\ crate has been added to provide bindings to the vendored libghostty-vt, and the main Cargo.toml now includes this as a workspace member. The \portable-pty\ dependency has been vendored into \vendor/portable-pty\ and patched in the main manifest. New dependencies include \clap\ and \clap\_complete\ for shell completions, \bincode\ for serialization, \ctrlc\ for signal handling, and \schemars\ for schema generation. Platform-specific dependencies have been added: \zbus\ and \futures-util\ for Linux, and \widestring\, \wmi\, and \windows-sys\ for Windows. The license has been changed from AGPL-3.0-or-later to Apache-2.0.

(dependencies) · high confidence

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

• CAI 71 → 70 (-0.2)
• Rubric changed (rubric-2026.09.8 → rubric-2026.09.16) — scores are not directly comparable.

• Code Health 77 → 88 (+10.6)
• Architecture 98 → 88 (-10.3)
• Maturity 57 → 57 (+0.1)
• Readiness 83 → 81 (-2.2)
• Security 78 → 77 (-1.0)
• Event-Driven 100 → 100 (+0.0)
• Event Sourcing 100 → 100 (+0.0)
• Performance 85 (new)

• App::handle_pane_graphics_stream_direct (cognitive 21) (src/app/api/pane_graphics.rs)
• App::handle_pane_graphics_stream_direct (cyclomatic 19) (src/app/api/pane_graphics.rs)
• App::handle_worktree_open (cognitive 22) (src/app/api/worktrees.rs)
• App::handle_worktree_open (cyclomatic 17) (src/app/api/worktrees.rs)
• App::set_layer (cognitive 16) (src/app/api/pane_graphics.rs)
• Change coupling: persist.rs ↔ workspace.rs (src/persist.rs)
• ClassTooLong: Terminal (src/ghostty/mod.rs)
• ClientShellState::route_copy_search_prompt_key (cognitive 16) (src/client/shell/copy_mode.rs)
• Documentation: no installation or build instructions (README.md)
• Duplicated block (10 lines × 2) (src/persist/io.rs)
• Duplicated block (10–12 lines × 2) (src/client/shell/overlays.rs)
• Duplicated block (10–15 lines × 4) (src/integration/targets.rs)
• Duplicated block (11 lines × 2) (src/app/api/worktrees.rs)
• Duplicated block (11 lines × 2) (src/detect/mod.rs)
• Duplicated block (11 lines × 3) (src/integration/targets.rs)
• Duplicated block (12 lines × 2) (src/app/terminal_targets.rs)
• Duplicated block (12 lines × 2) (src/persist/io.rs)
• Duplicated block (13 lines × 2) (src/client/shell/endpoint_sidebar.rs)
• Duplicated block (14 lines × 2) (src/app/api/worktrees.rs)
• Duplicated block (14 lines × 2) (src/ghostty/mod.rs)
• …and 79 more

• ActiveSubscription::poll_batch (cognitive 16) (src/api/subscriptions.rs)
• App::finish_worktree_open (cognitive 21) (src/app/api/worktrees.rs)
• App::finish_worktree_open (cyclomatic 16) (src/app/api/worktrees.rs)
• AppState::update_terminal_state_with_completion_policy (cognitive 19) (src/app/actions.rs)
• AppState::update_terminal_state_with_completion_policy (cyclomatic 17) (src/app/actions.rs)
• Change coupling: agents.rs ↔ pane.rs (src/app/api/agents.rs)
• Change coupling: changelog.py ↔ update.rs (scripts/changelog.py)
• ClassTooLong: Terminal (crates/ghostty-vt/src/lib.rs)
• ClientShellState::cache_endpoint_snapshot_with_surface (cognitive 20) (src/client/shell/endpoints.rs)
• ClientShellState::cache_endpoint_snapshot_with_surface (cyclomatic 17) (src/client/shell/endpoints.rs)
• ClientShellState::explicit_link_regions (cognitive 18) (src/client/shell/link_hover.rs)
• ConsoleProbe.Read (cognitive 28) (scripts/windows_input/Native.cs)
• CursorPositionSettleState::observe (cognitive 27) (src/pane/cursor.rs)
• CursorPositionSettleState::observe (cyclomatic 22) (src/pane/cursor.rs)
• Decoder::decode (cognitive 31) (src/protocol/surface_reuse.rs)
• Decoder::decode (cyclomatic 18) (src/protocol/surface_reuse.rs)
• Desktop.DeadKeyChord (cognitive 19) (scripts/windows_input/Native.cs)
• Desktop.SetEmptyClipboardImage (cognitive 18) (scripts/windows_input/Native.cs)
• Desktop.SetEmptyClipboardImage (cyclomatic 16) (scripts/windows_input/Native.cs)
• Duplicated block (10 lines × 2) (src/persist/restore.rs)
• …and 162 more

• 178 commits — 52 feature/other, 126 fixes

• src/client — 49 commits
• docs/next — 19 commits
• src/server — 14 commits
• src/detect — 9 commits
• src/platform — 9 commits
• src/integration — 7 commits
• scripts/windows_input — 6 commits
• src/pane — 6 commits
• .github/workflows — 5 commits
• src/app — 5 commits
• (root) — 4 commits
• distribution/agent-detection — 4 commits
• src/api — 4 commits
• src/input — 4 commits
• .github/APPROVED_CONTRIBUTORS — 3 commits
• docs/preview — 3 commits
• scripts/docs — 3 commits
• crates/ghostty-vt — 2 commits
• src/cli — 2 commits
• src/kitty_graphics — 2 commits

• fix: fix(client): re-assert host mouse modes after a terminal reconnect (#4079)
• fix: fix(input): accept parameterized CSI-tilde F1-F4 keys (#4067)
• fix: fix(input): preserve super-modified pane keys (#4044)
• fix: fix(linux): avoid blocking proc reads for wsl agents (#2179)
• fix: fix(linux): bound the foreground process-tree scan (#3674)
• fix: fix(remote): resolve ssh host aliases from git bash on windows (#4054)
• fix: fix(server): transfer handoff descriptors in batches (#3411)
• fix: fix(ui): keep muted sidebar and tab labels readable (#4062)
• fix: fix(windows): avoid lossy native Win32 input mode (#4133)
• fix: fix(windows): batch input trace diagnostics (#4146)
• fix: fix(windows): disable host mouse reporting on terminal restore (#4055)
• fix: fix(windows): honor default_shell in login shell mode (#4060)
• fix: fix(windows): keep powershell cwd reporting in login mode (#4065)
• fix: fix(windows): normalize pane launch cwd casing (#4199)
• fix: fix(windows): prefer VT input for SSH clients (#4148)
• fix: fix(windows): prefer pwsh for the default pane shell (#4297)
• fix: fix(windows): preserve VT input during mouse refresh (#4257)
• fix: fix(windows): preserve mouse capture during refresh (#4319)
• fix: fix(windows): preserve sgr mouse encoding after native capture (#4195)
• fix: fix(windows): read agent command lines without PROCESS_VM_READ (#4708)
• …and 158 more

• Unchanged — 0 containers · 1 contexts · 0 edges

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

herdrdev/herdr 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.