Rel.AI MCP 0.25.1

Process reliability

• Preserve empty managed-process lists through connector compaction so relai_process list satisfies its output contract when no managed process is running.
• Add regression coverage for the empty process-list contract.

Search and contract reliability

• Bound broad repository searches by useful output instead of exhaustive counting. Stop streamed text search after one additional visible match proves maxResults is truncated, extend the search budget to 25 seconds, and return useful partial matches instead of failing the whole call when that budget is reached. Truncated observability reports matchCount as an explicit lower bound (at least N) rather than implying an exact total.
• Refresh stale Secure Tunnel, runtime-surface, and Activity contract tests. Keep tests aligned with the current Tunnel + No authentication workflow, canonical release-manifest tool metadata, and the current live Activity controller/CSS contract.
• Keep discovery tests on canonical MCP metadata. Remove the last dependencies on the deleted cloud contract manifest and hard-coded 37/12 surface values so command/process guidance, status metadata, and stdio discovery follow the current public schema and include newly added tools such as relai_ui automatically.
• Keep ChatGPT setup guidance aligned after the Secure Tunnel cutover. Remove stale plan-specific Plugins/workspace-Apps navigation from the README and regression guard; the durable setup contract is Tunnel + No authentication, with reconnects reusing the existing Rel.AI MCP integration instead of creating duplicates.

MCP startup reliability

• Keep stdio discovery off execution-only dependency paths. Load tool execution, managed-process cleanup, browser automation, and workspace-status/Repository Intelligence modules only when those capabilities are actually used, so initial MCP discovery and tools/list no longer eagerly initialize Playwright or SQLite-backed repository intelligence.
• Measure cold startup with a platform-realistic budget. Preserve the strict in-process tools/list latency budget while allowing Windows cold-process startup variance in the dedicated benchmark; the native-task release gate continues to verify real stdio discovery end to end.

Repository maintainability

• Restore architecture-budget compliance without weakening the guard. Separate the internal operation-definition data from public tool composition, move dashboard navigation rendering into the dashboard shell/chrome owner, and remove two unreferenced legacy request-budget/process-kill modules. Repo-health and frontend acceptance remain green after the split.

Bump root/electron/status UI/lockfiles to 0.25.1.

Rel.AI MCP 0.25.0

ChatGPT connection reliability

• Keep every tool argument visible after tunnel import. Publish flat connector-facing input objects for all 12 tools while retaining strict action and variant validation inside Rel.AI, preventing OpenAI's MCP importer from dropping shared fields such as workspace, objective, command, and summary from sparse oneOf branches.
• Accept interoperable OAuth client registration. Support and validate standard authorization-code, refresh-token, response-type, and public-client metadata while ignoring safe unknown Dynamic Client Registration fields.
• Complete authorization back in ChatGPT. Return successful local and cloud authorization form submissions with a 303 See Other callback while preserving the authorization code and OAuth state.
• Make pairing codes easy to copy. Provide accessible copy actions with progress and success feedback in both the setup wizard and Connection settings.
• Keep Connection settings stable during device refresh. Refresh only the device region instead of remounting and clearing the surrounding settings page.
• Make cloud devices understandable and removable. Register new pairings with a machine-specific label, replace legacy generic app-name labels in the UI, and let the current device disconnect safely by revoking its gateway access, clearing local pairing state, and suppressing reconnect with revoked credentials.
• Keep the public gateway address out of private launch secrets. Persist the non-secret cloud origin in the connection profile while retaining backward-compatible reads and explicit development overrides.

Heavy edit workflow

