Roomote v1.0.2

1.0.2 (2026-09-01)

Roomote 1.0.2 makes Fast follow-ups reliable and steerable during active work, moves artifact builds into Sessions, and strengthens conversational and unattended automations.

Highlights

• Send follow-ups during active Fast responses without losing messages, with same-person corrections steering current work between completed tool calls.
• Create recurring automations from Fast conversations, and let unattended runs launch follow-on Sessions and coding tasks with trusted owner context.
• Build Markdown plans inside Sessions while preserving the selected environment, branch, model, and plan context.

Patch changes

• Let unattended automation runs use their trusted owner context to start follow-on Sessions and coding tasks and attribute resulting pull requests, while ownerless runs remain restricted.
• Let deployment admins turn repeatable Fast work into recurring automations through conversation, with schedule confirmation, duplicate checks, and an optional test run after creation.
• Keep human follow-ups sent during an active Fast response durable across web and supported chat providers, so accepted messages run in order under the correct participant instead of disappearing.
• Let same-person follow-ups steer active Fast work between completed tool calls instead of waiting for the current response to finish, while preserving safe queued turns for other participants.
• Reduce noise in Sessions list and board views by removing active spinners while keeping needs-input and blocked badges visible.
• Start Markdown artifact builds inside a Session while preserving the selected environment, branch, model, and plan context, so retries recover the same delegated task instead of creating a standalone Task.

Roomote v1.0.1

1.0.1 (2026-09-01)

Roomote 1.0.1 improves Session access and task navigation, brings automated Slack and Discord entries into Fast, and hardens Fast recovery, model defaults, and pull-request review follow-through.

Highlights

• Share Session links across the deployment, see attached work in task-only Sessions, and keep task timelines consistently ordered.
• Route eligible Slack and Discord automation feeds through Fast, and let authorized Slack Fast sessions discover channels and post standalone updates.
• Open direct environment launches in their task workspace while keeping Fast retries, model defaults, and pull-request auto-resolve behavior reliable.

Patch changes

• Route eligible Slack and Discord messages from bots, webhooks, and automated feeds through Fast first, while retaining direct task launch as a fallback so automated work is not dropped.
• Open the task workspace immediately after a user selects an environment and launches work from the web, instead of routing them through the owning Session first.
• Show and honor the deployment's Fast orchestration model in the new-Session picker instead of silently persisting the coding model default as a Session override.
• Recover Fast Sessions whose owner disappears during a quiet provider retry, preserving the silent short-retry experience while ensuring abandoned turns settle to a visible interruption instead of remaining stuck.
• Give Slack-originated Fast sessions authorized channel discovery and standalone posting while keeping reactions safely scoped to the current inbound message and honoring deployment-disabled tools.
• Keep pull-request auto-resolve enabled through temporary task snapshot gaps so later review and CI cycles retry automatic dispatch instead of showing duplicate review prompts.
• Make Sessions reliable and shareable across deployments: any signed-in user with the link can view and contribute like they can with tasks, task-only Sessions show their attached work, and concurrently attached tasks stay consistently ordered.
• Render Session and task start times in each viewer's local format without triggering hydration errors when the browser and server use different locales or time zones.

Roomote v1.0.0

1.0.0 (2026-08-30)

Roomote 1.0 makes Fast the default entry point for conversations, enables Memory by default on new hosted deployments, and completes the Session-centered automation, analytics, and artifact experience.

Highlights

• Start unpinned requests in Fast by default, while choosing an environment or repository still starts coding work immediately.
• Enable Memory by default for new hosted deployments and recall public Discord discussions, visible Linear issues, and richer Notion database properties.
• Follow conversations, delegated executions, artifacts, reviews, and costs in a searchable Session workspace across desktop and mobile.
• Continue Fast across supported chat providers, delegate parallel work with attachments, preview generated HTML safely, and announce default-branch changes.

Major changes

• Make Fast the default entry point for unpinned Roomote requests across the web dashboard and supported chat providers, and enable Memory by default for new hosted deployments. Select an environment or repository when work should start directly in a coding task; existing deployments keep their current Memory setting.

