@orkastery/cli 0.5.0 → 0.5.3

package/dist/hosts.js

@@ -57,6 +57,7 @@ exports.ORDEM_DOS_HOSTS = exports.HOSTS = exports.MAESTRO_HOST_SURFACES = export
 exports.parseHost = parseHost;
 exports.lerRecibo = lerRecibo;
 exports.classificarDivergencia = classificarDivergencia;
+exports.avisoDoOrkNoPath = avisoDoOrkNoPath;
 exports.renderizarArquivo = renderizarArquivo;
 exports.instalarAdaptador = instalarAdaptador;
 exports.desinstalarExperiencia = desinstalarExperiencia;
@@ -64,6 +65,7 @@ exports.tabelaDeHosts = tabelaDeHosts;
 exports.textoDosPitfalls = textoDosPitfalls;
 exports.textoDaInstalacao = textoDaInstalacao;
 const node_crypto_1 = require("node:crypto");
+const node_child_process_1 = require("node:child_process");
 const fs = __importStar(require("node:fs"));
 exports.BRAIN_HOST_SURFACES = {
     hermes: 'cli', openclaw: 'cli', 'claude-code': 'mcp', codex: 'mcp',
@@ -92,8 +94,8 @@ exports.HOSTS = {
         pitfalls: [
             {
                 titulo: 'manifesto sem os caminhos das skills instala limpo e nao expoe nada',
-                detalhe: 'o plugin auto-descobre skills/<nome>/SKILL.md e para ai: ele nao desce nos buckets (core/, phases/, reviewers/, ...) que este catalogo usa, entao o plugin.json declara os 17 caminhos um a um',
-                prova: 'claude plugin details orkastery   # a contagem precisa bater com os SKILL.md em disco',
+                detalhe: 'o plugin auto-descobre skills/<nome>/SKILL.md e para ai: ele nao desce nos buckets (core/, phases/, reviewers/, ...) que este catalogo usa, entao o plugin.json declara cada caminho de skill, um a um',
+                prova: 'claude plugin details orkastery   # Skills (N) soma as skills do plugin.json e os comandos de commands/',
             },
             {
                 titulo: 'duas copias do catalogo divergem',
@@ -246,6 +248,31 @@ function listarArquivos(dir, prefixo = '') {
     }
     return achados;
 }
+function mesmoArquivo(a, b) {
+    try {
+        return fs.realpathSync(a) === fs.realpathSync(b);
+    }
+    catch {
+        return path.resolve(a) === path.resolve(b);
+    }
+}
+/**
+ * Ensaio de 03/10: com outro `ork` primeiro no PATH, a extensão segue apontando para o binário que roda o
+ * install, e o aviso diz as duas versões para ninguém descobrir a diferença pela extensão chamando o velho.
+ */
+function avisoDoOrkNoPath(emExecucao, versao, env = process.env) {
+    const doPath = (0, util_1.noPath)('ork', env);
+    if (!doPath || mesmoArquivo(doPath, emExecucao))
+        return undefined;
+    let outra = 'versão desconhecida';
+    try {
+        const saida = (0, node_child_process_1.execFileSync)(doPath, ['--version'], { encoding: 'utf8', timeout: 5000, stdio: ['ignore', 'pipe', 'ignore'], env });
+        outra = saida.trim().split('\n')[0]?.trim() || outra;
+    }
+    catch { /* o aviso sai mesmo sem a versão */ }
+    return `o ork do PATH (${doPath}, ${outra}) não é o que roda este install (${emExecucao}, ${versao}). ` +
+        `A extensão chama ${emExecucao}; para outro binário, passe --ork <caminho>.`;
+}
 /** Substitui os tres placeholders. Nao ha template engine aqui de proposito. */
 function renderizarArquivo(conteudo, valores) {
     return conteudo
@@ -267,8 +294,10 @@ function instalarAdaptador(host, opcoes = {}) {
         ? path.resolve(projeto, opcoes.dir)
         : path.join(projeto, def.destinoPadrao);
     const destino = def.subdir ? path.join(base, def.subdir) : base;
-    const orkBin = opcoes.orkBin ?? (0, util_1.noPath)('ork') ?? (0, catalogo_1.cliDoCatalogo)(catalogo);
+    const orkBin = opcoes.orkBin ?? opcoes.orkEmExecucao ?? (0, util_1.noPath)('ork') ?? (0, catalogo_1.cliDoCatalogo)(catalogo);
     const versao = opcoes.versao ?? versao_1.VERSAO_DO_ORK;
+    const avisoOrk = opcoes.orkBin === undefined && opcoes.orkEmExecucao
+        ? avisoDoOrkNoPath(opcoes.orkEmExecucao, versao) : undefined;
     const dirDoHost = path.join(catalogo, 'adapters', host);
     if (!fs.existsSync(dirDoHost)) {
         throw new Error(`adaptador do host ${host} nao existe em ${dirDoHost}`);
@@ -424,6 +453,7 @@ function instalarAdaptador(host, opcoes = {}) {
         ...(reciboVizinho ? { reciboVizinho } : {}),
         ok: !barrado,
         orkBin,
+        ...(avisoOrk ? { avisoOrk } : {}),
         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 ?? '',
@@ -510,8 +540,12 @@ function textoDosPitfalls(host) {
 /** Texto de `ork adapter install`. */
 function textoDaInstalacao(r) {
     const linhas = [];
+    // Ensaio da 0.5.0: com o pacote ativo e pulado por aviso (catalogo fora do projeto), a linha dizia
+    // "desativada"; o aviso logo abaixo diz o motivo.
     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})` : ''}.`);
+        linhas.push(`Experiência: ${r.experiencia.ativa ? 'ativação preparada'
+            : r.experiencia.aviso ? 'pacote pulado nesta instalação, veja o aviso abaixo' : '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
@@ -519,28 +553,35 @@ function textoDaInstalacao(r) {
         : r.ok
             ? `Arquivos do adaptador ${r.host} preparados.`
             : `Instalacao do adaptador ${r.host} BARRADA: ha arquivo diferente no destino.`);
+    // Ensaio de 03/10 (R6): a ativacao sai no comeco e de novo no fim, depois da lista de arquivos e dos
+    // pitfalls, para que o fim da saida diga o proximo passo.
+    const ativacao = [];
     if (r.ok && !r.dryRun && r.host === 'claude-code') {
         const destino = "'" + r.destino.replace(/'/g, "'\"'\"'") + "'";
         linhas.push('Uso no Claude Code ainda nao verificado por esta copia.');
         linhas.push('No diretorio deste projeto, valide e ative o plugin:');
-        linhas.push(`  claude plugin validate ${destino}`);
-        linhas.push(`  claude plugin marketplace add ${destino} --scope project`);
-        linhas.push('  claude plugin install orkastery@orkastery --scope project');
-        linhas.push('  claude plugin list --json');
-        linhas.push('Depois, na sessao deste projeto: /orkastery:ork');
+        ativacao.push(`  claude plugin validate ${destino}`);
+        ativacao.push(`  claude plugin marketplace add ${destino} --scope project`);
+        ativacao.push('  claude plugin install orkastery@orkastery --scope project');
+        ativacao.push('  claude plugin list --json');
+        ativacao.push('Depois, na sessao deste projeto: /orkastery:ork');
     }
     else if (r.ok && !r.dryRun && r.host === 'codex') {
-        linhas.push('Abra o Codex neste projeto e use $ork.');
-        linhas.push('Descoberta e uso nativo ainda nao verificados por esta copia.');
+        ativacao.push('Abra o Codex neste projeto e use $ork.');
+        ativacao.push('Descoberta e uso nativo ainda nao verificados por esta copia.');
     }
     if (r.ok && !r.dryRun && (r.host === 'codex' || r.host === 'claude-code')) {
         const projeto = "'" + r.projeto.replace(/'/g, "'\"'\"'") + "'";
-        linhas.push(`Prepare tambem as ferramentas do projeto: ork mcp install --project ${projeto} --host ${r.host}`);
-        linhas.push('A configuracao MCP exige descoberta e consentimento no cliente; a copia nao concede aprovacoes.');
+        ativacao.push(`Prepare tambem as ferramentas do projeto: ork mcp install --project ${projeto} --host ${r.host}`);
     }
+    linhas.push(...ativacao);
+    if (ativacao.length)
+        linhas.push('A configuracao MCP exige descoberta e consentimento no cliente; a copia nao concede aprovacoes.');
     linhas.push(`  catalogo: ${r.catalogo}`);
     linhas.push(`  destino:  ${r.destino}`);
     linhas.push(`  ork:      ${r.orkBin}`);
+    if (r.avisoOrk)
+        linhas.push(`  Aviso: ${r.avisoOrk}`);
     linhas.push('');
     const novos = r.arquivos.filter((a) => a.estado === 'novo').length;
     const iguais = r.arquivos.filter((a) => a.estado === 'igual').length;
@@ -588,5 +629,10 @@ function textoDaInstalacao(r) {
     }
     linhas.push('');
     linhas.push(textoDosPitfalls(r.host));
+    if (ativacao.length) {
+        linhas.push('');
+        linhas.push(r.host === 'claude-code' ? 'Proximo passo, no diretorio deste projeto (o mesmo do comeco):' : 'Proximo passo (o mesmo do comeco):');
+        linhas.push(...ativacao);
+    }
     return linhas.join('\n');
 }

package/dist/impedimento.js

@@ -0,0 +1,205 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MOTIVOS_DE_IMPEDIMENTO_DO_DONO = void 0;
+exports.ehImpedimentoDoDono = ehImpedimentoDoDono;
+exports.ehEsperaDoDono = ehEsperaDoDono;
+exports.classificarImpedimento = classificarImpedimento;
+exports.impedimentoResolvido = impedimentoResolvido;
+exports.correcaoDoImpedimento = correcaoDoImpedimento;
+exports.registrarImpedimentoDoDono = registrarImpedimentoDoDono;
+exports.impedimentoDoEvento = impedimentoDoEvento;
+exports.pedidoCurtoDoImpedimento = pedidoCurtoDoImpedimento;
+/**
+ * RM-055: impedimento que so o dono resolve vira HITL.
+ *
+ * Em 29/09/2026 tres despachos `claude --bg` morreram com "Workspace not trusted. Run `claude` in
+ * <worktree> once and accept the trust prompt". O ledger guardou so `phase_dispatch_failed`, as threads
+ * ficaram `aberta` e o board, a fabrica e o pulse disseram "espera voce: -". O dono descobriu horas
+ * depois, perguntando.
+ *
+ * Aqui a saida do runtime vira motivo tipado. O motivo que so o dono resolve (aceitar a confianca do
+ * diretorio, aceitar termos novos do CLI) abre a pausa do dono com o que trava, o comando exato que ele
+ * roda e o que o `ork` faz depois: `ork retry run <thread>` re-despacha a MESMA fase com o MESMO prompt
+ * gravado, sem o dono reescrever o pedido. Login ausente e cota esgotada continuam na rotacao de conta
+ * (I-33): la quem resolve primeiro e o orquestrador, trocando de perfil. Motivo desconhecido continua
+ * generico (`runtime.unavailable`).
+ */
+const fs = __importStar(require("node:fs"));
+const os = __importStar(require("node:os"));
+const path = __importStar(require("node:path"));
+const gates_1 = require("./gates");
+const hitl_curto_1 = require("./hitl-curto");
+exports.MOTIVOS_DE_IMPEDIMENTO_DO_DONO = Object.freeze([
+    'runtime.workspace-untrusted', 'runtime.consent-pending',
+]);
+function ehImpedimentoDoDono(motivo) {
+    return typeof motivo === 'string' && exports.MOTIVOS_DE_IMPEDIMENTO_DO_DONO.includes(motivo);
+}
+/**
+ * Um evento do ledger que espera o dono: a escalada `human.pending` ou o impedimento tipado do despacho.
+ * E a mesma regra para o monitor, a ocupacao de vaga, a fabrica e o pulse.
+ */
+function ehEsperaDoDono(e, tipoGateBloqueado = 'gate_blocked') {
+    return e.tipo === tipoGateBloqueado && (e.motivo === 'human.pending' || ehImpedimentoDoDono(e.motivo));
+}
+/** Aspas de shell so quando o caminho precisa. */
+function citar(caminho) {
+    return /^[A-Za-z0-9_./:@+-]+$/.test(caminho) ? caminho : `'${caminho.replace(/'/g, `'\\''`)}'`;
+}
+const FRASES_DE_CONFIANCA = [
+    /workspace not trusted/i,
+    /accept the trust (?:prompt|dialog)/i,
+    /not inside a trusted directory/i,
+    /(?: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,
+];
+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);
+}
+function binarioDo(runtime) {
+    return runtime === 'codex' ? 'codex' : 'claude';
+}
+/**
+ * Le a saida do runtime (stderr e o erro do adapter) e devolve o impedimento do dono, ou null.
+ * Null quer dizer "nao e do dono": o despacho segue no caminho de antes.
+ */
+function classificarImpedimento(saida, ctx) {
+    const texto = saida ?? '';
+    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));
+    if (confianca) {
+        return {
+            motivo: 'runtime.workspace-untrusted',
+            trava: `o ${bin} não confia no diretório da worktree e recusou o despacho de ${ctx.fase}`,
+            comando: `cd ${citar(ctx.cwd)} && ${bin}`,
+            depois: `aceite a confiança no diretório e saia; ${depois}`,
+            trecho: trechoDa(texto, confianca),
+        };
+    }
+    const consentimento = FRASES_DE_CONSENTIMENTO.find(r => r.test(texto));
+    if (consentimento) {
+        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),
+        };
+    }
+    return null;
+}
+/**
+ * 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.
+ */
+function impedimentoResolvido(motivo, ctx) {
+    if (motivo !== 'runtime.workspace-untrusted' || ctx.runtime !== 'claude-bg')
+        return null;
+    // A conta do processo segue o `CLAUDE_CONFIG_DIR` do ambiente, como o proprio `claude`.
+    const configDir = ctx.configDir ?? (ctx.home ? null : process.env.CLAUDE_CONFIG_DIR) ?? null;
+    const arquivo = configDir ? path.join(configDir, '.claude.json') : path.join(ctx.home ?? os.homedir(), '.claude.json');
+    let projetos;
+    try {
+        const dados = JSON.parse(fs.readFileSync(arquivo, 'utf8'));
+        if (!dados || typeof dados.projects !== 'object' || dados.projects === null)
+            return null;
+        projetos = dados.projects;
+    }
+    catch {
+        return null;
+    }
+    for (let dir = path.resolve(ctx.cwd);; dir = path.dirname(dir)) {
+        if (projetos[dir]?.hasTrustDialogAccepted === true)
+            return true;
+        if (path.dirname(dir) === dir)
+            return false;
+    }
+}
+/** A frase de correcao que vai ao gate e ao monitor: o comando e o que vem depois. */
+function correcaoDoImpedimento(i) {
+    return `rode \`${i.comando}\`; ${i.depois}`;
+}
+/**
+ * RM-055: classifica a saida de um despacho recusado e, quando so o dono resolve, grava o `gate_blocked`
+ * tipado que o monitor, a fabrica, o board e o pulse leem como espera do dono. Devolve null quando o
+ * motivo nao e do dono (o chamador segue no caminho de antes). Tambem usado pelo redespacho do retry.
+ */
+function registrarImpedimentoDoDono(dir, thread, d) {
+    const impedimento = classificarImpedimento(d.saida, { thread: thread.id, fase: d.fase, runtime: d.runtime, cwd: d.cwd });
+    if (!impedimento)
+        return null;
+    (0, gates_1.registrarGateBloqueado)(dir, thread.id, { gate: 'phase.dispatch', motivo: impedimento.motivo, modo: thread.modo,
+        detalhe: impedimento.trava, correcao: correcaoDoImpedimento(impedimento), fase: d.fase, slug: d.slug,
+        runtime: d.runtime, cwd: d.cwd, origem: d.origem, promptPath: d.promptPath, promptSha256: d.promptSha256,
+        impedimento: { motivo: impedimento.motivo, comando: impedimento.comando, depois: impedimento.depois, trecho: impedimento.trecho },
+        ...(d.perfil ? { perfil: d.perfil } : {}), pausaQualquerModo: true,
+        evidencia: 'stderr real do runtime adapter no despacho, nao relato do agente' });
+    return impedimento;
+}
+/** O impedimento gravado no `gate_blocked`, lido de volta com tipos; null quando o evento nao o traz. */
+function impedimentoDoEvento(e) {
+    const i = e.impedimento;
+    if (!i || typeof i.comando !== 'string' || typeof i.depois !== 'string')
+        return null;
+    return { comando: i.comando, depois: i.depois, trecho: typeof i.trecho === 'string' ? i.trecho : '' };
+}
+/**
+ * RM-055 (b): o pedido do impedimento no contrato curto da RM-048 (`ork.hitl-curto/v1`): o que trava,
+ * desde quando, o comando exato que o dono roda e o que o ork faz depois. A recomendada e o re-despacho
+ * do mesmo prompt; as outras dizem o custo de nao fazer nada e de trocar o runtime do bloco.
+ */
+function pedidoCurtoDoImpedimento(d, quando) {
+    const retry = `ork retry run ${d.thread}`;
+    return (0, hitl_curto_1.montarPedidoCurto)({
+        thread: d.thread, fase: d.fase, desde: d.desdeEm,
+        pergunta: `Você roda \`${d.impedimento.comando}\` no terminal para destravar o despacho?`,
+        corpo: [`${d.motivo}: ${d.detalhe}`, `Depois: ${d.impedimento.depois}.`],
+        alternativas: [
+            { chave: 'a', texto: 'Rodei o comando', consequencia: `\`${retry}\` re-despacha ${d.fase ?? 'a fase'} com o mesmo prompt gravado`,
+                recomendada: { porque: 'nada rodou ainda; o pedido volta igual, sem você reescrever nada' } },
+            { chave: 'b', texto: 'Trocar o runtime do bloco', consequencia: 'ork setup <modo> --bloco N --runtime <outro>, e depois o mesmo retry' },
+            { chave: 'c', texto: 'Deixar parada', consequencia: 'nada é despachado; a thread segue esperando você' },
+        ],
+    }, { quando, responder: { tipo: 'terminal', comando: retry } });
+}