• Keep large repository migrations coherent. Keep the 10 MiB Streamable HTTP request boundary, normalize complete updateText work to the 50 MiB internal ceiling, and route changes that do not fit one request through staged updateText instead of repeated smaller edit calls while preserving atomic structured-batch preflight, rollback, stale-write, and path-containment safeguards. Legacy low patch-size values no longer throttle upgraded installations, and patch sizing is no longer a normal user setting.
• Make relai_edit tolerant at the connector boundary without weakening repository safety. Advertise one structural input object instead of a non-discriminated seven-branch wrapper, document every canonical edit form and work_id, and enforce exclusivity in the edit planner before any path is resolved or file is written. Ambiguous and incomplete calls now return one actionable retry contract instead of unrelated oneOf failures, while type, unknown-field, task, path, sensitive-content, stale-write, preflight, and rollback protections remain intact.

Repository Intelligence

• Hard-cut over code intelligence to a persistent local graph. Replace the 32 MiB regex/in-memory index and hashed-vector pseudo-semantic search with lazy Tree-sitter WASM parsing, a per-workspace SQLite graph/FTS5 index, structural symbols/references/imports/calls, affected-test and impact traversal, reciprocal-rank fusion, recursive dirty tracking, and periodic reconciliation.
• Keep full-source retrieval lightweight. Use Zoekt automatically when packaged/configured, indexing only Rel.AI-approved staged files; otherwise use bounded Git grep candidate discovery plus the persistent graph/FTS5 ranker. No neural embedding or reranking model is required.
• Ship Repository Intelligence reliably in desktop builds. Package the complete web-tree-sitter and tree-sitter-wasms runtime payload, build pinned Sourcegraph Zoekt search/index binaries from reviewed source with SHA-256 provenance, carry the minimal Windows file-reader/umask compatibility layer, and verify both runtimes before and after Electron packaging.
• Advance the MCP contract to schema 6. Keep protocol 2026-07-28 and the 12-tool public surface, advance tool surface 33 for the connector-compatible edit contract, and update semantic-search wording to describe the new non-neural engine.

Workflow execution reliability

• Advertise structured MCP output contracts to ChatGPT. Publish strict outputSchema metadata for every direct and cloud tool from the canonical operation catalog, keep semantic-search and compacted-result fields declared, and reject cloud device responses that drift from the advertised structured output contract.
• Keep successful MCP results aligned with the closed public contracts. Accept the intentional adaptive-search, semantic-search, truncated-snapshot, and managed-worktree metadata without weakening unknown-field rejection, and preserve task/baseline ownership metadata in compact review responses.
• Validate the task that actually changed. Use exact work-session-owned paths to choose impact and validation scope while retaining repository-wide fingerprints for stale-content and cross-task conflict protection; embedded relai_edit checks reuse the edit's own changed files and can satisfy final validation without a duplicate check run.
• Track mutations correctly on dirty workspaces. Record mutations even when a command or post-check returns failure after changing files, and fingerprint already-dirty paths with filesystem metadata so relai_exec detects content changes that leave the Git status code unchanged. Controlled benchmarks keep the added dirty-worktree overhead bounded while preserving the existing safety scans.
• Keep idempotent cancellation responses valid. Accept both live millisecond timestamps and persisted ISO timestamps for cancellation lifecycle fields so reconnect or duplicate relai_work cancel calls do not fail closed output validation after the task is already cancelled.

Skills and packaged runtime reliability

• Temporarily remove desktop skill management. Remove Skills navigation, GitHub skill installation, per-workspace assignments, skill-library resources, and workspace bootstrap injection while retaining the six bundled first-party workflow skills in the plugin package.
• Keep built-in skills present in installed Electron builds. Package the runtime JavaScript from src/ plus the required bin/, public/, and skills/ runtime assets while keeping source Tailwind/build-only files out of Electron; packaged verification locks the required runtime resources and rejects hosted-service implementation/tooling leakage.

Desktop runtime reliability

• Control supported desktop versions remotely. Fetch a strict GitHub-hosted support policy with a 0.25.0 initial floor, cache only valid unexpired policy data, fail open on unavailable or stale policy, show grace-period/update-required UI through the existing updater modal, and block both direct MCP and cloud-gateway work only when a valid policy reaches required or emergency enforcement.
• Retry transient updater transport failures. Update checks and downloads retry short-lived Electron/Chromium network errors such as ERR_HTTP2_SERVER_REFUSED_STREAM with bounded backoff and emit update_failed only after retries are exhausted or for a non-transient failure.
• Repair Windows launch-at-sign-in readback. Read login-item state with the same executable path and --background argument used during registration so the toggle reflects the actual Windows startup entry.

