@orkastery/cli 0.5.3 → 0.5.6

package/dist/roadmap-reservas.js

@@ -48,6 +48,7 @@ exports.soltarItem = soltarItem;
 exports.reservasOrfas = reservasOrfas;
 exports.soltarReservaDaThread = soltarReservaDaThread;
 exports.soltarReservasOrfas = soltarReservasOrfas;
+exports.leituraDasReservas = leituraDasReservas;
 exports.textoDasReservas = textoDasReservas;
 /**
  * I-47: reservas de item do roadmap entre maquinas, como documentacao em codigo.
@@ -71,6 +72,7 @@ const os = __importStar(require("node:os"));
 const path = __importStar(require("node:path"));
 const branch_de_estado_1 = require("./branch-de-estado");
 const horario_1 = require("./horario");
+const locale_1 = require("./locale");
 const ledger_1 = require("./ledger");
 const maquina_1 = require("./maquina");
 const thread_1 = require("./thread");
@@ -101,15 +103,16 @@ const PREFIXO = 'roadmap';
 /** O item precisa existir no roadmap do projeto (`docs/roadmap/RM-NNN-*.md`). */
 function exigirItem(raiz, item) {
     const id = item.trim().toUpperCase();
+    // RM-061 (D14): `thread new --roadmap` chama isto no escopo pt-BR da reserva; a entrada do CLI remonta no locale dele.
     if (!ITEM.test(id))
-        throw new Error(`roadmap.item: "${item}" nao e um item do roadmap (esperado RM-NNN)`);
+        throw new locale_1.ErroDoCatalogo((m) => m.thread.roadmapItemInvalido(item));
     const dir = path.join(raiz, 'docs', 'roadmap');
     const doItem = (f) => path.basename(f).startsWith(`${id}-`) && f.endsWith('.md');
     const naArvore = fs.existsSync(dir) && fs.readdirSync(dir).some(doItem);
     // O checkout pode estar numa branch antiga, sem o item: vale tambem o que a main ja tem.
     const naBase = !naArvore && ['main', 'origin/main'].some((ref) => (0, branch_de_estado_1.git)(raiz, ['ls-tree', '--name-only', ref, '--', 'docs/roadmap/']).stdout.split('\n').some(doItem));
     if (!naArvore && !naBase)
-        throw new Error(`roadmap.item: ${id} nao existe em docs/roadmap`);
+        throw new locale_1.ErroDoCatalogo((m) => m.thread.roadmapItemInexistente(id));
     return id;
 }
 /** Quem esta pegando: `--por`, senao o `user.name` do git, senao o usuario do sistema. */
@@ -458,8 +461,22 @@ function soltarReservasOrfas(raiz, opcoes = {}) {
         }
     });
 }
+function leituraDasReservas(p, temRemoto) {
+    if (!temRemoto)
+        return 'sem-remoto';
+    return p.atualizado ? 'lido-agora' : p.ponta ? 'copia-local' : 'sem-copia';
+}
 /** O texto de `ork roadmap reservas` para o terminal, no fuso do dono. */
