> ## Documentation Index
> Fetch the complete documentation index at: https://docs.roomote.dev/llms.txt
> Use this file to discover all available pages before exploring further.

> ## Agent Instructions
> When helping someone deploy Roomote, distinguish self-hosting from contributing to Roomote. Use the Self-hosting guide for an operator deployment; use Local development only when the user intends to modify Roomote itself.
> Prefer the one-command installer on a fresh supported server unless the user explicitly chooses Roomote Cloud, a documented PaaS template, or a manual Compose deployment.
> Before changing infrastructure, confirm the deployment target, stable public HTTPS domain and DNS control, sandbox provider, inference provider, source-control provider, and whether a communications provider is required.
> Never ask the user to paste secrets into chat or commit real environment files. Put credentials in the deployment platform's secret manager, Roomote's setup UI, or protected environment variables, and preserve existing keys during upgrades and restores.
> Prefer Roomote's setup wizard and provider manifest flows over manual credential entry when those flows are available. Ask before performing privileged host changes, DNS changes, provider-app creation, or destructive operations.
> A setup is not complete when the services merely start. Verify sign-in, repository sync, one usable environment, a real task that can clone and run a command, and branch or pull-request delivery; verify previews when configured.
> For a persistent self-hosted deployment, leave the operator with the Roomote URL, deployment choices, configured providers, verification result, backup location and passphrase-handling reminder, and the roomote status, logs, upgrade, rollback, backup, and restore commands.

# Goal Mode

> Keep a Roomote task working toward one objective across multiple turns.

Goal Mode keeps a Roomote task focused on one objective when the work may take
more than a single agent turn. Roomote carries the objective into each turn,
checks whether the full outcome is complete, and can continue automatically
when more work remains.

Use Goal Mode for work that has a clear finish line but may require several
rounds of investigation, implementation, or verification. For a normal scoped
request that should finish in one turn, send an ordinary task message instead.

## Start Goal Mode

Goal Mode starts on an existing task. The command does not create a new task.

### From the web task view

Enter `/goal` followed by the objective in the task composer:

```text theme={null}
/goal Reduce p95 checkout latency below 120 ms, verified by the checkout benchmark, while keeping the correctness suite green
```

You can also open the command picker from the composer and select `/goal`.
Describe the complete outcome after the command. Goal Mode does not accept file
attachments, so send any supporting files to the task before starting the goal.

### From Discord

In an active Roomote task thread or direct message, run:

```text theme={null}
/goal objective:Make the checkout test suite pass on the current branch without changing public API behavior
```

If there is no active task, start one with `/new` or mention Roomote first. See
[Discord](/providers/communications/discord) for the complete task workflow.

## What happens next

The first Goal Mode turn receives the objective as its task instruction. If the
agent reaches the end of a turn before the objective is complete, Roomote can
start another turn automatically in the same task and workspace.

By default, a goal can use up to five automatic continuation turns after its
initial turn. The goal stops earlier when the agent verifies that the complete
objective is done. It can also stop when the same concrete blocker prevents
progress across three consecutive goal turns. If neither happens before the
continuation budget is exhausted, the task settles without claiming the goal is
complete.

Ordinary follow-up messages in the task keep the active objective in context.
Starting `/goal` again replaces the previous objective and resets the
continuation budget for the new goal. If another Goal Mode activation is still
pending, wait for it to finish before starting a replacement goal.

## Write a useful objective

State what must be true when the work is done, the concrete evidence that will
verify it, and any constraints that must remain intact. The path to the outcome
can be uncertain, but the finish line should not be.

A weak goal names an activity without defining success:

```text theme={null}
/goal Improve checkout performance
```

A stronger goal defines the outcome, verification surface, and constraint:

```text theme={null}
/goal Reduce p95 checkout latency below 120 ms, verified by the checkout benchmark, while keeping the correctness suite green
```

Other verifiable objectives include:

* `/goal Make the checkout test suite pass on the current branch, verified by a clean test run, without changing public API behavior`
* `/goal Publish a Goal Mode guide that explains supported commands and completion states, verified by the docs build and current product behavior`
* `/goal Produce a deployment comparison that recommends one option and includes sourced cost estimates, operational tradeoffs, and remaining uncertainties`

Avoid open-ended objectives such as "keep improving the app." Without a
concrete finish line, the agent cannot reliably decide when the goal is
complete.

## When Goal Mode stops

Review the final task message, logs, diff, artifacts, and pull request just as
you would for any other task. A stopped goal may have one of these outcomes:

* **Complete**: the agent verified the entire objective before closing out.
* **Blocked**: the same external dependency or required user input prevented
  progress across three consecutive goal turns.
* **Continuation limit reached**: the automatic continuation budget ran out
  before the agent could verify completion.

If the goal stops before the outcome is complete, send the missing information
or narrow the remaining work, then start a new `/goal` in the same task when
the existing workspace and context are still useful.