Dashboard discoverability and connection layout

• Make Repository details visible from every workspace card. A direct action opens and focuses branch/worktree, validation, protected-branch, remote, project-instruction, session, activity, and removal details instead of leaving them hidden behind hard-to-find disclosure copy.
• Align Connection layers with the shared disclosure layout. Connection layers now use the same summary spacing and alignment contract as technical connection details while redundant competing layout rules are removed.

Activity history and live-update reliability

• Make passive dashboard state updates non-destructive. MCP/SSE request snapshots, desktop-status pushes, visibility-resume refreshes, and ordinary dashboard refresh requests no longer fall back to route remounts; only explicit structural mutations can rebuild a route. Real Electron acceptance now verifies Settings, Diagnostics, Workspaces, and Tools retain DOM identity without loading flashes or main-frame navigation during MCP requests.
• Treat stored Activity history as an authoritative snapshot. Navigating away, clearing history, or remounting the route no longer allows stale in-memory entries to reappear, while live events received during history loading are retained safely.
• Surface history-loading failures instead of showing a misleading empty list. Structured /api/logs errors now render an explicit history-unavailable state while continuing to accept live events.
• Make Freeze live list lossless. Incoming snapshots are buffered while frozen, applied on resume, and reconciled with a fresh stored-history read so Activity catches up without shifting rows while the user is reading.
• Skip unchanged live snapshots. Activity fingerprints displayed content, preserves the current DOM when nothing changed, and keeps the virtualized row depth already reached instead of collapsing back to the first chunk.

Filtering, messages, and accessibility

• Use accurate status groups. Succeeded, in-progress, failed, blocked, cancelled, and other events are filtered independently; legacy ok and error route values remain compatible without grouping blocked or cancelled work into failures.
• Age time-range filters automatically. The shared dashboard clock now removes entries exactly when they leave the selected 15-minute, 1-hour, 24-hour, or 7-day window, even when no new backend snapshot arrives.
• Keep Activity messages consistently visible. Empty lifecycle patches cannot erase useful text, the Message column receives readable space before optional columns, and event titles are secondary metadata...

Rel.AI MCP 0.24.1

Simplified tool and runtime architecture

• Use one canonical 12-tool action catalog. Keep public schemas, operation definitions, execution, output validation, dashboard metadata, and capability classification aligned through one catalog boundary, while keeping relai_edit as the only repository file-change tool.
• Remove unnecessary forwarding and duplicate dispatch layers. Replace parallel registries, wrapper factories, operation-task handlers, and redundant server adapters with direct module boundaries that are easier to inspect and maintain.
• Keep protocol compatibility isolated. Route legacy MCP request handling through a bounded adapter while preserving the current stateless MCP lifecycle, authorization policy, and native Tasks behavior.
• Simplify the Electron runtime composition. Group IPC registration by trusted surface, colocate dashboard window controls, replace unnecessary desktop status and settings factories, and direct-import diagnostic sanitization.

Task state, progress, and durable recovery

• Normalize one task status vocabulary across runtime, history, and UI projections. Centralize live task progress, terminal-state handling, durable history normalization, dashboard activity data, and browser session rendering so the same work is not interpreted differently by each layer.
• Persist worktree and connection-generation registries atomically. Use the shared durable-state path with backups and recovery behavior so restarts do not silently lose managed worktrees or authorization-generation state.
• Narrow native task execution to the actual eligible operations. Remove the broader operation-task compatibility layer and keep cancellation, telemetry, and bounded synchronous fallback aligned with the canonical action catalog.

Desktop notifications and application updates

