specrails-desktop 2.57.1 → 2.58.0

package/client/dist/assets/settings-HZSu-K4l.js

@@ -1 +0,0 @@
-import{r as e}from"./rolldown-runtime-CNC7AqOf.js";var t=e({appUpdate:()=>v,appearance:()=>m,budget:()=>c,codeSection:()=>p,coreUpdate:()=>_,default:()=>C,desktop:()=>l,effects:()=>S,errors:()=>i,freestylePrePrompt:()=>s,integrationBranch:()=>b,language:()=>n,mobile:()=>h,notifications:()=>u,page:()=>r,pairWeb:()=>g,prePrompt:()=>o,projectDialog:()=>y,telemetry:()=>a,terminal:()=>f,webhooks:()=>d,worktreeEnv:()=>x}),n={title:`Language`,description:`Desktop-wide UI language. Applies instantly — no restart needed.`,selectLabel:`Interface language`,updateFailed:`Could not save the language preference`},r={title:`Project Settings`},i={saveFailed:`Failed to save: {{message}}`},a={title:`Pipeline Telemetry`,description:`Capture token usage, phase durations, and subagent activity for diagnostic export. On by default.`,toggleLabel:`Enable pipeline telemetry`,toggleDescription:`When on, OTEL data from pipeline jobs is captured locally. Use the <mono>Export diagnostic</mono> button on any job card to download.`,enabled:`Pipeline telemetry enabled`,disabled:`Pipeline telemetry disabled`,saveFailed:`Failed to save telemetry setting`},o={title:`Rail Pre-prompt`,description:`Extra project-specific instructions appended to implement and batch-implement rail jobs after the ticket context and before execution.`,label:`Pre-prompt`,placeholder:`Example: Prefer incremental changes, keep migrations backward compatible, and add tests for every rail change.`,helper:`Use this for stable project guidance that should accompany every rail implementation run.`,saveButton:`Save pre-prompt`,cleared:`Pre-prompt cleared`,saved:`Pre-prompt saved`,saveFailed:`Failed to save pre-prompt`},s={title:`Freestyle pre-prompt`,description:`Instruction sent to the selected provider in Freestyle. Freestyle skips the OpenSpec pipeline — it hands the provider this pre-prompt plus the spec text and lets it implement autonomously. Leave blank to use the built-in default.`,label:`Freestyle pre-prompt`,placeholder:`Leave blank to use the default Freestyle instruction.`,helper:`The spec text is appended automatically after this pre-prompt. Empty = default.`,saveButton:`Save Freestyle pre-prompt`,resetToDefault:`Freestyle pre-prompt reset to default`,saved:`Freestyle pre-prompt saved`,saveFailed:`Failed to save Freestyle pre-prompt`},c={title:`Budget`,description:`Set a daily spend cap for this project. The queue auto-pauses when the limit is hit.`,dailyLabel:`Daily budget (USD)`,dailyHelper:`Leave blank to disable. Spend is calculated over the last 24 hours.`,dailyPlaceholder:`e.g. 5.00`,perJobLabel:`Per-job cost alert (USD)`,perJobHelper:`Alert when a single job in this project exceeds this amount.`,perJobPlaceholder:`e.g. 0.50`,invalidNumber:`Enter a positive number or leave blank to disable`,dailyRemoved:`Daily budget removed`,dailySet:"Daily budget set to ${{amount}}",perJobAlertDisabled:`Per-job cost alert disabled`,alertSet:"Alert set for jobs over ${{amount}}",saveBudgetFailed:`Failed to save budget`,saveThresholdFailed:`Failed to save threshold`},l={nav:{appearance:`Appearance`,specrailsAgents:`AI providers`,code:`Code`,terminal:`Terminal`,updates:`Updates`,mobile:`Mobile`,mcp:`MCP`,projects:`Projects`,advanced:`Advanced`,webhooks:`Webhooks`,about:`About`,effects:`Effects`},title:`Desktop Settings`,description:`Manage registered projects and view Desktop information.`,registeredProjects:`Registered Projects`,noProjects:`No projects registered yet`,techUrlDescription:`Base URL for the specrails-tech API (default: http://localhost:3000)`,techUrlSaved:`specrails-tech URL saved`,techUrlSaveFailed:`Failed to save URL`,budgetAlertsHeading:`Budget & Alerts`,dailyBudgetLabel:`Desktop daily budget (USD)`,dailyBudgetHelper:`Global daily spend limit across all projects. Queues auto-pause when exceeded.`,dailyBudgetPlaceholder:`e.g. 10.00`,perJobHelper:`Alert when a single job exceeds this amount. Leave blank to disable.`,costAlertsDisabled:`Cost alerts disabled`,dailyBudgetRemoved:`Desktop daily budget removed`,dailyBudgetSet:"Desktop daily budget set to ${{amount}}",dailyBudgetSaveFailed:`Failed to save Desktop daily budget`,projectRemoved:`Project removed`,projectRemoveFailed:`Failed to remove project`,onboardingHeading:`Onboarding`,platformTour:`Platform Tour`,platformTourDescription:`Replay the welcome wizard to review key features.`,replayTour:`Replay Tour`,terminalPanelHeading:`Terminal Panel`,infoHeading:`Desktop Information`,infoPort:`Port`,infoProjects:`Projects`,infoDb:`Desktop DB`},u={heading:`OS Notifications`,description:`Show native desktop notifications when jobs complete or fail. Notifications only appear when the tab is not focused.`,enableLabel:`Enable OS Notifications`,notifyOn:`Notify on:`,filterAll:`All (completed & failed)`,filterCompleted:`Completed only`,filterFailed:`Failed only`,enabledToast:`OS notifications enabled`,disabledToast:`OS notifications disabled`},d={heading:`Outbound Webhooks`,description:`Notify external tools (Slack, Zapier, CI/CD) on Desktop events. Requests are signed via <code>X-Specrails-Signature</code> when a secret is set.`,eventJobCompleted:`Job completed`,eventJobFailed:`Job failed`,eventDailyBudgetExceeded:`Daily budget exceeded`,statusOn:`on`,statusOff:`off`,disable:`Disable`,enable:`Enable`,sendTestPing:`Send test ping`,addHeading:`Add webhook`,secretPlaceholder:`Signing secret (optional)`,addButton:`Add Webhook`,urlRequired:`URL is required`,selectEvent:`Select at least one event`,added:`Webhook added`,addFailed:`Failed to add webhook`,updateFailed:`Failed to update webhook`,removed:`Webhook removed`,removeFailed:`Failed to remove webhook`,testPingSent:`Test ping sent`,testPingFailed:`Failed to send test ping`},f={title:`Terminal panel`,desktopDescription:`Desktop-wide defaults applied to every project unless a per-project override is set.`,projectDescription:`Per-project overrides for the terminal panel. Leave a field unchanged to inherit the Desktop default.`,fontFamily:`Font family`,fontSize:`Font size ({{min}}–{{max}})`,renderMode:`Render mode`,copyOnSelect:`Copy on select`,shellIntegration:`Shell integration (OSC 133 marks)`,notifyLongRunning:`Notify on long-running commands`,longCommandThreshold:`Long-command threshold (ms)`,imageRendering:`Inline image rendering (Sixel + iTerm2)`,browserShortcutUrl:`Browser shortcut URL`,quickScript:`Quick script (pasted into active terminal — Enter manually)`,reset:`Reset`,unsavedChanges:`Unsaved changes`,clearOverride:`Clear override`,clear:`Clear`,inheritingDefault:`Inheriting Desktop default`,nothingToSave:`Nothing to save`,saved:`Terminal settings saved`},p={heading:`Code section`,summaryLanguage:`Summary language`,monthlyBudget:`Monthly budget (USD)`,budgetHelper:"Cap on `surface=file-summary` spend per calendar month. User-initiated regenerations can override."},m={taglines:{dracula:`The original — dark purple-tinted with vivid neon accents`,"aurora-light":`Premium light — Linear-inspired indigo on warm off-white`,"obsidian-dark":`Premium dark — near-black blue-tinted with electric accents`,specrails:`Brand theme — deep navy-indigo with saturated cyan accents`,"code-rain":`Phosphor terminal — soft mint on green-tinted near-black`,galaxy:`Deep-space blue with a glowing blade trail`},heading:`Appearance`,themeGroupLabel:`Theme`,currentlyActive:`Currently active`,updateFailed:`Failed to update theme`},h={heading:`Mobile companion`,description:`Control Specrails from the SpecRails Companion app on your phone, 100% over your local network. Off by default.`,accessOn:`Mobile access on`,accessOff:`Mobile access off`,listeningOnPort:`Listening on port {{port}}`,notListening:`Not listening`,turnOn:`Turn on`,turnOff:`Turn off`,pairWebDevice:`Pair web companion`,reset:`Reset`,resetConfirm:`Reset the mobile identity? Every paired device will be revoked and must pair again.`,identityReset:`Mobile identity reset`,enableFailed:`Could not enable mobile access: {{message}}`,disableFailed:`Could not disable mobile access: {{message}}`,windowsFirewall:`Windows Firewall will ask to allow the SpecRails server on first enable — choose “Allow on private networks”.`,pairedDevices:`Paired devices`,noDevices:`No devices paired yet.`,revokeDevice:`Revoke {{name}}`},g={title:`Pair web companion`,description:`Open specrails.dev/companion-app on your phone, then scan this code with it.`,startFailed:`Could not start pairing: {{error}}`,showThenScan:`After your phone scans this, tap “Scan phone's code” and point the camera at your phone.`,scanAnswer:`Scan phone's code`,scanning:`Point the camera at the code on your phone…`,cameraFailed:`Camera unavailable: {{message}}`,notAnswer:`That QR isn't a pairing answer.`,connecting:`Connecting…`,paired:`✓ Paired`,pairedToast:`Web companion paired`,answerRejected:`The desktop rejected that code. Generate a fresh one and retry.`,copyCode:`Copy code`,codeCopied:`Code copied`,cancel:`Cancel`},_={heading:`Specrails Core`,installed:`Installed:`,updateAvailable:`Update available: {{version}}`,upToDate:`Up to date`,neverChecked:`Not checked yet`,check:`Check for updates`,checking:`Checking…`,update:`Update to {{version}}`,downloading:`Downloading…`,materializing:`Installing…`,affectsAll:`Applies to all projects — no restart needed.`,unavailable:`Core updates aren't available in this build.`,toastDone:`Specrails Core updated to {{version}}`,toastError:`Core update failed: {{message}}`,toastUpToDate:`Specrails Core is up to date`,toastCheckFailed:`Update check failed: {{message}}`,loadFailed:`Could not refresh Core status. Retry`,runtime:`Runtime: {{version}}`,bundled:`Included in Desktop: {{version}}`,sources:{override:`Explicit override`,managed:`Managed by Desktop`,bundled:`Included in Desktop`,local:`Local package`,global:`External CLI`},repair:`Finish updating {{version}}`},v={heading:`Specrails Desktop`,installed:`Installed:`,check:`Check for updates`,checking:`Checking…`,upToDate:`You're on the latest version`,updateAvailable:`Update available: {{version}}`,autoHint:`Checks automatically at launch and every 6 hours.`,unavailable:`App updates are only available in the desktop app.`,toastUpToDate:`Specrails Desktop is up to date`,toastCheckFailed:`Update check failed: {{message}}`},y={title:`{{name}} — Settings`,description:`Project-level configuration: prompts, branch, environment, budget, telemetry and terminal.`,nav:{general:`General`,branch:`Branch`,environment:`Environment`,budget:`Budget`,telemetry:`Telemetry`,terminal:`Terminal`,agentRuntime:`Agent runtime`}},b={title:`Integration branch`,description:`The branch parallel rails branch from and target their draft PRs at. Leave empty to auto-resolve to the repository's default branch.`,placeholder:`auto (repository default)`,resolved:`Rails branch off <mono>{{branch}}</mono>`,save:`Save branch`,saved:`Integration branch saved`,saveFailed:`Could not save the integration branch`},x={title:`Worktree environment`,description:`Choose environment variable names this project passes to rail jobs and isolated loop worktrees. Only names are saved; values are read when a run starts, with login-shell recovery when the desktop process is missing them.`,label:`Environment variable`,placeholder:`NODE_AUTH_TOKEN`,helper:`Press Enter or Add. You can paste several names separated by commas or spaces.`,add:`Add`,empty:`No project-specific variables configured yet.`,remove:`Remove {{name}}`,save:`Save environment`,saved:`Worktree environment saved`,saveFailed:`Could not save the worktree environment`,invalidName:`{{name}} is not a valid environment variable name`,noValues:`Add only variable names here, not KEY=value secrets.`},S={heading:`Effects`,description:`Visual flourishes across the app. Each one can be switched off here.`,thinkingHalo:{label:`Thinking halo on the agent composer`,description:`While the agent is thinking or writing, the Builder's orbiting ring glows around the composer — it fades in when a turn starts and fades out when the reply settles.`},reducedMotion:`Follows your system's reduced-motion setting: the ring stays as a static glow.`,preview:`Preview`,previewThinking:`Thinking…`},C={language:n,page:r,errors:i,telemetry:a,prePrompt:o,freestylePrePrompt:s,budget:c,desktop:l,notifications:u,webhooks:d,terminal:f,codeSection:p,appearance:m,mobile:h,pairWeb:g,coreUpdate:_,appUpdate:v,projectDialog:y,integrationBranch:b,worktreeEnv:x,effects:S};export{t};

