specrails-desktop 2.18.2 → 2.19.0

package/docs/guide/ja/pipeline/1-rails-and-jobs.md

@@ -23,7 +23,7 @@ SpecsBoard（左）            レール（右）
 ## スペックでレールを起動する
 
 1. **スペックカードをドラッグ**して、SpecsBoard からレールへ移します。スペックの ID がそのレールのスペック一覧に表示されます。（ドラッグが苦手ですか？ スペックカードの **レールに移動** ポップオーバーを使えば、レールごとにステータスのドットが表示されるので、ふさがっているレーンに作業を落としてしまう心配がありません。）
-2. レールヘッダーで **Loop を選びます**。レールは **Loop** を実行します — それがレールの行う作業そのものです。デフォルトは組み込みの `Implement` Loop ですが、`Batch`、`Ultracode`、あるいは自分で作ったカスタム Loop を選ぶこともできます。[Loop Builder](the-loop-builder) を参照してください。
+2. レールヘッダーで **Loop を選びます**。レールは **Loop** を実行します — それがレールの行う作業そのものです。デフォルトは組み込みの `Implement` Loop ですが、`Batch`、`Freestyle`、あるいは自分で作ったカスタム Loop を選ぶこともできます。[Loop Builder](the-loop-builder) を参照してください。
 3. **▶ Play を押します。**
 
 これだけです。レールがあなたのプロジェクト内で AI CLI プロセスを立ち上げ、パイプラインを開始します。
@@ -34,7 +34,7 @@ SpecsBoard（左）            レール（右）
 |---------|--------------|
 | **ステータスピル** | `idle`、`running`、`failed` のいずれか。「completed」という別ステータスはありません — ジョブがきれいに完了すると、レールは `idle` に戻ります。 |
 | **スペック一覧** | このレールに割り当てられた ID。さらにドラッグして追加したり、ドラッグして外したりできます。 |
-| **Loop ピッカー** | このレールが実行する Loop — 組み込み（`Implement` / `Batch` / `Ultracode`）かカスタム Loop。下の表を参照してください。レールごとに保持されます。 |
+| **Loop ピッカー** | このレールが実行する Loop — 組み込み（`Implement` / `Batch` / `Freestyle`）かカスタム Loop。下の表を参照してください。レールごとに保持されます。 |
 | **プロファイルピッカー** | どのエージェントプロファイルを実行するか（Claude レール限定）。プロジェクトにプロファイルが 1 つ以上あるときだけ表示されます。 |
 | **エンジンセレクター** | このレールをどのインストール済みプロバイダーで実行するか — Claude、Codex、Gemini。プロジェクトに複数のプロバイダーがある場合だけ表示されます。[レールごとのエンジン選択](picking-an-engine-per-rail) を参照してください。 |
 | **▶ Play / ■ Stop** | 開始またはキャンセル。 |
@@ -47,9 +47,9 @@ SpecsBoard（左）            レール（右）
 |------|---------|--------------|
 | **Implement** | `/specrails:implement` | レール上のすべてのスペックをまとめた 1 つのジョブ。Architect → Developer → Reviewer → Ship のフルパイプラインを実行します。日常的に使うデフォルトです。 |
 | **Batch** | `/specrails:batch-implement` | レール上のスペックを、依存関係を考慮したウェーブで順番に処理する 1 つのジョブ。関連する複数のスペックに最適です。 |
-| **Ultracode** | Ultracode | Claude が各スペックをパイプラインを**バイパス**して自律的に実装します。スペックごとに独立したジョブが 1 つずつ作られます。Claude 専用。 |
+| **Freestyle** | Freestyle | Claude が各スペックをパイプラインを**バイパス**して自律的に実装します。スペックごとに独立したジョブが 1 つずつ作られます。Claude 専用。 |
 
-Ultracode は少し毛色が違います。エージェントチェーンを飛ばし、生のスペックを Claude に渡してネイティブツールで作業させます。自由度が高いぶん、Play を押すとまず確認ダイアログが開き、レールごとのモデルピッカーで Haiku / Sonnet / Opus を選べます。Ultracode はレールのエンジンが Claude のときだけ表示されます。
+Freestyle は少し毛色が違います。エージェントチェーンを飛ばし、生のスペックを Claude に渡してネイティブツールで作業させます。自由度が高いぶん、Play を押すとまず確認ダイアログが開き、レールごとのモデルピッカーで Haiku / Sonnet / Opus を選べます。Freestyle はレールのエンジンが Claude のときだけ表示されます。
 
 組み込みのほかにも、**自分だけの Loop を作る** ことができます — verify → fix → verify のサイクルを目標が達成されるまで繰り返したり、AI ステップの間にシェルコマンドを連ねたり、さらにいろいろなことができます。そうしたカスタム Loop は同じ Loop ピッカーに表示されます。それが次の大きなアイデア、[Loop Builder](the-loop-builder) です。
 

