esengine/DeepSeek-Reasonix

Reasonix is a cross-platform AI coding agent platform that manages autonomous agent sessions, tool execution, and multi-modal provider integrations. It provides a unified CLI and desktop interface for managing skills, plugins, and remote SSH workspaces, while enforcing strict security, sandboxing, and safety guardrails. The system also supports headless bot interactions and community-driven plugin distribution.

The agent now supports the ACP protocol, enabling structured communication with host applications. This change introduces the \internal/acp\ package, which includes a JSON-RPC service (\service.go\) to manage sessions and a dispatch layer (\dispatch.go\) that translates the agent's internal event stream into ACP session updates, tool calls, and approval requests. This allows external clients to interact with the agent's planning, tool execution, and reasoning processes in real-time.

reasonix · high confidence

The Anthropic provider is introduced as a new implementation of the provider.Message abstraction, enabling Claude model usage via the /v1/messages endpoint. The provider supports vision (embedding attached images as base64 blocks), extended thinking (replaying signed reasoning blocks on subsequent turns), and server-side web search tool integration. It also handles compatibility with DeepSeek's Anthropic-compatible endpoint, including unsigned thinking blocks and effort mapping. The implementation includes a custom HTTP client, SSE stream handling with idle timeouts, and structural handling of tool results and image blocks.

internal/provider/anthropic · high confidence

The CLI now supports Simplified and Traditional Chinese interfaces. Users can switch their preferred language using the new /language command, which allows selecting from English, Simplified Chinese, and Traditional Chinese. The translation catalogue includes all user-facing strings for the CLI, including the welcome screen, chat REPL, tool approval prompts, and status lines. A test suite ensures that all translation files remain in sync with the English baseline, preventing missing or mismatched strings.

internal/i18n · high confidence

The plugin package now supports importing and running plugins built for Claude. The system parses \.claude-plugin/plugin.json\ and \.codex-plugin/plugin.json\ manifests, mapping their hooks, skills, and MCP servers into the internal model. A new Manifest v1 format is introduced, allowing plugins to declare agents, prompts, themes, and runtime processes in a structured \contributes\ block. To ensure stability, the legacy native manifest parser is pinned to preserve existing behavior, and the plugin state file is protected against concurrent writes and file-system sharing violations.

internal/pluginpkg · high confidence

A new Feishu bot adapter is introduced, supporting both WebSocket and Webhook connection modes. The adapter handles inbound message parsing, @mention gating, and interactive card actions. For outbound media, the implementation enforces strict file confinement: outbound files are read from configured root directories using \os.OpenRoot\ to prevent path traversal and symlink escape attacks. It also requires a verification token for webhook endpoints and enforces a 25 MB aggregate limit on outbound media payloads.

internal/bot/feishu · high confidence

The serve HTTP interface now supports three authentication modes: none (default), token-based, and password-based login. Users can secure their instance by setting a shared token or a password, with rate-limiting and cookie-based session management. Additionally, a new provider setup page allows remote hosts to configure missing API keys, enabling seamless provider activation without manual file editing.

internal/serve · high confidence