package/client/dist/assets/settings-p4OVIyRh.js

@@ -1 +0,0 @@
-var e={title:`Idioma`,description:`Idioma da UI em todo o Desktop. Aplica-se de imediato — sem reiniciar.`,selectLabel:`Idioma da interface`,updateFailed:`Não foi possível guardar a preferência de idioma`},t={title:`Definições do projeto`},n={saveFailed:`Falha ao guardar: {{message}}`},r={title:`Telemetria do pipeline`,description:`Capture uso de tokens, durações de fases e atividade de subagentes para exportação de diagnóstico. Ativada por omissão.`,toggleLabel:`Ativar telemetria do pipeline`,toggleDescription:`Quando ativa, os dados OTEL dos jobs do pipeline são capturados localmente. Use o botão <mono>Exportar diagnóstico</mono> em qualquer cartão de job para descarregar.`,enabled:`Telemetria do pipeline ativada`,disabled:`Telemetria do pipeline desativada`,saveFailed:`Falha ao guardar a definição de telemetria`},i={title:`Pre-prompt de rail`,description:`Instruções extra específicas do projeto, acrescentadas aos jobs de rail implement e batch-implement depois do contexto do ticket e antes da execução.`,label:`Pre-prompt`,placeholder:`Exemplo: Prefira alterações incrementais, mantenha as migrações retrocompatíveis e adicione testes a cada alteração de rail.`,helper:`Use isto para orientações estáveis do projeto que devem acompanhar cada execução de implementação em rail.`,saveButton:`Guardar pre-prompt`,cleared:`Pre-prompt limpo`,saved:`Pre-prompt guardado`,saveFailed:`Falha ao guardar o pre-prompt`},a={title:`Pre-prompt de Freestyle`,description:`Instrução enviada ao fornecedor selecionado em Freestyle. O Freestyle salta o pipeline OpenSpec — entrega ao fornecedor este pre-prompt mais o texto da spec e deixa-o implementar de forma autónoma. Deixe em branco para usar o valor predefinido.`,label:`Pre-prompt Freestyle`,placeholder:`Deixe em branco para usar a instrução Freestyle predefinida.`,helper:`O texto da spec é acrescentado automaticamente depois deste pre-prompt. Vazio = predefinição.`,saveButton:`Guardar pre-prompt Freestyle`,resetToDefault:`Pre-prompt Freestyle reposto na predefinição`,saved:`Pre-prompt Freestyle guardado`,saveFailed:`Falha ao guardar o pre-prompt Freestyle`},o={title:`Orçamento`,description:`Defina um limite de gasto diário para este projeto. A fila pausa automaticamente quando o limite é atingido.`,dailyLabel:`Orçamento diário (USD)`,dailyHelper:`Deixe em branco para desativar. O gasto é calculado sobre as últimas 24 horas.`,dailyPlaceholder:`ex.: 5.00`,perJobLabel:`Alerta de custo por job (USD)`,perJobHelper:`Alertar quando um único job deste projeto excede este valor.`,perJobPlaceholder:`ex.: 0.50`,invalidNumber:`Introduza um número positivo ou deixe em branco para desativar`,dailyRemoved:`Orçamento diário removido`,dailySet:"Orçamento diário definido como ${{amount}}",perJobAlertDisabled:`Alerta de custo por job desativado`,alertSet:"Alerta definido para jobs acima de ${{amount}}",saveBudgetFailed:`Falha ao guardar o orçamento`,saveThresholdFailed:`Falha ao guardar o limiar`},s={nav:{appearance:`Aparência`,specrailsAgents:`Provedores de IA`,code:`Código`,terminal:`Terminal`,updates:`Atualizações`,mobile:`Móvel`,mcp:`MCP`,projects:`Projetos`,advanced:`Avançado`,webhooks:`Webhooks`,about:`Sobre`,effects:`Efeitos`},title:`Definições do Desktop`,description:`Faça a gestão dos projetos registados e consulte informações do Desktop.`,registeredProjects:`Projetos registados`,noProjects:`Ainda não há projetos registados`,techUrlDescription:`URL base para a API specrails-tech (predefinição: http://localhost:3000)`,techUrlSaved:`URL do specrails-tech guardado`,techUrlSaveFailed:`Falha ao guardar o URL`,budgetAlertsHeading:`Orçamento e alertas`,dailyBudgetLabel:`Orçamento diário do Desktop (USD)`,dailyBudgetHelper:`Limite global de gasto diário em todos os projetos. As filas pausam automaticamente quando é excedido.`,dailyBudgetPlaceholder:`ex.: 10.00`,perJobHelper:`Alertar quando um único job excede este valor. Deixe em branco para desativar.`,costAlertsDisabled:`Alertas de custo desativados`,dailyBudgetRemoved:`Orçamento diário do Desktop removido`,dailyBudgetSet:"Orçamento diário do Desktop definido como ${{amount}}",dailyBudgetSaveFailed:`Falha ao guardar o orçamento diário do Desktop`,projectRemoved:`Projeto removido`,projectRemoveFailed:`Falha ao remover o projeto`,onboardingHeading:`Onboarding`,platformTour:`Tour da plataforma`,platformTourDescription:`Repita o assistente de boas-vindas para rever as funcionalidades principais.`,replayTour:`Repetir tour`,terminalPanelHeading:`Painel de terminal`,infoHeading:`Informações do Desktop`,infoPort:`Porta`,infoProjects:`Projetos`,infoDb:`BD do Desktop`},c={heading:`Notificações do SO`,description:`Mostrar notificações nativas do desktop quando os jobs terminam ou falham. As notificações só aparecem quando o separador não está focado.`,enableLabel:`Ativar notificações do SO`,notifyOn:`Notificar em:`,filterAll:`Tudo (concluídos e falhados)`,filterCompleted:`Apenas concluídos`,filterFailed:`Apenas falhados`,enabledToast:`Notificações do SO ativadas`,disabledToast:`Notificações do SO desativadas`},l={heading:`Webhooks de saída`,description:`Notifique ferramentas externas (Slack, Zapier, CI/CD) sobre eventos do Desktop. Os pedidos são assinados via <code>X-Specrails-Signature</code> quando há um segredo definido.`,eventJobCompleted:`Job concluído`,eventJobFailed:`Job falhado`,eventDailyBudgetExceeded:`Orçamento diário excedido`,statusOn:`ligado`,statusOff:`desligado`,disable:`Desativar`,enable:`Ativar`,sendTestPing:`Enviar ping de teste`,addHeading:`Adicionar webhook`,secretPlaceholder:`Segredo de assinatura (opcional)`,addButton:`Adicionar webhook`,urlRequired:`O URL é obrigatório`,selectEvent:`Selecione pelo menos um evento`,added:`Webhook adicionado`,addFailed:`Falha ao adicionar o webhook`,updateFailed:`Falha ao atualizar o webhook`,removed:`Webhook removido`,removeFailed:`Falha ao remover o webhook`,testPingSent:`Ping de teste enviado`,testPingFailed:`Falha ao enviar o ping de teste`},u={title:`Painel de terminal`,desktopDescription:`Predefinições do Desktop aplicadas a todos os projetos, salvo override por projeto.`,projectDescription:`Overrides por projeto para o painel de terminal. Deixe um campo inalterado para herdar a predefinição do Desktop.`,fontFamily:`Tipo de letra`,fontSize:`Tamanho da letra ({{min}}–{{max}})`,renderMode:`Modo de renderização`,copyOnSelect:`Copiar ao selecionar`,shellIntegration:`Integração com a shell (marcas OSC 133)`,notifyLongRunning:`Notificar comandos de longa duração`,longCommandThreshold:`Limiar de comando longo (ms)`,imageRendering:`Renderização de imagens inline (Sixel + iTerm2)`,browserShortcutUrl:`URL do atalho do browser`,quickScript:`Script rápido (colado no terminal ativo — Enter manualmente)`,reset:`Repor`,unsavedChanges:`Alterações não guardadas`,clearOverride:`Limpar override`,clear:`Limpar`,inheritingDefault:`A herdar a predefinição do Desktop`,nothingToSave:`Nada para guardar`,saved:`Definições do terminal guardadas`},d={heading:`Secção de código`,summaryLanguage:`Idioma dos resumos`,monthlyBudget:`Orçamento mensal (USD)`,budgetHelper:"Limite de gasto em `surface=file-summary` por mês de calendário. Regenerações iniciadas pelo utilizador podem ignorá-lo."},f={taglines:{dracula:`O original — escuro com tom púrpura e acentos néon vivos`,"aurora-light":`Claro premium — índigo inspirado no Linear sobre branco quente`,"obsidian-dark":`Escuro premium — quase preto com tom azulado e acentos elétricos`,specrails:`Tema da marca — azul-marinho-índigo profundo com acentos ciano saturados`,"code-rain":`Terminal de fósforo — menta suave sobre quase preto esverdeado`,galaxy:`Azul de espaço profundo com um rastro brilhante de lâmina`},heading:`Aspeto`,themeGroupLabel:`Tema`,currentlyActive:`Atualmente ativo`,updateFailed:`Falha ao atualizar o tema`},p={heading:`Companion móvel`,description:`Controle o Specrails a partir da app SpecRails Companion no seu telemóvel, 100% através da sua rede local. Desativado por omissão.`,accessOn:`Acesso móvel ligado`,accessOff:`Acesso móvel desligado`,listeningOnPort:`À escuta na porta {{port}}`,notListening:`Não está à escuta`,turnOn:`Ligar`,turnOff:`Desligar`,pairWebDevice:`Emparelhar companion web`,reset:`Repor`,resetConfirm:`Repor a identidade móvel? Todos os dispositivos emparelhados serão revogados e terão de emparelhar novamente.`,identityReset:`Identidade móvel reposta`,enableFailed:`Não foi possível ativar o acesso móvel: {{message}}`,disableFailed:`Não foi possível desativar o acesso móvel: {{message}}`,windowsFirewall:`A Firewall do Windows pedirá para permitir o servidor SpecRails na primeira ativação — escolha “Permitir em redes privadas”.`,pairedDevices:`Dispositivos emparelhados`,noDevices:`Ainda não há dispositivos emparelhados.`,revokeDevice:`Revogar {{name}}`},m={title:`Emparelhar companion web`,description:`Abra specrails.dev/companion-app no seu telemóvel e leia este código com ele.`,startFailed:`Não foi possível iniciar o emparelhamento: {{error}}`,showThenScan:`Depois de o seu telemóvel ler isto, toque em “Ler código do telemóvel” e aponte a câmara para o telemóvel.`,scanAnswer:`Ler código do telemóvel`,scanning:`Aponte a câmara para o código no seu telemóvel…`,cameraFailed:`Câmara indisponível: {{message}}`,notAnswer:`Esse QR não é uma resposta de emparelhamento.`,connecting:`A ligar…`,paired:`✓ Emparelhado`,pairedToast:`Companion web emparelhado`,answerRejected:`O desktop rejeitou esse código. Gere um novo e tente novamente.`,copyCode:`Copiar código`,codeCopied:`Código copiado`,cancel:`Cancelar`},h={heading:`Specrails Core`,installed:`Instalado:`,updateAvailable:`Atualização disponível: {{version}}`,upToDate:`Atualizado`,neverChecked:`Não verificado`,check:`Procurar atualizações`,checking:`A verificar…`,update:`Atualizar para {{version}}`,downloading:`A descarregar…`,materializing:`A instalar…`,affectsAll:`Aplica-se a todos os projetos — sem reiniciar.`,unavailable:`As atualizações do core não estão disponíveis nesta versão.`,toastDone:`Specrails Core atualizado para {{version}}`,toastError:`Falha na atualização do core: {{message}}`,toastUpToDate:`O Specrails Core está atualizado`,toastCheckFailed:`Falha ao verificar atualizações: {{message}}`,loadFailed:`Não foi possível atualizar o estado do Core. Tentar novamente`,runtime:`Motor: {{version}}`,bundled:`Incluído no Desktop: {{version}}`,sources:{override:`Seleção explícita`,managed:`Gerido pelo Desktop`,bundled:`Incluído no Desktop`,local:`Pacote local`,global:`CLI externa`},repair:`Concluir atualização {{version}}`},g={heading:`Specrails Desktop`,installed:`Instalada:`,check:`Verificar atualizações`,checking:`Verificando…`,upToDate:`Você está na versão mais recente`,updateAvailable:`Atualização disponível: {{version}}`,autoHint:`Verificação automática ao iniciar e a cada 6 horas.`,unavailable:`Atualizações estão disponíveis apenas no app desktop.`,toastUpToDate:`O Specrails Desktop está atualizado`,toastCheckFailed:`Falha ao verificar atualizações: {{message}}`},_={title:`{{name}} — Configurações`,description:`Configuração do projeto: prompts, branch, ambiente, orçamento, telemetria e terminal.`,nav:{general:`Geral`,branch:`Branch`,environment:`Ambiente`,budget:`Orçamento`,telemetry:`Telemetria`,terminal:`Terminal`,agentRuntime:`Motor de agentes`}},v={title:`Ramo de integração`,description:`O ramo a partir do qual os rails paralelos derivam e para o qual apontam os seus PRs em rascunho. Deixe vazio para resolver automaticamente para o ramo padrão do repositório.`,placeholder:`automático (ramo padrão)`,resolved:`Os rails derivam de <mono>{{branch}}</mono>`,save:`Guardar ramo`,saved:`Ramo de integração guardado`,saveFailed:`Não foi possível guardar o ramo de integração`},y={title:`Ambiente dos worktrees`,description:`Escolha os nomes das variáveis de ambiente que este projeto passa para jobs de rail e worktrees isolados de loops. Só os nomes são guardados; os valores são lidos quando a execução começa, com recuperação a partir do login shell se faltarem no processo Desktop.`,label:`Variável de ambiente`,placeholder:`NODE_AUTH_TOKEN`,helper:`Prima Enter ou Adicionar. Pode colar vários nomes separados por vírgulas ou espaços.`,add:`Adicionar`,empty:`Ainda não há variáveis específicas para este projeto.`,remove:`Remover {{name}}`,save:`Guardar ambiente`,saved:`Ambiente dos worktrees guardado`,saveFailed:`Não foi possível guardar o ambiente dos worktrees`,invalidName:`{{name}} não é um nome válido de variável de ambiente`,noValues:`Adicione apenas nomes de variáveis, não segredos KEY=value.`},b={heading:`Efeitos`,description:`Detalhes visuais da app. Cada um pode ser desativado aqui.`,thinkingHalo:{label:`Halo de raciocínio no compositor do agente`,description:`Enquanto o agente pensa ou escreve, o anel orbital do Construtor brilha à volta do compositor: surge com fade ao começar o turno e desvanece quando a resposta termina.`},reducedMotion:`Respeita a definição de movimento reduzido do sistema: o anel fica como um brilho estático.`,preview:`Pré-visualização`,previewThinking:`A pensar…`},x={language:e,page:t,errors:n,telemetry:r,prePrompt:i,freestylePrePrompt:a,budget:o,desktop:s,notifications:c,webhooks:l,terminal:u,codeSection:d,appearance:f,mobile:p,pairWeb:m,coreUpdate:h,appUpdate:g,projectDialog:_,integrationBranch:v,worktreeEnv:y,effects:b};export{g as appUpdate,f as appearance,o as budget,d as codeSection,h as coreUpdate,x as default,s as desktop,b as effects,n as errors,a as freestylePrePrompt,v as integrationBranch,e as language,p as mobile,c as notifications,t as page,m as pairWeb,i as prePrompt,_ as projectDialog,r as telemetry,u as terminal,l as webhooks,y as worktreeEnv};

