anomalyco/opencode

This system is an AI-powered coding assistant platform comprising a CLI, a desktop application, and a web console for managing subscriptions and workspaces. It features a v2 architecture built on the Effect framework, utilizing event-sourced sessions and a confined execution environment for safe code generation. The platform supports multi-provider AI inference, comprehensive usage billing via Stripe, and integrates with GitHub for automated issue triage and pull request reviews.

90 changes.

This period focused on establishing the v2 architecture by removing legacy TUI and logging subsystems while introducing a new plugin system and specification documents. It involved building out the core Console platform with SolidStart, implementing enterprise features like sharing and billing, and launching new integrations including a VS Code extension, Slack bot, and GitHub Action.

131 changes.

This period focused on building the foundational v2 architecture, including a new Effect-based runtime, event-sourced session management, and a native LLM core with schema-first APIs. It also involved rewriting the desktop main process, implementing a new plugin system, and establishing comprehensive test coverage for these core subsystems.

Introduces a new \effect-sqlite-node\ package that provides a Node.js-specific SQLite client built on the native \node:sqlite\ module. This client integrates with the existing Effect SQL abstractions, offering features such as WAL journal mode support, foreign key constraints, configurable result/query name transformation, and the ability to load SQLite extensions. It exposes a service layer for dependency injection and includes a dedicated TypeScript configuration for the package.

packages/effect-sqlite-node · high confidence

Introduces a new email rendering system in the console mail package, including reusable React components (Text, Title, A, Span, Wbr, Fonts, SplitString) and a centralized styles module defining the visual theme (colors, typography, spacing). Adds an InviteEmail template that uses these components to render a workspace invitation with the OpenCode logo, a join button, and fallback link text, while loading custom web fonts (JetBrains Mono, Rubik) via the @jsx-email/all library.

packages/console/mail/emails · high confidence

Introduces a new \packages/containers\ package containing Dockerfiles and a build script for prebuilt container images (base, bun-node, rust, tauri-linux, publish) designed to speed up GitHub Actions jobs by baking in large dependencies. These images, based on Ubuntu 24.04, include specific toolchains like Bun 1.3.14, Node.js 24, Rust, and Tauri Linux build dependencies, allowing Linux jobs to run inside containers to reduce setup time.

packages/containers · high confidence

The support console now includes a dashboard that allows staff to look up users and workspaces by email, workspace ID, or API key. This new feature provides a unified interface to view authentication details, account workspaces, and comprehensive workspace data including users, billing, payments, usage, and disabled models.

packages/console/support · high confidence

The workspace keys route now provides a dedicated UI for managing API keys. Users can view a list of existing keys (including name, display value, and creator), copy key values to the clipboard, create new named keys via a form, and delete existing keys. The interface includes empty-state handling, form validation, and responsive styling for the key table.

packages/console/app/src/routes/workspace/\[id\]/keys · high confidence

The desktop package now includes Android adaptive icon definitions for the dev, beta, and prod build channels. These changes add the necessary XML resources (foreground/background drawables and background colors) to ensure the application displays correctly on Android devices, complementing the existing macOS icon generation workflow documented in the new README.

packages/desktop/icons · high confidence

This change introduces new resource adapters in the \packages/console/resource\ directory to support SST-based infrastructure management across different runtime environments. The \resource.cloudflare.ts\ file provides a proxy-based interface for accessing Cloudflare Workers environment variables and secrets, while \resource.node.ts\ implements a Node.js-compatible adapter that bridges SST resources (specifically Cloudflare Buckets and KV namespaces) with the Cloudflare API client for local development or Node.js execution. These files, along with the new \bun.lock\, \tsconfig.json\, and \sst-env.d.ts\, establish the foundational resource resolution layer for the console package, enabling consistent access to cloud resources regardless of the execution context.

packages/console/resource · high confidence

A new POST endpoint has been introduced at the Zen v1 chat route to handle chat completions using an OpenAI-compatible format. This endpoint leverages a shared handler to parse incoming requests, extracting the model identifier, API key, and streaming status from the request body and headers, while also supporting variant parsing for model differentiation.

packages/console/app/src/routes/zen/v1/chat · high confidence

New TypeScript configuration files and SST environment type declarations have been added for the \packages/console/function\ and \packages/console/mail\ locations. The \tsconfig.json\ in the console function package extends the Node 22 base configuration, sets the module system to ESNext with bundler resolution, and includes type definitions for Cloudflare Workers, Bun, and Node. Additionally, auto-generated \sst-env.d.ts\ files are now present in both the console function and mail packages to support SST-specific type checking.

packages/console/function · high confidence

Added a new catch-all route handler at \packages/console/app/src/routes/t/\[...path\].tsx\ that proxies requests to the enterprise OpenCode API. This route extracts the user's locale from headers or cookies and forwards it via the \accept-language\ header, enabling locale-specific URL handling for the console application.

packages/console/app/src/routes/t · high confidence

The enterprise package now includes basic route definitions for the home page, a share view, and a 404 not-found handler. The home route displays a simple 'Hello World' message, the share route renders its children, and the 404 route provides a styled error page with links to the home and about pages.

packages/enterprise/src/routes · high confidence

Introduced a new SerializeAddon for the embedded terminal that allows serializing the terminal buffer contents (including text, attributes like bold/italic/underline, and colors) into a string format that can be written back to restore the terminal state. This includes support for preserving ANSI color codes, 256-color palettes, RGB truecolors, and background colors, with options to exclude modes or specific buffer ranges.

packages/app/src/addons · high confidence

Introduces a new 'smoke' theme configuration and a corresponding TUI plugin implementation. The \smoke-theme.json\ file defines a comprehensive set of color tokens (based on the Nord palette) for both dark and light modes, covering UI elements like backgrounds, text, borders, and syntax highlighting. The \tui-smoke.tsx\ file implements a demo plugin that utilizes the OpenTUI framework, featuring a tabbed interface (overview, counter, help), custom keybindings for navigation and modals, and dynamic styling that adapts to the current theme.

.opencode/plugins · high confidence

A new script has been added to automatically generate the site's sitemap.xml file. It scans the main application's static routes (including the new /go landing page) and the documentation directory for .mdx files, then outputs a combined sitemap that respects locale-specific URL structures.

packages/console/app/script · high confidence

The CLI now includes specific handler implementations for managing the background service and debugging agents. Users can start, stop, restart, and check the status of the service via the CLI, as well as retrieve the service password. Additionally, a new debug command allows listing available agents in the current directory, with results sorted by ID and output as formatted JSON.

packages/cli/src/commands/handlers/debug, packages/cli/src/commands/handlers/service · high confidence

The console application has been initialized with a new SolidStart-based architecture, introducing server-side rendering and client hydration entry points. This change adds comprehensive internationalization support, including locale detection from URL paths and request headers, automatic HTML language/direction attributes, and cookie-based state persistence. A new middleware layer enforces security by sanitizing server action requests and manages referral code tracking via cookies. The app root now integrates meta providers for favicons and fonts, while a central configuration file defines base URLs, social links, and static GitHub statistics.

packages/console/app/src · high confidence

The console application now includes full localization dictionaries for Arabic, Brazilian Portuguese, Danish, German, English, Spanish, and French. These files provide translated strings for the navigation menu, footer, workspace management, error messages, and home page content, enabling the console UI to display in these languages. The translations also include specific Go subscription promo text for DeepSeek V4.1 Flash.

packages/console/app/src/i18n · high confidence

The console application directory has been initialized with a new project structure based on SolidStart and Nitro, configured to deploy to Cloudflare Workers. This includes a Vite build configuration setting the development server to port 3001, TypeScript settings for Solid.js, and environment file exclusions in .gitignore.

packages/console/app · high confidence

The desktop main process has been rewritten for the v2 architecture, introducing a new Electron-based entry point that manages the background CLI sidecar, local server spawning, and WSL integration. This update adds robust attachment handling with a 20 MB size limit and scoped file authorizations, a buffered SQLite draft store for improved composer performance, and a new debug tool to force focus states via the Chrome DevTools Protocol. It also includes a migration path to import settings from previous Tauri-based installations, system certificate trust, and a new 'Export Debug Logs' feature that packages application logs and crash reports into a zip file for troubleshooting.

packages/desktop/src/main · high confidence

The web package has been replaced with a new documentation site built on Astro and the Starlight theme. This change introduces a multi-locale documentation structure supporting 17 languages, a new dark/light mode logo set, and a custom footer component with language selection and edit links. The site is configured for server-side output with Cloudflare hosting and includes specific robots.txt rules to exclude shared content pages from indexing.

packages/web · high confidence

The desktop renderer's internationalization layer has been significantly expanded with the addition of translation dictionaries for numerous new locales, including Amharic (am), Arabic (ar), Azerbaijani (az), Bulgarian (bg), Bengali (bn), Basque (br), Bosnian (bs), Catalan (ca), Czech (cs), Danish (da), German (de), Dhivehi (dv), Dzongkha (dz), Greek (el), English (en), Spanish (es), Estonian (et), Persian (fa), Finnish (fi), Faroese (fo), French (fr), Hindi (hi), Croatian (hr), Hungarian (hu), Armenian (hy), Indonesian (id), Icelandic (is), and others. These new language files provide translations for core desktop-specific UI strings, such as menu options (check for updates, install CLI, reload webview), file dialogs, update status messages, and CLI installation prompts, ensuring these features are accessible in a wider range of languages.

packages/desktop/src/renderer/i18n · high confidence

The client package now includes a complete, auto-generated HTTP API client and an Effect-based SDK for interacting with the OpenCode server. This change introduces a build script that generates TypeScript code from the \ClientApi\ contract, producing two distinct client implementations: a standard Promise-based client in \src/generated\ and an Effect-based client in \src/generated-effect\. The generated code covers all server groups (health, location, agents, sessions, messages, models, providers, integrations, credentials, permissions, files, commands, skills, events, ptys, questions, references, and projectCopies) and includes specific type definitions for error handling (e.g., \ClientError\, \SessionNotFoundError\) and input/output shapes. The \effect.ts\ module re-exports schema types from \@opencode-ai/schema\ to support the Effect client, while \contract.ts\ defines the API structure and middleware requirements. This provides a robust, type-safe foundation for client-side communication with the server.

packages/client/src · high confidence

A new server-side route at /honeycomb/webhook has been added to receive alerts from Honeycomb and forward them to Discord. The endpoint validates incoming requests using a shared secret token and parses payloads for specific alert types (model HTTP errors, low TPS, provider HTTP errors, and custom alerts). When a triggered alert is received, it formats a message including the alert name, relevant metrics (TPS or error percentage), and a mention of the configured Discord alert role, then posts it to the designated Discord incident webhook.

packages/console/app/src/routes/honeycomb · high confidence

The \packages/function\ directory now includes a \tsconfig.json\ and an auto-generated \sst-env.d.ts\ file, establishing the TypeScript compilation settings and SST environment types for this package. The configuration extends the Node 22 base, targets ESNext modules with bundler resolution, and includes type definitions for Cloudflare Workers and Node.

packages/function · high confidence

The .opencode directory now includes essential configuration files to define the application's environment and behavior. A new .gitignore file excludes build artifacts (node\_modules, lockfiles) and generated content (plans, references). An env.d.ts file provides TypeScript declarations for importing .txt assets. The opencode.jsonc file establishes the base configuration, including provider settings, permission scopes, project references (Effect-TS and local data), MCP settings, and disabled GitHub tools. Additionally, tui.json configures the terminal user interface, specifically enabling a plugin for workspace interaction with custom keybindings.

.opencode · high confidence

This change introduces the foundational configuration files for the \packages/console/core\ package. It adds a Drizzle ORM configuration (\drizzle.config.ts\) set up for a MySQL dialect using SST resource references, a TypeScript configuration (\tsconfig.json\) extending Node 22 with ESNext modules and React JSX support, an SST environment type declaration (\sst-env.d.ts\), and a \.gitignore\ file to exclude specific scripts. This establishes the build and database migration infrastructure for the new core module.

packages/console/core · high confidence

The \packages/ui\ directory is now published as a standalone npm package, providing a shared design system and UI components for the application. This release includes the core component library, a comprehensive color token system (including the OC-2 theme), and build tooling scripts for packaging and publishing. It also introduces strict localization guidelines via \AGENTS.md\ to ensure all user-facing strings are externalized for translation, and adds a new v3 SVG favicon and PWA manifest for improved web presence.

