tailcallhq/forgecode

This system is a Rust-based AI coding assistant CLI that orchestrates interactions with multiple LLM providers to automate software development tasks. It provides a structured environment for agents to execute code, manage files, and resolve conflicts through a suite of specialized skills and tool integrations. The platform supports complex workflows including automated planning, pull request review, and release note generation, all managed via a unified API and persistent conversation history.

58 changes.

The project was initialized as a multi-crate Rust workspace, establishing the foundational architecture with dedicated crates for infrastructure, domain models, and API surfaces. This period focused on building core capabilities such as file system operations, agent execution, and provider-agnostic LLM integration, while simultaneously setting up comprehensive CI/CD pipelines and development tooling.

14 changes.

This period focused on enhancing agent capabilities through a new streaming markdown renderer, centralized TOML-based configuration, and behavioral hooks for context compaction and loop detection. It also expanded the skill ecosystem with tools for release notes, PR comments, and FIXME resolution, while introducing Google Gemini support and rigorous evaluation benchmarks for semantic search and tool usage.

The \forge\_ci\ crate now includes a \release\_matrix\ module that defines the build matrix for CI pipelines. This configuration specifies build targets across Linux (musl and gnu, x86\_64 and aarch64), macOS (x86\_64 and aarch64), Windows (x86\_64 and aarch64), and Android (aarch64), indicating which targets require cross-compilation. This enables the CI system to generate binaries for all supported platforms during the release process.

_crates/forge\ci/src · high confidence

Users can now authenticate with Model Context Protocol (MCP) servers using OAuth 2.0. This change introduces a dedicated credential store that persists OAuth tokens and client registration details per server URL, and implements the necessary HTTP providers (including standard PKCE, Anthropic-specific quirks, and GitHub error handling) to manage the authorization flow.

_crates/forge\infra/src/auth · high confidence

Introduces a new provider implementation for the OpenAI Responses API, enabling support for Codex models via the \chatgpt.com/backend-api/codex/responses\ endpoint. The change includes a \CodexTransformer\ that adjusts requests for the Codex backend by disabling storage, stripping unsupported parameters like temperature and max output tokens, and ensuring reasoning continuity via encrypted content inclusion. The provider handles streaming events, including Codex-specific \response.completed\ and \response.incomplete\ signals, and maps reasoning effort and summary configurations to the API.

_crates/forge\_repo/src/provider/openai\responses · high confidence

The forge\_tracker module now includes a new PostHog integration that captures user events and sends them to the PostHog analytics service. This change introduces a Collect trait and a concrete Tracker implementation that constructs HTTP requests with event payloads, including distinct IDs, event names, and custom properties, to the PostHog capture endpoint.

_crates/forge\tracker/src/collect · high confidence

A new evaluation suite has been added to benchmarks/evals/semantic\_search\_quality to measure the quality of semantic search queries generated by Forge. This suite uses an LLM-as-judge approach (Gemini 3 Pro via Vertex AI) to verify that embedding and reranking queries are well-formed, differentiated, and aligned with user intent. The addition includes a TypeScript-based LLM judge script, shell scripts for running the full evaluation and test suites, a manual query tester for interactive feedback, and a YAML task definition with diverse test cases covering implementation, flow understanding, architecture, and documentation intents.

_benchmarks/evals/semantic\_search\quality · high confidence

New DTOs have been added in \crates/forge\_app/src/dto/google\ to support the Google Gemini API. The \request.rs\ module defines the structure for API requests, including support for system instructions, generation configuration (such as thinking levels and temperature), various content parts (text, images, function calls), and tool definitions. The \response.rs\ module defines structures for parsing API responses, including candidates, usage metadata, and error handling, along with conversion logic to map Google's model names and context lengths to the internal domain model.

_crates/forge\app/src/dto/google · high confidence

A new benchmark suite has been added to evaluate how models handle modifications across multiple files simultaneously. The evaluation uses a set of tasks defined in \multi\_file\_patch\_tasks.csv\ (such as adding comments, updating Cargo.toml configurations, and modifying documentation) and verifies that the model correctly utilizes the \patch\ tool rather than shell commands like \git apply\. It also checks that the model invokes the patch tool multiple times to address changes in distinct files.

_benchmarks/evals/multi\_file\_patch, benchmarks/evals/parallel\_tool\calls · high confidence

The forge\_test\_kit crate now provides async helpers for loading test fixtures, replacing synchronous file inclusion. Users can use the new \fixture\ function and \fixture!\ macro to load file contents asynchronously, or the \json\_fixture\ function and \json\_fixture!\ macro (when the \json\ feature is enabled) to load and parse JSON fixtures directly. These utilities simplify test setup by reducing boilerplate in test code.

_crates/forge\_test\kit · high confidence