package/docs/guide/ja/pipeline/2-the-job-detail-view.md

@@ -35,7 +35,7 @@ Architect ──► Developer ──► Reviewer ──► Ship
 | **Reviewer** | `sr-reviewer` | 出力をレビューします。 |
 | **Ship** | （状況による） | 最終仕上げ: テスト、コミット、PR ドラフト。 |
 
-どのフェーズをどのエージェントが担当するかは、プロジェクトの **エージェントプロファイル** で決まります。基本の 3 つ（`sr-architect`、`sr-developer`、`sr-reviewer`）は常に存在し、プロファイル内のルーティングルールでエージェントを追加したり、あるフェーズを担当するエージェントを差し替えたりできます。フェーズの進捗バーは、コマンドが実際にフェーズを定義しているときだけ表示されます — パイプラインをバイパスする Ultracode ジョブでは表示されません。
+どのフェーズをどのエージェントが担当するかは、プロジェクトの **エージェントプロファイル** で決まります。基本の 3 つ（`sr-architect`、`sr-developer`、`sr-reviewer`）は常に存在し、プロファイル内のルーティングルールでエージェントを追加したり、あるフェーズを担当するエージェントを差し替えたりできます。フェーズの進捗バーは、コマンドが実際にフェーズを定義しているときだけ表示されます — パイプラインをバイパスする Freestyle ジョブでは表示されません。
 
 ## ライブメトリクス — 設計からして誠実
 

package/docs/guide/ja/pipeline/4-picking-an-engine-per-rail.md

@@ -24,7 +24,7 @@ Specrails desktop は **Claude Code**、**Codex CLI**、**Gemini CLI** をいず
 
 | エンジン | こんなときに | 補足 |
 |--------|--------------------|-------|
-| **Claude** | フルの機能セットがほしいとき: エージェントプロファイル、Ultracode、ネイティブのコスト報告、最も充実したツールサポート。たいていの作業のデフォルト。 | **エージェントプロファイル**、**Ultracode**、いくつかの Claude 専用スペック機能（Contract Layer、SMASH）をサポートする唯一のエンジン。 |
+| **Claude** | フルの機能セットがほしいとき: エージェントプロファイル、Freestyle、ネイティブのコスト報告、最も充実したツールサポート。たいていの作業のデフォルト。 | **エージェントプロファイル**、**Freestyle**、いくつかの Claude 専用スペック機能（Contract Layer、SMASH）をサポートする唯一のエンジン。 |
 | **Codex** | OpenAI Codex CLI を好むとき、あるいはプロバイダー間で実装を比べたいとき。 | `codex` ≥ 0.128.0。ネイティブのコスト報告なし — アプリが料金表からコストを補います。プロファイルは適用されません。 |
 | **Gemini** | Google の Gemini CLI を使いたいとき、ネイティブのテレメトリがほしいとき、あるいは日常的なスペックを安く実行したいとき。 | `gemini` ≥ 0.11.0（`GEMINI_API_KEY` を設定）。ネイティブの OTLP テレメトリ。プロファイルは適用されません。 |
 
@@ -33,7 +33,7 @@ Specrails desktop は **Claude Code**、**Codex CLI**、**Gemini CLI** をいず
 いくつかの機能は Claude レールでしか動きません — 必要なら Claude を選んでください。
 
 - **エージェントプロファイル** — エージェントごとのモデルルーティング。Codex や Gemini のレールでは、実行は常にレガシーモードになり、選んだプロファイルは **無視されます**。プロファイルピッカーは Claude 以外のエンジンでは非表示になります。
-- **Ultracode（`Ultra` モード）** — 自律的でパイプラインをバイパスするモード。`Ultra` セグメントと、その Haiku/Sonnet/Opus のモデルピッカーは、レールのエンジンが Claude のときだけ表示されます。
+- **Freestyle** — 自律的でパイプラインをバイパスするモード。`Freestyle` セグメントと、その Haiku/Sonnet/Opus のモデルピッカーは、レールのエンジンが Claude のときだけ表示されます。
 - **Contract Layer と SMASH** — Claude 専用のスペック改良機能（これらはレールのオプションではなく Add-Spec のオプションですが、同じ制約が当てはまります）。
 
 プロジェクトが複数のエンジンを混在させると、右サイドバーにはインストール済みの **すべての** プロバイダーがサポートするセクションだけが表示されます — つまり、Claude 以外のプロバイダーを含むプロジェクトでは **エージェント** セクションがまるごと消えます。プロファイルは Claude 固有のものだからです。

package/docs/guide/ja/pipeline/5-the-loop-builder.md

@@ -1,6 +1,6 @@
 # Loop Builder
 