package/client/dist/assets/settings-rddaldUp.js

@@ -1 +0,0 @@
-var e={title:`言語`,description:`Desktop 全体の UI 言語。即座に適用され、再起動は不要です。`,selectLabel:`インターフェース言語`,updateFailed:`言語設定を保存できませんでした`},t={title:`プロジェクト設定`},n={saveFailed:`保存に失敗しました: {{message}}`},r={title:`パイプラインテレメトリ`,description:`診断エクスポート用にトークン使用量、フェーズ時間、サブエージェントの活動を記録します。デフォルトはオンです。`,toggleLabel:`パイプラインテレメトリを有効化`,toggleDescription:`オンにすると、パイプラインジョブの OTEL データがローカルに記録されます。ジョブカードの <mono>診断をエクスポート</mono> ボタンからダウンロードできます。`,enabled:`パイプラインテレメトリを有効にしました`,disabled:`パイプラインテレメトリを無効にしました`,saveFailed:`テレメトリ設定の保存に失敗しました`},i={title:`レールのプレプロンプト`,description:`implement と batch-implement のレールジョブで、チケットコンテキストの後・実行前に追加されるプロジェクト固有の指示です。`,label:`プレプロンプト`,placeholder:`例: 段階的な変更を優先し、マイグレーションの後方互換性を保ち、レールの変更ごとにテストを追加すること。`,helper:`すべてのレール実装の実行に常に添えたい、安定したプロジェクト指針に使用してください。`,saveButton:`プレプロンプトを保存`,cleared:`プレプロンプトをクリアしました`,saved:`プレプロンプトを保存しました`,saveFailed:`プレプロンプトの保存に失敗しました`},a={title:`Freestyle プレプロンプト`,description:`Freestyle で選択したプロバイダーに送られる指示です。Freestyle は OpenSpec パイプラインをスキップし、このプレプロンプトとスペックテキストをプロバイダーに渡して自律的に実装させます。空欄の場合は組み込みのデフォルトを使用します。`,label:`Freestyle プレプロンプト`,placeholder:`空欄の場合はデフォルトの Freestyle 指示を使用します。`,helper:`スペックテキストはこのプレプロンプトの後に自動で追加されます。空欄 = デフォルト。`,saveButton:`Freestyle プレプロンプトを保存`,resetToDefault:`Freestyle プレプロンプトをデフォルトにリセットしました`,saved:`Freestyle プレプロンプトを保存しました`,saveFailed:`Freestyle プレプロンプトの保存に失敗しました`},o={title:`予算`,description:`このプロジェクトの1日あたりの支出上限を設定します。上限に達するとキューは自動で一時停止します。`,dailyLabel:`日次予算（USD）`,dailyHelper:`無効にするには空欄のままにします。支出は過去24時間で計算されます。`,dailyPlaceholder:`例: 5.00`,perJobLabel:`ジョブ単位のコストアラート（USD）`,perJobHelper:`このプロジェクトの単一ジョブがこの金額を超えたときにアラートします。`,perJobPlaceholder:`例: 0.50`,invalidNumber:`正の数値を入力するか、無効にするには空欄のままにしてください`,dailyRemoved:`日次予算を削除しました`,dailySet:"日次予算を ${{amount}} に設定しました",perJobAlertDisabled:`ジョブ単位のコストアラートを無効にしました`,alertSet:"${{amount}} を超えるジョブにアラートを設定しました",saveBudgetFailed:`予算の保存に失敗しました`,saveThresholdFailed:`しきい値の保存に失敗しました`},s={nav:{appearance:`外観`,specrailsAgents:`AI プロバイダー`,code:`コード`,terminal:`ターミナル`,updates:`更新`,mobile:`モバイル`,mcp:`MCP`,projects:`プロジェクト`,advanced:`詳細`,webhooks:`Webhooks`,about:`概要`,effects:`エフェクト`},title:`Desktop 設定`,description:`登録済みプロジェクトの管理と Desktop 情報の表示。`,registeredProjects:`登録済みプロジェクト`,noProjects:`登録されたプロジェクトはまだありません`,techUrlDescription:`specrails-tech API のベース URL（デフォルト: http://localhost:3000）`,techUrlSaved:`specrails-tech の URL を保存しました`,techUrlSaveFailed:`URL の保存に失敗しました`,budgetAlertsHeading:`予算とアラート`,dailyBudgetLabel:`Desktop 日次予算（USD）`,dailyBudgetHelper:`全プロジェクト共通のグローバルな日次支出上限。超過するとキューは自動で一時停止します。`,dailyBudgetPlaceholder:`例: 10.00`,perJobHelper:`単一ジョブがこの金額を超えたときにアラートします。無効にするには空欄のままにします。`,costAlertsDisabled:`コストアラートを無効にしました`,dailyBudgetRemoved:`Desktop の日次予算を削除しました`,dailyBudgetSet:"Desktop の日次予算を ${{amount}} に設定しました",dailyBudgetSaveFailed:`Desktop の日次予算の保存に失敗しました`,projectRemoved:`プロジェクトを削除しました`,projectRemoveFailed:`プロジェクトの削除に失敗しました`,onboardingHeading:`オンボーディング`,platformTour:`プラットフォームツアー`,platformTourDescription:`ウェルカムウィザードを再生して主要機能を確認します。`,replayTour:`ツアーを再生`,terminalPanelHeading:`ターミナルパネル`,infoHeading:`Desktop 情報`,infoPort:`ポート`,infoProjects:`プロジェクト`,infoDb:`Desktop DB`},c={heading:`OS 通知`,description:`ジョブの完了・失敗時にネイティブのデスクトップ通知を表示します。通知はタブがフォーカスされていないときのみ表示されます。`,enableLabel:`OS 通知を有効化`,notifyOn:`通知の対象:`,filterAll:`すべて（完了と失敗）`,filterCompleted:`完了のみ`,filterFailed:`失敗のみ`,enabledToast:`OS 通知を有効にしました`,disabledToast:`OS 通知を無効にしました`},l={heading:`アウトバウンド Webhook`,description:`Desktop のイベントを外部ツール（Slack、Zapier、CI/CD）に通知します。シークレットが設定されている場合、リクエストは <code>X-Specrails-Signature</code> で署名されます。`,eventJobCompleted:`ジョブ完了`,eventJobFailed:`ジョブ失敗`,eventDailyBudgetExceeded:`日次予算超過`,statusOn:`オン`,statusOff:`オフ`,disable:`無効化`,enable:`有効化`,sendTestPing:`テスト ping を送信`,addHeading:`Webhook を追加`,secretPlaceholder:`署名シークレット（任意）`,addButton:`Webhook を追加`,urlRequired:`URL は必須です`,selectEvent:`イベントを1つ以上選択してください`,added:`Webhook を追加しました`,addFailed:`Webhook の追加に失敗しました`,updateFailed:`Webhook の更新に失敗しました`,removed:`Webhook を削除しました`,removeFailed:`Webhook の削除に失敗しました`,testPingSent:`テスト ping を送信しました`,testPingFailed:`テスト ping の送信に失敗しました`},u={title:`ターミナルパネル`,desktopDescription:`プロジェクト別のオーバーライドがない限り、すべてのプロジェクトに適用される Desktop 全体のデフォルトです。`,projectDescription:`ターミナルパネルのプロジェクト別オーバーライド。Desktop のデフォルトを継承するには、フィールドを変更しないでください。`,fontFamily:`フォントファミリー`,fontSize:`フォントサイズ（{{min}}–{{max}}）`,renderMode:`レンダリングモード`,copyOnSelect:`選択時にコピー`,shellIntegration:`シェル統合（OSC 133 マーク）`,notifyLongRunning:`長時間実行コマンドの通知`,longCommandThreshold:`長時間コマンドのしきい値（ms）`,imageRendering:`インライン画像レンダリング（Sixel + iTerm2）`,browserShortcutUrl:`ブラウザショートカット URL`,quickScript:`クイックスクリプト（アクティブなターミナルに貼り付け — Enter は手動）`,reset:`リセット`,unsavedChanges:`未保存の変更`,clearOverride:`オーバーライドをクリア`,clear:`クリア`,inheritingDefault:`Desktop のデフォルトを継承中`,nothingToSave:`保存する変更はありません`,saved:`ターミナル設定を保存しました`},d={heading:`Code セクション`,summaryLanguage:`要約の言語`,monthlyBudget:`月次予算（USD）`,budgetHelper:"暦月ごとの `surface=file-summary` 支出の上限。ユーザーが開始した再生成は上限を超えられます。"},f={taglines:{dracula:`オリジナル — 紫がかったダークにネオンのアクセント`,"aurora-light":`プレミアムライト — Linear風のインディゴと温かみのあるオフホワイト`,"obsidian-dark":`プレミアムダーク — 青みがかった漆黒にエレクトリックなアクセント`,specrails:`ブランドテーマ — 深いネイビーインディゴに鮮やかなシアン`,"code-rain":`蛍光ターミナル — 緑がかった漆黒にソフトミント`,galaxy:`深宇宙のブルーと輝くブレードの軌跡`},heading:`外観`,themeGroupLabel:`テーマ`,currentlyActive:`現在アクティブ`,updateFailed:`テーマの更新に失敗しました`},p={heading:`モバイルコンパニオン`,description:`スマートフォンの SpecRails Companion アプリから Specrails を操作します。通信は 100% ローカルネットワーク経由です。デフォルトはオフです。`,accessOn:`モバイルアクセス オン`,accessOff:`モバイルアクセス オフ`,listeningOnPort:`ポート {{port}} で待機中`,notListening:`待機していません`,turnOn:`オンにする`,turnOff:`オフにする`,pairWebDevice:`Web コンパニオンをペアリング`,reset:`リセット`,resetConfirm:`モバイル ID をリセットしますか？ペアリング済みのすべてのデバイスが無効化され、再ペアリングが必要になります。`,identityReset:`モバイル ID をリセットしました`,enableFailed:`モバイルアクセスを有効にできませんでした: {{message}}`,disableFailed:`モバイルアクセスを無効にできませんでした: {{message}}`,windowsFirewall:`初回有効化時に Windows ファイアウォールが SpecRails サーバーの許可を求めます — 「プライベートネットワークで許可」を選択してください。`,pairedDevices:`ペアリング済みデバイス`,noDevices:`ペアリングされたデバイスはまだありません。`,revokeDevice:`{{name}} を無効化`},m={title:`Web コンパニオンをペアリング`,description:`スマートフォンで specrails.dev/companion-app を開き、それでこのコードをスキャンしてください。`,startFailed:`ペアリングを開始できませんでした: {{error}}`,showThenScan:`スマートフォンでこれをスキャンしたら、「スマートフォンのコードをスキャン」をタップし、カメラをスマートフォンに向けてください。`,scanAnswer:`スマートフォンのコードをスキャン`,scanning:`カメラをスマートフォンのコードに向けてください…`,cameraFailed:`カメラを利用できません: {{message}}`,notAnswer:`その QR はペアリング応答ではありません。`,connecting:`接続中…`,paired:`✓ ペアリング済み`,pairedToast:`Web コンパニオンをペアリングしました`,answerRejected:`デスクトップがそのコードを拒否しました。新しいコードを生成して再試行してください。`,copyCode:`コードをコピー`,codeCopied:`コードをコピーしました`,cancel:`キャンセル`},h={heading:`Specrails Core`,installed:`インストール済み:`,updateAvailable:`アップデートあり: {{version}}`,upToDate:`最新です`,neverChecked:`未確認`,check:`アップデートを確認`,checking:`確認中…`,update:`{{version}} に更新`,downloading:`ダウンロード中…`,materializing:`インストール中…`,affectsAll:`すべてのプロジェクトに適用 — 再起動不要。`,unavailable:`このビルドではコアの更新は利用できません。`,toastDone:`Specrails Core を {{version}} に更新しました`,toastError:`コアの更新に失敗しました: {{message}}`,toastUpToDate:`Specrails Core は最新です`,toastCheckFailed:`更新の確認に失敗しました: {{message}}`,loadFailed:`Core の状態を更新できませんでした。再試行`,runtime:`ランタイム: {{version}}`,bundled:`Desktop 同梱: {{version}}`,sources:{override:`明示的な指定`,managed:`Desktop が管理`,bundled:`Desktop 同梱`,local:`ローカルパッケージ`,global:`外部 CLI`},repair:`{{version}} への更新を完了`},g={heading:`Specrails Desktop`,installed:`インストール済み:`,check:`アップデートを確認`,checking:`確認中…`,upToDate:`最新バージョンです`,updateAvailable:`アップデートあり: {{version}}`,autoHint:`起動時と6時間ごとに自動確認します。`,unavailable:`アップデートはデスクトップアプリでのみ利用できます。`,toastUpToDate:`Specrails Desktop は最新です`,toastCheckFailed:`アップデートの確認に失敗しました: {{message}}`},_={title:`{{name}} — 設定`,description:`プロジェクト設定：プロンプト、ブランチ、環境、予算、テレメトリ、ターミナル。`,nav:{general:`一般`,branch:`ブランチ`,environment:`環境`,budget:`予算`,telemetry:`テレメトリ`,terminal:`ターミナル`,agentRuntime:`エージェント実行エンジン`}},v={title:`統合ブランチ`,description:`並列レールが分岐し、ドラフト PR の対象となるブランチです。空欄にするとリポジトリのデフォルトブランチに自動解決されます。`,placeholder:`自動（リポジトリのデフォルト）`,resolved:`レールは <mono>{{branch}}</mono> から分岐します`,save:`ブランチを保存`,saved:`統合ブランチを保存しました`,saveFailed:`統合ブランチを保存できませんでした`},y={title:`Worktree 環境`,description:`このプロジェクトが rail ジョブと分離された loop worktree に渡す環境変数名を選びます。保存されるのは名前だけで、値は実行開始時に読み取られ、Desktop プロセスにない場合は login shell から復元を試みます。`,label:`環境変数`,placeholder:`NODE_AUTH_TOKEN`,helper:`Enter または追加を押します。カンマやスペース区切りで複数の名前を貼り付けられます。`,add:`追加`,empty:`このプロジェクト固有の変数はまだ設定されていません。`,remove:`{{name}} を削除`,save:`環境を保存`,saved:`Worktree 環境を保存しました`,saveFailed:`Worktree 環境を保存できませんでした`,invalidName:`{{name}} は有効な環境変数名ではありません`,noValues:`ここには変数名だけを追加してください。KEY=value のシークレットは入力しないでください。`},b={heading:`エフェクト`,description:`アプリ内の視覚的な演出。それぞれここでオフにできます。`,thinkingHalo:{label:`エージェントコンポーザーの思考ハロー`,description:`エージェントが考えたり書いたりしている間、ビルダーの回転リングがコンポーザーの周りで光ります。ターン開始時にフェードイン、返答完了時にフェードアウトします。`},reducedMotion:`システムの「視差効果を減らす」設定に従い、リングは静的な光のままになります。`,preview:`プレビュー`,previewThinking:`考え中…`},x={language:e,page:t,errors:n,telemetry:r,prePrompt:i,freestylePrePrompt:a,budget:o,desktop:s,notifications:c,webhooks:l,terminal:u,codeSection:d,appearance:f,mobile:p,pairWeb:m,coreUpdate:h,appUpdate:g,projectDialog:_,integrationBranch:v,worktreeEnv:y,effects:b};export{g as appUpdate,f as appearance,o as budget,d as codeSection,h as coreUpdate,x as default,s as desktop,b as effects,n as errors,a as freestylePrePrompt,v as integrationBranch,e as language,p as mobile,c as notifications,t as page,m as pairWeb,i as prePrompt,_ as projectDialog,r as telemetry,u as terminal,l as webhooks,y as worktreeEnv};

