@orkastery/cli 0.5.3 → 0.6.0

package/dist/locale-phase.js

@@ -0,0 +1,151 @@
+"use strict";
+/**
+ * RM-061, fatia F2a: a familia `phase` do catalogo de mensagens (`ork phase list` e o resumo de
+ * `ork phase run`). O pt-BR e a fonte; o ingles e tipado por ele. Sem import do nucleo.
+ *
+ * O que o despacho grava e dado e sai como foi gravado: o erro do ledger, a recusa de conducao
+ * registrada, o detalhe e a correcao de uma policy avaliada, a decisao autonoma, o estado e o
+ * veredito de um evento. O catalogo traduz a moldura que o comando monta em volta deles.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PHASE_EN = exports.PHASE_PT_BR = void 0;
+exports.PHASE_PT_BR = {
+    // ork phase list
+    ledgerVazio: (id) => `Ledger vazio para a thread ${id}.`,
+    colunas: ['QUANDO', 'EVENTO', 'DETALHE'],
+    sessao: (id) => `sessao ${id}`,
+    pausaSobre: (sobre) => `pausa sobre ${sobre}`,
+    noRuntime: (encontrada) => `no runtime: ${encontrada ? 'sim' : 'nao'}`,
+    modelo: (modelo, esforco) => `modelo ${modelo}/${esforco}`,
+    motivo: (motivo) => `motivo ${motivo}`,
+    veredito: (veredito) => `veredito: ${veredito}`,
+    ocupacao: (ocupacao, fonte) => `ocupacao ${ocupacao === null ? 'nao medivel' : ocupacao} (${fonte})`,
+    proximoSlug: (slug) => `proximo slug ${slug}`,
+    acao: (acao) => `acao ${acao}`,
+    pedido: (pedido) => `pedido ${pedido}`,
+    rodada: (rodada) => `rodada ${rodada}`,
+    cobertura: (cobertura) => `cobertura ${cobertura}`,
+    liberaEm: (quando) => `libera em ${quando}`,
+    tentativa: (tentativa, limite) => `tentativa ${tentativa}/${limite}`,
+    remoto: (sha) => `remoto ${sha}`,
+    pushProvado: (provado) => `push provado: ${provado ? 'sim' : 'nao'}`,
+    autorizadoPor: (quem) => `autorizado por ${quem}`,
+    sobre: (sobre) => `sobre ${sobre}`,
+    ensaio: 'ensaio (--dry-run)',
+    worktreeEm: (branch, dir) => `${branch} em ${dir}`,
+    triagem: (inline, ponteiros, resumos) => `triagem ${inline} inline / ${ponteiros} ponteiros / ${resumos} resumos`,
+    ponteiro: (local) => `ponteiro ${local}`,
+    erro: (erro) => `erro: ${erro}`,
+    modo: (modo) => `modo ${modo}`,
+    usoList: 'uso: ork phase list <thread-id>',
+    // ork phase run
+    usoRun: 'uso: ork phase run <thread-id> <FASE> --prompt "<texto>"',
+    canalUso: 'uso: --canal <claude-code|hermes|openclaw|codex|mcp|cli>',
+    esperarUso: 'uso: --esperar [minutos], de 1 a 1440 (sem valor, 30)',
+    aviso: (aviso) => `aviso: ${aviso}`,
+    /** Rotulo do resumo (`  slug da sessao : valor`), na largura de 14. */
+    rotulos: { slug: 'slug da sessao', prompt: 'prompt', sha256: 'sha256', pausaAoFim: 'pausa ao fim', runtime: 'runtime',
+        modelo: 'modelo/esforco', comando: 'comando', sessionId: 'sessionId' },
+    simulacao: 'Simulacao (--dry-run), nada foi despachado.',
+    simNao: (sim) => sim ? 'sim' : 'nao',
+    despachada: (fase) => `Fase ${fase} despachada como background agent.`,
+    modeloGravado: (modelo, esforco) => `${modelo}/${esforco} (gravado no ledger, veja \`ork phase list\`)`,
+    verificada: (sim) => `  verificada no runtime: ${sim ? 'sim' : 'NAO (confira `ork sessions`)'}`,
+    pausaNoFim: (sim) => `  pausa ao fim do bloco: ${sim ? 'sim' : 'nao (decisao autonoma no ledger)'}`,
+    acompanheClaude: (sessao, id) => `Acompanhe: claude attach ${sessao}  |  ork phase list ${id}`,
+    acompanhe: (id) => `Acompanhe: ork phase list ${id} (eventos do despacho no log da thread)`,
+    vagaRecusada: (ocupam, limite) => `Despacho recusado: concurrency.limite. O projeto ja tem ${ocupam} sessao(oes) viva(s) ` +
+        `em outras threads e o limite e ${limite} (concurrency.max_parallel_threads).`,
+    despachoEmCurso: 'despacho em curso',
+    desde: (quando) => `desde ${quando}`,
+    correcao: (correcao) => `  correcao: ${correcao}`,
+    vagaEnsaio: '  ensaio (--dry-run): nada foi gravado.',
+    vagaLedger: (id) => `  evento slot_refused no ledger de ${id}; nenhuma sessao aberta.`,
+    recusado: (erro) => `Despacho recusado: ${erro}`,
+    baselinePendente: '  nenhuma sessao aberta; o ledger nao ganhou gate_blocked',
+    bloqueado: (motivo) => `Despacho BLOQUEADO pelo gate tipado: ${motivo}`,
+    violacaoCorrecao: (correcao) => `           correcao: ${correcao}`,
+    promptNaoGravado: (id) => `  o prompt nao foi gravado em disco; evento gate_blocked no ledger de ${id}`,
+    falhou: (erro) => `Despacho falhou: ${erro}`,
+    falhouLedger: (id) => `  evento registrado no ledger de ${id}`,
+    repetido: (fase, id, sha, desde) => `Pedido ja em andamento: a fase ${fase} da thread ${id} roda com este mesmo prompt ` +
+        `(sha256 ${sha}) desde ${desde}. Nenhuma sessao nova foi aberta e nenhuma cota foi gasta.`,
+    acompanhar: (comando) => `  acompanhar: ${comando}`,
+    /** Aviso de policy em `warn` (policies.ts): o detalhe e a correcao sao dado da policy avaliada. */
+    avisoDaPolicy: (recuo, policy, detalhe) => `${recuo}aviso da policy ${policy}: ${detalhe}`,
+    avisoCorrecao: (recuo, correcao) => `${recuo}  correcao: ${correcao}`,
+    // thread.ts
+    faseInvalida: (bruto, fases) => `fase invalida: "${bruto}" (esperado uma de ${fases})`,
+    /** D14: erros de argumento de `phase run` que nascem no escopo pt-BR do despacho (`ErroDoCatalogo`). */
+    runtimeDesconhecido: (nome, homologados) => `runtime de despacho desconhecido: "${nome}" (homologados: ${homologados})`,
+    modeloAoTrocarRuntime: (origem, runtime) => `setup.model.required: ao trocar runtime de ${origem} para ${runtime}, ` +
+        `informe --runtime ${runtime} --model <modelo> para este despacho; o setup do projeto permanece intacto.`,
+    modeloPendente: (runtime) => `setup.model.required: modelo pendente para ${runtime}; informe --model <modelo> neste despacho ou complete o bloco em ork setup.`,
+};
+exports.PHASE_EN = {
+    ledgerVazio: (id) => `Empty ledger for thread ${id}.`,
+    colunas: ['WHEN', 'EVENT', 'DETAIL'],
+    sessao: (id) => `session ${id}`,
+    pausaSobre: (sobre) => `pause on ${sobre}`,
+    noRuntime: (encontrada) => `in the runtime: ${encontrada ? 'yes' : 'no'}`,
+    modelo: (modelo, esforco) => `model ${modelo}/${esforco}`,
+    motivo: (motivo) => `reason ${motivo}`,
+    veredito: (veredito) => `verdict: ${veredito}`,
+    ocupacao: (ocupacao, fonte) => `occupancy ${ocupacao === null ? 'not measurable' : ocupacao} (${fonte})`,
+    proximoSlug: (slug) => `next slug ${slug}`,
+    acao: (acao) => `action ${acao}`,
+    pedido: (pedido) => `request ${pedido}`,
+    rodada: (rodada) => `round ${rodada}`,
+    cobertura: (cobertura) => `coverage ${cobertura}`,
+    liberaEm: (quando) => `released at ${quando}`,
+    tentativa: (tentativa, limite) => `attempt ${tentativa}/${limite}`,
+    remoto: (sha) => `remote ${sha}`,
+    pushProvado: (provado) => `push proven: ${provado ? 'yes' : 'no'}`,
+    autorizadoPor: (quem) => `authorized by ${quem}`,
+    sobre: (sobre) => `about ${sobre}`,
+    ensaio: 'dry run (--dry-run)',
+    worktreeEm: (branch, dir) => `${branch} at ${dir}`,
+    triagem: (inline, ponteiros, resumos) => `triage ${inline} inline / ${ponteiros} pointers / ${resumos} summaries`,
+    ponteiro: (local) => `pointer ${local}`,
+    erro: (erro) => `error: ${erro}`,
+    modo: (modo) => `mode ${modo}`,
+    usoList: 'usage: ork phase list <thread-id>',
+    usoRun: 'usage: ork phase run <thread-id> <PHASE> --prompt "<text>"',
+    canalUso: 'usage: --canal <claude-code|hermes|openclaw|codex|mcp|cli>',
+    esperarUso: 'usage: --esperar [minutes], from 1 to 1440 (no value: 30)',
+    aviso: (aviso) => `warning: ${aviso}`,
+    rotulos: { slug: 'session slug', prompt: 'prompt', sha256: 'sha256', pausaAoFim: 'pause at end', runtime: 'runtime',
+        modelo: 'model/effort', comando: 'command', sessionId: 'sessionId' },
+    simulacao: 'Dry run (--dry-run): nothing was dispatched.',
+    simNao: (sim) => sim ? 'yes' : 'no',
+    despachada: (fase) => `Phase ${fase} dispatched as a background agent.`,
+    modeloGravado: (modelo, esforco) => `${modelo}/${esforco} (recorded in the ledger, see \`ork phase list\`)`,
+    verificada: (sim) => `  verified in the runtime: ${sim ? 'yes' : 'NO (check `ork sessions`)'}`,
+    pausaNoFim: (sim) => `  pause at block end: ${sim ? 'yes' : 'no (autonomous decision in the ledger)'}`,
+    acompanheClaude: (sessao, id) => `Follow: claude attach ${sessao}  |  ork phase list ${id}`,
+    acompanhe: (id) => `Follow: ork phase list ${id} (dispatch events in the thread log)`,
+    vagaRecusada: (ocupam, limite) => `Dispatch refused: concurrency.limite. The project already has ${ocupam} live session(s) ` +
+        `in other threads and the limit is ${limite} (\`concurrency.max_parallel_threads\`).`,
+    despachoEmCurso: 'dispatch in progress',
+    desde: (quando) => `since ${quando}`,
+    correcao: (correcao) => `  fix: ${correcao}`,
+    vagaEnsaio: '  dry run (--dry-run): nothing was written.',
+    vagaLedger: (id) => `  slot_refused event in the ${id} ledger; no session opened.`,
+    recusado: (erro) => `Dispatch refused: ${erro}`,
+    baselinePendente: '  no session opened; the ledger did not get gate_blocked',
+    bloqueado: (motivo) => `Dispatch BLOCKED by the typed gate: ${motivo}`,
+    violacaoCorrecao: (correcao) => `           fix: ${correcao}`,
+    promptNaoGravado: (id) => `  the prompt was not written to disk; gate_blocked event in the ${id} ledger`,
+    falhou: (erro) => `Dispatch failed: ${erro}`,
+    falhouLedger: (id) => `  event recorded in the ${id} ledger`,
+    repetido: (fase, id, sha, desde) => `Request already in progress: phase ${fase} of thread ${id} runs with this same prompt ` +
+        `(sha256 ${sha}) since ${desde}. No new session was opened and no quota was spent.`,
+    acompanhar: (comando) => `  follow: ${comando}`,
+    avisoDaPolicy: (recuo, policy, detalhe) => `${recuo}policy ${policy} warning: ${detalhe}`,
+    avisoCorrecao: (recuo, correcao) => `${recuo}  fix: ${correcao}`,
+    faseInvalida: (bruto, fases) => `invalid phase: "${bruto}" (expected one of ${fases})`,
+    runtimeDesconhecido: (nome, homologados) => `unknown dispatch runtime: "${nome}" (supported: ${homologados})`,
+    modeloAoTrocarRuntime: (origem, runtime) => `setup.model.required: switching the runtime from ${origem} to ${runtime} needs a model; ` +
+        `pass \`--runtime ${runtime} --model <model>\` for this dispatch. The project setup stays as it is.`,
+    modeloPendente: (runtime) => `setup.model.required: no model set for ${runtime}; pass \`--model <model>\` in this dispatch or complete the block with \`ork setup\`.`,
+};

