@orkastery/cli 0.5.3 → 0.5.6

package/dist/handoff.js

@@ -73,6 +73,7 @@ const phase_1 = require("./phase");
 const thread_1 = require("./thread");
 const memoria_1 = require("./memoria");
 const util_1 = require("./util");
+const procedencia_1 = require("./procedencia");
 /** sha256 de um arquivo em disco, a prova de proveniencia de cada item. */
 function sha256DoArquivo(caminho) {
     if (!fs.existsSync(caminho))
@@ -98,7 +99,8 @@ function caminhoDoArtefato(raiz, thread, arquivo) {
         ? [path.resolve(thread.worktree, arquivo), path.resolve(raiz, arquivo)]
         : [path.resolve(raiz, arquivo)];
     for (const c of candidatos) {
-        if (fs.existsSync(c) && fs.statSync(c).isFile())
+        // RM-047 (P2): o arquivo da claim vem do estado; fora da raiz e da worktree registrada, não vira ponteiro.
+        if (fs.existsSync(c) && fs.statSync(c).isFile() && (0, procedencia_1.caminhoContidoOuNulo)(raiz, thread, c))
             return c;
     }
     return null;
@@ -222,7 +224,7 @@ function exportarHandoff(carregado, threadId, opcoes = {}) {
         if (s.origem === 'adocao')
             continue;
         const caminhoPrompt = path.resolve(raiz, s.promptPath);
-        if (!fs.existsSync(caminhoPrompt))
+        if (!fs.existsSync(caminhoPrompt) || !(0, procedencia_1.caminhoContidoOuNulo)(raiz, thread, caminhoPrompt))
             continue;
         addPonteiro(`Prompt da sessao ${s.slug} (fase ${s.fase})`, caminhoPrompt, 'pedido-do-builder', s.fase);
     }
@@ -261,7 +263,7 @@ function exportarHandoff(carregado, threadId, opcoes = {}) {
         for (const e of anteriores) {
             const arquivo = (0, memoria_1.arquivoDoHandoff)(e);
             const emDisco = arquivo ? path.resolve(raiz, arquivo) : '';
-            if (!emDisco || !fs.existsSync(emDisco))
+            if (!emDisco || !fs.existsSync(emDisco) || !(0, procedencia_1.caminhoContidoOuNulo)(raiz, thread, emDisco))
                 continue;
             addPonteiro(`Handoff anterior desta thread (${arquivo})`, emDisco, 'tudo', proximaFase, `orkmind://handoff/${e.id}`);
         }
@@ -270,7 +272,7 @@ function exportarHandoff(carregado, threadId, opcoes = {}) {
         for (const e of (0, memoria_1.licoesDoProduto)(memoria, manifesto, threadId)) {
             const postmortem = (0, memoria_1.postmortemDaLicao)(e);
             const emDisco = postmortem ? path.resolve(raiz, postmortem) : '';
-            if (!emDisco || !fs.existsSync(emDisco))
+            if (!emDisco || !fs.existsSync(emDisco) || !(0, procedencia_1.caminhoContidoOuNulo)(raiz, thread, emDisco))
                 continue;
             addPonteiro(`Licao da thread ${(0, memoria_1.threadDaEntrada)(e) ?? '(anterior)'}`, emDisco, 'json:resumo', 'MASTER', `orkmind://learning/${e.id}`);
         }
@@ -398,9 +400,11 @@ function recall(carregado, threadId, ponteiro) {
     if (!fs.existsSync(caminho) || !fs.statSync(caminho).isFile()) {
         throw new Error(`ponteiro nao resolve: arquivo "${bruto}" nao existe a partir de ${raiz}`);
     }
-    const conteudoBruto = fs.readFileSync(caminho, 'utf8');
+    // RM-047 (P2): o `location` vem do handoff.json (estado, talvez versionado); só lê dentro do projeto.
+    const real = (0, procedencia_1.exigirCaminhoContido)(raiz, (0, thread_1.lerThread)(raiz, threadId), caminho, bruto);
+    const conteudoBruto = fs.readFileSync(real, 'utf8');
     const linhas = conteudoBruto.split('\n');
-    const sha = sha256DoArquivo(caminho);
+    const sha = sha256DoArquivo(real);
     const base = { location: `${bruto}#${ancora}`, caminho, ancora, sha256: sha };
     const registrarRecall = (r) => {
         (0, ledger_1.registrar)((0, thread_1.dirThread)(raiz, threadId), threadId, ledger_1.TIPOS_DE_EVENTO.handoffRecuperado, {

package/dist/hitl-local-receipt.js

@@ -33,6 +33,7 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.chaveLocal = chaveLocal;
 exports.gravarEvidenciaLocal = gravarEvidenciaLocal;
 exports.gravarEvidenciaLocalSessao = gravarEvidenciaLocalSessao;
 exports.validarEvidenciaLocalSessao = validarEvidenciaLocalSessao;
@@ -70,6 +71,7 @@ function diretorioPrivado(file) {
     }
     return validarDiretorio(file, 0o700);
 }
+/** RM-058 (N1): exportada só para o arco #Noctum derivar a subchave dele (`noctum-arco.ts`). */
 function chaveLocal(raiz, criar) {
     const estado = path.join((0, estado_thread_1.raizDoEstado)(raiz), '.orkastery');
     const stEstado = fs.lstatSync(estado);

package/dist/hitl-resumo.js

@@ -1,9 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SEM_PERGUNTA_NO_RESUMO = exports.TETO_DE_DECISOES_DETALHADAS = exports.TETO_DE_ESPERAS_POR_MAQUINA = exports.TETO_DE_PARADOS_NO_CONDUTOR = exports.TETO_DE_THREADS_NOMEADAS = exports.PERGUNTA_DO_RESUMO = exports.CONTRATO_RESUMO = void 0;
+exports.SEM_PERGUNTA_COM_IMPEDIMENTO = exports.SEM_PERGUNTA_NO_RESUMO = exports.TETO_DE_DECISOES_DETALHADAS = exports.TETO_DE_ESPERAS_POR_MAQUINA = exports.TETO_DE_IMPEDIMENTOS = exports.TETO_DE_PARADOS_NO_CONDUTOR = exports.TETO_DE_THREADS_NOMEADAS = exports.PERGUNTA_DO_RESUMO = exports.CONTRATO_RESUMO = void 0;
 exports.resumirHitl = resumirHitl;
 exports.linhaDoParadoNoCondutor = linhaDoParadoNoCondutor;
 exports.linhasDoCondutor = linhasDoCondutor;
+exports.linhasDosImpedimentos = linhasDosImpedimentos;
 exports.linhaDosTecnicos = linhaDosTecnicos;
 exports.linhasDasOutrasMaquinas = linhasDasOutrasMaquinas;
 exports.linhasDasDecisoes = linhasDasDecisoes;
@@ -29,6 +30,7 @@ exports.textoDoResumo = textoDoResumo;
  * mensagem do canal. Quem entrega chama a segunda.
  */
 const horario_1 = require("./horario");
+const locale_1 = require("./locale");
 const hitl_tempo_parado_1 = require("./hitl-tempo-parado");
 const decisao_autonoma_1 = require("./decisao-autonoma");
 const hitl_classificacao_1 = require("./hitl-classificacao");
@@ -60,6 +62,8 @@ function resumirHitl(itens, opcoes) {
         threadsTecnicas: [...new Set(tecnicos.map(i => i.thread).filter((t) => !!t))].sort(),
         ...(opcoes.paradosNoCondutor?.length ? { paradosNoCondutor: opcoes.paradosNoCondutor.map(p => ({ thread: p.thread, caso: p.caso,
                 desdeEm: p.desdeEm, proximoPasso: p.proximoPasso })) } : {}),
+        ...(opcoes.impedimentosDoDono?.length ? { impedimentosDoDono: opcoes.impedimentosDoDono.map(i => ({ thread: i.thread,
+                fase: i.fase, comando: i.comando, retry: i.retry })) } : {}),
         ...(opcoes.hitlDeConducao?.acimaDaMeta ? { hitlDeConducao: opcoes.hitlDeConducao } : {}),
     };
 }
@@ -71,7 +75,7 @@ exports.TETO_DE_PARADOS_NO_CONDUTOR = 5;
  */
 function linhaDoParadoNoCondutor(p, opcoes) {
     const { desdeEm: desde } = p;
-    return `${p.thread} parado no condutor desde ${(0, horario_1.formatarHora)(desde, opcoes)}: ${p.proximoPasso}`;
+    return (0, locale_1.msg)().pulse.linhaDoCondutor(p.thread, (0, horario_1.formatarHora)(desde, opcoes), p.proximoPasso);
 }
 /** As linhas do condutor no resumo, uma por thread, com o resto contado. */
 function linhasDoCondutor(r, marcador, recuo) {
@@ -80,6 +84,24 @@ function linhasDoCondutor(r, marcador, recuo) {
     return [...mostradas.map(p => `${marcador}${linhaDoParadoNoCondutor(p, { agora: r.consultadoEm })}`),
         ...(sobra > 0 ? [`${recuo}e mais ${sobra}: ork pulse`] : [])];
 }
+/** Quantos impedimentos do dono o resumo detalha antes de contar o resto. */
+exports.TETO_DE_IMPEDIMENTOS = 5;
+/** Uma linha so, sem caractere de controle e sem corte: o comando precisa chegar inteiro para ser copiado. */
+const semQuebra = (texto) => String(texto).replace(/\p{Cc}/gu, ' ').replace(/\s+/g, ' ').trim();
+/**
+ * RM-055 (continuacao, D3): o titulo e uma linha por impedimento do dono, iguais nos dois canais (so o
+ * marcador e o recuo mudam). Cada linha diz a thread, a fase, o comando exato e o retry que vem depois.
+ */
+function linhasDosImpedimentos(r, marcador, recuo) {
+    const impedimentos = r.impedimentosDoDono ?? [];
+    if (!impedimentos.length)
+        return [];
+    const mostrados = impedimentos.slice(0, exports.TETO_DE_IMPEDIMENTOS), sobra = impedimentos.length - mostrados.length;
+    return [`${marcador}Só você destrava, no terminal: ${impedimentos.length}`,
+        ...mostrados.map(i => `${recuo}• ${semQuebra(i.thread)}${i.fase ? ` ${semQuebra(i.fase)}` : ''}: ` +
+            `rode \`${semQuebra(i.comando)}\`; depois \`${semQuebra(i.retry)}\``),
+        ...(sobra > 0 ? [`${recuo}e mais ${sobra}: ork pulse`] : [])];
+}
 /** RM-057 (fatia 3): a linha do tempo parado por HITL de conducao, a mesma nos dois canais. */
 function linhaDoHitlParado(r) {
     const linha = (0, hitl_tempo_parado_1.linhaDoHitlAcimaDaMeta)(r.hitlDeConducao, { agora: r.consultadoEm });
@@ -143,6 +165,8 @@ function linhasDasDecisoes(r, marcador, recuo) {
 }
 /** Quando nao ha pergunta, o resumo diz isso em vez de pedir licenca para mandar nada. */
 exports.SEM_PERGUNTA_NO_RESUMO = 'Nada aqui pede resposta sua por este canal agora.';
+/** RM-055 (continuacao, D3): sem pergunta, mas com impedimento do dono: o que fazer esta no bloco acima. */
+exports.SEM_PERGUNTA_COM_IMPEDIMENTO = 'Nada aqui pede resposta sua por este canal agora; o que só você destrava está acima, no terminal.';
 /** A linha das perguntas prontas, uma so para os dois canais, pelo mesmo motivo da de baixo. */
 function linhaDasPerguntas(n) {
     return `Perguntas para você: ${n}`;
@@ -192,7 +216,7 @@ function abertura(r, codigo, marca, resposta) {
     return r.pergunta ? [`${marca}${r.pergunta}`, ...linhaDeResposta(codigo).map(l => `${resposta}${l}`), ''] : [];
 }
 function fecho(r) {
-    return r.pergunta ? [] : ['', exports.SEM_PERGUNTA_NO_RESUMO];
+    return r.pergunta ? [] : ['', r.impedimentosDoDono?.length ? exports.SEM_PERGUNTA_COM_IMPEDIMENTO : exports.SEM_PERGUNTA_NO_RESUMO];
 }
 function textoTelegram(r, codigo) {
     const quando = (0, horario_1.formatarDataHoraRotulada)(r.consultadoEm, { agora: r.consultadoEm });
@@ -209,6 +233,7 @@ function textoTelegram(r, codigo) {
         ...(r.tecnicos ? [`🔧 ${linhaDosTecnicos(r)}`] : []),
         ...(r.consertos ? [`🔧 ${linhaDosConsertos(r.consertos)}`] : []),
         ...linhaDoHitlParado(r).map(l => `⏳ ${l}`),
+        ...(r.impedimentosDoDono?.length ? ['', ...linhasDosImpedimentos(r, '🔑 ', '   ')] : []),
         ...(r.paradosNoCondutor?.length ? ['', ...linhasDoCondutor(r, '🚧 ', '   ')] : []),
         ...(r.acumuladas ? ['', `📥 ${linhaDoLoteGuardado(r.acumuladas)}`] : []),
         ...(r.decisoes.length || r.acimaDoLimiar.length ? ['', ...linhasDasDecisoes(r, '🧭 ', '   ')] : []),
@@ -241,6 +266,7 @@ function textoTerminal(r, codigo) {
         ...(r.tecnicos ? ['', `  ${linhaDosTecnicos(r)}`] : []),
         ...(r.consertos ? ['', `  ${linhaDosConsertos(r.consertos)}`] : []),
         ...linhaDoHitlParado(r).flatMap(l => ['', `  ${l}`]),
+        ...(r.impedimentosDoDono?.length ? ['', ...linhasDosImpedimentos(r, '  ', '  ')] : []),
         ...(r.paradosNoCondutor?.length ? ['', ...linhasDoCondutor(r, '  ', '  ')] : []),
         ...(r.acumuladas ? ['', `  ${linhaDoLoteGuardado(r.acumuladas)}`] : []),
         ...(r.decisoes.length || r.acimaDoLimiar.length ? ['', ...linhasDasDecisoes(r, '', '  ').map(l => l.startsWith('  ') ? l : `  ${l}`)] : []),

package/dist/hitl-tempo-parado.js

@@ -42,6 +42,7 @@ const hitl_contract_1 = require("./hitl-contract");
 const horario_1 = require("./horario");
 const ledger_1 = require("./ledger");
 const thread_1 = require("./thread");
+const locale_1 = require("./locale");
 /** A meta da RM-057: mediana de resposta abaixo de 5 minutos. */
 exports.META_DA_MEDIANA_DE_RESPOSTA_MS = 5 * 60_000;
 const RESPOSTAS = ['human_gate', 'session_answered'];
@@ -178,13 +179,12 @@ const emMinutos = (ms) => `${(ms / 60_000).toFixed(1)} min`;
 function textoDaMediana(h) {
     const s = h.seteDias;
     if (s.medianaRespostaMs === null)
-        return 'mediana de 7 dias sem resposta medida';
-    return `mediana de 7 dias ${emMinutos(s.medianaRespostaMs)} (${s.dentroDaMeta ? 'dentro' : 'acima'} da meta de 5 min, ` +
-        `${s.respondidos} resposta(s))`;
+        return (0, locale_1.msg)().pulse.medianaSemResposta;
+    return (0, locale_1.msg)().pulse.mediana(emMinutos(s.medianaRespostaMs), s.dentroDaMeta, s.respondidos);
 }
 /** "<thread> (<fase>) parada ha 12min, desde 01:02": a hora no fuso do dono (RM-035). */
 function linhaDaPerguntaParada(p, opcoes) {
-    return `${p.thread} (${p.fase}) parada há ${(0, horario_1.duracaoRelativa)(p.paradaHaMin)}, desde ${(0, horario_1.formatarHora)(p.desdeEm, opcoes)}`;
+    return (0, locale_1.msg)().pulse.perguntaParada(p.thread, p.fase, (0, horario_1.duracaoRelativa)(p.paradaHaMin), (0, horario_1.formatarHora)(p.desdeEm, opcoes));
 }
 /**
  * A linha unica do resumo do pulse, so quando passou da meta: quantas abertas, a mais antiga e a

package/dist/hitl.js

@@ -88,6 +88,8 @@ const horario_1 = require("./horario");
 Object.defineProperty(exports, "duracaoCurta", { enumerable: true, get: function () { return horario_1.duracaoCurta; } });
 const hitl_estado_1 = require("./hitl-estado");
 const redacao_url_1 = require("./redacao-url");
+const locale_1 = require("./locale");
+const locale_pulse_1 = require("./locale-pulse");
 /** Limite de atencao padrao, em minutos, igual ao do monitor de orquestracao. */
 exports.ATENCAO_PADRAO_MIN = 30;
 function redigirSegredos(texto) {
@@ -110,28 +112,29 @@ function contextoSeguro(texto, linhas = 20) {
  * `stopped` NAO pede humano: a sessao foi parada por decisao de alguem. `failed` pede,
  * porque alguem precisa decidir entre retomar, corrigir ou abandonar.
  */
+// RM-061 (F2b): o detalhe de cada estado tem a fonte no catalogo pt-BR (`locale-pulse.ts`), com o ingles ao lado.
 const REGRA_POR_ESTADO = {
     blocked: {
         classe: 'hitl',
         precisaDeHumano: true,
-        detalhe: 'sessao parada esperando acao humana (prompt, permissao ou credencial)',
+        detalhe: locale_pulse_1.PULSE_PT_BR.sessao.blocked,
     },
     failed: {
         classe: 'falha',
         precisaDeHumano: true,
-        detalhe: 'sessao terminou em erro: alguem decide entre retomar, corrigir ou abandonar',
+        detalhe: locale_pulse_1.PULSE_PT_BR.sessao.failed,
     },
-    working: { classe: 'trabalhando', precisaDeHumano: false, detalhe: 'sessao em execucao' },
-    done: { classe: 'concluida', precisaDeHumano: false, detalhe: 'sessao concluiu' },
+    working: { classe: 'trabalhando', precisaDeHumano: false, detalhe: locale_pulse_1.PULSE_PT_BR.sessao.working },
+    done: { classe: 'concluida', precisaDeHumano: false, detalhe: locale_pulse_1.PULSE_PT_BR.sessao.done },
     stopped: {
         classe: 'interrompida',
         precisaDeHumano: false,
-        detalhe: 'sessao parada por decisao humana (`claude stop`)',
+        detalhe: locale_pulse_1.PULSE_PT_BR.sessao.stopped,
     },
     idle: {
         classe: 'interativa',
         precisaDeHumano: false,
-        detalhe: 'sessao interativa ociosa, conduzida por um humano no terminal',
+        detalhe: locale_pulse_1.PULSE_PT_BR.sessao.idle,
     },
 };
 /** Estado cru da sessao: `state` manda, `status` e o fallback historico. */
@@ -142,14 +145,13 @@ function estadoBruto(s) {
 /** Classifica o estado cru do runtime. Estado que nao esta no mapa avisa a mais. */
 function classificarEstado(estado) {
     const regra = REGRA_POR_ESTADO[estado];
+    // RM-061 (F2b, G2): o detalhe vem do catalogo (o mesmo pt-BR da tabela) e o pulse o remonta no locale.
     if (regra)
-        return regra;
+        return { ...regra, detalhe: (0, locale_1.textoDoCatalogo)((m) => m.pulse.sessao[estado] ?? regra.detalhe) };
     return {
         classe: 'desconhecida',
         precisaDeHumano: true,
-        detalhe: estado === ''
-            ? 'runtime nao informou estado desta sessao: tratada como possivel parada'
-            : `estado "${estado}" nao esta no catalogo do ork: tratado como possivel parada`,
+        detalhe: (0, locale_1.textoDoCatalogo)((m) => estado === '' ? m.pulse.sessaoSemEstado : m.pulse.sessaoEstadoForaDoCatalogo(estado)),
     };
 }
 /** Resposta do `claude logs` quando o job da sessao ja saiu do runtime. */
@@ -279,28 +281,22 @@ function lerPerguntaDaTela(textoLimpo) {
  * inventa opcao que a sessao nao deu.
  */
 function recomendarPara(classe, tipo, id) {
-    if (classe === 'abandonada') {
-        return ('nao responda: o job ja saiu. Confira o que ficou na worktree da sessao e ' +
-            'redespache so o resto do trabalho.');
-    }
-    if (classe === 'falha') {
-        return `leia \`ork sessions logs ${id}\` e decida entre retomar, corrigir a causa ou abandonar a sessao.`;
-    }
-    if (classe === 'desconhecida') {
-        return `estado fora do catalogo: confirme no \`ork sessions logs ${id}\` se a sessao esta mesmo parada.`;
-    }
-    switch (tipo) {
-        case 'hitl.credencial':
-            return (`entregue o segredo agora (\`claude attach ${id}\`) para nao segurar a entrega; ` +
-                'se este mesmo bloqueio ja se repetiu, troque por credencial de automacao e ele nao volta.');
-        case 'hitl.permissao':
-            return (`responda o prompt (\`claude attach ${id}\`); se o comando e rotineiro nesse projeto, ` +
-                'coloque-o na allowlist de permissoes para nao parar de novo pelo mesmo motivo.');
-        case 'hitl.pergunta':
-            return `abra a sessao (\`claude attach ${id}\`) e escolha entre as opcoes que ela listou.`;
-        default:
-            return `veja o que a sessao pede com \`ork sessions logs ${id}\` antes de responder.`;
-    }
+    // RM-061 (F2b, G2): nasce em pt-BR pelo catalogo (o --json guarda) e o pulse a remonta no locale.
+    return (0, locale_1.textoDoCatalogo)((m) => {
+        const r = m.pulse.recomendacaoDoRadar;
+        if (classe === 'abandonada')
+            return r.abandonada;
+        if (classe === 'falha')
+            return r.falha(id);
+        if (classe === 'desconhecida')
+            return r.desconhecida(id);
+        switch (tipo) {
+            case 'hitl.credencial': return r.credencial(id);
+            case 'hitl.permissao': return r.permissao(id);
+            case 'hitl.pergunta': return r.pergunta(id);
+            default: return r.outra(id);
+        }
+    });
 }
 /** Minutos inteiros entre um epoch em ms e um carimbo ISO (nunca negativo). */
 function idadeEmMinutos(inicioMs, ateEm) {
@@ -440,7 +436,7 @@ function varrerSessoes(opcoes = {}) {
     }
     const consultaClaude = opcoes.consulta ?? (adapter.disponivel()
         ? adapter.consultarSessoes(opcoes.soDaRaiz && raiz ? raiz : undefined, true)
-        : { ok: false, sessoes: [], detalhe: 'runtime adapter indisponivel nesta maquina (`claude` fora do PATH)' });
+        : { ok: false, sessoes: [], detalhe: (0, locale_1.textoDoCatalogo)((m) => m.pulse.adapterIndisponivel) });
     const consulta = { ...consultaClaude, ok: consultaClaude.ok || nativas.size > 0,
         sessoes: [...consultaClaude.sessoes, ...nativas.values()] };
     if (!consulta.ok) {

package/dist/horario.js

@@ -34,6 +34,7 @@ exports.formatarPrazo = formatarPrazo;
 exports.formatarDesde = formatarDesde;
 exports.localizarTexto = localizarTexto;
 exports.localizarTextoRotulado = localizarTextoRotulado;
+const locale_1 = require("./locale");
 exports.CHAVE_DO_FUSO = 'owner.timezone';
 /** Único fuso com nome próprio no rótulo; exemplo da documentação e do `ork init`. */
 exports.FUSO_DE_BRASILIA = 'America/Sao_Paulo';
@@ -194,11 +195,11 @@ function duracaoCurta(minutos) {
 }
 /** Duração até ou desde agora: abaixo de 1 min diz `menos de 1 min`, nunca `0min`. */
 function duracaoRelativa(minutos) {
-    return minutos < 1 ? 'menos de 1 min' : duracaoCurta(minutos);
+    return minutos < 1 ? (0, locale_1.msg)().horario.menosDeUmMin : duracaoCurta(minutos);
 }
-function sigla(fuso, ms) {
+function sigla(fuso, ms, locale = (0, locale_1.localeAtivo)()) {
     try {
-        return new Intl.DateTimeFormat('pt-BR', { timeZone: fuso, timeZoneName: 'short' })
+        return new Intl.DateTimeFormat(locale === 'en' ? 'en-US' : 'pt-BR', { timeZone: fuso, timeZoneName: 'short' })
             .formatToParts(new Date(ms)).find(p => p.type === 'timeZoneName')?.value ?? '';
     }
     catch {
@@ -208,7 +209,7 @@ function sigla(fuso, ms) {
 /** Como o fuso aparece entre parênteses: `horário de Brasília`, `UTC`, `Europe/Lisbon, GMT+1`. */
 function rotuloDoFuso(fuso = fusoDoDono().fuso, quando) {
     if (fuso === exports.FUSO_DE_BRASILIA)
-        return 'horário de Brasília';
+        return (0, locale_1.msg)().horario.brasilia;
     if (fuso === 'UTC')
         return 'UTC';
     const ms = instante(quando);
@@ -218,16 +219,22 @@ function rotuloDoFuso(fuso = fusoDoDono().fuso, quando) {
 /** Legenda de mensagem com vários horários: `Horários de Brasília.` */
 function legendaDoFuso(fuso = fusoDoDono().fuso, quando) {
     if (fuso === exports.FUSO_DE_BRASILIA)
-        return 'Horários de Brasília.';
-    return `Horários em ${rotuloDoFuso(fuso, quando)}.`;
+        return (0, locale_1.msg)().horario.legendaBrasilia;
+    return (0, locale_1.msg)().horario.legenda(rotuloDoFuso(fuso, quando));
 }
-/** `19/09 15:16`; `19/09/2025 15:16` quando o ano não é o corrente do dono. Inválido volta como veio. */
+/**
+ * `19/09 15:16`; `19/09/2025 15:16` quando o ano não é o corrente do dono. Em `en`, sempre
+ * `2026-09-19 15:16` (EN6). Inválido volta como veio.
+ */
 function formatarDataHora(quando, opcoes = {}) {
     const ms = instante(quando ?? null);
     if (!Number.isFinite(ms))
         return quando === null || quando === undefined ? '' : String(quando);
     const fuso = opcoes.fuso ?? fusoDoDono().fuso;
     const p = partesLocais(ms, fuso), a = partesLocais(instante(opcoes.agora), fuso);
+    if ((opcoes.locale ?? (0, locale_1.localeAtivo)()) === 'en') {
+        return `${p.ano}-${p.mes}-${p.dia} ${p.hora}:${p.minuto}` + (opcoes.segundos ? `:${p.segundo}` : '');
+    }
     return `${p.dia}/${p.mes}${p.ano !== a.ano ? `/${p.ano}` : ''} ${p.hora}:${p.minuto}` +
         (opcoes.segundos ? `:${p.segundo}` : '');
 }

package/dist/hosts.js

@@ -354,7 +354,7 @@ function instalarAdaptador(host, opcoes = {}) {
     let planoExperiencia = null;
     if (preferencias && hostComBloco && !avisoExperiencia) {
         try {
-            planoExperiencia = (0, experiencia_instalacao_1.planejarExperiencia)(projeto, host, preferencias.experience ? diretorioExperiencia : null);
+            planoExperiencia = (0, experiencia_instalacao_1.planejarExperiencia)(projeto, host, preferencias.experience ? diretorioExperiencia : null, opcoes.locale);
         }
         catch (e) {
             const motivo = e.message;
@@ -421,6 +421,7 @@ function instalarAdaptador(host, opcoes = {}) {
             estado,
         });
     }
+    const removidos = sobrasDeMods(destino, recibo, arquivos);
     const conflitos = arquivos.filter((a) => a.estado === 'sobrescrito');
     /**
      * I-43 (D5): a divergencia continua sendo DETECTADA; ela deixa de BARRAR quando e
@@ -458,6 +459,7 @@ function instalarAdaptador(host, opcoes = {}) {
         ...(preferencias || avisoExperiencia ? { experiencia: { ativa: host !== 'openclaw' && !!preferencias?.experience && !avisoExperiencia,
                 arquivos: planoExperiencia?.mudancas.map(m => path.relative(planoExperiencia.projeto, m.arquivo)) ?? [], skill: preferencias?.skill ?? '',
                 ...(avisoExperiencia ? { aviso: avisoExperiencia } : {}) } } : {}),
+        ...(removidos.length ? { removidos } : {}),
     };
     if (opcoes.dryRun === true || barrado)
         return resultado;
@@ -477,6 +479,17 @@ function instalarAdaptador(host, opcoes = {}) {
         if (arquivo.executavel)
             fs.chmodSync(arquivo.destino, 0o755);
     }
+    // RM-059 (T0.7, A1 do CHECK): o que saiu do catalogo em `mods/` sai da copia, com a pasta que ficar vazia.
+    for (const relativo of removidos) {
+        const alvo = path.join(destino, relativo);
+        fs.unlinkSync(alvo);
+        const raizDoMod = path.join(destino, ...relativo.split('/').slice(0, 2));
+        for (let dir = path.dirname(alvo); dir.startsWith(raizDoMod); dir = path.dirname(dir)) {
+            if (fs.readdirSync(dir).length)
+                break;
+            fs.rmdirSync(dir);
+        }
+    }
     // O recibo: com ele da para saber, depois, se alguem editou a copia instalada em vez do
     // catalogo. Sem ele a instalacao e um monte de arquivo sem procedencia.
     fs.writeFileSync(path.join(destino, 'INSTALADO.json'), JSON.stringify({
@@ -497,6 +510,41 @@ function instalarAdaptador(host, opcoes = {}) {
         (0, experiencia_instalacao_1.aplicarExperiencia)(planoExperiencia);
     return resultado;
 }
+/**
+ * RM-059 (T0.7, A1 do CHECK): os arquivos de `mods/` do recibo anterior que nao estao mais no catalogo e que a
+ * copia guarda como foram instalados (sha256 do recibo), os de cada mod e os comuns da raiz de `mods/` (N2 da
+ * rodada 2). Arquivo editado, link ou caminho fora do destino fica: o despacho continua recusando com o motivo,
+ * e a decisao e de quem editou.
+ */
+function sobrasDeMods(destino, recibo, arquivos) {
+    if (!recibo)
+        return [];
+    const novos = new Set(arquivos.map((a) => a.relativo));
+    let base;
+    try {
+        base = fs.realpathSync(destino);
+    }
+    catch {
+        return [];
+    }
+    return recibo.arquivos.flatMap((a) => {
+        const rel = typeof a.arquivo === 'string' ? a.arquivo : '';
+        if (!/^mods\/[^/]+(?:$|\/.)/.test(rel) || novos.has(rel) || path.isAbsolute(rel) || rel.split('/').includes('..'))
+            return [];
+        const alvo = path.join(destino, rel);
+        const st = fs.lstatSync(alvo, { throwIfNoEntry: false });
+        if (!st || !st.isFile() || st.nlink !== 1)
+            return [];
+        try {
+            if (!fs.realpathSync(path.dirname(alvo)).startsWith(base + path.sep))
+                return [];
+        }
+        catch {
+            return [];
+        }
+        return sha256(fs.readFileSync(alvo)) === a.sha256 ? [rel] : [];
+    });
+}
 /** Caminho real do maior ancestral existente, com o resto como está: o destino pode não existir ainda. */
 function caminhoReal(alvo) {
     let existente = path.resolve(alvo);
@@ -592,6 +640,9 @@ function textoDaInstalacao(r) {
         const porque = a.divergencia ? `  (${a.divergencia})` : '';
         linhas.push(`    ${marca} ${a.relativo}${porque}`);
     }
+    // RM-059 (T0.7): arquivo de mod que saiu do catalogo sai da copia, para o despacho nao recusar o mod.
+    for (const rel of r.removidos ?? [])
+        linhas.push(`    - ${rel}  (saiu do catalogo${r.dryRun ? ', seria removido' : ', removido'})`);
     // I-43 (D5): o `--dir` na raiz avisa, em vez de reportar "tudo novo" com saida 0.
     if (r.reciboVizinho) {
         linhas.push('');

package/dist/impedimento.js

@@ -79,6 +79,17 @@ function ehEsperaDoDono(e, tipoGateBloqueado = 'gate_blocked') {
 function citar(caminho) {
     return /^[A-Za-z0-9_./:@+-]+$/.test(caminho) ? caminho : `'${caminho.replace(/'/g, `'\\''`)}'`;
 }
+/**
+ * RM-055 (continuacao, D4): frases que dizem "Workspace not trusted" mas que aceitar a confianca NAO
+ * resolve. No claude 2.1.296 o veredito do `--bg` tem tres saidas: o diretorio que nao existe mais no
+ * disco, o diretorio home (que so confia uma sessao por vez) e a recusa de confianca de verdade. As duas
+ * primeiras ficam no caminho generico (`runtime.unavailable`), com o stderr gravado no despacho falho:
+ * mandar o dono rodar `cd <dir> && claude` ali nao destrava nada.
+ */
+const FRASES_QUE_NAO_SAO_DO_DONO = [
+    /could not be resolved on disk/i,
+    /home directory is trusted one session at a time/i,
+];
 const FRASES_DE_CONFIANCA = [
     /workspace not trusted/i,
     /accept the trust (?:prompt|dialog)/i,
@@ -86,10 +97,32 @@ const FRASES_DE_CONFIANCA = [
     /(?:folder|directory|workspace) (?:is )?not trusted/i,
 ];
 const FRASES_DE_CONSENTIMENTO = [
-    /accept (?:the )?(?:updated |new )?(?:terms|consumer terms|privacy policy|usage policy)/i,
-    /(?:terms|policy) (?:have|has) (?:been )?updated[^\n]*accept/i,
-    /consent (?:is )?required/i,
+    // claude 2.1.296, modo print: o aviso que bloqueia e sai com 1. O aviso de carencia ("will take effect
+    // ... Run `claude` to review the updated terms") nao bloqueia e nao casa aqui.
+    { regra: /\[ACTION REQUIRED\][^\n]*(?:terms|policy)/i, aceita: 'revisar e aceitar os termos novos',
+        feito: 'aceite os termos e saia' },
+    // claude 2.1.296: o portao do `--bg` que vem antes da confianca (gateCause "disclaimer").
+    { regra: /requires accepting the disclaimer first/i, aceita: 'aceitar o aviso do modo sem permissões (bypass)',
+        feito: 'aceite o aviso e saia' },
+    { regra: /requires opting in first/i, aceita: 'ativar o modo auto uma vez', feito: 'confirme o modo auto e saia' },
+    // Fatia 1 (02/10/2026): frases genericas de termos novos.
+    { regra: /accept (?:the )?(?:updated |new )?(?:terms|consumer terms|privacy policy|usage policy)/i,
+        aceita: 'aceitar termos novos', feito: 'aceite os termos e saia' },
+    { regra: /(?:terms|policy) (?:have|has) (?:been )?updated[^\n]*accept/i, aceita: 'aceitar termos novos',
+        feito: 'aceite os termos e saia' },
+    { regra: /consent (?:is )?required/i, aceita: 'aceitar termos novos', feito: 'aceite os termos e saia' },
 ];
+/** A forma fechada de um comando que o runtime manda rodar: o binario e opcoes `--nome` com valor simples. */
+const FORMA_DO_COMANDO = /^(?:claude|codex)(?: --[a-z][a-z-]*(?: [a-z][a-z0-9-]*)?)*$/;
+/**
+ * RM-055 (continuacao, D4): o comando que a propria frase do runtime manda rodar ("Run `claude
+ * --permission-mode auto` once interactively"). So na forma fechada e so do binario do runtime: a saida
+ * do runtime nunca chega ao dono como comando arbitrario. Fora disso, o binario puro.
+ */
+function comandoDaFrase(trecho, bin) {
+    const pedido = /\brun `([^`]{1,120})`/i.exec(trecho)?.[1].replace(/\s+/g, ' ').trim();
+    return pedido && FORMA_DO_COMANDO.test(pedido) && pedido.split(' ')[0] === bin ? pedido : bin;
+}
 function trechoDa(texto, regra) {
     const linha = texto.split(/\r?\n/).find(l => regra.test(l)) ?? texto;
     return linha.replace(/\s+/g, ' ').trim().slice(0, 240);
@@ -103,6 +136,8 @@ function binarioDo(runtime) {
  */
 function classificarImpedimento(saida, ctx) {
     const texto = saida ?? '';
+    if (FRASES_QUE_NAO_SAO_DO_DONO.some(r => r.test(texto)))
+        return null;
     const bin = binarioDo(ctx.runtime);
     const depois = `depois, \`ork retry run ${ctx.thread}\` re-despacha ${ctx.fase} com o mesmo prompt gravado`;
     const confianca = FRASES_DE_CONFIANCA.find(r => r.test(texto));
@@ -115,23 +150,77 @@ function classificarImpedimento(saida, ctx) {
             trecho: trechoDa(texto, confianca),
         };
     }
-    const consentimento = FRASES_DE_CONSENTIMENTO.find(r => r.test(texto));
+    const consentimento = FRASES_DE_CONSENTIMENTO.find(c => c.regra.test(texto));
     if (consentimento) {
+        const trecho = trechoDa(texto, consentimento.regra);
         return {
             motivo: 'runtime.consent-pending',
-            trava: `o ${bin} espera você aceitar termos novos e recusou o despacho de ${ctx.fase}`,
-            comando: bin,
-            depois: `aceite os termos e saia; ${depois}`,
-            trecho: trechoDa(texto, consentimento),
+            trava: `o ${bin} espera você ${consentimento.aceita} e recusou o despacho de ${ctx.fase}`,
+            comando: comandoDaFrase(trecho, bin),
+            depois: `${consentimento.feito}; ${depois}`,
+            trecho,
         };
     }
     return null;
 }
+/** O caminho como o claude o compara: o real, sem link; o resolvido quando ele nao existe no disco. */
+function caminhoReal(caminho) {
+    try {
+        return fs.realpathSync.native(caminho);
+    }
+    catch {
+        return path.resolve(caminho);
+    }
+}
+/** A raiz git do diretorio: o ancestral mais proximo, ele incluido, com `.git` (arquivo ou diretorio). */
+function raizGit(dir) {
+    for (let d = dir;; d = path.dirname(d)) {
+        try {
+            const st = fs.lstatSync(path.join(d, '.git'));
+            if (st.isFile() || st.isDirectory())
+                return d;
+        }
+        catch { /* sem `.git` aqui: sobe */ }
+        if (path.dirname(d) === d)
+            return null;
+    }
+}
+/**
+ * A raiz canonica de uma raiz git, conferida como o claude 2.1.296 confere: numa worktree vinculada (o
+ * arquivo `.git` aponta `gitdir:` para `<comum>/worktrees/<nome>`, que tem `commondir` e um `gitdir` de
+ * volta para `<raiz>/.git`), e o repositorio principal, o diretorio de cima do `<comum>` chamado `.git`.
+ * Qualquer conferencia que falha devolve a propria raiz, e um repositorio comum (`.git` diretorio) tambem.
+ */
+function raizCanonica(raiz) {
+    try {
+        const conteudo = fs.readFileSync(path.join(raiz, '.git'), 'utf8').trim();
+        if (!conteudo.startsWith('gitdir:'))
+            return raiz;
+        const gitdir = path.resolve(raiz, conteudo.slice('gitdir:'.length).trim());
+        const comum = path.resolve(gitdir, fs.readFileSync(path.join(gitdir, 'commondir'), 'utf8').trim());
+        if (path.dirname(gitdir) !== path.join(comum, 'worktrees'))
+            return raiz;
+        const deVolta = path.resolve(gitdir, fs.readFileSync(path.join(gitdir, 'gitdir'), 'utf8').trim());
+        if (caminhoReal(deVolta) !== path.join(caminhoReal(raiz), '.git'))
+            return raiz;
+        if (path.basename(comum) !== '.git')
+            return fs.existsSync(path.join(comum, '.git')) ? raiz : comum;
+        return path.dirname(comum);
+    }
+    catch {
+        return raiz;
+    }
+}
 /**
  * O impedimento ja foi resolvido? So o de confianca do diretorio tem prova local: o `claude` grava
- * `hasTrustDialogAccepted` por projeto no `.claude.json` da conta (o do perfil, com `CLAUDE_CONFIG_DIR`),
- * e a confianca de um diretorio vale para os de baixo. `null` e "nao sei": o retry despacha e o runtime
- * decide; se recusar de novo, a mesma pausa volta.
+ * `hasTrustDialogAccepted` por projeto no `.claude.json` da conta (o do perfil, com `CLAUDE_CONFIG_DIR`).
+ * `null` e "nao sei": o retry despacha e o runtime decide; se recusar de novo, a mesma pausa volta.
+ *
+ * RM-055 (continuacao, D1): a regra e a que o claude 2.1.296 aplica no `--bg`, medida com worktrees git
+ * reais: vale a confianca do proprio diretorio e dos de cima ate a raiz git, inclusive, e a da raiz
+ * canonica de uma worktree vinculada (o repositorio principal), more a worktree dentro ou fora dele. Acima
+ * da raiz git nada vale: com so o diretorio de cima do repositorio confiado, o claude recusa a worktree.
+ * Fora de git, qualquer diretorio de cima vale, como no claude.
  */
 function impedimentoResolvido(motivo, ctx) {
     if (motivo !== 'runtime.workspace-untrusted' || ctx.runtime !== 'claude-bg')
@@ -149,10 +238,15 @@ function impedimentoResolvido(motivo, ctx) {
     catch {
         return null;
     }
-    for (let dir = path.resolve(ctx.cwd);; dir = path.dirname(dir)) {
-        if (projetos[dir]?.hasTrustDialogAccepted === true)
+    const confia = (dir) => projetos[dir]?.hasTrustDialogAccepted === true;
+    const cwd = caminhoReal(ctx.cwd);
+    const raiz = raizGit(cwd);
+    if (raiz && confia(raizCanonica(raiz)))
+        return true;
+    for (let dir = cwd;; dir = path.dirname(dir)) {
+        if (confia(dir))
             return true;
-        if (path.dirname(dir) === dir)
+        if (dir === raiz || path.dirname(dir) === dir)
             return false;
     }
 }