@orkastery/cli 0.4.2 → 0.5.0

package/dist/session-watcher-claude.js

@@ -158,6 +158,20 @@ function classificarSessaoClaude(e) {
                 : { terminal: true, classificacao: 'fase_concluida', motivo: null, fonte: `${sinal}; ${prova.fonte}`, conclusaoNativa, stop };
         return { ...c, dependeDoStop: true };
     };
+    // RM-037 (defeitosdeco D-1): turno encerrado pelo Stop e sessão viva em `blocked` é o Claude Code
+    // dizendo que o texto final pediu resposta. Nunca conclui direto, e a pausa humana abre sempre
+    // (`human.pending`): GO-FIX (R6 do CHECK), sem a prova o motivo também é o humano, porque um
+    // `artifact.missing` automático abriria correção sobre uma sessão viva que espera resposta.
+    const esperaHumana = () => {
+        const sinal = 'Stop correlacionado e sessão viva à espera humana (blocked)';
+        const prova = e.prova();
+        const c = !prova.ok
+            ? { ...bloqueio(`${sinal}; sem prova do ork: ${prova.fonte}; o humano decide`, 'human.pending'),
+                diagnostico: `a sessão espera resposta humana (blocked) e a fase ainda não tem a prova do ork: ${prova.fonte}` }
+            : { ...bloqueio(`${sinal}; ${prova.fonte}; o humano decide`, 'human.pending'),
+                diagnostico: 'a fase tem a prova do ork e a sessão espera resposta humana (blocked): o humano decide' };
+        return { ...c, dependeDoStop: true };
+    };
     const venceu = (desde) => agora - desde >= e.limiteMs;
     // Sem prova para concluir nem para bloquear: `runtime.unavailable` reexecutaria o mesmo prompt
     // sobre uma fase que pode ter terminado. O observador encerra sem gate e o radar de liveness