• Add persistent notification categories. Users can independently control task-completion, error, connection/service, and application-update alerts under one master switch that preserves category choices while disabled.
• Centralize native notifications in the Electron main process. Task results, service state changes, connection readiness, authorization requirements, update availability, downloaded updates, and update failures now use one category-aware service instead of duplicate renderer notification paths.
• Repair unread completion badges across Windows and Linux. Windows now renders a supported PNG taskbar overlay, Linux uses the application badge count, duplicate completions do not inflate the counter, and focusing or opening the app clears unread work reliably.
• Show an update-available modal in the desktop dashboard. Users can download immediately, postpone until a later application launch, or ignore only the currently offered version while still receiving future-version notices.

Dashboard stability and usability

• Update live dashboard regions without remounting the active route. Tool-call snapshots refresh only the affected Home, Tasks, Processes, Activity, or Connection content, reducing full-screen flicker and preserving unrelated controls and connection setup content.
• Keep event messages visible beside status. The Activity table retains the Message column in desktop layouts and preserves its mobile metadata presentation.
• Classify consolidated tools by their real capabilities. The Tools page can distinguish inspect, edit, validate, Git, and recovery actions even when several capabilities belong to one consolidated tool.
• Hide the custom-titlebar skip link until keyboard focus. Remove the clipped rounded shape that could appear above the Rel.AI MCP title while retaining accessible skip navigation.

Documentation, configuration, and regression coverage

• Document the simplified architecture and protocol boundaries. Add the canonical runtime map, dependency rules, persistence ownership, public tool contract, and legacy-adapter policy to the repository documentation.
• Refresh the example configuration for the current schema. Include current budgets, product UX, release readiness, patch safety, workspace validation, and environment options.
• Keep release validation focused on critical regressions. Replace the automatic every-test-file release gate with a curated suite covering authentication, authorization, connector contracts, durable state, desktop lifecycle, OAuth, packaging policy, safety boundaries, task state, and runtime security; focused tests remain available without blocking every release.
• Repair consolidated Git publish result validation. Align commit, push, and pull-request draft output contracts with their actual runtime payloads so valid dry runs and publish operations are not rejected after Git completes.
• Prevent stale public contracts from returning. Refresh active connection, workflow, release-gate, roadmap, and status documentation for the 12 consolidated tools; derive test action counts from the catalog; and add a release-critical guard against removed operation names and obsolete current-release claims.
• Add architecture and UI contract coverage. New tests lock action-catalog parity, IPC channels, persistence, task projections, live dashboard rendering, desktop notification preferences, update-modal eligibility, and removed-layer boundaries.

Bump root/electron/plugin/status UI/lockfiles/release manifest to 0.24.1.

Rel.AI MCP 0.23.2

Linux release and connector reliability

• Complete Linux release packaging. Configure the Chromium SUID sandbox in CI, provide DEB maintainer metadata, use canonical x64 artifact names, and ignore electron-builder diagnostic YAML while promoting only the required AppImage, DEB, and updater metadata.
• Accept ChatGPT dynamic registration metadata. Default an omitted OAuth application_type to web while continuing to reject unsupported explicit values.
• Keep setup controls reachable on Linux. Make the setup wizard resizable and maximizable, enable vertical scrolling, and size it from actual wizard content instead of the viewport scroll height.
• Synchronize release contracts. Keep plugin metadata, runtime assertions, cross-platform verification, and release-bump fixtures aligned with the application version and artifact workflow.

Bump root/electron/plugin/status UI/lockfiles to 0.23.2.

Rel.AI MCP 0.23.1

Desktop recovery and tunnel reliability

• Restore setup and recovery renderer loading. Register the restricted relai-app:// protocol on each custom Electron session before loading its window, and surface renderer load failures in runtime diagnostics instead of leaving a blank recovery window.
• Make managed ngrok startup diagnostics deterministic. Request logfmt info output explicitly, record preparation and startup events, and keep the displayed launch command aligned with the actual managed process.

Cross-platform desktop releases