package/dist/locale-projetos.js

@@ -0,0 +1,100 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PROJETOS_EN = exports.PROJETOS_PT_BR = void 0;
+/** RM-061 F3d: registro e seleção de projetos, sem importar o núcleo. */
+exports.PROJETOS_PT_BR = {
+    candidatos: 'Candidatos:', semRemoto: 'sem remoto', ausente: 'ausente do disco',
+    ocupado: (trava) => `registro de projetos ocupado (${trava}); tente de novo`,
+    segredoConteudo: 'registro de projetos recusado: o conteudo parece carregar segredo',
+    segredoEntrada: 'registro de projetos recusado: a entrada parece carregar segredo',
+    semManifesto: (caminho) => `nenhum manifesto do ork em ${caminho}`,
+    rodeInit: 'Rode `ork init` na raiz do projeto antes de registrá-lo.',
+    manifestoInvalido: (caminho) => `registro de projetos: manifesto inválido em ${caminho}`,
+    naoRegistrado: (valor) => `"${valor}" não está no registro de projetos desta máquina`,
+    vejaRegistrados: 'Veja os registrados com `ork projetos`.',
+    caminhoNaoExiste: (caminho) => `o caminho ${caminho} não existe`,
+    informeRaiz: 'Informe o caminho da raiz de um projeto com orkastery.yaml, ou o nome de um projeto registrado (`ork projetos`).',
+    yamlAusente: (caminho) => `nenhum orkastery.yaml em ${caminho} nem acima dele`,
+    initOuNome: 'Rode `ork init` na raiz do projeto, ou informe o nome de um projeto registrado (`ork projetos`).',
+    nomeInvalido: (valor) => `"${valor}" não é um nome de projeto válido`,
+    useNome: 'Use o nome ou o abbrev de um projeto de `ork projetos`.',
+    ambiguo: (valor, total) => `"${valor}" casa ${total} projetos registrados nesta máquina`,
+    escolhaRaiz: 'Repita com o caminho da raiz (`--projeto <caminho>`), ou tire a cópia que sobra com `ork projetos esquecer <caminho>`.',
+    semManifestoRegistrado: (valor) => `"${valor}" está registrado, mas o manifesto não está mais na raiz`,
+    registreCopia: 'Veja os registrados com `ork projetos`; registre uma cópia com `ork projetos registrar <caminho>`.',
+    ofertaRede: 'Para ver todos os projetos e as threads de todas as máquinas sem escolher, com a fonte e a hora de cada parte: ' +
+        '`ork network roadmap` (tool ork_network_roadmap).',
+    opcaoSemValor: '--projeto sem valor',
+    usoOpcao: 'Uso: --projeto <nome|caminho>; os nomes registrados estão em `ork projetos`.',
+    hostCaminho: (valor) => `no host o projeto vem pelo nome registrado; o caminho "${valor}" não é aceito`,
+    hostUseNome: 'Use o nome de um projeto de `ork projetos` (ex.: --projeto orkastery).',
+    precisaEscolher: (total) => `${total} projetos conhecidos nesta máquina e nenhum foi pedido; o ork não escolhe pelo diretório do gateway`,
+    repitaEscolha: (oferta) => 'Repita com o projeto pedido: parâmetro `projeto` da tool, ou `--projeto <nome>`. ' + oferta,
+    nenhum: 'nenhum projeto conhecido nesta máquina e nenhum foi pedido',
+    registrePrimeiro: 'Registre o projeto com `ork projetos registrar <caminho>` (ou `ork init` na raiz dele) e repita com o nome. ' +
+        'Sem clone nesta máquina, o roadmap de um projeto vem da forja: `ork network roadmap --projeto github:dono/repo` (tool ork_network_roadmap).',
+    avisoTemporario: (raiz, registro) => `aviso: projeto em pasta temporária (${raiz}) não entra no registro desta máquina ` +
+        `(${registro}); para registrá-lo mesmo assim: ork projetos registrar ${raiz}`,
+    avisoRegistro: (registro, erro) => `aviso: projeto não registrado em ${registro} (${erro})`,
+    cli: {
+        titulo: (arquivo) => `Projetos conhecidos desta maquina (${arquivo})`,
+        nenhum: '  Nenhum ainda. ork init, ork thread new e ork fabrica entrar registram; ou: ork projetos registrar <caminho>',
+        cabecalho: ['NOME', 'ABBREV', 'RAIZ', 'REMOTO', 'NO DISCO', 'ATUALIZADO'],
+        sim: 'sim', ausente: 'ausente', semRemoto: 'sem remoto',
+        selecao: 'Use --projeto <nome> em qualquer comando (ORK_PROJETO vale para o shell inteiro).',
+        usoRegistrar: 'uso: ork projetos registrar [caminho] (um caminho ou --projeto, não os dois)',
+        registrado: (nome, abbrev, raiz, remoto) => `Projeto ${nome} (${abbrev}) registrado: ${raiz} · ${remoto}`,
+        usoEsquecer: 'uso: ork projetos esquecer <nome|caminho>',
+        esquecido: (nome, raiz) => `Projeto ${nome} esquecido: ${raiz} (nada no disco foi apagado)`,
+        desconhecido: (sub) => `subcomando desconhecido: projetos ${sub}`,
+        uso: 'uso: ork projetos [--json] | projetos registrar [caminho] | projetos esquecer <nome|caminho>',
+    },
+};
+exports.PROJETOS_EN = {
+    candidatos: 'Candidates:', semRemoto: 'no remote', ausente: 'missing from disk',
+    ocupado: (lock) => `project registry busy (${lock}); try again`,
+    segredoConteudo: 'project registry refused: its content appears to contain a secret',
+    segredoEntrada: 'project registry refused: the entry appears to contain a secret',
+    semManifesto: (path) => `no ork manifest in ${path}`,
+    rodeInit: 'Run `ork init` at the project root before registering it.',
+    manifestoInvalido: (path) => `project registry: invalid manifest at ${path}`,
+    naoRegistrado: (value) => `"${value}" is not in this machine's project registry`,
+    vejaRegistrados: 'View registered projects with `ork projetos`.',
+    caminhoNaoExiste: (path) => `path ${path} does not exist`,
+    informeRaiz: 'Provide the root path of a project with orkastery.yaml, or the name of a registered project (`ork projetos`).',
+    yamlAusente: (path) => `no orkastery.yaml in ${path} or any parent directory`,
+    initOuNome: 'Run `ork init` at the project root, or provide the name of a registered project (`ork projetos`).',
+    nomeInvalido: (value) => `"${value}" is not a valid project name`,
+    useNome: 'Use the name or abbrev of a project from `ork projetos`.',
+    ambiguo: (value, total) => `"${value}" matches ${total} projects registered on this machine`,
+    escolhaRaiz: 'Repeat with the root path (`--projeto <path>`), or remove the stale copy with `ork projetos esquecer <path>`.',
+    semManifestoRegistrado: (value) => `"${value}" is registered, but its manifest is no longer at the root`,
+    registreCopia: 'View projects with `ork projetos`; register a copy with `ork projetos registrar <path>`.',
+    ofertaRede: 'To view all projects and threads from every machine without choosing one, including each source and timestamp: ' +
+        '`ork network roadmap` (tool ork_network_roadmap).',
+    opcaoSemValor: '--projeto has no value',
+    usoOpcao: 'Usage: --projeto <name|path>; registered names are listed by `ork projetos`.',
+    hostCaminho: (value) => `on a host, select a project by its registered name; path "${value}" is not accepted`,
+    hostUseNome: 'Use a project name from `ork projetos` (for example: --projeto orkastery).',
+    precisaEscolher: (total) => `${total} projects are known on this machine and none was requested; ork does not choose from the gateway directory`,
+    repitaEscolha: (offer) => "Repeat with the requested project: the tool's `projeto` parameter, or `--projeto <name>`. " + offer,
+    nenhum: 'no project is known on this machine and none was requested',
+    registrePrimeiro: 'Register the project with `ork projetos registrar <path>` (or `ork init` at its root), then repeat with its name. ' +
+        'Without a clone on this machine, read a project roadmap from the forge: `ork network roadmap --projeto github:owner/repo` (tool ork_network_roadmap).',
+    avisoTemporario: (root, registry) => `warning: project in a temporary folder (${root}) is not added to this machine's registry ` +
+        `(${registry}); to register it anyway: ork projetos registrar ${root}`,
+    avisoRegistro: (registry, error) => `warning: project was not registered in ${registry} (${error})`,
+    cli: {
+        titulo: (file) => `Projects known on this machine (${file})`,
+        nenhum: '  None yet. ork init, ork thread new, and ork fabrica entrar register projects; or run: ork projetos registrar <path>',
+        cabecalho: ['NAME', 'ABBREV', 'ROOT', 'REMOTE', 'ON DISK', 'UPDATED'],
+        sim: 'yes', ausente: 'missing', semRemoto: 'no remote',
+        selecao: 'Use --projeto <name> with any command (ORK_PROJETO applies to the whole shell).',
+        usoRegistrar: 'usage: ork projetos registrar [path] (use either a path or --projeto, not both)',
+        registrado: (name, abbrev, root, remote) => `Project ${name} (${abbrev}) registered: ${root} · ${remote}`,
+        usoEsquecer: 'usage: ork projetos esquecer <name|path>',
+        esquecido: (name, root) => `Project ${name} forgotten: ${root} (nothing was deleted from disk)`,
+        desconhecido: (sub) => `unknown subcommand: projetos ${sub}`,
+        uso: 'usage: ork projetos [--json] | projetos registrar [path] | projetos esquecer <name|path>',
+    },
+};