package/client/dist/assets/useRuntimeRuns-Dqmz9fS9.js

@@ -1 +0,0 @@
-import{a as e}from"./rolldown-runtime-CNC7AqOf.js";import{n as t}from"./jsx-runtime-zu2_FqZY.js";import{n}from"./createLucideIcon-Bjbbp_KS.js";import{n as r}from"./project-repositories-9Wzs0coQ.js";function i(e){if(!Number.isFinite(e)||e<0)return`0s`;let t=Math.round(e/1e3);if(t<60)return`${t}s`;let n=Math.floor(t/60),r=t%60;return n<60?`${n}m ${r}s`:`${Math.floor(n/60)}h ${n%60}m`}var a=e(t(),1);function o(e,t={}){let{jobId:i,railIndex:o,enabled:s=!0}=t,{t:c}=n(`agentRuntime`),[l,u]=(0,a.useState)([]),[d,f]=(0,a.useState)(``),[p,m]=(0,a.useState)(null),[h,g]=(0,a.useState)(0),[_,v]=(0,a.useState)({}),y=(0,a.useRef)(!0),b=s&&!!e,x=e?`${r(e)}/agent-runtime/runs`:``,S=i?`${x}/${encodeURIComponent(i)}`:o===void 0?x:`${x}?railIndex=${o}`;(0,a.useEffect)(()=>{if(y.current=!0,!b)return u([]),f(``),()=>{y.current=!1};let e=!1,t;async function n(){try{let t=await fetch(S,{cache:`no-store`});if(!t.ok)throw Error();let n=await t.json();if(!Array.isArray(n.runs))throw Error();e||(u(n.runs),f(``))}catch{e||f(c(`runs.loadFailed`))}finally{e||(t=setTimeout(()=>void n(),1e4))}}return n(),()=>{e=!0,y.current=!1,clearTimeout(t)}},[b,S,h,c]);let C=(0,a.useCallback)(async(e,t)=>{m(e.runId),f(``);try{let n=t===`approve`?{approve:[e.pendingApproval.stepId]}:t===`recover`?{recover:e.recoverableSteps}:t===`answer`?{answer:(_[e.runId]??``).trim()}:{},r=t===`cancel`?`cancel`:t===`settle`?`settle`:t===`dismiss`?`dismiss`:`resume`,i=await fetch(`${x}/${encodeURIComponent(e.runId)}/${r}`,{method:`POST`,headers:{"Content-Type":`application/json`},body:JSON.stringify(n)});if(!i.ok){let e=await i.json();throw Error(e.message??c(`runs.actionFailed`))}y.current&&(t===`answer`&&v(t=>({...t,[e.runId]:``})),g(e=>e+1))}catch(e){y.current&&f(e instanceof Error?e.message:c(`runs.actionFailed`))}finally{y.current&&m(null)}},[_,x,c]);return{runs:l,error:d,busy:p,answers:_,setAnswer:(0,a.useCallback)((e,t)=>{v(n=>({...n,[e]:t}))},[]),act:C,refresh:(0,a.useCallback)(()=>g(e=>e+1),[])}}export{i as n,o as t};