• Add Linux desktop packages. Build and verify x64 AppImage and DEB artifacts with the platform-specific bundled ngrok binary, executable checks, package-size policy, updater metadata, and AppImage update support.
• Publish one combined Windows and Linux release. Split release builds by operating system, verify each packaged application independently, combine the artifacts for checksums, attestations, and GitHub publication, and expand CI coverage for both platforms.

Bump root/electron/status UI/lockfiles to 0.23.1.

Rel.AI MCP 0.23.0

Standards-compliant MCP lifecycle and recovery

• Use MCP 2026-07-28 through the stable v2 SDK without cutting off ChatGPT. Native stdio and modern HTTP use server/discover plus per-request protocol, client, and capability metadata. HTTP also serves the SDK-supported stateless 2025-11-25 initialize flow used by ChatGPT. MCP-Session-Id, /sse, /messages, JSON-RPC batches, and removed tool aliases remain rejected.
• Keep transport, work-session, native-task, and process identity separate. Every stateless request supplies its authenticated principal; the principal-bound work_id returned by relai_begin_work owns repository work, native taskId owns one asynchronous MCP request, and processId owns one managed process.
• Detect and recover stale client state. Rel.AI fingerprints the canonical tool manifest, serves the current list on every stateless request, invalidates stale credentials, and exposes explicit reconnect or host-action states in the dashboard.
• Publish one 30-tool surface at tool-surface version 27. The public native-Tasks probe, standalone validation-plan tool, named UI-check wrapper, and duplicate protocol routers are removed. Work-scoped schemas require a principal- and workspace-bound work_id; relai_run_checks plans change-aware validation internally.

Task observability, privacy, and runtime integrity

• Sanitize completion summaries before they enter task state. One bounded sanitizer now covers credential-bearing headers, token/password assignments, cookies, secret URL fields, private-key blocks, and approval or authorization codes at completion input, tracker, activity, persistence, historical-read, dashboard, SSE, and copy/export boundaries.
• Use one canonical task state machine. New writes no longer emit inactive or attention; historical aliases normalize on read, terminal states share one predicate, stale updates cannot reopen terminal work, and terminal timestamps, reasons, counters, and partial progress are preserved.
• Add explicit cooperative cancellation. relai_cancel_work targets the exact work session, is idempotent, preserves partial progress, bypasses the workspace lock, records a bounded reason, and signals supported process-backed operations without claiming every external side effect can be reversed.
• Report real validation and diagnostics progress. Known workflows establish a deduplicated denominator before execution, advance after every check, identify failures and timeouts, persist midpoint progress, and never present failed or cancelled work as successful 100% completion.
• Detect repository/runtime skew without locking the workspace. Status, MCP discovery, dashboard data, and packaged metadata compare application, protocol, tool-surface, tool-count, schema, and manifest-hash values. A mismatch remains visible with restart or reconnect guidance, but it is advisory: every tool stays available so Rel.AI can always finish or repair edits to its own checkout.
• Add production-path regression and acceptance infrastructure. Security tests inspect raw persisted history and every dashboard projection, real Electron Chromium acceptance covers task states, keyboard reachability, 200%/400% zoom, and accessibility, and the machine-readable observability benchmark executes both backend and isolated Electron renderer workloads while failing incomplete runs.
• Normalize historical state without destructive migration. Existing inactive, attention, and related aliases remain readable through evidence-based mapping; sanitized canonical records are used in memory and on subsequent persistence.
• Centralize and verify status-color semantics. Tasks, validation, native Tasks, processes, workspaces, connection layers, diagnostics, application updates, and Electron status surfaces now share one status-to-tone classifier: normal progress is information blue, success is green, intervention is amber, failure is red, and inactive terminal state is neutral. Exhaustive dark/light contrast and status-matrix tests prevent silent fallback or cross-screen disagreement.
• Stop terminal sessions from appearing to run forever. Failed, inactivity-cancelled, expired, blocked, approval-paused, and validation-failed tasks now render explicit static end or action-required states instead of an indeterminate loading animation. Terminal history also discards stale active-call and running-operation projections.
• Fail closed on native-task storage faults. Request validation, task unavailability, record corruption, and filesystem failures now use separate typed errors; protocol responses never expose host paths, corrupt records move out of the active task directory, and pruning reports quarantined records.

