@orkastery/cli 0.4.3 → 0.5.0

package/dist/hitl-texto-livre.js

@@ -0,0 +1,150 @@
+"use strict";
+/**
+ * RM-048 (item 2, D2 e D3): a resposta em linguagem natural, quando ela e inequivoca.
+ *
+ * Em 27/09 o dono respondeu "1. I-31. Aprovar, 2. D2 ..." e nada foi ao ledger: o ingresso so
+ * conhecia "P4EJ a" e "1a 2c", e a prosa caiu no assistente. A decisao do dono (28/09) foi: a
+ * resposta em linguagem natural registra quando for inequivoca ("aprovo", "sim", "pode seguir",
+ * "a", "1", "1. B, 2. A"); ambigua, volta como pergunta com as opcoes reais, nunca como veredito
+ * chutado; com mais de um pedido aberto na mesma thread, texto livre nao registra.
+ *
+ * "Inequivoca" nao e julgamento de ninguem. E esta regra, fechada e pura:
+ *
+ *   1. o texto tem a forma de uma resposta: letra a-d, digito 1-4, ou uma palavra do VOCABULARIO
+ *      (que e uma lista, e nao um classificador), sozinha ou numerada ("1. B, 2. aprovo");
+ *   2. a palavra casa com UMA alternativa, pela acao dela ("aprovo" casa `aprovar`; "nao" num gate
+ *      casa `recusar` e `esperar`, entao e ambigua e volta como pergunta);
+ *   3. a palavra sem numero e sem codigo so vale para a pergunta que acabou de sair, sozinha, e
+ *      nunca para ato irreversivel (`JANELA_DO_TEXTO_LIVRE_MIN`).
+ *
+ * Este modulo nao autentica nada e nao registra nada. A prova continua sendo a do ingresso
+ * (`autenticarResposta`, no endereco do pulse), conferida ANTES de qualquer leitura de conteudo.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FORMAS_DO_TEXTO_LIVRE = exports.TETO_DA_FORMA = exports.JANELA_DO_TEXTO_LIVRE_MIN = exports.ACOES_DA_INTENCAO = exports.VOCABULARIO_LIVRE = void 0;
+exports.normalizarLivre = normalizarLivre;
+exports.lerTrecho = lerTrecho;
+exports.lerLista = lerLista;
+exports.lerSolta = lerSolta;
+exports.resolverTrecho = resolverTrecho;
+exports.consentimentoDoTrecho = consentimentoDoTrecho;
+/**
+ * O vocabulario fechado, ja normalizado (minusculas, sem acento). Palavra fora daqui nao e
+ * resposta: vai ao assistente, como sempre foi. Acrescentar uma palavra e decisao de contrato,
+ * com teste, e nunca efeito colateral de alguem achar que "entendeu" o dono.
+ */
+exports.VOCABULARIO_LIVRE = Object.freeze({
+    afirmar: ['sim', 's', 'ok', 'pode', 'pode seguir', 'pode ir', 'segue', 'siga', 'seguir', 'manda', 'aprovo', 'aprovado',
+        'aprovada', 'aprovar', 'aprova', 'confirmo', 'confirmado', 'de acordo'],
+    negar: ['nao', 'n'],
+    revisar: ['recuso', 'recusado', 'recusar', 'reprovo', 'reprovado', 'revisar', 'revisao', 'refazer', 'volta', 'voltar'],
+    esperar: ['esperar', 'espera', 'aguardar', 'aguarda', 'aguarde', 'depois', 'mais tarde', 'agora nao'],
+    detalhe: ['detalhe', 'detalhes', 'evidencia', 'evidencias'],
+});
+/** Que acoes de alternativa cada intencao casa. `negar` casa duas de proposito: e ambigua num gate. */
+exports.ACOES_DA_INTENCAO = Object.freeze({
+    afirmar: ['aprovar', 'responder'],
+    negar: ['recusar', 'esperar'],
+    revisar: ['recusar'],
+    esperar: ['esperar'],
+});
+/**
+ * D3: a palavra solta (sem numero e sem codigo) so vale ate esta quantidade de minutos depois de
+ * a pergunta sair. Numero e codigo nao tem janela: a linha que o dono recebeu vale enquanto o gate
+ * esperar a mesma pergunta.
+ */
+exports.JANELA_DO_TEXTO_LIVRE_MIN = 60;
+/**
+ * As palavras em fonte de expressao regular, com as variantes de acento. E daqui que saem as
+ * formas `lista` e `livre` de `GRAMATICA_DO_PULSE`, que os adaptadores copiam texto a texto.
+ */
+const PALAVRAS_DA_FORMA = 'pode seguir|pode ir|pode|sim|s|ok|aprovo|aprovado|aprovada|aprovar|aprova|segue|siga|seguir|manda|' +
+    'confirmo|confirmado|de acordo|agora n[aã]o|n[aã]o|n|recuso|recusado|recusar|reprovo|reprovado|revisar|revis[aã]o|refazer|' +
+    'volta|voltar|esperar|espera|aguardar|aguarda|aguarde|depois|mais tarde|detalhes?|evid[eê]ncias?';
+/** Uma resposta: letra, ou palavra do vocabulario. */
+const RESPOSTA_DA_FORMA = `(?:[a-d]|${PALAVRAS_DA_FORMA})`;
+/**
+ * Um item numerado: "1a", "1 a", "1. B", "1) aprovo", "1 - nao", "1: detalhes".
+ *
+ * Sem dois quantificadores de espaco lado a lado: o adaptador testa a forma ANTES de conferir a
+ * allowlist, e forma com backtracking caro seria uma porta de negacao de servico para quem nao e
+ * o dono. Os adaptadores tambem recusam, antes da regex, texto acima de `TETO_DA_FORMA`.
+ */
+const ITEM_DA_FORMA = `[0-9]{1,2}(?:[ \\t]*[.):-])?[ \\t]*${RESPOSTA_DA_FORMA}`;
+/** Maior texto que o ingresso testa contra as formas do pulse. */
+exports.TETO_DA_FORMA = 300;
+/** As fontes das duas formas novas do ingresso. Ambas sao lidas sem diferenca de caixa. */
+exports.FORMAS_DO_TEXTO_LIVRE = Object.freeze({
+    /** Resposta numerada, uma ou varias, separadas por virgula, ponto e virgula, espaco ou linha. */
+    lista: `^[ \\t]*${ITEM_DA_FORMA}(?:[ \\t\\r\\n,;]*${ITEM_DA_FORMA})*[ \\t]*(?:[.!][ \\t]*)?$`,
+    /** Resposta solta: letra, digito ou palavra, sozinha na mensagem. */
+    livre: `^[ \\t]*(?:[1-4]|${RESPOSTA_DA_FORMA})[ \\t]*(?:[.!]+[ \\t]*)?$`,
+});
+/** Minusculas, sem acento, espaco unico, sem pontuacao final. */
+function normalizarLivre(texto) {
+    return texto.normalize('NFD').replace(/[̀-ͯ]/g, '').toLowerCase().replace(/\s+/g, ' ').trim().replace(/[.!]+$/, '').trim();
+}
+/** O que um pedaco de resposta quer dizer, ou `null` quando ele nao e resposta. */
+function lerTrecho(bruto) {
+    const t = normalizarLivre(bruto);
+    if (/^[a-d]$/.test(t))
+        return { tipo: 'letra', letra: t };
+    if (/^[1-4]$/.test(t))
+        return { tipo: 'digito', numero: Number(t) };
+    for (const [intencao, palavras] of Object.entries(exports.VOCABULARIO_LIVRE)) {
+        if (palavras.includes(t))
+            return { tipo: 'intencao', intencao, palavra: t };
+    }
+    return null;
+}
+/** Os itens de uma resposta numerada, na ordem em que o dono escreveu. */
+function lerLista(texto) {
+    if (texto.length > exports.TETO_DA_FORMA || !new RegExp(exports.FORMAS_DO_TEXTO_LIVRE.lista, 'i').test(texto))
+        return null;
+    const itens = [];
+    const item = new RegExp(`([0-9]{1,2})(?:[ \\t]*[.):-])?[ \\t]*(${RESPOSTA_DA_FORMA})(?=[ \\t\\r\\n,;]*(?:[0-9]|[.!]?[ \\t]*$))`, 'gi');
+    for (const m of texto.matchAll(item)) {
+        const trecho = lerTrecho(m[2]);
+        if (!trecho)
+            return null;
+        itens.push({ numero: Number(m[1]), trecho });
+    }
+    return itens.length ? itens : null;
+}
+/** A resposta solta, ou `null` quando o texto nao tem a forma de uma. */
+function lerSolta(texto) {
+    return texto.length <= exports.TETO_DA_FORMA && new RegExp(exports.FORMAS_DO_TEXTO_LIVRE.livre, 'i').test(texto) ? lerTrecho(texto) : null;
+}
+/**
+ * Qual alternativa o trecho escolhe, pelas acoes das alternativas (na ordem do pedido). Letra e
+ * digito escolhem pela posicao; palavra, pela acao, e so quando exatamente uma casa.
+ */
+function resolverTrecho(trecho, acoes, letras) {
+    if (trecho.tipo === 'letra') {
+        const i = letras.indexOf(trecho.letra);
+        return i >= 0 ? { tipo: 'escolha', indice: i } : { tipo: 'nenhuma' };
+    }
+    if (trecho.tipo === 'digito')
+        return trecho.numero <= acoes.length ? { tipo: 'escolha', indice: trecho.numero - 1 } : { tipo: 'nenhuma' };
+    const intencao = trecho.intencao;
+    if (intencao === 'detalhe')
+        return { tipo: 'detalhe' };
+    const casam = acoes.map((a, i) => exports.ACOES_DA_INTENCAO[intencao].includes(a) ? i : -1).filter(i => i >= 0);
+    if (casam.length === 1)
+        return { tipo: 'escolha', indice: casam[0] };
+    return casam.length ? { tipo: 'ambigua', indices: casam } : { tipo: 'nenhuma' };
+}
+/** O que o dono respondeu ao resumo ("posso mandar as perguntas?"), pela mesma regra. */
+function consentimentoDoTrecho(trecho) {
+    if (!trecho)
+        return undefined;
+    if (trecho.tipo === 'letra')
+        return trecho.letra === 'a' ? 'sim' : trecho.letra === 'b' ? 'nao' : undefined;
+    if (trecho.tipo === 'digito')
+        return trecho.numero === 1 ? 'sim' : trecho.numero === 2 ? 'nao' : undefined;
+    if (trecho.intencao === 'afirmar')
+        return 'sim';
+    if (trecho.intencao === 'negar' || trecho.intencao === 'esperar')
+        return 'nao';
+    return undefined;
+}