-function textoDasReservas(p, orfas = []) {
+function textoDasReservas(p, orfas = [], lida = {}) {
+    const remoto = lida.remoto ?? exports.REMOTO_PADRAO;
+    const leitura = leituraDasReservas(p, lida.temRemoto !== false);
+    if (leitura === 'sem-remoto') {
+        const projeto = lida.projeto ? `o projeto ${lida.projeto}` : 'o projeto';
+        return `Reservas do roadmap: ${projeto} não tem o remoto ${remoto}; nada foi lido de ${exports.BRANCH_DE_RESERVAS}.`;
+    }
+    if (leitura === 'sem-copia') {
+        return `Reservas do roadmap: o remoto ${remoto} não respondeu e esta máquina não tem cópia de ${exports.BRANCH_DE_RESERVAS}; nada foi lido.`;
+    }
     const linhas = [];
     if (!p.atualizado)
         linhas.push('AVISO: sem acesso ao remoto; esta e a ultima copia lida nesta maquina.', '');

package/dist/roadmap-status.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TETO_DO_FECHO = exports.GRUPO_DO_CICLO = exports.GRUPOS_DO_ROADMAP = exports.CONTRATO_STATUS_DO_ROADMAP = void 0;
 exports.esperaDoDono = esperaDoDono;
+exports.esperaVoce = esperaVoce;
 exports.fatosLocais = fatosLocais;
 exports.batidaDaFabrica = batidaDaFabrica;
 exports.montarStatusDoRoadmap = montarStatusDoRoadmap;
@@ -26,6 +27,11 @@ exports.textoDoStatusDoRoadmap = textoDoStatusDoRoadmap;
  * RM-054: o montador recebe FATOS de thread (`FatoDeThread`), nao so as threads deste disco. O
  * relatorio local continua com os fatos locais; o panorama da rede soma os retratos das outras
  * maquinas, e so ai o fecho diz entre parenteses em que maquina a thread anda.
+ *
+ * RM-063 (F2): o fecho so diz "sigo <thread> na fase <F>" com sessao viva verificada no runtime
+ * (`vida-da-thread.ts`) ou com o processo do condutor conduzindo agora; sessao fantasma, despacho falho ou
+ * nenhuma sessao viram "<thread> parada desde HH:MM: <motivo>". E "O que precisa de voce" le a MESMA fila do `ork pulse` (`precisaDeHumanoAgora`),
+ * que o CLI e o MCP passam: com item do dono na fila, o fecho nunca diz "Nada agora".
  */
 const docs_1 = require("./docs");
 const ledger_1 = require("./ledger");
@@ -42,6 +48,10 @@ const manifest_1 = require("./manifest");
 const maquina_1 = require("./maquina");
 const parado_no_condutor_1 = require("./parado-no-condutor");
 const util_1 = require("./util");
+const impedimento_1 = require("./impedimento");
+const ocupacao_1 = require("./ocupacao");
+const locale_1 = require("./locale");
+const vida_da_thread_1 = require("./vida-da-thread");
 exports.CONTRATO_STATUS_DO_ROADMAP = 'ork.roadmap-status/v1';
 /** Os grupos, na ordem e com os icones que o dono aprovou. */
 exports.GRUPOS_DO_ROADMAP = Object.freeze([
@@ -117,13 +127,31 @@ function esperaDoDono(raiz, t, quando) {
     }
     return undefined;
 }
+/**
+ * R3 (RM-049): a thread espera o dono, pela regra de `esperaDoDono` ou pela do monitor e do pulse
+ * (`ehEsperaDoDono`): a escalada `human.pending` ou o impedimento do despacho que so o dono resolve,
+ * ainda sem evento que destrave. O fim de turno sem pergunta continua do condutor. Leitura pura.
+ */
+function esperaVoce(raiz, t, quando) {
+    if (t.status === 'fechada')
+        return false;
+    if (esperaDoDono(raiz, t, quando))
+        return true;
+    const eventos = (0, ledger_1.lerLedger)((0, thread_1.dirThread)(raiz, t.id));
+    const doCondutor = (0, parado_no_condutor_1.esperaDoCondutor)(t, eventos, quando) !== null;
+    return eventos.some((e, i) => (0, impedimento_1.ehEsperaDoDono)(e) && !(doCondutor && e.motivo === 'human.pending') &&
+        !eventos.slice(i + 1).some(p => ocupacao_1.EVENTOS_QUE_DESTRAVAM.includes(p.tipo) || (0, ocupacao_1.ehAprovacaoHumana)(p)));
+}
 /**
  * Os fatos das threads deste disco: `ship_done` do dia e espera do dono lidos do ledger local.
  * `fuso`: o do projeto consultado, na visao da rede; sem ele, o do dono deste processo.
  */
-function fatosLocais(raiz, quando, fuso) {
+function fatosLocais(raiz, quando, fuso, opcoes = {}) {
     const hoje = (0, horario_1.dataLocal)(quando, fuso);
     const fatos = [];
+    // RM-063 (F2): o runtime e consultado uma vez por relatorio, e so quando alguma thread tem sessao a conferir.
+    let leitura;
+    const lerUmaVez = () => (leitura ??= (opcoes.runtime ?? (() => (0, vida_da_thread_1.lerRuntime)(raiz)))());
     // RM-037 (fatia 4): o estado das entregas sai uma vez, sob demanda, do git local e do retrato de PRs do pulse.
     let entregas;
     const lerEntregas = () => {
@@ -160,7 +188,19 @@ function fatosLocais(raiz, quando, fuso) {
             id: t.id, roadmap: t.roadmap ?? null, aberta: t.status !== 'fechada', fase: t.faseAtual,
             entregueHoje: () => (0, ledger_1.lerLedger)((0, thread_1.dirThread)(raiz, t.id)).some(e => e.tipo === 'ship_done' && (0, horario_1.dataLocal)(e.ts, fuso) === hoje),
             espera: () => esperaDoDono(raiz, t, quando),
+            esperaVoce: () => esperaVoce(raiz, t, quando),
             entrega: () => (t.status === 'fechada' ? undefined : entrega(t.id)),
+            vida: () => {
+                if (t.status === 'fechada')
+                    return undefined;
+                try {
+                    return (0, vida_da_thread_1.vidaDaThread)(t, (0, ledger_1.lerLedger)((0, thread_1.dirThread)(raiz, t.id)), lerUmaVez, Date.parse(quando));
+                }
+                catch (e) {
+                    const causa = { tipo: 'naoLida', detalhe: e.message.slice(0, 80) };
+                    return { viva: false, sessionId: null, desdeEm: null, motivo: (0, vida_da_thread_1.motivoDaCausa)(causa), causa };
+                }
+            },
         });
     }
     return fatos;
@@ -169,7 +209,8 @@ function fatosLocais(raiz, quando, fuso) {
 function entregaNoStatus(e) {
     if (!e || (!e.resumo && !e.parado))
         return undefined;
-    return { estado: e.resumo, ...(e.conduzidaAgora ? { conduzida: true } : {}),
+    // RM-063 (F2): o lease de sessao nao prova trabalho (a K7 morta seguia com ele); quem diz e a vida da sessao no runtime.
+    return { estado: e.resumo, ...(e.conduzidaAgora && e.donoDaConducao !== 'sessao' ? { conduzida: true } : {}),
         ...(e.parado ? { parado: { desdeEm: e.parado.desdeEm, proximoPasso: e.parado.proximoPasso,
                 ...(e.parado.prLidoEm ? { prLidoEm: e.parado.prLidoEm } : {}) } } : {}),
         ...(e.prLidoEm ? { prLidoEm: e.prLidoEm } : {}) };
@@ -185,7 +226,7 @@ function batidaDaFabrica(carregado, quando) {
     // a 2.45 ignora o GIT_NO_LAZY_FETCH, entao o clone parcial nem e lido aqui (N4 da seguranca, rodada 2).
     // N4 da seguranca (rodada 3): o git novo registra o clone parcial no `remote.<r>.promisor`, o velho no `extensions`.
     if ((0, util_1.exec)('git', ['config', '--get-regexp', '^(extensions\\.partialclone|remote\\..+\\.promisor)$'], carregado.raiz).stdout.trim()) {
-        return { lido: false, motivo: `clone parcial: a cópia local de ${fabrica_estado_1.BRANCH_DA_FABRICA} não é lida sem rede`, semBatida: [] };
+        return { lido: false, motivo: (0, locale_1.textoDoCatalogo)((m) => m.roadmap.fabricaClone(fabrica_estado_1.BRANCH_DA_FABRICA)), semBatida: [] };
     }
     const antes = process.env.GIT_NO_LAZY_FETCH;
     process.env.GIT_NO_LAZY_FETCH = '1';
@@ -194,7 +235,7 @@ function batidaDaFabrica(carregado, quando) {
         painel = (0, fabrica_estado_1.lerFabrica)(carregado.raiz, { remoto: carregado.manifesto.fabrica.remoto, semRemoto: true });
     }
     catch {
-        return { lido: false, motivo: `a cópia local de ${fabrica_estado_1.BRANCH_DA_FABRICA} está ilegível`, semBatida: [] };
+        return { lido: false, motivo: (0, locale_1.textoDoCatalogo)((m) => m.roadmap.fabricaIlegivel(fabrica_estado_1.BRANCH_DA_FABRICA)), semBatida: [] };
     }
     finally {
         if (antes === undefined)
@@ -237,8 +278,17 @@ function montarStatusDoRoadmap(raiz, opcoes = {}) {
     catch {
         hitlDeConducao = undefined;
     }
-    return montarStatusDeFatos((0, docs_1.carregarDocs)(raiz).docs, fatosLocais(raiz, quando), { quando, projeto: opcoes.projeto, consulta: opcoes.consulta,
-        ...(fabrica ? { fabrica } : {}), ...(hitlDeConducao ? { hitlDeConducao } : {}) });
+    let fila;
+    if (opcoes.fila) {
+        try {
+            fila = opcoes.fila(quando);
+        }
+        catch (e) {
+            fila = { lida: false, detalhe: e.message.slice(0, 160), itens: [] };
+        }
+    }
+    return montarStatusDeFatos((0, docs_1.carregarDocs)(raiz).docs, fatosLocais(raiz, quando, undefined, { runtime: opcoes.runtime }), { quando, projeto: opcoes.projeto, consulta: opcoes.consulta,
+        ...(fabrica ? { fabrica } : {}), ...(hitlDeConducao ? { hitlDeConducao } : {}), ...(fila ? { fila } : {}) });
 }
 /** O relatorio a partir das paginas do roadmap e dos fatos das threads, de onde quer que venham. */
 function montarStatusDeFatos(docs, fatos, opcoes) {
@@ -264,8 +314,11 @@ function montarStatusDeFatos(docs, fatos, opcoes) {
         }
         // RM-037 (fatia 4): a thread que diz o estado real vem primeiro: a parada no condutor, depois a entrega em curso.
         const entregas = new Map(abertas.map(f => [f.id, f.entrega?.()]));
-        const conduz = abertas.find(f => entregas.get(f.id)?.parado) ?? abertas.find(f => entregas.get(f.id)?.estado) ?? abertas[0];
+        // RM-063 (F2): sem parada nem entrega a dizer, a thread com sessao viva vem antes das paradas.
+        const conduz = abertas.find(f => entregas.get(f.id)?.parado) ?? abertas.find(f => entregas.get(f.id)?.estado) ??
+            abertas.find(f => f.vida?.()?.viva) ?? abertas[0];
         const entrega = conduz ? entregas.get(conduz.id) : undefined;
+        const vida = conduz?.vida?.();
         const emAberto = exports.GRUPO_DO_CICLO[ciclo] === 'disponiveis' ? [
             ...(texto(estado.exposicao) && texto(estado.exposicao) !== 'Geral' ? [`exposição ${texto(estado.exposicao)}`] : []),
             ...(texto(estado.habilitacao) && texto(estado.habilitacao) !== 'Concluída' ? [`habilitação ${texto(estado.habilitacao)}`] : []),
@@ -275,19 +328,36 @@ function montarStatusDeFatos(docs, fatos, opcoes) {
             grupo: entregueHoje ? 'hoje' : exports.GRUPO_DO_CICLO[ciclo] ?? 'proposto',
             emAberto, threads: ligadas,
             ...(conduz ? { conduzindo: { thread: conduz.id, fase: conduz.fase, ...(conduz.maquina ? { maquina: conduz.maquina } : {}),
-                    ...(entrega ? { entrega } : {}) } } : {}),
+                    ...(entrega ? { entrega } : {}), ...(vida ? { vida } : {}) } } : {}),
             ...(hitl ? { hitl } : {}),
         });
     }
     const grupos = exports.GRUPOS_DO_ROADMAP.map(g => ({ ...g, itens: itens.filter(i => i.grupo === g.id) }));
+    // R3 (RM-049): a thread aberta que nao conduz item nenhum e espera o dono. O relatorio continua por item;
+    // isto so evita que "O que precisa de voce" negue o que o pulse mostra.
+    const doRoadmap = new Set(itens.flatMap(i => i.threads));
+    const fora = fatos.filter(f => f.aberta && !doRoadmap.has(f.id) && (f.esperaVoce ? f.esperaVoce() : !!f.espera()))
+        .map(f => f.id).sort();
+    const precisaDeVoce = itens.filter(i => i.hitl).map(i => ({ item: i.id, espera: i.hitl }));
+    // RM-063 (F2): a fila do pulse entra no fecho com o que ele ainda nao dizia; a thread que espera o dono sai do "sigo".
+    const ditas = new Set([...precisaDeVoce.map(x => x.espera.thread), ...fora]);
+    const itemDaThread = new Map(itens.flatMap(i => i.threads.map(t => [t, i.id])));
+    const daFila = (opcoes.fila?.itens ?? []).filter(x => !(x.thread && ditas.has(x.thread)))
+        .map(x => (x.thread && itemDaThread.has(x.thread) ? { ...x, item: itemDaThread.get(x.thread) } : x));
+    const esperamODono = new Set(daFila.map(x => x.thread).filter((t) => !!t));
+    const fila = opcoes.fila;
     return {
         contrato: exports.CONTRATO_STATUS_DO_ROADMAP, consultadoEm: quando,
         projeto: opcoes.projeto ?? 'projeto', grupos,
-        precisaDeVoce: itens.filter(i => i.hitl).map(i => ({ item: i.id, espera: i.hitl })),
-        emSeguida: itens.filter(i => i.conduzindo && !i.hitl).map(i => ({ item: i.id, ...i.conduzindo })),
+        precisaDeVoce,
+        emSeguida: itens.filter(i => i.conduzindo && !i.hitl && !esperamODono.has(i.conduzindo.thread))
+            .map(i => ({ item: i.id, ...i.conduzindo })),
         ...(opcoes.consulta ? { consulta: opcoes.consulta } : {}),
         ...(opcoes.fabrica ? { fabrica: opcoes.fabrica } : {}),
         ...(opcoes.hitlDeConducao ? { hitlDeConducao: opcoes.hitlDeConducao } : {}),
+        ...(fora.length ? { foraDoRoadmap: { threads: fora } } : {}),
+        ...(fila && (!fila.lida || daFila.length) ? { filaDoDono: { lida: fila.lida,
+                ...(!fila.lida && fila.detalhe ? { detalhe: fila.detalhe } : {}), itens: daFila } } : {}),
     };
 }
 /** "orkastery" vira "Orkastery": o titulo diz o nome do projeto como gente escreve. */
@@ -299,35 +369,52 @@ const naMaquina = (maquina) => maquina ? ` (${maquina})` : '';
  * proximo passo; entrega em curso, com o estado do PR e a hora em que ele foi lido; sem nada disso, a fase.
  */
 function linhaDoQueVem(x, agora, fuso) {
+    const m = (0, locale_1.msg)().roadmap;
     const e = x.entrega;
     if (e?.parado) {
         const { prLidoEm: lido } = e.parado;
         return `• ${x.item}: ${(0, hitl_resumo_1.linhaDoParadoNoCondutor)({ thread: x.thread, ...e.parado }, { agora, fuso })}${naMaquina(x.maquina)}` +
-            `${lido ? ` (PR lido às ${(0, horario_1.formatarHora)(lido, { agora, fuso })})` : ''}.`;
-    }
-    if (e?.estado) {
-        const { prLidoEm: lido } = e;
-        const daLeitura = lido ? ` (PR lido às ${(0, horario_1.formatarHora)(lido, { agora, fuso })})` : '';
-        return e.conduzida ? `• ${x.item}: sigo ${x.thread} na fase ${x.fase}${naMaquina(x.maquina)}; ${e.estado}${daLeitura}.`
-            : `• ${x.item}: ${x.thread} na fase ${x.fase}${naMaquina(x.maquina)}, ${e.estado}${daLeitura}.`;
+            `${lido ? m.prLido((0, horario_1.formatarHora)(lido, { agora, fuso })) : ''}.`;
     }
-    return `• ${x.item}: sigo ${x.thread} na fase ${x.fase}${naMaquina(x.maquina)}.`;
+    const daLeitura = e?.estado && e.prLidoEm ? m.prLido((0, horario_1.formatarHora)(e.prLidoEm, { agora, fuso })) : '';
+    const maquina = naMaquina(x.maquina);
+    const linha = (sigo) => e?.estado
+        ? (sigo ? m.sigoComEstado(x.item, x.thread, x.fase, maquina, e.estado, daLeitura) : m.comEstado(x.item, x.thread, x.fase, maquina, e.estado, daLeitura))
+        : (sigo ? m.sigo(x.item, x.thread, x.fase, maquina) : m.semSessaoVerificada(x.item, x.thread, x.fase, maquina));
+    const v = x.vida;
+    // Sem `vida` (status montado sem ela), a linha de antes: "sigo" sem entrega, ou com o processo do condutor.
+    if (!v)
+        return linha(!e?.estado || !!e.conduzida);
+    // RM-063 (F2): "sigo" so com a sessao viva verificada no runtime ou com o processo do condutor conduzindo agora; sem
+    // isso, a parada com o desde e o motivo; sem motivo (retrato que nao publica a sessao), nada foi verificado.
+    if (v.viva || e?.conduzida)
+        return linha(true);
+    if (!v.motivo)
+        return linha(false);
+    return m.parada(x.item, x.thread, maquina, v.desdeEm && Number.isFinite(Date.parse(v.desdeEm)) ? (0, horario_1.formatarHora)(v.desdeEm, { agora, fuso }) : null, v.causa ? (0, vida_da_thread_1.motivoDaCausa)(v.causa, m.motivoDaParada) : v.motivo, e?.estado ? `${e.estado}${daLeitura}` : null);
+}
+/** RM-063 (F2): um item da fila do pulse no fecho, numa linha: quem, a pergunta e o que responder. */
+function linhaDaFila(x) {
+    const m = (0, locale_1.msg)().roadmap;
+    const quem = x.item ? `${x.item} (${x.thread}${x.fase ? `, ${x.fase}` : ''})`
+        : x.thread ? `${x.thread}${x.fase ? ` (${x.fase})` : ''}` : m.sessaoSemThread((x.sessionId ?? '?').slice(0, 8));
+    const pergunta = x.pergunta.trim();
+    return `• ${quem}: ${pergunta}${/[.?!…]$/u.test(pergunta) ? '' : '.'}${x.comando ? m.responder(x.comando) : ''}`;
 }
 /** RM-037 (fatia 4, D8): uma linha so para a fabrica, e so quando ha o que avisar. */
 function linhaDaFabrica(f, agora, fuso) {
     if (!f)
         return [];
+    const m = (0, locale_1.msg)().roadmap;
     if (!f.lido)
-        return [`Fábrica: não lido (${f.motivo ?? `esta máquina não tem cópia local de ${fabrica_estado_1.BRANCH_DA_FABRICA}`}).`];
+        return [m.fabricaNaoLida(f.motivo !== undefined ? (0, locale_1.remontar)(f.motivo) : m.fabricaSemCopia(fabrica_estado_1.BRANCH_DA_FABRICA))];
     if (f.copiaVelha) {
         const { ultimoDestaMaquina: ultimo } = f.copiaVelha;
-        return [`Fábrica: a cópia local de ${fabrica_estado_1.BRANCH_DA_FABRICA} está velha (${ultimo ? `esta máquina publicou nela por último em ` +
-                `${(0, horario_1.formatarDataHora)(ultimo, { agora, fuso })}` : 'esta máquina não aparece nela'}); não dá para dizer quem está sem batida.`];
+        return [m.fabricaVelha(fabrica_estado_1.BRANCH_DA_FABRICA, ultimo ? (0, horario_1.formatarDataHora)(ultimo, { agora, fuso }) : null)];
     }
     if (!f.semBatida.length)
         return [];
-    return [`Fábrica: ${f.semBatida.map(m => `${m.maquina} sem batida há ${(0, horario_1.duracaoCurta)(m.idadeMin)} ` +
-            `(último retrato ${(0, horario_1.formatarDataHora)(m.publicadoEm, { agora, fuso })})`).join('; ')}, pela cópia local de ${fabrica_estado_1.BRANCH_DA_FABRICA}.`];
+    return [m.fabricaSemBatida(f.semBatida.map(x => m.semBatida(x.maquina, (0, horario_1.duracaoCurta)(x.idadeMin), (0, horario_1.formatarDataHora)(x.publicadoEm, { agora, fuso }))).join('; '), fabrica_estado_1.BRANCH_DA_FABRICA)];
 }
 /**
  * O texto do relatorio, igual em todo canal: os icones sao parte do formato aprovado. `fuso`: o do
@@ -346,23 +433,32 @@ function textoDoStatusDoRoadmap(s, fuso, opcoes = {}) {
             ? ` (${i.conduzindo.fase}${i.conduzindo.maquina ? `, ${i.conduzindo.maquina}` : ''})` : '';
         return `• ${i.id} ${i.titulo}${detalhe}${i.hitl ? ' #HITL' : ''}`;
     };
-    const cortar = (lista, f) => [...lista.slice(0, exports.TETO_DO_FECHO).map(f), ...(lista.length > exports.TETO_DO_FECHO ? [`• e mais ${lista.length - exports.TETO_DO_FECHO}`] : [])];
+    const m = (0, locale_1.msg)().roadmap;
+    const cortar = (lista, f) => [...lista.slice(0, exports.TETO_DO_FECHO).map(f), ...(lista.length > exports.TETO_DO_FECHO ? [m.eMais(lista.length - exports.TETO_DO_FECHO)] : [])];
     return [
-        `Roadmap do ${capitalizar(s.projeto)} (${p.dia}/${p.mes}, ${p.hora}:${p.minuto})`,
+        m.titulo(capitalizar(s.projeto), p),
         ...(opcoes.legenda === false ? [] : [(0, horario_1.legendaDoFuso)(fuso, s.consultadoEm)]),
         // RM-052: logo abaixo do titulo aprovado (e do fuso), qual projeto foi lido e o que nao foi.
         ...(s.consulta ? (0, projeto_alvo_1.linhasDaConsulta)(s.consulta) : []),
         ...linhaDaFabrica(s.fabrica, s.consultadoEm, fuso),
-        ...s.grupos.filter(g => g.itens.length).flatMap(g => ['', `${g.icone} ${g.titulo}`, ...g.itens.map(linhaDoItem)]),
-        '', 'O que precisa de você',
-        ...(s.precisaDeVoce.length ? cortar(s.precisaDeVoce, x => `• ${x.item}${naMaquina(x.espera.maquina)}: ${x.espera.pergunta}` +
-            (x.espera.codigo ? ` Responda ${x.espera.codigo} ${x.espera.recomendada ?? 'a'} (ou outra letra).` : ' A pergunta chega no próximo resumo.'))
-            : ['• Nada agora.']),
+        // RM-061 (F2b, D4): o titulo do grupo e dado do contrato; a impressao o traduz pelo id.
+        ...s.grupos.filter(g => g.itens.length).flatMap(g => ['', `${g.icone} ${(0, locale_1.localeAtivo)() === 'pt-BR' ? g.titulo : m.grupos[g.id] ?? g.titulo}`,
+            ...g.itens.map(linhaDoItem)]),
+        '', m.precisaDeVoce,
+        ...cortar(s.precisaDeVoce, x => `• ${x.item}${naMaquina(x.espera.maquina)}: ${x.espera.pergunta}` +
+            (x.espera.codigo ? m.responda(x.espera.codigo, x.espera.recomendada ?? 'a') : m.chegaNoResumo)),
+        // RM-063 (F2): a fila do pulse, com o que ainda nao foi dito; a que nao foi lida inteira e dita, nunca "Nada agora".
+        ...cortar(s.filaDoDono?.itens ?? [], linhaDaFila),
+        ...(s.filaDoDono && !s.filaDoDono.lida ? [m.filaNaoLida(s.filaDoDono.detalhe ?? null)] : []),
+        // R3 (RM-049): so quando ha; o detalhe de cada thread esta no `ork pulse`.
+        ...(s.foraDoRoadmap?.threads.length ? [m.foraDoRoadmap(s.foraDoRoadmap.threads.length)] : []),
+        // RM-063 (F2): "Nada agora" so quando nada do dono foi dito acima (substitui a alternativa a da R3).
+        ...(!s.precisaDeVoce.length && !s.filaDoDono && !s.foraDoRoadmap?.threads.length ? [m.nadaAgora] : []),
         // RM-057 (fatia 3): ha quanto tempo cada pergunta de conducao parou a thread, e a mediana da semana.
-        ...(s.hitlDeConducao ? [`• HITL de condução: ${s.hitlDeConducao.abertas.length} aberta(s); ${(0, hitl_tempo_parado_1.textoDaMediana)(s.hitlDeConducao)}.`,
+        ...(s.hitlDeConducao ? [m.hitlDeConducao(s.hitlDeConducao.abertas.length, (0, hitl_tempo_parado_1.textoDaMediana)(s.hitlDeConducao)),
             ...cortar(s.hitlDeConducao.abertas, a => `  ${(0, hitl_tempo_parado_1.linhaDaPerguntaParada)(a, { agora: s.consultadoEm, fuso })}.`)] : []),
-        '', 'O que eu faço em seguida',
+        '', m.emSeguida,
         ...(s.emSeguida.length ? cortar(s.emSeguida, x => linhaDoQueVem(x, s.consultadoEm, fuso))
-            : ['• Nada em andamento; sigo o que você priorizar.']),
+            : [m.nadaEmAndamento]),
     ].join('\n');
 }

package/dist/runtime-context.js

@@ -36,6 +36,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.novaIdentidadeDeDespacho = novaIdentidadeDeDespacho;
 exports.contextoDoProjeto = contextoDoProjeto;
 exports.validarContextoRuntime = validarContextoRuntime;
+exports.lerDeclaracaoDeMod = lerDeclaracaoDeMod;
+exports.modsDeFaseInstalados = modsDeFaseInstalados;
 /** Contexto interno opt-in: configuracao M4 existente + catalogo instalado, nunca args do modelo. */
 const fs = __importStar(require("node:fs"));
 const path = __importStar(require("node:path"));
@@ -193,27 +195,203 @@ function validarContextoRuntime(contexto, cwd) {
     if (recibo.contrato !== 'ork.adapter-install/v1' || recibo.host !== contexto.host || !Array.isArray(recibo.arquivos) || recibo.arquivos.length > 512)
         throw Error('runtime.context.installation: recibo instalado invalido');
     const arquivos = new Map();
+    // RM-059 (T0.7): os bytes ja conferidos da declaracao e do manifesto de cada mod, lidos uma vez so.
+    const conferidos = new Map();
     for (const item of recibo.arquivos) {
         const a = objeto(item);
         if (typeof a.arquivo !== 'string' || path.isAbsolute(a.arquivo) || a.arquivo.split(/[\\/]/).includes('..') ||
             typeof a.sha256 !== 'string' || !/^[a-f0-9]{64}$/.test(a.sha256) || arquivos.has(a.arquivo))
             throw Error('runtime.context.installation: arquivo do recibo invalido');
         const file = path.join(instalacao, a.arquivo);
-        if (!dentro(raiz, file).startsWith(instalacao + path.sep) || (0, node_crypto_1.createHash)('sha256').update(ler(raiz, file, 1048576)).digest('hex') !== a.sha256)
+        if (!dentro(raiz, file).startsWith(instalacao + path.sep))
+            throw Error('runtime.context.installation: bytes instalados divergentes');
+        const bytes = ler(raiz, file, 1048576);
+        if ((0, node_crypto_1.createHash)('sha256').update(bytes).digest('hex') !== a.sha256)
             throw Error('runtime.context.installation: bytes instalados divergentes');
         arquivos.set(a.arquivo, file);
+        if (DECLARACAO_OU_MANIFESTO_DE_MOD.test(a.arquivo))
+            conferidos.set(a.arquivo, bytes);
     }
     const bootstrap = arquivos.get('skills/core/orkastery-bootstrap/SKILL.md');
     if (!bootstrap || (contexto.host === 'claude-code' && !arquivos.has('.claude-plugin/plugin.json')))
         throw Error('runtime.context.installation: catalogo ou plugin incompleto');
+    const modsDeFase = contexto.host === 'claude-code' ? modsDeFaseInstalados(raiz, instalacao, arquivos, conferidos) : [];
     // Capacidade derivada do bloco atual, nunca aceita como entrada do modelo.
     const permiteEditarProduto = permissoesFilho === 'worktree' && (0, thread_1.blocoDaThread)(thread, thread.faseAtual).fases.includes('GO');
     // RM-031 KG5 (D2, D7): as tools do grafo seguem a flag do manifesto da raiz, que o servidor do filho tambem le;
     // o manifesto da worktree da thread e o pedido do modelo nao ligam nada.
-    const grafoMcp = (0, mcp_grafo_1.grafoLigado)((0, manifest_1.exigirManifesto)(raiz).manifesto);
+    const manifestoDaRaiz = (0, manifest_1.exigirManifesto)(raiz).manifesto;
+    const grafoMcp = (0, mcp_grafo_1.grafoLigado)(manifestoDaRaiz);
+    // RM-059 (T10.4, D11 da thread ork-rm059portao): os tetos do piloto de agent teams so vao ao despacho do Claude Code
+    // quando o bloco da fase atual tem o GO, a mesma regra da edicao de produto; o manifesto da raiz decide, nunca o
+    // pedido do modelo. Quem liga de fato e o `montarComando`, e so com o Portao de Tarefas na sessao.
+    const tetos = contexto.host === 'claude-code' ? manifestoDaRaiz.runtime.agent_teams : undefined;
+    const agentTeams = tetos && (0, thread_1.blocoDaThread)(thread, thread.faseAtual).fases.includes('GO') ? { ...tetos } : null;
     const publicVerifiers = (0, hitl_public_receipt_1.publicHitlVerifiers)();
     const servidor = { ...(0, mcp_install_1.configuracaoServidorMcp)(raiz, contexto.host, contexto.threadId, transporteShip, permissoesFilho, contexto.identidade?.dispatchId),
         ...(publicVerifiers ? { env: { [hitl_public_receipt_1.ENV_HITL_VERIFIERS]: publicVerifiers } } : {}),
         ...(contexto.host === 'codex' && permissoesFilho === 'worktree' ? (0, mcp_install_1.politicasFilhoCodex)(perfil.politicasCodex ?? {}) : {}) };
-    return { projeto: raiz, instalacao, bootstrap, permissoesFilho, permiteEditarProduto, grafoMcp, servidor };
+    return { projeto: raiz, instalacao, bootstrap, permissoesFilho, permiteEditarProduto, grafoMcp, servidor, modsDeFase, agentTeams };
+}
+const DECLARACAO_OU_MANIFESTO_DE_MOD = /^mods\/[^/]+\/(?:orkastery-mod\.json|\.claude-plugin\/plugin\.json)$/;
+const DECLARACAO_DE_MOD = /^mods\/([^/]+)\/orkastery-mod\.json$/;
+const NOME_DE_MOD = /^[a-z0-9](?:[a-z0-9-]{0,62}[a-z0-9])?$/;
+/** A declaracao de papel de um mod; o erro diz o que esta fora da convencao. */
+function lerDeclaracaoDeMod(texto) {
+    let bruto;
+    try {
+        bruto = JSON.parse(texto);
+    }
+    catch {
+        throw Error('orkastery-mod.json nao e JSON');
+    }
+    if (!bruto || typeof bruto !== 'object' || Array.isArray(bruto))
+        throw Error('orkastery-mod.json precisa ser objeto');
+    const d = bruto;
+    if (d.formato !== 'ork.mod/v1')
+        throw Error('orkastery-mod.json com formato diferente de ork.mod/v1');
+    const papeis = d.papeis;
+    if (!Array.isArray(papeis) || papeis.length === 0 || papeis.some((p) => p !== 'dono' && p !== 'fase') ||
+        new Set(papeis).size !== papeis.length)
+        throw Error('orkastery-mod.json com papeis fora de dono e fase, vazios ou repetidos');
+    if (typeof d.claudeCodeMinimo !== 'string' || !/^\d+\.\d+\.\d+$/.test(d.claudeCodeMinimo))
+        throw Error('orkastery-mod.json com claudeCodeMinimo fora do formato X.Y.Z');
+    return { formato: 'ork.mod/v1', papeis: papeis, claudeCodeMinimo: d.claudeCodeMinimo };
+}
+/**
+ * RM-059 (T0.7, D3): os nomes que o `dependencies` do `plugin.json` de um mod cita, em melhor esforco:
+ * lista de nomes (com ou sem `@marketplace`), objeto com os nomes nas chaves, ou lista de objetos com `name`.
+ */
+function dependenciasDoManifesto(texto) {
+    let manifesto;
+    try {
+        manifesto = JSON.parse(texto);
+    }
+    catch {
+        throw Error('.claude-plugin/plugin.json nao e JSON');
+    }
+    if (!manifesto || typeof manifesto !== 'object' || Array.isArray(manifesto))
+        throw Error('.claude-plugin/plugin.json precisa ser objeto');
+    const deps = manifesto.dependencies;
+    const itens = Array.isArray(deps) ? deps : deps && typeof deps === 'object' ? Object.keys(deps) : [];
+    return itens.flatMap((item) => {
+        const nome = typeof item === 'string' ? item : item && typeof item === 'object' ? item.name : undefined;
+        return typeof nome === 'string' && nome ? [nome.split('@')[0]] : [];
+    });
+}
+/** Os tipos que o proprio Claude Code escreve na pasta do mod que ele carrega: declaracoes, nunca codigo. */
+function tipoDoMotor(relativo) {
+    return relativo.startsWith('.claude-plugin/types/') && (relativo.endsWith('.d.ts') || path.posix.basename(relativo) === 'tsconfig.json');
+}
+/**
+ * RM-059 (T0.7, D1): a pasta instalada de um mod de fase tem exatamente os arquivos do recibo. O
+ * `--plugin-dir` carrega o que estiver nela (comandos, agentes e skills sao descobertos), entao arquivo
+ * fora do recibo entraria na sessao de fase sem prova. Link e arquivo especial recusam sempre.
+ */
+function conferirPastaDoMod(raiz, instalacao, nome, arquivos) {
+    const dir = path.join(instalacao, 'mods', nome);
+    const recusa = (motivo, correcao = 'reinstale com ork adapter install claude-code') => Error(`runtime.context.installation: mod ${nome}: ${motivo}; ${correcao}`);
+    if (!fs.lstatSync(dir, { throwIfNoEntry: false })?.isDirectory() || dentro(raiz, dir) !== dir)
+        throw recusa('pasta instalada ausente ou fora da instalacao');
+    const visitar = (atual, prefixo) => {
+        for (const entrada of fs.readdirSync(atual, { withFileTypes: true })) {
+            const relativo = prefixo ? `${prefixo}/${entrada.name}` : entrada.name;
+            if (entrada.isSymbolicLink())
+                throw recusa(`link em ${relativo}`);
+            if (entrada.isDirectory()) {
+                visitar(path.join(atual, entrada.name), relativo);
+                continue;
+            }
+            if (!entrada.isFile())
+                throw recusa(`arquivo especial em ${relativo}`);
+            if (!arquivos.has(`mods/${nome}/${relativo}`) && !tipoDoMotor(relativo)) {
+                throw recusa(`arquivo fora do INSTALADO.json (${relativo})`, 'se ele saiu do catalogo, ork adapter install claude-code o tira da copia; ' +
+                    `se foi editado ou acrescentado a mao, apague ${path.join(dir, relativo)}`);
+            }
+        }
+    };
+    visitar(dir, '');
+    return dir;
+}
+/**
+ * RM-059 (rodada 2 do CHECK, N2): o arquivo comum da raiz de `mods/` tambem so vale com prova. A ponte le a lista
+ * de autoridade em `../autoridade.json` antes da propria pasta, entao uma copia velha ou escrita a mao ali mudaria o
+ * que a sessao de fase aceita. Com mod de fase no despacho, todo arquivo direto em `mods/` esta no recibo (que ja
+ * conferiu os bytes); link e arquivo especial recusam. Pastas sao os mods, conferidos um a um.
+ */
+function conferirRaizDosMods(raiz, instalacao, arquivos) {
+    const dir = path.join(instalacao, 'mods');
+    const recusa = (motivo, correcao = 'reinstale com ork adapter install claude-code') => Error(`runtime.context.installation: mods/: ${motivo}; ${correcao}`);
+    if (!fs.lstatSync(dir, { throwIfNoEntry: false })?.isDirectory() || dentro(raiz, dir) !== dir)
+        throw recusa('pasta instalada ausente ou fora da instalacao');
+    for (const entrada of fs.readdirSync(dir, { withFileTypes: true })) {
+        if (entrada.isSymbolicLink())
+            throw recusa(`link em ${entrada.name}`);
+        if (entrada.isDirectory())
+            continue;
+        if (!entrada.isFile())
+            throw recusa(`arquivo especial em ${entrada.name}`);
+        if (!arquivos.has(`mods/${entrada.name}`)) {
+            throw recusa(`arquivo fora do INSTALADO.json (${entrada.name})`, 'se ele saiu do catalogo, ork adapter install claude-code o tira da copia; ' +
+                `se foi editado ou acrescentado a mao, apague ${path.join(dir, entrada.name)}`);
+        }
+    }
+}
+/**
+ * RM-059 (T0.7): os mods de papel `fase` da instalacao, lidos do recibo ja conferido e na ordem da D3:
+ * a dependencia antes de quem depende, depois o nome. Declaracao ou manifesto invalidos recusam como
+ * um byte divergente (D2): e instalacao corrompida, e o CI do catalogo ja reprova esse caso.
+ */
+function modsDeFaseInstalados(raiz, instalacao, arquivos, conferidos) {
+    const achados = [];
+    const nomes = [...arquivos.keys()].flatMap((arquivo) => DECLARACAO_DE_MOD.exec(arquivo)?.[1] ?? []).sort();
+    const daInstalacao = new Set(nomes);
+    for (const nome of nomes) {
+        const arquivo = `mods/${nome}/orkastery-mod.json`;
+        const recusa = (motivo) => Error(`runtime.context.installation: mod ${nome}: ${motivo}; reinstale com ork adapter install claude-code`);
+        if (!NOME_DE_MOD.test(nome))
+            throw recusa('nome fora de letras minusculas, digitos e hifen');
+        let declaracao;
+        try {
+            declaracao = lerDeclaracaoDeMod(conferidos.get(arquivo).toString('utf8'));
+        }
+        catch (e) {
+            throw recusa(e.message);
+        }
+        if (!declaracao.papeis.includes('fase'))
+            continue;
+        const manifesto = conferidos.get(`mods/${nome}/.claude-plugin/plugin.json`);
+        if (!manifesto)
+            throw recusa('.claude-plugin/plugin.json fora do recibo');
+        let dependencias;
+        try {
+            dependencias = dependenciasDoManifesto(manifesto.toString('utf8')).filter((d) => daInstalacao.has(d) && d !== nome);
+        }
+        catch (e) {
+            throw recusa(e.message);
+        }
+        achados.push({ nome, dir: conferirPastaDoMod(raiz, instalacao, nome, arquivos), claudeCodeMinimo: declaracao.claudeCodeMinimo, dependencias });
+    }
+    if (achados.length)
+        conferirRaizDosMods(raiz, instalacao, arquivos);
+    const porNome = new Map(achados.map((m) => [m.nome, m]));
+    const ordem = [];
+    const feitos = new Set(), abertos = new Set();
+    // Busca em profundidade: a dependencia sai antes; num ciclo, a aresta de volta e ignorada (melhor esforco).
+    const visitar = (m) => {
+        if (feitos.has(m.nome) || abertos.has(m.nome))
+            return;
+        abertos.add(m.nome);
+        for (const dep of [...m.dependencias].sort()) {
+            const alvo = porNome.get(dep);
+            if (alvo)
+                visitar(alvo);
+        }
+        abertos.delete(m.nome);
+        feitos.add(m.nome);
+        ordem.push(m);
+    };
+    for (const m of achados)
+        visitar(m);
+    return ordem;
 }

package/dist/runtimes.js

@@ -55,6 +55,7 @@ exports.resolverRuntime = resolverRuntime;
 const claudeBg = __importStar(require("./adapters/claude-bg"));
 const codex = __importStar(require("./adapters/codex"));
 const hitl_ingress_receipt_1 = require("./hitl-ingress-receipt");
+const locale_1 = require("./locale");
 exports.RUNTIME_PADRAO = 'claude-bg';
 /** Phase e retry atravessam o mesmo preparo, antes de retirar segredos do filho. */
 function comRecibosPublicos(p, dispatch) {
@@ -97,7 +98,7 @@ function runtimeConhecido(nome) {
 function resolverRuntime(nome) {
     const adapter = exports.RUNTIMES[nome];
     if (!adapter) {
-        throw new Error(`runtime de despacho desconhecido: "${nome}" (homologados: ${exports.ORDEM_DOS_RUNTIMES.join(', ')})`);
+        throw new locale_1.ErroDoCatalogo((m) => m.phase.runtimeDesconhecido(nome, exports.ORDEM_DOS_RUNTIMES.join(', ')));
     }
     return adapter;
 }

package/dist/session-events.js

@@ -63,10 +63,12 @@ function exigirSessaoDespachada(sessao, sessionId) {
     }
     return sessao;
 }
-function resolverSessao(raiz, sessionId) {
+function resolverSessao(raiz, sessionId, threadId) {
     if (!/^[a-zA-Z0-9][a-zA-Z0-9_-]{0,127}$/.test(sessionId))
         throw new Error('sessionId inválido');
-    const achadas = (0, thread_1.listarIds)(raiz).flatMap(id => {
+    // Um watcher já vinculado não depende da leitura de threads alheias a cada poll.
+    // O vínculo explícito continua exigindo uma única sessão e o estado canônico.
+    const achadas = (threadId === undefined ? (0, thread_1.listarIds)(raiz) : [threadId]).flatMap(id => {
         const thread = (0, thread_1.lerThread)(raiz, id);
         return thread.sessoes.filter(s => s.sessionId === sessionId).map(sessao => ({ thread, sessao }));
     });
@@ -75,8 +77,10 @@ function resolverSessao(raiz, sessionId) {
     const achada = achadas[0];
     if (achada.thread.worktree) {
         const estado = (0, estado_thread_1.auditarEstado)(raiz, achada.thread.id, achada.thread.worktree);
+        // comEstadoParaGit materializa o estado local durante commit/rebase. Não leia essa
+        // cópia: o watcher pode repetir a auditoria, com seu orçamento finito de falhas.
         if (estado.nivel !== 'ok')
-            throw new Error(estado.detalhe);
+            throw Object.assign(new Error(estado.detalhe), { code: 'SESSION_STATE_SPLIT' });
     }
     return achada;
 }