The repository is initialized with essential configuration files and documentation, including a Rust toolchain specification (channel 1.98), code formatting rules (rustfmt, clippy), and IDE settings (rust-analyzer). It introduces a JSON schema for the \ForgeConfig\ to enable editor validation, a \Cross.toml\ for cross-compilation builds, and a Nix flake for reproducible development environments. The project is licensed under Apache 2.0, and the README provides installation and usage instructions for the AI-enhanced terminal development environment.

(repo-wide) · high confidence

A new evaluation system is available in the \benchmarks\ directory to run automated tests and benchmarks against Forge Code commands. Users can define task workflows via YAML files (specifying setup commands, execution steps, parallelism, timeouts, and early-exit conditions) and drive data-driven testing using CSV sources. The framework supports output validation through regex patterns and shell commands, executes tasks in isolated temporary directories, and stores timestamped debug logs for each run.

benchmarks · high confidence

The shell-plugin directory now contains the complete Forge ZSH plugin, providing intelligent command transformation, file tagging, and session-based conversation management. Users can start and manage AI conversations using the \:\ prefix, switch between sessions with \:conversation\ (or \:c\), clone conversations with \:clone\, and view system status with \:info\. The plugin includes a dedicated \doctor.zsh\ diagnostic script to verify environment setup, a \forge.theme.zsh\ for displaying agent/model context in the right prompt, and a \keyboard.zsh\ helper for platform-specific ZLE shortcuts. Installation and configuration are handled via \forge.setup.zsh\, which ensures required dependencies like \zsh-autosuggestions\ and \zsh-syntax-highlighting\ are present.

shell-plugin · high confidence

The new \forge\_fs\ crate provides a standardized file system abstraction layer that replaces previous character-based indexing with line-based indexing for file reads. It introduces a custom binary file detector (using BOM analysis and zero-byte heuristics) to prevent binary files from being processed as text, and implements a \read\_range\_utf8\ method that allows reading specific line ranges while returning a content hash of the full file for change detection. The crate also includes utilities for file size retrieval, directory reading, and consistent error handling for I/O and UTF-8 validation.

_crates/forge\fs · high confidence

The forge\_template crate now exposes an Element builder API that allows constructing HTML elements with attributes, text content, and nested children. This new component provides a structured way to generate HTML output, including support for class handling and text escaping, which improves readability and safety in template rendering.

_crates/forge\template · high confidence

Users can now have their conversations persisted to a local SQLite database, enabling conversation history to survive application restarts. The implementation introduces a new \ConversationRepositoryImpl\ that handles upserting, retrieving, and deleting conversations, while ensuring database operations are offloaded to a blocking thread pool to prevent UI freezing.

_crates/forge\repo/src/conversation · high confidence

A new \ToolsOverview\ data structure has been added to the \forge\_app\ DTO module to provide a consolidated view of all available tools. This structure categorizes tools by their source—system, agents, and MCP servers—allowing users to see a comprehensive list of capabilities in one place. The implementation includes a helper method to flatten these categorized tools into a single vector for easier iteration.

_crates/forge\app/src/dto · high confidence

The application now allows agents to be invoked as tools. A new \AgentExecutor\ service handles these calls by creating or reusing conversations, executing the agent via \ForgeApp\, and returning the result as a tool output. An \AgentProviderResolver\ manages provider and model selection for agents, falling back to session defaults when needed. Additionally, \ApplyTunableParameters\ now applies agent-specific settings (temperature, top\_p, top\_k, max\_tokens, reasoning) to the conversation context, and \CommandGenerator\ uses JSON schema structured output for shell command generation.

_crates/forge\app/src · high confidence

The create-plan skill now includes shell scripts (validate-plan.sh, validate-all-plans.sh) that enforce strict formatting and content rules for generated plans. Users must ensure plans follow the YYYY-MM-DD-task-name-vN.md naming convention, reside in the plans/ directory, and contain all required sections (Objective, Implementation Plan, Verification Criteria, etc.). The validator rejects plans containing code blocks or snippets, requiring natural language descriptions instead, and mandates checkbox format for tasks. This ensures consistent, high-quality planning documentation before integration.

.forge/skills/create-plan · high confidence

The new \forge\_select\ crate provides a unified interface for terminal user interactions, replacing direct dependencies on \dialoguer\ across the codebase. It offers builder-based APIs for single-select, multi-select, confirm (yes/no), and text-input prompts, all featuring consistent theming and error handling. The selection components utilize \nucleo\ for fuzzy matching and include support for inline previews. Additionally, input prompts now use \rustyline\ for full line-editing capabilities and automatically handle terminal alternate-screen modes to prevent viewport scrolling issues.

_crates/forge\select · high confidence