packages/ui · high confidence

This change introduces the foundational structure for the opencode VS Code extension within the \sdks/vscode\ directory. It establishes the build pipeline using esbuild for bundling TypeScript into a CommonJS extension, configures ESLint with TypeScript-specific rules for code quality, and sets up the test runner via \@vscode/test-cli\. The entry includes the necessary configuration files (tsconfig, gitignore, vscodeignore), build scripts for publishing and versioning, and references to the extension's branding assets, effectively preparing the SDK for development and distribution.

sdks · high confidence

The repository is initialized with essential configuration files to standardize development workflows and environment isolation. A \.dockerignore\ file is added to exclude build artifacts and local state from Docker contexts, while \.editorconfig\ enforces consistent code formatting (UTF-8, LF line endings, 2-space indentation). An \.oxlintrc.json\ file introduces the Oxlint linter with type-aware rules for catching unhandled promises and spread misuse, alongside specific overrides for Effect and SolidJS patterns. Additionally, \.gitattributes\ marks generated migration files to prevent them from being highlighted in diffs, and \.gitleaksignore\ excludes hardcoded test secrets from security scans.

(repo-wide) · high confidence

This change introduces the foundational structure for the new \packages/enterprise\ application, which is built using the SolidStart framework. It includes the necessary configuration files such as \tsconfig.json\ for TypeScript settings, \vite.config.ts\ for the build toolchain (including Tailwind CSS and Nitro integration), and a \.gitignore\ file. A \README.md\ provides standard instructions for creating, developing, and building the project, while \sst-env.d.ts\ sets up environment type definitions for the SST infrastructure-as-code tool. Additionally, a \test-debug.ts\ script is included to facilitate initial testing of core sharing and storage functionalities.

packages/enterprise · high confidence

The CLI package now includes foundational configuration files to support its development environment. A new \bunfig.toml\ registers \@opentui/solid/preload\ as a preload module, and \tsconfig.json\ is configured to extend the Bun base configuration while setting JSX to preserve mode with \@opentui/solid\ as the import source. Additionally, an auto-generated \sst-env.d.ts\ file is added to provide TypeScript definitions for the SST framework.

packages/cli · high confidence

The new \@opencode-ai/http-recorder\ package allows you to record real HTTP and WebSocket traffic once and replay it from deterministic JSON cassettes, enabling reliable testing for provider integrations, retries, and multi-step flows. Built on Effect 4 beta, it provides \HttpRecorder.http\ and \HttpRecorder.socket\ to seamlessly switch between live requests and recorded responses without changing application code. The recorder includes secure defaults for redacting sensitive headers, URLs, and JSON bodies, and enforces strict request ordering to correctly model repeated or concurrent interactions.

packages/http-recorder · high confidence

A new private build-time tool, @opencode-ai/httpapi-codegen, has been added to generate TypeScript client APIs from Effect HttpApi contracts. It produces two distinct client variants: a zero-Effect Promise client that uses standard fetch, and a rich Effect client that leverages Effect-native values and runtime schemas. The generator handles complex API features including streaming endpoints, error mapping, and input field flattening, while ensuring type safety and preventing transport drift through executable tests and regeneration checks.

packages/httpapi-codegen · high confidence

A new transitional package, @opencode-ai/sdk-next, is added to provide an Effect-native, in-process host for OpenCode applications. It executes the server's HTTP router in memory without opening network listeners, preserving the same routing, middleware, handlers, codecs, and errors as the network client. The package exposes session management (including live event streams, active sessions, and session runtime operations), tool registration via a local-only API, and an embedded host with its own DI layer. It replaces the former @opencode-ai/core/public facade for tool registration and is designed to replace the existing generated @opencode-ai/sdk after consumers migrate.

packages/sdk-next · high confidence

The \packages/codemode\ package now provides a confined JavaScript execution environment that allows models to write programs calling only explicitly supplied, schema-described tools, keeping the interpreter isolated from ambient filesystem, network, or module authority. It includes an OpenAPI adapter (\OpenAPI.fromSpec\) that converts OpenAPI 3.x documents into a tree of CodeMode tools, handling supported parameter encodings (form, deepObject, simple) and authentication schemes (bearer, basic, header, apiKey) while safely skipping unsupported operations. Hosts can use \CodeMode.execute\ for one-off runs or \CodeMode.make\ to create reusable runtimes with configurable limits and discovery catalogs.

packages/codemode · high confidence

The \http-recorder\ package now provides a complete HTTP and WebSocket recording/replay system. It introduces a default "auto" mode that records new interactions and replays existing ones, while \CI=true\ forces strict replay. The recorder includes a built-in redactor that automatically sanitizes sensitive data (such as API keys, tokens, and passwords) from request/response bodies, headers, and URLs before saving cassettes. It also supports custom request matching, configurable redaction policies, and atomic file writes to ensure cassette integrity.

packages/http-recorder/src · high confidence

This change adds Nix derivations to build the OpenCode CLI and a new Electron-based Desktop application. The CLI derivation builds the core tool using Bun, installs shell completions, and bundles the JSON schema. The new Desktop derivation packages the application into a native .app bundle on macOS and a Linux package, handling Electron integration, desktop icons, and ad-hoc code signing on Darwin. Both derivations rely on a new node\_modules derivation that fetches dependencies via Bun with platform-specific hashes, and they include patches to relax Bun version checks and adjust resource paths for the Nix environment.

nix · high confidence

The CLI now defines the command-line interface structure for the OpenCode 2.0 preview, establishing a new set of commands including 'api' for making server requests, 'debug' for troubleshooting, 'migrate' for upgrading data from v1 to v2, 'service' for managing the background server, and 'serve' for starting the v2 API server. This change implements the command registry and argument/flag specifications for these features within the CLI package.

packages/cli/src/commands · high confidence

The application now features a new Settings v2 interface, replacing the previous layout with a tabbed dialog structure. This update introduces dedicated views for managing servers (including WSL support and search), AI model providers (with connection/disconnection controls), and model visibility (with grouping and search). The General tab has been rebuilt to support granular appearance settings (themes, color schemes, and distinct UI/code/terminal fonts), auto-accept permissions scoped to specific server directories, shell selection, and sound notifications. The new UI leverages the v2 component library for a consistent look and feel across all settings sections.

packages/app/src/components/settings-v2 · high confidence

Added a new \@opencode-ai/slack\ package that integrates the application with Slack using the Bolt framework. The bot creates threaded conversations, mapping each Slack thread to a separate opencode session. It supports real-time tool call updates via live events, requires specific OAuth scopes (\chat:write\, \app\_mentions:read\, \channels:history\, \groups:history\), and uses Socket Mode for communication. Configuration is handled via environment variables (\SLACK\_BOT\_TOKEN\, \SLACK\_SIGNING\_SECRET\, \SLACK\_APP\_TOKEN\).

packages/slack · high confidence

A new VS Code extension has been added to the project, providing commands to open and manage an 'opencode' terminal. The extension automatically creates a terminal instance with a specific environment variable to identify the caller as VS Code, waits for the backend to connect, and can append the currently active file path (including line numbers if text is selected) to the terminal prompt. It also includes logic to bring an existing opencode terminal to the front if it is already open.

sdks/vscode · high confidence

Adds a new confined execution environment for running AI-generated JavaScript programs with strict resource limits (timeout, tool call count, and output size) and a sandboxed tool runtime. The package provides a structured API to define tools using Effect Schemas or JSON Schema, execute code within a bounded context, and receive standardized success or diagnostic results, ensuring safe interaction between the model and host tools.

packages/codemode/src · high confidence

The /go route now features a dedicated landing page that displays the current Go model lineup (including Grok 4.7, GPT 5.6 Luna, GLM-5.3, Kimi K3, and DeepSeek V4 variants) along with their data retention policies. The page includes a responsive usage limits graph, provider logos (MiniMax, Zai, Alibaba, DeepSeek, MiMo), and localized hero copy with a subscription call-to-action, providing a centralized view of Go subscription benefits and available models.

packages/console/app/src/routes/go · high confidence

Added the \global-sync\ context module to manage application-wide state, including directory bootstrapping, child store lifecycle management, event reduction, and session indexing. This location introduces the core implementation files (\bootstrap.ts\, \child-store.ts\, \event-reducer.ts\, \home-session-index.ts\, \mcp.ts\, \queue.ts\) alongside their corresponding test suites (\bootstrap.test.ts\, \child-store.test.ts\, \event-reducer.test.ts\, \home-session-index.test.ts\, \mcp.test.ts\, \queue.test.ts\), establishing the foundation for handling server connections, project sessions, and MCP status updates.

packages/app/src/context/global-sync · high confidence

Adds a new \@opencode-ai/llm\ package that provides a schema-first LLM core, establishing a canonical runtime data model via Effect Schema classes for messages, tools, and events. The package introduces a route-first provider architecture that decomposes integrations into protocol, endpoint, auth, and framing layers, allowing new providers to be added with minimal code. It includes provider facades for major services (OpenAI, Anthropic, Google, Bedrock, Azure, etc.) and enables native chronological system message updates. A key behavioral change is that prompt caching is now enabled by default (\cache: 'auto'\), automatically placing breakpoints at the last tool definition, system part, and latest user message to optimize cost and latency across supported providers.

packages/llm · high confidence

The \packages/llm/src/protocols\ directory now contains the core protocol implementations for the LLM package, replacing previous ad-hoc or external handling. This change adds native adapters for Anthropic Messages, AWS Bedrock Converse, Google Gemini, OpenAI Chat Completions, OpenAI Responses, and a generic OpenAI-compatible route. Each adapter defines strict request/response schemas using the \effect\ library, handles provider-specific streaming framing (including AWS event-stream decoding for Bedrock), and implements tool schema projection and media handling (images, documents, audio, video) tailored to each provider's wire format. A shared \shared.ts\ module provides common utilities for token usage calculation, JSON parsing, and media validation, ensuring consistent behavior across all supported LLM providers.

packages/llm/src/protocols · high confidence

The \packages/llm/src/schema\ directory now contains the foundational type definitions for the LLM package, built on the Effect library. This includes a comprehensive error model (\errors.ts\) that classifies provider failures (such as rate limits, authentication issues, and context overflows) and exposes retryability metadata. It also defines a granular event stream schema (\events.ts\) for tracking text, reasoning, and tool interactions, alongside a normalized \Usage\ model that reports inclusive token totals and non-overlapping breakdowns (cached vs. non-cached, reasoning vs. visible output) to ensure consistent billing and context tracking across different providers. Additionally, the schema provides structured message types (\messages.ts\) and model configuration defaults (\options.ts\), establishing the contract for how LLM requests and responses are validated and processed.

packages/llm/src/schema · high confidence

The CLI now utilizes a new command execution framework located in \packages/cli/src/framework\. This change introduces a \Spec\ module for defining command structures and a \Runtime\ module that handles lazy loading and execution of commands using the \effect\ library. Users will experience this as the underlying mechanism for how CLI commands are registered, loaded, and run, potentially affecting command startup performance and error handling paths.

packages/cli/src/framework · high confidence

The CLI package now includes a new main entry point (index.ts) that bootstraps the application using the Effect framework, wiring up command handlers for API requests, debugging, migrations, and service management. Additionally, a new TUI module (tui.ts) has been added to integrate the terminal user interface, featuring a graceful fetch wrapper that provides legacy default configurations for missing endpoints to ensure backward compatibility during the transition.

packages/cli/src · high confidence

The app now includes a structured desktop menu configuration (desktop-menu.ts) that defines platform-specific menu items for actions like exporting logs, checking for updates, and managing windows, along with corresponding tests (desktop-menu.test.ts). Additionally, a new file picker constant file (file-picker.ts) has been added to standardize accepted file types and extensions across the application, ensuring consistent file selection behavior.

packages/app/src · high confidence

This change adds the \github/\ directory, which contains the source code and configuration for the opencode GitHub Action. Users can now integrate opencode directly into their GitHub Actions workflows by using the \anomalyco/opencode/github@latest\ action. The action supports triggering via issue comments and pull request review comments, allowing opencode to explain issues, fix issues by creating PRs, and review PRs. It includes configurable inputs for the model, agent, custom prompts, and mentions, and supports OIDC token exchange or direct GITHUB\_TOKEN usage. The implementation is written in TypeScript using the Bun runtime and depends on the \@opencode-ai/sdk\ and Octokit libraries.