package/docs/guide/de/pipeline/3-batch-implement-and-multi-feature.md

@@ -1,84 +0,0 @@
-# Batch implement & Multi-Feature
-
-Eine Spec nach der anderen ist völlig okay, aber viel echte Arbeit kommt in Bündeln — ein Feature plus seine Tests plus seine Migration, oder ein Backlog, das du in einer Sitzung abräumen willst. Diese Seite zeigt, wie du mehrere Specs zusammen ausführst: den Batch-Modus, Abhängigkeits-Wellen und wie die Pipeline verhindert, dass gleichzeitige Arbeit miteinander kollidiert.
-
-## Mehrere Specs auf einmal ausführen
-
-Der einfachste Weg, einen ganzen Stapel Specs aus einer Rail laufen zu lassen, ist der **Batch**-Modus:
-
-1. **Zieh alle Specs**, die du willst, auf eine einzige Rail. Sie stapeln sich in der Spec-Liste dieser Rail.
-2. **Stell den Modus der Rail auf Batch** (die segmentierte Auswahl im Rail-Header).
-3. **Drück ▶ Play.**
-
-Die Rail startet **einen** `/specrails:batch-implement`-Job, der jede zugewiesene Spec abarbeitet. Beobachte ihn wie jeden anderen Job auf der Jobs-Seite — es ist ein einzelner Job für das gesamte Set, nicht ein Job pro Spec.
-
-Der Batch-Modus bleibt der sauberste Weg, zusammenhängende Specs zu *sequenzieren*, weil ihre Abhängigkeitsreihenfolge in einer einzigen Rail bleibt. Wenn die Specs unabhängig sind, kannst du sie auch auf mehrere Rails verteilen: Git-gestützte Rails laufen parallel und jede bekommt ihren eigenen isolierten Worktree.
-
-### Implement vs. Batch — welcher Modus?
-
-| | **Implement** | **Batch** |
-|---|---|---|
-| Befehl | `/specrails:implement` | `/specrails:batch-implement` |
-| Specs pro Job | Alle auf der Rail, als eine Arbeitseinheit behandelt | Alle auf der Rail, **nacheinander** abgearbeitet |
-| Am besten für | Eine eng verzahnte Änderung | Mehrere eigenständige Features, die du der Reihe nach abräumen willst |
-| Reihenfolge | n/v | Abhängigkeitsbewusste Wellen (siehe unten) |
-
-Wenn die Specs wirklich eine Änderung sind, nimm **Implement**. Wenn sie eine Liste separater Features sind, nimm **Batch** und lass es sie sequenzieren.
-
-## Abhängigkeits-Wellen
-
-Der Batch-Modus arbeitet die Specs nicht einfach von oben nach unten ab — er berechnet eine **abhängigkeitsbewusste Ausführungsreihenfolge** und gruppiert die Specs in *Wellen*. Der Orchestrator (`/specrails:batch-implement`) ermittelt, welche Specs von welchen abhängen, und plant sie dann so ein, dass nichts vor der Arbeit läuft, auf der es aufbaut.
-
-Konzeptionell:
-
-```
-Welle 1:  #2 (Datenmodell)         ← keine Abhängigkeiten, läuft zuerst
-Welle 2:  #4 (API auf dem Modell)  ← wartet auf #2
-          #5 (CLI auf dem Modell)  ← wartet auf #2
-Welle 3:  #7 (Docs über alles)     ← wartet auf #4 und #5
-```
-
-Innerhalb des Jobs werden die Specs jeder Welle implementiert, bevor die nächste Welle beginnt. Du konfigurierst das nicht von Hand — der Orchestrator leitet die Wellen aus den Specs selbst ab. Sieh dabei zu, wie es sich in der [Job-Detail-Ansicht](the-job-detail-view) entfaltet: Das Streaming-Log erzählt, an welcher Spec der Batch gerade arbeitet, und der Ticket-Header zeigt jede Spec, die der Job berührt hat.
-
-## Worktree-Isolation und wie die Arbeit ausgeliefert wird
-
-Wenn in einem Lauf mehrere Specs implementiert werden, hält die Pipeline jede Arbeitseinheit isoliert, damit gleichzeitige oder aufeinanderfolgende Änderungen sich nicht gegenseitig die Dateien zertrampeln. Die Implementierung jeder Spec läuft in ihrem eigenen sauberen **git-Worktree** — einem separaten Checkout, der die Historie deines Repositories teilt, aber deinen Arbeitsbaum niemals berührt, während die KI arbeitet.
-
-Wenn der Lauf fertig ist, **wird nichts gepusht und noch kein Pull-Request geöffnet**. Die Arbeit bleibt sicher auf ihren isolierten Branches committet, die Specs wechseln in einen neuen Status **In Prüfung**, und specrails **fragt dich zuerst**: Auf dem Rail erscheint eine persistente Entscheidungsleiste mit **PR erstellen** — ein einziger Entwurfs-Pull-Request von dem für dein Projekt festgelegten Integrations-Branch (lege ihn unter **Einstellungen → Integrations-Branch** fest; standardmäßig ist es der Default-Branch deines Repositories), kombiniert über alle Specs des Rails — und **Verwerfen**. specrails **merged niemals und committet niemals direkt auf deinen Integrations-Branch** — du entscheidest, ob überhaupt ein PR entsteht, und ein Mensch verantwortet den Merge. Das ist die sichere Übergabe: specrails erstellt den Pull-Request erst, wenn du es sagst, und deine Entwickler prüfen ihn und mergen ihn in GitHub genau so, wie sie es ohnehin schon tun.
-
-Wenn du eine Spec erneut startest, die bereits in Prüfung ist und einen offenen Pull-Request hat, behandelt Specrails das als Follow-up-Arbeit. Es erkennt die aktive PR über seinen eigenen Lieferdatensatz oder über GitHub-/Jira-Referenzen, checkt die Head-Branch dieser PR aus, committet die neuen Änderungen dort und zeigt dieselbe PR-Karte wieder an. Neue Arbeit startet weiterhin vom Integrations-Branch.
-
-In der Praxis heißt das:
-
-- Jede Spec bekommt zum Implementieren eine saubere Ausgangslage, statt die noch laufenden Änderungen der vorherigen Spec mitten im Fluss zu erben.
-- Dein Arbeitsbaum wird während des laufenden Durchgangs nie verändert — nichts landet, bevor du es freigibst.
-- Wenn der Lauf fertig ist, zeigen die Specs ein **In Prüfung**-Abzeichen und das Rail stellt dir die Frage: **PR erstellen**, um den kombinierten Entwurfs-Pull-Request zu öffnen, oder **Verwerfen**, um die Branches aufzuräumen und die Specs ins Backlog zurückzulegen. Hast du das Rail aus dem Agenten-Chat gestartet, erscheint dieselbe Frage als Karte in dieser Konversation — antworte an einer der beiden Stellen, beide bleiben synchron.
-- Nach dem Erstellen kannst du mit **PR öffnen** hineinsehen, mit **Veröffentlichen** ihn für das Review deines Teams öffnen und an das normale GitHub-Review übergeben, und **Merge prüfen** setzt die Specs auf Fertig, sobald dein Team ihn gemerged hat.
-- Falls die isolierten Branches beim Erstellen des PR nicht sauber kombiniert werden können, stoppt specrails auf sichere Weise und überlässt die Branches einem Menschen — es erzwingt niemals einen kaputten Merge auf deinen Basis-Branch. Von derselben Leiste aus kannst du es erneut versuchen oder verwerfen.
-
-> Für das Erstellen oder Fortsetzen einer PR brauchst du ein Git-Repository, eine authentifizierte GitHub-CLI (`gh`) und ein konfiguriertes Remote. Ohne `gh` oder Remote bleibt die Arbeit trotzdem auf einem Branch committet, von dem aus du selbst einen Pull-Request öffnen kannst — es geht nichts verloren, und die Entscheidungsleiste erlaubt einen erneuten Versuch. Ganz ohne Git gibt es keinen Branch-Graphen, den Specrails fortsetzen könnte: Die Rail läuft im gemeinsamen Ordner und es erscheint keine PR-Karte. Um auf das ältere Verhalten zurückzufallen (lokal integrieren, statt zu fragen), setze `SPECRAILS_RAIL_DELIVER_PR=0`.
-
-## Multi-Feature über Projekte hinweg
-
-Wenn du echte Parallelität willst, nutze mehrere Rails für unabhängige Specs im selben Git-gestützten Projekt oder teile die Arbeit über Projekte auf. Jede aktive Rail bekommt ihren eigenen isolierten Worktree, also:
-
-```
-Projekt A   ▶ Rail baut Feature X   ┐
-                                    ├─ laufen gleichzeitig
-Projekt B   ▶ Rail baut Feature Y   ┘
-```
-
-Es gibt kein globales Parallelitäts-Limit, das du einstellen musst. Öffne die Projekte oder Rails, die du brauchst, starte sie, und sie kommen zusammen voran. Die einzige geteilte Bremse ist dein Budget-Limit, das die Queues pro Projekt oder app-weit pausiert, sobald die Ausgaben des Tages das Limit erreichen.
-
-## Tipps für große Batches
-
-- **Gruppiere verwandte Specs auf einer Rail**, bevor du auf Batch umstellst — die Abhängigkeits-Wellen sehen nur, was auf dieser Rail liegt.
-- **Setze ein Tagesbudget**, bevor du einen großen Batch startest, damit ein unerwartet teurer Lauf automatisch pausiert, statt davonzulaufen. Konfiguriere es unter [Budget](../settings/customizing).
-- **Nutze danach den Compare-Button** auf der Jobs-Seite, um zwei Batch-Läufe nebeneinander zu vergleichen.
-- **Exportiere eine Diagnose** (falls Telemetrie an war), um den exakten Profil- und Plugin-Snapshot für den gesamten Batch zu erhalten.
-
-## Wie es weitergeht
-
-- [Rails & Jobs](rails-and-jobs) — das Queue-Modell im Detail.
-- [Die Job-Detail-Ansicht](the-job-detail-view) — einem Batch-Lauf live zusehen.
-- [Engine pro Rail wählen](picking-an-engine-per-rail) — Batch läuft auf jedem Provider; Freestyle gibt es mit Claude und Kimi.