package/dist/locale-prompts.js

@@ -0,0 +1,194 @@
+"use strict";
+/** RM-061 F3c: texto dos prompts de fase e da familia `ork prompt`. PT-BR e a fonte tipada. */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PROMPTS_EN = exports.PROMPTS_PT_BR = void 0;
+const locale_thread_1 = require("./locale-thread");
+exports.PROMPTS_PT_BR = {
+    contratoDasFases: {
+        GOAL: 'GOAL (F1): objetivo verificavel, impact map, criterios de sucesso e claims com comando de verificacao. Nao implementa.',
+        PLAN: 'PLAN (F2): plano com tarefas, touch_paths, decisoes D1..Dn com domicilio unico e verify executavel por tarefa. Nao implementa.',
+        GO: 'GO (F3): implementacao slice por slice, um commit atomico por tarefa, dentro da worktree da thread.',
+        CHECK: 'CHECK (F4): verificacao contra a baseline (regressao versus divida pre-existente), review de codigo, testes, seguranca e performance; ' +
+            'o parecer diz o modo do CHECK da rodada (Agile Check ou Classic Check, da linha `check` do `ork verify`).',
+        SHIP: 'SHIP (F5): merge serializado, push provado por comando, roadmap atualizado e plano de rollback.',
+        MASTER: 'MASTER (F6): MASTER log com postmortem tipado, licoes e o score humano de 0 a 5. Uma entrega sem MASTER log nao aconteceu.',
+    },
+    invariantes: [
+        'Claims, verify e policies rodam identicos em todos os modos.',
+        'Policy `block` pausa qualquer modo, inclusive #Auto.',
+        'Escalacao tipada para humano pausa qualquer modo, inclusive #Auto.',
+        'Toda entrega fecha com indice derivado do ledger; a nota humana, quando vier, sobrescreve.',
+        'Toda decisao autonoma vai ao ledger com quem decidiu, evidencia e razao.',
+    ],
+    variante: (v) => `Variante de ciclo: ${v}`,
+    pausaSobre: (s) => s,
+    pausa: (sobre) => `Ao fim deste bloco HA PAUSA humana sobre: ${sobre}. Pare, apresente a evidencia e espere o veredito.`,
+    semPausa: 'Ao fim deste bloco NAO ha pausa humana: siga com decisao autonoma e registre no ledger quem decidiu, com que evidencia e por que.',
+    raizDoProjeto: '(raiz do projeto)',
+    regrasDeEvidencia: [
+        'Nada de self-report: toda alegacao vem com o comando que a comprova e a saida real.',
+        'Trabalhe apenas no diretorio de trabalho indicado acima.',
+        'Passos irreversiveis (push, merge, delecao) so acontecem quando o modo autoriza.',
+    ],
+    regraDasEsperas: 'Esperas: nunca dispare verify, build ou suite com `&` dentro do comando, porque o processo se perde e a sessao ' +
+        'espera um aviso que nunca vem; rode o `ork verify` em primeiro plano, com `timeout` (ele espera a vez na fila de ' +
+        'recursos pesados), ou use a execucao em segundo plano do host, que avisa quando termina; nunca espere com ' +
+        '`pgrep -f` cujo padrao aparece no proprio comando, porque o laco acha a si mesmo e nao termina: espere pelo ' +
+        'arquivo de saida com prazo, ou pelo PID guardado.',
+    fechoDoGo: (t) => [
+        '## Fecho obrigatório do GO',
+        '',
+        `Antes de encerrar o bloco com GO, rode \`ork verify ${t}\` e o build declarado no manifesto, ambos em primeiro plano.`,
+        `Gere o bundle com \`ork ci prepare ${t}\` e faça o commit atômico final \`ci(${t}): bundle ...\`.`,
+        `Grave \`.orkastery/threads/${t}/pr-body.md\` curto, no idioma do projeto, com o modo do CHECK da rodada (Agile Check ou Classic Check, da linha \`check\` do \`ork verify\`); ` +
+            'se o perfil não puder gravá-lo pelo transporte autorizado, devolva o corpo completo no resumo final.',
+        'O rito é idêntico em Claude Code e Codex. Ele fecha o GO, mas não autoriza SHIP, push, PR ou merge.',
+    ].join('\n'),
+    contextoDoGrafo: (thread) => '\n\n## Contexto do grafo (opcional)\n' +
+        `Consulte ork_grafo_contexto {threadId: "${thread}"} ou ork grafo contexto ${thread} --json para o pacote da thread com evidencias e teto em bytes.\n` +
+        'As tools ork_grafo_vizinhos, ork_grafo_chamadores, ork_grafo_importadores e ork_grafo_caminho permitem aprofundar. ' +
+        'Sem indice do HEAD, rode ork grafo indexar. O grafo e parcial e descreve o HEAD; ' +
+        'aresta com arvore: modificada vem de fonte que mudou depois dele: confira o arquivo antes de usar.\n',
+    memoria: {
+        titulo: (regime) => `## Memoria injetada (regime ${regime})`,
+        explicacao: 'Recuperacao deterministica por tag. Todo item declara de onde veio: nada entra neste prompt sem proveniencia. ' +
+            'O que NAO esta aqui esta nos ponteiros do handoff, recuperavel por `ork recall`.',
+        decisaoFechada: (id, por) => `Decisao ${id} (fechada por ${por})`,
+        decisaoSemantica: (id) => `Decisao ${id} (memoria semantica)`,
+        decisaoSemId: 'Decisao fechada (memoria semantica)',
+        licaoDaThread: (thread) => `Licao da thread ${thread}`,
+        licoesDoProduto: 'Licoes das threads fechadas deste produto (POSTMORTEM e MASTER)',
+        regraMandatoria: (titulo) => `Regra mandatoria: ${titulo}`,
+        grupos: { decision: 'Decisoes fechadas desta thread (entram em TODA fase)', learning: 'Licoes de threads anteriores deste produto',
+            rule: 'Regras mandatorias do ecossistema', handoff: 'Handoffs anteriores', roadmap: 'Roadmap' },
+        mandatory: ' [MANDATORY]',
+        origem: (location) => `origem: ${location}`,
+    },
+    secoesObrigatorias: ['## Ciclo canonico', '## Modo de conducao', '## Contexto da thread', '## Pedido do builder', '## Regras de evidencia'],
+    regraCentral: 'REGRA CENTRAL: o modo afrouxa a pausa, NUNCA a verificacao.',
+    cli: {
+        variavelSemValor: (id, v) => `template ${id}: variavel sem valor na renderizacao: ${v}`,
+        frontmatterAusente: (o) => `template em ${o}: frontmatter ausente (esperado bloco --- ... ---)`,
+        idAusente: 'frontmatter sem `id`', idDiverge: (id, e) => `o id "${id}" nao bate com o nome do arquivo "${e}.md"`,
+        versaoInvalida: (v) => `versao "${v}" invalida: esperado inteiro a partir de 1`, descricaoAusente: 'frontmatter sem `descricao`',
+        faseInvalida: (f, fs) => `"${f}" nao e fase do ciclo canonico (${fs})`,
+        variaveisNaoDeclaradas: (v) => `usadas no corpo e nao declaradas: ${v}`, variaveisNaoUsadas: (v) => `declaradas e nao usadas: ${v}`,
+        secaoAusente: (s) => `secao obrigatoria ausente: ${s}`, regraCentralAusente: (r) => `o template perdeu a linha: ${r}`,
+        pedidoAusente: (v, c) => `o template nao usa {{${v}}}: despacharia uma ${c} sem a demanda do builder`,
+        segredo: (n, l) => `padrao "${n}" casou na linha ${l} do template (trecho omitido de proposito)`,
+        tamanho: (b, l) => `${b} bytes acima do limite de ${l}`,
+        hitlTextoLivre: (l, o) => `linha ${l} pede ${o}; HITL de conducao e selecao de 3 a 5 alternativas com uma Recomendacao (RM-057)`,
+        travessao: 'o template usa travessao longo (U+2014); o padrao do projeto e hifen ou virgula',
+        templateNaoExiste: (id, ids) => `template "${id}" nao existe (conhecidos: ${ids})`,
+        templatePadraoAusente: 'template `fase-padrao` ausente: o `ork` nao tem prompt de fase',
+        semParIngles: (id) => `o dono fala ingles e o template ${id} do projeto nao tem o par ${id}.en: essa fase sai em pt-BR`,
+        gravidades: { erro: 'erro', aviso: 'aviso' }, semProblema: (n) => `  nenhum problema em ${n} template(s)`,
+        resumoLint: (n, e, a) => `templates: ${n} | erros: ${e} | avisos: ${a}`,
+        tituloLista: 'Templates de prompt (o do projeto sobrescreve o embutido de mesmo id)', origem: (o) => `origem: ${o}`,
+        fases: (f) => `fases: ${f}`, todas: 'todas', comoVersionar: 'Para versionar o seu: grave em prompts/<id>.md e rode `ork prompt lint`.',
+        lintTitulo: (r) => `Lint dos templates de prompt${r ? ` (projeto ${r})` : ' (somente embutidos)'}`, somenteEmbutidos: 'somente embutidos',
+        pedidoExemplo: '<pedido do builder>', cabecalhoTemplate: (id, v, o) => `# template ${id} v${v} (origem: ${o})`,
+        cabecalhoExemplo: (m, s) => `# thread de EXEMPLO (nada foi gravado), modo ${m}, sha256 ${s}`,
+        cabecalhoThread: (t, f, s) => `# thread ${t}, fase ${f}, sha256 ${s}`,
+        pedidoGuardado: (s) => `# pedido guardado na criacao da thread (sha256 ${s})`,
+        usoRenderThread: 'uso: ork prompt render <thread-id> <FASE> --pedido "<texto>"',
+        usoRenderExemplo: '     ork prompt render --exemplo --fase GOAL --modo auto --pedido "<texto>"',
+        subcomandoDesconhecido: (s) => `subcomando desconhecido: prompt ${s}`,
+        faseForaDoCiclo: (f, fs) => `fase "${f}" fora do ciclo canonico (${fs})`,
+    },
+};
+exports.PROMPTS_EN = {
+    contratoDasFases: {
+        GOAL: 'GOAL (F1): verifiable objective, impact map, success criteria, and claims with verification commands. Does not implement.',
+        PLAN: 'PLAN (F2): sliced tasks, queryable touch_paths, D1..Dn decisions with one home, and executable verify per task. Does not implement.',
+        GO: 'GO (F3): implement slice by slice, one atomic commit per task, inside the thread worktree.',
+        CHECK: 'CHECK (F4): verify against the baseline (regressions versus pre-existing debt), then review code, tests, security, and performance; ' +
+            'the verdict names the CHECK mode of the round (Agile Check or Classic Check, from the `check` line of `ork verify`).',
+        SHIP: 'SHIP (F5): serialized merge, command-proven push, updated roadmap, and rollback plan.',
+        MASTER: 'MASTER (F6): typed POSTMORTEM, MASTER log, lessons, and a human score from 0 to 5. A delivery without a MASTER log did not happen.',
+    },
+    invariantes: [
+        'Claims, verify, and policies run identically in every mode.',
+        'A `block` policy pauses every mode, including #Auto.',
+        'A typed human escalation pauses every mode, including #Auto.',
+        'Every delivery closes with an index derived from the ledger; a later human score overrides it.',
+        'Every autonomous decision goes to the ledger with who decided, evidence, and rationale.',
+    ],
+    variante: (v) => `Cycle variant: ${v}`,
+    pausaSobre: (s) => locale_thread_1.PAUSA_SOBRE_EN[s] ?? s,
+    pausa: (s) => `At the end of this block, PAUSE for a human verdict about: ${s}. Stop, present the evidence, and wait for the verdict.`,
+    semPausa: 'At the end of this block there is NO human pause: continue autonomously and record who decided, the evidence, and why in the ledger.',
+    raizDoProjeto: '(project root)',
+    regrasDeEvidencia: [
+        'No self-report: every claim includes the command that proves it and its real output.',
+        'Work only in the working directory shown above.',
+        'Irreversible steps (push, merge, deletion) happen only when the mode authorizes them.',
+    ],
+    regraDasEsperas: 'Waiting: never start verify, build, or a test suite with `&` inside the command; the process may be lost while the session ' +
+        'waits for a notice that never comes. Run `ork verify` in the foreground with `timeout` (it waits for the heavy-resource queue), ' +
+        'or use the host background execution that reports completion. Never wait with `pgrep -f` when its pattern appears in the command itself; ' +
+        'the loop finds itself and never ends. Wait for an output file with a deadline, or for a stored PID.',
+    fechoDoGo: (t) => [
+        '## Mandatory GO closing',
+        '',
+        `Before ending a block that includes GO, run \`ork verify ${t}\` and the build declared in the manifest, both in the foreground.`,
+        `Generate the bundle with \`ork ci prepare ${t}\` and make the final atomic commit \`ci(${t}): bundle ...\`.`,
+        `Write a short \`.orkastery/threads/${t}/pr-body.md\` in the project language, naming the CHECK mode of the round (Agile Check or Classic Check, from the \`check\` line of \`ork verify\`); ` +
+            'if the profile cannot write it through the authorized transport, return the full body in the final summary.',
+        'The ritual is identical in Claude Code and Codex. It closes GO, but it does not authorize SHIP, push, PR, or merge.',
+    ].join('\n'),
+    contextoDoGrafo: (thread) => '\n\n## Graph context (optional)\n' +
+        `Use ork_grafo_contexto {threadId: "${thread}"} or ork grafo contexto ${thread} --json for the thread package with evidence and a byte limit.\n` +
+        'The ork_grafo_vizinhos, ork_grafo_chamadores, ork_grafo_importadores, and ork_grafo_caminho tools allow deeper queries. ' +
+        'If HEAD has no index, run ork grafo indexar. The graph is partial and describes HEAD; an edge marked arvore: modificada comes from a source ' +
+        'that changed after HEAD, so inspect the file before using it.\n',
+    memoria: {
+        titulo: (regime) => `## Injected memory (${regime} regime)`,
+        explicacao: 'Deterministic retrieval by tag. Every item declares its source: nothing enters this prompt without provenance. ' +
+            'What is NOT here remains in the handoff pointers and can be retrieved with `ork recall`.',
+        decisaoFechada: (id, por) => `Decision ${id} (closed by ${por})`,
+        decisaoSemantica: (id) => `Decision ${id} (semantic memory)`,
+        decisaoSemId: 'Closed decision (semantic memory)',
+        licaoDaThread: (thread) => `Lesson from thread ${thread}`,
+        licoesDoProduto: 'Lessons from closed threads in this product (POSTMORTEM and MASTER)',
+        regraMandatoria: (titulo) => `Mandatory rule: ${titulo}`,
+        grupos: { decision: 'Closed decisions from this thread (included in EVERY phase)', learning: 'Lessons from previous product threads',
+            rule: 'Mandatory ecosystem rules', handoff: 'Previous handoffs', roadmap: 'Roadmap' },
+        mandatory: ' [MANDATORY]',
+        origem: (location) => `source: ${location}`,
+    },
+    secoesObrigatorias: ['## Canonical cycle', '## Conduction mode', '## Thread context', '## Builder request', '## Evidence rules'],
+    regraCentral: 'CENTRAL RULE: the mode relaxes the pause, NEVER verification.',
+    cli: {
+        variavelSemValor: (id, v) => `template ${id}: missing render value for variable: ${v}`,
+        frontmatterAusente: (o) => `template at ${o}: missing frontmatter (expected a --- ... --- block)`,
+        idAusente: 'frontmatter has no `id`', idDiverge: (id, e) => `id "${id}" does not match file name "${e}.md"`,
+        versaoInvalida: (v) => `invalid version "${v}": expected an integer starting at 1`, descricaoAusente: 'frontmatter has no `descricao`',
+        faseInvalida: (f, fs) => `"${f}" is not a canonical phase (${fs})`,
+        variaveisNaoDeclaradas: (v) => `used in the body but not declared: ${v}`, variaveisNaoUsadas: (v) => `declared but not used: ${v}`,
+        secaoAusente: (s) => `missing required section: ${s}`, regraCentralAusente: (r) => `template lost the line: ${r}`,
+        pedidoAusente: (v, c) => `template does not use {{${v}}}: it would dispatch a ${c} without the builder request`,
+        segredo: (n, l) => `pattern "${n}" matched template line ${l} (excerpt intentionally omitted)`,
+        tamanho: (b, l) => `${b} bytes exceeds the ${l}-byte limit`,
+        hitlTextoLivre: (l, _o) => `line ${l} asks for free-form text; conduction HITL is a selection of 3 to 5 choices with one Recommendation (RM-057)`,
+        travessao: 'template uses an em dash (U+2014); the project standard is a hyphen or comma',
+        templateNaoExiste: (id, ids) => `template "${id}" does not exist (known: ${ids})`,
+        templatePadraoAusente: 'missing `fase-padrao` template: `ork` has no phase prompt',
+        semParIngles: (id) => `the owner speaks English and the project template ${id} has no ${id}.en counterpart: that phase is rendered in pt-BR`,
+        gravidades: { erro: 'error', aviso: 'warning' }, semProblema: (n) => `  no problem in ${n} template(s)`,
+        resumoLint: (n, e, a) => `templates: ${n} | errors: ${e} | warnings: ${a}`,
+        tituloLista: 'Prompt templates (the project template overrides the built-in template with the same id)',
+        origem: (o) => `source: ${o === 'embutido' ? 'built-in' : o}`,
+        fases: (f) => `phases: ${f}`, todas: 'all', comoVersionar: 'To version yours, write prompts/<id>.md and run `ork prompt lint`.',
+        lintTitulo: (r) => `Prompt template lint${r ? ` (project ${r})` : ' (built-ins only)'}`, somenteEmbutidos: 'built-ins only',
+        pedidoExemplo: '<builder request>',
+        cabecalhoTemplate: (id, v, o) => `# template ${id} v${v} (source: ${o === 'embutido' ? 'built-in' : o})`,
+        cabecalhoExemplo: (m, s) => `# EXAMPLE thread (nothing was written), mode ${m}, sha256 ${s}`,
+        cabecalhoThread: (t, f, s) => `# thread ${t}, phase ${f}, sha256 ${s}`,
+        pedidoGuardado: (s) => `# request stored when the thread was created (sha256 ${s})`,
+        usoRenderThread: 'usage: ork prompt render <thread-id> <PHASE> --pedido "<text>"',
+        usoRenderExemplo: '       ork prompt render --exemplo --fase GOAL --modo auto --pedido "<text>"',
+        subcomandoDesconhecido: (s) => `unknown subcommand: prompt ${s}`,
+        faseForaDoCiclo: (f, fs) => `phase "${f}" is outside the canonical cycle (${fs})`,
+    },
+};