The \forge\_display\ crate now provides specialized formatters for terminal output: \SyntaxHighlighter\ adds syntax highlighting to code blocks in markdown using a cached terminal theme detection, \DiffFormat\ renders text diffs with dynamic line-number width and color-coded additions/deletions, and \GrepFormat\ displays search results in a ripgrep-like style with path grouping and regex highlighting. These components replace ad-hoc formatting logic, ensuring consistent, readable output for code snippets, file changes, and search matches.

_crates/forge\display/src · high confidence

The \crates/forge\_repo\ crate now provides the infrastructure implementations for the application's core data repositories. This includes \ForgeAgentRepository\, which loads agent definitions from built-in, global, and project-local sources with a defined precedence order, and \ForgeSkillRepository\, which similarly loads skills from multiple directories including a new \\~/.agents/skills\ location. Additionally, the crate introduces \ForgeContextEngineRepository\ and \ForgeFuzzySearchRepository\ to handle workspace indexing and fuzzy search via gRPC, alongside \ForgeValidationRepository\ for syntax checking. These components are aggregated in \ForgeRepo\ to serve as the single point of access for persistence and external service interactions.

_crates/forge\repo/src · high confidence

Added a new \forge\_spinner\ crate providing two distinct UI primitives: a custom, terminal-safe indeterminate spinner (\ActiveSpinner\) that handles pause/resume, elapsed time formatting, and safe line clearing to prevent flickering and message loss, and a determinate progress bar manager (\ProgressBarManager\) wrapping \indicatif\ for operations with known totals. This replaces ad-hoc terminal output logic with a structured, reusable component for displaying task status and progress.

_crates/forge\spinner · high confidence

The \forge\_domain\ crate now includes core domain structures for authentication flows (API key, OAuth device/code, Google ADC, AWS profile), chat response handling (including reasoning, tool calls, and interruptions), and context compaction strategies (eviction, retention, min/max composition). These changes provide the foundational types and logic for secure provider authentication, structured agent communication, and context window management.

_crates/forge\domain · high confidence

The \forge\_snaps\ crate now provides a \SnapshotService\ that allows users to create snapshots of file contents and subsequently undo changes by restoring the most recent snapshot. This feature enables reverting file modifications to a previously saved state, with built-in handling for missing snapshots and directory management.

_crates/forge\snaps · high confidence

Added a new \forge\_walker\ crate that provides a configurable file system walker. The walker allows users to control traversal depth, breadth, and file size limits, and includes logic to skip binary files based on a defined list of extensions (e.g., .exe, .jpg, .zip). It also respects standard ignore filters and excludes symlinks and hidden files by default, matching common CLI tool behaviors like \fd\.

_crates/forge\walker · high confidence

The new \crates/forge\_api\ crate exposes a single \API\ trait and \ForgeAPI\ implementation that consolidates access to core capabilities including model and provider management, conversation persistence (create, list, delete, rename, compact), shell command execution, MCP configuration management, agent and skill discovery, and commit generation. This centralizes the interface for these features, replacing scattered access points with a consistent, typed API layer.

_crates/forge\api · high confidence

The new \forge\_json\_repair\ crate provides a JSON repair parser that tolerates malformed input commonly generated by LLMs, such as missing commas, unquoted keys, trailing commas, and truncated structures. It also includes schema-based type coercion to automatically convert string values to their expected types (e.g., numbers, booleans) when a JSON schema is provided, ensuring tool arguments match the required contract.

_crates/forge\_json\repair · high confidence

The CLI now features an interactive fuzzy-finder for command and file completion. Typing a command prefix (starting with \/\ or \:\) opens a picker to select from available commands, while typing a search term (prefixed with \@\) triggers a fuzzy search across workspace files with a live preview. This replaces the previous autocomplete mechanism with a more robust, widget-based selection experience.

_crates/forge\main · high confidence

The \forge.proto\ file defines the \ForgeService\ gRPC interface, exposing RPCs for workspace management, file operations (upload, delete, list, chunk), syntax validation, skill selection, and fuzzy search. It also introduces the \BuildTextPatch\ RPC for generating text patches via fuzzy replacement, alongside message definitions for nodes, relations, and queries that support the context engine's data model.

_crates/forge\repo/proto · high confidence

The services layer now includes an in-memory \ForgeAgentRegistryService\ that lazily loads and caches agents from the repository, managing the active agent ID and providing reload capabilities. Additionally, file indexing and discovery are now governed by a new \allowed\_extensions.txt\ whitelist, which restricts indexed files to a specific set of source-code extensions and explicitly excludes lock files and symlinks to improve sync performance and accuracy.

_crates/forge\services/src · high confidence

A new \truncation\ module has been added to \crates/forge\_app\ to handle output size limits for tool results. This introduces specific truncation strategies: fetch content is truncated by character count; search results support both line-based and byte-based limits; and shell command outputs (stdout/stderr) are clipped by line count with configurable prefix/suffix lines and maximum line lengths. These changes ensure that large tool outputs are safely truncated before being returned to the user.