Minor changes

• Start and continue linked Fast conversations directly from Microsoft Teams and Telegram, matching the existing Slack and Discord experience.
• React to Roomote Fast replies across Slack, Discord, Microsoft Teams, and Telegram to provide context for a follow-up or let the conversation stay quiet.
• Announce default-branch pushes across supported source-control providers with concise, pull-request-aware summaries, direct change links, and durable Slack, Discord, Microsoft Teams, or Telegram destinations.
• Open Analytics on Costs by default and break out Session orchestration and Memory synthesis so teams can understand where inference spend comes from.
• Let Fast launch multiple independent coding tasks from one turn, forward image and supported file context into delegated work, and show nested startup progress without losing retries or results.
• Let Fast inspect GitHub Actions runs, jobs, and logs to explain CI failures while keeping the diagnostic path read-only.
• Open generated HTML artifacts as safely sandboxed previews with a source-code toggle, while keeping presentational widgets available in web transcripts and linked chat previews.
• Add public Discord discussions and visible Linear issues to Memory, preserve richer Linear planning metadata, and render readable Notion database properties for more complete recall.
• Let administrators enable Memory without a dedicated synthesis-provider key, enable it by default for new hosted deployments, and surface newly ingested pages within minutes instead of waiting for a later maintenance pass.
• Finish setup in one Roomote Session that launches and tracks selected starter tasks, with clearer guidance about the value and limits of hosted trial inference.
• Make Sessions the primary workspace for Roomote work, with dashboard launch and search, recent-session navigation, delegated execution details, artifacts, reviews, costs, stable titles, and responsive mobile layouts in one continuous conversation.
• Browse current and previous Roomote releases directly in the update dialog, with the latest release expanded and newer remotely detected updates kept visible even when their notes are not yet available in the running image.
• Open current and previous Roomote release notes directly from About Roomote in the existing in-app release-history dialog.
• Follow delegated work more clearly in Sessions with live nested-task activity, a conversation-wide artifact gallery, cleaner task details and navigation, and modernized search, filter, board, and list controls.
• Include one safely validated, representative pull-request screenshot in Slack Merge Announcer reports when the pull request provides a suitable image.
• Show richer task context throughout Sessions with accumulated pull requests, actor and source details, clearer status indicators, direct access to a sole running task, and full task workspaces for Session deep links.
• Make Roomote MCP Session-first so ordinary start, search, summary, message, and follow-up operations use Sessions by default while explicit task IDs continue to target individual coding tasks.
• Have Fast acknowledge substantive human requests before starting model-invoked work, using a brief reply or eligible Slack reaction without duplicating immediate answers, clarifications, or delegated-task kickoffs.

Patch changes

• Keep Fast sessions quiet through short transient provider recoveries: retries stay silent unless the wait grows past 30 seconds, all retryable provider errors share a six-retry budget with bounded jittered backoff, and warm-session progress refreshes the recovery budget the way completed coding-task turns do.
• Queue delegated-task updates durably for their Fast parent so busy conversations process child progress and completion in order instead of rejecting or killing the parent event after 30 seconds.
• Keep pull-request review follow-through reliable by showing actionable feedback in Fast and standard web tasks, clearing resolved Roomote findings, preserving the correct destination branch and attribution, and avoiding duplicate review requests.
• Disable anonymous usage reporting in the bundled Infinity service so self-hosted local Memory embeddings stay quiet by default.
• Keep Fast Sessions stable through cold starts and refreshes by preserving conversation context, model and reasoning choices, generated titles, pull-request status, and recovery state without duplicate or stale transcript notices.
• Keep Slack Fast thread titles synchronized with generated and manually edited Session titles instead of leaving conversations labeled Thread.
• Show platform issue alerts sent directly to Slack deployment admins with the same actionable automation card used for configured alert destinations.
• Keep expanded tool-call details readable in Task and Fast transcripts by wrapping long YAML values within the transcript instead of clipping or overflowing them.
• Keep Session context accurate by including attached task inference spend in total costs, opening inline task links in their owning Session, and hiding running or artifact states when they no longer apply.
• Keep Slack-backed Sessions and automations reliable by deferring silent custom-automation delivery, suppressing no-op placeholders, validating Fast titles without retry loops, restoring clear Configure actions, and using the correct Merge Announcer icon.
• Restore required runtime dependencies in standalone deployment images while continuing to bundle in-app release history.
• Show the shared progress spinner while tool calls are active, then restore each tool or integration icon when the call settles.
• Let Fast mode discover, load, and explicitly invoke environment-scoped Settings skills while preserving built-in skill precedence and bounded access.
• Complete large Notion historical discovery scans in the fast continuation loop instead of spreading database-row traversal across weeks of scheduled passes.
• Keep tasks moving when visual proof takes too long by applying one five-minute deadline across capture, retries, and recovery before returning a graceful proof blocker.
• Include authorized Settings skills in Fast mode's unscoped skill inventory.
• Keep running nested-task activity visible when a Session is loaded directly or reconnects, while still hiding it during genuine new parent responses.
• Restore authorized deployment MCP tools in Fast advisor and judge consultations while keeping Fast-native orchestration and custom automation tools confined to the parent Session.
• Keep Fast conversations responsive through API restarts by closing out in-flight turns gracefully during shutdown, so replies no longer disappear and sessions no longer get stuck waiting on an abandoned turn.