package/docs/guide/en/pipeline/3-batch-implement-and-multi-feature.md

@@ -1,126 +0,0 @@
-# Batch implement & multi-feature
-
-One spec at a time is fine, but a lot of real work comes in clusters — a feature plus its tests plus its migration, or a backlog you want cleared in one sitting. This page covers running several specs together: Batch mode, dependency waves, and how the pipeline keeps concurrent work from colliding.
-
-## Running several specs at once
-
-The simplest way to run a pile of specs from one rail is **Batch** mode:
-
-1. **Drag all the specs** you want onto a single rail. They stack up in that rail's spec list.
-2. **Switch the rail's mode to Batch** (the segmented control in the rail header).
-3. **Press ▶ Play.**
-
-The rail launches **one** `/specrails:batch-implement` job that works through every assigned spec. Monitor it like any other job on the Jobs page — it's a single job covering the whole set, not one job per spec.
-
-The built-in Implement and Batch Implement graphs are **Start → Core command → End**.
-Core owns implementation, review, verification and corrections; Desktop does not
-append another Verify, Loop Decider or Fix cycle. Existing custom forks keep
-their saved steps. Freestyle and Revision retain their own verification cycles.
-
-SDD Quick (OpenSpec) uses **Start → prepare artifacts → apply and test → CLI
-validate → CLI archive → End**. Apply handles code checks and corrections;
-`openspec validate` checks the change artifacts before archiving. There is no
-separate AI Verify or Loop Decider. Failed implementation checks or CLI validation
-stop the run before archive. This lightweight path has no independent AI review.
-
-Batch mode is still the cleanest way to *sequence* related specs because it keeps their dependency order inside one rail. If the specs are independent, you can also spread them across several rails: git-backed rails run in parallel and each one gets its own isolated worktree.
-
-### Implement vs Batch — which mode?
-
-| | **Implement** | **Batch** |
-|---|---|---|
-| Command | `/specrails:implement` | `/specrails:batch-implement` |
-| Specs per job | All on the rail, treated as one unit of work | All on the rail, worked **sequentially** |
-| Best for | A tightly coupled change | Several distinct features you want cleared in order |
-| Ordering | n/a | Dependency-aware waves (see below) |
-
-If the specs are really one change, use **Implement**. If they're a list of separate features, use **Batch** and let it sequence them.
-
-## Dependency waves
-
-Batch mode doesn't just run specs top to bottom — it computes a **dependency-aware execution order** and groups specs into *waves*. The orchestrator (`/specrails:batch-implement`) figures out which specs depend on which, then schedules them so that nothing runs before the work it builds on.
-
-Conceptually:
-
-```
-Wave 1:  #2 (data model)        ← no dependencies, runs first
-Wave 2:  #4 (API on the model)  ← waits for #2
-         #5 (CLI on the model)  ← waits for #2
-Wave 3:  #7 (docs across all)   ← waits for #4 and #5
-```
-
-Within the job, each wave's specs are implemented before the next wave starts. You don't configure this by hand — the orchestrator derives the waves from the specs themselves. Watch it unfold in the [Job Detail view](the-job-detail-view): the streaming log narrates which spec the batch is on, and the ticket header shows every spec the job touched.
-
-## Worktree isolation and how work is delivered
-
-When several specs are implemented in one run, the pipeline keeps each unit of work isolated so concurrent or sequential changes don't trample each other's files. Each spec's implementation runs in its own clean **git worktree** — a separate checkout that shares your repository's history but never touches your working tree while the AI works.
-
-When the run finishes, **nothing is pushed and no pull request is opened yet**. The work stays safely committed on its isolated branches, the specs move to a new **On Review** status, and specrails **asks you first**: a persistent decision bar appears on the rail with **Create PR** — one draft pull request off your project's designated integration branch (set it in **Settings → Integration branch**; it defaults to your repository's default branch), combined across every spec on the rail — and **Discard**. specrails **never merges, and never commits to your integration branch directly** — you decide whether a PR exists at all, and a human owns the merge. It's the safe hand-off: specrails produces the pull request only when you say so, and your engineers review and merge it in GitHub the way they already do.
-
-If you relaunch a spec that is already in review and has an open pull request, Specrails treats that as follow-up work. It detects the active PR from its own delivery record or from GitHub/Jira references, checks out the PR's head branch, commits the new changes there, and brings the same PR card back. New work still starts from the integration branch.
-
-In practice this means:
-
-- Each spec gets a clean slate to implement against, rather than inheriting the in-flight edits of the previous spec mid-stream.
-- Your working tree is never modified while the run is in flight — nothing lands until you say so.
-- When the run is done the specs show an **On Review** badge and the rail asks the question: **Create PR** to open the combined draft pull request, or **Discard** to clean up the branches and return the specs to the backlog. If you launched the rail from the agent chat, the same question appears as a card in that conversation — answer in either place, both stay in sync.
-- After creating it, **Open PR** views the draft, **Publish** opens it for review and hands it to your team's normal GitHub review, and **Check merge** flips the specs to Done once your team has merged it.
-- If the isolated branches can't be combined cleanly when you create the PR, specrails stops safely and leaves the branches for a human — it never forces a broken merge onto your base. You can retry or discard from the same bar.
-
-> Creating or continuing a PR needs a git repository, the GitHub CLI (`gh`) authenticated, and a remote configured. Without `gh` or a remote, specrails still keeps the work committed on a branch you can open a pull request from yourself — nothing is lost, and the decision bar lets you retry. Without git at all, there is no branch graph to continue: the rail runs in the shared folder and no PR card appears. To fall back to the older behaviour (integrate locally instead of asking), set `SPECRAILS_RAIL_DELIVER_PR=0`.
-
-The app records, per job, exactly which files were touched and which ticket touched them (you'll see this surface as provenance chips in the **Code** section and as a "Files touched by this ticket" list on each spec's detail modal). That attribution is what lets you trust a multi-spec run: you can always trace a file change back to the spec that caused it.
-
-## Multi-feature across projects
-
-If you want genuine parallelism, use multiple rails for independent specs in the same git-backed project, or split work across projects. Each active rail gets its own isolated worktree, so:
-
-```
-Project A   ▶ Rail running feature X   ┐
-                                       ├─ run simultaneously
-Project B   ▶ Rail running feature Y   ┘
-```
-
-There's no global concurrency limit to tune. Open the projects or rails you need, launch them, and they progress together. The only shared throttle is your budget cap, which pauses queues per-project or app-wide once the day's spend hits the limit.
-
-## Tips for big batches
-
-- **Group related specs on one rail** before switching to Batch — the dependency waves only see what's on that rail.
-- **Set a daily budget** before a large batch so an unexpectedly expensive run auto-pauses instead of running away. Configure it under [Budget](../settings/customizing).
-- **Use the Compare button** on the Jobs page afterward to diff two batch runs side by side.
-- **Export a diagnostic** (if telemetry was on) to get the exact profile + plugin snapshot for the whole batch.
-
-## Where to go next
-
-- [Rails & jobs](rails-and-jobs) — the queue model in depth.
-- [The Job Detail view](the-job-detail-view) — watch a batch run live.
-- [Picking an engine per rail](picking-an-engine-per-rail) — Batch runs on any provider; Freestyle is available on Claude and Kimi.
-
-
-## Read the implementation result
-
-With a Core runtime that supports acceptance evidence, the completed run shows four
-separate states: implementation, validation, archive and delivery. “Verified with
-exceptions” means accepted requirement interpretations or failed/unavailable
-supplementary checks remain visible. “Pending host delivery” means Core has not
-performed the host's delivery work, even if the change has been archived.
-
-Open **Evidence, exceptions and phase timings** to inspect decisions, approval
-references, measurement scope and limitations, review findings and recorded phase
-times. Required checks and unresolved requirements block acceptance. A passing Node
-benchmark does not establish browser rendering performance. Material requirement
-changes need existing user/host authorization; minor interpretations can be accepted
-by the reviewer with a recorded reason and impact.
-
-Execution success describes the process. If the current runtime reports incomplete
-implementation or blocked/pending validation, Desktop settles the run as blocked
-and does not complete its tickets. Older or unavailable runtimes show acceptance
-evidence as unavailable; a successful process alone is not proof of acceptance.
-The result is a snapshot captured at completion, not a revalidation of later edits.
-
-The final counters distinguish executed steps, decider evaluations and agent turns.
-A built-in Implement run can have one step, zero decider evaluations and many agent
-turns. Core phase durations/attempts are shown when recorded; per-phase costs are
-unavailable because provider usage is attributed to loop steps. Valid full test
-receipts are reused until their inputs change; each phase does not need another
-identical full-suite execution.

