anomalyco/opencode
30.4
Weak · 23 October 2026
500.8k
lines of production code
TypeScript
primary language
6
measurements over time
What this system is
OpenCode is a monorepo-based AI coding assistant platform that provides a unified interface for interacting with large language models across CLI, desktop, and web environments. It manages local development workflows through a robust core engine handling session management, configuration, and process execution, while supporting a wide array of AI providers and Model Context Protocol integrations. The system enables developers to automate coding tasks and manage project contexts via a plugin architecture, emphasizing reliability and security through strict validation and extensive testing.
Features
Add Alibaba provider support across chat, messages, and responses protocols
The AI protocols package now includes native support for the Alibaba provider, introducing three new protocol implementations: \alibaba-chat.ts\ for chat completions, \alibaba-messages.ts\ for message-based interactions, and \alibaba-responses.ts\ for the responses API. These protocols enable Alibaba-specific features such as reasoning effort, thinking budgets, and search options, while correctly mapping Alibaba's request formats and handling their specific streaming and tool-use behaviors.
packages/ai/src/protocols · high confidence
Add SQLite example migration and SST environment types
The package now includes a sample SQL migration file that creates a 'users' table with 'id' and 'name' columns, providing a concrete example for schema setup. Additionally, an auto-generated SST environment type definition file has been added to support the serverless infrastructure tooling integration.
packages/effect-drizzle-sqlite · high confidence
Add Unicode LaTeX rendering in Markdown code blocks
Users can now write LaTeX math in Markdown code fences (using \latex\, \math\, \tex\, or \LATEX\ languages) and see it rendered as structured Unicode text in the terminal. The new \packages/latex\ module parses the source into a structural AST and lays it out using Unicode characters (e.g., fractions, matrices, braces, roots, and script variants), while preserving styles like bold, italic, and color. In streaming mode, the renderer keeps the last valid formula visible while the next one is incomplete, and falls back to showing the raw source for invalid or unsupported syntax. Wide formulas scroll horizontally without wrapping, and the layout respects display mode, compact scripts, and alignment options.
packages/latex · high confidence
Add component styles and improve keyboard accessibility
This change introduces new CSS files for the console application's UI components. It adds styling for buttons, including variants for primary, danger, and warning colors, as well as small and large sizes. It also defines styles for FAQ answers to ensure they remain in the server HTML for accessibility and indexing. Additionally, it restores visible focus rings for keyboard users on mobile navigation toggles, command slots, email form buttons, CLI rows, and brand grid buttons.
packages/console/app/src/style/component · high confidence
Add effect simplification lint rules for TypeScript and TSX
The \script/ast-grep/effect-simplifications\ directory now includes a set of ast-grep rules and their corresponding test snapshots for TypeScript and TSX files. These rules enforce simplifications in Effect-based code, such as replacing \Effect.catch\ with \Effect.mapError\ when only transforming errors, replacing \Effect.andThen(Effect.succeed(undefined))\ with \Effect.as(undefined)\, replacing \Effect.flatMap\ with \Effect.suspend\ with \Effect.andThen(Effect.suspend(...))\, and removing identity pipes. The addition includes both the rule definitions and the validation tests to ensure these patterns are correctly identified and simplified.
script · high confidence
Add privacy policy page with 2026 terms and state privacy rights
The console app now includes a dedicated privacy policy route (\/legal/privacy-policy\) featuring a new effective date of March 6, 2026. This page displays the full legal text, including specific sections for California (CCPA), Colorado (CPA), Connecticut (CTDPA), Delaware (DPDPA), Iowa (ICDPA), Montana (MCDPA), Nebraska (NDPA), New Hampshire (NHPA), New Jersey (NJPA), Oregon (OCPA), Texas (TDPSA), Utah (UCPA), and Virginia (VCDPA) resident rights, along with standard sections on data collection, security, and contact information.
packages/console/app/src/routes/legal/privacy-policy · high confidence
Add support for editing saved permissions
Users can now modify previously saved permission entries. This change introduces a new persistence layer for saved permissions, including a database schema and a service interface that supports listing, adding, updating, and removing individual permission records. The update capability allows users to change the action or resource associated with an existing saved permission, with conflict detection to prevent duplicate entries within a project.
packages/core/src/permission · high confidence
Added Amharic, Arabic, Azerbaijani, Bengali, and Brazilian Portuguese translations
The application now includes new translation files for Amharic (am), Arabic (ar), Azerbaijani (az), Bengali (bn), and Brazilian Portuguese (br). These files provide localized strings for the desktop menu, command palette, session management, provider connection dialogs, and server settings, enabling users to interact with the interface in these languages.
packages/app/src/runtime/i18n · high confidence
Added Cloudflare Workers and Node.js resource adapters for SST integration
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
Added LLM usage tutorial demonstrating core API patterns
A new tutorial file (\packages/ai/example/tutorial.ts\) was added to demonstrate the public API of the \@opencode/ai\ package. It provides runnable examples for configuring providers (like OpenAI), building provider-neutral requests, and executing LLM calls via \generate\ and \stream\. The tutorial also covers advanced features such as tool use with Effect Schema, structured output generation via \generateObject\, and provider composition using custom protocols.
packages/ai/example · high confidence
Added catch-all route for internationalized API proxying
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
Automatic session and job recovery after server restart
The system now automatically resumes suspended sessions and recovers background jobs (shells and subagents) when the server restarts. Users will see a notification indicating the server restarted and that work is continuing from where it left off, rather than losing progress or having to manually restart interrupted tasks. This ensures that long-running or background operations are preserved across service restarts.
packages/core/src/session/execution · high confidence
CLI plugin management commands
The CLI now includes a set of commands to manage plugins directly from the terminal. Users can add, remove, list, check, and update plugins for both the server and TUI environments. The add command installs npm or Git packages and updates configuration files, while the list command displays installed plugins with their versions and sources. The check command verifies the status of plugins, and the update command upgrades outdated plugins. These commands provide a comprehensive way to handle plugin lifecycle without leaving the command line.
packages/cli/src/commands/handlers/plugin · high confidence
CLI v2 architecture overhaul with new command surface and embedded web UI
The CLI has been rebuilt for v2, introducing a comprehensive set of new commands including session management (list, delete, import, export), authentication (login, logout, switch, export, import), model selection, plugin management, and debugging tools (heap dump, CPU profiling, config inspection). The embedded web UI is now served as a brotli-compressed binary archive for improved performance, and the CLI now supports managed background services with automatic updates, remote pairing via OpenTunnel, and SSH askpass integration.
packages/cli/src · high confidence
Console app bootstrapped with SolidStart, i18n, and security middleware
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
Console app localization files added for multiple languages
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
Console app scaffolding for SolidStart and Cloudflare Workers
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
Core services and provider routing restructured
The core package has been reorganized into distinct service modules (agent, command, config, credential, bus, file-access) and a new native provider routing layer (aisdk-native). This introduces a centralized agent selection service, a command registry for executing session prompts, and a credential management system backed by a SQLite database. Additionally, the AI SDK provider mappings are now rewritten to route external packages to native OpenCode providers, with specific handling for Bedrock, Azure, and various hosted endpoints.
packages/core/src · high confidence
Enterprise form now uses hCaptcha and Jev spam scoring to filter leads
The Console enterprise contact form now integrates hCaptcha for bot protection and a Jev-based spam classifier to score submissions before they reach Salesforce. Confident spam (score ≥ 0.9) is silently dropped with a success message, while uncertain or failed scores still create the lead (fail-open). The form also captures monthly inference spend, sends localized emails via AWS SES, and subscribes verified leads to EmailOctopus.
packages/console/app/src/lib · high confidence
Expanded JavaScript standard library implementation in CodeMode
The CodeMode interpreter now includes a comprehensive implementation of the JavaScript standard library, significantly increasing language parity. This update introduces full support for Array, Map, Set, and WeakMap/WeakSet collections, along with Iterator helpers (map, filter, take, drop, flatMap) and groupBy. It also adds the Headers built-in, a structured console for logging and table output, and a complete Date implementation with UTC and timezone handling. Furthermore, the interpreter now supports Uint8Array for binary data, expanded Math and Number methods (including sumPrecise), and robust JSON parsing and stringification with replacer callbacks.
packages/codemode/src/stdlib · high confidence
Experimental evaluation API and real-time voice connectivity
This update introduces an experimental evaluation API for assessing model outputs, including the \evaluation-client.ts\ and \evaluation.ts\ files which define the client service, request/response schemas (choice, score, boolean questions), and validation logic. It also adds real-time voice connectivity support in \realtime.ts\, enabling connections to OpenAI (gpt-live, gpt-realtime), xAI (grok-voice), and Google (gemini-live) via WebRTC or WebSocket transports, including ephemeral token handling for Gemini and OpenAI. Additionally, \system-one.ts\ implements a specific evaluation route for the System One provider, handling authentication, request encoding, and response parsing for their evaluation endpoint.
packages/ai/src/experimental · high confidence
Extracted dedicated TUI theme package with native V2 support
The theme logic has been extracted into a standalone \packages/theme\ package, introducing a new native V2 theme format for the terminal UI. This update brings a comprehensive schema for defining semantic hues, text, background, and syntax tokens, along with utilities to expand, resolve, and migrate themes. Users benefit from a new \migrateV1\ function that automatically converts legacy V1 theme definitions into the new V2 structure, ensuring backward compatibility. The package also includes build and publish scripts to streamline the release process for this new theme system.
packages/theme · high confidence
Generated Effect-based API client for server communication
The client now includes a generated API layer (\packages/client/src/effect/api/api.ts\) built on the Effect framework, providing typed operations for server interactions such as session management, plugin updates, and location handling. This replaces or supplements previous client-side API implementations with a standardized, code-generated contract that ensures type safety and consistent error handling across the application.
packages/client/src/effect/api · high confidence
Generated Effect-based HTTP client for OpenCode API
The client now includes a generated HTTP API client built on the Effect framework, located in \packages/client/src/effect/generated\. This addition introduces a new \ClientError\ type and exports a comprehensive \OpenCode\ client module that provides typed, Effect-based wrappers for server interactions, including session management, plugin handling, integration connections, and permission controls.
packages/client/src/effect/generated · high confidence
Initial TypeScript configuration for the function package
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
Initial configuration and environment setup for .opencode
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
Initial release of the opencode VS Code extension SDK
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
Initial repository scaffolding and developer tooling configuration
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
Introduce @opencode/ai package with schema-first Effect-based APIs
The new @opencode/ai package provides a schema-first API for text, image, video, speech, and transcription generation built on Effect. It exposes LLM.generate/stream for text, Image.generate for media, and Evaluation.run for experimental evaluation tasks, with provider-specific entry points for OpenAI, Google Interactions, Venice AI, and others. The package includes a promise-based facade (@opencode/ai/promise) for simpler synchronous-style usage, configurable request executors, and a test harness that replays recorded HTTP cassettes by default.
packages/ai · high confidence
Introduce @opencode/client package with generated HTTP APIs
A new private package, @opencode/client, has been added to provide client-side HTTP access derived from the server's authoritative Effect HttpApi. It exposes two entry points: a standard Promise-based client using fetch and a rich Effect-based client for environments requiring Effect runtime integration. The package includes generated code covering standard HTTP groups, utilizes canonical decoded values from the @opencode/schema package, and enforces transport consistency through generation-equivalence tests.
packages/client · high confidence
Introduce @opencode/codemode confined JavaScript interpreter
The new @opencode/codemode package provides a lightweight, confined JavaScript interpreter designed for running code in a sandboxed environment. It supports a subset of JavaScript syntax and standard library features, allowing programs to interact with the outside world exclusively through host-provided tools and extensions. The interpreter enforces execution limits such as timeouts, tool call caps, and output size bounds, and handles data serialization across the host boundary using JSON-like constraints. This release includes the core runtime, API documentation, and a support matrix detailing implemented features and known gaps.
packages/codemode · high confidence
Introduce @opencode/core package with v2 database schema
The packages/core directory now contains the core runtime services, including a new Drizzle ORM schema definition (schema.json) that establishes the v2 database structure with tables for sessions, projects, worktrees, and credentials. This location also provides the configuration files (tsconfig, bunfig, drizzle.config) and SQL table definitions required to support the v2 data migration and the new session inbox and pending storage features.
packages/core · high confidence
Introduce @opencode/http-recorder for deterministic HTTP and WebSocket test cassettes
A new \@opencode/http-recorder\ package is available for Node.js 22+ and Bun, enabling tests to record real HTTP and WebSocket traffic once and replay it from deterministic JSON cassettes. The package provides Effect layers (\layer\, \layerFetch\, \layerSocket\, \layerWebSocketConstructor\) that intercept requests and responses, automatically redacting sensitive headers, URLs, and JSON bodies by default while allowing custom redaction rules. It supports an "auto" mode that records on the first local run and replays subsequently, failing in CI if a cassette is missing, and includes safety checks to prevent writing cassettes containing detected secrets.
packages/http-recorder · high confidence
Introduce @opencode/httpapi-codegen for generating Effect and Promise HTTP clients
A new private package, @opencode/httpapi-codegen, has been added to provide build-time source generation for domain-oriented HTTP clients derived from Effect's HttpApi and Schema contracts. The package exposes a staged API (compile, emitEffect, emitPromise, write) to generate two distinct client types: a rich Effect client with decoded native values and runtime schemas, and a zero-Effect Promise client with structural wire-oriented values and direct fetch usage. It handles input flattening, error mapping to a stable ClientError, streaming support, and safe file output management, with comprehensive tests validating the generation logic and file writing behavior.
packages/httpapi-codegen · high confidence
Introduce @opencode/sdk for in-process embedding
The \packages/sdk\ directory now contains the \@opencode/sdk\ package, providing an in-process host that executes the OpenCode HTTP router in memory without opening a network listener. This SDK supports both Promise-based and Effect-based application patterns, allowing developers to embed the full OpenCode application graph directly into their own runtimes. It includes dedicated entrypoints for Cloudflare Workerd (Durable Objects) and features session-selected plugin instances, enabling different application plugins to be configured and cached per session within the same directory. The package also includes build, publish, and verification scripts to manage the SDK lifecycle and ensure package integrity.
packages/sdk · high confidence
Introduce Astro-based posts site
Adds a new Astro-powered static site for publishing blog posts at the /posts path on opencode.ai. The site renders MDX content with a dark theme, supports interactive Astro components (such as a client-side counter), and is configured for deployment on Cloudflare Workers.
packages/posts · high confidence
Introduce CodeMode confined execution runtime
Adds a new confined execution environment for running user-provided JavaScript code safely. The runtime enforces resource limits (timeout, tool call count, output size) and isolates data crossing the host boundary by converting program values to JSON-safe formats (e.g., Sets become arrays, URLSearchParams become query strings) while stripping dangerous keys like \\_\proto\\_\. It supports a structured tool system with namespaces, schema-based input/output validation, and hooks for monitoring tool and extension calls, ensuring that program failures are returned as data diagnostics rather than unhandled exceptions.
packages/codemode/src · high confidence
Introduce Effect-based client and service lifecycle implementations
The client package now provides an Effect-based entry point (packages/client/src/effect) alongside the existing Promise-based one. This includes a new RPC client runtime that wraps calls and event subscriptions in Effect streams, a client factory that integrates HTTP headers and shared event streams, and a service management module that handles discovering, ensuring, and stopping the local background service using Effect schedulers and health probes.
packages/client/src/effect · high confidence
Introduce FFF-powered file search with runtime-specific adapters
The filesystem search layer now supports a new FFF (Fast File Finder) backend to accelerate file and directory lookups. This change adds runtime-specific adapters for Bun, Node, and Workerd runtimes, allowing the system to leverage native search capabilities where available. The search service automatically selects the FFF layer when appropriate (e.g., non-workspace, VCS-backed locations on supported platforms) and falls back to the existing Ripgrep-based fuzzy search if FFF is unavailable or disabled. Additionally, the diff introduces a location watcher policy service to manage ignore patterns and a location watcher that monitors specific VCS-related paths (like .git/HEAD) for changes, ensuring the search index stays synchronized with the file system state.
packages/core/src/filesystem · high confidence
Introduce GitHub Copilot Responses API integration
Added a new language model implementation in the \packages/core/src/github-copilot/responses\ directory that enables the use of the OpenAI Responses API for GitHub Copilot. This change introduces a new \OpenAIResponsesLanguageModel\ class and supporting modules to convert standard prompts into the Responses API format, handle specific tool types (such as file search, web search, code interpreter, and image generation), and map API responses back to the provider's internal model. It also includes type definitions for the API and configuration options for file ID prefixes, allowing users to interact with models using the newer Responses API structure.
packages/core/src/github-copilot/responses · high confidence
Introduce GitHub Copilot adapter with model catalog and error handling
Added the core GitHub Copilot adapter implementation, including a provider factory that creates chat and responses language models, a model catalog loader that fetches and reconciles available models (including support for PDF input and adaptive thinking capabilities), and an error handling schema for OpenAI-compatible responses. This establishes the foundational integration layer for GitHub Copilot within the core package.
packages/core/src/github-copilot · high confidence
Introduce MCP client, transport, and orchestration layer
The core now includes a full Model Context Protocol (MCP) integration, providing the client logic, transport implementations (stdio, WebSocket/socket, and HTTP), and OAuth 2.1 authentication flows. This change adds the \Mcp\ service layer to manage server connections, tool execution, and resource access, while also introducing MCP-specific instruction handling to guide the agent on how to use available tools.
packages/core/src/mcp · high confidence
Introduce Nix build support for the OpenCode CLI and Desktop application
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
Introduce OpenAPI tool adapter for CodeMode
The \packages/codemode/src/openapi\ directory now provides a new adapter that converts OpenAPI 3.x specifications into executable CodeMode tools. The \fromSpec\ function parses the document, projects request and response schemas (respecting \readOnly\/\writeOnly\ directions), and generates a tool for each supported HTTP operation. It handles authentication via a pluggable \AuthResolver\, manages query/header/body serialization, and returns a list of generated tools alongside any operations that were skipped due to unsupported features (such as cookie parameters or complex security schemes).
packages/codemode/src/openapi · high confidence
Introduce OpenCode V2 Plugin API with Effect and Promise runtimes
The \packages/plugin\ package now provides the authoring interfaces and runtime loader for OpenCode V2 plugins, supporting both Effect and Promise-based implementations. This release exposes a comprehensive plugin context that allows plugins to register domain transforms (for agents, models, tools, providers, skills, VCS, and more) and runtime hooks (for session generation, retries, and tool execution). It also includes APIs for managing MCP servers, defining custom tools, handling permissions, and interacting with the terminal UI, establishing the foundation for the V2 plugin ecosystem.
packages/plugin · high confidence
Introduce Solid.js-based client data and connection layer
The client now uses a new Solid.js-based architecture for managing state and connectivity. This includes a robust connection manager that handles event streaming, automatic reconnection, and idle-timeout detection to keep the session alive. A new data layer caches API reads and applies server events into a Solid store, ensuring consistent state across the UI. Additionally, new utilities handle PTY (terminal) connections and calculate context usage metrics for display in the TUI and desktop apps.
packages/client/src/solid · high confidence
Introduce V2 CLI service architecture and remote access capabilities
The CLI now uses a new service layer built on the Effect framework, introducing several key capabilities: remote access via OpenTunnel with unguessable subdomains and one-time pairing links, a self-update mechanism supporting multiple package managers (npm, Homebrew, WinGet, etc.), and an embedded web UI served with brotli compression. Background service management is now handled through a dedicated config system with channel-aware registration files, and Windows-specific issues with binary replacement are resolved by retaining hard links during upgrades. The update system includes a preflight UI for version mismatches and respects user-configured update policies (disable, notify, auto).
packages/cli/src/services · high confidence
Introduce V2 formatter runtime with built-in tool definitions
The core formatter module now includes a new V2 runtime architecture, starting with the addition of \builtins.ts\ which defines the configuration and detection logic for a wide range of code formatting tools. This change introduces support for detecting and invoking formatters such as Prettier, oxfmt, Biome, gofmt, mix, zig, clang-format, ktlint, ruff, and air, allowing the editor to automatically format files based on project dependencies and configuration files. The implementation uses the Effect library for managing side effects and process execution, marking a shift in how formatter selection and execution are handled within the core package.
packages/core/src/formatter · high confidence
Introduce VS Code extension for terminal integration
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
Introduce dedicated CLI package with Bun runtime and embedded web UI
The \packages/cli\ directory is now a standalone package built for the Bun runtime, featuring a new Dockerfile for multi-architecture Linux builds and a Vite-based build system. This change embeds the web UI assets directly into the CLI binary and configures the environment to use \@opentui/solid\ for the interface, while also establishing a development guide for CLI and TUI contributors.
packages/cli · high confidence
Introduce dedicated Go landing page with model lineup and usage visualization
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
Introduce dedicated desktop package with Electron build and packaging configuration
The \packages/desktop\ directory now contains the complete build and packaging configuration for the OpenCode desktop application, which is built with Electron. This includes the \electron-builder\ configuration for managing app identity across dev, beta, and prod channels, Vite build settings for the main process and renderer, and scripts for benchmarking startup performance. The package also defines platform-specific resources, such as macOS entitlements for JIT and audio input, Windows installer scripts for sandbox access, and Linux desktop entry files, alongside a Drizzle ORM configuration for SQLite-based persistence.
packages/desktop · high confidence
Introduce dedicated web app package with PWA, testing, and build tooling
The \packages/app\ directory now contains the standalone web application, including the SolidJS entry point, Vite build configuration, and a service worker for offline support and installability as a Progressive Web App (PWA). The package includes Playwright configuration for end-to-end and component tests, a custom Vite plugin for channel-specific icon management, and SST infrastructure definitions for deploying the web app to the beta environment. This change establishes the structural foundation for the web client, separating it from the desktop and CLI packages.
packages/app · high confidence
Introduce environment abstraction with local and memory drivers
The core package now exposes a structured environment layer that abstracts file system operations and process execution. This change adds a local driver that wraps Node.js \fs\ for host filesystem access and a memory driver for in-memory simulation, both implementing a unified \Files\ interface. The environment service integrates these drivers with a child process spawner, allowing the system to operate in local or workspace-bound contexts while providing a consistent API for file reads, writes, and metadata operations.
packages/core/src/environment · high confidence
Introduce new Home session list UI and management logic
The Home page now features a completely rewritten session list that groups sessions by recency, supports searching by name or session ID, and allows archiving, renaming, and exporting sessions. The new implementation includes a command palette integration for session selection, background opening via middle-click or modifier keys, and optimized index loading that caps concurrent requests and retains a bounded set of recent sessions per directory.
packages/app/src/home/sessions · high confidence
Introduce new desktop menu system and file picker constants
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
Introduce new-session draft workflow with workspace and MCP controls
The new-session area now implements a draft-based session creation flow. A new route (DraftRoute) manages draft tabs, allowing users to configure project selection, workspace/worktree branching, and MCP tool states before submitting. The composer adapter handles the transition from draft to active session, including worktree creation and optimistic attachment handoff. UI components include a new session wordmark with a subtle shimmer animation, expanded prompt width, and persistent onboarding tips for workspaces and providers.
packages/app/src/new-session · high confidence
Introduce opencode CLI with comprehensive command structure
The CLI root command is now named 'opencode' and exposes a structured set of commands including 'upgrade', 'uninstall', 'acp', 'api', 'debug', and 'auth'. Users can now manage integrations and credentials via 'auth' subcommands (list, login, logout), make direct server requests via 'api', and access debugging tools like heap dumps and path listings. The root command supports session continuation via --continue and --session flags, allows running with a private server via --standalone, and includes permission handling flags like --auto.
packages/cli/src/commands · high confidence
Introduce opencode GitHub Action for workflow integration
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
Introduce persistent PTY daemon with secure binary management
The core package now includes a new persistent PTY subsystem that manages terminal sessions via an external daemon process. This change introduces secure binary resolution and installation logic (in \binary.bun.ts\ and \binary.node.ts\) that validates embedded executables using SHA-256 checksums and enforces strict file permissions and ownership checks to prevent tampering. The \daemon.ts\ module implements the communication protocol and lifecycle management for these persistent terminals, while \index.ts\ exposes the new \PersistentPty\ service interface for creating, attaching to, and managing terminal sessions across server restarts.
packages/core/src/persistent-pty · high confidence
Introduce prebuilt CI container images for GitHub Actions
This change adds a new \packages/containers\ area containing Dockerfiles and a build script for prebuilt Linux container images (base, bun-node, rust, tauri-linux, publish) designed to speed up GitHub Actions jobs by baking in large dependencies. The \base\ image provides Ubuntu 24.04 with common build tools, \bun-node\ adds Bun 1.4.4 and Node.js 24, \rust\ includes the Rust toolchain, \tauri-linux\ adds Tauri-specific dependencies, and \publish\ includes Docker CLI and AUR tooling. A \script/build.ts\ script allows building and optionally pushing these multi-arch images to a registry, and a README documents their usage in GitHub Actions workflows via \job.container\.
packages/containers · high confidence
Introduce recently closed session tabs menu
Users can now access a menu of recently closed session tabs, allowing them to quickly reopen sessions that were previously closed. This feature is implemented in the tabs shell, where closed session tabs are tracked in a stack (limited to 25 entries) and exposed via a new UI component. Draft tabs are not included in this history, as their state is deleted upon closing. The implementation includes persistence of the closed tab stack and logic to filter out tabs that are already open or associated with removed servers.
packages/app/src/shell/tabs · high confidence
Introduce session-level prompt queuing and location recovery
The session composer now supports queuing multiple prompts behind the current turn, allowing users to reorder, edit, undo, or steer (move to the front) queued items via a dedicated panel. It also restores sessions when their workspace location becomes unavailable by presenting a UI to choose a new directory or create a worktree.
packages/app/src/session/composer · high confidence
Introduce standalone Promise-based client with generated types and error handling
The promise client package now includes a new set of generated TypeScript files (client.ts, types.ts, client-error.ts, index.ts) that provide a standalone promise-based API for interacting with the server. This includes a comprehensive set of input/output types for sessions, agents, plugins, integrations, and more, along with a dedicated ClientError class that preserves provider error status and includes detailed reason codes (Transport, UnexpectedStatus, etc.) for better error diagnostics.
packages/client/src/promise/generated · high confidence
Introduce the @opencode/protocol package with a generated OpenAPI specification
The \packages/protocol\ directory now contains a new package that defines the server's HTTP API surface using Effect's \HttpApi\ framework. This includes a generated \openapi.json\ document, a build script, and a stabilization utility to ensure deterministic schema naming. The package exposes typed API groups for server, debug, location, agent, command, config, credential, event, form, filesystem, generate, integration, session, message, model, provider, voice, permission, skill, rpc, pty, persistent-pty, shell, reference, worktree, vcs, migration, and websearch, along with a client definition and error types. This centralizes the protocol definition and enables OpenAPI generation for external tooling and documentation.
packages/protocol · high confidence
Introduce unified AI SDK with multi-modal generation and caching
The \packages/ai/src\ directory now provides a comprehensive, Effect-based AI SDK that unifies language model interactions with new multi-modal capabilities. Users can now generate images, video, speech, and transcriptions alongside standard text generation, all managed through a single \AIClient\ layer. The SDK introduces a robust caching system (\cache-policy.ts\) that automatically places provider cache breakpoints on tools, system prompts, and message tails to optimize costs for long-running agent sessions. Additionally, it supports asynchronous, queued media generation with polling and streaming events, and includes an experimental evaluation API for testing model outputs.
packages/ai/src · high confidence
Introduce v2 UI component primitives and design system
The \packages/ui\ package now publishes a new v2 design system, introducing \Button-v2\, \IconButton-v2\, and \SplitButton-v2\ components with distinct visual variants (neutral, danger, warning, contrast, ghost, submit) and sizes (small, normal, large). These components are styled via a new CSS layering strategy (\@layer properties, theme, base, components, utilities\) and rely on v2 CSS tokens (e.g., \--v2-background-bg-button-neutral\) for theming. The package also includes a new \AGENTS.md\ file enforcing strict i18n and typography guidelines, and build scripts (\pack.ts\, \publish.ts\, \tailwind.ts\) to support the new component exports and Tailwind color variable generation.
packages/ui · high confidence
Introduce v2 session runner with durable execution and compaction
The session runner has been replaced with a new v2 implementation that manages session lifecycles through a durable \drain\ loop, allowing sessions to continue across location moves and reloads. This change introduces automatic and manual context compaction to handle context overflow, a robust retry policy for transient provider failures, and a new step-based execution model that supports interrupted tool calls and streaming continuations. The runner now persists session state via an event-sourced inbox, ensuring that work is not lost during interruptions and that sessions can be resumed from the last known step.
packages/core/src/session/runner · high confidence
Introduces Effect-based app node builder and platform-specific runtime layers
This change adds new infrastructure files in the core Effect module to support the embedded v2 session runtime. It introduces an app-node builder that configures instance and location service bindings, a platform layer that sets up HTTP clients and WebSocket constructors for the Node.js environment, and a keyed mutex utility for concurrent access control. Additionally, it implements a platform-aware WebSocket constructor that handles proxy configuration (via environment variables like NO\_PROXY and HTTP\_PROXY) and disables Bun's default fetch idle timeout to prevent premature termination of long-running provider requests.
packages/core/src/effect · high confidence
Introduces PTY ticketing and wire protocol for secure terminal access
The PTY service now includes a ticket-based authorization system that issues short-lived tokens to grant access to specific pseudo-terminals or MCP client connections, ensuring that only valid, scoped requests can attach to a session. Additionally, a new wire protocol defines how terminal data is transmitted over websockets, handling replay chunks and cursor metadata to allow clients to resume terminal state reliably after disconnection.
packages/core/src/pty · high confidence
Introduces a new session UI architecture with dedicated layout, model, and revert logic
The session view has been restructured into a new vertical slice under \packages/app/src/session\. This change introduces a dedicated \SessionModel\ (model.ts) that centralizes session state, message history, and project context, replacing the previous ad-hoc data access. A new \SessionScreenView\ (screen.tsx) and \createSessionScreenLayout\ (screen-layout.ts) manage the responsive layout, side panels, and dock regions. The revert functionality is now handled by a new \createSessionRevert\ (revert.ts) module, enabling users to undo, redo, and recall prompts within a session. Additionally, a new \PreparingComposer\ (preparing-composer.tsx) handles the composer state during session initialization, and \IncompatibleServerPanel\ (incompatible-server-panel.tsx) provides specific error handling for server version mismatches. These changes collectively improve session navigation, layout stability, and the user's ability to manage conversation history.
packages/app/src/session · high confidence
Introduces a unified, Effect-based schema for AI protocol types, events, and errors
The \packages/ai/src/schema\ directory now defines the core data contracts for the AI system using Effect's Schema library. This includes a comprehensive error hierarchy (\errors.ts\) with distinct types for provider failures, transport issues, and tool execution errors, ensuring structured error handling. The \events.ts\ file establishes a detailed event stream schema, introducing a granular \Usage\ model that separates cached, non-cached, and reasoning tokens to provide accurate billing and context metrics, alongside specific events for text, reasoning, and tool interactions. \messages.ts\ standardizes content parts (text, media, tool calls) and tool result values, while \options.ts\ defines request configuration structures like \HttpOptions\ and \GenerationOptions\. These schemas provide a single source of truth for data validation and serialization across the AI package.
packages/ai/src/schema · high confidence
Introduces global-sync runtime for server-backed project and directory state management
Adds a new \global-sync\ module to the app runtime that manages the lifecycle, synchronization, and memory usage of per-directory state stores. This includes a bootstrap process that loads project metadata and path information from the server, a child-store manager that handles directory-specific state with pinning and idle eviction (capping active stores at 30 with a 20-minute TTL), and utilities for normalizing agents, providers, and project info. The implementation also features a refresh queue for batching directory updates, MCP server connection toggling, and retry logic for transport errors during bootstrap.
packages/app/src/runtime/server/global-sync · high confidence
Introduces platform abstraction and PWA route persistence
The application now uses a unified platform abstraction layer to handle environment-specific behaviors, providing a \PlatformProvider\ context and distinct implementations for web and desktop environments. For web users, this includes improved PWA support that automatically restores the previous navigation route when relaunching the app, ensuring a seamless return to the last session. The platform layer also standardizes core capabilities such as external link handling, system notifications, and local storage, while introducing a \KeyboardInsets\ component to manage safe-area adjustments on mobile devices when the keyboard is open.
packages/app/src/runtime/platform · high confidence
Introduces structured composer editor with typed prompt parts and robust state management
The composer editor now uses a structured, typed state model (ComposerPersistedState) that distinguishes between text, file, skill, and agent parts, ensuring that attachments and structured mentions are preserved during edits rather than being flattened. New editor actions (actions.ts) provide precise control over prompt text, cursor position, and context items, while DOM utilities (dom.ts) correctly handle caret positioning across complex content including zero-width characters, line breaks, and mention pills. The interaction layer (interaction.ts) integrates these actions with a state machine to manage suggestions, context, and command menus, and includes logic to handle clipboard pasting as attachments only when appropriate. Tests (actions.test.ts, dom.test.ts, interaction.test.ts) verify that text insertion, mention handling, and cursor mapping work correctly with this new structured approach.
packages/app/src/composer/editor · high confidence
Introduces the GUI extensions SDK and built-in browser extension
The desktop and web apps now organize non-core features as extensions using a new typed SDK in \packages/gui-extensions\. This change adds the SDK infrastructure (manifests, context, lifetimes, and host boundaries) and ships the first built-in extension: the browser, which includes a redesigned address bar, URL resolution logic, and tools for analyzing performance traces, CPU profiles, and heap snapshots. The extension system enforces strict typing and lifecycle management to prevent common integration bugs at compile time.
packages/gui-extensions · high confidence
Introduction of design token system for colors, typography, and spacing
The console application now includes a foundational design token system located in the style token directory. This change introduces three new CSS files: color.css defines semantic color variables for light and dark themes (including backgrounds, text, accents, and button states); font.css establishes a consistent typography scale and font families (defaulting to Berkeley Mono); and space.css provides a standardized spacing scale and border-radius values. These tokens centralize visual styling decisions, enabling consistent theming and easier maintenance of the UI's visual language.
packages/console/app/src/style/token · high confidence
Launch of the OpenCode Stats site
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
Launch of the Zen landing page
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
Launch of v2 documentation site
The web package has been replaced with a new Astro and Starlight-based documentation site. This introduces a multi-locale documentation platform (supporting English, Chinese, Japanese, Korean, German, French, Spanish, and others) with a dedicated landing page, a v2 announcement banner, and a new WebSocket-powered share page component for viewing session history. The site is configured to deploy to Cloudflare and uses a custom theme for styling.
packages/web · high confidence
Local Salesforce integration and automated sitemap generation
The Console package now includes scripts to support local development and documentation visibility. A new local enterprise handler (dev-enterprise.ts) allows developers to run a local server that proxies Salesforce Lead submissions via the Salesforce CLI, enabling offline testing of lead enrichment workflows. Additionally, a new sitemap generation script (generate-sitemap.ts) automatically builds an XML sitemap by combining main application routes (including the new /go landing page) with localized documentation routes, ensuring search engines can index the latest content.
packages/console/app/script · high confidence
Manage provider accounts and extensions in Settings
The Settings UI now includes a Providers section where users can switch, rename, and remove provider accounts (such as OpenAI or Anthropic) directly, with UI feedback for actions like disconnecting or switching credentials. It also introduces an Extensions tab allowing users to toggle MCP servers on or off, while displaying available plugins and skills.
packages/app/src/settings/providers · high confidence
Native provider support for Alibaba, Amazon Bedrock Mantle, and Anthropic-compatible services
The AI package now includes dedicated provider modules for Alibaba Cloud, Amazon Bedrock Mantle, and generic Anthropic-compatible endpoints. Alibaba support adds chat, messages, and responses routes with region-based host resolution and hosted tools (web search, code interpreter). Amazon Bedrock Mantle introduces native support for Anthropic Messages and OpenAI-compatible chat/responses, handling SigV4 and bearer authentication, with specific handling for Claude model versioning and effort updates. The new Anthropic-compatible provider allows connecting to any Anthropic-API-compatible endpoint by specifying a custom base URL and provider name, enabling flexibility for self-hosted or third-party Anthropic-like services.
packages/ai/src/providers · high confidence
New @opencode-ai/util package with shared utility functions
The new @opencode-ai/util package introduces a suite of shared utility functions and Effect-based infrastructure. It includes an activity calendar generator for displaying step/activity data, artifact classification by file extension, base64 encoding/decoding with native fallbacks, binary search and insertion utilities, and UTF-8 BOM handling. The package also provides cross-platform child process spawning, file locking (flock) with heartbeat and stale detection, and a LayerNode system for composable, replaceable Effect Layer wiring. Build and publish scripts are included to support package distribution.
packages/util · high confidence
New API route for enterprise form submissions
A new API route at /api/enterprise has been added to handle enterprise form submissions. In non-production environments, the route immediately returns a success response without performing external integrations like hCaptcha, spam scoring, or Salesforce updates. In production, it delegates to the existing enterprise request handler to process the submission through the full pipeline.
packages/console/app/src/routes/api · high confidence
New About settings page with animated wordmark and contributor credits
A new About page has been added to the application settings. It displays the current version, license information, and credits for writers and illustrators, including a dynamic count of other contributors. The page features an animated 'opencode' wordmark that plays when the section is active and includes a button to view third-party license notices in a dialog.
packages/app/src/settings/about · high confidence
New Bedrock protocol utilities and streaming infrastructure
This change introduces a suite of new utility modules in the Bedrock protocol layer to enhance authentication, media handling, and caching. It adds \bedrock-auth.ts\ to support AWS SigV4 signing and the AWS default credential chain, \bedrock-media.ts\ to validate and lower image and document (PDF, CSV, etc.) inputs, and \bedrock-cache.ts\ to manage breakpoint limits and TTLs for prompt caching. Additionally, it includes \gemini-generate-content.ts\ for handling Google Gemini streaming and policy errors, \gemini-json-schema.ts\ for normalizing JSON schemas, \lifecycle.ts\ for tracking text and reasoning event states, \partial-json.ts\ for parsing incomplete JSON streams, and \responses-checkpoint.ts\ for managing compaction checkpoints.
packages/ai/src/protocols/utils · high confidence
New Brand Assets page with localized downloads
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
New CLI build and distribution scripts for v2
The \packages/cli/script\ directory now contains the build tooling for the v2 CLI, including \build.ts\ and \build-node.ts\ for compiling Bun and Node SEA binaries, \app-assets.ts\ for embedding the web UI, and \postinstall.mjs\ for installing native binaries. It also introduces \publish-aur.ts\ and \publish-homebrew.ts\ for publishing to Linux and macOS package managers, alongside \publish.ts\ for npm distribution and \service-smoke.ts\ for verifying the compiled service lifecycle.
packages/cli/script · high confidence
New CLI command execution framework using Effect
The CLI now uses a new runtime and specification layer built on the Effect library to manage command execution. This introduces a structured way to define command hierarchies, handle lazy loading of command handlers, and manage dependencies like configuration and file system access. Users benefit from a more robust command structure that supports aliases and nested subcommands, although the specific user-facing commands remain defined in other parts of the codebase.
packages/cli/src/framework · high confidence
New CLI commands for API, models, stats, and ACP interactions
The CLI now includes dedicated handlers for several new capabilities: the \api\ command allows users to execute arbitrary HTTP requests against the server using operation IDs or raw method/path syntax; the \models\ command lists available models for the current directory; the \stats\ command provides detailed usage statistics with activity calendars and cost breakdowns; and the \acp\ command enables direct Agent Client Protocol interactions. These handlers replace the previous monolithic command structure with a modular, Effect-based runtime that manages server connections, authentication, and output formatting for each specific use case.
packages/cli/src/commands/handlers · high confidence
New CLI commands for managing authentication credentials
The CLI now includes dedicated commands to manage stored authentication credentials: \auth export\ and \auth import\ allow backing up and restoring credentials (with a warning about secrets in export output), \auth list\ displays configured integrations and their connection types, \auth switch\ lets users change the active credential for a specific integration, and \auth logout\ removes a specific credential. These commands rely on new handlers in \packages/cli/src/commands/handlers/auth\ that interact with the OpenCode client to list, create, activate, and remove credentials, supporting both interactive selection and programmatic targeting via flags.
packages/cli/src/commands/handlers/auth · high confidence
New CLI commands for managing sessions
The CLI now includes four new commands under the session namespace: list, delete, export, and import. The list command displays recent sessions in a table or JSON format, optionally paging through results. The delete command removes a specific session by ID. The export command allows users to export session data to JSON, with interactive selection if no session ID is provided. The import command reads session data from a local file or URL and imports it into the server, handling conflicts and validation.
packages/cli/src/commands/handlers/session · high confidence
New CLI commands to manage MCP servers
The CLI now includes four new commands for managing Model Context Protocol (MCP) servers: \mcp add\ allows users to register remote or local MCP servers by providing a URL or a local command, storing the configuration in \opencode.json\ or \opencode.jsonc\; \mcp list\ displays all configured MCP servers along with their connection status (connected, needs authentication, failed, or disabled); \mcp auth\ enables interactive OAuth authentication for remote MCP servers that require it, handling credential storage and re-authentication; and \mcp logout\ removes stored OAuth credentials for a specified MCP server. These commands provide a unified interface for configuring and authenticating MCP integrations directly from the command line.
packages/cli/src/commands/handlers/mcp · high confidence
New CLI debug commands for agents, config, heap dumps, and paths
The CLI now includes a suite of debug commands to help diagnose and inspect the application state. Users can run \debug agents\ to list available agents, \debug config\ to view configuration with sensitive credentials automatically redacted, \debug heap-dump\ to capture memory snapshots from a running server, and \debug paths\ to display relevant file system locations. These commands provide direct access to internal state and diagnostics without requiring manual server interaction.
packages/cli/src/commands/handlers/debug · high confidence
New Enterprise page with contact form and localization support
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
New Figma plugin with official skills and remote MCP integration
Users can now install the Figma plugin to connect to Figma's public MCP server via OAuth and Dynamic Client Registration (DCR), enabling agent interactions with Figma tools like \whoami\ and \get\_design\_context\. The plugin also bundles the complete set of official Figma skills (e.g., design-to-code, Code Connect, file creation) directly from Figma's upstream repository, allowing the agent to perform complex design and code workflows without requiring additional configuration or client secrets.
packages/plugins/figma · high confidence
New GitHub PR search and issue triage tools
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
New HTTP and WebSocket transport implementations for AI routes
The \packages/ai/src/route/transport\ directory now includes new \http.ts\, \websocket.ts\, and \websocket-channel.ts\ modules that define the concrete transport layer for AI requests. The HTTP transport (\httpJson\ and \sseJson\) handles JSON and Server-Sent Events over HTTP, supporting configurable body overlays, query parameters, and specific timeout settings for headers and data chunks. The WebSocket transport provides a robust connection layer with error handling for connection phases and message framing, while the WebSocket channel module introduces a sequential channel abstraction for managing stateful, incremental provider interactions. These files establish the core execution paths for sending requests and streaming responses in the AI package.
packages/ai/src/route/transport · high confidence
New OpenAI-compatible chat language model adapter for GitHub Copilot
The chat core now includes a new \OpenAICompatibleChatLanguageModel\ implementation that allows GitHub Copilot to interact with any provider exposing an OpenAI-compatible API. This adapter handles the conversion of internal chat prompts into OpenAI-compatible message formats (including support for text, images, and tool calls) and maps provider responses back to the internal model interface. It also introduces Copilot-specific features such as reasoning opaque values, reasoning effort, text verbosity, and thinking budget configuration, along with standardized metadata extraction and finish-reason mapping.
packages/core/src/github-copilot/chat · high confidence
New Storybook infrastructure for isolated component testing
The Storybook package now provides a complete environment for rendering and testing UI components in isolation. It includes a Vite-based configuration that mocks app-level contexts (such as routing, server connections, and platform APIs) and integrates with Playwright to run browser-based component tests directly against Storybook stories. This setup allows developers to verify component behavior and styling without booting the full application or configuring a backend server.
packages/storybook · high confidence
New TUI experiments framework and settings dialog
The TUI now includes a permanent Experiments framework that allows users to opt into temporary UI features via a new Experiments dialog. This framework is gated by the \config.experimental\ key and includes an initial experiment called "New designs" to preview updated interface styles. Additionally, a new Settings dialog has been added, providing users with controls for appearance (theme, color mode, animations), session behavior (sidebar, scrollbar, thinking, markdown, tool grouping, verbosity, image previews, TPS), and tab management (mode, scope, layout, indicators).
packages/tui · high confidence
New V2 documentation site and component library
The \services/www\ area now hosts a new V2 documentation site built with Astro. This change introduces the site's content configuration, a suite of reusable UI components (including Callout, Card, CodeBlock, CodeTabs, and an OpenAPI reference renderer), and the initial documentation content covering Agents, Attachments, and the Build/Plugin/Client guides. Users will see a structured, searchable documentation experience with dedicated API reference pages generated from the OpenAPI spec.
services/www · high confidence
New appearance settings page for theme and font customization
A new dedicated appearance settings page has been added, allowing users to customize the application's visual presentation. Users can now select a color scheme (system, light, or dark), choose from available themes (with a link to V2 documentation for more options), and configure specific fonts for the UI, code editor, and terminal components.
packages/app/src/settings/appearance · high confidence
New benchmarking and maintenance scripts for core infrastructure
The \packages/core/script\ directory now includes a suite of new tooling scripts to support development and operations. This adds benchmarking utilities (\benchmark-location-memory\, \benchmark-location\, \benchmark-snapshot\, \benchmark-snapshot-pack\, \benchmark-snapshot-session\, \benchmark-snapshot-worker\) to measure memory usage, load times, and snapshot performance overhead. It also introduces maintenance and CI scripts: \migration.ts\ for generating and checking database migrations, \build.ts\ for the core build process, \publish.ts\ for package publishing, \test.ts\ for running tests with isolated environments, \fix-node-pty.ts\ for fixing binary permissions, \update-models-snapshot.ts\ for refreshing the models catalog, and \snapshot-parity.ts\/\snapshot-parity-run.sh\ for verifying snapshot consistency across Git configurations. Additionally, \wellknown-server.ts\ provides a local server for testing configuration discovery.
packages/core/script · high confidence
New build, publish, and test262 sync scripts for Codemode
The Codemode package now includes dedicated Bun-based scripts to streamline development and release workflows. A new build script handles TypeScript compilation, while a publish script automates the package build, exports configuration adjustment, local verification, and npm publishing. Additionally, scripts have been added to synchronize the test262 JavaScript test suite from a local checkout and to generate reports on test failures and recovered tests, ensuring the interpreter's compliance with the ECMAScript standard is easier to maintain and verify.
packages/codemode/script · high confidence
New changelog page with collapsible release sections and media highlights
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
New client-side service lifecycle, MCP tool hosting, and shared event infrastructure
The client package now includes a complete set of new modules that redefine how the client manages the local OpenCode service and communicates with it. Service lifecycle management is handled by new \service.ts\, \service-probe.ts\, \service-contender.ts\, and \service-timing.ts\ files, which implement a robust startup process with version matching, health probing, and a contender pool to handle race conditions during service replacement. Persistent terminal (PTY) handoffs are now supported via \pty-handoff.ts\, allowing terminals to survive service restarts. The client can now host its own tools for the server using the new \mcp.ts\ module, which implements an MCP client over WebSocket to expose local functions to the model. Additionally, \shared-events.ts\ provides a centralized, capacity-limited event stream for multiple subscribers, and \rpc-runtime.ts\ adds typed RPC error handling and event decoding using the Effect library.
packages/client/src · high confidence
New command palette with keybinds, session search, and file navigation
The application now features a new command palette UI and underlying command system. Users can search and execute commands, open files, and navigate sessions directly from the palette. The palette supports custom keybindings, contextual filtering, and displays recent sessions and files. It also includes a new desktop menu system for platform-specific actions.
packages/app/src/shell/commands · high confidence
New console UI components and Go usage limits visualization
The console application now includes a suite of new UI components to enhance the user interface and data presentation. A reusable dropdown component has been added to support interactive elements like the new language picker, which allows users to switch locales directly from the footer and legal sections. The header has been updated with a context menu that lets users copy brand assets (logos and wordmarks) to their clipboard. Additionally, a new FAQ component provides collapsible Q&A sections, and an email signup component enables newsletter subscriptions with server-side validation. A significant addition is the Go Plan Chart, which visualizes request limits and API allowances for Go and Go Plus tiers across various models, including support for bonus multipliers and limited-time offers. The footer now dynamically displays GitHub star counts and links to community resources like Feishu for Chinese locales.
packages/console/app/src/component · high confidence
New console landing page, 404 view, and API routes
The console app now includes a dedicated landing page (index.tsx) with a hero section, installation instructions for multiple package managers (curl, npm, bun, brew, paru, yay), a video showcase, feature highlights, and community links. A new 404 page (\[...404\].tsx) provides a styled error view with navigation options. Additionally, several new routes are introduced: a changelog JSON endpoint (changelog.json.ts) with caching and CORS headers, redirect routes for desktop feedback and Discord, a Feishu community link redirect, an LLMs.txt redirect to the docs, and an OpenAPI JSON proxy route.
packages/console/app/src/routes · high confidence
New core diagram rendering engine for Merman
The \packages/merman\ package now includes a new core rendering engine that handles diagram layout and text rendering. This introduces a \DiagramCanvas\ for managing cell-based drawing with support for Unicode graphemes, custom cell merging, and whitespace trimming. It also adds a \SpatialIndex\ for collision detection and clearance management, geometry utilities for orthogonal pathing, and drawing primitives for frames, diamonds, and arrows. A layout audit script has been added to generate reports on structural violations and metrics like bends and crossings.
packages/merman · high confidence
New core utility modules for error handling, path resolution, and pattern matching
This change introduces a suite of new utility modules in the core package to standardize common operations. Users benefit from improved error diagnostics via \error-summary\, which extracts structured details (type, message, code) from error cause chains. Platform-specific behavior is clarified with \git-executable\ and \which\, ensuring correct Git path resolution on Windows and reliable command discovery. Additional utilities include \lazy\ for deferred execution, \slug\ for generating random identifiers, \token\ for input estimation, and \wildcard\ for pattern matching with cross-platform path normalization.
packages/core/src/util · high confidence
New declarative configuration plugins for agents, commands, and system settings
The core configuration system now uses a set of dedicated plugins in \packages/core/src/config/plugin\ to manage agents, commands, instructions, providers, and other settings. These plugins (e.g., \agent.ts\, \command.ts\, \instruction.ts\, \provider.ts\, \policy.ts\) replace previous ad-hoc loading logic with a unified, event-driven architecture. They automatically discover and load configuration from standard directories (like \agent/\, \command/\, \AGENTS.md\), watch for filesystem changes, and debounce updates to reload the relevant subsystems (agents, commands, skills, etc.) without requiring a full application restart. This provides a more robust and maintainable way to configure the application's behavior through declarative files.
packages/core/src/config/plugin · high confidence
New directory picker dialog with server-side browsing and autocomplete
The workspace selection area now includes a new directory picker dialog that allows users to browse and select files or directories. This picker supports server-side directory listing and file search, providing autocomplete suggestions as you type. It intelligently switches between native OS pickers (for local desktop projects) and a custom server-based UI (for remote/WSL environments), ensuring consistent behavior across different connection types. The implementation includes domain logic for path normalization, case-insensitive matching on Windows, and efficient preloading of directory trees.
packages/app/src/workspaces/selection · high confidence
New download page with multi-platform installer support
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
New download route for stable and beta desktop channels
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
New experimental settings page added
A dedicated experimental settings page has been added to the application, providing a new tab in the settings UI that displays a title and description for experimental features. This page is currently a placeholder with no functional settings controls exposed to the user.
packages/app/src/settings/experimental · high confidence
New extension runtime host and integration layer
The application now includes a new extension runtime host in the \packages/app/src/runtime/extension\ directory, providing the core infrastructure for loading, managing, and communicating with GUI extensions. This change introduces a typed command registry that exposes extension commands to the host, a session attachment context for sharing state, and a comprehensive host API layer that bridges extension capabilities with app features like storage, IPC, and embedded views. It also adds a hot-module reloading (HMR) system for development, a mobile view switcher for narrow screens, and a menubar item provider, effectively wiring the extension SDK into the application's runtime.
packages/app/src/runtime/extension · high confidence
New file workspace implementation with media handling and content caching
The application introduces a new file workspace module that handles file content loading, caching, and view state persistence. Media files (images, audio, video, PDF, fonts, documents, spreadsheets, presentations) are now supported with raw bytes retained for in-memory previews up to a 256 MiB cap, while larger media files are stored as placeholders. The file content cache uses an LRU eviction policy with a 20 MiB byte cap and 40-entry limit to manage memory usage. File view states (scroll position, selected lines) are persisted per workspace session with a 500-file limit. Path normalization handles cross-platform paths (Windows/POSIX), file protocols, and Git-style quoted paths. File system watcher events trigger appropriate reloads and directory refreshes.
packages/app/src/workspaces/files · high confidence
New general settings page with shell, appearance, and sound controls
A new General settings page has been added, providing users with controls for shell selection (including auto-detection and terminal-only indicators), appearance customization (theme, UI/code/terminal fonts), and sound notifications (agent, permissions, errors with preview). The page also includes settings for workspace default destination, terminal placement, follow-up behavior, language, and tab layout.
packages/app/src/settings/general · high confidence
New interactive CLI UI components for integration selection and command timelines
The CLI now includes new UI modules for enhanced interactive experiences. The \integration-picker\ provides a searchable, category-grouped autocomplete interface for selecting MCP or other integrations, displaying connection status and hints. The \timeline\ module introduces a structured, visual log view for command execution, featuring distinct markers for intro, success, and failure states, along with a spinner for pending operations and keyboard shortcuts (Escape/Ctrl+C) for cancellation. Additionally, the \prompt\ module standardizes user input handling, ensuring interactive commands fail gracefully when not run in a TTY and providing robust error and cancellation handling (including proper exit codes) for the CLI environment.
packages/cli/src/ui · high confidence
New internal scripts for publishing and test recording cost reporting
The \packages/ai/script\ directory now includes \publish.ts\, a Bun-based utility that automates the package publishing workflow by building the project, updating \package.json\ exports to point to distribution files, packing, and publishing to npm, while safely restoring the original configuration. Additionally, \recording-cost-report.ts\ provides a tool to analyze test cassette recordings, extracting token usage and estimating costs by fetching current pricing data from \models.opencode.ai\. The \setup-recording-env.ts\ script has also been added to configure environment variables and validate API keys for a wide range of supported providers (including OpenAI, Anthropic, Google, Bedrock, and various media providers) to facilitate test recording.
packages/ai/script · high confidence
New keybinds settings page with command migration
A new keybinds settings page has been added to the application, allowing users to view and customize keyboard shortcuts organized into groups such as General, Session, Navigation, Model and agent, Terminal, and Prompt. The implementation includes a migration utility that automatically transfers custom keybindings from deprecated command IDs (e.g., 'app.checkForUpdates', 'server.pair') to their new equivalents (e.g., 'updater.check', 'pairing.open') to preserve user preferences after the underlying command structure changed.
packages/app/src/settings/keybinds · high confidence
New mobile drawer primitives and responsive shell layout
The shell now includes a reusable mobile drawer component (MobileDrawer) with bottom-sheet styling, safe-area handling, and accessibility features, alongside a MobilePanelDrawer that adds a navigable header and back-button support for multi-step flows. The main shell layout (shell.tsx) introduces a vertical tabs sidebar that can be resized and is conditionally shown based on user preferences and screen width, while also adjusting insets and padding for mobile titlebar positions and safe areas to improve usability on smaller screens.
packages/app/src/shell · high confidence
New persisted state layer with schema-driven validation and optimized draft storage
The application introduces a new persistence layer in \packages/app/src/runtime/persistence\ that manages application state using Effect Schema for type-safe validation and recovery. This system serializes store changes on a schedule rather than on every setter call, reducing write overhead and ensuring that local edits take precedence over remote updates from other windows. It also implements content-addressed storage for large draft text and images, splitting large strings into chunks and managing blob lifecycles to improve performance and reliability during document editing.
packages/app/src/runtime/persistence · high confidence
New project and workspace management interface in Settings
The Settings view now includes dedicated sections for managing projects and workspaces. Users can add, rename, and close projects, customize project icons and colors, and configure startup commands. The interface displays project logos, warns when a project folder is missing, and allows configuring language servers (LSP) and extensions per project. A new workspace list shows directories with their associated sessions, enabling filtering by project and deletion of workspaces.
packages/app/src/settings/workspaces · high confidence
New provider catalog management and Console workspace integration
The application now includes a dedicated provider catalog system that manages AI provider discovery, ordering, and grouping. A new Console workspace integration allows providers to be grouped by workspace (e.g., 'Anomaly'), with automatic name normalization for display. The system introduces a 'popular providers' list (prioritizing OpenCode Go, OpenCode, Anthropic, etc.) and integrates with the server SDK to sync provider and model data from the current directory or default location. It also handles connection status detection, distinguishing between built-in plugins, local packages, and server-managed integrations, while exposing APIs for listing connected, paid, and available providers.
packages/app/src/providers/catalog · high confidence
New provider plugins for Amazon Bedrock, Azure, Cerebras, ChatGPT, Cloudflare, DigitalOcean, GitHub Copilot, and GitLab
The provider discovery and configuration logic has been restructured into individual plugin files under \packages/core/src/plugin/provider\. This change introduces dedicated plugins for Amazon Bedrock (supporting AWS profile and API key auth), Azure (supporting Azure CLI authentication and resource discovery), Cerebras (adding a custom integration header), ChatGPT (implementing a new OAuth sign-in flow with token sharing), Cloudflare AI Gateway and Workers AI (configuring account IDs and API tokens), Databricks (setting cache compatibility for Claude models), DigitalOcean (OAuth login and router model discovery), GitHub Copilot (device OAuth and model discovery), GitLab (OAuth login and workflow model discovery), and dynamic SDK loading. These plugins centralize how each provider is authenticated, configured, and how its models are discovered or transformed within the application.
packages/core/src/plugin/provider · high confidence
New public browser plugin for desktop automation
The \@opencode/plugin-browser\ package is now available as a public plugin, exposing a suite of desktop browser tools (tabs, navigation, snapshots, input, file handling, and diagnostics) to agents in Code Mode. The plugin manages the RPC connection and permissions between the server and the desktop, ensuring that browser actions are scoped to the correct session and that file transfers remain server-local and bounded.
packages/plugin-browser · high confidence
New server inventory and settings UI for SSH and extension servers
The settings interface now includes a dedicated server management section that displays both live HTTP connections and contributed extension servers (such as SSH). The new inventory logic aggregates these sources, correctly handling asynchronous loading so that contributed servers appear in the list before they are fully connected, and prevents cache reload loops by avoiding directory store allocation during inventory reads. The UI renders these servers with health indicators, allows editing of HTTP server credentials when authentication fails, and provides a consistent view for extension-based server entries.
packages/app/src/settings/servers · high confidence
New server registry UI components and management logic
This change introduces the core UI and logic for the server registry within the app. It adds a new AddServerMenu component that dynamically renders extension-provided server types, and a comprehensive set of row components (ServerRow, ServerHealthIndicator, ServerRowMenu, ExtensionServerRow) to display server status, health, and actions. The controller logic now sorts server connections by health status while preserving insertion order, and management utilities provide safe server replacement and health preview capabilities with proper cancellation and race-condition handling.
packages/app/src/servers/registry · high confidence
New server runtime module with authentication, health checks, and event streaming
This change introduces a new server runtime module in \packages/app/src/runtime/server\ that handles server connections, authentication, and state management. It adds password-based Basic authentication for server API calls, implements health checking with configurable timeouts and retries, and provides an event streaming system for server events with location-based filtering. The module also includes session mutation handling for optimistic UI updates, error formatting for user-friendly messages, and persistence schema migrations for server state.
packages/app/src/runtime/server · high confidence
New session export, fork, and ID copy commands
This change introduces three new session management capabilities in the app. Users can now export their session history to a JSON file, which is saved via the native platform dialog or downloaded as a file, with filenames automatically generated from the session title, slug, or ID. A new fork dialog allows users to select a previous user message in the session history to create a new session branching from that point, preserving context and attachments. Additionally, commands have been added to copy the current session ID and project ID to the clipboard for easy sharing or reference.
packages/app/src/session/commands · high confidence
New session header components for running work and review controls
The session header now includes dedicated components to display active background tasks and manage the review panel. SessionRunningMenu lists running subagents and shells, allowing users to open or interrupt them directly from the header. SessionWorkingIndicator provides a visual cue when a session is actively working, and SessionReviewToggle adds a button to open or close the side review panel with keyboard shortcut support.
packages/app/src/session/header · high confidence
New session request handling with auto-approval, background work tracking, and third-party consent docks
The session view now manages a unified request model that surfaces and resolves permission prompts, MCP elicitation forms, user questions, and third-party web search consent within the session context. A new auto-approval system automatically grants permission requests based on app-wide or per-project settings, including a background sweep to handle requests that arrive while disconnected. The session header now displays running subagents and shell jobs, which are tracked in the background and moved out of the primary view when the session is backgrounded. Additionally, a new web search consent flow allows users to select a search provider, with dedicated UI docks for permissions, elicitation forms, questions, and web search configuration.
packages/app/src/session/requests · high confidence
New session workspace selection logic and UI
The new session workspace selector now supports cycling between the local project root, creating a new worktree, and selecting existing worktrees. The controller manages state for resolving the correct worktree and branch based on project inventory and user settings, while the UI component provides a menu for these choices with branch search capabilities and onboarding tooltips.
packages/app/src/new-session/workspace · high confidence
New settings page for managing AI model providers and visibility
A new settings view has been added to allow users to browse, search, and toggle the visibility of available AI model providers. The interface groups models by provider, prioritizes popular providers, and persists the collapsed/expanded state of these groups. Users can filter the list via a search field and reveal specific providers within the settings navigation.
packages/app/src/settings/models · high confidence
New simulation package with headless UI and driver-controlled backend
The \packages/simulation\ package introduces a new simulation environment that replaces the real network with a controlled, in-memory route table and provides a headless terminal renderer for automated UI interaction. Users can now drive the application via a WebSocket control server, which exposes capabilities for capturing UI frames, semantic snapshots, and literal text matching, while allowing external drivers to inject mouse and keyboard inputs. The package also includes a driver-controlled backend that intercepts OpenAI API calls to stream simulated responses, and supports recording UI timelines and pointer events for playback.
packages/simulation · high confidence
New skill discovery and instruction system
The skill module now includes a new discovery service that downloads and caches remote skills from URLs, validating file paths for safety and handling versioned updates with atomic swaps. Additionally, a new instruction service generates and updates the list of available skills in the conversation context, sending only changed entries to the model to reduce token usage and improve clarity on which skills are active.
packages/core/src/skill · high confidence
New titlebar navigation and tab management components
This change introduces a new titlebar implementation in the shell, adding a dedicated history system for back/forward navigation, a right-slot mechanism for managing exclusive UI ownership, and a recently-closed tabs menu. It also includes new components for tab navigation, ordering, and preview popovers, along with comprehensive test coverage for these new modules.
packages/app/src/shell/titlebar · high confidence
New tool plugin architecture with dedicated file, search, and session management tools
The core tool infrastructure has been restructured into a modular plugin system located in packages/core/src/tool/plugin. This change introduces dedicated implementations for file editing (edit, patch), content searching (glob, grep), and session management (session\_rename, session\_move, worktree operations). It also adds new capabilities for reading MCP resources (list\_mcp\_resources, read\_mcp\_resource) and interactive user questioning (question). The edit and patch tools now feature improved line-ending preservation and Unicode normalization, while the search tools utilize ripgrep for efficient file and content matching with configurable limits and hidden file support.
packages/core/src/tool/plugin · high confidence
New utility functions for media detection, sanitization, and data handling
The AI package introduces several new utility modules in the utils directory to support media and data processing. A new \sanitize.ts\ module provides a \sanitizeSurrogates\ function that replaces invalid UTF-16 surrogates in request data while optimizing performance by returning unchanged subtrees by reference. A \media-type.ts\ module adds \detectMediaType\ to sniff file types from magic bytes and \fileMediaType\ to combine sniffing with extension-based detection, alongside helpers for mapping between media types and file extensions. Additional utilities include \bytes.ts\ for concatenating byte arrays, \json.ts\ for JSON encoding/decoding using the Effect schema library, and \record.ts\ for safely narrowing plain objects.
packages/ai/src/utils · high confidence
New web search providers: Exa, Firecrawl, Parallel, and TinyFish
The web search plugin now supports four additional search providers alongside the existing ones. Users can now use Exa, Firecrawl, Parallel, and TinyFish for web searches. Each provider is configured via its respective API key environment variable (EXA\_API\_KEY, FIRECRAWL\_API\_KEY, PARALLEL\_API\_KEY, TINYFISH\_API\_KEY) or can operate in keyless mode where supported. The implementation uses the Model Context Protocol (MCP) for Exa, Firecrawl, Parallel, and TinyFish, while Tavily uses a direct API call. All providers are registered in the websearch plugin index and are available for use in the application.
packages/core/src/plugin/websearch · high confidence
New workspace driver interface and SQL schema
The workspace module now includes a new driver interface and corresponding SQLite schema. The driver defines operations for creating, connecting, suspending, and destroying workspace resources, using an opaque binding mechanism to reconnect to provider resources. The SQL schema introduces a 'workspace' table to persist workspace ID, provider, binding, and timestamps, supporting the new driver-based workspace management.
packages/core/src/workspace · high confidence
New workspace management and worktree creation logic
The application introduces a dedicated workspace management system within the workspaces module. This includes a new \createWorktree\ function that handles the creation of worktrees by resolving project details and syncing the client cache. A new \WorktreeInventory\ system manages the discovery and caching of workspace directories, distinguishing between the main worktree and sandbox workspaces. The UI now features a \WorkspaceSubmenu\ that allows users to select from existing workspaces, including a search filter for larger lists. Additionally, new path utilities (\paths.ts\, \path-key.ts\) provide logic for identifying workspace directories, handling session merging, and inspecting workspace deletion states.
packages/app/src/workspaces · high confidence
Promise-based client and service lifecycle APIs
The client package now exposes a dedicated promise-based entry point under \packages/client/src/promise\. This includes a new RPC layer (\rpc.ts\) that wraps raw calls and event subscriptions with typed promises, and a service lifecycle module (\service.ts\) that provides \discover\, \ensure\, and \stop\ functions for managing the local background opencode service using standard Node.js APIs (avoiding Effect runtime dependencies). The public API surface is re-exported via \index.ts\ and \api.ts\, exposing typed interfaces for agents, commands, config, credentials, events, generation, integrations, MCP, models, plugins, permissions, providers, references, web search, sessions, skills, VCS, and worktrees.
packages/client/src/promise · high confidence
Publish OAuth client metadata document for the opencode client
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
Redesigned home projects view with session import and server management
The home projects interface has been rebuilt to support a new desktop session import feature, allowing users to import session data via JSON files. The view now includes comprehensive server management capabilities, such as editing server connections, handling authentication for unauthorized servers, and toggling server visibility. Additionally, the UI has been updated with a new visual style for project rows, including hover effects and label fading, and supports revealing project folders in the native file explorer on desktop platforms.
packages/app/src/home/projects · high confidence
Server package restructured with new build, publish, and runtime entry points
The server package has been reorganized to support new build and deployment workflows. A new build script (packages/server/script/build.ts) now uses Bun to compile TypeScript and bundle the server into an ESM output directory. A publish script (packages/server/script/publish.ts) automates the build, type-checking, and npm publishing process. Additionally, a new fetch handler (packages/server/src/fetch.ts) provides a web-standard entry point for embedding the server in runtimes like workerd, and a comprehensive set of HTTP API handlers has been added to expose server functionality via the new API structure.
packages/server · high confidence
Standalone changelog service and public file distribution
The \services\ directory now hosts independently deployed Cloudflare Workers. The new Changelog worker serves release notes at \/changelog\ by fetching and caching the \CHANGELOG.md\ from the \dev\ branch, rendering it with a dedicated UI, and handling version redirects. The new Files worker provides public file distribution at \/files/\*\ backed by R2 buckets, supporting byte-range streaming for assets like release binaries.
services · high confidence
Structured error handling and display for shell startup and API failures
The application now features a dedicated error handling module in the shell that provides specific, user-friendly descriptions for different failure modes. It distinguishes local server startup errors from generic issues and extracts HTTP status codes from error causes or structured data to display relevant context. The error UI renders detailed, localized chains for specific failure types such as MCP failures, provider authentication errors, API errors (including status codes and retryability), model not found suggestions, and various configuration errors (JSON, directory typos, frontmatter), ensuring users receive actionable feedback rather than raw stack traces.
packages/app/src/shell/errors · high confidence
UI and validation logic for custom OpenAI-compatible providers
The credentials provider area now includes the frontend form and validation logic for adding custom OpenAI-compatible providers. Users can input a provider ID, name, base URL, and API key (supporting environment variable references), and dynamically add multiple models and custom headers. The new validation ensures unique provider IDs, valid URL formats, and no duplicate model or header keys, preparing the configuration for the backend. Note: The current save implementation is a placeholder that throws an error, indicating this feature is gated behind future V2 config and credential APIs.
packages/app/src/providers/credentials · high confidence
Vite-powered TUI development entrypoint with hot reload and route recovery
The CLI now supports a Vite-based development mode for the TUI, enabling hot module replacement (HMR) for component edits and full UI reloads that preserve the current route (session, Home workspace, or plugin page) after cleanup. The entrypoint (\dev:vite\ / \dev:vite:live\) uses \solid-refresh\ and a custom \host.js\ to manage lifecycle outside Vite's module cache, ensuring route state survives reloads. Syntax errors trigger a retry loop, and render failures during hot updates display a themed error dialog instead of causing a reload loop. This is a development-only feature; production CLI handlers and imports remain unchanged.
packages/cli/dev · high confidence
Removals
Removal of internal TUI style definitions
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
Removal of internal logging subsystem
The internal logging implementation, including the logger, message structures, and pubsub integration, has been removed from the codebase.
internal/logging · high confidence
Removal of internal pub/sub broker implementation
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
Removal of legacy TUI application model
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
Removal of legacy TUI layout system
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
Removal of legacy TUI page implementations
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
Removal of legacy logs table component
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
Removal of legacy status component
The legacy status component file (status.go) has been removed from the core TUI components. This change eliminates the previous implementation of the status display, likely as part of the ongoing refactoring and improvements to the status bar and diagnostics visuals described in the commit history.
internal/tui/components/core · high confidence
Removal of stubbed REPL UI components
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
Removal of the termai TUI entry point
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
Architecture
Core capabilities migrate to internal plugins
The core application logic for agents, commands, hooks, and the plugin host is now implemented as internal plugins (e.g., \opencode.agent\, \opencode.command\, \opencode.prompt.identity\). This change consolidates how built-in features like the default agent, session title/summary generation, and MCP prompt commands are registered and managed, providing a unified plugin-based architecture for the core system.
packages/core/src/plugin · high confidence
Git and Mercurial VCS providers moved to internal plugins
The Git and Mercurial version control adapters have been restructured as internal plugins (opencode.vcs.git and opencode.vcs.hg) within the core package. This change encapsulates the VCS logic, registering the adapters via the VCS service transform mechanism to handle repository initialization, status, and diff operations for their respective systems.
packages/core/src/plugin/vcs · high confidence
New unified route layer for AI providers
The \packages/ai/src/route\ directory now introduces a new, Effect-based architecture for managing AI provider interactions. This change adds a structured \Route\ system that centralizes endpoint configuration, authentication (including optional/required API keys and custom auth overrides), and HTTP transport handling. It also introduces a \MediaProtocol\ layer to standardize inline, streamed, and queued media generation routes (such as image and video), along with utilities for server-sent event framing and request execution. This refactors how provider requests are built, authenticated, and streamed, providing a consistent interface for both text and media AI capabilities.
packages/ai/src/route · high confidence
Session core refactored into modular, event-sourced components
The session management logic in the core package has been restructured into a set of distinct, modular services. This change introduces dedicated modules for session execution (with write-ahead claims for crash recovery), compaction (supporting both native and background summaries), context loading, and an inbox for managing user and synthetic inputs. It also adds new capabilities such as turn-based file diffing, session affinity tracking for provider cache routing, and per-session environment variable management, replacing the previous monolithic session handling with a more granular, event-sourced architecture.
packages/core/src/session · high confidence
Behavioural changes
ACP implementation migrated to Effect and V2 protocol
The ACP subsystem in the CLI has been rewritten to use the Effect library for effectful operations and updated to support the Agent Client Protocol V2. This change introduces a new service-oriented architecture for managing sessions, catalogs, and permissions, and adds support for V2-specific features such as form elicitation, session compaction updates, and child session tracking.
packages/cli/src/acp · high confidence
CLI entry points now delegate to platform-specific binaries with signal forwarding
The CLI entry points (opencode.cjs and opencode2.cjs) have been rewritten to act as shims that locate and execute the appropriate platform-specific binary (e.g., @opencode/cli-linux-x64) from node\_modules. This change introduces robust signal forwarding (SIGINT, SIGTERM, SIGHUP, and SIGUSR1 on non-Windows) to ensure the underlying process handles termination correctly, and adds logic to detect AVX2 support and musl libc environments to select the correct binary variant. The opencode2.cjs file serves as a direct alias that delegates to the main opencode.cjs shim.
packages/cli/bin · high confidence
CLI service commands now use the Effect runtime and persistent PTY handling
The CLI service commands (get, set, unset, start, stop, restart, status) have been rewritten to use the Effect runtime instead of the previous implementation. This change introduces proper handling of persistent PTY (pseudo-terminal) daemons: the stop and restart commands now explicitly shut down the persistent PTY before stopping the service, ensuring terminal state is preserved during restarts. The start and restart commands now use a unified 'ensure' lifecycle method to manage service transport, and the status command reflects the service's actual state (stopped vs running URL). Configuration changes (get/set/unset) are now handled through the ServiceConfig module within the Effect context.
packages/cli/src/commands/handlers/service · high confidence
Centralized favicon, social share, and theme configuration assets
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
Code Mode tool catalog and execution runtime restructured
The Code Mode tool catalog is now delivered through structured instructions that summarize available tools by namespace, respecting an inline budget to keep the catalog concise in the prompt. The catalog supports pinned tools and namespace-level descriptions, and updates are rendered as deltas when possible to save context. The Code Mode execution runtime has been restructured to use a shared runtime per request, with explicit before/after hooks for tool and extension calls to track progress and errors. The \execute\ tool now returns content-only results, and \fetch\ is exposed for HTTP requests with a 30-second timeout and a restriction against using \file://\ URLs. Tool namespaces are registered, and tool name normalization is reused across the system.
packages/core/src/codemode · high confidence
Composer UI and logic restructured into a new modular package
The composer component has been refactored into a new \packages/app/src/composer\ directory, introducing a typed adapter layer (\adapter.ts\) that decouples the UI from session and submission logic. This change adds a client-side slash command parser (\client-slash-command.ts\) to handle triggers like \/btw\ and \/model\, and introduces a dedicated comment and note system (\comment-note.ts\, \comments.tsx\) that supports file-level annotations and browser element notes. Additionally, the composer now includes a persistent prompt history store (\history/store.ts\) to track and deduplicate sent prompts, and a visual dropzone component (\dropzone.tsx\) for file attachments.
packages/app/src/composer · high confidence
Database schema migration to v2 with event sourcing and credential refactoring
The core database schema has been migrated to v2, introducing event-sourced session history via new \event\ and \event\_sequence\ tables and replacing the legacy \session\_entry\ table with \session\_message\. Session storage is now split into \session\_v2\ (renamed from \session\) and dedicated tables for inputs (\session\_input\, \session\_pending\) and context epochs (\session\_context\_epoch\). The schema also adds support for workspaces (\workspace\), project directories (\project\_directory\), and usage tracking (cost and token counts on sessions). Authentication storage has been refactored to use a new \credential\ table with connector/integration support, replacing the previous \account\ and \control\_account\ tables, and includes a migration to import legacy credentials from \auth.json\.
packages/core/src/database/migration · high confidence
Enforce Bun version consistency and run typecheck on push
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
Extract non-interactive run logic into a dedicated CLI module
The non-interactive run command logic has been extracted from the mini package into a new \packages/cli/src/run\ module. This change introduces a structured entry point (\index.ts\) that exports \runNonInteractive\ for standard usage and \runV1Bridge\ for V1 compatibility. The implementation separates concerns into \run.ts\ (orchestration, file preparation, and session targeting), \noninteractive.ts\ (event stream handling, tool rendering, and permission/form cancellation logic), and \ui.ts\ (terminal output styling). This refactoring isolates the run workflow, making it easier to maintain and extend without affecting the broader mini package.
packages/cli/src/run · high confidence
Improved image resizer availability and error handling in workerd environments
The image normalization logic now gracefully handles environments where the Photon WASM artifact is unavailable, such as the workerd runtime. Instead of causing a module load failure or a generic 500 error, the system detects the missing artifact early and degrades to a typed \ResizerUnavailableError\, allowing image-bearing prompts to pass through without resizing rather than failing entirely. This change introduces platform-specific entry points for Bun, Node, and workerd to manage WASM loading, ensuring that image processing remains robust across different deployment targets.
packages/core/src/image · high confidence
Internal Effect SQLite adapter for Drizzle ORM
The repository now includes an internal adapter in \packages/core/src/database/drizzle/effect-sqlite\ that integrates Drizzle ORM with the Effect ecosystem. This change adds the \driver.ts\, \session.ts\, and supporting utilities to provide an \EffectSQLiteDatabase\ and \EffectSQLiteSession\, enabling database operations to be handled as Effect effects with native transaction management and caching support.
packages/core/src/database/drizzle/effect-sqlite · high confidence
Internal SQLite Effect adapter implementation for Drizzle ORM
The SQLite database adapter in the core package has been refactored to internalize the Effect integration, moving the implementation into a new \effect/\ subdirectory. This change introduces a complete set of Effect-based query builders (for select, insert, update, delete, count, and raw queries) and a dedicated session layer, replacing the previous structure to better align with the upgraded Drizzle ORM and Effect libraries.
packages/core/src/database/drizzle/sqlite-core · high confidence
Internalized Effect SQLite adapter for Drizzle ORM
The Drizzle ORM integration for SQLite has been internalized as a local fork within the core package, exposing the \EffectDrizzleSqlite\ namespace via \@opencode/core/database/drizzle\. This change replaces the previous external migration framework with a self-contained implementation that adapts Drizzle's Effect SQLite driver to run over Effect's generic \SqlClient\, providing local utilities for caching, mapping, and transaction handling while maintaining compatibility with the existing database service.
packages/core/src/database/drizzle · high confidence
Interpreter rewritten with strict data boundaries and expanded standard library support
The CodeMode interpreter has been refactored to enforce strict data boundaries between the host and the program, ensuring that opaque runtime references (such as tool calls and promises) are never leaked into program data or tool arguments. This change introduces a comprehensive standard library implementation, adding support for generators, async iterators, WeakMap/WeakSet, and various built-in objects like Headers and Uint8Array. Error handling is now more robust, with proper prototype chains for error types and detailed source-location diagnostics. Additionally, the interpreter now supports JSON callbacks, tagged templates, and enforces execution limits to prevent runaway recursion and excessive memory usage.
packages/codemode/src/interpreter · high confidence
Introduce centralized build and release script package
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
Introduce one-time pairing links and QR code scanning for server connections
The server connection flow now supports pairing via one-time links and QR codes, replacing the previous password-based method as the primary connection path. Users can scan a QR code using their device camera or paste a pairing link to authenticate with a server, with the system handling mixed-content security checks and legacy credential link compatibility. This change adds a new connect dialog and screen that manage the pairing state, including camera availability detection and redemption logic for single-use codes.
packages/app/src/servers/connect · high confidence
Introduce structured, delta-sync instruction system with built-in environment and date context
The core instruction handling has been refactored to use a new composable architecture where instructions are defined as typed sources with explicit keys, codecs, and renderers. This enables value-delta synchronization, meaning only changed instruction content is processed, improving efficiency and consistency. Two built-in instructions are now provided: 'core/date' which injects the current date, and 'core/environment' which provides details about the working directory, workspace root, git status, platform, and temporary directory guidance. This replaces the previous checkpoint-based mechanism with a more robust, schema-driven approach that ensures deterministic rendering and easier extensibility for future instruction types.
packages/core/src/instructions · high confidence
Introduce v1 configuration schema definitions and migration logic
The v1 configuration layer now includes formal schema definitions for agents, commands, MCP servers, permissions, providers, and provider options, alongside a migration module that translates these v1 structures into the v2 format. This ensures that existing v1 configuration files are correctly interpreted and upgraded, preserving settings such as model selections, permissions, and provider-specific options during the transition.
packages/core/src/v1 · high confidence
Localized documentation proxying for specific resource routes
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
Migrate infrastructure to SST with consolidated service definitions
The infrastructure codebase has been restructured into a new SST-based deployment model, replacing previous configuration methods. This change introduces explicit definitions for the API worker, Console (SolidStart), Stats application, and Web documentation site, each with their own domains and secret linkages. Key behavioral updates include deploying the Console server in the \us-east-2\ region with a \global\_fetch\_strictly\_public\ compatibility flag, enabling regional hostname routing for the main domain, and configuring the Stats service with increased memory (2 GB) to prevent OOM crashes during data sync. The Share worker now adopts the retired Teams worker's domain, and the infrastructure supports beta web app deployments via a dedicated \createWebApp\ function.
infra · high confidence
Migration of stats routes to data with proxy and redirect handlers
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
New CLI configuration service with v1 migration and inline config support
The CLI now uses a new, Effect-based configuration service (packages/cli/src/config) that manages the cli.json file with atomic writes and file locking. This change introduces support for inline configuration via the OPENCODE\_CLI\_CONFIG\_CONTENT environment variable and automatically migrates legacy v1 settings (from tui.json and kv.json) into the new v2 schema, including normalizing legacy tab and keybind settings. A JSON schema is also published to validate the new configuration structure.
packages/cli/src/config · high confidence
New CLI utility functions for error handling, stdin reading, and process execution
The CLI package now includes new utility modules in the \src/util\ directory to support core operations. Users benefit from a standardized \errorMessage\ helper for consistent error message extraction, a \readStdin\ function leveraging Node.js stream consumers for input handling, and a \selfCommand\ function that reconstructs the CLI execution command while filtering and preserving relevant Node.js runtime flags (such as \--experimental-ffi\ and \--enable-source-maps\) for proper subprocess invocation.
packages/cli/src/util · high confidence
New Drizzle ORM schema definitions for account data
The account module now defines its database schema using Drizzle ORM, introducing new tables for \account\ and \account\_state\ to manage user credentials and active session context. A legacy \control\_account\ table definition is also included for backward compatibility, ensuring existing data structures remain accessible during the transition.
packages/core/src/account · high confidence
New Terms of Service page with updated legal policies and multi-account restrictions
The console now includes a dedicated Terms of Service route that displays the updated legal agreement effective August 15, 2026. This page explicitly prohibits abusive multi-account use, such as creating multiple accounts to circumvent usage limits or billing obligations, and outlines restrictions on automated data extraction and AI model training. The implementation adds the necessary CSS styling for the legal content and integrates locale-specific navigation links to ensure consistent access across languages.
packages/console/app/src/routes/legal/terms-of-service · high confidence
New build and publish scripts for the client package
The client package now includes dedicated Bun scripts to automate its build and release process. The new \build-package.ts\ script compiles TypeScript and bundles the output into an ESM distribution using Bun, while \build.ts\ generates the client-side protocol contracts for both Promise and Effect runtimes from the schema definitions. Additionally, \publish.ts\ handles the release workflow by running type checks, building the package, adjusting export paths for the distribution, and publishing the resulting tarball to npm.
packages/client/script · high confidence
New database layer with SQLite backend and V1-to-V2 migration
The core database module has been replaced with a new implementation using Drizzle ORM and SQLite, providing platform-specific adapters for Node.js, Bun, and Cloudflare Workers (Durable Objects). This change introduces a robust migration system that automatically bootstraps the new schema and migrates existing V1 session data to the V2 format. The new layer includes per-session permission rules, a session inbox, and improved path handling for cross-platform compatibility, while ensuring database file security by restricting permissions to the owner on POSIX systems.
packages/core/src/database · high confidence
New portable shell permission scanner and parser
The shell execution layer now uses a new portable scanner and parser to analyze shell commands for permissions and resource access. This replaces the previous tree-sitter-based parser with a custom, platform-agnostic implementation that supports Bash, Zsh, and PowerShell. The new system scans commands to identify directories, resources, and permission requirements, enabling more accurate and consistent shell command analysis across different environments.
packages/core/src/shell · high confidence
New project schema and database table definitions
The project module now defines its data model using the Effect Schema library and Drizzle ORM. A new \ProjectTable\ is introduced in the SQLite database, featuring fields for worktree paths, VCS type, and activity timestamps (including \time\_active\ and \time\_archived\), while the legacy \ProjectDirectoryTable\ is marked as deprecated. The schema exports types for project IDs, current state, info, updates, and events, providing a structured foundation for project data handling.
packages/core/src/project · high confidence
New provider connection dialogs and upsell flows
The Connect provider area now includes dedicated UI components for managing provider connections and handling usage limits. Users will see a new ChatGPT usage limit dialog that guides them to manage their plan settings, and a ChatGPT plan welcome dialog shown after first connection. The main provider connection dialog has been expanded to support OpenCode Console sign-in via device flow, MCP server toggling scoped to the workspace, and an animated Go upsell hero for usage-exceeded scenarios. These changes introduce new dialog states, authorization flows, and visual feedback for provider integration.
packages/app/src/providers/connect · high confidence
Nix build now includes Bun-specific node\_modules canonicalization and binary normalization scripts
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
Node.js CLI runtime initialization and platform targeting
The Node.js CLI entry point now initializes the runtime by loading plugin support for both Promise-based and Effect-based architectures, and includes a handler to suppress EPIPE errors on stdout to prevent crashes when the output stream is closed. Additionally, a new target configuration module defines supported platforms (darwin, linux, win32) and architectures (arm64, x64), mapping them to specific native dependencies like node-pty, parcel-watcher, fff, and ffi-rs, while also exposing configuration for WebAssembly assets and Node execution arguments.
packages/cli/src/node · high confidence
Redesigned configuration discovery, normalization, and variable substitution
The core configuration system has been rewritten to improve reliability and flexibility. Configuration discovery now explicitly supports macOS MDM managed preferences, system-wide directories, and project-level roots with a defined priority order. A new normalization layer handles migration from legacy v1 config formats (such as \autoupdate\, \small\_model\, and singular \command\/\agent\ keys) to the current schema, while also supporting mixed config formats. Variable substitution for environment variables (\{env:VAR}\) and file references (\{file:path}\) has been hardened to gracefully handle missing or unreadable files by substituting empty values, and to escape values that break JSON parsing. Additionally, markdown frontmatter parsing now bypasses the gray-matter content cache to prevent parse errors from poisoning subsequent reads.
packages/core/src/config · high confidence
Redesigned home page with server-aware project selection and session management
The home page has been restructured to support multi-server environments, allowing users to select and switch between different server contexts directly from the home view. The new layout features a dedicated project list region and a session list region, with mobile-optimized navigation for project selection. The implementation includes a new scroll controller that manages sticky headers and fade effects for session groups, improving readability when browsing long lists of sessions. Users can now open new sessions or resume existing ones within the context of a specific server and project, with the UI automatically adjusting to the selected server's available projects.
packages/app/src/home · high confidence
Redesigned model selection and management dialogs
The model selection interface has been redesigned to improve usability and visual clarity. Users can now manage models through a new dedicated dialog that supports searching, filtering, and toggling visibility for individual models or entire providers. The selection dialog itself features a revamped UI with improved mobile drawer support, better keyboard navigation (arrow keys follow rendered order), and clearer visual indicators for free and latest models. Additionally, the system now groups OpenCode Console workspace providers under a single section and displays free models alongside their paid counterparts by default.
packages/app/src/providers/models · high confidence
Redesigned settings interface with search and hierarchical navigation
The settings experience has been completely redesigned to support a searchable, hierarchical navigation structure. Users can now open settings via a dedicated command (mod+comma) and navigate through a sidebar or mobile menu that organizes options into root, server, and project scopes. A new search feature allows users to quickly find specific settings across all scopes, with results linking directly to the relevant controls. The settings model has been updated to use Effect Schema for robust persistence, handling migrations for timeline detail presets and gracefully defaulting invalid or malformed preferences while preserving valid data. The interface now includes dedicated pages for general preferences, appearance, notifications, shortcuts, projects, workspaces, providers, models, extensions, servers, experimental features, and about information, with per-project and per-server settings available where applicable.
packages/app/src/settings · high confidence
Refactored session tab avatars and project resolution logic
The shell layout now uses new helper functions and components to manage session tab visuals and project identification. \useSessionTabAvatarState\ computes unread and loading states for session tabs, incorporating permission checks and notification status. \projectForSession\ and \resolveProjectForSession\ provide more robust logic for matching sessions to projects, considering worktrees and sandboxes. New components \ProjectIcon\ and \SessionTabAvatar\ render the project avatars and progress indicators for session tabs, ensuring consistent display of project identities and activity states.
packages/app/src/shell/layout · high confidence
Refactored shell state management with robust layout persistence and session tab handling
The shell state layer has been restructured to improve reliability and maintainability. Layout persistence now uses Effect Schema for strict validation, ensuring that invalid or missing configuration fields are safely migrated to defaults without breaking the user interface. Session tab state management has been rewritten to correctly handle preview tabs, ensuring that preview placeholders are replaced by actual files and that closing tabs correctly selects neighboring tabs. Additionally, scroll position persistence has been decoupled into a dedicated module with debounced writes to reduce storage overhead, and helper functions for session key management have been added to ensure proper state tracking.
packages/app/src/shell/state · high confidence
Rewritten notification system with cross-tab coordination and server-driven unread state
The notification subsystem in the app shell has been rebuilt to improve reliability and consistency across multiple windows and tabs. A new coordinator manages focus and sound notifications, ensuring that alerts are not duplicated when the same event occurs in different tabs. Unread state is now derived from server-side watermarks rather than local lists, with a background migration process to sync legacy viewed states. Clicking a notification now reliably opens the corresponding session tab, and the system includes a new sound engine with a curated library of audio assets.
packages/app/src/shell/notifications · high confidence
Ripgrep binary extraction now uses system tar on Windows
The ripgrep binary extraction logic on Windows has been updated to use the system-provided \tar.exe\ (bsdtar) instead of PowerShell. This change ensures that ripgrep archives can be extracted even in environments where PowerShell execution is blocked by security policies, improving reliability for Windows users.
packages/core/src/ripgrep · high confidence
Schema package restructured with v2 config support and new domain contracts
The schema package has been reorganized to own browser-safe wire and storage contracts, separating current unversioned definitions from legacy V1 contracts. A new configuration schema now accepts both V1 and V2 shapes, with V2 fields generated from the current \Config.Info\ and V1 fields marked as deprecated for compatibility. The package introduces new domain contracts for agents, commands, credentials, connections, and permissions, alongside updated event definitions for sessions, worktrees, and MCP integrations. Build and publish scripts have been added to support TypeScript compilation and npm publishing, while the package boundary ensures schema values remain serializable contract definitions without runtime implementation details.
packages/schema · high confidence
Server-keyed session routing and session UI context provider
The application now routes sessions using server-keyed URLs (e.g., /server/:serverKey/session/:id) to correctly identify which server a session belongs to, replacing previous routing logic. This change introduces a new \SessionUIProvider\ that wraps session views with necessary context, including markdown image reading, session navigation, and turn-diff caching. It also adds support for opening referenced session IDs from markdown content and ensures session lineage is preserved through a \rootSession\ utility that resolves parent sessions while detecting cycles. The routing layer now handles server connection validation and provides a dedicated screen for connecting to servers when no valid connection exists.
packages/app/src/shell/routes · high confidence
Stream large attachments with upload progress and path-based delivery
The composer now streams large file attachments to the server with real-time progress updates visible in a persistent toast notification, allowing users to monitor and cancel uploads. To improve performance and reliability, files that are not natively supported by the current model (or are too large for inline embedding) are delivered to the server as file paths rather than being base64-encoded into the request payload. This change also introduces a new CSS-based fade animation for the attachment list and ensures the composer retains focus after files are attached.
packages/app/src/composer/attachments · high confidence
Unified branded OAuth callback pages
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
Unified tool runtime with structured validation and MCP support
The core tool execution layer has been restructured to enforce strict input and output validation using Effect schemas and the StandardSchemaV1 specification (including Zod v4 support), ensuring that tool calls fail with typed errors rather than dropping silently. This change introduces a new MCP tool integration that registers server-discovered tools with namespace-based naming, handles permission assertions, and parses JSON text results when no output schema is declared. Additionally, built-in tools like the read filesystem tool now support paged reading with configurable line and byte limits, and the HTML-to-Markdown converter includes bounded output handling to prevent excessive content generation.
packages/core/src/tool · high confidence
Fixes
Add animated presence logic and Safari runtime polyfills
The runtime package now includes a new \createAnimatedPresence\ utility that manages element visibility with animation support, ensuring content remains visible for a minimum duration during transitions. Additionally, \polyfills.ts\ has been added to import \core-js\ modules for \Map.groupBy\, \Promise.withResolvers\, and \Promise.try\, ensuring compatibility with older Safari versions (pre-17.4/18.2) that lack these native APIs.
packages/app/src/runtime · high confidence
Fixes for static asset serving and PWA theme synchronization
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
Improved project selection logic and multi-server support in new session
The new session project selector now correctly handles multi-server environments by filtering available projects based on the current server context, ensuring that a project ID match from a different server does not incorrectly select a remote worktree. The controller logic has been refined to prioritize the currently active workspace location and explicitly resolved project ID when determining the initial selection, while also preserving workspace choices across draft tabs. Additionally, the UI now displays pending states when switching servers to provide better feedback during asynchronous project loading.
packages/app/src/new-session/project · high confidence
Session timeline rewritten with new architecture and scroll stability fixes
The session timeline has been completely rewritten to improve performance, stability, and user experience. A new caching system (createTimelineCache) prevents unnecessary rebuilds of detached views, while a new projection layer (controller-projection) correctly handles message ordering, ensuring active work appears above undelivered steers and queued inputs are hidden until delivery. Scroll behavior is significantly improved: the timeline no longer follows the end while dragging the scrollbar, and scroll position is preserved across session switches and history prepends. The UI now includes a new background work hint component, supports voice delegations from iOS, and features a new search bar with highlighting. Additionally, the timeline rendering is stabilized to prevent clipping and reduce load work.
packages/app/src/session/timeline · high confidence
Stabilized scrolling and interaction across terminal, UI, and virtualization components
This update applies patches to several core libraries to fix scrolling stability and interaction bugs. In the Ghostty terminal, mouse tracking is now disabled when the Shift key is held, and wheel events are corrected to support horizontal scrolling and proper behavior in the alternate screen. The TanStack Virtualizer patch improves scroll anchoring during data changes by capturing multiple fallback anchors and fixes iOS touch handling to prevent scroll drift. The @dnd-kit/dom patch ensures that essential scroll and style plugins are always included in the drag-and-drop instance. The @corvu/drawer patch prevents visual glitches by checking the drawer's open state before starting transitions and handling cases where animations are cancelled. Finally, the @ai-sdk/google patch prevents errors by removing empty message parts that the Gemini API rejects.
patches · high confidence
Update service introduces caching, partial index lookups, and graceful overload handling
The update service now caches D1 reads per isolate to reduce database load and uses partial indexes (artifact\_active, artifact\_minimum) for more efficient lookups. It also returns a 503 status with a Retry-After header instead of a 1101 exception when D1 is overloaded, improving reliability for clients polling for updates.
services/update · high confidence
Test coverage
Add test262 integration for JavaScript compliance testing; Added Markdown timeline preload disposal benchmark; Added Test262 and Web Platform Tests compliance suites for CodeMode; Added browser test fixture for model selection persistence; Added browser unit tests for core application runtime and UI components; Added component tests for browser pane, composer, and extension host behavior; Added comprehensive test coverage for core configuration plugins and services; Added comprehensive test coverage for the portable shell scanner; Added desktop cold-startup performance benchmark; Added e2e performance benchmarks for session timeline and navigation; Added e2e tests for model selection and session state persistence; Added e2e tests for service worker caching and updates; Added manual benchmark for composer history hydration performance; Added native terminal performance benchmark suite; Added patch-groups performance benchmark harness; Added regression tests for background reads, /btw side questions, command palette, composer, home, MCP, and mobile UI; Added service lifecycle test fixtures; Added test coverage for GitHub Copilot core integration; Added test coverage for core plugin subsystems; Added test coverage for the client package; Added test fixtures for CLI upgrade, concurrency, and service lifecycle; Added tests for ACP subprocess and wire protocol behaviors; Added tests for AppProcess service; Added tests for Modal model resolution and live backfill; Added tests for PTY session management, protocol handling, and ticketing; Added tests for console marketing navigation, language routing, and server action security; Added tests for core Effect utilities; Added tests for core filesystem utilities and services; Added tests for core utility modules; Added tests for instruction built-ins and core instruction management; Added tests for layer node type safety and graph construction; Added tests for non-interactive CLI run behavior; Added tests for skill instruction generation and permission handling; Added timeline stability e2e tests; Added timeline suspense reproduction test fixture; Added type tests for provider options and compaction capabilities; Added unit tests for performance diagnostics and benchmarking infrastructure; Added v1 configuration schema fixtures; Component tests for session-ui; Expanded test coverage for AI package core components; Expanded test coverage for CLI authentication, configuration, and debugging commands; Expanded test coverage for core subsystems; Expanded test fixtures for core integration testing; New e2e test utilities for app mounting, state seeding, and server mocking; New manual performance diagnostics suite for the app renderer; New test harness utilities in packages/core/test/lib; New test infrastructure and provider coverage for Alibaba and Anthropic; Tests for Code Mode catalog summarization and instruction rendering.
Dependencies
Introduce monorepo dependency catalog and standardize package versions
The project now uses a centralized dependency catalog to manage versions across the monorepo, replacing scattered version pins with \catalog:\ references in \package.json\ files. This change standardizes dependency versions for better reliability and reduces conflicts, while also introducing new packages such as \github\, \@opencode/ai\, \@opencode/codemode\, and \@opencode/latex\ with their specific dependencies and devDependencies defined.
(dependencies) · high confidence
Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.
How this codebase got here
Score
- CAI 44 → 30 (-13.3)
Lenses
- Code Health 63 → 62 (-1.5)
- Architecture 58 → 58 (-0.3)
- Maturity 74 → 74 (-0.2)
- Readiness 48 → 45 (-3.1)
- Security 44 → 44 (+0.1)
- Domain Modelling 38 → 10 (-27.8)
- Accessibility 51 → 47 (-3.5)
- Performance 60 → 60 (+0.0)
Resolved (1156)
- 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: session-sortable-tab.tsx ↔ session.tsx (packages/app/src/components/session/session-sortable-tab.tsx)
- Boundary-crossing change coupling: session-sortable-terminal-tab.tsx ↔ session.tsx (packages/app/src/components/session/session-sortable-terminal-tab.tsx)
- 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: model-compare-detail.tsx ↔ [model].tsx (packages/stats/app/src/component/model-compare-detail.tsx)
- Change coupling: model-compare-detail.tsx ↔ index.tsx (packages/stats/app/src/component/model-compare-detail.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: 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)
- …and 1136 more
New (2064)
- 20260805200742_import_legacy_credentials.importLegacyCredentials (cognitive 37) (packages/core/src/database/migration/20260805200742_import_legacy_credentials.ts)
- 20260805200742_import_legacy_credentials.importLegacyCredentials (cyclomatic 20) (packages/core/src/database/migration/20260805200742_import_legacy_credentials.ts)
- ADR has no Consequences section (specs/v2/event-stream-architecture.md)
- Ambiguous naming for similar input types. parseDataUrl suggests returning a parsed structure or validation, while fromDataUrl suggests creating an Asset. If both create Assets, the names are confusingly distinct. If parse returns a raw object and from returns an Asset, the distinction is valid but parse is a poor name for a constructor-like function.
- Boundary-crossing change coupling: platform.tsx ↔ index.ts (packages/app/src/runtime/platform/platform.tsx)
- Boundary-crossing change coupling: platform.tsx ↔ index.tsx (packages/app/src/runtime/platform/platform.tsx)
- Boundary-crossing change coupling: platform.tsx ↔ ipc.ts (packages/app/src/runtime/platform/platform.tsx)
- Boundary-crossing change coupling: platform.tsx ↔ types.ts (packages/app/src/runtime/platform/platform.tsx)
- Change coupling: api.ts ↔ handlers.ts (packages/protocol/src/api.ts)
- Change coupling: client.ts ↔ handlers.ts (packages/protocol/src/client.ts)
- Change coupling: devtools-bar.tsx ↔ index.tsx (packages/tui/src/component/devtools-bar.tsx)
- Change coupling: go-models.ts ↔ index.tsx (packages/console/app/src/component/go-models.ts)
- Change coupling: index.ts ↔ index.ts (packages/desktop/src/main/index.ts)
- Change coupling: index.tsx ↔ footer.tsx (packages/tui/src/component/prompt/index.tsx)
- Change coupling: index.tsx ↔ footer.tsx (packages/tui/src/component/prompt/index.tsx)
- Change coupling: index.tsx ↔ index.tsx (packages/stats/app/src/routes/[lab]/index.tsx)
- Change coupling: index.tsx ↔ sidebar.tsx (packages/tui/src/routes/session/index.tsx)
- Change coupling: message.ts ↔ session.ts (packages/server/src/handlers/message.ts)
- Change coupling: opencode.ts ↔ routes.ts (packages/sdk/src/opencode.ts)
- Change coupling: session.ts ↔ run-coordinator.ts (packages/core/src/session.ts)
- …and 2044 more
Changes since last survey
- 300 commits — 188 feature/other, 112 fixes
By area
- packages/core — 87 commits
- packages/tui — 28 commits
- packages/ai — 27 commits
- packages/console — 27 commits
- services/www — 20 commits
- (root) — 19 commits
- nix/hashes.json — 13 commits
- packages/app — 10 commits
- packages/stats — 8 commits
- packages/web — 8 commits
- .github/workflows — 6 commits
- packages/cli — 6 commits
- packages/client — 6 commits
- packages/desktop — 5 commits
- packages/gui-extensions — 4 commits
- packages/schema — 3 commits
- .opencode/skills — 2 commits
- packages/codemode — 2 commits
- packages/function — 2 commits
- packages/server — 2 commits
Notable commits
- fix: fix(ai): only send store on chat completions for OpenAI and Azure (#57239)
- fix: fix(ai): recognize more context overflow errors (#57982)
- fix: fix(ai): retry Gemini MALFORMED_RESPONSE finishes (#56232)
- fix: fix(ai): send expires_after.anchor for OpenAI realtime client secrets (#57514)
- fix: fix(ai): skip non-cacheable content parts when placing cache breakpoints (#57610)
- fix: fix(ai): tolerate unknown and untyped stream events (#56286)
- fix: fix(ai): treat null Responses stream fields as absent (#56669)
- fix: fix(app): bundle worker dependency subpaths in dev pre-bundles (#58345)
- fix: fix(app): paste plain text when renaming session tabs (#58036)
- fix: fix(app): restore free-tier usage limit dialog, timeline line, and prompt recall (#57466)
- fix: fix(app): show MCP elicitation forms in desktop and web (#58305)
- fix: fix(app): show file change count before label (#58353)
- fix: fix(app): show free models alongside their paid twins by default (#55712)
- fix: fix(app): stop following the timeline end while dragging the scrollbar (#57831)
- fix: fix(ci): include PrivacyUrl in WinGet locale manifests (#56123)
- fix: fix(ci): run app e2e on dev and every package's unit tests (#56117)
- fix: fix(cli): don't crash auth login when no browser opener is available (#56082)
- fix: fix(cli): keep mini session waits alive (#50248)
- fix: fix(cli): move the Windows service port out of the WSL mirrored range (#57428)
- fix: fix(codemode): honor Uint8Array.from mappers, compare byte searches without coercion, skip flatMap holes, and truncate fractional radixes (#57285)
- …and 280 more
Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.
Survey your own repository
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.
About this page
- The score is its most recent published measurement, taken on 23 October 2026 at a pinned commit. It is not a live figure and does not change until the project is measured again.
- Measured at commit 4d30794bcf4dccdcadbcb1f62bb35b4943a96426 — the exact code this score is about.
- Scored under rubric-2026.10.5 — the same rubric and the same method as every other entry in this index.
- Measured by watchdog.canine.dev using codehealth-analyzer measure-2026.10.6+preprod-d36780c2d857.