Roomote v0.45.1

0.45.1 (2026-08-29)

This patch restores complete Notion database discovery across Memory and the built-in Notion MCP.

Highlights

• Find and ingest pages inside directly shared Notion databases even when Notion search omits them.

Patch changes

• Discover pages inside directly shared Notion databases in Memory and let agents resolve the database through the Notion MCP even when Notion search omits its rows.

Roomote v0.45.0

0.45.0 (2026-08-27)

This release adds secure hosted trial inference and self-run Brain model options, expands GLM 5.3 support, and improves reliability across Fast sessions, pull-request reviews, Memory, and chat.

Highlights

• Start hosted deployments with secure, spend-capped Roomote trial inference and accurate cost reporting.
• Run Brain embeddings and reranking on self-hosted infrastructure with multilingual bundled defaults.
• Use GLM 5.3 and GLM 5.3 Flash across more existing inference providers.
• Keep Fast sessions, pull-request re-reviews, Memory ingestion, and chat reporting reliable through retries and resumptions.

Minor changes

• Expand GLM 5.3 and GLM 5.3 Flash availability and recommendations across OpenRouter, Vercel AI Gateway, Requesty, OpenCode Go, Z.AI, and Z.AI Coding Plan.
• Offer secure, spend-capped Roomote trial inference during hosted setup, record its real model costs in task and cost analytics, and present the option with clearer onboarding copy.
• Let self-hosted deployments run Brain embeddings and reranking through their own OpenAI-compatible upstream, including an opt-in bundled CPU service with multilingual model defaults.

Patch changes

• Include the Brain's memory volume and database state in supported self-hosted backup and restore bundles so memories survive host recovery consistently.
• Treat temporary Brain network outages as queue backpressure so infrastructure restarts do not exhaust individual memory write retries or require manual repair.
• Render Fast replies as rich Markdown in Discord guild channels instead of falling back to plain unformatted messages.
• Make suggested tasks in Fast automation reports launch reliably across Slack, Discord, Microsoft Teams, and Telegram while keeping each suggestion card's state in sync.
• Preserve the full Fast conversation context across resumed turns so follow-up answers continue from the existing thread instead of losing earlier messages.
• Keep Fast session sidebars and information panels usable on mobile by switching them to the same single-panel layout as task workspaces.
• Discover Notion pages and database rows that inherit integration access through shared parents, even when Notion search does not return them.
• Keep automatic pull-request re-reviews running after their previous sandbox shuts down and anchor each sync review on the head commit that was actually reviewed.
• Keep Standard tasks and Fast web sessions running through retryable inference-provider failures instead of ending the work prematurely.
• Briefly name the recalled insight that materially influenced an agent's approach without exposing internal memory provenance or identifiers.
• Keep Fast and standard agents identified as Roomote by removing OpenCode's conflicting injected identity prefix from their system prompts.
• Render automation report Markdown correctly in Slack while preserving the report's replyable thread footer.
• Use task-specific wording in Slack inline status updates so progress messages describe the work instead of exposing generic agent terminology.
• Make transcript tool activity easier to inspect by showing sanitized inputs and readable YAML details without hiding the corresponding tool results.