_crates/forge\app/src/truncation · high confidence

The \forge\_repo\ crate now includes a dedicated database module that manages a SQLite connection pool with exponential backoff retry logic for both pool creation and connection acquisition, ensuring resilience against transient locks. It automatically runs embedded Diesel migrations on startup, covering schema changes such as the creation of the \conversations\ table (with performance indexes and a metrics column), the temporary addition and subsequent removal of the \indexing\_auth\ table, and the creation and removal of the \workspace\ table. SQLite-specific optimizations like WAL mode and busy timeouts are applied to improve concurrency.

_crates/forge\repo/src/database · high confidence

The new \forge\_markdown\_stream\ crate provides a streaming markdown renderer optimized for terminal output, allowing LLM responses to be rendered incrementally as they arrive. It supports syntax-highlighted code blocks (using \syntect\ with dark/light themes), styled headings (with uppercase H1 and dimmed prefixes), nested lists with cycling bullet characters, task list checkboxes, and tables with inline formatting (bold, italic, code, links). The renderer preserves Korean spacing in structured output and handles malformed markdown repair, such as embedded closing code fences.

_crates/forge\_markdown\stream · high confidence

The \forge\_tracker\ crate now provides a comprehensive analytics and logging infrastructure. It integrates with PostHog to send telemetry events (such as login status, tool calls, and system traces) while enforcing a rate limit of 1,000 events per minute to prevent dispatch loops. Logging is automatically routed to PostHog when tracking is enabled, or falls back to local JSON file logging otherwise. The system also includes logic to suppress tracking for development builds (versions containing 'dev' or '0.1.0') and exposes a public version constant for external use.

_crates/forge\tracker/src · high confidence

The \crates/forge\_app/src/dto/anthropic\ module has been introduced to handle Anthropic API data structures. This includes request and response types that support structured output schemas, adaptive thinking (reasoning effort), and cache control for system messages. The response handling now accurately accumulates usage tokens, including cache read and creation costs, and correctly maps model metadata such as context lengths and input modalities for Claude 3, 4, 5, Mythos, and Fable models. An error type for overloaded states is also defined.

_crates/forge\app/src/dto/anthropic · high confidence

A new 'resolve-conflicts' skill has been added to the .forge/skills directory to provide a structured, plan-first approach for resolving Git merge conflicts. The skill guides users through assessing conflict scope, creating a detailed resolution plan for approval, and executing specific strategies for different file types (e.g., merging imports/tests, regenerating lock files, handling deleted-modified files). It includes a bash script to back up and analyze deleted-but-modified files, a validation script to ensure all conflicts are cleared, and reference documents detailing resolution patterns for imports, tests, lock files, and configuration files.

.forge/skills/resolve-conflicts · high confidence

This change introduces a new \forge\_app/dto/openai\ module that standardizes how the application parses and serializes data for OpenAI-compatible APIs, with specific support for GitHub Copilot. It adds dedicated DTOs for Copilot's unique model listing response (including policy and capability parsing), handles numeric pricing formats from providers like Chutes, and improves reasoning field handling by merging \reasoning\ and \reasoning\_content\ fields to prevent data loss from providers emitting both. The module also includes robust error parsing for nested error structures and test fixtures for various error scenarios.

_crates/forge\app/src/dto/openai · high confidence

The \crates/forge\_tool\_macros\ crate introduces a \ToolDescription\ derive macro that generates the \ToolDescription\ trait implementation for structs or enums. Users can now specify a tool's description by pointing to an external markdown file via the \\#\[tool\_description\_file("path")\]\ attribute, or by using standard Rust doc comments. The macro reads the file content at compile time (or parses doc comments) and provides the description string, with automatic trimming of surrounding whitespace and quotes from doc attributes.

_crates/forge\_tool\macros · high confidence

The \forge\_ci\ crate now includes a new \workflows\ module that programmatically generates GitHub Actions YAML files for the repository. This adds support for automated code quality checks via an autofix workflow, comprehensive bounty management with label synchronization, a main CI pipeline featuring code coverage and performance benchmarks, automated release drafting and publishing to npm and Homebrew, label synchronization, and automatic closing of stale issues and pull requests.

_crates/forge\ci/src/workflows · high confidence

The \crates/forge\_app/src/dto/openai/transformers\ module now implements a comprehensive request transformation pipeline (\ProviderPipeline\) that automatically adapts outgoing API requests to match the specific requirements of various providers. This includes merging multiple system messages into a single leading message for providers like NVIDIA and vLLM, enforcing strict JSON schemas for tool definitions and response formats, and handling provider-specific quirks such as mapping \max\_tokens\ to \max\_completion\_tokens\ for OpenAI, stripping unsupported parameters for xAI and Cerebras, and converting structured reasoning details into flat \reasoning\_content\ fields for DeepSeek and Xiaomi MiMo. The pipeline also applies model-specific optimizations, such as setting default temperature and top-k values for MiniMax models, managing prompt caching breakpoints for Anthropic and Gemini, and ensuring tool choice logic is correctly applied only when tools are defined.