Durable local coding runtime

• Add managed persistent processes. ChatGPT can start, read, write to, stop, and list long-running commands through stable process IDs, cursor-based logs, process-tree termination, ownership checks, crash-safe metadata, and a dedicated dashboard Processes page.
• Remove proprietary deferred-operation, probe, and validation-wrapper tools. The canonical catalog contains 30 tools; defer, operationTaskId, operation polling, relai_native_tasks_probe, relai_validation_plan, and relai_ui_check are no longer public. Persistent commands use relai_process_*, while selected long-running operations use native MCP Tasks or bounded direct execution.
• Add managed Git worktrees. Rel.AI creates isolated branches under its managed worktree root, registers dynamic workspace aliases, inherits workspace policy, refuses unsafe removal, and preserves branches by default.
• Expand code intelligence and validation. Private local hybrid semantic search, symbol/import/caller/test tracing, normalized diagnostics, internal content-bound validation planning, reverse-impact analysis, and affected-test selection are available through the public tool surface.

Security, telemetry, and caching

• Harden OAuth as an issuer-bound OAuth 2.1 flow. Dynamic registrations, authorization codes, access tokens, and refresh tokens are bound to the active issuer and exact resource; redirects are exact, PKCE S256 is mandatory, scopes accumulate safely, refresh tokens rotate, reuse is rejected, public issuers require HTTPS, and approval-token replacement revokes registrations and grants. Authorization codes and bearer tokens are persisted under SHA-256 identifiers rather than plaintext map keys.
• Add OpenTelemetry tracing with W3C propagation. MCP requests, logical tasks, tools, workspace queues, managed processes, validation, and OAuth operations emit sampled, redacted spans without file contents, credentials, environment values, approval material, or full command lines. Active W3C trace context propagates into managed child processes.
• Stop forwarding the service environment into repository commands. A shared process-environment policy passes required platform variables, rejects NODE_OPTIONS and Electron Node mode, and requires explicit configuration for additional inherited values.
• Add revision-aware private resource caching. Discovery, tool, and resource responses use bounded TTLs and invalidate when configuration, workspace state, or the tool surface changes.

Runtime and release modernization

• Require Node.js 24 LTS and npm 11. Root and Electron manifests declare the runtime policy, npm is pinned through packageManager, and CI uses immutable action commit SHAs.
• Update and exact-pin the release-critical stack. Electron remains at 43.2.0, electron-builder is pinned to 26.15.3, electron-updater is pinned to 6.8.9, MCP SDK packages are pinned to 2.0.0, and globals moves to 17.8.0.
• Harden Electron packages before publication. Setup and recovery pages use the restricted relai-app://renderer protocol; packaged binaries disable RunAsNode, NODE_OPTIONS, CLI inspection, and extra file-protocol privileges while requiring integrity-validated ASAR loading.
• Make Windows releases signed and attributable. Publication requires protected Authenticode credentials and valid signatures, generates a CycloneDX SBOM, and creates GitHub build-provenance and SBOM attestations.
• Make generated assets and module direction enforceable. CI regenerates and diffs color assets, browser UI source has an explicit ESM package scope, and a module-system audit prevents CommonJS growth or mixed modules before the coordinated backend and Electron hard cutover.
• Make native MCP Tasks selective and production-facing. Stateless HTTP and stdio discovery advertise the Tasks extension; relai_exec, relai_diagnostics_run, and relai_run_checks are task-eligible, process tools retain process semantics, clients without Tasks support receive bounded synchronous results, and both transports enforce task polling, update, cancellation, capability, and principal ownership.
• Add a release-blocking native Tasks matrix. A machine-readable gate covers HTTP/stdio capability negotiation, strict modern envelopes, stateless ChatGPT initialization, adaptive direct/native execution, notification no-response behavior, server identity metadata, lifecycle and persistence, input idempotency, cancellation cleanup, process independence, principal isolation, the 30-tool public surface, and dashboard terminal states.
• Reduce the published npm package to an explicit runtime allowlist. The package now ships only the CLI, service source, dashboard assets, examples, type boundaries, README, and license, reducing the dry-run artifact from 418 entries and about 4.09 MB to 194 entries and about 0.57 MB compressed.
• Remove build-only SDK files from the Electron runtime. Packaged MCP and telemetry dependencies exclude source, test, TypeScript, declaration, and source-map trees; final resources/ size is 45.36 MiB and packaged connector acceptance verifies the reduced runtime.
• **Make depend...

