@orkastery/cli 0.5.1 → 0.5.6

package/dist/impedimento.js

@@ -0,0 +1,299 @@
+"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, `'\\''`)}'`;
+}
+/**
+ * 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,
+    /not inside a trusted directory/i,
+    /(?:folder|directory|workspace) (?:is )?not trusted/i,
+];
+const FRASES_DE_CONSENTIMENTO = [
+    // 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);
+}
+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 ?? '';
+    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));
+    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(c => c.regra.test(texto));
+    if (consentimento) {
+        const trecho = trechoDa(texto, consentimento.regra);
+        return {
+            motivo: 'runtime.consent-pending',
+            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`).
+ * `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')
+        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;
+    }
+    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 (dir === raiz || 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 } });
+}