Roomote v0.44.0

0.44.0 (2026-08-26)

This release adds shared memory, skill discovery, and presentational widgets to Fast sessions, expands automation delivery across chat providers, and improves session and pull request review reliability.

Highlights

• Save durable context from Fast sessions and recall it in later work through connected memory providers.
• Discover and load packaged or repository-defined skills from Fast before delegating work.
• Render safe status cards, tables, plans, and other presentational widgets in Fast session transcripts.
• Deliver Fast automation reports across Slack, Discord, Microsoft Teams, and Telegram, with direct chat continuation where supported.

Minor changes

• Deliver Fast automation reports across Slack, Discord, Microsoft Teams, and Telegram channel or direct-message destinations, with web continuation everywhere and direct chat continuation where the provider supports Fast session identity.
• Let Fast sessions discover and load packaged and repository-defined skill documents through bounded, session-safe tools without exposing filesystem access.
• Let Fast save durable preferences, decisions, corrections, and facts to shared memory so they can be recalled in later sessions, while supporting pluggable memory providers and making concurrent memory ingestion more reliable.
• Render safe presentational widgets such as status cards, tables, and plans directly in Fast session transcripts while keeping raw HTML confined to the sandboxed web view.

Patch changes

• Deliver Fast custom automation reports to their owners through configured Slack direct messages, and fail runs clearly when their configured Fast destination cannot be resolved or supported.
• Reconcile image-only Fast replies with their canonical transcript events so optimistic messages do not remain duplicated or stale.
• Keep Fast sessions moving through retryable provider failures without repeating completed tool effects, and forward follow-up instructions to active tasks before posting the confirmation reply.
• Make Fast coding-task kickoffs clearer by describing the repository work and naming the target repository when it is known without exposing internal orchestration details.
• Restore web-initiated Fast turns in standalone production images by shipping native-tool runtime dependencies and removing stale generated tool files during setup.
• Honor each user's Fast response mode preference on the homepage even when the browser has a saved workspace, while keeping explicit environment links and active workspace choices ahead of the personal default.
• Deliver completed pull request review findings reliably by tracking the review lifecycle with structured metadata instead of variable status wording.
• Keep pull request review threads clear by removing stale action buttons when newer feedback arrives or an action is handled, while preserving the latest actionable controls across Slack, Discord, and Telegram.
• Settle Slack task cards when work becomes idle or waits for input, then return them to an active state when work resumes without losing delayed final output.
• Keep the current page visible while authenticated navigation loads and correct the label shown when an input request is cancelled.
• Show Slack pull request review resolutions as subdued context notes instead of prominent message sections after an action is handled.
• Show the redacted task memory submitted by an agent in the save tool result so users can inspect what was recorded without exposing secret-shaped values.
• Deliver Teams Fast automation reports and failure states to newly created owner direct messages by using the persisted session route when no active route row exists.

Roomote v0.43.0

0.43.0 (2026-08-26)

This release brings Fast conversations into the dashboard, introduces a streamlined Memory experience, launches useful starter tasks directly from setup, and adds optional GitHub review checks.

Highlights

• Start and continue Fast sessions from the dashboard with generated titles and live canonical transcripts.
• Browse and share individual memories from a streamlined Memory settings experience.
• Launch preselected starter tasks as soon as setup completes.
• Publish Review Code results as optional GitHub checks for branch protection and rulesets.

Minor changes

• Start, title, inspect, and continue Fast sessions from the web dashboard with live canonical transcripts, while Slack and Discord replies link back to the same session view.
• Publish Review Code results as an optional GitHub check that teams can use with branch protection and rulesets.
• Use consistent Memory naming across Roomote and browse, focus, and share individual memories from a streamlined settings page with recovery controls when ingestion needs attention.
• Replace the final setup step with preselected starter tasks (speed up CI, security scan, fix test flakes, update dependencies) that launch idempotently as standard tasks when setup completes.