package/docs/guide/es/pipeline/3-batch-implement-and-multi-feature.md

@@ -1,114 +0,0 @@
-# Batch implement y multifuncionalidad
-
-Una spec a la vez está bien, pero buena parte del trabajo real viene en racimos — una funcionalidad más sus tests más su migración, o un backlog que quieres dejar limpio de una sentada. Esta página cubre cómo ejecutar varias specs juntas: el modo Batch, las oleadas por dependencias y cómo el pipeline evita que el trabajo concurrente se pise.
-
-## Ejecutar varias specs a la vez
-
-La forma más sencilla de ejecutar un montón de specs desde un mismo rail es el modo **Batch**:
-
-1. **Arrastra todas las specs** que quieras a un único rail. Se apilan en la lista de specs de ese rail.
-2. **Cambia el modo del rail a Batch** (el control segmentado de la cabecera del rail).
-3. **Pulsa ▶ Play.**
-
-El rail lanza **un** job `/specrails:batch-implement` que recorre todas las specs asignadas. Monitorízalo como cualquier otro job en la página Jobs — es un único job que cubre el conjunto entero, no un job por spec.
-
-El modo Batch sigue siendo la forma más limpia de *secuenciar* specs relacionadas porque mantiene su orden de dependencias dentro de un solo rail. Si las specs son independientes, también puedes repartirlas entre varios rails: los rails respaldados por git se ejecutan en paralelo y cada uno recibe su propio worktree aislado.
-
-### Implement vs Batch — ¿qué modo?
-
-| | **Implement** | **Batch** |
-|---|---|---|
-| Comando | `/specrails:implement` | `/specrails:batch-implement` |
-| Specs por job | Todas las del rail, tratadas como una sola unidad de trabajo | Todas las del rail, trabajadas **secuencialmente** |
-| Mejor para | Un cambio fuertemente acoplado | Varias funcionalidades distintas que quieres despachar en orden |
-| Ordenación | n/a | Oleadas según dependencias (mira más abajo) |
-
-Si las specs son de verdad un único cambio, usa **Implement**. Si son una lista de funcionalidades independientes, usa **Batch** y deja que las secuencie.
-
-## Oleadas por dependencias
-
-El modo Batch no se limita a ejecutar las specs de arriba a abajo — calcula un **orden de ejecución según dependencias** y agrupa las specs en *oleadas*. El orquestador (`/specrails:batch-implement`) averigua qué specs dependen de cuáles y luego las planifica de modo que nada se ejecute antes que el trabajo sobre el que se construye.
-
-Conceptualmente:
-
-```
-Oleada 1:  #2 (modelo de datos)     ← sin dependencias, se ejecuta primero
-Oleada 2:  #4 (API sobre el modelo) ← espera a #2
-           #5 (CLI sobre el modelo) ← espera a #2
-Oleada 3:  #7 (docs de todo)        ← espera a #4 y #5
-```
-
-Dentro del job, las specs de cada oleada se implementan antes de que empiece la siguiente. Esto no lo configuras a mano — el orquestador deriva las oleadas de las propias specs. Velo desplegarse en la [vista de detalle del job](the-job-detail-view): el log en streaming va narrando en qué spec está el batch, y la cabecera de tickets muestra todas las specs que tocó el job.
-
-## Aislamiento por worktree y cómo se entrega el trabajo
-
-Cuando se implementan varias specs en una misma ejecución, el pipeline mantiene cada unidad de trabajo aislada para que los cambios concurrentes o secuenciales no se pisen los archivos. La implementación de cada spec se ejecuta en su propio **git worktree** limpio — un checkout aparte que comparte el historial de tu repositorio pero que nunca toca tu árbol de trabajo mientras la IA trabaja.
-
-Cuando la ejecución termina, **no se sube nada y todavía no se abre ninguna pull request**. El trabajo queda commiteado a salvo en sus ramas aisladas, las specs pasan a un nuevo estado **En revisión**, y specrails **te pregunta primero**: en el rail aparece una barra de decisión persistente con **Crear PR** — una única pull request en borrador partiendo de la rama de integración que hayas designado para tu proyecto (configúrala en **Ajustes → Rama de integración**; por defecto es la rama por defecto de tu repositorio), combinada a través de todas las specs del rail — y **Descartar**. specrails **nunca hace merge ni commitea directamente sobre tu rama de integración** — tú decides si siquiera existe una PR, y el merge lo decide una persona. Es el traspaso seguro: specrails produce la pull request solo cuando tú lo dices, y tus ingenieros la revisan y la mergean en GitHub como ya lo hacen.
-
-Si relanzas una spec que ya está en revisión y tiene una pull request abierta, Specrails lo trata como trabajo de seguimiento. Detecta la PR activa desde su propio registro de entrega o desde referencias de GitHub/Jira, hace checkout de la rama head de esa PR, commitea ahí los nuevos cambios y vuelve a mostrar la misma tarjeta de PR. El trabajo nuevo sigue empezando desde la rama de integración.
-
-En la práctica esto significa:
-
-- Cada spec recibe un lienzo en blanco contra el que implementar, en vez de heredar a mitad de camino las ediciones en vuelo de la spec anterior.
-- Tu árbol de trabajo nunca se modifica mientras la ejecución está en curso — nada aterriza hasta que tú lo digas.
-- Cuando la ejecución termina, las specs muestran una insignia **En revisión** y el rail te hace la pregunta: **Crear PR** para abrir la pull request en borrador combinada, o **Descartar** para limpiar las ramas y devolver las specs al backlog. Si lanzaste el rail desde el chat del agente, la misma pregunta aparece como una tarjeta en esa conversación — responde en cualquiera de los dos sitios: ambos se mantienen sincronizados.
-- Una vez creada, **Abrir PR** la muestra, **Publicar** la abre a revisión y la entrega a la revisión habitual de GitHub de tu equipo, y **Comprobar merge** pasa las specs a Hecho en cuanto tu equipo la haya mergeado.
-- Si las ramas aisladas no se pueden combinar limpiamente al crear la PR, specrails se detiene de forma segura y deja las ramas para una persona — nunca fuerza un merge roto sobre tu base. Puedes reintentar o descartar desde la misma barra.
-
-> Crear o continuar una PR requiere un repositorio git, la CLI de GitHub (`gh`) autenticada y un remoto configurado. Sin `gh` o sin remoto, specrails igualmente mantiene el trabajo commiteado en una rama desde la que puedes abrir tú mismo una pull request — no se pierde nada, y la barra de decisión te permite reintentar. Sin git en absoluto, no hay grafo de ramas que continuar: el rail se ejecuta en la carpeta compartida y no aparece ninguna tarjeta de PR. Para volver al comportamiento anterior (integrar en local en vez de preguntar), define `SPECRAILS_RAIL_DELIVER_PR=0`.
-
-## Multifuncionalidad entre proyectos
-
-Si quieres paralelismo de verdad, usa varios rails para specs independientes dentro del mismo proyecto respaldado por git, o reparte el trabajo entre proyectos. Cada rail activo recibe su propio worktree aislado, así que:
-
-```
-Proyecto A   ▶ Rail ejecutando la funcionalidad X   ┐
-                                                    ├─ se ejecutan a la vez
-Proyecto B   ▶ Rail ejecutando la funcionalidad Y   ┘
-```
-
-No hay límite global de concurrencia que ajustar. Abre los proyectos o rails que necesites, lánzalos y avanzarán juntos. El único freno compartido es tu tope de presupuesto, que pausa las colas por proyecto o de toda la app en cuanto el gasto del día llega al límite.
-
-## Consejos para batches grandes
-
-- **Agrupa specs relacionadas en un mismo rail** antes de pasar a Batch — las oleadas por dependencias solo ven lo que hay en ese rail.
-- **Fija un presupuesto diario** antes de un batch grande para que una ejecución inesperadamente cara se pause sola en vez de desbocarse. Configúralo en [Presupuesto](../settings/customizing).
-- **Usa el botón Comparar** en la página Jobs después para enfrentar dos ejecuciones de batch lado a lado.
-- **Exporta un diagnóstico** (si la telemetría estaba activada) para obtener la instantánea exacta de perfil + plugins de todo el batch.
-
-## A dónde ir después
-
-- [Rails y jobs](rails-and-jobs) — el modelo de cola en profundidad.
-- [La vista de detalle del job](the-job-detail-view) — mira un batch ejecutarse en vivo.
-- [Elegir un motor por rail](picking-an-engine-per-rail) — Batch corre en cualquier proveedor; Freestyle está disponible con Claude y Kimi.
-
-
-## Interpretar el resultado de Implement
-
-Con un runtime de Core que admita evidencia de aceptación, el resultado muestra cuatro
-estados separados: implementación, validación, archivo y entrega. «Verificada con
-excepciones» conserva las interpretaciones aceptadas y los checks complementarios
-fallidos o no disponibles. «Pendiente del host» indica que Core no ha realizado la
-entrega que corresponde al host, aunque el cambio ya esté archivado.
-
-Abre **Evidencia, excepciones y tiempos por fase** para consultar decisiones,
-referencias de aprobación, alcance y limitaciones de las mediciones, conclusiones de
-revisión y tiempos registrados. Los checks obligatorios fallidos y los requisitos
-sin resolver bloquean la aceptación. Un benchmark de Node no demuestra el rendimiento
-de renderizado del navegador. Los cambios materiales requieren autorización previa
-del usuario o del host; el reviewer puede aceptar interpretaciones menores dejando
-constancia de su motivo e impacto.
-
-El éxito de ejecución describe el proceso. Si el runtime informa de implementación
-incompleta o validación bloqueada/pendiente, Desktop cierra el run como bloqueado y
-no completa sus tickets. Con runtimes antiguos o no disponibles, la evidencia aparece
-como no disponible: el éxito del proceso por sí solo no prueba la aceptación.
-El resultado se registra al terminar; no revalida modificaciones posteriores.
-
-Los contadores distinguen pasos ejecutados, evaluaciones del decider y turnos del
-agente. Un Implement integrado puede tener un paso, cero evaluaciones y muchos turnos.
-Se muestran tiempos e intentos por fase de Core cuando están registrados; el coste por
-fase no está disponible porque el consumo se atribuye a pasos del loop. Los receipts
-completos se reutilizan mientras sus entradas sigan vigentes: cada fase no necesita
-repetir la misma suite completa.