Added a new LSP client implementation in internal/lsp that enables read-only code-intelligence tools (definition, references, hover, and diagnostics) for multiple languages (Go, Rust, TypeScript, Python, C++, C\#, Java, Ruby, PHP, Lua, Bash, Zig, Kotlin, Swift, Haskell). The implementation includes a JSON-RPC 2.0 connection handler with a 64 MiB frame cap to prevent OOM on corrupt Content-Length headers, and a manager that lazily spawns external language servers (e.g., gopls, rust-analyzer) on demand. Tests verify frame capping, bidirectional JSON-RPC, and integration with real language servers.

internal/lsp · high confidence

Users can now interact with the QQ platform through a new bot adapter. This change introduces the QQ bot gateway implementation, including WebSocket connection management, access token handling, and message routing for C2C, group, and guild channels. It also includes tests for the adapter's lifecycle and message parsing, ensuring reliable connectivity and proper cleanup of gateway connections.

internal/bot/qq · high confidence

Users can now connect a WeChat account to the bot system. The new Weixin adapter handles login via QR code scanning, polls for incoming messages, and sends replies. The change includes the core adapter logic, login/session management, and associated tests.

internal/bot/weixin · high confidence

The boot process now supports an ablation mechanism that allows individual Reasonix subsystems (evidence, planner, subagent, retrieval, and compaction) to be disabled for benchmarking purposes. This includes a new \ablation\ package to parse and manage these configurations, and integration within the \boot\ package to conditionally exclude specific tool surfaces based on the ablation set. Tests verify that the zero value represents the full control arm and that specific modules can be disabled without affecting others.

internal/boot · high confidence

The code and file preview components now support bounded regex search and display line numbers. A new \LineNumberCode\ component integrates a bounded regex search feature that respects pattern length, source size, and timeout limits to prevent performance issues. This includes a dedicated worker for regex operations and client-side logic to manage search state, highlighting matches, and handling errors gracefully. Additionally, the diff viewer (\HljsDiff\) and code viewer (\HljsCode\) have been updated to support these new capabilities, with the diff viewer also incorporating virtualization for better performance with large files.

desktop/frontend/src/components/editors · high confidence

The application now ships a built-in 'reasonix-guide' skill that provides a self-diagnostics and troubleshooting reference for capabilities, commands, hooks, MCP servers, and plugin packages. This embedded content is loaded at startup and can be invoked via the \/reasonix-guide\ slash command or the 'Diagnostics' settings panel. The guide includes static capability reports, configuration priority rules, and symptom-to-fix tables for debugging missing or shadowed skills, commands, hooks, and MCP connections.

internal/skill/builtincontent · high confidence

The application now delivers native desktop notifications on macOS (via AppleScript), Linux (via notify-send), and Windows (via the go-toast library), with a no-op fallback for other platforms. A new notification sink routes specific event types—turn completion, approval requests, and ask requests—to the platform sender, while explicitly suppressing notifications for protocol recovery events. Users will see system-level alerts for these configured events, with behavior controlled by the NotificationsConfig settings.

internal/notify · high confidence

A new internal/filelock package provides bounded, cross-process advisory file locks. It implements Acquire and TryAcquire functions that serialize access to files on both Unix (using flock) and Windows (using LockFileEx), with a local in-memory registry to coordinate goroutines within the same process. Tests verify that acquisition respects context deadlines and that the internal registry is reclaimed after release.

internal/filelock · high confidence

Introduced the \cmd/e2ebench\ command-line tool, which provides two primary capabilities for evaluating the model. First, it runs a committed suite of end-to-end tasks against a real provider, emitting a markdown and JSON report with accuracy, cache-hit rate, token usage, and cost metrics. Second, in 'diff' mode, it generates unit tests for a pull request's changes, grades them against the repository's existing tests, and reports on coverage, mutation testing, and build health. The tool supports configurable prompt profiles (baseline and delivery), ablation arms, and retry budgets for the stochastic agent. Tests cover profile normalization, report rendering, and test execution logic.

cmd/e2ebench · high confidence

The application now includes an embedded corpus of official product documentation and structured release notes, enabling local search for version-matched content. This adds a new \/docs\ slash command that retrieves from the bundled Markdown sources and release history, with support for English and Chinese locales. The change introduces the \internal/productdocs\ package, which handles loading, indexing, and searching the embedded content, and includes tests to verify deterministic catalog loading and manifest consistency.

internal/productdocs · high confidence

A new command-line tool has been added to generate extension protocol artifacts. The tool supports a 'check' mode to verify that generated artifacts are up to date without writing them, or a write mode to update the artifacts in the repository root.

cmd/extension-protocol-gen · high confidence

The internal/fileutil/encoding package now detects and converts file encodings including UTF-8 (with/without BOM), UTF-16 (LE/BE, with/without BOM), and GB18030. This ensures that CJK Windows files and other non-UTF-8 text files are correctly read and edited without byte mangling.

internal/fileutil/encoding · high confidence

The internal/stats package now implements the backend for the per-day usage statistics panel. New files, query.go and record.go, define the data structures (RangeStats, DailyTokens, ModelUsage, ProviderUsage) and the logic to append daily JSONL records and aggregate them by day, model, and provider. The implementation includes a Query method that filters by source and date range, handles legacy request accounting, and computes cache hit/miss totals. A new test file, stats\_test.go, validates the recorder's behavior, including request counting, turn tracking, and lock handling.

internal/stats · high confidence

A new local history tool is introduced, enabling agents to search saved session transcripts using lightweight BM25 retrieval and to read surrounding messages for any hit. The tool supports project and global scopes, filters by message kind (user text, assistant text, tool input, tool error, and optionally tool output), and filters by tool name. It also skips sessions marked as cleanup-pending, ensuring that incomplete or deleted sessions are not returned. Tests confirm that the search ranks results correctly, includes archives and global sessions as expected, filters out common noise, and rejects access to cleanup-pending files.

internal/history · high confidence

The application now includes a migration rescue mechanism that imports legacy user sessions and memory files from older installation directories. This process is triggered automatically during boot or via a new /migrate command, providing progress updates and a summary of imported data. The migration respects the REASONIX\_HOME environment variable, skipping implicit legacy migrations in isolated runtime environments to ensure data isolation.

internal/migration · medium confidence

Users can now see their provider's wallet balance directly in the status bar. This new feature fetches the balance from the provider's API (currently supporting DeepSeek's /user/balance endpoint) and displays the amount in the user's preferred currency, falling back to CNY if no preference is set. The implementation includes robust error handling for network issues, malformed responses, and missing API keys, ensuring the status bar remains stable even if the balance service is unavailable.

internal/billing · high confidence

A new \MockProvider\ implementation has been added to the \internal/agent/testutil\ package. This component replaces real LLM backends in agent tests with scripted responses, request recording, and error injection, allowing the harness loop, cache behaviour, and tool dispatch to be verified without network calls. The addition includes the implementation (\mock\_provider.go\) and its corresponding tests (\mock\_provider\_test.go\).

internal/agent/testutil · high confidence

Users can now use the new \list\_sessions\ and \read\_session\ tools to discover and view past AI conversation sessions, enabling cross-session AI context sharing. The \list\_sessions\ tool provides a table of saved sessions (timestamp, model, turn count, preview, and file), while \read\_session\ allows reading a specific session's conversation with privacy-safe filtering (no system prompts or reasoning content) and optional inclusion of tool results. The implementation reuses existing agent infrastructure (ListSessionOrder, LoadSession, IsCleanupPending) and includes tests for schema validity, empty directories, cleanup-pending exclusions, and content truncation.

internal/tool/sessiontool · medium confidence

The desktop frontend now includes dedicated localization files for Simplified Chinese (zh.ts) and Traditional Chinese (zh-TW.ts), providing translated UI strings for components such as the sidebar, top bar, and workspace panels. These files mirror the English dictionary structure, ensuring consistent key coverage and enabling the application to display Chinese text in those interface areas.

desktop/frontend/src/locales · high confidence

The write\_heartbeat tool now initializes the heartbeat-tasks.json file with two default tasks: a 'greeting' task that runs every 2 minutes and a 'daily\_check' task that runs every hour. These tasks are designed to periodically inject AI prompts into the system, supporting a scheduled heartbeat mechanism for automated AI interactions.

tools · high confidence

The release process now automatically builds and publishes prebuilt binaries for macOS (ARM64/x64), Linux (ARM64/x64), and Windows (x64) as separate npm packages under the @reasonix/cli namespace. A new build script generates platform-specific package.json files and invokes Go builds with injected version and commit SHA metadata. The publish logic handles version validation, manages dist-tags (latest, next, canary), and includes resilience against npm registry visibility lag and immutable package integrity checks.

npm · high confidence

The bot gateway now exposes a local HTTP control server (defaulting to 127.0.0.1:37913) that provides status, metrics, and a /send endpoint for sending messages. Additionally, a new /desktop command suite is available for users with the desktop bridge, allowing them to view live sessions, subscribe to events, approve or deny pending actions, answer questions, and take over or release remote desktop sessions directly from the bot chat.

internal/bot · high confidence

The bot runtime now explicitly resolves enabled platforms (QQ, Feishu/Lark, Weixin) against configuration, supporting the 'lark' alias for Feishu. It also introduces functions to map inbound messages and sessions to user and group identifiers, ensuring distinct group-user mappings and shared thread mappings are correctly persisted in user config.

internal/botruntime · high confidence

The release-notes module now embeds a structured, version-matched changelog (releases.json) directly into the binary, providing a consistent, offline-accessible history of product changes and fixes for each release.

release-notes · high confidence

The plugin system now persists the handshake results (tool schemas, capabilities, and read-only hints) to the user cache directory. This allows the application to register tools optimistically on subsequent launches without waiting for the network or subprocess, significantly improving cold-start performance. The cache is keyed by a hash of the server's identity and configuration, ensuring that changes to the server's environment or command invalidate the cache appropriately. Additionally, the system now canonicalizes JSON schemas to ensure stable cache keys and prevent cache pollution from equivalent but differently ordered schemas. Tests have been added to verify the cache round-trip, schema canonicalization, and handling of legacy cache formats.

internal/plugin · high confidence

The desktop frontend now manages layout geometry (sidebar, right dock, workspace panel, and terminal drawer sizes and states), transient overlay visibility (command palette, settings, search, splash), remote SSH connection status and explorer state, and integrated terminal session lifecycle through dedicated Zustand stores. This refactors previously scattered React state into a unified state management layer, ensuring consistent persistence of user preferences like sidebar collapse and panel open states, while providing a single source of truth for remote SSH conditions and terminal session management.

desktop/frontend/src/store · high confidence

The internal/store package now owns the authoritative layout for session sidecar files (meta, goal state, event logs, checkpoints, jobs, and cleanup markers) and remote SSH module state names. Previously, each component derived these paths independently, which made layout changes require hunting across multiple packages. This change consolidates path generation into the store package, ensuring consistent naming conventions and simplifying session cleanup and remote state management.

internal/store · high confidence

The crash-report worker now includes a full database schema and migration scripts. Authentication has shifted from local passwords to a shared identity provider (id.reasonix.io), with an \access\ table managing email-based roles. New tables support CLI telemetry (\cli\_pings\, \cli\_metrics\, \cli\_metric\_users\), structured crash data (\groups\, \reports\ with new fields like \error\_type\, \breadcrumbs\), and a registry for skills/MCP servers (\packages\, \package\_versions\, \stars\). Performance is improved by adding indexes for dashboard queries and removing inefficient window-scan indexes.

workers/crash-report · high confidence

The desktop frontend is now built with Vite, featuring code splitting for React, Markdown, and syntax highlighting libraries to reduce bundle sizes. The build process automatically archives source maps for crash reporting and strips crossorigin attributes from assets to ensure compatibility with older macOS WebKit versions. Additionally, the development server is bound to 127.0.0.1 to fix Windows blank window issues, and ESLint is configured to enforce React hooks rules.

desktop/frontend · high confidence

The @file reference search now matches files by intermediate directory segments (e.g., searching for 'planind' finds 'src/planind/index.tsx'), making it easier to locate files in deep or nested paths. The search also filters out common build outputs and generated directories (like 'node\modules', 'build', 'dist', '\\pycache\\_') to keep results clean and responsive. Directory matches are prioritized in the results, allowing users to navigate into folders directly from the completion menu.

internal/fileref · high confidence

The permission system now classifies bash commands into reusable, exact-match, and human-approval categories based on shell syntax, indirect execution, and dynamic content. Compound bash commands (e.g., \git add . && git commit\) are now decomposed and evaluated segment-by-segment, allowing prefix rules to apply to each segment. Dynamic commands (e.g., those with command substitution, process substitution, or environment variable expansion) require explicit human approval or exact-match rules. Read-only bash commands are identified more accurately, and dangerous patterns (e.g., \rm -rf\, \git push --force\) trigger UI warnings. Safe redirects (e.g., \2\>/dev/null\) are normalized for matching, and the system distinguishes between reusable, exact-only, and human-required approvals for better auto-approval of safe commands while maintaining security for dynamic or destructive operations.

internal/permission · high confidence

Added internal/cli/acp.go to run Reasonix as an Agent Client Protocol (ACP) agent, enabling editor integration via a stdio JSON-RPC server. Added internal/cli/bot.go to manage multi-platform IM bot gateways (Feishu, Weixin, QQ) with connection and access control. Added internal/cli/box.go to provide terminal UI helpers for rendering bordered boxes and measuring visible string width, supporting the new TUI layouts.

internal/cli · high confidence

Added a new \sign\ command-line tool that generates cryptographic signatures (\.minisig\) and a \latest.json\ manifest for desktop release artifacts. This tool handles signing with minisign keys, generating platform-specific manifests (including Windows ARM64 and Linux .deb packages), and verifying signatures, ensuring all desktop download links and update channels are correctly mapped in the release metadata.

desktop/cmd/sign · high confidence

Adds the Go SDK for building Reasonix extensions (sidecar processes) that speak Extension Protocol v1 over stdio. The SDK provides the \extension.Serve\ entry point, a \Handler\ interface for initialization, and callback types for interceptors, observers, providers, and structured UI. It enforces a strict JSON-RPC 2.0 wire format with a handshake barrier, concurrent callback execution, and content reference handling. The release includes a minimal starter extension example, a full-featured reference sidecar, and comprehensive unit tests for the host handshake, provider streams, and content reads.

sdk · high confidence

The CLI has been renamed from 'duo' to 'reasonix' and is now the primary entry point for the coding agent. A new 'reasonix-plugin-example' command is added as a reference implementation of the MCP stdio protocol, exposing tools, prompts, and resources via JSON-RPC 2.0. The main CLI binary now includes crash reporting that captures panics and writes them to the reasonix home directory, with tests verifying that crash reports are generated and that sensitive data (like panic messages) is redacted from the reports.

cmd/reasonix · medium confidence

The project has been rewritten in Go (v2), introducing a new \reasonix.toml\ configuration format, a \.env.example\ template for API keys, and a \Makefile\ for building and testing. New scripts (\dev\, \prod\_test\, \prod\_fast\_test\) streamline local development and production-style desktop builds. The repository also includes a \CHANGELOG.md\ documenting the v2 features, a \CONTRIBUTING.md\ guide, and updated \README\ files. This marks a significant architectural shift from the previous TypeScript/JavaScript implementation.

(repo-wide) · high confidence

Added a new Responses API provider implementation in internal/provider/responses, including the main client logic, vendor capability definitions, and comprehensive tests. This enables the system to communicate with OpenAI-style Responses endpoints, specifically supporting stateless modes for DeepSeek and MiMo, with configurable output budgets, web search tools, and reasoning content handling.

internal/provider/responses · high confidence

A new Go-based utility at cmd/signpath-contract validates the release signing contract and fingerprints, ensuring that only the official stable publication path is used for signing. The tool enforces strict allowlists for branches and build definitions, rejects wildcards, and verifies that top-level workflows correctly reach SignPath, preventing unauthorized or legacy manifests from being used in the release process.

cmd/signpath-contract · high confidence

The desktop application is rebuilt on the Wails framework, introducing a new \App\ struct that manages multiple \WorkspaceTab\ instances. Each tab represents an independent conversation with its own controller, session, and tool registry, allowing multiple projects and topics to be active concurrently. The implementation includes a single-instance lock to prevent duplicate processes, a tab lifecycle system with automatic session restoration from disk, and event routing from the frontend to the appropriate tab controller.

reasonix/desktop · high confidence

The internal/checkpoint package now implements a new snapshot-based edit safety net that persists per-turn file states to enable conversation and code rewind. This includes a new \Store\ that manages checkpoints, a \MutationBarrier\ to coordinate workspace mutations, and a \BlobStore\ for content-addressed file payloads. The system supports transactional restore with compensation, ensuring that if a file write fails mid-transaction, the workspace is rolled back to its previous state. It also tracks coverage gaps (e.g., symlinks, hardlinks, or unreadable files) to warn users about potential issues during rewind. The checkpoint format has been updated to version 2, which includes after-write fingerprints and blob references for improved conflict detection and recovery.

internal/checkpoint · high confidence

The internal/guardian package now implements an automated safety gate that evaluates tool calls before they execute, replacing the previous interactive human approval step. The system uses a dedicated sub-agent with read-only tools to inspect calls against a structured policy (risk level, user authorization, outcome) and returns an allow/deny decision. The implementation includes a policy definition (guardian\_policy.md) that enforces hard constraints (e.g., critical risks are always denied), a parser for the LLM's JSON assessment, and a transcript handler that manages conversation history and delta updates. Tests verify that critical risks are denied, unknown enums are rejected, and session state (cursor) is correctly saved and loaded.

internal/guardian · high confidence

The memory subsystem now includes an automatic recall mechanism that surfaces relevant saved facts during a session, with a dedicated \memory\ tool for manual search, read, and list operations, and a \forget\ tool to archive stale or incorrect memories. The system distinguishes between global and project-scoped facts, ensuring project-level facts override global ones. The \remember\ tool is also available for saving new memories. All these features are supported by comprehensive tests.

internal/memory · high confidence

Added a new internal package, internal/boundedllm, which provides a shared infrastructure for making isolated, no-tool LLM calls with strict hard limits on timeout, output length, and byte size. This ensures that independent reviewers, such as the Auto Guard recovery reviewer and the Goal evaluator, operate in isolation from the main conversation context, preventing resource exhaustion and ensuring fail-closed behavior when budget constraints are exceeded.

internal/boundedllm · high confidence

The system now loads built-in skills from embedded Markdown content, providing a stable, cache-stable index of available playbooks. Each skill carries structured metadata (name, description, scope, and execution mode) that feeds into the system prompt index. The change introduces a read-only contract for review and security-review subagents, ensuring they only access read-only tools. Additionally, the 'explore' skill receives optional code graph hints and tool bindings when code graph MCP tools are discovered, while the 'init' skill bootstraps project memory. The skill discovery process now distinguishes between winner, shadowed, and disabled candidates for diagnostic purposes, and validates subagent profile names against reserved slash commands.

internal/skill · high confidence

Added a new capability routing system in internal/capability that manages how the agent selects and invokes skills, tools, and MCP servers. The new files (audit.go, capability.go, catalog.go, ledger.go, semantic.go) introduce a unified catalog of available capabilities, a deterministic and semantic routing mechanism that prioritizes required and preferred capabilities, and a turn-scoped ledger to track invocation outcomes. The system also includes an audit struct to track routing decisions, skill invocations, and router usage metrics (tokens, cost, latency). Tests verify that the routing respects auto-use policies, handles Chinese text fallbacks, and correctly renders transient blocks for delivery and capability proxy scenarios.

internal/capability · high confidence

The internal/worktree package now creates durable, Git-backed workspaces for parallel Delivery sessions. These worktrees live under Reasonix-managed state, never inside the source repository, and are never deleted automatically. The Create function generates a new branch and linked worktree at a managed root, reporting uncommitted source changes without copying or modifying them. A new IsManagedPath helper identifies paths belonging to Reasonix's durable worktree storage. Tests confirm support for long Windows paths and isolation of concurrent writers.

internal/worktree · high confidence

Added the internal/autoresearch package to manage the lifecycle of autonomous research tasks. This includes a file-based store (store.go) that handles task creation, concurrent ID reservation, and secure removal using create tokens. It introduces a progress model tracking iteration, stale counts, and pivot requirements, alongside a validation schema (schema.go) for task specs and progress states. A readiness check (readiness.go) and summary generation (summary.go) allow the system to report on task status, open criteria, and required next actions. Comprehensive tests (store\_test.go, bounded\_store\_test.go) verify atomic task creation, collision avoidance, and correct handling of direction fingerprints and legacy data migration.

internal/autoresearch · high confidence

Added a new internal/diff package that computes line-level diffs between file versions, supporting create, modify, and delete operations. The implementation includes safeguards to prevent out-of-memory errors on large files by capping the edit distance calculation, falling back to approximate line tallies when changes exceed 2000 edits. The package provides a Change struct with added/removed line counts, unified diff output, and binary file detection. Tests cover edge cases including CRLF handling, large file performance, and binary content detection.

internal/diff · high confidence

The internal/sandbox package now provides a unified interface for confining shell commands in an OS-level jail. On macOS, it uses Seatbelt (sandbox-exec); on Linux, it uses bubblewrap (bwrap); on Windows, it falls back to running commands unconfined. The package introduces a Spec struct to configure write/read roots, network access, and forbidden paths, and provides helper functions to prepare command arguments with appropriate wrappers. Session-private temporary directories are now supported, allowing consecutive Bash calls in the same session to share temporary files. The shell resolution logic has been updated to prefer bash, falling back to PowerShell on Windows, and to detect and exclude WSL bash launchers. Tests have been added to verify the behavior of the sandbox configuration, shell resolution, and null redirect normalization across platforms.

internal/sandbox · high confidence

The desktop application now uses dedicated update-helper executables for each platform to manage updates more securely and reliably. On Windows, the helper verifies the Authenticode signature of the installer and the release unit payload before execution, ensuring the update binary has not been tampered with. On Linux, the helper runs as root via Polkit to install the .deb package, validating the package signature and architecture before invoking apt-get. Both implementations enforce strict input validation, prevent symlink attacks, and ensure that updates are applied atomically to avoid leaving the application in a broken state.

desktop/cmd/update-helper · high confidence

Added a new \scripts/official-theme-art/\ module that procedurally generates original background images and thumbnails for eight official themes using Python (numpy, PIL). The system defines color palettes, scene compositions, and stylized character figures, ensuring all assets are reproducible and free of copied pixels or third-party content. A build script (\build.py\) generates the final WebP files and a provenance document (\THEme\_ASSETS.md\) that records generation parameters and SHA-256 hashes for each theme.

scripts/official-theme-art · high confidence

Added a new internal/remote module that enables SSH-based remote connections, including cross-platform agent support (Unix socket on Linux/macOS, stub on Windows), OpenSSH-like authentication ordering (agent, identity files, password/keyboard-interactive), and a bootstrap package that locates or installs the Reasonix CLI on remote hosts, launches a detached 'serve' process, and manages its lifecycle with file-based state, locking, and hardening against stale processes and shell injection.

internal/remote · high confidence

A new \internal/eventwire\ package defines the shared frontend JSON contract for \event.Event\, mapping internal runtime events into a structured JSON format. This includes support for tool dispatch and results, usage metrics, approval requests, compaction, guardian assessments, and extension surfaces. The \ToWire\ function converts typed runtime events into this contract, ensuring consistent serialization for frontend consumption. Tests verify the correct mapping of all event kinds, including retry attempts, notice codes, decision receipts, and memory citations.

internal/eventwire · high confidence

The evidence subsystem now features a new \Ledger\ that records tool receipts and supports merging child evidence from sub-agents, allowing parent agents to inherit successful writes, reads, and commands while filtering out meta-tool noise. A new \ChildEvidenceSummary\ type and \MergeChild\/\MergeChildren\ methods enable this aggregation. Additionally, the system introduces a \ReadinessAudit\ struct and \ReadinessAuditResult\ constants to track final-answer readiness gates, and a \ReviewReport\ type to parse and validate structured review and security review reports. The \risk.go\ file adds a \ClassifyMutationRisk\ function that scores change sets as low, medium, or high risk based on file paths and tool names. Finally, \commandmatch.go\ provides a \CommandMatches\ function that tolerates command string drift when matching verification commands, and \meta.go\ defines a whitelist of non-mutating meta tools.

internal/evidence · high confidence

The desktop auto-updater now uses explicit Go types to define the update manifest (latest.json) and the Windows payload manifest. The Manifest struct in manifest.go defines the schema for release metadata, platform assets, and optional native packages, while verify.go embeds the minisign public key for signature verification. For Windows, windows\_payload.go introduces a strict schema for the payload manifest, enforcing exact file members, version matching, and SHA-256 integrity checks. These changes provide a single source of truth for the updater and CI signing tools, ensuring that the sign path and verify path never drift apart.

desktop/internal · high confidence

The task monitor now includes a control plane for managing task lifecycles. The new ControlService handles stop, cancel, and requeue operations, enforcing state transitions, version conflicts, and idempotency. It routes control requests to the correct runtime using a namespaced job ID. The FileStore provides persistent JSON-based storage with cross-platform file locking, path traversal protection, and atomic writes. A TmuxAdapter maps tasks to tmux sessions, handling session creation, ownership, and cleanup. Tests cover the full lifecycle, including lease renewal, state validation, and error handling.

internal/taskmonitor · high confidence

The desktop frontend now includes a new HeartbeatPanel component that allows users to configure and manage scheduled AI prompt injection tasks. This feature adds a modal interface for creating, editing, and deleting recurring tasks with specific intervals, time windows, and scopes. The implementation includes a dedicated bridge layer (heartbeat.bridge.ts) to handle task persistence and triggering, while the CSS file (heartbeat.css) provides scoped styling for the panel's UI elements. The types (heartbeat.types.ts) define the structure for these tasks, including fields for interval, time windows, and notification channels.

desktop/frontend/src/custom/features/heartbeat · high confidence

The desktop frontend is now bootstrapped via a new \App.tsx\ entry point, establishing the core React application structure for the desktop client. This change introduces the primary application container, integrating essential providers for internationalization, toast notifications, and remote state management, while also implementing global crash handlers and performance monitoring to improve stability and diagnostics for desktop users.

desktop/frontend/src · high confidence

The \install\_source\ tool is now available for installing and managing skills, MCP servers, and plugin packages. It supports a two-phase workflow: first generating a deterministic plan with risk levels, then applying changes (copying files, registering paths, connecting MCP servers) only after approval. The tool handles various source types including URLs, local paths, GitHub repositories, and package names, with specific support for \.mcp.json\ configurations, Claude plugin manifests, and Codex-style plugins. Security is enforced through risk classification (low/medium/high), approval gates, and restrictions on symlink targets and remote URLs.

internal/installsource · high confidence

The desktop client now uses a new \installlayout\ package that manages a versioned directory structure (\versions/\<version\>/\) and an atomic \current.json\ pointer. Updates are staged in temporary directories and only committed to the active version after all files are validated and copied, ensuring that a failed update never leaves the system in a broken state. The implementation includes strict validation of version names and file paths to prevent path traversal and symlink attacks, and provides a migration path from the previous flat layout structure.

internal/installlayout · high confidence

Adds a new \internal/repair\ package that provides robust, atomic repair and diagnostic capabilities for the application. This includes \InspectAndRepairConfig\ to safely quarantine and restore global and project configuration files, \RebuildDerivedState\ to handle transient state files like \desktop-tabs.json\, and \Diagnose\ to report on configuration, provider, and plugin health. The subsystem also introduces \UpdateApplyFailure\ tracking to recover from interrupted or failed update transactions, ensuring that pending updates can be safely rolled back or completed. These changes are supported by extensive unit tests covering edge cases such as dangling symlinks, concurrent file modifications, and cross-device operations.

internal/repair · high confidence

The agent now emits a structured, typed event stream (internal/event) that decouples what happens (reasoning, tool calls, usage, notices) from how it is displayed. This replaces the previous system where the agent wrote pre-formatted ANSI text, allowing each frontend (CLI, Desktop, Headless) to implement its own Sink for rendering. The new system supports granular events like ToolProgress for live streaming, sub-agent progress tracking, and distinct handling for operator vs. user-facing notices.

internal/event · high confidence

The internal/tool package adds a new ConfigWriteApprover interface and context helpers, enabling the system to require explicit human approval for writes to Reasonix-managed configuration files outside standard workspace roots. Additionally, the package now exposes a ContractEntry structure and a RenderContractMarkdown function that generates a Markdown document of tool schemas, descriptions, and read-only status, ensuring the documentation stays in sync with the tool registry.

internal/tool · high confidence

A new community forum service is introduced, providing a public API for browsing and creating topics and posts. Access is gated by a trust system: new members start with limited capabilities (e.g., no links, lower post limits) and gain access as they participate. The system includes anti-spam measures, including email verification requirements, self-reporting restrictions, and automatic post hiding after a threshold of flags. Staff and moderators are exempt from trust-based gates.

workers/forum · high confidence

The Linux desktop build now includes a native .deb package, defined by a new \nfpm.yaml\ configuration that packages the application binaries, desktop integration files, and icon assets. To support in-app updates, a Polkit policy file (\io.reasonix.desktop.update.policy\) has been added, requiring administrator authentication for the update helper. A \postinstall.sh\ script ensures desktop integration and icon caches are refreshed after installation or upgrade.

desktop/build/linux · high confidence

Added a suite of shell and Node.js scripts to the \scripts/\ directory to support the new Stable and Preview release channels and improved CI safety. The new scripts include \check-cache-impact.sh\ and \check-docs-impact.sh\ to enforce PR body fields for cache-sensitive and documentation changes, \compare-cli-release-manifests.sh\ and \compare-desktop-release-manifests.sh\ to validate release artifacts, \decide-cli-pointer-update.sh\ and \decide-desktop-pointer-update.sh\ to manage channel pointers, and \check-single-release-public-contract.mjs\ to prevent public references to deprecated channels. Additionally, \credential-leak-check.mjs\ was added to detect accidental credential leaks in test output, and \agent-complexity-report.sh\ provides a non-blocking complexity report for the agent codebase.

scripts · high confidence

A new Cloudflare Worker at id.reasonix.io provides the backend API for account management, including email/password sign-up, email verification, password reset, and public profiles. It introduces device-authorization (RFC 8628-style) sign-in for CLI and desktop clients, allowing headless authentication without browser redirects. The service uses D1 for storage and supports both cookie-based (web) and Bearer token (CLI) session management.

workers/accounts · high confidence

The crash-report worker now includes a new admin dashboard for managing user access and auditing permissions, a community moderation console for reviewing and approving user-published skills and plugins, and a release gateway for serving desktop and CLI update manifests. These additions introduce new UI pages and API endpoints for administrative control and release distribution.

workers/crash-report/src · high confidence

A new \capdiag\ package has been introduced to collect and report on the status of project capabilities. The \Collect\ function generates a structured \Report\ containing summaries and detailed entries for instructions, skills, commands, hooks, plugins, and MCP servers. The report includes an \Issues\ array for diagnostics (e.g., missing descriptions, invalid matchers, command not found) and a \Summary\ with counts. For CLI usage, the \--live\ flag enables live probing of MCP servers, while desktop users receive static configuration data. The report ensures privacy by redacting sensitive paths and secrets, replacing absolute paths with safe markers like \\<workspace\>\ and \\<reasonix-home\>\. Tests verify that the report is deterministic, does not leak secrets or raw paths, and correctly handles legacy and Manifest v1 plugin packages.

internal/capdiag · high confidence

Introduced new React components for the desktop application's user interface, including AnchoredPopover for managing floating menus and popups, AppChrome for the main window header with tab and search controls, AppearanceOverview for theme and typography settings, and ApprovalModal for handling tool execution permissions. These components form the foundation of the new desktop shell, providing the structural and interactive elements for the Wails-based frontend.

desktop/frontend/src/components · high confidence

The extension subsystem now uses a unified contributor model where tools, skills, commands, hooks, and interceptors are registered via a deterministic builder pipeline. This introduces a new catalog and snapshot system that resolves conflicts (e.g., same-tier duplicates) and ensures stable ordering regardless of registration order. Tests confirm that the system correctly handles shadowing, additive kinds like hooks, and conflict policies (fail vs. collect).

internal/extension · high confidence

Added a new \desktop/frontend/src/lib\ directory containing a suite of utility modules that support the desktop application's core features. These include \array.ts\ for safe array handling, \atMatches.ts\ for fuzzy file search in the composer, \attachDedup.ts\ for preventing duplicate file attachments via SHA-256 hashing, \attachmentDisplay.ts\ for formatting and parsing attachment references, \breadcrumbs.ts\ for crash diagnostics, \bridge.ts\ for Go kernel communication, \clipboard.ts\ for cross-platform copy support, \codeReadability.ts\ for theme-aware syntax highlighting, \compat.ts\ for browser compatibility, \composerDraftKey.ts\ for draft persistence, and \composerHistory.ts\ for prompt history navigation.

desktop/frontend/src/lib · high confidence

The internal/instruction package now provides a complete pipeline for resolving, deduplicating, and rendering project and user instructions. The resolver (resolver.go) walks the workspace and target directory chains to collect convention files (REASONIX.md, AGENTS.md, CLAUDE.md and their .local variants), applies strict import scoping and deduplication, and produces a sorted list of documents with provenance. The render module (render.go) formats these documents into a structured 'Instructions' block that is prepended to prompts, with later (more specific) entries taking precedence. Additionally, the system extracts 'VerifyCheck' commands from a structured 'Reasonix host checks' section in documents, allowing host-side verification commands to be surfaced without polluting the model's instruction context. Tests confirm that imports are confined, symlinks are safely resolved, and user/project scopes are correctly separated.

internal/instruction · high confidence

The site has been rebuilt using the Astro framework, introducing a new community forum at /community with discussion categories, topic listing, and guidelines, alongside a new changelog system at /changelog that displays release notes with version rails, highlights, and download links. The build process now pre-fetches community stats and contributor avatars, and the site is served from the custom domain reasonix.io with a sitemap and favicon.

site · high confidence

The environment probe system now persists probe results to disk as snapshots, ensuring the rendered environment section remains byte-stable across rebuilds and process restarts. This prevents the cached system-prompt prefix from changing unnecessarily, which previously caused session cache invalidation. The implementation includes a 24-hour TTL for snapshots, a 2-second timeout per probe, and a merge strategy that preserves previous successful observations for transient failures (like timeouts or cold daemons) while still adopting definitive changes (like a tool being uninstalled). Tests verify the caching, snapshotting, and Windows-specific console-hiding behavior.

internal/environment · high confidence

Users can now define custom slash commands and skills by creating Markdown files in the project's command directories. Each command is a prompt template that expands arguments (e.g., $1, $ARGUMENTS) into the final prompt. The system loads these commands, handling subdirectories as namespaces (e.g., git/commit.md becomes /git:commit). Plugin-provided commands are exposed with their package-qualified names (e.g., /plugin:command) while maintaining backward compatibility with unqualified names. A new 'slash\_command' tool allows the model to invoke these commands, which return the expanded prompt text for the model to act on. The implementation includes robust handling of file encoding (UTF-8, GB18030), symlinked directories, and frontmatter parsing.

internal/command · high confidence

The desktop build now includes the full source code for the go-webview2 library, including the COM bridge implementation and Windows-specific bindings. This adds the necessary third-party code to support WebView2 functionality on Windows, enabling the application to interact with the Chromium-based browser engine.

_desktop/third\party · high confidence

The Windows installer script (project.nsi) has been replaced with a custom implementation that enables per-user installation without requiring administrator rights, allowing the auto-updater to run in a visible progress-only mode without triggering UAC prompts. The installer now persists the user's chosen install path via the HKCU registry key, ensuring that updates preserve the user's custom directory selection rather than forcing a reinstall to the default %LOCALAPPDATA% location. Additionally, the uninstaller is registered under HKCU instead of HKLM, and the script includes logic to handle update modes and stage modes via command-line arguments.

desktop/build/windows/installer · high confidence

The Windows support executables are now stamped with Reasonix branding, including an embedded icon and version information. This ensures that Windows Explorer, shortcuts, and the taskbar display the correct application icon instead of a generic placeholder. The change adds a new command-line tool at desktop/cmd/windows-resource to perform this resource stamping, along with corresponding tests to verify the embedded resources.

desktop/cmd/windows-resource · high confidence

The system now automatically detects and masks sensitive data—including API keys, bearer tokens, cookie headers, and URL credentials—in error logs and diagnostic outputs. This prevents accidental exposure of secrets in crash reports and tool output, with the protection level configurable via the \[secrets\] configuration section.

internal/secrets · high confidence

A .gitkeep file was added to the desktop/frontend/dist directory. This ensures the directory is tracked by version control, which is typically done to preserve an empty directory structure in a Git repository.

desktop/frontend/dist · low confidence

On Windows, the proxy package now automatically resolves the system proxy by reading IE/WinHTTP settings, including static proxy configurations, PAC auto-config URLs, and WPAD auto-detection. If no system proxy applies, the function returns nil, allowing the client to fall back to environment variables or direct connections. This change is specific to the Windows implementation, while non-Windows platforms continue to return nil for system proxy resolution.

internal/sysproxy · high confidence

The internal/gitcmd package now centralizes the baseline configuration for all Git invocations, ensuring that every command carries the same security and stability overrides. This includes disabling external fsmonitor commands, background maintenance, and repository-configured diff/textconv programs, while also suppressing interactive prompts and credential inheritance. Tests confirm that these hardening flags are applied consistently and cannot be dropped by individual call sites.

internal/gitcmd · high confidence

The plan mode now enforces a strict separation between the planning workflow and the implementation phase. The system blocks tools that are semantically invalid during planning, such as 'complete\_step', ensuring that users approve the plan before the workflow switches to implementation. This change clarifies that plan mode is a collaboration workflow, not a security boundary, with every tool call still governed by the active Permissions and Sandbox policy.

internal/planmode · high confidence

The frontmatter parser has been extracted into a new internal package and refactored to handle YAML list values (such as 'allowed-tools') as comma-separated strings, ensuring that tool scoping for skills is preserved. The new implementation includes comprehensive tests for parsing, decoding, and edge cases like unclosed fences and nested metadata.

internal/frontmatter · medium confidence

The pre-push git hook has been rewritten in Go, replacing the previous npm-based implementation. This change ensures that the local pre-push validation runs via 'go vet' instead of relying on Node.js dependencies, providing a faster and cross-platform local check while deferring full test suites to CI.

.githooks · low confidence

The shell parser now uses the Bash AST (via the mvdan.cc/sh/v3/syntax library) to distinguish static commands from complex shell syntax. This allows the system to safely reduce simple commands to their executable arguments while rejecting or flagging shell-specific features like here-documents, control operators, redirections, and expansions. Users will see more precise handling of shell commands, with clearer rejection reasons for unsupported syntax.

internal/shellparse · medium confidence

A new registry worker has been added to handle package publishing, listing, and activity feeds. The change introduces strict validation rules for publish sources: whole-repo GitHub URLs are rejected for skills, and bare package names are rejected for skills (they resolve as MCPs). Plugin submissions are now supported, requiring GitHub sources. The system enforces a moderation workflow where publisher updates to existing packages are automatically re-queued for admin review, and admin approvals require the current revision to prevent stale reviews.

workers/crash-report/src/registry · high confidence

The internal/recovery package now implements a structured 'Auto Guard' system that enforces strict limits on autonomous execution. It introduces a decision engine that routes actions through allow, review, or stop states based on failure counts, plan transitions, and operation risks. The system enforces hard limits on operation failures (3), episode failures (6), and review rejections (3) before halting further execution, while preserving read-only diagnosis. A dedicated reviewer session handles ambiguous recovery mutations, and the implementation ensures that enabling the Auto Guard does not alter the provider-visible system prompt or tool schemas on the success path.

internal/recovery · high confidence

The application now uses a versioned install layout (v1.20+) with a thin launcher entry point and a dedicated legacy migrator. The migrator converts existing flat installations into the new structure, creating versioned directories and updating the current.json pointer. The launcher strips legacy command-line arguments (e.g., --safe-mode) and resolves the active desktop binary from the versioned layout, falling back to a flat sibling only if no pointer exists. Tests confirm that migration is idempotent, rejects corrupt pointers, and ensures failure-atomicity during staging activation.

cmd/reasonix-legacy-migrator · medium confidence

The internal netclient now applies the configured proxy settings to all network connections, including non-HTTP protocols like SSH. A new StreamDialer ensures that raw TCP streams honor the same proxy rules (SOCKS5, HTTP CONNECT, or direct) as HTTP requests, while DirectHosts and NoProxy settings are consistently applied to bypass the proxy for specific hosts.

internal/netclient · high confidence

The jobs package now persists background job outputs and metadata to disk as artifacts, allowing the system to recover and surface job results after restarts. This includes a new \artifacts.go\ module that handles reading, writing, and listing job artifacts, along with a \ListArtifactViews\ function that projects status without exposing sensitive data. To address security concerns, the implementation adds strict validation for \parentSession\ and \kind\ fields to prevent path traversal attacks, and enforces private file permissions on artifact directories. Comprehensive test coverage was added across multiple test files (\artifacts\_test.go\, \jobs\_security\_test.go\, \jobs\_sessionpath\_test.go\, etc.) to verify artifact persistence, concurrency safety, and input validation.

internal/jobs · high confidence

The doctor tool now provides a new quality report that summarizes session transcripts and telemetry without exposing sensitive data, and bundles session artifacts into a zip file for issue reporting. The session redaction logic was hardened to decode JSON before masking, preventing corruption and ensuring all historical session logs are scrubbed of secrets. Additionally, the report generation now surfaces warnings about ignored sandbox configurations and missing skills, and the session bundle includes a redacted doctor report alongside the session data.

internal/doctor · high confidence

The hook runner now correctly executes Windows batch (.cmd/.bat) and PowerShell hooks by preserving argument semantics and quoting. A new \command\_normalize.go\ module repairs common quoting issues in Node.js eval commands and PowerShell file hooks. Platform-specific files (\batch\_command\_other.go\, \batch\_command\_windows.go\, \windows\_compat.go\) implement the actual command construction, ensuring that batch scripts receive their arguments exactly as configured, and that \cmd.exe\ is invoked with the correct command line to avoid escaping issues. Tests in \execution\_contract\_test.go\ and \windows\_batch\_test.go\ verify that literal arguments, complex commands, and environment variable expansion work as expected on Windows.

internal/hook · high confidence

The bash tool now handles shell cancellation more robustly, ensuring that background jobs and foreground commands are properly terminated and reaped across Windows and POSIX environments. It also preserves explicit background processes (e.g., those launched with nohup or disown) and merges login-shell PATHs for better command resolution. Additionally, the tool now supports configurable foreground timeouts and provides more specific error messages for shell-specific syntax like PowerShell chaining.

internal/tool/builtin · high confidence

Added platform-specific implementations for process tree tracking, cancellation, and window hiding. On Windows, the \proc\ package now uses Job Objects to ensure that all child and grandchild processes are properly terminated when the parent exits or is cancelled, preventing orphaned processes and console window flashes. Non-Windows platforms use process groups for similar cleanup. The changes include new files for hiding windows, setting low priority, and tracking process trees, along with comprehensive tests for each.

internal/proc · high confidence

The internal file utility now handles Windows-specific file locking and cross-device rename failures more robustly. When an atomic write encounters a transient lock (such as from antivirus software or the search indexer), the system retries the operation instead of immediately falling back to a non-atomic copy. For structural cross-device errors (like those caused by encryption filter drivers), the system immediately uses a copy fallback rather than wasting time on retries. Additionally, the code now ensures temporary files have the correct permissions before closing, preventing race conditions where other processes might interfere with the file's state.

internal/fileutil · high confidence

The desktop launcher now correctly resolves the active install root by following symlinks on Unix and directory junctions on Windows, ensuring the application finds its resources even when the launcher is accessed via a symbolic link or Windows junction. Additionally, the launcher now performs a one-time migration from the legacy 'reasonix-guard' layout if present, and strips legacy command-line arguments (like --safe-mode) before passing them to the desktop process.

internal/desktoplauncher · high confidence

ACP integration and extension support; Add comprehensive tests for provider package internals; Add desktop build asset ignore rules and test coverage for session and icon handling; Add frontend build and test tooling scripts; Add tests for OpenAI-compatible provider effort and host-matching logic; Add tests for agent ablation, session branching, cache diagnostics, and the new Ask tool; Added Rust test data for LSP code-intelligence tools; Added comprehensive tests for control subsystems; Added end-to-end benchmarks for context maintenance and story compaction; Added extensive test coverage for desktop frontend components; Added tests for config backfill, cache policy, and credential migration.

The desktop frontend's \package.json\ and \pnpm-lock.yaml\ have been updated, introducing React 19.2.7, React DOM 19.2.7, and various other dependencies including \react-markdown\, \katex\, and \mermaid\. The Go module files (\go.mod\, \go.sum\) for the desktop shell and the root module have been updated to use Go 1.25.0 with toolchain 1.26.5, and include updated dependencies such as \github.com/wailsapp/wails/v2\ and \github.com/tree-sitter/go-tree-sitter\. Additionally, a local patch for \github.com/wailsapp/go-webview2\ has been added to the root \go.mod\ to support mixed-DPI monitor scaling and proxy isolation.

(dependencies) · high confidence

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

• First survey — no prior run to compare against. CAI 68.

• Code Health 78
• Architecture 100
• Maturity 75
• Readiness 74
• Security 70
• Accessibility 61

• 300 commits — 132 feature/other, 168 fixes

• (repo) — 96 commits
• desktop/frontend — 47 commits
• internal/agent — 22 commits
• internal/cli — 21 commits
• release-notes/releases.json — 21 commits
• internal/control — 8 commits
• internal/provider — 8 commits
• internal/boot — 7 commits
• internal/config — 6 commits
• .github/workflows — 5 commits
• internal/extension — 4 commits
• (root) — 3 commits
• internal/acp — 3 commits
• internal/remote — 3 commits
• internal/repair — 3 commits
• internal/serve — 3 commits
• internal/taskmonitor — 3 commits
• desktop/app.go — 2 commits
• desktop/tabs.go — 2 commits
• internal/checkpoint — 2 commits

• fix: Fix extension stream lint
• fix: Fix non-Goal evaluation and Delivery negation
• fix: Fix remote setup and window ownership recovery
• fix: Fix remote window identity test lint
• fix: Fix task monitor positional flag parsing
• fix: Fix task monitor review blockers
• fix: Fix task monitor runtime ownership
• fix: Fix task monitor tab-bound routing
• fix: Merge latest main-v2 into remote recovery regression
• fix: Merge latest main-v2 into remote recovery regression
• fix: Merge latest main-v2 into task monitor fixes
• fix: Merge latest main-v2 into task monitor fixes
• fix: Merge main-v2 into task monitor fixes
• fix: Merge pull request #7225 from Lxiny-zy/fix/subagent-corrupt-meta-startup
• fix: Merge pull request #7309 from skyzhao1223/fix/subagent-created-at-meta
• fix: Merge pull request #7328 from Nath-Vikky/codex/fix-custom-supported-efforts
• fix: Merge pull request #7344 from SivanCola/fix/cli-recovery-session-hygiene
• fix: Merge pull request #7351 from SivanCola/fix/bot-recovery-lease-handoff
• fix: Merge pull request #7353 from SivanCola/fix/system-prompt-file-resilience-secure
• fix: Merge pull request #7360 from SivanCola/fix/docs-codeblock-layout
• …and 280 more

• 0 containers · 2 bounded contexts · 1 dependency edges (baseline)

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

esengine/DeepSeek-Reasonix 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.