Rel.AI MCP 0.22.0

MCP SDK v2 hard cutover

• Replace the custom JSON-RPC and transport implementation with MCP SDK v2. Stdio framing, initialization, capability negotiation, tool and resource registration, schema validation, protocol errors, and Streamable HTTP now use @modelcontextprotocol/server and @modelcontextprotocol/node.
• Remove the legacy MCP SSE transport. GET /sse, POST /messages, custom session IDs, conversation-header hashing, and transport-derived task scopes are deleted; HTTP clients use the OAuth-protected POST /mcp endpoint.
• Require exact logical task identity. Each independent objective calls relai_start_task once and every later task-scoped call supplies the returned task_id. Rel.AI no longer selects or merges tasks by transport, ChatGPT conversation metadata, workspace, process, timestamp, or validation aliases.
• Make task history current-version-only. The first 0.22.0 history access deletes the previous sessions directory, writes .task-history-v2, and stores only explicit identity-v2 events. Existing audit logs remain activity records but are not reconstructed into task history.
• Remove configuration compatibility. Legacy workflow, flow, cautionZone, top-level maxIndexFiles, workspace fastTask, context includePaths, and patch maxPatchBytes values are ignored instead of migrated or written back.
• Keep OAuth and managed ngrok as active product features. OAuth discovery, dynamic client registration, authorization code plus PKCE, access/refresh tokens, revocation, connector recovery, static-domain delivery, and bundled ngrok remain supported.

Release and packaging changes

• Package the MCP SDK runtime explicitly in the Electron application. The package allowlists the SDK, Hono adapter, Hono, and Zod dependencies, excludes source maps and the source Tailwind stylesheet, and verifies the packaged backend can initialize MCP from resources/.
• Patch the SDK's Node adapter dependency. @hono/node-server is overridden to 2.0.12, leaving the production dependency audit at zero known vulnerabilities.
• Add packaged connector acceptance. CI and release workflows launch the isolated packaged Node backend and verify OAuth/PKCE, tools and resources, explicit task calls, completion, reconnect rejection, and removal of the old MCP routes without installing or launching Electron.
• Document the incompatible upgrade explicitly. Release notes and architecture documentation identify discarded history, ignored configuration, removed routes, standard initialization requirements, exact task IDs, and new runtime dependencies.

Codebase reduction

• Bind tool definitions directly to executable handlers and delete the dispatch lookup module. Registry annotations, behavior, dashboard metadata, and empty arrays now use centralized defaults.
• Consolidate repeated UI behavior. HTML escaping, duration formatting, hidden settings save rows, workspace alias/path handling, task-history event utilities, and ngrok authtoken validation each have one implementation.
• Remove public legacy workspace helper exports while preserving MCP resource behavior through the internal status module.

Breaking upgrade behavior

• Back up any removed configuration values or old session-history files before upgrading if they are still needed.

• Clients must use stdio or POST /mcp, send standards-compliant initialization fields, call relai_start_task, and preserve the returned task_id.

• Old task-history sessions are intentionally discarded and are not converted.

• Synchronize every release surface at 0.22.0. Root and Electron manifests, both lockfiles, the desktop status badge, changelog, and release metadata now agree.

Bump all release surfaces to 0.22.0.