_crates/forge\app/src/dto/openai/transformers · high confidence

A new skill named 'resolve-fixme' has been added to the .forge/skills directory, providing a structured workflow for finding and implementing code marked with FIXME comments. This skill includes a discovery script (find-fixme.sh) that scans the codebase for FIXMEs, capturing surrounding context and grouping related tasks across multiple files. Users can now trigger this skill to automatically identify, consolidate, and resolve pending implementation tasks, ensuring that FIXME comments are only removed after the underlying code changes are verified complete.

.forge/skills/resolve-fixme · high confidence

The shell plugin now includes dedicated action handler scripts for managing authentication (login/logout), configuration (agent, model, reasoning effort, session overrides, and config reload), and conversation workflows (switching, cloning, copying, and renaming). These handlers enable users to interactively select providers, models, and agents, apply session-scoped settings that do not persist to the global config, and manage conversation history directly from the shell prompt.

shell-plugin/lib/actions · high confidence

A new skill named 'github-pr-comments' has been added to help users address code review feedback on pull requests. It includes a script that fetches active, unresolved review threads from GitHub via the GraphQL API, pairing each comment with its surrounding code context. The skill guides the user to create a todo list for each comment, apply suggested changes or infer fixes for free-form feedback, and verify the result by running cargo check and cargo nextest.

.forge/skills/github-pr-comments · high confidence

This change introduces a new \tool\_services\ module in \crates/forge\_services/src/tool\_services\ containing concrete implementations for core agent tools. The \fetch\ service now retrieves web content as markdown, explicitly rejecting binary responses and hardening HTML sniffing to prevent processing non-text data. The \fs\_read\ service has been enhanced to support reading images (JPEG, PNG, WebP, GIF) and PDFs by detecting MIME types and returning them as base64-encoded content, alongside existing text file reading with line truncation and size limits. The \fs\_write\ service now normalizes line endings to match the target file's style (CRLF on Windows, LF elsewhere) before writing, ensuring consistent formatting. The \fs\_patch\ service implements exact text matching with CRLF-aware normalization and range-based replacements. The \fs\_search\ service uses \grep\-based regex matching with file type and glob filtering. The \shell\ service now supports passing custom environment variables to executed commands. Additionally, new services include \image\_read\ for dedicated image handling, \plan\_create\ for structured plan files, \skill\ for loading domain-specific skills, and \followup\ for interactive clarification. All services implement their respective traits from \forge\_app\ and coordinate with infrastructure for file I/O, snapshots, and validation.

_crates/forge\_services/src/tool\services · high confidence

A new skill has been added to generate enthusiastic, user-facing release notes by fetching live data from GitHub. The skill includes a script to retrieve release metadata and linked PR details, and another to validate that the output stays under 2000 characters. The generated notes follow specific guidelines: they exclude internal implementation details, PR/issue references, and core team/bot contributors, focusing instead on clear, factual descriptions of features and fixes.

.forge/skills/write-release-notes · high confidence

The client ID tracking mechanism now uses platform-specific implementations to generate persistent identifiers. On Android, a UUID is stored in a local file within the user's home directory, while on other platforms, a hardware-based ID is generated using system and CPU core information. This ensures consistent client identification across different operating environments.

_crates/forge\_tracker/src/client\id · high confidence

The new \forge\_infra\ crate consolidates all infrastructure implementations into a single location, providing thread-safe console output via \StdConsoleWriter\, centralized configuration management through \ForgeEnvironmentInfra\ with in-memory caching, and dedicated services for file operations, directory reading, shell command execution, HTTP requests, gRPC communication, and key-value caching. This change centralizes how the application interacts with the file system, network, and environment, ensuring consistent error handling and configuration access across all components.

_crates/forge\infra/src · high confidence

The \crates/forge\_repo/src/provider\ module has been restructured into a dedicated provider repository layer that centralizes chat and model-listing requests for OpenAI, Anthropic, Google, Amazon Bedrock, and OpenCode Zen. This change introduces a \ForgeChatRepository\ that routes requests to the correct backend based on provider type, enabling features like background model cache refresh and structured output enforcement. It also adds specific authentication support for Anthropic (OAuth tokens and Vertex AI ADC) and Bedrock (Bearer tokens and AWS profiles), along with behavioral fixes such as sanitizing Bedrock tool call IDs to match required patterns and enabling prompt caching for supported models.

_crates/forge\repo/src/provider · high confidence