package/dist/hosts.js

@@ -59,6 +59,7 @@ exports.lerRecibo = lerRecibo;
 exports.classificarDivergencia = classificarDivergencia;
 exports.renderizarArquivo = renderizarArquivo;
 exports.instalarAdaptador = instalarAdaptador;
+exports.desinstalarExperiencia = desinstalarExperiencia;
 exports.tabelaDeHosts = tabelaDeHosts;
 exports.textoDosPitfalls = textoDosPitfalls;
 exports.textoDaInstalacao = textoDaInstalacao;
@@ -78,6 +79,9 @@ const path = __importStar(require("node:path"));
 const catalogo_1 = require("./catalogo");
 const util_1 = require("./util");
 const versao_1 = require("./versao");
+const manifest_1 = require("./manifest");
+const experiencia_1 = require("./experiencia");
+const experiencia_instalacao_1 = require("./experiencia-instalacao");
 exports.HOSTS = {
     'claude-code': {
         host: 'claude-code',
@@ -122,7 +126,7 @@ exports.HOSTS = {
             },
             {
                 titulo: 'skill confundida com autorizacao de runtime',
-                detalhe: 'instalar instrucoes nao habilita permissoes, hooks ou sandbox nem altera AGENTS.md; gates e preflight continuam no nucleo, e descoberta nao prova a jornada conversacional',
+                detalhe: 'instalar instrucoes nao habilita permissoes, hooks ou sandbox; em projeto configurado, AGENTS.md recebe apenas o bloco reversível da experiência. Gates e preflight continuam no nucleo, e descoberta nao prova a jornada conversacional',
                 prova: 'ork doctor',
             },
         ],
@@ -282,6 +286,64 @@ function instalarAdaptador(host, opcoes = {}) {
             fontes.push({ origem: ref, relativo: path.posix.join('references', path.basename(ref)) });
         }
     }