github · high confidence

Added \provider-catalog.ts\ and \use-providers.ts\ hooks to manage AI provider selection based on route context. The \selectProviderCatalog\ function prioritizes a directory-specific provider list when available and ready, falling back to a global catalog for non-explicit routes. The \resolveDefaultModel\ function determines the active model by checking the current server's default first, then falling back to legacy configuration strings. The \useProviders\ hook exposes these resolved providers, including lists of popular, connected, and paid providers, ensuring that session-specific configurations are correctly isolated from global defaults.

packages/app/src/hooks · high confidence

The server package now exposes a new v2 HTTP API built on the Effect framework, providing endpoints for sessions, messages, agents, models, permissions, file system access, and PTY terminals. A key behavioral change is the introduction of session-scoped location routing: the \SessionLocationMiddleware\ automatically resolves the correct workspace and directory context for any request containing a session ID by querying the database, ensuring that session operations are isolated to their specific project location. The server also includes basic authentication via environment variables, CORS configuration, and a live event stream for real-time updates.

packages/server · high confidence

The session runner has been replaced by a new v2 implementation that executes coding-agent sessions using the Effect framework. This runner manages the full lifecycle of a session turn, including translating session history into LLM messages, resolving models from the catalog, and persisting events for text, reasoning, and tool calls. It enforces configured agent step limits, handles interrupted or declined tool permissions, and supports model variants and credentials. The runner also includes a model resolution service that maps catalog models to supported LLM providers (OpenAI, Anthropic, OpenAI-compatible) and handles errors such as missing models or unsupported APIs.

packages/core/src/session/runner · high confidence

The application now features a new v2 layout and home page. The layout (layout-new.tsx) applies safe area insets for mobile devices, integrates the titlebar, and conditionally displays a debug bar in development. The home page (home.tsx) has been redesigned with a grid layout that includes a projects list, a sessions list, and a utility navigation bar. Additionally, a new directory layout (directory-layout.tsx) handles project directory resolution and session data provisioning, while new pages for new sessions (new-session.tsx) and error handling (error.tsx) provide updated user flows for session creation and error reporting.

packages/app/src/pages · high confidence

The core package now provides a new v2 runtime foundation built on the Effect library, replacing legacy patterns with a service-oriented architecture. This change introduces dedicated services for managing agents, models, providers, and the catalog, as well as new capabilities for background job execution, command definitions, and credential storage backed by SQLite. It also establishes a durable event system for state tracking and a new account service to handle authentication flows, effectively consolidating shared infrastructure into the core package to support the v2 session and tool architecture.

packages/core/src · high confidence

The session page now includes a new v2 review panel that features a dedicated inline file browser tab, allowing users to search and open files directly within the session context. The review panel itself has been overhauled to support virtualized file lists for improved performance with large diffs, persistent sidebar state (width, open/close, expand mode), and a new file-diff classification system that accurately maps file statuses (added, deleted, modified) to directory hierarchies. This change also introduces a new state management layer for the review panel and adds comprehensive tests for the diff-kind logic.

packages/app/src/pages/session/v2 · high confidence

The session management layer has been replaced with a new v2 implementation that uses an event-sourced model for inputs and execution. This change introduces automatic context compaction to manage token limits, a snapshot and revert system to restore file states, and a location-based runner coordination system. Users benefit from more resilient session handling, including the ability to interrupt and resume long-running tasks, recover from context overflows, and revert sessions to previous states.

packages/core/src/session · high confidence

The core skill module now includes a new v2 discovery service that safely downloads and caches remote skills from URLs, validating paths and handling versioned updates with atomic swaps. Additionally, a guidance service automatically loads and renders available skills into the system context, respecting agent permissions and providing clear instructions on when and how to use the skill tool.

packages/core/src/skill · high confidence

The \packages/cli/script\ directory now contains the tooling to build, publish, and run the \lildax\ CLI. \build.ts\ compiles the CLI for multiple platform/architecture combinations (Linux, macOS, Windows on x64/arm64, including musl and baseline variants) using Bun. \publish.ts\ packages these platform-specific binaries and publishes them as optional dependencies to the main \@opencode-ai/cli\ package. \generate.ts\ fetches model data for the build, and \bin/lildax.cjs\ serves as the runtime entry point that detects the user's environment and executes the correct pre-compiled binary.

packages/cli/script · high confidence

The \packages/core/src/config\ directory now contains a comprehensive set of TypeScript schema definitions (using the Effect library) for the new ConfigV2 structure. This change adds type-safe configuration models for agents, attachments, commands, compaction, experimental policies, formatters, LSP servers, MCP servers (including local and remote types with timeout and OAuth settings), plugins, providers (with model API, cost, and limit details), project references (Git and local), tool output limits, and file watchers. These schemas define the shape and validation rules for the application's configuration, replacing or supplementing previous ad-hoc or less-strict configuration handling with a unified, schema-driven approach.

packages/core/src/config · high confidence

The console core now includes a comprehensive set of database schema definitions using Drizzle ORM, covering accounts, authentication providers, user roles, workspaces, API keys, and models. It also defines schemas for billing and usage tracking (including subscriptions, payments, coupons, and token-level usage), rate limiting (IP, key, and model TPM/TPS), referrals, and benchmarking. This establishes the data structure for the platform's multi-tenant workspace model, billing logic, and usage monitoring.

packages/console/core/src/schema · high confidence

A new \daemon.ts\ service has been added to the CLI package to handle starting, stopping, and monitoring the background server process. This service manages a registration file to track the server's URL, PID, and version, ensuring that the CLI only connects to a healthy and compatible server instance. It implements a robust lifecycle with automatic retries, graceful shutdown via SIGTERM followed by SIGKILL if necessary, and secure password handling stored in a local file, allowing clients to reconnect without exposing credentials.

packages/cli/src/services · high confidence

The \packages/llm/src/route\ directory now contains the core implementation for a new LLM request routing system. This includes a \Route\ abstraction that declaratively defines provider endpoints, authentication strategies (supporting optional/required API keys and bearer tokens), and transport protocols (HTTP and WebSocket). The layer introduces a structured \Protocol\ interface to separate provider-specific body construction and streaming decoding from deployment details, and an \Executor\ that handles HTTP execution with automatic sensitive data redaction, rate-limit parsing, and retry logic. This change establishes the foundational client-side infrastructure for sending LLM requests, distinct from the provider implementations themselves.

packages/llm/src/route · high confidence

The core package now includes a new Effect-based application node system that provides a typed, hierarchical dependency injection graph. This system introduces \LayerNode\ for defining services with strict type-checked dependencies and replacements, \AppNodeBuilder\ for assembling the final runtime graph (including automatic location service wiring), and \makeRuntime\ for executing effects against these layers. It also adds platform-specific global nodes for file system, path, HTTP client, and LLM client access, along with supporting utilities like a keyed mutex and a proxy-based service-use accessor.

packages/core/src/effect · high confidence

The Zen inference route now uses a new set of utility modules in \packages/console/app/src/routes/zen/util\ to handle request processing. This includes a central \handler.ts\ that orchestrates authentication, billing source validation, and provider selection, supported by specialized limiters: \ipRateLimiter.ts\ and \keyRateLimiter.ts\ for IP and API-key rate limiting via Redis, \modelTpmLimiter.ts\ and \modelTpsLimiter.ts\ for per-model throughput limits, and \providerBudgetTracker.ts\ for per-provider budget gating. Error handling is standardized via \error.ts\ with specific error classes (e.g., \RateLimitError\, \GoUsageLimitError\). Additional utilities include \requestBody.ts\ for streaming JSON body inspection and modification, \stickyProviderTracker.ts\ for provider affinity, \trialLimiter.ts\ for trial usage tracking, \usageBatcher.ts\ for batching usage updates to reduce DB contention, \variant.ts\ for parsing model-specific variants, \pricing.ts\ for peak pricing logic, and \modelsHandler.ts\ for the models listing endpoint.

packages/console/app/src/routes/zen/util · high confidence

The \packages/llm/src\ package now provides the foundational LLM client, including a \generateObject\ API that forces a synthetic tool call to decode model output against a schema (supporting both static Effect schemas and dynamic JSON schemas). The package also introduces an automatic cache-policy system that injects cache hints into tool definitions, system parts, and the latest user message by default, and adds robust context-overflow detection that classifies provider errors based on expanded token-limit patterns.

packages/llm/src · high confidence

The LLM routing system now includes dedicated transport implementations in \packages/llm/src/route/transport\. The new \http.ts\ module provides an \httpJson\ transport that constructs HTTP requests using the Effect library, handling URL query parameters, authentication, and JSON body overlays while enforcing a denylist of protocol-owned fields (such as \model\, \messages\, and \temperature\) to prevent conflicts. A corresponding \sseJson\ transport is also provided for Server-Sent Events. Additionally, \websocket.ts\ introduces a WebSocket transport layer that manages connection lifecycle, message framing, and binary/string payload handling via a dedicated \WebSocketExecutor\ service. These changes establish the foundational transport infrastructure for sending LLM requests over HTTP and WebSocket protocols.

packages/llm/src/route/transport · high confidence

The plugin package now includes a new v2 plugin architecture alongside the existing v1 implementation. This adds a new Effect-based API (\@opencode-ai/plugin/v2/effect\) and a Promise-based API (\@opencode-ai/plugin/v2/promise\) that allow plugins to imperatively register domain transforms (for agents, catalogs, commands, integrations, references, and skills) and runtime hooks (for tool execution and AI SDK integration). The v2 system uses a scoped registration model with support for reloading domains and disposing of hooks. The package also exposes a BunShell interface for plugin tool execution, a TUI API for terminal UI integration, and a workspace adapter system for managing local and remote directories.

packages/plugin · high confidence

The core plugin subsystem has been rewritten to support a v2 plugin architecture, introducing a new \PluginHost\ that exposes typed hooks for agents, catalog, commands, integrations, and skills. This change embeds default agent configurations (default, plan, general, explore, compaction, title, and summary) with specific permission rules and system prompts directly into the core. It also adds a \models-dev\ plugin that loads model metadata and pricing from a build-time snapshot, and a \variant\ plugin that auto-generates model variants for specific providers. Additionally, a \fromPromise\ adapter is provided to allow existing Promise-based plugins to run within the new Effect-based runtime, and a \LayerMap\ example is included to demonstrate context-scoped service caching.

packages/core/src/plugin · high confidence

The core package now includes configuration files for the Bun runtime environment and the Drizzle ORM. A new \bunfig.toml\ sets up a test preload script, while \drizzle.config.ts\ defines the SQLite database dialect, schema paths, and output directory for migrations. Additionally, a comprehensive \schema.json\ file is introduced, detailing the database structure including tables such as workspace, account, credential, session, and project, along with their columns. Supporting TypeScript configuration files (\tsconfig.json\, \sst-env.d.ts\) are also added to support the build and type-checking processes within this package.

packages/core · high confidence

The console core now includes a new database abstraction layer using Drizzle ORM configured for PlanetScale (MySQL). This change introduces a \Database\ namespace that manages client connections via environment resources, provides a context-aware \use\ function for executing transactions or queries, and defines shared column types such as ULIDs, UTC timestamps, and currency fields to standardize schema definitions across the application.

packages/console/core/src/drizzle · high confidence

The OpenCode Stats site is now available as a standalone application built on SolidStart, separate from the main console. It provides detailed usage rankings, market share analysis, and model comparison data. The site includes a full internationalization (i18n) system supporting 17 languages, a dark/light theme toggle, and responsive layouts for mobile and desktop. Key features include model comparison pages with radar charts, unique user metrics, and geo-breakdowns.

packages/stats · high confidence

A new landing page for the Zen product has been added to the console application. This page features a localized hero section with model partner logos (Gemini, MiniMax, Zai), a pricing overview, a comparison video, and detailed sections explaining the product's value proposition and how it works. It includes an email signup component, FAQ, legal links, and a sticky header with navigation, supporting both light and dark themes.

packages/console/app/src/routes/zen · high confidence

