@orkastery/cli 0.6.1 → 0.6.2

package/dist/locale-prompts.js

@@ -31,15 +31,15 @@ exports.PROMPTS_PT_BR = {
         '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 ' +
+        'espera um aviso que nunca vem; prefira `ork_verify` assíncrono e consulte `ork_verify_status` a cada 30–60 s; sem essa ' +
+        'ferramenta, 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 ...\`.`,
+        `Antes de encerrar o bloco com GO, use \`ork_verify\` e aguarde o veredito verde por \`ork_verify_status\`; sem a consulta assíncrona, rode \`ork verify ${t}\` em primeiro plano. Rode também o build declarado no manifesto em primeiro plano.`,
+        `Com o veredito verde, gere o bundle com \`ork ci prepare ${t}\`, faça o commit atômico final \`ci(${t}): bundle ...\` e siga para CHECK e SHIP conforme os gates.`,
         `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.',
@@ -125,14 +125,14 @@ exports.PROMPTS_EN = {
         '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; ' +
+        'waits for a notice that never comes. Prefer asynchronous `ork_verify` and query `ork_verify_status` every 30–60 seconds; without that ' +
+        'tool, 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 ...\`.`,
+        `Before ending a block that includes GO, use \`ork_verify\` and wait for its green verdict through \`ork_verify_status\`; without the asynchronous query, run \`ork verify ${t}\` in the foreground. Also run the manifest build in the foreground.`,
+        `After the green verdict, generate the bundle with \`ork ci prepare ${t}\`, make the final atomic commit \`ci(${t}): bundle ...\`, and continue to CHECK and SHIP as their gates allow.`,
         `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.',

package/dist/locale-pulse.js

@@ -192,7 +192,9 @@ exports.PULSE_PT_BR = {
         'tree.blocked': 'a arvore de destino nao esta disponivel para o merge (branch em check-out com alteracao nao commitada, ou worktree que nao pode ser montada)',
         'lease.busy': 'lease ocupado por outra thread',
         'lease.resume-unavailable': 'retomada indisponivel; libere o lease explicitamente com --forcar',
+        'concurrency.lease-indeterminado': 'a vida do dono do lease nao pode ser provada deste host ou namespace; desconhecido nunca e orfao',
         'conducao.em-andamento': 'outra conducao ja executa na worktree da thread (I-36): o pedido foi recusado com quem conduz e as tres acoes (esperar, acompanhar, assumir)',
+        'conducao.acao-necessaria': 'a sessao parou de proposito e deixou um comando exato para a conducao executar fora do sandbox',
         'hitl.formato': 'o pedido HITL saiu fora do formato obrigatorio (pergunta em uma frase, de 3 a 5 alternativas rotuladas com consequencia, exatamente uma com o selo Recomendacao e o porque, corpo em lista; texto livre so com dependencia tecnica tipada)',
         'human.pending': 'gate humano do modo de conducao ainda nao autorizou',
     },
@@ -342,7 +344,9 @@ exports.PULSE_EN = {
         'tree.blocked': 'the target tree is not available for the merge (branch checked out with uncommitted changes, or a worktree that cannot be set up)',
         'lease.busy': 'lease held by another thread',
         'lease.resume-unavailable': 'resume unavailable; release the lease explicitly with `--forcar`',
+        'concurrency.lease-indeterminado': 'the lease owner life cannot be proven from this host or namespace; unknown is never orphaned',
         'conducao.em-andamento': 'another conduction already runs on the thread worktree (I-36): the request was refused with who conducts and the three actions (wait, follow, take over)',
+        'conducao.acao-necessaria': 'the session stopped on purpose and left an exact command for the conductor to run outside the sandbox',
         'hitl.formato': 'the HITL request came out of the required format (question in one sentence, 3 to 5 labeled alternatives with a consequence each, exactly one with the Recommendation seal and the reason, body as a list; free text only with a typed technical dependency)',
         'human.pending': 'the human gate of the conduction mode has not authorized yet',
     },

package/dist/locale-retry.js

@@ -107,10 +107,18 @@ exports.RETRY_PT_BR = {
             porque: 'o lease e de outra thread e vai ser liberado: a fila ja serializa, entao a acao e tentar de novo quando chegar a vez, nunca furar a fila',
             correcao: 'ork lease list mostra a fila; a vez chega sem ninguem forcar',
         },
+        'concurrency.lease-indeterminado': {
+            porque: 'o sandbox nao conseguiu provar se o dono do lease esta vivo ou morto: ausencia de PID visivel nao prova orfandade, e reexecutar poderia abrir duas operacoes pesadas',
+            correcao: 'espere com --esperar; se a observacao continuar inconclusiva, execute pela conducao o comando exato do pedido aberto',
+        },
         'conducao.em-andamento': {
             porque: 'outra conducao executa na mesma worktree agora: a vez chega quando ela terminar, e furar a fila e o incidente de 19/09/2026',
             correcao: 'ork conducao status <thread> mostra quem conduz; repita o pedido com --esperar <min> para seguir sozinho quando liberar',
         },
+        'conducao.acao-necessaria': {
+            porque: 'a sessao parou de proposito porque a proxima operacao exige a autoridade da conducao; reexecutar a fase antes desse comando so repete a mesma parada',
+            correcao: 'execute o comando exato do pedido no canal da conducao; depois retome a mesma fase',
+        },
         'hitl.formato': {
             porque: 'o pedido HITL saiu fora do formato obrigatorio: quem errou foi o emissor, e a correcao e reemitir com alternativas rotuladas, consequencia por alternativa e exatamente uma recomendada com o porque',
             correcao: 'ork fix open <thread> abre a rodada com a spec exata do formato',
@@ -386,10 +394,18 @@ exports.RETRY_EN = {
             porque: 'the lease belongs to another thread and will be released: the queue already serializes, so the action is to try again when the turn comes, never to jump the queue',
             correcao: '`ork lease list` shows the queue; the turn comes with nobody forcing it',
         },
+        'concurrency.lease-indeterminado': {
+            porque: 'the sandbox could not prove whether the lease owner is alive or dead: an invisible PID does not prove orphanhood, and rerunning could open two heavy operations',
+            correcao: 'wait with `--esperar`; if observation stays inconclusive, run the exact command from the open request through the conductor',
+        },
         'conducao.em-andamento': {
             porque: 'another conduction runs on the same worktree now: the turn comes when it finishes, and jumping the queue is the 2026-09-19 incident',
             correcao: '`ork conducao status <thread>` shows who conducts; repeat the request with `--esperar <min>` to go on by itself when it frees up',
         },
+        'conducao.acao-necessaria': {
+            porque: 'the session stopped on purpose because the next operation needs conductor authority; rerunning the phase before that command only repeats the same stop',
+            correcao: 'run the exact request command in the conductor channel; then resume the same phase',
+        },
         'hitl.formato': {
             porque: 'the HITL request came out of the required format: the issuer made the mistake, and the fix is to issue it again with labeled alternatives, a consequence per alternative and exactly one recommended, with the reason',
             correcao: '`ork fix open <thread>` opens the round with the exact format spec',

package/dist/locale-security-scan.js

@@ -2,15 +2,47 @@
 /**
  * The `securityScan` family of the message catalog: `ork security-scan` output (stdout summary, `report.md`) and its
  * usage error. pt-BR is the source; English is typed by it. No import from the core. Values that are data (tool names,
- * states, reasons, rule ids, paths) are printed as recorded, in both languages.
+ * states, reasons, rule ids, paths) remain unchanged in report.json. The human render translates the known reason
+ * vocabulary without rewriting the stored data.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SECURITY_SCAN_EN = exports.SECURITY_SCAN_PT_BR = void 0;
+const motivoEmPtBR = (reason) => {
+    const exact = new Map([
+        ['not in the catalog', 'não está no catálogo'], ['unbalanced JSON', 'JSON desbalanceado'],
+        ['truncated JSON', 'JSON truncado'], ['empty stream', 'fluxo vazio'], ['invalid JSON', 'JSON inválido'],
+        ['expected a JSON array', 'era esperado um array JSON'], ['expected a JSON object', 'era esperado um objeto JSON'],
+        ['unreadable output', 'saída ilegível'], ['commit-range-unresolved', 'intervalo de commits não resolvido'],
+        ['timeout', 'tempo esgotado'], ['no-requirements-file', 'nenhum arquivo requirements'],
+        ['zero-commits-scanned', 'nenhum commit varrido'], ['disabled', 'desabilitada'], ['unsupported-ci', 'CI não suportada'],
+    ]);
+    const conhecida = exact.get(reason);
+    if (conhecida !== undefined)
+        return conhecida;
+    return reason
+        .replace(/not in the catalog/g, 'não está no catálogo')
+        .replace(/unbalanced JSON/g, 'JSON desbalanceado')
+        .replace(/truncated JSON/g, 'JSON truncado')
+        .replace(/empty stream/g, 'fluxo vazio')
+        .replace(/invalid JSON/g, 'JSON inválido')
+        .replace(/expected a JSON array/g, 'era esperado um array JSON')
+        .replace(/expected a JSON object/g, 'era esperado um objeto JSON')
+        .replace(/unexpected "([^"]+)" outside a JSON value/g, '"$1" inesperado fora de um valor JSON')
+        .replace(/missing key "([^"]+)"/g, 'chave "$1" ausente')
+        .replace(/tool reported "([^"]+)"/g, 'a ferramenta relatou "$1"')
+        .replace(/must be a list of strings/g, 'deve ser uma lista de strings')
+        .replace(/expected an object/g, 'era esperado um objeto')
+        .replace(/expected a list/g, 'era esperada uma lista')
+        .replace(/\(no fingerprint\)/g, '(sem fingerprint)')
+        .replace(/missing-output/g, 'saída-ausente');
+};
 exports.SECURITY_SCAN_PT_BR = {
     usage: 'uso: ork security-scan [--base <ref>] [--json] [--check classic|agile]',
     // RM-072 (D9): o modo da varredura aceita so os dois valores.
     checkInvalido: (valor) => `--check inválido: ${valor === null ? '(sem valor)' : JSON.stringify(valor)} (aceitos: classic, agile)`,
     unknownFlag: (flag) => `opção desconhecida: ${flag}`,
+    error: (message) => motivoEmPtBR(message),
+    reason: (reason) => motivoEmPtBR(reason),
     // report.md
     title: 'Varredura de segurança',
     headBase: (head, base) => `HEAD \`${head.slice(0, 12)}\`, base \`${base ? base.slice(0, 12) : '(não resolvida)'}\``,
@@ -42,6 +74,8 @@ exports.SECURITY_SCAN_EN = {
     usage: 'usage: ork security-scan [--base <ref>] [--json] [--check classic|agile]',
     checkInvalido: (valor) => `invalid --check: ${valor === null ? '(no value)' : JSON.stringify(valor)} (accepted: classic, agile)`,
     unknownFlag: (flag) => `unknown option: ${flag}`,
+    error: (message) => message,
+    reason: (reason) => reason,
     title: 'Security scan',
     headBase: (head, base) => `HEAD \`${head.slice(0, 12)}\`, base \`${base ? base.slice(0, 12) : '(unresolved)'}\``,
     generatedAt: (iso) => `Generated at ${iso}`,

package/dist/locale-verify.js

@@ -82,6 +82,14 @@ exports.VERIFY_PT_BR = {
     semVeredito: (nomes) => `Sem veredito por tempo (nao e reprovacao: prazo estourado ou relogio sob steal): ${nomes}`,
     // Classificacao e veredito
     classificacao: (regressoes, preExistentes, semBaseline) => `Classificacao: ${regressoes} regressao(oes), ${preExistentes} pre-existente(s), ${semBaseline} falha(s) sem baseline`,
+    comparacaoPorTeste: (comando, regressoes, preExistentes, corrigidos) => `Comparacao teste a teste (${comando}): ${regressoes} regressao(oes), ${preExistentes} pre-existente(s), ` +
+        `${corrigidos} corrigido(s)`,
+    testeRegressao: (nome) => `    regressao      ${nome}`,
+    testePreExistente: (nome) => `    pre-existente  ${nome}`,
+    testeCorrigido: (nome) => `    corrigido      ${nome}`,
+    comparacaoPorComando: (comando, classificacao, motivo) => `Comparacao somente por comando (${comando}): ${classificacao}; ${motivo === 'baseline-sem-nomes'
+        ? 'a baseline nao guardou nomes de testes' : 'a rodada atual nao informou nomes de testes'}. ` +
+        'Nenhuma contagem de regressoes por teste foi calculada.',
     regressao: (nome, comando) => `  regressao      ${nome}: ${comando}`,
     preExistente: (nome, comando) => `  pre-existente  ${nome}: ${comando}`,
     falhaSemBaseline: (nome, comando) => `  sem baseline   ${nome}: ${comando}`,
@@ -171,6 +179,13 @@ exports.VERIFY_EN = {
     falhou: (code) => `FAILED (exit ${code})`,
     semVeredito: (nomes) => `No verdict for lack of time (not a failure: deadline exceeded or clock under steal): ${nomes}`,
     classificacao: (regressoes, preExistentes, semBaseline) => `Classification: ${regressoes} regression(s), ${preExistentes} pre-existing, ${semBaseline} failure(s) without a baseline`,
+    comparacaoPorTeste: (comando, regressoes, preExistentes, corrigidos) => `Test-by-test comparison (${comando}): ${regressoes} regression(s), ${preExistentes} pre-existing, ${corrigidos} fixed`,
+    testeRegressao: (nome) => `    regression     ${nome}`,
+    testePreExistente: (nome) => `    pre-existing   ${nome}`,
+    testeCorrigido: (nome) => `    fixed          ${nome}`,
+    comparacaoPorComando: (comando, classificacao, motivo) => `Command-only comparison (${comando}): ${classificacao === 'regressao' ? 'regression' : classificacao === 'pre-existente'
+        ? 'pre-existing' : 'fixed'}; ${motivo === 'baseline-sem-nomes' ? 'the baseline did not store test names'
+        : 'the current run did not report test names'}. No per-test regression count was calculated.`,
     regressao: (nome, comando) => `  regression     ${nome}: ${comando}`,
     preExistente: (nome, comando) => `  pre-existing   ${nome}: ${comando}`,
     falhaSemBaseline: (nome, comando) => `  no baseline    ${nome}: ${comando}`,

package/dist/locale.js

@@ -108,22 +108,25 @@ const locale_operacao_restante_1 = require("./locale-operacao-restante");
 const locale_conducao_1 = require("./locale-conducao");
 const locale_grafo_1 = require("./locale-grafo");
 const locale_audit_1 = require("./locale-audit");
+const locale_preflight_1 = require("./locale-preflight");
+const locale_maestro_1 = require("./locale-maestro");
 exports.LOCALE_PADRAO = 'pt-BR';
 /**
  * Comandos cujo texto ja sai pelo catalogo, por `comando` ou por `comando subcomando`; `comando ?` e o
  * subcomando desconhecido (o erro de uso e do proprio comando). Os demais seguem em pt-BR. Ficam de
- * fora por decisao (D2 da F2a): `doctor --modo`, `thread new --from-finding`, `onboarding sync` e
- * `experiencia uninstall`. A F2b (G3) acrescenta `verify` (com `--baseline`),
+ * fora por decisao (D2 da F2a): `thread new --from-finding`. A F3e acrescenta `doctor --modo`,
+ * `onboarding sync` e `experiencia uninstall`. A F2b (G3) acrescenta `verify` (com `--baseline`),
  * `ship`, `ship registrar-pr`, `retry plan`, `retry run`, `master` (o indice), `master aceitar-omissao` e
  * `master pedir`, `pulse` (sem `responder` nem `cadencia`) e `roadmap status`. A F3a (D5) acrescenta `docs init`, e a
  * F3b (D1), o resto da lista do dono; a F3c completa `decisao registrar` e `network roadmap`. O conhecimento escrito
  * (RM-026 K7, fatia 2) nasce coberto: `conhecimento listar|mostrar|colecoes|verificar` e o uso errado dele.
  */
 exports.COMANDOS_COM_LOCALE = ['doctor', 'init', 'onboarding show', 'onboarding set', 'onboarding reset',
-    'onboarding ?', 'experiencia show', 'experiencia ?', 'thread new', 'thread status', 'thread ?',
+    'onboarding sync', 'onboarding ?', 'experiencia show', 'experiencia uninstall', 'experiencia ?', 'thread new', 'thread status', 'thread ?',
     'phase list', 'phase run', 'phase ?', 'verify', 'ship', 'ship registrar-pr', 'retry plan', 'retry run',
     'retry policy', 'retry parse', 'retry list', 'retry resume', 'retry cancel', 'retry ?',
-    'master', 'master <thread>', 'master aceitar-omissao', 'master pedir', 'master classes', 'master batch',
+    'master', 'master <thread>', 'master aceitar-omissao', 'master pedir', 'master audit', 'master digest', 'master migrar',
+    'master classes', 'master ratificar', 'master batch', 'master propor',
     'pulse', 'roadmap status', 'docs init',
     // F3b (D1): o resto do CLI, na ordem do pedido.
     'thread list', 'thread close', 'thread entrega', 'worktree ensure', 'worktree sync', 'worktree audit', 'worktree release', 'worktree ?',
@@ -151,7 +154,7 @@ exports.COMANDOS_COM_LOCALE = ['doctor', 'init', 'onboarding show', 'onboarding
     'orquestracao status', 'orquestracao ?', 'monitor', 'licoes', 'demo',
     'fabrica list', 'fabrica publicar', 'fabrica entrar', 'fabrica sair', 'fabrica batida', 'fabrica ?', 'eval',
     'memory status', 'memory inventory', 'memory migrate', 'memory sync', 'memory search', 'memory index', 'memory ?',
-    'mcp install', 'conducao status', 'conducao assumir', 'conducao atualizar', 'conducao autorizar',
+    'mcp install', 'mcp serve', 'mcp ?', 'brain', 'activation', 'conducao status', 'conducao assumir', 'conducao atualizar', 'conducao autorizar',
     'conducao autorizacao', 'conducao batida', 'conducao sentinela', 'conducao ?', 'grafo',
     'audit packs', 'audit pack', 'audit lint', 'audit run', 'audit list', 'audit show', 'audit prompt',
     'audit ingest', 'audit finding', 'audit achado', 'audit verify', 'audit report', 'audit relatorio',
@@ -226,8 +229,6 @@ function chaveDoMaster(bruto, opcoes) {
 function cobreLocale(posicionais, opcoes) {
     if (opcoes.json !== undefined)
         return false;
-    if (posicionais[0] === 'doctor' && opcoes.modo !== undefined)
-        return false;
     return exports.COMANDOS_COM_LOCALE.includes(chaveDoLocale(posicionais, opcoes));
 }
 /** `en_US.UTF-8`, `en-GB`, `en` viram `en`; `pt_BR.UTF-8`, `pt` viram pt-BR; o resto, undefined. */
@@ -293,7 +294,14 @@ const PT_BR = {
         subcomandoDesconhecido: (comando, sub) => `subcomando desconhecido: ${comando} ${sub}`,
         /** `exigirManifesto` fora de um projeto: o primeiro erro de quem chega (D14). */
         manifestoNaoEncontrado: (nome, dir) => `manifesto ${nome} nao encontrado a partir de ${dir}. Rode: ork init`,
+        receiptVerifiersUso: 'uso: ork receipt-verifiers --json',
+        activationUso: 'uso: ork activation plan|status|enable|disable',
+        masterDigestUso: 'uso: ork master digest <enviar|preview|responder>',
+        masterRatificarUso: 'resposta deve ser ratificar <thread> <assinatura> <classe>',
+        masterSelecaoUso: 'seleção deve ser thread:assinatura',
     },
+    preflight: locale_preflight_1.PREFLIGHT_PT_BR,
+    maestro: locale_maestro_1.MAESTRO_PT_BR,
     horario: {
         brasilia: 'horário de Brasília',
         legendaBrasilia: 'Horários de Brasília.',
@@ -307,6 +315,7 @@ const PT_BR = {
     },
     doctor: {
         titulo: 'ork doctor: o que vale nesta maquina agora',
+        modoUso: (modos) => `uso: ork doctor --modo ${modos}`,
         correcao: 'correcao',
         bloqueado: (falhas, avisos) => `Veredito: BLOQUEADO (${falhas} fail, ${avisos} warn). Corrija os itens acima antes de despachar fase.`,
         pronto: (avisos) => `Veredito: PRONTO (${avisos} warn). Despacho de fase liberado por \`ork phase run\`.`,
@@ -731,7 +740,14 @@ const EN = {
         erro: (mensagem) => `error: ${mensagem}`,
         subcomandoDesconhecido: (comando, sub) => sub === undefined ? `missing subcommand: ${comando}` : `unknown subcommand: ${comando} ${sub}`,
         manifestoNaoEncontrado: (nome, dir) => `\`${nome}\` not found in ${dir} or any parent directory; run \`ork init\` first.`,
+        receiptVerifiersUso: 'usage: ork receipt-verifiers --json',
+        activationUso: 'usage: ork activation plan|status|enable|disable',
+        masterDigestUso: 'usage: ork master digest <enviar|preview|responder>',
+        masterRatificarUso: 'the response must be ratificar <thread> <signature> <class>',
+        masterSelecaoUso: 'the selection must be thread:signature',
     },
+    preflight: locale_preflight_1.PREFLIGHT_EN,
+    maestro: locale_maestro_1.MAESTRO_EN,
     horario: {
         brasilia: 'Brasília time',
         legendaBrasilia: 'Times in Brasília time.',
@@ -744,6 +760,7 @@ const EN = {
     },
     doctor: {
         titulo: 'ork doctor: what holds on this machine now',
+        modoUso: (modes) => `usage: ork doctor --modo ${modes}`,
         correcao: 'fix',
         bloqueado: (falhas, avisos) => `Verdict: BLOCKED (${falhas} fail, ${avisos} warn). Fix the items above before dispatching a phase.`,
         pronto: (avisos) => `Verdict: READY (${avisos} warn). Phase dispatch allowed through \`ork phase run\`.`,

package/dist/maestro-cli.js

@@ -10,6 +10,7 @@ const maestro_sources_1 = require("./maestro-sources");
 const maestro_actions_1 = require("./maestro-actions");
 const maestro_runtime_1 = require("./maestro-runtime");
 const horario_1 = require("./horario");
+const locale_maestro_1 = require("./locale-maestro");
 function readMaestro(context, options) {
     const observations = options.native && options.threadId ? (0, maestro_runtime_1.nativeForThread)(context.root, options.threadId) : [];
     return (0, maestro_snapshot_1.maestroSnapshot)(context, { ...options, collect: ctx => {
@@ -31,31 +32,25 @@ function readMaestro(context, options) {
             return sources;
         } });
 }
-/** RM-052: de onde veio o projeto do panorama, na lingua do dono. */
-const ORIGEM_DO_PANORAMA = Object.freeze({
-    installation: 'fixado na instalação', cwd: 'pelo diretório atual', worktree: 'pela worktree da thread',
-    selection: 'pedido explicitamente (--projeto ou ORK_PROJETO)',
-});
-function maestroText(snapshot) {
+function maestroText(snapshot, textos = locale_maestro_1.MAESTRO_PT_BR) {
     const p = snapshot.project;
-    return [`${p.name} · panorama Maestro`,
+    return [textos.titulo(p.name),
         // I-35: o snapshot guarda ISO; o texto ao dono diz quando consultou, no fuso dele.
-        `• Consulta: ${(0, horario_1.formatarDataHoraRotulada)(snapshot.observedAt, { agora: snapshot.observedAt })}`,
+        textos.consulta((0, horario_1.formatarDataHoraRotulada)(snapshot.observedAt, { agora: snapshot.observedAt })),
         // RM-052: qual cópia foi lida e o que o panorama não lê, antes de qualquer seção.
-        `• Projeto consultado: ${p.name}${p.root ? ` · ${p.root}` : ''}${p.remote === undefined ? '' : ` · ${p.remote ?? 'sem remoto'}`} · ${ORIGEM_DO_PANORAMA[p.origin]}`,
-        ...(snapshot.notConsulted?.length ? [`• Não lido: ${snapshot.notConsulted.join(' · ')}`] : []),
+        textos.projeto(p.name, p.root ?? '', p.remote === null ? textos.semRemoto : p.remote, textos.origem[p.origin]),
+        ...(snapshot.notConsulted?.length ? [textos.naoLido(snapshot.notConsulted.join(' · '))] : []),
         ...maestro_contract_1.SECTION_NAMES.map(name => {
             const s = snapshot.sections[name];
-            return `• ${name}: ${s.state} · ${s.coverage.returned}/${s.coverage.total ?? '?'}${s.coverage.omitted ? ' · mais itens disponíveis' : ''}`;
+            return textos.secao(name, s.state, s.coverage.returned, s.coverage.total, !!s.coverage.omitted);
         }),
-        ...snapshot.sections.threads.items.slice(0, 8).map(t => `  ${t.title}: ${t.facts.phase} · ${t.status}`),
-        `• Recomendo: ${snapshot.conflicts.length ? 'reler as fontes em conflito' : snapshot.gaps.length ? 'conferir as lacunas antes de agir' : 'escolher uma thread para ver o detalhe'}.`,
-        'Use ork maestro --json para cobertura e ações; --thread ID consulta o detalhe nativo.',
+        ...snapshot.sections.threads.items.slice(0, 8).map(t => textos.thread(t.title, String(t.facts.phase), t.status)),
+        textos.recomendacao(snapshot.conflicts.length, snapshot.gaps.length), textos.final,
     ].join('\n');
 }
-function runMaestroCli(argv, cwd = process.cwd(), trusted = {}, io = { out: (v) => console.log(v), err: (v) => console.error(v) }) {
+function runMaestroCli(argv, cwd = process.cwd(), trusted = {}, io = { out: (v) => console.log(v), err: (v) => console.error(v) }, textos = locale_maestro_1.MAESTRO_PT_BR) {
     if (argv.length === 1 && argv[0] === '--help') {
-        io.out('ork maestro [--json] [--thread ID] [--section NOME --offset N]\nConsulta sem criar ou despachar trabalho. Na conversa, diga: orkastery maestro.');
+        io.out(textos.help);
         return 0;
     }
     try {
@@ -94,7 +89,7 @@ function runMaestroCli(argv, cwd = process.cwd(), trusted = {}, io = { out: (v)
         const context = (0, maestro_discovery_1.discoverMaestro)({ cwd, ...trusted });
         const snapshot = readMaestro(context, { threadId, offsets: section ? { [section]: offset } : undefined, native: true,
             host: { tools: ['ork_thread_status', 'ork_observe', 'ork_git_status'], child: false } });
-        io.out(json ? JSON.stringify(snapshot) : maestroText(snapshot));
+        io.out(json ? JSON.stringify(snapshot) : maestroText(snapshot, textos));
         return 0;
     }
     catch (e) {

package/dist/mcp-install.js

@@ -55,7 +55,8 @@ const IMPRESSAO_SSH = /^SHA256:[A-Za-z0-9+/]{43}$/;
 exports.TOOLS_DONO_CODEX = ['ork_thread_new', 'ork_phase_run', 'ork_request_decision'];
 // RM-037 (rm037defeito, defeito 1): a decisao autonoma da sessao entra com as outras mutacoes do filho;
 // sem o grant, o codex com approval_policy never recusaria a chamada.
-exports.TOOLS_FILHO_CODEX = ['ork_artifact_write', 'ork_claim_add', 'ork_decision_record', 'ork_git_commit', 'ork_verify', 'ork_ship'];
+exports.TOOLS_FILHO_CODEX = ['ork_artifact_write', 'ork_claim_add', 'ork_decision_record', 'ork_request_conduction',
+    'ork_git_commit', 'ork_verify', 'ork_verify_status', 'ork_ship'];
 // Brain mutation tools are deliberately excluded from the existing opt-in bundle.
 // A native integration must request exact startup grants plus scoped activation.
 var company_brain_mcp_1 = require("./company-brain-mcp");

package/dist/mcp-server.js

@@ -70,9 +70,7 @@ const preflight_1 = require("./preflight");
 const modos_1 = require("./modos");
 const mcp_noctum_1 = require("./mcp-noctum");
 const versao_1 = require("./versao");
-const mcp_verify_1 = require("./mcp-verify");
 const conducao_1 = require("./conducao");
-const fila_pesada_1 = require("./fila-pesada");
 const decisao_autonoma_1 = require("./decisao-autonoma");
 const conducao_texto_1 = require("./conducao-texto");
 const mcp_ship_1 = require("./mcp-ship");
@@ -87,6 +85,7 @@ const mcp_experiencia_1 = require("./mcp-experiencia");
 const mcp_grafo_1 = require("./mcp-grafo");
 const mcp_conhecimento_1 = require("./mcp-conhecimento");
 const locale_1 = require("./locale");
+const pedido_conducao_1 = require("./pedido-conducao");
 const identidade = zod_1.z.string().min(1).max(80).regex(/^[a-zA-Z0-9][a-zA-Z0-9._-]*$/);
 const daThread = zod_1.z.object({ threadId: identidade }).strict();
 const daDecisao = daThread.extend({ pedidoId: identidade }).strict();
@@ -456,23 +455,20 @@ function criarServidorMcp(opcoes) {
         const r = await (0, mcp_ship_1.shipMcp)(perfilShip, args, extra.signal);
         return { ...resposta(r), ...(r.ok ? {} : { isError: true }) };
     });
-    registrarTool('ork_verify', { description: 'Reexecuta claims e verificadores do manifesto na worktree, em sandbox e com prazo total de tres minutos. Registra resultado real; falhas bloqueiam a verificacao.',
+    registrarTool('ork_verify', { description: 'Inicia uma rodada assíncrona do verify canônico no processo do servidor, vinculada à thread e ao despacho. Devolve imediatamente o UUID; repetir enquanto viva reutiliza a rodada.',
         inputSchema: daThread, annotations: { readOnlyHint: false, destructiveHint: false } }, async ({ threadId }) => {
         thread(threadId);
-        livre(threadId);
-        try {
-            const r = (0, mcp_verify_1.verificarMcp)(raiz, threadId, conducao);
-            return { ...resposta(r), ...(r.ok ? {} : { isError: true }) };
-        }
-        catch (e) {
-            // I-36 (T18): a mesma recusa tipada do CLI, com o mesmo texto, sem reescrever nada no host.
-            if (e instanceof conducao_1.ErroDeConducao)
-                return { ...resposta(e.recusa), isError: true };
-            // RM-058 N2 (A6 do CHECK): a fila pesada que nao deu a vez no prazo responde como a conducao.
-            if (e instanceof fila_pesada_1.ErroDaFilaPesada)
-                return { ...resposta(e.recusa), isError: true };
-            throw e;
-        }
+        const { iniciarVerifyMcp } = await Promise.resolve().then(() => __importStar(require('./mcp-verify-async')));
+        const r = iniciarVerifyMcp(raiz, threadId, { host: opcoes.host, despacho: opcoes.dispatchId ?? null });
+        return { ...resposta(r), ...(r.estado === 'falhou' ? { isError: true } : {}) };
+    });
+    registrarTool('ork_verify_status', { description: 'Consulta uma rodada assíncrona do verify por UUID: na fila, rodando com a lane atual, concluída com o veredito completo do CLI ou falha tipada. Não inicia nem duplica rodada.',
+        inputSchema: daThread.extend({ rodadaId: zod_1.z.string().uuid() }).strict(), annotations: { readOnlyHint: true, destructiveHint: false } }, async ({ threadId, rodadaId }) => {
+        thread(threadId);
+        const { consultarVerifyMcp } = await Promise.resolve().then(() => __importStar(require('./mcp-verify-async')));
+        const r = consultarVerifyMcp(raiz, threadId, rodadaId);
+        const reprovou = r.estado === 'falhou' || (r.estado === 'concluido' && r.veredito?.ok === false);
+        return { ...resposta(r), ...(reprovou ? { isError: true } : {}) };
     });
     registrarTool('ork_git_commit', { description: 'Commita somente paths com claims e HEAD esperado na worktree da thread. Recusa hooks/filtros ativos; preserva configuracao. Commit local nao e SHIP.',
         inputSchema: daThread.extend({ expectedHead: zod_1.z.string().regex(/^[a-f0-9]{40}$/),
@@ -649,6 +645,13 @@ function criarServidorMcp(opcoes) {
         });
     if (opcoes.threadId && opcoes.dispatchId) {
         const despacho = opcoes.dispatchId;
+        registrarTool('ork_request_conduction', { description: 'Registra um pedido tipado desta sessao para a conducao, com comando ork exato. Nao executa o comando, nao aprova gate e nao responde pelo dono.',
+            inputSchema: daThread.extend({ motivo: zod_1.z.enum(pedido_conducao_1.MOTIVOS_DE_PEDIDO_A_CONDUCAO), detalhe: zod_1.z.string().trim().min(1).max(2000),
+                comando: zod_1.z.string().trim().min(1).max(1000) }).strict(),
+            annotations: { readOnlyHint: false, destructiveHint: false } }, async ({ threadId, motivo, detalhe, comando }) => {
+            thread(threadId);
+            return resposta((0, pedido_conducao_1.registrarPedidoAConducao)(raiz, threadId, { despacho, motivo, detalhe, comando, host: opcoes.host }));
+        });
         registrarTool('ork_session_inbox', { description: 'Lado receptor do Mensageiro de Sessoes na sessao de fase deste despacho: confere e reserva uma vez a resposta do dono que chegou de outra sessao (conferir, com o prazo ate) e, depois de ela entrar na fila, grava o recibo (confirmar). A sessao sai do despacho deste servidor, nunca de argumento. Nao responde nem aprova pedido.',
             inputSchema: daThread.extend({ operacao: zod_1.z.enum(['conferir', 'confirmar']), texto: zod_1.z.string().max(entrega_por_mod_1.LIMITE_DA_MENSAGEM),
                 envioId: zod_1.z.string().uuid().optional(), ate: zod_1.z.string().max(40).optional() }).strict(),