Rel.AI MCP 0.21.9

Tool-call latency overhaul

• Read-only tools now share a per-workspace reader/writer lock instead of serializing behind the mutation queue, so a batch of relai_read, relai_search, relai_status, or relai_diff calls dispatched together runs concurrently while edits stay exclusive.
• Session-history writes use a prune fast-path and parsed-session cache, while history listings revalidate high-resolution file metadata so updates from the desktop app, connector server, or another process cannot remain stale.
• The workspace tree walk dropped one realpath syscall per file, taking relai_repo_snapshot and relai_code_inspect collection from ~70-94 ms to ~7 ms on a 350-file repository.
• relai_code_inspect gained per-file identifier and token sets so symbol, references, and related queries skip files that cannot match: warm queries went from ~102-124 ms to ~13-19 ms.
• config.json is parsed once per change instead of once per tool call, workspace root realpaths are memoized, and command discovery plus validation-check detection now share a manifest-signature cache.
• relai_repo_snapshot overlaps its git summary with the tree walk, and relai_git_commit overlaps its work-tree probe with the status read. relai_diff deliberately waits for canonical status classification before reading any diff so sensitive paths are never loaded speculatively.
• relai_read accepts ranges:[{path,startLine,endLine}] so several files with different line windows resolve in one call instead of one call per file (tool surface version 12).
• relai_status skips the package.json read and .github/workflows CI scan for connector calls, which strip both from the result anyway.
• Git status consumers now share NUL-delimited porcelain parsing, preserving filenames with spaces and non-ASCII characters across review, status, baseline ownership, tidy, and command mutation tracking. Unified-diff authorization now uses Git's own apply inspection rather than scraping +++ b/ headers.
• The Sessions tab now uses blue for open logical tasks, amber for incomplete sessions where completion was not reported, green for completed sessions, and red only for actual errors.

Bump root/electron/status UI/lockfiles to 0.21.9.

Rel.AI MCP 0.21.7

Tailwind editor diagnostics

• Suppress VS Code's propertyIgnoredDueToDisplay false positive for Tailwind's intentional generated preflight rule.
• Apply the Tailwind language association to the source stylesheet across workspace paths while leaving runtime CSS unchanged.

Bump root/electron/status UI/lockfiles to 0.21.7.

Rel.AI MCP 0.20.7

Context-rich repository search

• Make adaptive search context the default without adding another tool. mode:"auto" selects focused, moderate, or broad context budgets from the total match count, while explicit compact and context modes remain deterministic overrides.
• Prioritize likely implementation files in auto mode. File-path relevance and bounded match density decide which matched files receive context first; the raw match list remains available separately.
• Merge overlapping and adjacent result windows by default. Callers can disable merging, request flat ranges, and cap files, ranges per file, lines per range, and returned context bytes.
• Make contextual results safe to reuse. Each returned file includes its SHA-256 digest, line count, source byte count, match count, and explicit context truncation metadata.
• Preserve broad-search observability. Raw matchCount and truncated remain separate from contextMatchCount, omitted files, omitted ranges, and contextTruncated.

One-shot commands and project guidance

• Add relai_exec as the nineteenth connector tool. ChatGPT can run bounded one-shot project commands with workspace-relative working directories, environment overrides, explicit output limits, and complete nonzero-exit diagnostics.
• Track command side effects conservatively. Command calls invalidate workspace caches, report changed files, redact sensitive audit details, and never replace the final structured validation requirement.
• Load persistent repository instructions automatically. Workspace inspection reads REL_AI.md and .relai/instructions.md with explicit precedence, bounded UTF-8-safe payloads, cache invalidation, and path hardening.
• Keep the current runtime scope focused. Repository context, one-shot commands, and project instructions are included; persistent processes, managed worktrees, task plans, and independent workers remain deferred.
• Update documentation, desktop behavior, connector registration, type boundaries, and regression coverage for the new runtime capabilities.

Bump root/electron/status UI/lockfiles to 0.20.7.