The \packages/llm/src/providers\ directory now contains native TypeScript implementations for major LLM providers, replacing or supplementing previous abstractions. This change introduces dedicated provider modules for Amazon Bedrock, Anthropic, Azure, Cloudflare (both AI Gateway and Workers AI), GitHub Copilot, Google (Gemini), OpenAI, OpenRouter, and xAI. Each provider module defines its own configuration schema, authentication handling (supporting API keys, environment variables, and custom auth objects), and endpoint routing (including support for both Chat and Responses APIs where applicable, such as for Azure, OpenAI, and xAI). The implementation also includes a shared \openai-compatible\ provider with pre-configured profiles for services like Groq, Cerebras, and Fireworks, and a centralized \openai-options\ module that normalizes provider-specific options like reasoning effort and text verbosity. Users can now configure these providers directly via the \configure\ function exported from each module, which returns a typed model factory and route configuration.

packages/llm/src/providers · high confidence

The console now includes dedicated UI for the 'Black' tier, introducing a plan selection interface at /black and a workspace routing page at /black/workspace. The plan selection component displays three pricing tiers ($20, $100, $200) with distinct icons and localized text, supporting smooth view transitions when switching selections. The workspace page provides a styled list for selecting a target workspace, featuring keyboard navigation (Tab/Enter) and a GitHub star count display. Both pages are fully internationalized and styled with a dark theme.

packages/console/app/src/routes/black · high confidence

A new Brand page has been added to the console application, providing a centralized location for users to view and download official brand assets. The page displays previews of the OpenCode logo and wordmark in both light and dark modes, including standard and square variants, and allows users to download individual files in PNG and SVG formats or grab a complete zip archive. The interface is fully internationalized using the i18n context and supports locale-specific URL routing, ensuring the content is accessible and correctly labeled for users across different regions.

packages/console/app/src/routes/brand · high confidence

The CLI now includes dedicated command handlers in the \handlers\ directory. The \api\ handler allows users to execute arbitrary API requests by specifying an OpenAPI operation ID with parameters or by providing a raw HTTP method and path, automatically fetching the OpenAPI spec from the daemon to resolve paths. The \serve\ handler starts the local server, introducing logic to incrementally try ports starting from 4096 if the default is unavailable. A \migrate\ handler has been added, currently logging that no migrations are pending, and a \default\ handler initializes the TUI session via the daemon transport.

packages/cli/src/commands/handlers · high confidence

A new \packages/effect-drizzle-sqlite\ package has been added to provide a Drizzle ORM adapter for SQLite using the Effect framework. This package vendors the necessary adapter code, including drivers, sessions, and query builders, allowing users to integrate Drizzle with Effect's runtime. It includes a migration utility and an example demonstrating basic usage with Bun SQLite.

packages/effect-drizzle-sqlite · high confidence

The project now includes a dedicated \packages/desktop\ directory containing the source code and build configuration for the OpenCode Desktop application, built on Electron. This package introduces a complete build pipeline using \electron-vite\ and \electron-builder\, supporting development, beta, and production channels with distinct app identifiers. It handles platform-specific packaging for macOS (DMG/ZIP), Windows (NSIS), and Linux (AppImage/deb/rpm), including Linux AppStream metadata and legacy desktop entry compatibility. The configuration also integrates Sentry for error reporting, manages native module externalization (node-pty), and enforces strict TypeScript project references.

packages/desktop · high confidence

The enterprise package now exposes a new API route handler at \packages/enterprise/src/routes/api/\[...path\].ts\ that enables users to create, sync, retrieve, and delete session shares via dedicated endpoints (\/share\, \/share/:shareID/sync\, \/share/:shareID/data\, \/share/:shareID\). Additionally, a new administrative endpoint (\/support/actions/remove-share\) has been added to allow support staff to forcibly remove shares using a Bearer token for authentication, addressing the need for administrative control over shared sessions.

packages/enterprise/src/routes/api · high confidence

A new Enterprise page has been added to the console application, featuring a dedicated layout with header, footer, and mobile navigation components. The page includes a contact form that submits data to the /api/enterprise endpoint, along with support for internationalization via i18n and locale-specific URL links.

packages/console/app/src/routes/enterprise · high confidence

A new temporary package at packages/core/src/github-copilot has been added to provide compatibility specifically for GitHub Copilot. This location introduces the provider factory (copilot-provider.ts) and the underlying language model implementations for both the Chat API (openai-compatible-chat-language-model.ts) and the Responses API (openai-responses-language-model.ts). It includes the necessary conversion utilities to map internal prompts to OpenAI-compatible formats, tool preparation logic for built-in tools like code interpreter and file search, and error handling schemas, enabling the core system to interact with Copilot's APIs.

packages/core/src/github-copilot · high confidence

Added two new tools to the .opencode/tool directory: github-pr-search, which allows searching for open pull requests in the anomalyco/opencode repository by title and description, and github-triage, which assigns incoming GitHub issues to a random member of a specified team (such as core, inference, or desktop\_web). These tools replace previous implementations that relied on the Octokit library, now using native fetch calls to interact with the GitHub API.

.opencode/tool · high confidence

Added a set of new API routes under the \zen/go\ path to support the Go product tier. This includes a usage endpoint (\/v1/usage\) that validates API keys against the database, checks for an active Go subscription, and returns rolling, weekly, and monthly usage limits. Additionally, new inference endpoints were introduced for chat completions (supporting OpenAI and Anthropic formats), a generic messages endpoint, a models listing endpoint, and a systemone-specific endpoint, all wired to the existing inference handler to route requests appropriately for Go users.

packages/console/app/src/routes/zen/go · high confidence

A new Go workspace page has been added at the \/workspace/\[id\]/go\ route, providing users with a dedicated interface to manage their Go subscription. This page features a Lite section that displays detailed usage breakdowns across rolling, weekly, and monthly windows, including progress bars and expandable tables showing per-model costs. It also integrates a referral section, allowing users to view their referral summary and manage invite-related features. The page serves as the central hub for Go-specific billing and usage visibility within the console.

packages/console/app/src/routes/workspace/\[id\]/go · high confidence

The \packages/sdk\ directory now includes a new JavaScript SDK (\@opencode-ai/sdk\) featuring \createOpencodeClient\ and \createOpencodeServer\ entry points. The client wraps server error responses into standard JavaScript \Error\ objects (accessible via \.cause\) when \throwOnError\ is enabled, preventing callers from receiving opaque objects. It also supports passing a \directory\ configuration to automatically inject the \x-opencode-directory\ header for scoped requests. The SDK is generated from the OpenAPI spec using \@hey-api/openapi-ts\ and includes a build script that patches generated types to fix session history query parameters and SSE error types.

packages/sdk · high confidence

Added a new \packages/llm/example\ directory containing \call-sites.md\ and \tutorial.ts\. The markdown file documents the architectural direction for the LLM package, emphasizing that routes execute while provider facades organize configured route sets, and detailing the shapes for Routes, Provider Facades, Model Selectors, and Models. The TypeScript tutorial provides a runnable walkthrough of the public API, demonstrating how to configure providers (like OpenAI), build provider-neutral requests with generation and provider-specific options, execute synchronous generation, stream events for incremental UI updates, handle tool calls with explicit provider turns, and generate structured objects using synthetic tool calls.

packages/llm/example · high confidence

Added \recording-cost-report.ts\ and \setup-recording-env.ts\ scripts to the \packages/llm/script\ directory. The setup script configures environment variables and validates API keys for a wide range of providers (including OpenAI, Anthropic, Google, Bedrock, and various canary/compatible providers) to enable test recording. The cost-report script analyzes these recorded test fixtures to estimate and report LLM usage costs by fetching pricing data from the OpenCode model catalog.

packages/llm/script · high confidence

The Zen console now exposes new API routes under \/zen/v1\ that allow users to interact with AI models using standard OpenAI, Anthropic, and Google formats. These endpoints handle API key parsing, model selection, and streaming detection, routing requests through the existing inference proxy. The \/zen/v1/models\ endpoint lists available models, filtering out disabled ones based on the user's API key, while specific model endpoints (e.g., \/zen/v1/messages\, \/zen/v1/responses\) provide format-specific handling for different provider integrations.

packages/console/app/src/routes/zen/v1 · high confidence

The console now includes dedicated, locale-aware routes for the Privacy Policy and Terms of Service. These new pages display the updated legal text (effective March 6, 2026, and August 15, 2026, respectively) with full styling for screen and print, and allow users to view the policies in their selected language via the locale links component.

packages/console/app/src/routes/legal · high confidence

The \packages/app\ directory now contains a complete web application built on SolidJS and Tailwind CSS, replacing the previous structure. This package introduces a Vite-based build pipeline (\vite.config.ts\, \vite.js\) that integrates Sentry for error tracking and supports environment-specific channels (dev, beta, prod). It includes a full end-to-end testing setup using Playwright (\playwright.config.ts\, \happydom.ts\) with configuration for local and CI environments. The package also provides documentation for development workflows (\AGENTS.md\, \README.md\) and a migration guide for the underlying API (\V1\_API\_MIGRATION.md\), establishing the foundation for the app's UI and testing infrastructure.

packages/app · high confidence

The desktop application now includes a new backend module for managing WSL (Windows Subsystem for Linux) servers. This change introduces a new IPC layer to handle server lifecycle events (subscribe, unsubscribe, get state, probe runtime, refresh distros, install WSL/distro/opencode, open terminal, add/remove/start servers) and a controller to manage server state, including health polling and OpenCode version checks. It also adds runtime utilities for executing WSL commands with timeouts to prevent hangs, spawning sidecar processes, and handling terminal arguments. This functionality is specific to the main process WSL module and does not include the UI components.

packages/desktop/src/main/wsl · high confidence

The Console now includes dedicated context providers for authentication and language management. The new auth context (\auth.ts\) handles session management via OpenAuth, enforces access controls by restricting legacy access to specific 'Black' accounts, and redirects migrated teams to the new Console URL. Additionally, new \language.tsx\ and \i18n.tsx\ contexts provide locale detection from cookies and request headers, manage the document's language and direction attributes, and expose translation functions to the application.

packages/console/app/src/context · high confidence

The repository now includes a suite of Bun-based scripts to automate development workflows. The beta branch sync script (\script/beta.ts\) uses the opencode AI agent to automatically resolve merge conflicts and run type-checks during beta releases. Changelog generation is handled by \script/changelog.ts\ and \script/raw-changelog.ts\, which fetch commit data and format release notes. Additional scripts manage GitHub lifecycle tasks, including \script/github/close-issues.ts\ for stale issue cleanup and \script/github/close-prs.ts\ for automated PR cleanup based on reaction thresholds. The \script/translate-app.ts\ script automates the synchronization of product translations across app, UI, and desktop packages, while \script/publish.ts\ and \script/release\ streamline the version bumping and publishing process for CLI, SDK, and desktop components. Finally, \script/sign-windows.ps1\ implements code signing for Windows releases using Azure Trusted Signing.

script · high confidence

Users can now access a new benchmarking section in the console to view, analyze, and submit model evaluation results. The main list page displays the top 100 recent benchmarks, showing agent, model, and average scores alongside per-task performance metrics. Clicking a specific task navigates to a detail view that breaks down scores, costs, duration, and prompts, with links to the relevant GitHub commits. Additionally, an API endpoint is available to submit new benchmark results, requiring model, agent, and result data.

packages/console/app/src/routes/bench · high confidence

The console app now includes a dedicated /changelog route that displays release history in a structured, user-friendly format. The page renders release articles with collapsible sections for detailed item lists, allowing users to expand or collapse specific changes. It also supports rich highlights, including embedded videos and images, to showcase key features. The layout features a sticky header for easy navigation and is fully internationalized, supporting locale-specific URLs and translations for all text content.

packages/console/app/src/routes/changelog · high confidence

The console application now includes a suite of new UI components and a dedicated Go referral system. Users can now dismiss a desktop promotion banner that persists via a cookie, use a new dropdown component for selections, and subscribe to email updates via a server-side action. The Go section features a comprehensive referral system allowing users to copy invite links, view usage previews, and apply rewards, alongside a new FAQ component and an updated footer that links to a changelog and uses Feishu for Chinese community support. Additionally, the header now supports a right-click context menu to copy brand assets, and a new Go models list defines usage allowances for various AI models.

packages/console/app/src/component · high confidence

Added a suite of new command-line scripts in the console core to support the Black subscription plan and general workspace administration. These include scripts to manage the Black waitlist (onboarding, cancellation, and selection), provision Black seats via Stripe gift subscriptions, transfer subscriptions between workspaces, and generate usage statistics. Additional administrative tools allow for creating API keys and coupons, granting or freezing workspace credits, disabling workspace reloads, and updating or promoting rate limits and model configurations via environment secrets.