This change introduces a suite of new transformers in the Anthropic DTO layer to ensure requests conform to Anthropic API requirements and Claude Code conventions. Tool names are now normalized (e.g., \read\ to \Read\) and MCP tool names are converted to the \mcp\_\server\\_tool\ format expected by Claude Code. Tool call IDs are sanitized to match the required alphanumeric pattern, and invalid tool call inputs are wrapped to ensure they are objects. Output schemas are enforced to include \additionalProperties: false\, while the \output\_format\ field is removed for Vertex AI compatibility. Additionally, reasoning support now correctly strips \top\_k\ and \top\_p\ parameters, and a new caching strategy ensures system messages and the first/last conversation messages are cached to stabilize prompt costs.

_crates/forge\app/src/dto/anthropic/transforms · high confidence

Users now have a unified, TOML-based configuration system (\ForgeConfig\) that consolidates settings previously scattered across the application. This change introduces a new default configuration directory (\\~/.forge\) while maintaining backward compatibility by automatically detecting and reading from the legacy \\~/forge\ path if it exists, ensuring no disruption for existing users. The new system supports granular control over context compaction (e.g., retention windows, token thresholds), automatic update frequencies, and reasoning effort levels. It also includes a built-in migration path that converts legacy JSON configs into the new TOML format, and improves data integrity by using a custom \Decimal\ type to prevent floating-point serialization noise in the config files.

_crates/forge\config/src · high confidence

The MCP service now enforces a trust gate for project-local \.mcp.json\ configurations, prompting users to accept or reject untrusted servers and persisting that decision in a trust store to avoid repeated prompts. It also tracks connection failures per server, exposing full error details for diagnostics, and uses a config-hash mechanism to safely reinitialize servers only when the configuration changes, preventing race conditions during concurrent initialization.

_crates/forge\services/src/mcp · high confidence

The CI configuration in \crates/forge\_ci/src/jobs\ has been rewritten in Rust using the \gh\_workflow\ library, introducing structured job definitions for the entire release pipeline (drafting, building with cross-compilation via \taiki-e/setup-cross-toolchain-action\, Homebrew, and NPM publishing), a new bounty management workflow with label synchronization, and dedicated linting jobs for \clippy\ and \fmt\. This change also standardizes the checkout action to v6, adds explicit Protobuf compiler setup for non-cross builds, and implements a state-reconciliation model for bounty labels to ensure consistent issue labeling.

_crates/forge\ci/src/jobs · high confidence

The \crates/forge\_app/src/transformers\ module introduces a suite of new transformers to improve context management and API compatibility. A \SummaryTransformer\ pipeline now reduces context size by dropping system messages, deduplicating consecutive user/assistant messages, trimming redundant file operations, and stripping working directory prefixes from file paths. Additionally, \DropReasoningOnlyMessages\ prevents API errors by removing assistant messages that contain only reasoning content, while \ModelSpecificReasoning\ normalizes reasoning configurations (such as effort levels and token budgets) to match the specific API contracts of various Anthropic model families, including Opus 4.7, Opus 4.8, and Sonnet 5.5.

_crates/forge\app/src/transformers · high confidence

The \crates/forge\_app/src/hooks\ module now includes dedicated handlers that modify agent behavior during conversation lifecycles. The \CompactionHandler\ automatically compresses conversation context when token limits are approached, helping manage memory and costs. The \DoomLoopDetector\ identifies repetitive tool-call patterns (such as consecutive identical calls or repeating sequences) to prevent the agent from wasting tokens in unproductive loops. Additionally, the \PendingTodosHandler\ injects reminders into the conversation when the agent signals task completion while todo items remain pending, ensuring follow-through on outstanding work. These hooks are registered in \mod.rs\ and operate on specific lifecycle events (start, request, response, end) to enforce these policies transparently.

_crates/forge\app/src/hooks · high confidence

The \forge\_app\ crate now uses a new formatting module (\crates/forge\_app/src/fmt\) to generate structured \ChatResponseContent\ for tool interactions. Input formatting (\fmt\_input.rs\) provides human-readable titles and subtitles for tool calls (e.g., showing file paths and line ranges for \Read\, or command details for \Shell\). Output formatting (\fmt\_output.rs\) renders tool results, specifically showing diffs for file writes and patches, and formatted lists for todo operations. A dedicated \todo\_fmt.rs\ module handles the styling of todo items, using icons and ANSI colors to distinguish between pending, in-progress, completed, and cancelled states, as well as highlighting changes in todo diffs.

_crates/forge\app/src/fmt · high confidence

The system prompt provided to the agent has been updated to include a new \\<workspace\_extensions\>\ section within the system information block. This section lists the distribution of file extensions in the current workspace (e.g., \.rs\, \.md\, \.toml\) along with their counts and percentages. For larger workspaces, the list is truncated to the top 15 extensions to manage context size. This change helps the agent understand the project's technology stack and file structure at a glance, potentially improving its ability to navigate and edit code appropriately.