+    if (host === 'hermes') {
+        for (const skill of (0, catalogo_1.skillsDoCatalogo)(catalogo).filter(s => ['orchestration-experience', 'orchestration-experience-pt-br'].includes(s.nome))) {
+            fontes.push({ origem: skill.caminho, relativo: path.posix.join('skills', skill.nome, 'SKILL.md') });
+        }
+    }
+    // A experiência é opcional: manifesto com erro, bloco alheio ou caminho inadequado pulam só a
+    // ativação, com aviso, e o adaptador segue instalado como antes da RM-051.
+    const segue = 'O restante da instalação do adaptador segue normalmente.';
+    const carregado = (0, manifest_1.carregarManifesto)(projeto);
+    let avisoExperiencia;
+    if (carregado?.raiz === projeto && carregado.erros.length) {
+        avisoExperiencia = `Pacote de experiência pulado: o manifesto tem erros (${carregado.erros[0]}). ${segue}`;
+    }
+    // Preferência inválida (ex.: experience: "false") não ativa nem remove nada: quem escreveu pode ter
+    // tentado desligar o pacote. Corrigir com ork onboarding set maestro volta a instalar.
+    const invalida = carregado?.raiz === projeto ? carregado.avisos.find(a => a.startsWith('experiencia.config.invalid')) : undefined;
+    if (!avisoExperiencia && invalida)
+        avisoExperiencia = `Pacote de experiência pulado: ${invalida}. ${segue}`;
+    const preferencias = carregado?.raiz === projeto && !avisoExperiencia ? (0, experiencia_1.resolverExperiencia)(carregado.manifesto.owner) : null;
+    const hostComBloco = host === 'codex' || host === 'claude-code';
+    // O bloco aponta o diretório relativo ao projeto: CLAUDE.md e AGENTS.md costumam ir ao repositório.
+    const diretorioExperiencia = path.relative(caminhoReal(projeto), caminhoReal(path.join(destino, 'skills', 'core')))
+        .split(path.sep).join('/');
+    if (preferencias?.experience && host !== 'openclaw') {
+        const skillRelativa = host === 'hermes' ? `skills/${preferencias.skill}/SKILL.md`
+            : `skills/core/${preferencias.skill}/SKILL.md`;
+        if (!fontes.some(f => f.relativo === skillRelativa)) {
+            avisoExperiencia = `Pacote de experiência pulado: a skill ${preferencias.skill} não está no catálogo. ${segue}`;
+        }
+        else if (hostComBloco && (diretorioExperiencia.startsWith('../') || path.isAbsolute(diretorioExperiencia))) {
+            avisoExperiencia = `Pacote de experiência pulado: o adaptador fica fora do projeto e o bloco de instruções só aponta caminhos do projeto. ${segue}`;
+        }
+        else if (hostComBloco && /[\r\n`]/.test(diretorioExperiencia)) {
+            avisoExperiencia = `Pacote de experiência pulado: o caminho das skills contém quebra de linha ou crase, incompatível com o bloco de instruções. ${segue}`;
+        }
+    }
+    let planoExperiencia = null;
+    if (preferencias && hostComBloco && !avisoExperiencia) {
+        try {
+            planoExperiencia = (0, experiencia_instalacao_1.planejarExperiencia)(projeto, host, preferencias.experience ? diretorioExperiencia : null);
+        }
+        catch (e) {
+            const motivo = e.message;
+            if (!/^experiencia\.(bloco\.conflict|path\.unsafe)/.test(motivo))
+                throw e;
+            avisoExperiencia = `Pacote de experiência pulado: ${motivo.startsWith('experiencia.path') ? 'o arquivo de instruções é link ou não é arquivo comum' : `o bloco de instruções ou o recibo .orkastery/experiencia/${host}.json foi editado ou está duplicado`}; nada foi escrito. Revise os dois à mão. ${segue}`;
+        }
+    }
+    // O preflight cobre o destino e os arquivos do próprio adaptador antes de copiar o primeiro. Links
+    // acima do destino (.agents/skills compartilhado, diretório do usuário) são escolha de quem instala.
+    for (const alvo of [...fontes.map(f => path.join(destino, f.relativo)), path.join(destino, 'INSTALADO.json')]) {
+        for (let atual = alvo; atual !== path.dirname(destino) && atual !== path.dirname(atual); atual = path.dirname(atual)) {
+            const stat = fs.lstatSync(atual, { throwIfNoEntry: false });
+            if (stat && (stat.isSymbolicLink() || (atual === alvo ? !stat.isFile() || stat.nlink !== 1 : !stat.isDirectory()))) {
+                throw Error('experiencia.path.unsafe: destino do adaptador');
+            }
+        }
+    }
     // I-43 (D5): o recibo e lido UMA vez, antes de classificar, e e ele que transforma
     // "divergente" em um dos quatro motivos.
     const recibo = lerRecibo(destino);
@@ -363,6 +425,9 @@ function instalarAdaptador(host, opcoes = {}) {
         ok: !barrado,
         orkBin,
         pitfalls: def.pitfalls,
+        ...(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 } : {}) } } : {}),
     };
     if (opcoes.dryRun === true || barrado)
         return resultado;
@@ -398,8 +463,24 @@ function instalarAdaptador(host, opcoes = {}) {
             bytes: a.bytes,
         })),
     }, null, 2) + '\n', 'utf8');
+    if (planoExperiencia)
+        (0, experiencia_instalacao_1.aplicarExperiencia)(planoExperiencia);
     return resultado;
 }
+/** 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);
+    while (!fs.existsSync(existente) && existente !== path.dirname(existente))
+        existente = path.dirname(existente);
+    return path.join(fs.realpathSync(existente), path.relative(existente, path.resolve(alvo)));
+}
+/** Remove somente o bloco do pacote; o adaptador e as demais instruções permanecem. */
+function desinstalarExperiencia(projeto, host, dryRun = false) {
+    const plano = (0, experiencia_instalacao_1.planejarExperiencia)(projeto, host, null);
+    if (!dryRun)
+        (0, experiencia_instalacao_1.aplicarExperiencia)(plano);
+    return { host, dryRun, arquivos: plano.mudancas.map(m => path.relative(plano.projeto, m.arquivo)) };
+}
 /** Texto de `ork adapter list`. */
 function tabelaDeHosts() {
     const linhas = ['Adaptadores de host (Camada 1, o podio)', ''];
@@ -429,6 +510,10 @@ function textoDosPitfalls(host) {
 /** Texto de `ork adapter install`. */
 function textoDaInstalacao(r) {
     const linhas = [];
+    if (r.experiencia)
+        linhas.push(`Experiência: ${r.experiencia.ativa ? 'ativação preparada' : 'desativada ou sem integração de skills'}${r.experiencia.skill ? ` (${r.experiencia.skill})` : ''}.`);
+    if (r.experiencia?.aviso)
+        linhas.push(`Aviso: ${r.experiencia.aviso}`);
     linhas.push(r.dryRun
         ? `Simulacao (--dry-run) da instalacao do adaptador ${r.host}: nada foi escrito.`
         : r.ok