packages/console/core/script · high confidence

The application now includes dedicated context providers and logic for managing closed session tabs (with a 25-entry LRU limit), file line comments (supporting focus, active state, and per-file indexing), and a command palette with robust keybinding parsing and matching. These changes introduce new state management for tab history, comment sessions, and command registrations, along with comprehensive test coverage for the keybinding parser, command registration shadowing, and comment session indexing.

packages/app/src/context · high confidence

The console core now includes new modules for managing accounts, billing, and workspaces. Account creation and removal are handled with proper cleanup of associated users, keys, and coupons. Billing logic integrates with Stripe for payments, credits, and coupon redemption, while workspace management supports creation, updates, and batch blocking/unblocking. Referral system improvements include code generation, reward tracking, and application. Provider management allows admins to create and remove API providers. Model management now supports complex provider configurations with fallback and rate limiting. Quota reset functionality allows resetting usage counters for both Lite and subscription plans. User invitation and workspace joining flows are enhanced with email notifications via AWS SES.

packages/console/core/src · high confidence

The \packages/core/src/util\ directory now includes a comprehensive set of new utility modules to support core application logic. This adds a robust file-locking system with both standard Node.js (\flock.ts\) and Effect-based (\effect-flock.ts\) implementations, featuring stale-lock detection and heartbeat mechanisms. It also introduces utilities for binary array search and insertion, base64 encoding/decoding, cryptographic hashing (SHA-256, SHA-1), and checksum generation. Additional helpers include glob pattern matching, path manipulation (truncation, extension extraction), retry logic with transient error detection, and slug generation.

packages/core/src/util · high confidence

Added a new Remotion-based video project in artifacts/glm52-rise-video that renders several animated data visualizations for OpenCode Go usage. The bundle includes a main composition tracking the GLM-5.2 token rise from June 12–25, a weekly share breakdown for DeepSeek V4 Flash, a MiniMax M3 growth chart, a New Zealand-specific token-per-sheep metric, a novel tokens-per-request highlight, and a June monthly recap. These components are wired together in the project's root index and provide the visual assets for the associated data storytelling.

artifacts/glm52-rise-video · high confidence

The layout area now includes a new deep-link parser (deep-links.ts) that recognizes opencode:// URLs for opening projects (open-project) and creating new sessions (new-session), including an optional prompt parameter, and drains these links from the global window state. Additionally, a new helpers module (helpers.ts) provides utilities for session sorting (by persisted update time), workspace path normalization, project avatar source resolution, and home project selection/navigation, all backed by a comprehensive test suite (helpers.test.ts).

packages/app/src/pages/layout · high confidence

The \packages/desktop/scripts\ directory now contains a suite of Bun-based scripts that handle the desktop application's build and release pipeline. These scripts automate copying channel-specific icons and generating Linux AppStream metainfo files, downloading and bundling the CLI binary for the target platform, and finalizing release artifacts by merging platform-specific YAML files and uploading signed assets to GitHub releases. This centralizes the logic for preparing desktop builds across Windows, macOS, and Linux.

packages/desktop/scripts · high confidence

The console application now includes a dedicated download route that provides installation options for the CLI (via curl, npm, bun, brew, paru, and yay) and desktop binaries for macOS (Apple Silicon and Intel), Windows, and Linux (DEB, RPM, and AppImage). The page features copy-to-clipboard functionality for installation commands, locale-aware routing, and a sticky header, with the AppImage option currently disabled in the UI.

packages/console/app/src/routes/download · high confidence

A new server-side route at /download/\[channel\]/\[platform\] has been added to handle desktop application downloads. This route supports both 'stable' and 'beta' channels, mapping internal platform identifiers (such as darwin-aarch64-dmg or windows-x64-nsis) to specific asset filenames (e.g., opencode-desktop-mac-arm64.dmg). It fetches the latest release metadata from the opencode.ai update API and redirects users to the correct download URL, returning a 404 if the platform is unsupported or a 502 if the asset URL cannot be resolved.

packages/console/app/src/routes/download/\[channel\] · high confidence