_crates/forge\_app/src/orch\spec/snapshots · high confidence

The test snapshots for the OpenAI responses provider have been updated to show the current state of tool definitions sent to the API. The 'all catalog tools' snapshot now includes the 'read' and 'write' tools with strict mode enabled and nullable fields converted to anyOf structures for compatibility. The 'tools' snapshot reflects changes to the 'shell' tool, which now requires 'alpha' and 'zebra' string parameters alongside 'output\_mode'. These changes align with recent fixes for strict mode compatibility and schema normalization.

_crates/forge\_repo/src/provider/openai\responses/snapshots · medium confidence

The application now includes two new internal crates, \forge\_eventsource\ and \forge\_eventsource\_stream\, which vendor the \reqwest-eventsource\ and \eventsource-stream\ libraries. \forge\_eventsource\_stream\ provides the low-level parsing of Server-Sent Events (SSE) from byte streams, while \forge\_eventsource\ wraps this with \reqwest\ integration, adding automatic retry logic (defaulting to exponential backoff) and connection state management. This change replaces external dependencies with maintained internal versions to ensure stability and control over the SSE implementation.

_crates/forge\_eventsource\stream · high confidence

The Zsh plugin now includes dedicated modules for keybindings, completion, and terminal context capture. Keybindings are re-applied after zsh-vi-mode initialization to prevent silent clobbering, and a custom bracketed-paste handler automatically wraps dropped file paths in @\[\] syntax while ensuring proper buffer redisplay. Completion now supports fuzzy selection for both :commands and @ file paths via the Rust-based picker. Additionally, the plugin captures terminal context by maintaining a ring buffer of recent commands and emitting OSC 133 semantic markers for compatible terminals (Kitty, WezTerm, iTerm, etc.), which are then passed to the Forge CLI to provide richer context for AI interactions.

shell-plugin/lib · high confidence

Add patch\_exact\_match benchmark for evaluating patch tool usage; Add snapshot tests for diff and grep display formatting; Added debug-cli skill with testing scripts; Added diagnostic and testing scripts for CLI performance, porcelain output, and Zsh formatting; Added evaluation benchmark for todo\_write tool usage; Added orchestrator specification tests for conversation flow and system prompts; Added reasoning-effort configuration and validation tests; Added schema validation test for ForgeConfig; Added tests for CI workflow generation functions; Snapshot tests added for changed-files, command generation, compaction, and file operations; Snapshot tests added for model fetching and request conversion across providers; Snapshot tests for subagent tool configuration; Updated snapshot tests for task formatting and file patch diffs.

The project has been restructured into a multi-crate workspace, introducing several new packages including forge\_api, forge\_app, forge\_ci, forge\_config, forge\_display, forge\_embed, forge\_eventsource, forge\_eventsource\_stream, forge\_fs, forge\_infra, forge\_json\_repair, forge\_main, forge\_markdown\_stream, forge\_repo, forge\_select, forge\_services, forge\_snaps, forge\_spinner, forge\_stream, forge\_template, forge\_test\_kit, forge\_tool\_macros, forge\_tracker, and forge\_walker. This restructuring is accompanied by significant dependency updates across the workspace, such as upgrading crossterm to 0.29.0 in forge\_select, posthog-rs to 0.27.0 in forge\_tracker, and various other crates to their latest versions as specified in the new Cargo.toml files.

(dependencies) · high confidence

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

• CAI 43 → 46 (+3.4)
• Rubric changed (rubric-2026.09.9 → rubric-2026.09.17) — scores are not directly comparable.

• Code Health 87 → 87 (+0.1)
• Architecture 96 → 94 (-1.5)
• Maturity 44 → 44 (-0.1)
• Readiness 89 → 85 (-4.2)
• Security 36 → 57 (+21.0)
• Domain Modelling 91 → 90 (-1.5)
• Event Sourcing 100 → 100 (+0.0)
• Accessibility 30 → 30 (+0.0)
• Performance 85 (new)