-**レールは Loop を実行します。** 組み込みの Loop（`Implement`、`Batch`、`Ultracode`）は日常的なケースをカバーしますが、**Loop Builder** を使えば自分だけの Loop を設計できます — 目標が達成されるまで繰り返す自動化のための、n8n スタイルのビジュアルエディターです。このページでは、Loop とは何か、どう作るのか、そしてレールでどう実行するのかを説明します。
+**レールは Loop を実行します。** 組み込みの Loop（`Implement`、`Batch`、`Freestyle`）は日常的なケースをカバーしますが、**Loop Builder** を使えば自分だけの Loop を設計できます — 目標が達成されるまで繰り返す自動化のための、n8n スタイルのビジュアルエディターです。このページでは、Loop とは何か、どう作るのか、そしてレールでどう実行するのかを説明します。
 
 ## Loop とレール — その関係
 
@@ -11,7 +11,7 @@
    ───────────────────────────             ─────────────
    Implement   （組み込み）                  レール 1
    Batch       （組み込み）      ► で選ぶ      Loop: Verify-until-green
-   Ultracode   （組み込み）                    ▶ Play
+   Freestyle   （組み込み）                    ▶ Play
    Verify-until-green （あなたの作ったもの）
 ```
 

package/docs/guide/pt/integrations/1-ai-providers.md

@@ -6,7 +6,7 @@ O Specrails não está preso a uma única IA. Todas as partes da app que falam c
 
 | Provider | CLI | Feito por | Notas |
 |---|---|---|---|
-| **Claude** | `claude` | Anthropic | O mais completo. O único provider para Agentes (perfis) e rails Ultracode, e para o Contract Refine. |
+| **Claude** | `claude` | Anthropic | O mais completo. O único provider para Agentes (perfis) e rails Freestyle, e para o Contract Refine. |
 | **Codex** | `codex` | OpenAI | Requer codex `0.128.0+`. Lê os seus servidores MCP a partir do `~/.codex/config.toml` global. |
 | **Gemini** | `gemini` | Google | Requer gemini `0.11.0+`. Usa telemetria nativa e um ficheiro de instruções `GEMINI.md`. |
 
@@ -43,7 +43,7 @@ A sua escolha é guardada por projeto, predefinida para o provider primário, pa
 Algumas funcionalidades são, por natureza, específicas do Claude, por isso ficam escondidas ou são ignoradas quando outro provider está em jogo:
 
 - **Agentes (perfis)** — o catálogo de agentes por projeto e o roteamento de modelos. Escondido em qualquer projeto que inclua um provider que não seja Claude.
-- **Rails Ultracode** — correm sempre no Claude.
+- **Rails Freestyle** — correm sempre no Claude.
 - **Contract Refine** — a passagem extra de "Contract Layer" sobre uma spec confirmada só corre quando o provider da conversa é o Claude.
 - **Modos avançados de Adicionar Spec** (SMASH / Contract Layer) — escondidos para motores que não sejam Claude.
 

package/docs/guide/pt/integrations/5-mcp-server.md

@@ -31,6 +31,25 @@ Num cliente como o Claude Desktop ou o Cursor, a configuração tem este aspeto:
 
 Os clientes que suportam servidores MCP HTTP remotos podem, em alternativa, apontar diretamente para `http://127.0.0.1:4200/api/mcp` com o token do painel.
 
+### Pelo terminal: Claude Code, Gemini CLI, Codex CLI
+
+Copie seu token em **Configurações ▸ MCP ▸ Copiar token** e depois:
+
+```bash
+# Claude Code
+claude mcp add --transport http specrails http://localhost:4200/api/mcp \
+  --header "X-Desktop-Token: <seu token>"
+
+# Gemini CLI
+gemini mcp add --transport http specrails http://localhost:4200/api/mcp \
+  --header "X-Desktop-Token: <seu token>"
+
+# Codex CLI (stdio — registre o comando do bridge mostrado em Configurações ▸ MCP)
+codex mcp add specrails -- <comando do bridge de Configurações ▸ MCP>
+```
+
+O cabeçalho `Authorization: Bearer <token>` também funciona. Se você mudou a porta do app, troque `4200`.
+
 Uma vez ligado, o seu assistente vê cerca de **18 ferramentas** que cobrem a app inteira — projetos, specs, rails e trabalhos, chat/Explore, agentes, plugins, Jira, loops, o explorador de código, análises, definições — mais uma ferramenta de **guia** incorporada que lê primeiro, para que perceba como o Specrails funciona sem que lhe explique seja o que for.
 
 ## O que pode fazer com ele
@@ -51,7 +70,7 @@ Mantenha o **Destrutivo** desativado e ele pode trabalhar a noite toda sem nunca
 > *"Verifica todos os meus projetos. Diz-me quais têm specs no backlog e nenhum rail a correr, e arranca o de prioridade mais alta em cada um."*
 
 **Sem usar as mãos enquanto programa.** Conduza o Specrails a partir do seu editor ou por voz, sem trocar de janela:
-> *"Lança o rail 0 em modo ultracode com o Opus para o ticket #42 e avisa-me quando estiver pronto."*
+> *"Lança o rail 0 em modo Freestyle com o Opus para o ticket #42 e avisa-me quando estiver pronto."*
 
 **Pergunte sobre custos e histórico.** As suas análises, em linguagem simples:
 > *"Onde gastei mais em IA esta semana, por projeto e por modelo? Mostra-me os cinco tickets mais caros."*

package/docs/guide/pt/pipeline/1-rails-and-jobs.md

@@ -23,7 +23,7 @@ Você pode ter vários rails para organizar o trabalho em pistas nomeadas (uma p
 ## Lançando um rail sobre uma spec
 
 1. **Arraste um cartão de spec** do SpecsBoard para um rail. O ID da spec aparece na lista de specs do rail. (Prefere não arrastar? Use o popover **Mover para o rail** no cartão da spec — ele mostra um indicador de status por rail, para você não soltar trabalho numa pista ocupada.)
-2. **Escolha um Loop** no cabeçalho do rail. Um rail roda um **Loop** — é o trabalho que ele realiza. O padrão é o Loop `Implement` embutido; você também pode escolher `Batch`, `Ultracode` ou um loop personalizado que você mesmo construiu. Veja [O Loop Builder](the-loop-builder).
+2. **Escolha um Loop** no cabeçalho do rail. Um rail roda um **Loop** — é o trabalho que ele realiza. O padrão é o Loop `Implement` embutido; você também pode escolher `Batch`, `Freestyle` ou um loop personalizado que você mesmo construiu. Veja [O Loop Builder](the-loop-builder).
 3. **Aperte ▶ Play.**
 
 É isso. O rail sobe um processo de CLI de IA no seu projeto e começa o pipeline.
@@ -34,7 +34,7 @@ Você pode ter vários rails para organizar o trabalho em pistas nomeadas (uma p
 |---------|--------------|
 | **Pílula de status** | `idle`, `running` ou `failed`. Não há um "completed" separado — um rail volta para `idle` quando seu job termina sem erros. |
 | **Lista de specs** | Os IDs atribuídos a este rail. Arraste mais para dentro, arraste para fora para desanexar. |
-| **Seletor de Loop** | O Loop que este rail roda — um embutido (`Implement` / `Batch` / `Ultracode`) ou um loop personalizado. Veja a tabela abaixo. Persistido por rail. |
+| **Seletor de Loop** | O Loop que este rail roda — um embutido (`Implement` / `Batch` / `Freestyle`) ou um loop personalizado. Veja a tabela abaixo. Persistido por rail. |
 | **Seletor de perfil** | Qual perfil de agente roda (apenas rails Claude). Só aparece quando o projeto tem ao menos um perfil. |
 | **Seletor de motor** | Qual provedor instalado roda este rail — Claude, Codex ou Gemini. Só é renderizado quando o projeto tem mais de um provedor. Veja [Escolhendo um motor por rail](picking-an-engine-per-rail). |
 | **▶ Play / ■ Stop** | Iniciar ou cancelar. |
@@ -47,9 +47,9 @@ Um rail roda um **Loop** — a receita do trabalho. Três loops são **embutidos
 |------|---------|--------------|
 | **Implement** | `/specrails:implement` | Um job cobrindo todas as specs do rail. Roda o pipeline completo Architect → Developer → Reviewer → Ship. O padrão do dia a dia. |
 | **Batch** | `/specrails:batch-implement` | Um job que percorre as specs do rail sequencialmente, em ondas que respeitam as dependências. Melhor para várias specs relacionadas. |
-| **Ultracode** | Ultracode | O Claude implementa cada spec de forma autônoma, **ignorando** o pipeline. Um job independente por spec. Apenas Claude. |
+| **Freestyle** | Freestyle | O Claude implementa cada spec de forma autônoma, **ignorando** o pipeline. Um job independente por spec. Apenas Claude. |
 
-O Ultracode é o caso atípico: ele pula a cadeia de agentes e entrega a spec crua ao Claude para trabalhar com suas ferramentas nativas. É aberto, então apertar Play abre primeiro uma confirmação, e um seletor de modelo por rail deixa você escolher Haiku / Sonnet / Opus. Ele só aparece quando o motor do rail é o Claude.
+O Freestyle é o caso atípico: ele pula a cadeia de agentes e entrega a spec crua ao Claude para trabalhar com suas ferramentas nativas. É aberto, então apertar Play abre primeiro uma confirmação, e um seletor de modelo por rail deixa você escolher Haiku / Sonnet / Opus. Ele só aparece quando o motor do rail é o Claude.
 
 Além dos embutidos, você pode **construir seus próprios loops** — repetir um ciclo verify → fix → verify até atingir uma meta, encadear comandos de shell entre AI Steps e muito mais. Esses loops personalizados aparecem no mesmo seletor de Loop. Essa é a próxima grande ideia: [O Loop Builder](the-loop-builder).
 

package/docs/guide/pt/pipeline/2-the-job-detail-view.md

@@ -35,7 +35,7 @@ Cada fase é um agente especializado que o motor do rail invoca na diretoria do
 | **Reviewer** | `sr-reviewer` | Revê o resultado. |
 | **Ship** | (varia) | Finalização: testes, commit, rascunho de PR. |
 
-Que agente trata de cada fase é decidido pelo **perfil de agentes** do projeto. O trio base (`sr-architect`, `sr-developer`, `sr-reviewer`) está sempre presente; as regras de encaminhamento de um perfil podem acrescentar agentes ou trocar qual deles corre uma fase. A barra de progresso das fases só aparece quando o comando define mesmo fases — os jobs Ultracode (que ignoram o pipeline) não mostram nenhuma.
+Que agente trata de cada fase é decidido pelo **perfil de agentes** do projeto. O trio base (`sr-architect`, `sr-developer`, `sr-reviewer`) está sempre presente; as regras de encaminhamento de um perfil podem acrescentar agentes ou trocar qual deles corre uma fase. A barra de progresso das fases só aparece quando o comando define mesmo fases — os jobs Freestyle (que ignoram o pipeline) não mostram nenhuma.
 
 ## Métricas ao vivo — honestas por princípio
 

package/docs/guide/pt/pipeline/4-picking-an-engine-per-rail.md

@@ -24,7 +24,7 @@ Os três correm os pipelines standard **Implement** e **Batch**. Aqui fica um gu
 
 | Motor | Recorra a ele quando… | Notas |
 |--------|--------------------|-------|
-| **Claude** | Quer o conjunto completo de funcionalidades: perfis de agentes, Ultracode, reporte de custo nativo, o suporte de ferramentas mais rico. O default para a maioria do trabalho. | O único motor que suporta **perfis de agentes**, **Ultracode** e algumas funcionalidades de spec exclusivas do Claude (Contract Layer, SMASH). |
+| **Claude** | Quer o conjunto completo de funcionalidades: perfis de agentes, Freestyle, reporte de custo nativo, o suporte de ferramentas mais rico. O default para a maioria do trabalho. | O único motor que suporta **perfis de agentes**, **Freestyle** e algumas funcionalidades de spec exclusivas do Claude (Contract Layer, SMASH). |
 | **Codex** | Prefere o Codex CLI da OpenAI ou quer comparar implementações entre fornecedores. | `codex` ≥ 0.128.0. Sem reporte de custo nativo — a app preenche o custo a partir da sua tabela de preços. Os perfis não se aplicam. |
 | **Gemini** | Quer o Gemini CLI da Google, telemetria nativa ou uma execução mais barata para specs de rotina. | `gemini` ≥ 0.11.0 (defina `GEMINI_API_KEY`). Telemetria OTLP nativa. Os perfis não se aplicam. |
 
@@ -33,7 +33,7 @@ Os três correm os pipelines standard **Implement** e **Batch**. Aqui fica um gu
 Algumas coisas só funcionam em rails Claude — escolha o Claude se precisar delas:
 
 - **Perfis de agentes** — encaminhamento de modelo por agente. Em rails Codex ou Gemini a execução usa sempre o modo legado e qualquer perfil selecionado é **ignorado**. O seletor de perfil fica escondido nos motores que não são Claude.
-- **Ultracode (modo `Ultra`)** — o modo autónomo que ignora o pipeline. O segmento `Ultra` e o seu seletor de modelo Haiku/Sonnet/Opus só aparecem quando o motor do rail é o Claude.
+- **Freestyle** — o modo autónomo que ignora o pipeline. O segmento `Freestyle` e o seu seletor de modelo Haiku/Sonnet/Opus só aparecem quando o motor do rail é o Claude.
 - **Contract Layer e SMASH** — funcionalidades de refinamento de spec exclusivas do Claude (são opções de Add Spec, não opções de rail, mas aplica-se a mesma restrição).
 
 Se um projeto mistura motores, a barra lateral direita só mostra as secções que **todos** os fornecedores instalados suportam — por isso a secção **Agentes** desaparece por completo num projeto que inclua qualquer fornecedor que não seja Claude, porque os perfis são específicos do Claude.

package/docs/guide/pt/pipeline/5-the-loop-builder.md

@@ -1,6 +1,6 @@
 # O Loop Builder
 
-Um **rail roda um Loop**. Os loops embutidos (`Implement`, `Batch`, `Ultracode`) cobrem os casos do dia a dia, mas o **Loop Builder** deixa você desenhar os seus próprios — um editor visual, no estilo n8n, para automação que se repete até atingir uma meta. Esta página explica o que é um loop, como construir um e como rodá-lo em um rail.
+Um **rail roda um Loop**. Os loops embutidos (`Implement`, `Batch`, `Freestyle`) cobrem os casos do dia a dia, mas o **Loop Builder** deixa você desenhar os seus próprios — um editor visual, no estilo n8n, para automação que se repete até atingir uma meta. Esta página explica o que é um loop, como construir um e como rodá-lo em um rail.
 
 ## Loops e rails — a relação
 
@@ -11,7 +11,7 @@ Um **loop** é a *receita* do trabalho; um **rail** é a *pista* que o roda cont
    ───────────────────────────             ─────────────
    Implement   (embutido)                  Rail 1
    Batch       (embutido)      escolha ►      Loop: Verify-until-green
-   Ultracode   (embutido)                     ▶ Play
+   Freestyle   (embutido)                     ▶ Play
    Verify-until-green (seu)
 ```
 

package/docs/guide/zh/integrations/1-ai-providers.md

@@ -6,7 +6,7 @@ Specrails 并不绑定在某一个 AI 上。应用里所有会调用 AI 的环
 
 | 提供方 | CLI | 出品方 | 说明 |
 |---|---|---|---|
-| **Claude** | `claude` | Anthropic | 功能最完整。Agents（profile）、Ultracode rail 以及 Contract Refine 都只有它支持。 |
+| **Claude** | `claude` | Anthropic | 功能最完整。Agents（profile）、Freestyle rail 以及 Contract Refine 都只有它支持。 |
 | **Codex** | `codex` | OpenAI | 需要 codex `0.128.0+`。从你的全局 `~/.codex/config.toml` 读取 MCP 服务器。 |
 | **Gemini** | `gemini` | Google | 需要 gemini `0.11.0+`。使用原生遥测，以及 `GEMINI.md` 指令文件。 |
 
@@ -43,7 +43,7 @@ Specrails 并不绑定在某一个 AI 上。应用里所有会调用 AI 的环
 有少数功能天生就是 Claude 专属的，因此当其他提供方参与时，它们要么被隐藏、要么被跳过：
 
 - **Agents（profile）**——按项目的 agent 目录与模型路由。在任何包含非 Claude 提供方的项目上都会隐藏。
-- **Ultracode rail**——始终在 Claude 上运行。
+- **Freestyle rail**——始终在 Claude 上运行。
 - **Contract Refine**——对已提交规格追加的「Contract Layer」环节，只有当对话的提供方是 Claude 时才会运行。
 - **Add Spec 高级模式**（SMASH / Contract Layer）——对非 Claude 引擎隐藏。
 

package/docs/guide/zh/integrations/5-mcp-server.md

@@ -31,6 +31,25 @@ Specrails 可以把**自己**暴露给任何会说 [Model Context Protocol](http
 
 支持远程 HTTP MCP 服务器的客户端，则可以直接指向 `http://127.0.0.1:4200/api/mcp`，并配上面板里的令牌。
 
+### 从终端连接: Claude Code、Gemini CLI、Codex CLI
+
+先在 **设置 ▸ MCP ▸ 复制令牌** 复制令牌, 然后:
+
+```bash
+# Claude Code
+claude mcp add --transport http specrails http://localhost:4200/api/mcp \
+  --header "X-Desktop-Token: <你的令牌>"
+
+# Gemini CLI
+gemini mcp add --transport http specrails http://localhost:4200/api/mcp \
+  --header "X-Desktop-Token: <你的令牌>"
+
+# Codex CLI (stdio — 注册 设置 ▸ MCP 中显示的 bridge 命令)
+codex mcp add specrails -- <设置 ▸ MCP 中的 bridge 命令>
+```
+
+也可以使用 `Authorization: Bearer <token>` 请求头。如果修改过应用端口, 请替换 `4200`。
+
 一旦连上，你的助手会看到大约 **18 个工具**，覆盖整个应用——项目、规格、rail 和任务、聊天 / Explore、agent、插件、Jira、loop、代码浏览器、分析、设置——外加一个内置的**指南（guide）**工具，它会先读这个工具，从而无需你解释任何东西就能理解 Specrails 是怎么运作的。
 
 ## 你能用它做些什么
@@ -51,7 +70,7 @@ Specrails 可以把**自己**暴露给任何会说 [Model Context Protocol](http
 > *「检查我所有的项目。告诉我哪些在 backlog 里有规格却没有 rail 在跑，并在每个项目里启动优先级最高的那一个。」*
 
 **写代码时不用动手。** 从你的编辑器里或用语音来驱动 Specrails，无需切换窗口：
-> *「用 Opus、以 ultracode 模式在 rail 0 上为任务 #42 启动一条 rail，跑完了告诉我。」*
+> *「用 Opus、以 Freestyle 模式在 rail 0 上为任务 #42 启动一条 rail，跑完了告诉我。」*
 
 **询问费用和历史。** 用大白话查你的分析数据：
 > *「我这周在 AI 上花得最多的是哪里，按项目、按模型分别列出来？给我看最贵的五个任务。」*

package/docs/guide/zh/pipeline/1-rails-and-jobs.md

@@ -23,7 +23,7 @@ rail 是一条**执行通道**。你从 SpecsBoard 上拖一张 spec 卡片放
 ## 在某个 spec 上启动一条 rail
 
 1. **把一张 spec 卡片拖**到某条 rail 上。该 spec 的 ID 会出现在这条 rail 的 spec 列表里。（不想拖？用 spec 卡片上的 **放入 Rail** 弹窗——它会为每条 rail 显示一个状态圆点，避免你把活儿丢进一条正忙的通道。）
-2. **在 rail 头部挑一个 Loop。** 一条 rail 运行的是一个 **Loop**——也就是它要做的活儿。默认是内置的 `Implement` loop；你也可以挑 `Batch`、`Ultracode`，或者你自己搭的某个自定义 loop。见 [Loop Builder](the-loop-builder)。
+2. **在 rail 头部挑一个 Loop。** 一条 rail 运行的是一个 **Loop**——也就是它要做的活儿。默认是内置的 `Implement` loop；你也可以挑 `Batch`、`Freestyle`，或者你自己搭的某个自定义 loop。见 [Loop Builder](the-loop-builder)。
 3. **按下 ▶ Play。**
 
 就这么简单。rail 会在你的项目里启动一个 AI CLI 进程，开始跑流水线。
@@ -34,7 +34,7 @@ rail 是一条**执行通道**。你从 SpecsBoard 上拖一张 spec 卡片放
 |---------|--------------|
 | **状态标签** | `idle`、`running` 或 `failed`。这里没有单独的"completed"——任务干净地跑完后，rail 会回到 `idle`。 |
 | **spec 列表** | 分配给这条 rail 的 ID。可以再拖进来，也可以拖出去解除关联。 |
-| **Loop 选择器** | 这条 rail 运行的 Loop——内置的（`Implement` / `Batch` / `Ultracode`）或某个自定义 loop。见下表。按 rail 单独记忆。 |
+| **Loop 选择器** | 这条 rail 运行的 Loop——内置的（`Implement` / `Batch` / `Freestyle`）或某个自定义 loop。见下表。按 rail 单独记忆。 |
 | **Profile 选择器** | 运行哪个 Agent Profile（仅限 Claude rail）。只有当项目至少有一个 Profile 时才会出现。 |
 | **引擎选择器** | 这条 rail 用哪个已安装的提供方来跑——Claude、Codex 或 Gemini。仅当项目装有不止一个提供方时才显示。见 [为每条 rail 选择引擎](picking-an-engine-per-rail)。 |
 | **▶ Play / ■ Stop** | 启动或取消。 |
@@ -47,9 +47,9 @@ rail 是一条**执行通道**。你从 SpecsBoard 上拖一张 spec 卡片放
 |------|---------|--------------|
 | **Implement** | `/specrails:implement` | 一个任务覆盖这条 rail 上的所有 spec。跑完整的 Architect → Developer → Reviewer → Ship 流水线。日常默认选项。 |
 | **Batch** | `/specrails:batch-implement` | 一个任务，按依赖感知的批次（wave）依次处理 rail 上的各个 spec。最适合一组相关的 spec。 |
-| **Ultracode** | Ultracode | Claude 自主实现每个 spec，**绕过**流水线。每个 spec 一个独立任务。仅限 Claude。 |
+| **Freestyle** | Freestyle | Claude 自主实现每个 spec，**绕过**流水线。每个 spec 一个独立任务。仅限 Claude。 |
 
-Ultracode 是个特例：它跳过 Agent 链条，把原始 spec 直接交给 Claude，让它用自己的原生工具去做。因为它比较"放飞"，所以按下 Play 会先弹出一个确认框，而且有一个按 rail 单独的模型选择器，让你在 Haiku / Sonnet / Opus 之间挑选。只有当 rail 的引擎是 Claude 时它才会出现。
+Freestyle 是个特例：它跳过 Agent 链条，把原始 spec 直接交给 Claude，让它用自己的原生工具去做。因为它比较"放飞"，所以按下 Play 会先弹出一个确认框，而且有一个按 rail 单独的模型选择器，让你在 Haiku / Sonnet / Opus 之间挑选。只有当 rail 的引擎是 Claude 时它才会出现。
 
 除了这些内置 loop，你还可以**搭建自己的 loop**——重复一个 verify → fix → verify 的循环直到目标达成、在 AI 步骤之间串联 shell 命令，等等。这些自定义 loop 会出现在同一个 Loop 选择器里。这就是下一个大点子：[Loop Builder](the-loop-builder)。
 

package/docs/guide/zh/pipeline/2-the-job-detail-view.md

@@ -35,7 +35,7 @@ Architect ──► Developer ──► Reviewer ──► Ship
 | **Reviewer** | `sr-reviewer` | 审查产出。 |
 | **Ship** | （视情况而定） | 收尾：测试、提交、起草 PR。 |
 
-每个阶段由哪个 Agent 来处理，是由项目的 **Agent Profile** 决定的。基线三人组（`sr-architect`、`sr-developer`、`sr-reviewer`）始终在场；Profile 里的路由规则可以添加 Agent，或替换某个阶段由谁来跑。只有当命令确实定义了阶段时，阶段进度条才会出现——Ultracode 任务（绕过了流水线）不会显示进度条。
+每个阶段由哪个 Agent 来处理，是由项目的 **Agent Profile** 决定的。基线三人组（`sr-architect`、`sr-developer`、`sr-reviewer`）始终在场；Profile 里的路由规则可以添加 Agent，或替换某个阶段由谁来跑。只有当命令确实定义了阶段时，阶段进度条才会出现——Freestyle 任务（绕过了流水线）不会显示进度条。
 
 ## 实时指标——为诚实而设计
 

package/docs/guide/zh/pipeline/4-picking-an-engine-per-rail.md

@@ -24,7 +24,7 @@ Specrails desktop 把 **Claude Code**、**Codex CLI** 和 **Gemini CLI** 都当
 
 | 引擎 | 在什么情况下选它…… | 说明 |
 |--------|--------------------|-------|
-| **Claude** | 你想要全套功能：Agent Profile、Ultracode、原生成本上报、最丰富的工具支持。大多数工作的默认之选。 | 唯一支持 **Agent Profile**、**Ultracode** 以及几个 Claude 专属 spec 功能（Contract Layer、SMASH）的引擎。 |
+| **Claude** | 你想要全套功能：Agent Profile、Freestyle、原生成本上报、最丰富的工具支持。大多数工作的默认之选。 | 唯一支持 **Agent Profile**、**Freestyle** 以及几个 Claude 专属 spec 功能（Contract Layer、SMASH）的引擎。 |
 | **Codex** | 你更喜欢 OpenAI Codex CLI，或想跨提供方对比实现。 | `codex` ≥ 0.128.0。无原生成本上报——应用会用自己的价格表来补上成本。Profile 不适用。 |
 | **Gemini** | 你想用 Google 的 Gemini CLI、原生遥测，或为常规 spec 跑得更省钱。 | `gemini` ≥ 0.11.0（需设置 `GEMINI_API_KEY`）。原生 OTLP 遥测。Profile 不适用。 |
 
@@ -33,7 +33,7 @@ Specrails desktop 把 **Claude Code**、**Codex CLI** 和 **Gemini CLI** 都当
 有几样东西只在 Claude rail 上能用——如果你需要它们，就选 Claude：
 
 - **Agent Profile**——按 Agent 的模型路由。在 Codex 或 Gemini rail 上，运行始终走传统模式，所选的任何 Profile 都会被**忽略**。非 Claude 引擎下 Profile 选择器会被隐藏。
-- **Ultracode（`Ultra` 模式）**——那个自主的、绕过流水线的模式。`Ultra` 分段及其 Haiku/Sonnet/Opus 模型选择器，只有当 rail 的引擎是 Claude 时才会出现。
+- **Freestyle**——那个自主的、绕过流水线的模式。`Freestyle` 分段及其 Haiku/Sonnet/Opus 模型选择器，只有当 rail 的引擎是 Claude 时才会出现。
 - **Contract Layer 与 SMASH**——Claude 专属的 spec 优化功能（这些是 Add Spec 的选项，不是 rail 的选项，但同样的限制适用）。
 
 如果一个项目混用了引擎，右侧栏只会显示**每一个**已安装提供方都支持的区块——所以在一个含有任何非 Claude 提供方的项目上，**Agents** 区会彻底消失，因为 Profile 是 Claude 特有的。

package/docs/guide/zh/pipeline/5-the-loop-builder.md

@@ -1,6 +1,6 @@
 # Loop Builder
 
-**一条 rail 运行的是一个 Loop。** 内置的那些 loop（`Implement`、`Batch`、`Ultracode`）覆盖了日常场景，但 **Loop Builder** 让你能设计自己的——一个可视化的、n8n 风格的编辑器，用来做那种"重复执行直到目标达成"的自动化。本页会讲清楚什么是 loop、怎么搭一个，以及怎么在 rail 上运行它。
+**一条 rail 运行的是一个 Loop。** 内置的那些 loop（`Implement`、`Batch`、`Freestyle`）覆盖了日常场景，但 **Loop Builder** 让你能设计自己的——一个可视化的、n8n 风格的编辑器，用来做那种"重复执行直到目标达成"的自动化。本页会讲清楚什么是 loop、怎么搭一个，以及怎么在 rail 上运行它。
 
 ## Loop 与 rail——它们的关系
 
@@ -11,7 +11,7 @@
    ───────────────────────────             ─────────────
    Implement   (内置)                       Rail 1
    Batch       (内置)          在此挑选 ►       Loop: Verify-until-green
-   Ultracode   (内置)                          ▶ Play
+   Freestyle   (内置)                          ▶ Play
    Verify-until-green (你的)
 ```