Patch changes

• Keep Slack pull request status and resumed task previews accurate across ordinary, Fast-delegated, retried, reopened, and completed task paths.
• Keep Fast conversations useful across follow-ups and longer work by preserving native context through helper restarts, exposing deployment task inspection, responding naturally to corrections, and sharing concise progress when work takes time.
• Make pull request feedback and review checks more reliable by coalescing duplicate actionable notifications, completing checks when reviews finish, and showing provisional findings sooner when a summary is delayed.
• Render automation result tables in Slack with valid cell payloads, including tables with visually empty cells.
• Show the first user message as a Fast session's temporary title instead of exposing a timestamp-like conversation identifier while title generation finishes.
• Allow image-only prompts when starting or continuing Fast sessions while continuing to reject invalid images and empty messages.

Roomote v0.42.0

0.42.0 (2026-08-25)

This release expands Fast and automation workflows, shortens initial setup, adds proactive usage and pull-request conflict alerts, and improves task recovery and chat reliability.

Highlights

• Use current chat context and deployment-configured MCP tools directly from Fast, including automation management and all-repository delegation.
• Run custom automations in Fast and trigger Roomote from Slack workflows and third-party apps.
• Configure inference-provider usage alerts and notify originating conversations when Roomote-created GitHub pull requests conflict.
• Finish initial setup sooner, recover failed task starts with a prefilled launcher, and keep chat-backed work more reliable.

Minor changes

• Run custom automations in Fast mode with consistent Slack reports, easier command-palette discovery, and validation focused on the automation being saved.
• Let Fast read the current chat context and use deployment-configured MCP tools directly, including custom automation management and delegation across all repositories.
• Configure inference-provider usage alerts with adjustable thresholds, destinations, deduplication, and multi-provider delivery.
• Notify the originating task conversation when a Roomote-created GitHub pull request becomes conflicted so the team can resolve it promptly.
• Retry failed task starts through an editable new-task launcher prefilled with the original prompt, model, and environment.
• Let Slack workflows and third-party apps trigger Roomote through explicit mentions.
• Finish initial setup sooner by making environment creation optional, then guide teams to create an environment from Home when they want verified repository setup.

Patch changes

• Reduce GitHub App rate-limit pressure by coalescing installation-token requests, briefly caching the PR-notification hot path with one fresh-token retry, reusing bootstrap credentials until their scheduled refresh, and honoring provider backoff signals.
• Prevent chat-backed and Fast work from hanging during terminal delivery failures, provider recovery, or interrupted retries.
• Keep ChatGPT subscription OAuth credentials on the control plane and out of task sandboxes and restored snapshots.
• Deliver GitHub installation approval notifications to requesters who use Discord without Slack.
• Include complete Fast parent and advisor or judge inference usage in Costs analytics.
• Make empty Fast invocations respond contextually and keep updates focused on useful outcomes instead of orchestration details.
• Preserve exact Slack or Discord source-message links in pull requests created by Fast-delegated tasks.
• Stop pull-request review prompts from reappearing after a user selects automatic Fix all handling.
• Move completed tasks to Done after their pull request merges and resume settled delegated work under the original task.
• Restore each user's preferred Tasks layout and give Slack-launched tasks meaningful generated titles.
• Keep oversized Fast integration results readable through conversation-scoped spill handles without exposing the service filesystem.

Roomote v0.41.0

0.41.0 (2026-08-24)

This release adds a shared task board, expands Fast delegation and preferences, delivers actionable pull-request CI updates and proactive operator alerts, clarifies inference costs, and gives the Brain richer pull-request context.

Highlights

• Coordinate team work from a shared board organized by task lifecycle, ownership, and context.
• Launch multiple independent tasks from one Fast conversation, choose their coding models, and consult focused reasoning subagents.
• Send actionable GitHub check failures back to linked tasks and their originating conversations.
• Warn operators about provider usage limits and deliver configuration issues to admins even without a configured channel.