• High vulnerability: [GHSA redacted] (Cargo.lock)
• High vulnerability: [GHSA redacted] (Cargo.lock)
• Hotspot: crates/forge_main/src/ui.rs (crates/forge_main/src/ui.rs)
• Hotspot: crates/forge_repo/src/provider/openai.rs (crates/forge_repo/src/provider/openai.rs)
• Hotspot: crates/forge_repo/src/provider/openai_responses/response.rs (crates/forge_repo/src/provider/openai_responses/response.rs)
• Hotspot: crates/forge_repo/src/provider/provider_repo.rs (crates/forge_repo/src/provider/provider_repo.rs)
• Hotspot: crates/forge_select/src/preview.rs (crates/forge_select/src/preview.rs)
• Members sharing a duplicated core (4 members, 50+ identical tokens) (crates/forge_repo/src/provider/anthropic.rs)
• Off-boarding risk: anonymized user #1
• Off-boarding risk: anonymized user #2
• Repeated repair: crates/forge_app/src/dto/openai/transformers/pipeline.rs (crates/forge_app/src/dto/openai/transformers/pipeline.rs)
• Repeated repair: crates/forge_app/src/transformers/model_specific_reasoning.rs (crates/forge_app/src/transformers/model_specific_reasoning.rs)
• Repeated repair: crates/forge_repo/src/provider/anthropic.rs (crates/forge_repo/src/provider/anthropic.rs)
• TooManyFields: Request (crates/forge_app/src/dto/openai/request.rs)

• Dependency hygiene PARTLY measured — Cargo dependencies read, dependency currency not (crates.io unreachable)
• Duplicate intent: Both methods appear to retrieve the list of available tools. The naming convention differs ('get' vs 'list') and they reside in different service layers (API vs App), suggesting a lack of clear separation of concerns or a redundant wrapper.
• Duplicate intent: Both methods resolve the provider for a given agent. The API layer duplicates the resolver's functionality.
• Duplicate intent: Both methods retrieve agent information. The API layer duplicates the repository method without a clear differentiator in the signature (both return generic Result).
• Duplicate intent: Both methods retrieve all provider-specific models. The identical naming across different types suggests a copy-paste pattern or lack of abstraction, but the existence of both implies potential redundancy or unclear ownership.
• Duplicate intent: Both methods retrieve the list of available models. Similar to the tools issue, this duplication across API and App layers without clear distinction in signature or naming is inconsistent.
• High CVE: [GHSA redacted] (Cargo.lock)
• High CVE: [GHSA redacted] (Cargo.lock)
• Inconsistent naming and signature for shell execution: The API exposes execute_shell_command and execute_shell_command_raw, while the underlying infrastructure exposes execute_command and execute_command_raw. The 'shell' prefix is inconsistent between layers. Additionally, the parameters differ significantly (API uses working_dir and no env_vars explicitly in the raw version, while Infra uses env_vars and silent), making the mapping unclear.
• Inconsistent return types for similar operations: API.get_agent_model returns ModelId directly, while AgentProviderResolver.get_model returns Result. This inconsistency in error handling (one throws/panics on failure, the other returns a Result) is confusing for API consumers.
• Low cohesion: Context (LCOM4 4) (crates/forge_domain/src/context.rs)
• Medium CVE: [GHSA redacted] (package-lock.json)
• Members sharing a duplicated core (4 members, 50+ identical tokens) (crates/forge_repo/src/provider/anthropic.rs)
• Off the main sequence: forge_config
• Off the main sequence: forge_display
• Off the main sequence: forge_eventsource_stream
• Off the main sequence: forge_fs
• Off the main sequence: forge_json_repair
• Off the main sequence: forge_select
• Off the main sequence: forge_stream
• …and 8 more

• 55 commits — 51 feature/other, 4 fixes

• (root) — 52 commits
• crates/forge_app — 3 commits

• fix: Revert "chore(deps): update rust crate html2md to v0.2.17" (#3951)
• fix: fix(deps): pin html2md to 0.2.15 to fix android build (#3949)
• fix: fix(deps): update rust crate posthog-rs to 0.27.0 (#3941)
• fix: fix: Claude Sonnet 5.5 support for claude_code and anthropic providers (#3947)
• change: chore(deps): update aws-sdk-rust monorepo (#3906)
• change: chore(deps): update aws-sdk-rust monorepo (#3927)
• change: chore(deps): update aws-sdk-rust monorepo (#3932)
• change: chore(deps): update dependency @ai-sdk/google-vertex to v5.0.95 (#3939)
• change: chore(deps): update dependency @ai-sdk/google-vertex to v5.0.98 (#3944)
• change: chore(deps): update dependency @types/node to v24.13.5 (#3882)
• change: chore(deps): update dependency @types/node to v24.13.6 (#3907)
• change: chore(deps): update dependency @types/node to v24.19.0 (#3934)
• change: chore(deps): update dependency ai to v7.0.118 (#3940)
• change: chore(deps): update dependency ai to v7.0.122 (#3945)
• change: chore(deps): update dependency chalk to v6.0.1 (#3938)
• change: chore(deps): update dependency csv-parse to v7.0.3 (#3933)
• change: chore(deps): update dependency p-limit to v7.3.2 (#3883)
• change: chore(deps): update dependency p-limit to v7.3.3 (#3905)
• change: chore(deps): update dependency tsx to v4.23.13 (#3885)
• change: chore(deps): update dependency tsx to v4.23.15 (#3923)
• …and 35 more

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

tailcallhq/forgecode 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.