A new API route at /api/enterprise has been added to handle enterprise contact form submissions. When a user submits the form, the system now creates a lead in Salesforce, sends an email notification to the enterprise sales inbox (with the user's email as the reply-to address), and subscribes the user to the EmailOctopus mailing list. The endpoint includes validation for required fields and email format, and uses a hidden 'alias' field as a spam trap to silently accept bot submissions.

packages/console/app/src/routes/api · high confidence

This change introduces the core implementation for the enterprise sharing feature, located in packages/enterprise/src/core. The new share.ts module manages the lifecycle of shared sessions (create, get, remove, sync) and handles event compaction to optimize loading performance, using Zod for data validation. The accompanying storage.ts module provides a unified storage adapter that supports both AWS S3 and Cloudflare R2 backends, abstracting read, write, remove, and list operations for the share system.

packages/enterprise/src/core · high confidence

The core filesystem module now includes dedicated services for file searching, path ignoring, and file watching. The search service (\search.ts\) provides a unified interface (\find\, \glob\, \grep\) backed by either the \fff\ library (for high-performance fuzzy search and grep) or \ripgrep\ as a fallback, with \fff\ being the primary implementation for AI-mode operations. The \ignore.ts\ module defines a standard set of patterns to exclude common build artifacts, caches, and IDE files from scans. The \watcher.ts\ module introduces a file-watching service using \@parcel/watcher\ that monitors directory changes and publishes events, while respecting the new ignore patterns and platform-specific protected paths defined in \protected.ts\. These components are wired into the application's Effect-based dependency injection system.

packages/core/src/filesystem · high confidence

The infrastructure layer now provisions a dedicated AWS data lake (S3 Tables, Glue, Athena) and a separate PlanetScale database for stats, alongside a new SolidStart-based stats application and enterprise support site. It also introduces Stripe product and coupon definitions for 'OpenCode Go' and 'OpenCode Black' subscriptions, configures Honeycomb monitoring triggers for model HTTP errors and low TPS, and sets up regional hostnames and DNS records for trust center verification.

infra · high confidence

The application now includes initial translation dictionaries for six additional languages: Amharic (am), Arabic (ar), Azerbaijani (az), Bulgarian (bg), Bengali (bn), and Breton (br). These new files in the \packages/app/src/i18n\ directory provide localized strings for the desktop menu, session controls, command palette, and WSL error messages, expanding the app's internationalization coverage.

packages/app/src/i18n · high confidence

The core package now includes two new scripts: \fix-node-pty.ts\ ensures \node-pty\ helper binaries have executable permissions on non-Windows platforms, and \migration.ts\ automates the generation of database migration files, the TypeScript schema, and the migration registry using Drizzle Kit, while also providing a check mode to verify that generated artifacts are up to date.

packages/core/script · high confidence

A new script (packages/enterprise/script/scrap.ts) has been added to allow administrators to manually remove shared data. When executed with a specific share ID as an argument, it deletes the corresponding share record and all associated data items prefixed with that share ID from the storage system.

packages/enterprise/script · high confidence

A new server-side rendered route at \packages/enterprise/src/routes/share/\[shareID\].tsx\ now handles public sharing of OpenCode sessions. This page fetches session data, diffs, and messages via a server query, renders the session timeline and file diffs using SSR components, and includes social media meta tags (Open Graph/Twitter) for link previews. It also prevents search engine indexing and implements caching headers to optimize load performance for shared links.

packages/enterprise/src/routes/share · high confidence

The console now implements a complete server-side authentication flow via new route handlers in \packages/console/app/src/routes/auth\. The \/auth\ entry point redirects unauthenticated users to the migration login page or to their last workspace, while \/auth/authorize\ initiates the OAuth authorization code flow. The \/auth/callback\ handler exchanges the authorization code for tokens, updates the local auth session with account details, and redirects the user to the appropriate workspace. A \/auth/logout\ route clears the current session and redirects to the Zen interface, and \/auth/status\ exposes the current session state as JSON.

packages/console/app/src/routes/auth · high confidence

The session-ui package introduces a suite of new UI components to enhance the file viewing and tool interaction experience. A new \File\ component (with \FileSSR\ for server-side rendering) now handles text and diff views, featuring virtualized rendering for performance, line selection, and comment annotations. Media files (images, audio, SVGs) are rendered via a new \FileMedia\ component that supports remote loading and fallbacks. Tool interactions are standardized with a \BasicTool\ component, providing an expandable panel with structured triggers, status indicators (pending/running), and deferred content mounting. Additionally, \DockPrompt\ components handle question and permission layouts, while \LineComment\ components enable inline code annotations. A new \apply-patch-file\ utility normalizes patch metadata for consistent diff display, and an \AGENTS.md\ guideline enforces strict i18n practices for all user-visible strings.

packages/session-ui · high confidence

A new shared Drawer component has been added to the UI library, providing a complete set of primitives (Drawer, Trigger, Portal, Overlay, Content, Header, Footer, Title, Description) built on top of @corvu/drawer. This component offers a consistent, styled drawer interface for use across the application, featuring specific styling for overlays, content positioning, and typography.

packages/app/src/components/ui · high confidence

The console's support API now exposes new server-side actions for managing workspaces and accounts, including batch blocking and unblocking of workspaces, individual workspace unblocking, quota resets for specific plans, account deletion, and referral creation. These endpoints are secured via a support API key and provide structured error handling for invalid requests.

packages/console/app/src/routes/api/support · high confidence

A new usage section has been added to the workspace settings page, providing administrators with detailed insights into model consumption and costs. This update introduces a cost graph that visualizes spending over time, allowing users to filter by month and specific API keys, alongside a paginated usage table that breaks down input and output tokens (including cache and reasoning tokens) per model. The interface includes responsive styling for mobile devices and displays cost information based on the user's subscription plan (subscription, lite, or bring-your-own-key).

packages/console/app/src/routes/workspace/\[id\]/usage · high confidence

The \packages/app/src/utils\ directory has been populated with a comprehensive suite of new utility modules that implement core application behaviors. This includes robust persistence and storage handling (\persist.ts\, \draft-store.ts\) with quota management and legacy migration, diff normalization and parsing (\diffs.ts\), and prompt extraction from message parts (\prompt.ts\). The update also introduces agent-specific color logic (\agent.ts\), a mouse-aim activation controller (\aim.ts\), and various infrastructure utilities such as scoped caching (\scoped-cache.ts\), reference counting (\refcount.ts\), and runtime adapters for browser APIs (\runtime-adapters.ts\).

packages/app/src/utils · high confidence

Added new utility modules in packages/console/core/src/util, including crypto (safe string comparison), date (week and monthly bounds calculation), fn (Zod schema-wrapped function factory), log (context-aware logging with tags), memo (lazy evaluation with cleanup), and price (cent/micro-cent conversion).

packages/console/core/src/util · high confidence

A new artifact project named 'glm52-rise-video' has been added to the artifacts directory. This project is configured to use the Bun package manager and leverages the Remotion framework (version 4.0.384) along with React 19 for video generation. The setup includes a .gitignore file to exclude build outputs and node modules, and an SST environment definition file to integrate with the surrounding infrastructure.

artifacts · high confidence

The workspace billing page has been rebuilt to provide a comprehensive view of account status and financial controls. Users can now view their current balance, add funds via a dedicated checkout flow, and manage automatic reload settings (amount and trigger threshold) with clear processing fee disclosures. The interface also displays a detailed payment history table with receipt download capabilities and supports coupon code redemption. For users on the 'Black' subscription plan, a dedicated section shows rolling and weekly usage progress bars, allows management of the subscription via Stripe, and provides options to enroll in or cancel from the waitlist.

packages/console/app/src/routes/workspace/\[id\]/billing · high confidence

The workspace members page now features a dedicated interface for managing team access. Users can invite new members by specifying their email, role, and optional monthly usage limits. Existing members can be edited directly within the table to change their role or adjust their spending cap, and administrators can remove members from the workspace. The interface includes a custom dropdown for role selection and displays current usage against any set limits.

packages/console/app/src/routes/workspace/\[id\]/members · high confidence

The project management layer now supports creating and tracking copies of project directories, including a Git worktree strategy for efficient duplication. A new service manages these copies and their associated directories, persisting their state in the database and refreshing the list of available copies on application boot to ensure consistency.

packages/core/src/project · high confidence

The console now serves an OAuth Client ID Metadata Document at /oauth/opencode/client.json, allowing MCP servers to fetch client configuration (name, redirect URIs, grant types) via a URL-based client\_id instead of performing a traditional registration. This enables seamless authorization for the opencode native app by exposing its allowed loopback redirect URIs and authentication method directly through the metadata endpoint.

packages/console/app/src/routes/oauth · high confidence

The session component area has been reorganized into a modular structure with a new barrel export file (index.ts) and dedicated components for the session header, new session view, and various tab types (file and terminal, including v2 variants). A new 'Open in App' feature allows users to open the current project directory in installed desktop applications (e.g., VS Code, Cursor, Finder) with platform-specific app detection and selection. Additionally, a session context tab has been introduced, which displays token usage metrics, cost, provider/model details, and a visual breakdown of context tokens (system, user, assistant, tool) using new estimation and formatting utilities.

packages/app/src/components/session · high confidence

Users can now move sessions to different directories within the same project via the new MoveSession service, which handles Git change capture and application during the move. Additionally, the workspace database schema has been updated to include a branch field and a time\_used timestamp, while maintaining the reference to the project.

packages/core/src/control-plane · high confidence

The Storybook workspace is now configured to run against the application's UI and session-ui packages, enabling developers to view and test components in isolation. To support this, a comprehensive set of mock implementations has been added for application contexts (including language, prompt, file, sync, and provider states) and hooks, allowing stories to render without the full application backend. The configuration also integrates Tailwind CSS, sets up a theme toggle tool, and applies the v2 layout styles by default to ensure stories reflect the current design system.

packages/storybook · high confidence

The new \packages/console/app/src/routes/stripe/webhook.ts\ file introduces backend handling for Stripe events, enabling users to subscribe to the 'Lite' plan, apply referral coupons (such as first-month or multi-month discounts), and update default payment methods. It also records one-time payments and handles subscription state changes, including marking incomplete subscriptions as expired.

packages/console/app/src/routes/stripe · high confidence

The application now features a single, unified command palette (v2) that allows users to search and execute commands, open files, and navigate to sessions from one interface. This palette groups results by category (commands, files, sessions), supports fuzzy search across titles and descriptions, and integrates with the existing tab and session management systems to open files in the editor or switch to specific sessions. A dedicated home palette variant is also provided for the home screen, focusing on commands and recent sessions.

packages/app/src/components · high confidence

The workspace settings page now allows users to view and edit their workspace name. This change introduces a new settings section that displays the current workspace name and provides an inline editing interface. Users can click an edit button to modify the name, with validation ensuring the name is not empty and does not exceed 255 characters. The form includes save and cancel buttons, and displays any errors that occur during the update process. The interface is localized using i18n for all text elements.

packages/console/app/src/routes/workspace/\[id\]/settings · high confidence

The internal \internal/tui/styles\ package has been removed, deleting the hardcoded Catppuccin color definitions, icon constants, and Glamour markdown rendering styles that previously governed the terminal user interface's appearance.

internal/tui/styles · high confidence

The internal logging implementation, including the logger, message structures, and pubsub integration, has been removed from the codebase.

internal/logging · high confidence

The internal pub/sub broker package has been removed, deleting the generic Broker type, event definitions, and associated interfaces. This eliminates the previous mechanism for publishing and subscribing to typed events within the application.

internal/pubsub · high confidence

The \internal/tui/tui.go\ file, which defined the core \appModel\ for the terminal user interface, has been removed. This deletion eliminates the previous implementation of the TUI state machine, including its key bindings (Logs, Back, Quit), page navigation logic, and the initialization of specific pages (Logs, Init, Repl).

internal/tui · high confidence

The internal terminal UI layout implementation has been removed. This change deletes the files defining the bento grid layout, single pane wrappers, border styling utilities, and associated layout interfaces (bento.go, border.go, layout.go, single.go) from the internal/tui/layout package.

internal/tui/layout · high confidence

The internal TUI page definitions for initialization, logs, REPL, and the generic PageID type have been removed from the codebase. This deletion eliminates the previous UI structures that displayed an 'Initializing...' screen, a dedicated logs table, and a bento-layout REPL interface, indicating a structural shift in how the terminal user interface pages are managed or rendered.

internal/tui/page · high confidence

The \internal/tui/components/logs/table.go\ file has been deleted, removing the previous implementation of the logs view that displayed entries in a fixed-width table with columns for Time, Level, Message, and Attributes. This change eliminates the old rendering logic and associated UI interactions for the logs section, indicating a shift to a different component or structure for displaying logs in the TUI.

internal/tui/components/logs · high confidence

The placeholder components for the editor, messages, and threads within the REPL interface have been removed. These stubs, which previously returned static text views, are no longer part of the application, indicating a cleanup of initial scaffolding or a shift in how these features are implemented.

internal/tui/components/repl · high confidence

The main entry point for the termai terminal user interface (cmd/termai/main.go) has been removed. This file previously initialized the Bubble Tea application, configured the alternate screen, and managed subscriptions for logging events. Its deletion indicates that the standalone TUI executable is no longer part of the codebase.

cmd · high confidence

The home page logic has been refactored into a new modular controller architecture (home-controller, home-projects-controller, home-sessions-controller, home-scroll-controller, home-session-search-controller) and corresponding v2 UI views (home-projects-view, home-sessions-view). This change introduces a dedicated scroll controller for managing sticky session headers and wheel containment, a search controller for filtering sessions with keyboard navigation, and a projects controller that handles server/project selection, adding, and revealing. The legacy home view is preserved as a fallback component (legacy-home.tsx) to maintain compatibility during the transition.

packages/app/src/pages/home · high confidence

The console application's public directory now serves static assets via symlinks to a shared UI asset library, ensuring consistent favicons (including v3 variants), social share images, and web manifest icons across the platform. A new \theme.json\ schema has been added to define and validate color configurations for both light and dark modes, supporting granular control over UI elements like syntax highlighting and markdown rendering. Additionally, a \robots.txt\ file is now provided to manage search engine indexing, explicitly disallowing shared content paths while pointing to the site sitemap.

packages/console/app/public · high confidence

The application now uses a centralized \Flag\ object in the core package to manage runtime configuration via environment variables. This change introduces platform-specific defaults for features like FFF (disabled by default on Windows) and copy-on-select (disabled by default on Windows), and establishes a consistent mechanism for experimental flags that can be overridden by specific environment variables. Users should be aware that certain experimental behaviors may now default differently based on the operating system.

packages/core/src/flag · high confidence

The CodeMode execution engine has been replaced with a v2 implementation that parses TypeScript via the TypeScript compiler and executes it using a custom interpreter. This update introduces a comprehensive standard library supporting a wide range of JavaScript features, including array and object manipulation methods, string and number operations, Date and RegExp handling, JSON parsing, URL utilities, and Promise-based concurrency for tool calls. Users can now leverage these built-in capabilities within CodeMode scripts, while unsupported syntax is explicitly rejected with diagnostic feedback.

packages/codemode/src/interpreter, packages/codemode/src/stdlib · high confidence

The console application's routing layer and associated UI components have been completely rewritten. This includes new implementations for the home page (index.tsx), the 'black' plan selection page (black.tsx), and a dedicated 404 not-found page, all featuring updated styling and layout. The workspace management experience is overhauled with a new WorkspacePicker component that allows users to select or create workspaces via a dropdown and modal, alongside a new UserMenu component for account management. Additionally, new server-side routes have been added to serve the changelog as JSON (changelog.json.ts) and the OpenAPI specification (openapi.json.ts), while several legacy redirect routes (desktop-feedback, discord, feishu) have been introduced to manage community links.

packages/console/app/src/routes · high confidence

The console function now validates authorization redirect URIs to prevent open-redirect vulnerabilities, allowing only registered OpenCode callbacks and rejecting unregistered clients or external domains. It also introduces new endpoints for logging inference metrics to a data lake (log-processor) and querying model TPS rate limits (stat), enhancing observability and performance monitoring for the Zen inference service.

packages/console/function/src · high confidence

The console application library now includes a localized stats proxy that rewrites asset paths and respects locale headers when serving the /data section, alongside a new inference proxy that routes legacy BYOK keys to the correct provider endpoints. Added utilities support multi-language formatting for workspace reset times, handle form error localization, and manage referral cookies, while the changelog module fetches and parses GitHub release data for display. The language module expands locale support to include Ukrainian and other languages, and the GitHub module now fetches repository metadata and contributor counts.

packages/console/app/src/lib · high confidence

The core tool layer has been rewritten to a V2 architecture, introducing a new \Tool.make\ API and a \ToolRegistry\ that manages Location-scoped built-in tools (such as \bash\, \edit\, \read\, and \apply\_patch\) and process-scoped application tools. This change enforces V2 permissions via \PermissionV2.Service\ for all tool executions, ensuring that external directory access and file mutations are explicitly authorized. It also introduces generic output bounding at the \ToolRegistry.Materialization.settle\ boundary to manage model output size and retention, while providing a centralized registration system where Location-scoped registrations take precedence over application-scoped ones.

packages/core/src/tool · high confidence

The core database schema has been significantly restructured to support v2 session capabilities, event-sourced inputs, and granular project management. New tables include \project\ and \project\_directory\ for managing project roots and strategies, \workspace\ for branch and directory tracking, and \credential\ for connector authentication. Session handling has been modernized with \session\_message\ and \session\_input\ tables replacing older structures, backed by an \event\ and \event\_sequence\ system for durable event sourcing and context epochs. The schema also introduces \account\ and \account\_state\ for identity management, \permission\ for access control, and \session\_context\_epoch\ for state tracking. Existing data is migrated via scripts that normalize storage paths, populate usage metrics (cost, tokens), and reset pre-launch projections to ensure consistency with the new event-sourced architecture.

packages/core/src/database/migration · high confidence

The console core database schema has been updated to support more granular usage tracking and improved billing error handling. The \usage\ table now distinguishes between cache write tokens by time window (5-minute and 1-hour buckets) and requires a provider identifier, while the \key\ table has been refactored to replace the direct \user\_id\ with a flexible \actor\ JSON field and enforces unique key names per workspace. Additionally, the \billing\ table includes a lock timestamp to manage reload states, and the \payment\ table can now store error details.

packages/console/core/migrations · high confidence

The desktop renderer now explicitly handles initialization errors by surfacing local server startup failures to the user and stripping Electron's remote invocation wrapper from error messages. It also manages WSL server connections, ensuring that WSL servers are only published once they report a ready state and that the desktop startup is not blocked if a configured WSL server is not yet ready. Additionally, the renderer supports first-launch onboarding, which triggers a guided setup for new users based on specific conditions like existing installations and server status.

packages/desktop/src/renderer · high confidence

The pre-push hook now validates that the installed Bun version matches the range specified in the root package.json, warning if there is a minor version mismatch and failing if the version is outside the expected range. Additionally, the hook runs the project's typecheck before allowing the push, ensuring type safety is maintained.

.husky · high confidence

The enterprise application entry point has been restructured to use SolidStart, introducing server-side rendering via entry-server.tsx and client hydration via entry-client.tsx. The app now automatically detects the user's locale (English or Chinese) from the Accept-Language header or browser settings and applies it via a new UiI18nBridge provider, ensuring consistent internationalization across server and client. The root layout includes essential providers for routing, metadata, dialogs, and markdown, along with favicon and font handling, while CSS imports are centralized in app.css.

packages/enterprise/src · high confidence

A new \@opencode-ai/script\ package has been added to centralize build-time logic. It enforces a compatible Bun version range (relaxed to allow minor/patch updates via \^\), determines the current channel (latest, preview, or branch) and version (including auto-bumping logic), and loads the team member list from \.github/TEAM\_MEMBERS\ to identify valid contributors. This script is now used by CI workflows to ensure consistent versioning and team validation across builds.

packages/script · high confidence

The core configuration system now uses a formal v1 schema (Effect) to define and validate settings for agents, providers, MCP servers, permissions, and more. This change introduces a migration path that automatically converts existing v1-style configuration files into the new internal structure, handling field renames (such as \mode\ to \agent\ and \autoshare\ to \share\), normalizing permissions, and updating provider options. Users will benefit from stricter validation, clearer defaults, and a smoother transition to the new configuration format.

packages/core/src/v1/config · high confidence

The protocol package now defines a new v2 HTTP API surface built on the Effect \HttpApi\ library, replacing the previous internal communication mechanism. This change introduces a comprehensive set of experimental REST endpoints for managing sessions, agents, models, providers, integrations, permissions, and file systems, all scoped to a specific location context. It also adds a Server-Sent Events (SSE) endpoint for subscribing to live server events and WebSocket support for PTY sessions. The update includes structured error handling (e.g., \InvalidRequestError\, \UnauthorizedError\) and middleware for authorization and schema validation, providing a standardized, versioned interface for client applications.

packages/protocol · high confidence

The PTY subsystem has been refactored into a new, modular structure within \packages/core/src/pty\. This change introduces a unified protocol layer (\protocol.ts\) that handles UTF-8 terminal data framing and replay chunking, ensuring consistent communication regardless of the transport layer. It also provides platform-specific implementations for spawning and managing pseudo-terminals: a Node.js adapter using \@lydell/node-pty\ (with Windows ConPTY support) and a Bun adapter using \bun-pty\. Additionally, a new ticketing service (\ticket.ts\) is added to manage secure, time-limited access to PTY sessions using an Effect-based cache, decoupling session authentication from the terminal process management.

packages/core/src/pty · high confidence

The core library now exposes specific error types for v1 interactions. In permissions, users will encounter distinct errors when tool usage is rejected, corrected with feedback, or denied by rulesets, as well as when a request ID is not found. For sessions, the system now defines structured errors for output length limits, provider authentication failures, message abortion, structured output retries, API failures (including status codes and retryability), context overflow, and content filtering, providing clearer diagnostics for these failure modes.

packages/core/src/v1 · high confidence

The console application now includes a structured CSS foundation located in \packages/console/app/src/style\. This change introduces a token system for colors (supporting both light and dark themes via \prefers-color-scheme\), font sizes, spacing, and border radii, alongside a CSS reset and base styles. It also adds specific styling for a button component, allowing for primary, danger, and warning variants with small and large sizes, as well as accessible focus states.

packages/console/app/src/style · high confidence

The console application now handles requests to specific documentation resources (matched by ID) by proxying them to the external documentation site (docs.opencode.ai or docs.dev.opencode.ai). This change ensures that the user's locale is preserved during the proxy request via the Accept-Language header and that the locale is synchronized back to the user's browser via a cookie, enabling consistent localized content delivery for these specific routes.

packages/console/app/src/routes/s · high confidence

The Zen console's provider utilities have been replaced with a new set of helper modules (anthropic, google, openai, openai-compatible, systemone) that standardize how requests are modified, responses are parsed, and usage metrics are normalized. This change introduces support for new provider-specific features such as 1M context windows for Anthropic models, detailed cache token tracking (read/write, 5m/1h ephemeral), and reasoning token extraction for Google and OpenAI models. It also adds session affinity headers for OpenAI-compatible and SystemOne providers, handles binary stream decoding for AWS Bedrock, and ensures cost chunks are emitted in a client-facing format rather than upstream provider formats.

packages/console/app/src/routes/zen/util/provider · high confidence

The application has renamed the 'stats' section to 'data'. The new /data routes now serve as a proxy, forwarding all HTTP methods (GET, POST, PUT, DELETE, OPTIONS, PATCH) to the backend via the statsProxy handler. Meanwhile, the legacy /stats routes have been updated to use a statsRedirect handler, ensuring that requests to the old path are redirected to the new location.

packages/console/app/src/routes/stats · high confidence

The core package now includes explicit Drizzle ORM table definitions for account and share data. In the account module, new tables define the structure for user accounts (including tokens and expiry), account state tracking, and a legacy control account table with composite keys. In the share module, a new session share table is defined to link share sessions to existing user sessions with cascade deletion. These changes establish the database schema ownership within these specific modules using SQLite.

packages/core/src/account, packages/core/src/share · high confidence

The desktop preload script has been rewritten to expose a comprehensive \ElectronAPI\ to the renderer process, enabling new desktop-specific features. This includes a full WSL server management interface (probing, installing distros, starting/stopping servers), an app updater with subscription support, and system integrations such as opening external links in the system browser, file/directory pickers, deep-link handling, and window management (fullscreen, focus, zoom, pinch-zoom). It also adds support for exporting debug logs, setting native translations, and managing local storage and draft blobs, providing the frontend with the necessary hooks for the new desktop v2 architecture.

packages/desktop/src/preload · high confidence

The provider configuration system has been rewritten to use a new plugin-based architecture, introducing dedicated plugin files for each supported AI provider (such as OpenAI, Google Vertex, Amazon Bedrock, and Anthropic). This change centralizes provider-specific logic—including SDK initialization, credential handling, and catalog transformations—into modular plugins, replacing the previous configuration approach. Users will benefit from more robust and maintainable provider integrations, with specific handling for complex providers like Google Vertex (including multi-region endpoint fixes) and Amazon Bedrock (including Mantle SDK support).

packages/core/src/plugin/provider · high confidence

The server list UI now uses dedicated \ServerRow\ and \ServerRowMenu\ components. \ServerRow\ displays the server name, version, and optional credentials (username and masked password for HTTP servers) with truncation handling via ResizeObserver, while \ServerRowMenu\ provides a context menu with actions to edit, set as default, remove default, or delete the server. These components integrate with the existing server management controller and language context to render server items and their associated actions.

packages/app/src/components/server · high confidence

The session page components have been restructured into a new modular layout, introducing dedicated files for session lineage, ownership, model helpers, and panel width calculations. A key behavioral addition is the new file tab scrolling logic (\file-tab-scroll.ts\), which automatically scrolls the file tab list to the start when a context tab opens and to the right edge when new file tabs are added, ensuring the active tab remains visible.

packages/app/src/pages/session · high confidence

The new session page has been refactored to use a modular controller architecture, introducing \new-session-draft-controller.ts\ to manage prompt input and model selection, and \new-session-workspace-controller.ts\ to handle workspace and branch resolution. This change enables a new workspace selection bar (visible in non-production channels) that allows users to switch between project worktrees and branches directly from the new session view. The \new-session-view.tsx\ component has been updated to integrate these controllers, displaying the new workspace selector and project management UI, while \use-new-session-commands.tsx\ registers specific command palette entries for focusing the input and selecting projects.

packages/app/src/pages/new-session · high confidence

The session timeline page now uses a completely rewritten rendering and state architecture to improve performance and stability. This includes a new \message-timeline\ component that leverages TanStack Solid Virtual for efficient scrolling, a \model\ layer for managing message synchronization and history loading, and a \projection\ system that constructs timeline rows from session data. The update introduces a \row-reconciliation\ algorithm to preserve UI state (like open accordions) during updates, a \measure\ utility to safely handle element measurements, and an \observe-element-offset\ hook to maintain scroll position across route changes. Comprehensive test coverage has been added for the model, projection, and reconciliation logic.

packages/app/src/pages/session/timeline · high confidence

The \packages/function/src\ area now includes a new Hono-based API (\api.ts\) and GitHub utility module (\github.ts\) that replace the previous implementation for the sharing feature. The new API exposes endpoints for creating share links (\/share\_create\), deleting shares (\/share\_delete\), and synchronizing session data via WebSockets (\/share\_poll\) and HTTP (\/share\_sync\). It leverages Cloudflare Durable Objects to manage real-time state and R2 buckets for persistent storage, while the new \github.ts\ module adds logic to parse repository claims from JWT payloads, supporting the backend's integration with GitHub authentication flows.

packages/function/src · high confidence

The system now uses a new set of configuration plugins in \packages/core/src/config/plugin\ to load and apply settings for agents, commands, providers, skills, references, and external plugins. These plugins discover configuration from markdown files and directories (e.g., \agent/\\/\.md\, \command/\\/\.md\, \plugin/\*.{ts,js}\), parse them using Effect schemas, and apply the results to the runtime. Key behaviors include: expanding home-relative permission paths (e.g., \\~/\, \$HOME\) in agent configs; setting default agents and models from config; loading external plugins from npm packages or local files with effect or promise-based setups; updating provider and model catalogs with API keys, request headers, variants, and costs; registering local and git-based references; and discovering skills from directories or URLs. This replaces or augments previous config loading mechanisms with a more structured, effect-based approach.

packages/core/src/config/plugin · high confidence

The core database module has been replaced with a new v2 implementation that provides platform-specific SQLite drivers for both Bun and Node.js, wired into the Effect framework. This change introduces a robust migration system that automatically handles schema creation and upgrades, including a compatibility layer to recover legacy Drizzle migration history for existing installations. The database file path is now determined by the installation channel (latest, beta, prod) or a custom environment variable, and the schema now includes new tables for features like project directories, session context epochs, and event-sourced session inputs.

packages/core/src/database · high confidence

The workspace home page (route \/workspace/\[id\]\) has been replaced with a new layout that includes a billing header, a model selection section, a provider configuration section, and a new-user onboarding guide. The billing header displays the current balance for admin users and provides a button to enable billing via a checkout flow. The model section lists available AI models (filtered to exclude alpha and specific disabled models) with toggles to enable or disable them, grouped by provider lab. The provider section allows admins to configure, edit, and delete API keys for OpenAI, Anthropic, and Google Gemini. The new-user section appears only for workspaces with a single key and no usage, guiding users through enabling billing, logging in, and pasting their API key.

packages/console/app/src/routes/workspace/\[id\] · high confidence

The workspace interface now uses a dedicated layout component that renders a persistent sidebar navigation (with separate desktop and mobile views) alongside the main content area and a legal footer. This change introduces new routes for 'Go' and 'Usage' sections, integrates internationalization for navigation labels, and adds server-side logic to exclude migrated workspaces from selection and enforce rate limits on checkout session creation.

packages/console/app/src/routes/workspace · high confidence

The Nix build environment now incorporates two new TypeScript scripts to better support the Bun runtime. The \canonicalize-node-modules.ts\ script restructures the \node\_modules/.bun\ directory by resolving version conflicts and creating a clean, symlinked \node\_modules\ tree, ensuring consistent package resolution. The \normalize-bun-binaries.ts\ script scans packages for \bin\ entries and recreates the \.bin\ directory with correct symlinks, making command-line tools provided by dependencies available in the Nix environment. These changes improve compatibility and usability for users relying on Bun within the Nix-based build system.

nix/scripts · high confidence

The prompt input component has been completely rewritten for the v2 UI, introducing a modular architecture for handling attachments, history, and editor interactions. Users benefit from improved file and image attachment support, including native file picker integration, drag-and-drop overlays, and smarter paste handling that distinguishes between short single-line text (native paste) and multiline or large text (manual paste). The new design also features a dedicated context items display for file references, enhanced history navigation that preserves comments and deduplicates entries, and robust editor DOM utilities for accurate cursor positioning and text length calculation across complex content like file pills and line breaks.

packages/app/src/components/prompt-input · high confidence

The WSL server settings interface has been rebuilt using the v2 design system, introducing a new dialog for adding servers that guides users through WSL runtime installation, distro catalog selection, and server configuration. The update includes a dedicated context provider for WSL server state, a robust probing system that automatically checks runtime availability and distro readiness, and a settings view that displays server health, allows retrying failed starts, and managing default server selection. Existing WSL bugs related to server addition and state management have been addressed in this refactor.

packages/app/src/wsl · high confidence

The session composer has been restructured into a set of isolated, modular components to improve maintainability and state management. This change introduces dedicated controllers for managing composer state (\session-composer-state\), UI controls (\session-composer-controls\), and the visual region (\session-composer-region\), alongside specific dock components for permissions, questions, follow-ups, and reverts. It also adds a new \prompt-model-selection\ module for handling model and variant logic, and includes unit tests for the request tree and todo state logic.

packages/app/src/pages/session/composer · high confidence

The observability subsystem has been rewritten to use the Effect framework's logging and tracing capabilities. Logging is now structured, supporting both file output (with a fix to prevent high idle CPU usage by avoiding a zero batch window) and standard error, with log levels controlled via the OPENCODE\_LOG\_LEVEL environment variable. Additionally, OpenTelemetry support has been added, allowing logs and traces to be exported to an OTLP endpoint when configured, including automatic resource attributes like service name, version, and run ID.

packages/core/src/observability · high confidence

The \@opencode-ai/schema\ package has been completely rewritten to establish a new, browser-safe wire and storage contract layer. This change introduces a new event system with a centralized manifest (\event-manifest.ts\) that distinguishes between current, transitional, and legacy V1 events, and adds support for durable event definitions. All domain models (such as Agent, Model, Permission, and Session) now use V2 identifiers and schemas, while legacy V1 contracts are isolated in a \v1/\ subtree for temporary compatibility. The package also includes a new \AGENTS.md\ guide to enforce strict boundaries, ensuring schema values remain serializable and free of runtime implementation details.

packages/schema · high confidence

The TUI has been refactored into a standalone package, introducing a new application entry point (src/app.tsx) and a suite of UI components including a command palette, debug dialog with clipboard support, and dialogs for managing agents, models, and MCPs. The update also adds a new attention system for handling notifications and sounds, a cross-platform clipboard provider, and a Bun configuration file to preload the OpenTUI Solid runtime.

packages/tui · high confidence

The local OAuth callback server now uses a single, unified HTML page for all providers (such as MCP, xAI, and Snowflake) instead of provider-specific templates. This page features OpenCode branding, supports automatic window closing on success, and includes a bootstrap script to handle implicit grant flows by posting tokens back to the server. The visual design mirrors the main application, utilizing a curated subset of the app's semantic tokens and supporting both light and dark modes based on system preferences.

packages/core/src/oauth · high confidence

The static assets in the enterprise public directory (including favicons, touch icons, social share images, and the web app manifest) are now symbolic links pointing to the corresponding files in the shared UI assets directory. This change ensures that the enterprise application uses the same favicon and social share images as the rest of the web properties, maintaining visual consistency across the platform.

packages/enterprise/public · high confidence

Resolves issues with Windows path handling and canonicalization, ensuring that file paths are correctly processed and normalized across different Windows environments.

packages/opencode · high confidence

This update patches several underlying AI SDKs to improve reasoning capabilities and fix specific provider behaviors. For Amazon Bedrock and Anthropic, the patches add support for 'thinking block binding' (allowing 'none' reasoning effort and controlling prefix mismatch behavior) and ensure Anthropic input transformations are preserved. Google's SDK is patched to prevent sending empty message entries to Gemini. Groq and Mistral SDKs now accept arbitrary strings for 'reasoningEffort' to support newer model values, while Mistral also adds native reasoning support and a 'promptCacheKey'. xAI SDKs gain PDF file support in responses and a 'promptCacheKey'. OpenAI SDKs are patched to stop stripping explicit 'serviceTier' settings (flex/priority) for unsupported models, and OpenAI-compatible SDKs now pass through the full error object instead of just the message. Finally, the desktop app patches @dnd-kit/dom to preserve core scroll plugins during drag-and-drop operations.

patches · high confidence

This change introduces a \\_headers\ configuration file to ensure static assets (JavaScript, CSS) are served with the correct Content-Type headers, preventing potential browser parsing issues. It also adds an \oc-theme-preload.js\ script that runs early in the page load to synchronize the PWA status bar's \theme-color\ meta tag with the app's current color scheme (light/dark), and automatically migrates users from the deprecated 'oc-1' theme to 'oc-2'. Additionally, several favicon and social share image files are now symlinks pointing to the centralized asset location in the UI package, ensuring consistency across the application.

packages/app/public · high confidence

The file context module has been restructured into dedicated components: \path.ts\ and \path.test.ts\ now handle file path normalization and URL encoding, specifically fixing Windows path handling by preserving native separators and correctly encoding backslashes and special characters in file URLs; \content-cache.ts\ introduces an LRU cache for file content with configurable size limits to manage memory usage; \tree-store.ts\ provides a SolidJS-based store for managing the file tree state, including directory expansion and loading; \view-cache.ts\ persists file view states (scroll position, selection) across sessions; and \watcher.ts\ handles file system change events to reload open files and refresh directory listings. These changes improve reliability on Windows, optimize memory consumption for large files, and provide a more robust foundation for file management in the application.

packages/app/src/context/file · high confidence

Added browser tests for command palette, prompt state, and session lineage; Added comprehensive test coverage for core subsystems; Added comprehensive test coverage for the LLM package; Added contract, Effect, and Promise client tests; Added end-to-end test for model selection flow; Added manual performance diagnostics suite for timeline and review pane; Added regression tests for multi-server tabs, file browser stability, and review panel interactions; Added smoke tests for session timeline stability and rendering; Added specification documents for v2 architecture and package extraction; Added test coverage for CodeMode execution, tool integration, and JavaScript parity; Added test coverage for console usage, provider, and security logic; Added test coverage for the plugin system and provider integrations; Added test coverage for v2 configuration loading and plugin behavior; Added test fixtures for flock workers, git operations, and temporary directories; Added test utilities for Effect-based and Tool registry testing; Added tests for AppProcess service; Added tests for GitHub Copilot message conversion and model streaming; Added tests for GitHub OIDC repository claim parsing; Added tests for HTTP recorder redaction and record-replay fixtures; Added tests for PTY service, protocol, and ticketing; Added tests for core Effect utilities and observability; Added tests for core filesystem utilities and services; Added tests for core share and storage modules; Added tests for core utility modules; Added tests for date, model, and subscription utilities; Added tests for layer node type checking and graph building; Added timeline stability e2e test suite; Added timeline suspense reproduction fixture; Added unit tests for performance diagnostics and timeline metrics; New e2e testing utilities for visual stability and server mocking; New test infrastructure and provider coverage for the LLM package.

The project now uses a centralized dependency catalog in the root package.json to standardize versions across the monorepo, and adds new package manifests for the GitHub Actions integration, the GLM52 Rise video artifact, and several core packages (app, cli, client, codemode, console). This centralization ensures consistent dependency versions and provides the structural foundation for the new GitHub and video artifact packages.

(dependencies) · high confidence

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

• CAI 35 → 51 (+16.5)
• Rubric changed (rubric-2026.08.19 → rubric-2026.09.15) — scores are not directly comparable.

• Code Health 77 → 65 (-11.9)
• Architecture 16 → 61 (+44.7)
• Maturity 77 → 76 (-0.5)
• Readiness 38 → 46 (+7.7)
• Security 55 → 58 (+2.3)
• Accessibility 53 → 50 (-2.6)

• Boundary-crossing change coupling: bootstrap.ts ↔ font.tsx (packages/app/src/context/global-sync/bootstrap.ts)
• Boundary-crossing change coupling: bootstrap.ts ↔ server-health.ts (packages/app/src/context/global-sync/bootstrap.ts)
• Boundary-crossing change coupling: directory-layout.tsx ↔ server-health.ts (packages/app/src/pages/directory-layout.tsx)
• Boundary-crossing change coupling: index.ts ↔ github.ts (github/index.ts)
• Boundary-crossing change coupling: server-sync.tsx ↔ server-health.ts (packages/app/src/context/server-sync.tsx)
• Boundary-crossing change coupling: session-context-tab.tsx ↔ session.tsx (packages/app/src/components/session/session-context-tab.tsx)
• Boundary-crossing change coupling: status-popover.tsx ↔ server-health.ts (packages/app/src/components/status-popover.tsx)
• Boundary-crossing change coupling: terminal.tsx ↔ server-health.ts (packages/app/src/components/terminal.tsx)
• Coverage not included — suite not readable by the collector
• Dependency hygiene not measured — dependency manifest found but not parsed for hygiene
• High: security finding (details withheld)
• Hotspot: packages/opencode/src/config/config.ts (packages/opencode/src/config/config.ts)
• Hotspot: packages/opencode/src/session/prompt.ts (packages/opencode/src/session/prompt.ts)
• Medium IaC: CKV_DOCKER_3 (packages/containers/base/Dockerfile)
• Medium IaC: CKV_DOCKER_3 (packages/containers/bun-node/Dockerfile)
• Medium IaC: CKV_DOCKER_3 (packages/containers/publish/Dockerfile)
• Medium IaC: CKV_DOCKER_3 (packages/containers/rust/Dockerfile)
• Medium IaC: CKV_DOCKER_3 (packages/containers/tauri-linux/Dockerfile)
• Medium IaC: CKV_DOCKER_3 (packages/stats/server/Dockerfile)
• Medium IaC: CKV_DOCKER_7 (packages/opencode/Dockerfile)
• …and 19 more

• Boundary-crossing change coupling: dialog-select-mcp.tsx ↔ server-sync.tsx (packages/app/src/components/dialog-select-mcp.tsx)
• Boundary-crossing change coupling: session-side-panel.tsx ↔ session-review-v2.tsx (packages/app/src/pages/session/session-side-panel.tsx)
• Boundary-crossing change coupling: stats-proxy.ts ↔ index.tsx (packages/console/app/src/lib/stats-proxy.ts)
• Boundary-crossing change coupling: status-popover-body.tsx ↔ server-sync.tsx (packages/app/src/components/status-popover-body.tsx)
• Change coupling: [model].tsx ↔ index.tsx (packages/stats/app/src/routes/[lab]/[model].tsx)
• Change coupling: acp.ts ↔ serve.ts (packages/opencode/src/cli/cmd/acp.ts)
• Change coupling: dialog-select-mcp.tsx ↔ prompt-input.tsx (packages/app/src/components/dialog-select-mcp.tsx)
• Change coupling: dialog-select-mcp.tsx ↔ status-popover-body.tsx (packages/app/src/components/dialog-select-mcp.tsx)
• Change coupling: github.ts ↔ pr.ts (packages/opencode/src/cli/cmd/github.ts)
• Change coupling: index.tsx ↔ dialog-prompt.tsx (packages/tui/src/routes/session/index.tsx)
• Change coupling: network.ts ↔ server.ts (packages/opencode/src/cli/network.ts)
• Change coupling: network.ts ↔ worker.ts (packages/opencode/src/cli/network.ts)
• Change coupling: sdk.tsx ↔ server-sync.tsx (packages/app/src/context/sdk.tsx)
• Change coupling: serve.ts ↔ web.ts (packages/opencode/src/cli/cmd/serve.ts)
• Change coupling: settings-general.tsx ↔ settings-keybinds.tsx (packages/app/src/components/settings-general.tsx)
• Change coupling: types.ts ↔ index.tsx (packages/desktop/src/preload/types.ts)
• Change-coupling hub: settings-models.tsx → settings-general.tsx, settings-keybinds.tsx, settings-providers.tsx (packages/app/src/components/settings-models.tsx)
• ClassTooLong: Interpreter (packages/codemode/src/interpreter/runtime.ts)
• ClassTooLong: OpenAICompatibleChatLanguageModel (packages/core/src/github-copilot/chat/openai-compatible-chat-language-model.ts)
• ClassTooLong: OpenAIResponsesLanguageModel (packages/core/src/github-copilot/responses/openai-responses-language-model.ts)
• …and 1557 more

• 300 commits — 184 feature/other, 116 fixes

• packages/console — 92 commits
• packages/web — 69 commits
• packages/opencode — 47 commits
• packages/stats — 28 commits
• nix/hashes.json — 14 commits
• (root) — 12 commits
• packages/app — 8 commits
• packages/core — 7 commits
• (repo) — 5 commits
• packages/tui — 5 commits
• .github/workflows — 4 commits
• infra/console.ts — 3 commits
• packages/ui — 3 commits
• .github/TEAM_MEMBERS — 1 commit
• packages/function — 1 commit
• packages/sdk — 1 commit

• fix: Revert "delay removing first month discount"
• fix: fix map inaccuracy
• fix: fix map inaccuracy
• fix: fix(acp): restore session options and reasoning boundaries (#48225)
• fix: fix(app): backport session rename and tab menu fixes to v1 (#46116)
• fix: fix(app): bump happy-dom to fix GC-dependent MutationObserver flake (#46675)
• fix: fix(app): drop archived sessions from home list right away (#44905)
• fix: fix(app): identify desktop in Console device auth (v1) (#47000)
• fix: fix(app): increase open-in icon size (#46540)
• fix: fix(app): keep model provider headers visible (#44115)
• fix: fix(app): preserve file search results while loading (#43836)
• fix: fix(app): register archive session command in both layouts (#41741)
• fix: fix(console): authenticate inference proxy
• fix: fix(console): backport usage reset boundary fix to dev (#47267)
• fix: fix(console): cache desktop downloads
• fix: fix(console): connect enterprise form to Chatwoot (#47488)
• fix: fix(console): discontinue first-month Go discount (#44633)
• fix: fix(console): exclude migrated workspaces from selection (#49336)
• fix: fix(console): forward client IP to inference
• fix: fix(console): improve Go comparison chart on mobile (#45044)
• …and 280 more

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

anomalyco/opencode 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.