Minor changes

• Break down, filter, and inspect inference costs by usage source so operators can attribute spend to features such as task routing and title generation.
• Let Fast choose an enabled coding model for each delegated task and consult advisor or judge subagents for focused reasoning without launching another workspace-backed task.
• Let Fast launch multiple independent Roomote tasks from one Slack or Discord turn while keeping each kickoff visible and preventing repeated identical requests from creating duplicate work.
• Notify linked Roomote tasks and their originating conversations when checks fail on a GitHub pull request, consolidating related failures and ignoring results from outdated commits.
• Warn operators before supported inference-provider usage limits are exhausted, and deliver platform configuration issues to linked deployment admins by direct message when no alert or Manager Channel is configured.
• Add a shared task board that groups work into Active, Needs input, Blocked / failed, and Done columns, with ownership, participant, activity, workspace, and pull-request context for coordinating team work.

Patch changes

• Give Brain pull-request pages the PR description and labels from GitHub, GitLab, Gitea, Bitbucket, and Azure DevOps so agents can recall why a change was made, not only its title.
• Enrich Brain pull-request pages with files changed, code areas, line totals, and review outcomes across supported source-control providers so agents can find the changes that affected a part of the codebase.
• Keep Fast conversations moving with clearer delegated replies, Slack task cards that resume after follow-ups, recovery from missing runtime dependencies and transient provider outages, and accurate guidance when a provider blocks a response.
• Show Fast response mode to every user in Personal Settings and apply each saved preference to eligible linked Slack and Discord messages without requiring deployment configuration.
• Trust only explicitly configured Roomote GitHub App slugs for managed pull-request activity, and keep Roomote attribution in pull-request descriptions to one canonical entry.
• Make onboarding easier to follow with clearer account, inference-provider, source-control, and environment guidance throughout the setup flow.
• Make pull-request feedback in Fast conversations reliable by delivering review activity consistently, keeping Slack review actions usable after delegated tasks settle, suppressing duplicate or stale results, and reducing notification pressure on provider quotas.
• Keep Brain task-memory history accurate by recording completed tasks reliably, distinguishing real ingestion gaps from completed backfills, and preventing the history-ingestion banner from returning after completion.
• Finish Slack task cards with the delegated agent's real result after Fast work settles, preserve actionable input requests, and keep terminal error cards stable while delivery retries.
• Give Fast and normal Roomote agents the semantic product release in their core prompt context while omitting channel tags and unavailable versions.

Roomote v0.40.2

0.40.2 (2026-08-22)

This patch improves Fast coordination, Slack task visibility, pull request review reliability, task feedback, and Brain preview operations.

Highlights

• Configure a separate model and reasoning level for Fast orchestration.
• Follow Fast-delegated Slack work through native streaming task cards and richer pull request updates.
• Keep pull request review notifications and closeout work moving safely through GitHub API limits.
• See renamed tasks immediately, get clearer billing pause guidance, and avoid empty Dependabot reports.

Patch changes

• Explain when billing has paused new task launches and direct users to check billing across the web app and chat integrations.
• Improve the Brain preview with truthful source and corpus status, full-corpus browsing, correct page metadata, more reliable Slack and GitHub ingestion, resilient nightly synthesis and fact extraction, and durable mirror credentials across redeploys.
• Keep scheduled Dependabot triage quiet when a successful scan finds no open alerts or follow-up work.
• Make Fast workflows easier to follow with native streaming Slack task cards, relayed coding progress, task-specific pull request updates, automated review feedback, terminal pull request status, actionable follow-up suggestions, and stronger recovery from long turns and transient provider failures.
• Keep pull request review notifications and closeout work reliable under GitHub API limits by caching unchanged reads, deferring quota-limited work, and ignoring unrelated external bot activity.
• Let deployment admins choose a separate model and reasoning level for Fast orchestration while keeping the coding model as the default fallback.
• Refresh task lists and search results immediately after a task is renamed so the new title appears without reloading the page.