package/docs/guide/fr/pipeline/3-batch-implement-and-multi-feature.md

@@ -1,84 +0,0 @@
-# Batch implement et multi-fonctionnalité
-
-Une spec à la fois, c'est très bien, mais beaucoup de travail réel arrive par grappes — une fonctionnalité plus ses tests plus sa migration, ou un backlog que vous voulez vider d'une traite. Cette page couvre l'exécution de plusieurs specs ensemble : le mode Batch, les vagues de dépendances, et comment le pipeline empêche le travail concurrent d'entrer en collision.
-
-## Exécuter plusieurs specs à la fois
-
-La façon la plus simple de lancer une pile de specs depuis un seul rail, c'est le mode **Batch** :
-
-1. **Glissez toutes les specs** que vous voulez sur un même rail. Elles s'empilent dans la liste de specs de ce rail.
-2. **Basculez le mode du rail sur Batch** (le sélecteur segmenté dans l'en-tête du rail).
-3. **Appuyez sur ▶ Play.**
-
-Le rail lance **un** job `/specrails:batch-implement` qui traite chaque spec assignée. Suivez-le comme n'importe quel autre job sur la page Jobs — c'est un seul job couvrant tout l'ensemble, pas un job par spec.
-
-Le mode Batch reste le moyen le plus propre de *séquencer* des specs liées, car il garde leur ordre de dépendances dans un seul rail. Si les specs sont indépendantes, vous pouvez aussi les répartir sur plusieurs rails : les rails adossés à git s'exécutent en parallèle et chacun reçoit son propre worktree isolé.
-
-### Implement vs Batch — quel mode ?
-
-| | **Implement** | **Batch** |
-|---|---|---|
-| Commande | `/specrails:implement` | `/specrails:batch-implement` |
-| Specs par job | Toutes celles du rail, traitées comme une seule unité de travail | Toutes celles du rail, traitées **séquentiellement** |
-| Idéal pour | Un changement fortement couplé | Plusieurs fonctionnalités distinctes que vous voulez traiter dans l'ordre |
-| Ordonnancement | s/o | Vagues tenant compte des dépendances (voir ci-dessous) |
-
-Si les specs ne forment réellement qu'un seul changement, utilisez **Implement**. Si c'est une liste de fonctionnalités séparées, utilisez **Batch** et laissez-le les séquencer.
-
-## Vagues de dépendances
-
-Le mode Batch ne se contente pas d'exécuter les specs de haut en bas — il calcule un **ordre d'exécution tenant compte des dépendances** et regroupe les specs en *vagues*. L'orchestrateur (`/specrails:batch-implement`) détermine quelles specs dépendent de quelles autres, puis les planifie de sorte que rien ne s'exécute avant le travail sur lequel il s'appuie.
-
-Conceptuellement :
-
-```
-Vague 1 :  #2 (modèle de données)   ← aucune dépendance, s'exécute en premier
-Vague 2 :  #4 (API sur le modèle)   ← attend #2
-           #5 (CLI sur le modèle)   ← attend #2
-Vague 3 :  #7 (docs sur l'ensemble) ← attend #4 et #5
-```
-
-Au sein du job, les specs de chaque vague sont implémentées avant que la vague suivante ne commence. Vous ne configurez rien à la main — l'orchestrateur déduit les vagues à partir des specs elles-mêmes. Regardez-le se dérouler dans la [vue détaillée du job](the-job-detail-view) : le log en streaming raconte sur quelle spec le batch travaille, et l'en-tête de ticket affiche chaque spec touchée par le job.
-
-## Isolation par worktree et livraison du travail
-
-Lorsque plusieurs specs sont implémentées en une seule exécution, le pipeline garde chaque unité de travail isolée pour que les changements concurrents ou séquentiels ne piétinent pas les fichiers des autres. L'implémentation de chaque spec s'exécute dans son propre **worktree git** propre — un checkout séparé qui partage l'historique de votre dépôt mais ne touche jamais votre arbre de travail pendant que l'IA travaille.
-
-Lorsque l'exécution se termine, **rien n'est poussé et aucune pull request n'est encore ouverte**. Le travail reste commité en sécurité sur ses branches isolées, les specs passent à un nouveau statut **En relecture**, et specrails **vous demande d'abord** : une barre de décision persistante apparaît sur le rail avec **Créer la PR** — une seule pull request en brouillon à partir de la branche d'intégration désignée de votre projet (définissez-la dans **Réglages → Branche d'intégration** ; par défaut, c'est la branche par défaut de votre dépôt), combinée à travers toutes les specs du rail — et **Abandonner**. specrails **ne fusionne jamais, et ne commite jamais directement sur votre branche d'intégration** — c'est vous qui décidez si une PR existe tout court, et c'est un humain qui décide de la fusion. C'est le passage de relais sûr : specrails produit la pull request seulement quand vous le décidez, et vos ingénieurs la relisent et la fusionnent dans GitHub comme ils le font déjà.
-
-Si vous relancez une spec déjà en relecture avec une pull request ouverte, Specrails traite cela comme un travail de suivi. Il détecte la PR active depuis son propre registre de livraison ou depuis les références GitHub/Jira, checkout la branche head de cette PR, y commite les nouveaux changements et réaffiche la même carte de PR. Le nouveau travail continue de partir de la branche d'intégration.
-
-En pratique, cela signifie :
-
-- Chaque spec part d'une page blanche pour son implémentation, plutôt que d'hériter des modifications en cours de la spec précédente.
-- Votre arbre de travail n'est jamais modifié pendant que l'exécution est en cours — rien n'est intégré tant que vous ne l'avez pas décidé.
-- Lorsque l'exécution est terminée, les specs affichent un badge **En relecture** et le rail vous pose la question : **Créer la PR** pour ouvrir la pull request en brouillon combinée, ou **Abandonner** pour nettoyer les branches et renvoyer les specs au backlog. Si vous avez lancé le rail depuis le chat de l'agent, la même question apparaît sous forme de carte dans cette conversation — répondez à l'un ou l'autre endroit, les deux restent synchronisés.
-- Une fois créée, **Ouvrir la PR** permet de la consulter, **Publier** l'ouvre à la relecture et la confie au processus de relecture GitHub habituel de votre équipe, et **Vérifier le merge** fait passer les specs à Terminé dès que votre équipe l'a fusionnée.
-- Si les branches isolées ne peuvent pas être combinées proprement au moment de créer la PR, specrails s'arrête en toute sécurité et laisse les branches à un humain — il ne force jamais une fusion cassée sur votre branche de base. Vous pouvez réessayer ou abandonner depuis la même barre.
-
-> Créer ou continuer une PR nécessite un dépôt git, le CLI GitHub (`gh`) authentifié et un dépôt distant configuré. Sans `gh` ou sans remote, specrails garde quand même le travail commité sur une branche à partir de laquelle vous pouvez ouvrir une pull request vous-même — rien n'est perdu, et la barre de décision vous permet de réessayer. Sans git du tout, il n'existe pas de graphe de branches à continuer : le rail s'exécute dans le dossier partagé et aucune carte de PR n'apparaît. Pour revenir à l'ancien comportement (intégrer en local au lieu de demander), définissez `SPECRAILS_RAIL_DELIVER_PR=0`.
-
-## Multi-fonctionnalité entre projets
-
-Si vous voulez un vrai parallélisme, utilisez plusieurs rails pour des specs indépendantes dans le même projet adossé à git, ou répartissez le travail entre projets. Chaque rail actif reçoit son propre worktree isolé, donc :
-
-```
-Projet A   ▶ Rail exécutant la fonctionnalité X   ┐
-                                                  ├─ s'exécutent simultanément
-Projet B   ▶ Rail exécutant la fonctionnalité Y   ┘
-```
-
-Il n'y a aucune limite globale de concurrence à régler. Ouvrez les projets ou rails dont vous avez besoin, lancez-les, et ils progressent ensemble. Le seul régulateur partagé est votre plafond de budget, qui met les files en pause par projet ou pour toute l'application dès que la dépense du jour atteint la limite.
-
-## Conseils pour les gros batchs
-
-- **Regroupez les specs liées sur un seul rail** avant de basculer en Batch — les vagues de dépendances ne voient que ce qui se trouve sur ce rail.
-- **Définissez un budget quotidien** avant un gros batch pour qu'une exécution inopinément coûteuse se mette en pause automatiquement au lieu de s'emballer. Configurez-le sous [Budget](../settings/customizing).
-- **Utilisez le bouton Comparer** sur la page Jobs ensuite pour comparer deux exécutions de batch côte à côte.
-- **Exportez un diagnostic** (si la télémétrie était active) pour obtenir l'instantané exact du profil et des plugins de tout le batch.
-
-## Où aller ensuite
-
-- [Rails et jobs](rails-and-jobs) — le modèle de file d'attente en détail.
-- [La vue détaillée du job](the-job-detail-view) — regarder un batch s'exécuter en direct.
-- [Choisir un moteur par rail](picking-an-engine-per-rail) — Batch fonctionne avec tous les fournisseurs ; Freestyle est disponible avec Claude et Kimi.