@@ -183,6 +197,8 @@ function classificarSessaoClaude(e) {
         delete cursor.doneDesde;
     if (estado !== 'working' && estado !== 'blocked')
         delete cursor.mortoDesde;
+    if (estado !== 'blocked')
+        delete cursor.bloqueadoDesde;
     if (['done', 'failed', 'stopped', 'working', 'blocked'].includes(estado ?? ''))
         delete cursor.desconhecidoDesde;
     switch (estado) {
@@ -220,6 +236,16 @@ function classificarSessaoClaude(e) {
                 return bloqueio(`processo da sessão morreu sem terminal nativo nem Stop correlacionado (estado ${estado})`);
             }
             delete cursor.mortoDesde;
+            // D-1: a segunda leitura, com pelo menos um intervalo do observador, separa o `blocked` estável
+            // de um instante de transição logo depois do Stop. `status` ocupado ainda é trabalho.
+            const ocupado = ['busy', 'running', 'working'].includes(r.status ?? '');
+            if (estado === 'blocked' && stop && !bloqueioPendente(e.eventos, e.sessao) && !ocupado) {
+                cursor.bloqueadoDesde ??= agora;
+                if (agora - cursor.bloqueadoDesde < exports.INTERVALO_WATCH_CLAUDE_MS)
+                    return espera('turno encerrado pelo Stop com a sessão à espera humana (blocked); aguardando a segunda observação');
+                return esperaHumana();
+            }
+            delete cursor.bloqueadoDesde;
             return espera(estado === 'blocked' ? 'sessão bloqueada à espera humana' : 'sessão trabalhando');
         }
         default:

package/dist/sessoes.js

@@ -46,6 +46,7 @@ exports.pararSessao = pararSessao;
 exports.comandoDeAttach = comandoDeAttach;
 const adapter = __importStar(require("./adapters/claude-bg"));
 const sessoes_inventario_1 = require("./sessoes-inventario");
+const runtime_profiles_1 = require("./runtime-profiles");
 const util_1 = require("./util");
 function textoDoInventario(r) {
     const linhas = [
@@ -63,23 +64,56 @@ function textoDoInventario(r) {
 function tabelaDeSessoes(raiz, todas = false) {
     return textoDoInventario((0, sessoes_inventario_1.inventariarSessoes)(raiz, { todas }));
 }
-/** Logs de uma sessao pelo id curto, id completo ou nome. */
-function logsDaSessao(chave, linhas) {
-    const r = adapter.logs(chave, linhas);
+/**
+ * RM-037 (defeitosdeco D-2): a sessao pelo id curto, id completo ou nome, procurada no ambiente do
+ * processo e em cada perfil claude-bg do projeto (inclusive desativado, que ainda pode ter sessao
+ * viva). So uma conta pode responder; duas viram recusa, nenhuma mantem a mensagem de antes.
+ */
+function localizarSessao(chave, raiz) {
+    let perfis = [];
+    const falhas = [];
+    if (raiz) {
+        try {
+            perfis = (0, runtime_profiles_1.lerPerfis)(raiz).perfis.filter(p => p.runtime === 'claude-bg').map(runtime_profiles_1.perfilDeDespacho);
+        }
+        catch (e) {
+            falhas.push(`perfis: ${e.message}`);
+        }
+    }
+    const r = adapter.acharSessaoNasContas(chave, perfis);
+    falhas.push(...r.falhas);
+    if (r.achadas.length === 1)
+        return { achada: r.achadas[0] };
+    if (r.achadas.length > 1) {
+        const contas = r.achadas.map(a => `${a.perfil?.id ?? 'processo'} (${a.sessao.sessionId})`).join(', ');
+        return { texto: `sessao "${chave}" encontrada em mais de uma conta: ${contas}; use o id completo`, codigo: 1 };
+    }
+    return { texto: `sessao "${chave}" nao encontrada no runtime` + (falhas.length ? `; contas sem resposta: ${falhas.join('; ')}` : ''),
+        codigo: 1 };
+}
+/** Logs de uma sessao pelo id curto, id completo ou nome, lidos na conta onde ela esta. */
+function logsDaSessao(chave, linhas, raiz) {
+    const l = localizarSessao(chave, raiz);
+    if (!('achada' in l))
+        return l;
+    const { sessao, ambiente } = l.achada;
+    const r = adapter.logsDaSessao(sessao.id ?? sessao.sessionId.slice(0, 8), linhas, ambiente);
     return { texto: r.texto, codigo: r.ok ? 0 : 1 };
 }
-/** Para uma sessao pelo id curto, id completo ou nome. */
-function pararSessao(chave) {
-    const s = adapter.acharSessao(chave);
-    if (!s)
-        return { texto: `sessao "${chave}" nao encontrada no runtime`, codigo: 1 };
-    const r = adapter.parar(s.id ?? s.sessionId);
-    return { texto: r.texto || `sessao ${s.sessionId} parada`, codigo: r.ok ? 0 : 1 };
+/** Para uma sessao pelo id curto, id completo ou nome, com o `CLAUDE_CONFIG_DIR` da conta dela. */
+function pararSessao(chave, raiz) {
+    const l = localizarSessao(chave, raiz);
+    if (!('achada' in l))
+        return l;
+    const { sessao, perfil, ambiente } = l.achada;
+    const r = adapter.pararAchada(sessao, ambiente);
+    return { texto: r.texto || `sessao ${sessao.sessionId} parada${perfil ? ` (perfil ${perfil.id})` : ''}`, codigo: r.ok ? 0 : 1 };
 }
 /** Comando de attach (precisa de TTY, entao o CLI imprime em vez de executar). */
-function comandoDeAttach(chave) {
-    const s = adapter.acharSessao(chave);
-    if (!s)
-        return { texto: `sessao "${chave}" nao encontrada no runtime`, codigo: 1 };
-    return { texto: adapter.comandoAttach(s.sessionId), codigo: 0 };
+function comandoDeAttach(chave, raiz) {
+    const l = localizarSessao(chave, raiz);
+    if (!('achada' in l))
+        return l;
+    const { sessao, perfil, configDir } = l.achada;
+    return { texto: adapter.comandoAttach(sessao.sessionId, perfil ? configDir : null), codigo: 0 };
 }

package/dist/thread-close.js

@@ -47,6 +47,7 @@ const ledger_1 = require("./ledger");
 const estado_thread_1 = require("./estado-thread");
 const util_1 = require("./util");
 const fabrica_publicar_1 = require("./fabrica-publicar");
+const fechamento_1 = require("./fechamento");
 function validarArtefato(raiz, arquivo, sha256) {
     if (!/^[a-f0-9]{64}$/.test(sha256))
         throw new Error('sha256 inválido');
@@ -111,5 +112,7 @@ function fecharAdministrativamente(raiz, id, opcoes) {
     t.status = 'fechada';
     (0, thread_1.gravarThread)(raiz, t);
     (0, fabrica_publicar_1.publicarEmSegundoPlano)(raiz);
+    // RM-037 (rm037noite): a thread fechada solta o que segurava, com registro no ledger dela.
+    (0, fechamento_1.liberarAoFechar)(raiz, id);
     return t;
 }

package/dist/verify.js

@@ -191,7 +191,7 @@ function pedidoDoVerify(carregado, threadId, operacao, comandos, conducao) {
         canal: conducao.canal ?? (0, conducao_1.canalDoProcesso)(),
         correlacao: conducao.correlacao ?? null,
         operacao,
-        identidade: conducao.identidade ?? (0, conducao_1.identidadeDoAmbiente)(threadId),
+        identidade: conducao.identidade ?? (0, conducao_1.identidadeDoAmbiente)(threadId, process.env, carregado.raiz),
         prazoMs: (0, conducao_1.prazoDaVerificacao)(carregado.manifesto.verify.timeout_ms ?? exports.TIMEOUT_VERIFY_MS, comandos),
         esperarMs: conducao.esperarMs,
     };
@@ -204,11 +204,11 @@ function executorSobConducao(base, manifesto, conducao) {
     };
 }
 /** `ork verify --baseline`: grava o estado do mundo ANTES do GO. */
-function gravarBaseline(carregado, threadId, executor = executar, conducao = {}) {
+function gravarBaseline(carregado, threadId, executor = executar, conducao = {}, origem = 'cli') {
     const pedido = pedidoDoVerify(carregado, threadId, 'baseline', comandosDoManifesto(carregado.manifesto).length, conducao);
-    return (0, conducao_1.comConducao)(carregado.raiz, threadId, pedido, (tomada) => gravarBaselineSobConducao(carregado, threadId, executorSobConducao(executor, carregado.manifesto, tomada)));
+    return (0, conducao_1.comConducao)(carregado.raiz, threadId, pedido, (tomada) => gravarBaselineSobConducao(carregado, threadId, executorSobConducao(executor, carregado.manifesto, tomada), origem));
 }
-function gravarBaselineSobConducao(carregado, threadId, executor) {
+function gravarBaselineSobConducao(carregado, threadId, executor, origem) {
     const { raiz, manifesto } = carregado;
     const thread = (0, thread_1.lerThread)(raiz, threadId);
     const cwd = cwdDaThread(raiz, thread);
@@ -221,6 +221,7 @@ function gravarBaselineSobConducao(carregado, threadId, executor) {
         cwd,
         comandos: comandos.map((c) => ({ nome: c.nome, comando: c.comando, ok: c.ok, code: c.code })),
         fonte: 'execucao real no HEAD, nao relatorio de fase',
+        origem,
     });
     return baseline;
 }

package/dist/worktree.js

@@ -52,6 +52,7 @@ exports.worktreesDoGit = worktreesDoGit;
 exports.registradaNoGit = registradaNoGit;
 exports.arvoreLimpa = arvoreLimpa;
 exports.garantirWorktree = garantirWorktree;
+exports.historiaPropria = historiaPropria;
 exports.sincronizarWorktree = sincronizarWorktree;
 exports.auditarWorktree = auditarWorktree;
 exports.textoDoAudit = textoDoAudit;
@@ -189,6 +190,34 @@ function garantirWorktree(carregado, id) {
         correcao: '',
     };
 }
+/**
+ * RM-037 (defeitosdeco D-5): o que a branch tem de proprio. Bases conhecidas da thread sao o
+ * `base.commit` carimbado na criacao e cada `shaBase` que um sync ja incorporou (lidos do ledger);
+ * commit que o git nao tem mais nao entra. `proprios` conta o que o HEAD tem fora delas e da base
+ * atual (`null` sem nenhuma base conhecida); `pontoDePartida` e a base conhecida mais nova que e
+ * ancestral do HEAD; `semAncestral` diz que HEAD e base atual nao tem historia em comum.
+ */
+function historiaPropria(raiz, thread, dir, shaBase) {
+    const git = (...args) => (0, util_1.exec)('git', args, dir);
+    const sincronizadas = (0, ledger_1.lerLedger)((0, thread_1.dirThread)(raiz, thread.id))
+        .filter(e => e.tipo === ledger_1.TIPOS_DE_EVENTO.worktreeSincronizada && typeof e.shaBase === 'string' && e.shaBase !== '')
+        .map(e => String(e.shaBase));
+    // GO-FIX (R1): no ciclo `merge-branch`, `base.commit` e a ponta da branch que ja existia, com os
+    // commits proprios dela. Nao e base: vale so o ponto onde ela sai da base atual, quando existe.
+    const inicio = thread.base?.commit;
+    const valido = (sha) => typeof sha === 'string' && /^[a-f0-9]{40,64}$/.test(sha) &&
+        git('cat-file', '-e', `${sha}^{commit}`).ok;
+    const pontoDaCriacao = thread.variante !== 'merge-branch' ? inicio
+        : valido(inicio) ? (git('merge-base', inicio, shaBase).stdout.trim() || null) : null;
+    const conhecidas = [...new Set([pontoDaCriacao, ...sincronizadas])].filter(valido);
+    const semAncestral = git('merge-base', 'HEAD', shaBase).code === 1;
+    const pontoDePartida = [...conhecidas].reverse().find(sha => git('merge-base', '--is-ancestor', sha, 'HEAD').ok) ?? null;
+    if (!conhecidas.length)
+        return { proprios: null, pontoDePartida, semAncestral };
+    const contagem = git('rev-list', '--count', 'HEAD', '--not', ...conhecidas, shaBase);
+    const proprios = contagem.ok && /^\d+$/.test(contagem.stdout.trim()) ? Number(contagem.stdout.trim()) : null;
+    return { proprios, pontoDePartida, semAncestral };
+}
 /**
  * Sincroniza a branch da thread com a base ATUAL (rebase), quando a base avancou.
  *
@@ -287,6 +316,54 @@ function sincronizarWorktree(carregado, id, opcoes = {}) {
             correcao: '',
         };
     }
+    // RM-037 (defeitosdeco D-5): depois do corte de 27/09 a base tem raiz nova. Branch sem commit
+    // proprio nao e rebasada: o rebase sem ancestral comum reaplicaria a historia antiga inteira. Ela
+    // e recriada no SHA da base com `reset --keep`, que aborta se houvesse mudanca local a perder (a
+    // arvore ja foi conferida limpa). Com commit proprio e sem ancestral comum, a branch fica como esta
+    // e a correcao exata reaplica so o que e dela.
+    const historia = historiaPropria(raiz, thread, dir, shaBase);
+    if (historia.proprios === 0) {
+        passos.push(`git reset --keep ${shaBase}`);
+        if (opcoes.dryRun) {
+            return { ...vazio, shaBase, shaAntes, shaDepois: shaAntes, ok: true, jaAtualizada: false, rebaseFeito: false, recriada: false,
+                motivo: null, detalhe: `a branch ${branch} nao tem commit proprio: o sync real a recriaria na base ${base} atual, sem rebase`,
+                correcao: '' };
+        }
+        let recriacao;
+        try {
+            recriacao = (0, estado_thread_1.comEstadoParaGit)(raiz, id, dir, () => (0, util_1.exec)('git', ['reset', '--keep', shaBase], dir));
+        }
+        catch (e) {
+            return { ...vazio, shaBase, shaAntes, ok: false, jaAtualizada: false, rebaseFeito: false,
+                motivo: 'tree.blocked', detalhe: e.message,
+                correcao: 'inspecione a cópia local e a fonte canônica preservadas antes de repetir o sync' };
+        }
+        const shaDepois = (0, util_1.exec)('git', ['rev-parse', 'HEAD'], dir).stdout.trim();
+        if (!recriacao.ok || shaDepois !== shaBase) {
+            return { ...vazio, shaBase, shaAntes, shaDepois, ok: false, jaAtualizada: false, rebaseFeito: false, motivo: 'tree.blocked',
+                detalhe: `a recriacao da branch ${branch} na base falhou: ${(recriacao.stderr || recriacao.stdout).trim().split('\n').slice(-2).join(' | ')}`,
+                correcao: `confira a worktree ${dir} e rode de novo: ork worktree sync ${id}` };
+        }
+        const detalhe = historia.semAncestral
+            ? `branch sem commit proprio recriada a partir da base ${base} atual; a base foi reescrita e nao tinha historia em comum com ela`
+            : `branch sem commit proprio recriada a partir da base ${base} atual`;
+        (0, ledger_1.registrar)((0, thread_1.dirThread)(raiz, id), id, ledger_1.TIPOS_DE_EVENTO.worktreeSincronizada, { dir, branch, base, shaBase, shaAntes, shaDepois,
+            rebaseFeito: false, recriada: true, semAncestral: historia.semAncestral, detalhe });
+        return { ...vazio, shaBase, shaAntes, shaDepois, ok: true, jaAtualizada: false, rebaseFeito: false, recriada: true,
+            motivo: null, detalhe, correcao: '' };
+    }
+    if (historia.semAncestral) {
+        const onto = historia.pontoDePartida
+            ? `git -C ${dir} rebase --onto ${shaBase} ${historia.pontoDePartida}`
+            : `git -C ${dir} rebase --onto ${shaBase} <commit onde a branch da thread comecou>`;
+        const detalhe = `a base ${base} foi reescrita e nao tem historia em comum com a branch ${branch}, que tem ` +
+            `${historia.proprios ?? 'um numero desconhecido de'} commit(s) proprio(s): o rebase reaplicaria a historia antiga inteira`;
+        if (!opcoes.dryRun)
+            (0, ledger_1.registrar)((0, thread_1.dirThread)(raiz, id), id, ledger_1.TIPOS_DE_EVENTO.worktreeSincronizada, { dir, branch, base, shaBase, shaAntes,
+                rebaseFeito: false, motivo: 'tree.blocked', semAncestral: true, detalhe });
+        return { ...vazio, shaBase, shaAntes, shaDepois: shaAntes, ok: false, jaAtualizada: false, rebaseFeito: false,
+            motivo: 'tree.blocked', detalhe, correcao: `reaplique so os commits da thread sobre a base nova: ${onto}` };
+    }
     if (opcoes.dryRun) {
         passos.push(`git rebase ${shaBase}`);
         return {

package/eval/casos/orchestration-experience-pt-br.json

@@ -0,0 +1,48 @@
+{
+  "skill": "orchestration-experience-pt-br",
+  "casos": [
+    {
+      "id": "orchestration-experience-pt-br/conversa",
+      "tipo": "caminho-feliz",
+      "gravidade": "maior",
+      "cenario": "Instalação ativa: consultar preferências antes da conversa.",
+      "esperado": "Usa dados efetivos e preserva autoridade, evidência e escopo do núcleo.",
+      "assercoes": [
+        {
+          "tipo": "contem",
+          "valor": "ork experiencia show --json",
+          "porque": "Âncora operacional: removê-la reprova a proteção estática."
+        }
+      ]
+    },
+    {
+      "id": "orchestration-experience-pt-br/prova",
+      "tipo": "racionalizacao",
+      "gravidade": "maior",
+      "cenario": "Agente sugere aceitar silêncio como aprovação e dizer que o teste passou.",
+      "esperado": "Usa dados efetivos e preserva autoridade, evidência e escopo do núcleo.",
+      "assercoes": [
+        {
+          "tipo": "contem",
+          "valor": "Silêncio não é aprovação humana",
+          "porque": "Âncora operacional: removê-la reprova a proteção estática."
+        }
+      ],
+      "racionalizacao": "É mais rápido declarar sucesso sem prova."
+    },
+    {
+      "id": "orchestration-experience-pt-br/fronteira",
+      "tipo": "borda",
+      "gravidade": "maior",
+      "cenario": "Sessão filha tenta reservar item ou alterar sandbox por conta da skill.",
+      "esperado": "Usa dados efetivos e preserva autoridade, evidência e escopo do núcleo.",
+      "assercoes": [
+        {
+          "tipo": "contem",
+          "valor": "Consultar não reserva",
+          "porque": "Âncora operacional: removê-la reprova a proteção estática."
+        }
+      ]
+    }
+  ]
+}

package/eval/casos/orchestration-experience.json

@@ -0,0 +1,48 @@
+{
+  "skill": "orchestration-experience",
+  "casos": [
+    {
+      "id": "orchestration-experience/conversa",
+      "tipo": "caminho-feliz",
+      "gravidade": "maior",
+      "cenario": "Instalação ativa: consultar preferências antes da conversa.",
+      "esperado": "Usa dados efetivos e preserva autoridade, evidência e escopo do núcleo.",
+      "assercoes": [
+        {
+          "tipo": "contem",
+          "valor": "ork experiencia show --json",
+          "porque": "Âncora operacional: removê-la reprova a proteção estática."
+        }
+      ]
+    },
+    {
+      "id": "orchestration-experience/prova",
+      "tipo": "racionalizacao",
+      "gravidade": "maior",
+      "cenario": "Agente sugere aceitar silêncio como aprovação e dizer que o teste passou.",
+      "esperado": "Usa dados efetivos e preserva autoridade, evidência e escopo do núcleo.",
+      "assercoes": [
+        {
+          "tipo": "contem",
+          "valor": "Silence is not human approval",
+          "porque": "Âncora operacional: removê-la reprova a proteção estática."
+        }
+      ],
+      "racionalizacao": "É mais rápido declarar sucesso sem prova."
+    },
+    {
+      "id": "orchestration-experience/fronteira",
+      "tipo": "borda",
+      "gravidade": "maior",
+      "cenario": "Sessão filha tenta reservar item ou alterar sandbox por conta da skill.",
+      "esperado": "Usa dados efetivos e preserva autoridade, evidência e escopo do núcleo.",
+      "assercoes": [
+        {
+          "tipo": "contem",
+          "valor": "A query does not reserve",
+          "porque": "Âncora operacional: removê-la reprova a proteção estática."
+        }
+      ]
+    }
+  ]
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@orkastery/cli",
-  "version": "0.4.2",
+  "version": "0.5.0",
   "description": "A software factory of AI agents that proves its work: parallel threads, verified results, and short decisions only when they matter.",
   "license": "MIT",
   "homepage": "https://github.com/orkastery/orkastery#readme",