@orkastery/cli 0.2.0 → 0.3.0

package/dist/ledger.js

@@ -40,12 +40,17 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TIPOS_DE_EVENTO = void 0;
+exports.exigirRastroDeDecisaoAutonoma = exigirRastroDeDecisaoAutonoma;
 exports.caminhoLedger = caminhoLedger;
 exports.registrar = registrar;
+exports.threadPresente = threadPresente;
+exports.registrarSeExiste = registrarSeExiste;
 exports.lerLedger = lerLedger;
 const fs = __importStar(require("node:fs"));
 const path = __importStar(require("node:path"));
 const util_1 = require("./util");
+const node_crypto_1 = require("node:crypto");
+const company_brain_journal_1 = require("./company-brain-journal");
 /** Tipos de evento do ledger. B0 abriu a lista; o B1 acrescenta os seus. */
 exports.TIPOS_DE_EVENTO = {
     // Bloco B0
@@ -67,6 +72,24 @@ exports.TIPOS_DE_EVENTO = {
     shipIniciado: 'ship_started',
     shipConcluido: 'ship_done',
     shipBloqueado: 'ship_blocked',
+    /**
+     * I-43 (D3): a entrega foi revertida na base depois do ship.
+     *
+     * Ele ja existia na allowlist do ciclo (`company-brain-source.ts`) e tinha ZERO
+     * escritor no nucleo: o insumo de MAIOR peso do indice de qualidade nao era
+     * gravado por ninguem. Quem o escreve e `ship.ts`, que e quem sabe de merge e de
+     * base, e so quando o git prova a reversao.
+     */
+    rollbackConcluido: 'rollback_done',
+    /**
+     * I-43 (D3): a entrega foi aceita porque ninguem reclamou, e isso ficou REGISTRADO.
+     *
+     * Aceitacao por default nao pode ser silencio. O evento carrega o indice, os
+     * insumos que o produziram e quem decidiu, para o dono conseguir ver depois o que
+     * passou sem ele olhar. Nota humana posterior sobrescreve o score; este evento
+     * permanece, porque o ledger e append-only.
+     */
+    aceitePorOmissao: 'aceite_por_omissao',
     gateDeTokens: 'token_gate',
     handoffExportado: 'handoff_exported',
     handoffRecuperado: 'handoff_recalled',
@@ -78,6 +101,10 @@ exports.TIPOS_DE_EVENTO = {
     leaseEnfileirado: 'lease_queued',
     postmortemGravado: 'postmortem_recorded',
     masterConcluido: 'master_done',
+    scoreProposto: 'score_proposto',
+    masterMigrado: 'master_migrated',
+    threadFechadaAdmin: 'thread_closed_admin',
+    artefatoEntregue: 'artifact_delivered',
     // Bloco B5: auditores periodicos (rodada, achados, propostas e board de divida)
     auditoriaDespachada: 'audit_dispatch',
     auditoriaBloqueada: 'audit_blocked',
@@ -100,19 +127,97 @@ exports.TIPOS_DE_EVENTO = {
     rateLimitDetectado: 'rate_limit_detected',
     rateLimitEnfileirado: 'rate_limit_queued',
     rateLimitRetomado: 'rate_limit_resumed',
+    // I-33 (D5): troca de perfil ou de runtime depois de falha da conta (quem, de qual para
+    // qual, evidencia e razao). Faz parte do catalogo, nao de literal solto.
+    perfilRotacionado: 'runtime_profile_rotated',
     fixAberto: 'go_fix_opened',
     fixDespachado: 'go_fix_dispatched',
     reverifyConcluido: 'check_reverify',
+    // Feature #setup: customizacao de runtime/modelo/esforco por bloco de cada modo
+    setupConfigurado: 'setup_configured',
+    onboardingRegistrado: 'onboarding_recorded',
+    // Correcao do escalonador: vaga devolvida por thread sem procura ativa (`ork board reap`)
+    vagaLiberada: 'slot_released',
+    // I-07: estimativa humana no PLAN para comparacao economica posterior.
+    estimativaPlano: 'plan_estimate',
+    // I-42 (D5): ciclo sem CHECK que nao achou teste nem comando honesto declara a ausencia de
+    // prova, com os caminhos e o motivo. Ausencia registrada, nunca silenciosa.
+    provaAusente: 'prova_ausente',
+    // I-53 (RM-037, P6): o `ci prepare` avisou ou recusou comando de claim pelo lint.
+    lintDeClaim: 'claim_lint',
+    // I-55 (RM-008): a mesma falha em 3+ threads fechadas virou proposta de policy (so proposta).
+    politicaProposta: 'policy_proposta',
+    // I-36 (RM-036): conducao multicanal. O segundo pedido recusado, o despacho repetido que nao abriu
+    // sessao nova, a liberacao com prova (fim da sessao ou dono morto), o handoff e a renovacao do prazo.
+    conducaoRecusada: 'conducao_recusada',
+    despachoIdempotente: 'despacho_idempotente',
+    conducaoLiberada: 'conducao_liberada',
+    conducaoOrfaLiberada: 'conducao_orfa_liberada',
+    conducaoAssumida: 'conducao_assumida',
+    conducaoRenovada: 'conducao_renovada',
 };
+/**
+ * I-41 (GO-FIX 1, B4 e D11): o rastro tipado da decisao autonoma.
+ *
+ * O cabecalho deste arquivo sempre disse que "toda decisao autonoma precisa estar aqui com quem
+ * decidiu, evidencia e razao", e o registro nunca conferiu: 849 eventos com 215 chaves distintas,
+ * oito nomes para "quem decidiu" e 45% sem os tres campos (M6 do PLAN). A partir daqui o registro
+ * recusa `autonomous_decision` sem `quemDecidiu`, `evidencia` e `razao`, com esses nomes. Evento
+ * antigo continua legivel (a leitura normaliza os nomes historicos em `decisao-autonoma.ts`) e
+ * nenhuma linha e reescrita: a exigencia vale para a escrita nova, como v1 e v2 no contrato HITL.
+ */
+function exigirRastroDeDecisaoAutonoma(dados) {
+    for (const campo of ['quemDecidiu', 'evidencia', 'razao']) {
+        const v = dados[campo];
+        if (typeof v !== 'string' || !v.trim() || v.length > 1000 || /[\x00-\x08\x0b-\x1f\x7f]/.test(v)) {
+            throw new Error(`decisão autônoma exige ${campo}: quem decidiu, com que evidência e por quê`);
+        }
+    }
+}
 /** Caminho do ledger de uma thread. */
 function caminhoLedger(dirThread) {
     return path.join(dirThread, 'ledger.jsonl');
 }
 /** Anexa um evento ao ledger da thread e devolve o evento gravado. */
 function registrar(dirThread, threadId, tipo, dados = {}) {
-    const evento = { ts: (0, util_1.agora)(), thread: threadId, tipo, ...dados };
+    if (tipo === exports.TIPOS_DE_EVENTO.decisaoAutonoma)
+        exigirRastroDeDecisaoAutonoma(dados);
+    const evento = { ts: (0, util_1.agora)(), thread: threadId, tipo, ...dados, eventId: (0, node_crypto_1.randomUUID)() };
     fs.mkdirSync(dirThread, { recursive: true });
-    fs.appendFileSync(caminhoLedger(dirThread), JSON.stringify(evento) + '\n', 'utf8');
+    (0, company_brain_journal_1.durableAppend)(caminhoLedger(dirThread), evento);
+    return evento;
+}
+/** A thread ainda existe em disco? `thread.json` e ledger presentes; nada é criado aqui. */
+function threadPresente(dirThread) {
+    return fs.existsSync(path.join(dirThread, 'thread.json')) && fs.existsSync(caminhoLedger(dirThread));
+}
+/**
+ * Variante do `registrar` para processos destacados (watcher): anexa só a um ledger que já
+ * existe, sem criar pasta nem arquivo (`O_APPEND` sem `O_CREAT`). Thread apagada devolve
+ * `null` em vez de renascer com um ledger de um evento só.
+ */
+function registrarSeExiste(dirThread, threadId, tipo, dados = {}) {
+    if (tipo === exports.TIPOS_DE_EVENTO.decisaoAutonoma)
+        exigirRastroDeDecisaoAutonoma(dados);
+    if (!fs.existsSync(path.join(dirThread, 'thread.json')))
+        return null;
+    let fd;
+    try {
+        fd = fs.openSync(caminhoLedger(dirThread), fs.constants.O_WRONLY | fs.constants.O_APPEND);
+    }
+    catch (e) {
+        if (e.code === 'ENOENT')
+            return null;
+        throw e;
+    }
+    const evento = { ts: (0, util_1.agora)(), thread: threadId, tipo, ...dados, eventId: (0, node_crypto_1.randomUUID)() };
+    try {
+        fs.writeFileSync(fd, JSON.stringify(evento) + '\n');
+        fs.fsyncSync(fd);
+    }
+    finally {
+        fs.closeSync(fd);
+    }
     return evento;
 }
 /** Le o ledger inteiro. Linha corrompida vira evento `ledger_corrupted` em vez de quebrar a leitura. */

package/dist/licoes.js

@@ -0,0 +1,215 @@
+"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.PISO_DA_PROPOSTA = exports.JANELA_DA_PROPOSTA_DIAS = void 0;
+exports.lerLicoes = lerLicoes;
+exports.resumoDasLicoes = resumoDasLicoes;
+exports.textoDasLicoes = textoDasLicoes;
+exports.propostasDePolicy = propostasDePolicy;
+exports.registrarPropostasNovas = registrarPropostasNovas;
+exports.textoDeLicoes = textoDeLicoes;
+/**
+ * I-55 (RM-008): o loop de aprendizado.
+ *
+ * Havia dezenas de POSTMORTEMs e nenhuma licao voltando no ciclo seguinte: a licao so existia na
+ * colecao `learning` do OrkMind, e so no GOAL. Aqui ela sai direto dos arquivos que o MASTER ja
+ * grava (`POSTMORTEM.json` e `master-log.json`), em qualquer regime de memoria, e volta no GOAL e
+ * no PLAN da thread seguinte do mesmo produto. So conta thread fechada pelo MASTER: licao de
+ * thread aberta seria auto-relato.
+ *
+ * Quando a mesma falha se repete, o loop nao cria regra sozinho: ele PROPOE a policy, com as
+ * threads que a sustentam, e a proposta fica no ledger do projeto e em `ork licoes`. Transformar
+ * proposta em policy (`policies:` no manifesto) muda o que bloqueia a fabrica, e isso e do dono.
+ */
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const estado_thread_1 = require("./estado-thread");
+const ledger_1 = require("./ledger");
+/** O que evita cada bloqueio, na forma de comando. Sem dica, a licao so conta a recorrencia. */
+const DICA_DO_MOTIVO = {
+    'claims.failed': 'rode o comando da claim antes de registra-la; claim sem prova local volta como GO-FIX',
+    'verify.regression': 'grave a baseline antes do GO (`ork verify <thread> --baseline`) e rode os testes focados antes do CHECK',
+    'verify.failed': 'grave a baseline antes do GO, para a falha ter com que ser comparada',
+    'verify.timeout': 'divida o comando lento ou suba `verify.timeout_ms` no manifesto',
+    'runtime.unavailable': 'declare a ordem de fallback do bloco (`ork setup <modo> --bloco N --fallback runtime:modelo`)',
+    'runtime.quota-exhausted': 'tenha um segundo perfil da conta (`ork accounts add`) ou fallback no bloco',
+    'tree.blocked': 'sincronize a worktree com a base antes do SHIP (`ork worktree sync <thread>`)',
+    'ci.failed': 'rode a suite hermetica (`npm --prefix core run test:ci`) antes do push',
+    'artifact.missing': 'grave o artefato da fase exatamente no caminho que o prompt pede',
+};
+const DICA_DA_CLASSE = {
+    'erro-de-spec': 'declare criterios de pronto executaveis na criacao (`ork thread new ... --done`)',
+    'base-avancou': 'sincronize com a base antes do CHECK, nao so antes do SHIP',
+    'conflito': 'reserve o item do roadmap antes de comecar (`ork roadmap pegar`)',
+    'rate-limit': 'use o fallback do bloco em vez de esperar a janela',
+    'processo': 'siga o ciclo do modo: GOAL e PLAN antes do GO, e toda afirmacao com claim e comando',
+    'scope-creep': 'corte o pedido em fatias com item proprio no roadmap',
+};
+/** Classes que nao ensinam nada por si: nao entram na recorrencia. */
+const CLASSES_SEM_LICAO = new Set(['sem-falha', 'outra']);
+function lerJson(arquivo) {
+    try {
+        return JSON.parse(fs.readFileSync(arquivo, 'utf8'));
+    }
+    catch {
+        return null;
+    }
+}
+/** As licoes das threads fechadas pelo MASTER no estado deste projeto. */
+function lerLicoes(raiz) {
+    const dir = path.join((0, estado_thread_1.raizDoEstado)(raiz), '.orkastery', 'threads');
+    if (!fs.existsSync(dir))
+        return [];
+    const licoes = [];
+    for (const id of fs.readdirSync(dir)) {
+        const pm = lerJson(path.join(dir, id, 'POSTMORTEM.json'));
+        const master = lerJson(path.join(dir, id, 'master-log.json'));
+        if (!pm || !master || pm.thread !== id)
+            continue;
+        licoes.push({
+            thread: id,
+            score: typeof master.score === 'number' ? master.score : null,
+            justificativa: String(master.justificativa ?? '').replace(/\s+/g, ' ').trim(),
+            classes: (pm.classesDeFalha ?? []).filter((c) => typeof c === 'string'),
+            motivos: [...new Set((pm.gatesBloqueados ?? []).map((g) => g.motivo).filter((m) => typeof m === 'string'))],
+            bloqueios: (pm.gatesBloqueados ?? []).length,
+            fechadaEm: master.avaliadoEm ?? pm.geradoEm ?? '',
+        });
+    }
+    return licoes.sort((a, b) => b.fechadaEm.localeCompare(a.fechadaEm));
+}
+function recorrencias(licoes) {
+    const motivos = new Map();
+    const classes = new Map();
+    for (const l of licoes) {
+        for (const m of l.motivos) {
+            const r = motivos.get(m) ?? { chave: `motivo:${m}`, tipo: 'motivo', nome: m, threads: [], vezes: 0, dica: DICA_DO_MOTIVO[m] ?? null };
+            r.threads.push(l.thread);
+            motivos.set(m, r);
+        }
+        for (const c of l.classes) {
+            if (CLASSES_SEM_LICAO.has(c))
+                continue;
+            const r = classes.get(c) ?? { chave: `classe:${c}`, tipo: 'classe', nome: c, threads: [], vezes: 0, dica: DICA_DA_CLASSE[c] ?? null };
+            r.threads.push(l.thread);
+            classes.set(c, r);
+        }
+    }
+    const ordenar = (a, b) => b.threads.length - a.threads.length || a.nome.localeCompare(b.nome);
+    for (const r of motivos.values())
+        r.vezes = r.threads.length;
+    for (const r of classes.values())
+        r.vezes = r.threads.length;
+    return { motivos: [...motivos.values()].sort(ordenar), classes: [...classes.values()].sort(ordenar) };
+}
+/** O resumo que volta no GOAL e no PLAN: a thread corrente nunca aprende consigo mesma. */
+function resumoDasLicoes(raiz, threadCorrente) {
+    const licoes = lerLicoes(raiz).filter((l) => l.thread !== threadCorrente);
+    const { motivos, classes } = recorrencias(licoes);
+    return {
+        threads: licoes.length,
+        motivos: motivos.slice(0, 3),
+        classes: classes.slice(0, 2),
+        // Nota 0 e, na pratica, encerramento de thread orfa sem entrega: nao ensina nada ao proximo ciclo.
+        recentes: licoes.filter((l) => l.score !== null && l.score >= 1 && l.score <= 3 && l.justificativa).slice(0, 3),
+    };
+}
+const curto = (t, teto) => (t.length > teto ? `${t.slice(0, teto - 3)}...` : t);
+/** O texto da licao para o prompt. Vazio quando nao ha thread fechada para ensinar. */
+function textoDasLicoes(r) {
+    if (r.threads === 0 || (r.motivos.length === 0 && r.classes.length === 0 && r.recentes.length === 0))
+        return '';
+    const linhas = [`Das ${r.threads} threads ja fechadas pelo MASTER neste produto:`];
+    for (const m of r.motivos) {
+        linhas.push(`- o bloqueio ${m.nome} apareceu em ${m.threads.length} ${m.threads.length === 1 ? 'thread' : 'threads'}` +
+            (m.dica ? `; o que evita: ${m.dica}` : ''));
+    }
+    for (const c of r.classes) {
+        linhas.push(`- a classe de falha ${c.nome} fechou ${c.threads.length} ${c.threads.length === 1 ? 'thread' : 'threads'}` +
+            (c.dica ? `; o que evita: ${c.dica}` : ''));
+    }
+    for (const l of r.recentes)
+        linhas.push(`- ${l.thread} fechou com ${l.score}/5: ${curto(l.justificativa, 160)}`);
+    return linhas.join('\n');
+}
+/** Janela e piso da recorrencia que vira proposta de policy. */
+exports.JANELA_DA_PROPOSTA_DIAS = 30;
+exports.PISO_DA_PROPOSTA = 3;
+/**
+ * A mesma falha em pelo menos 3 threads fechadas nos ultimos 30 dias vira PROPOSTA de policy.
+ * So proposta: a policy muda o que bloqueia a fabrica, e isso e do dono.
+ */
+function propostasDePolicy(raiz, agoraIso = new Date().toISOString()) {
+    const limite = Date.parse(agoraIso) - exports.JANELA_DA_PROPOSTA_DIAS * 86_400_000;
+    const recentes = lerLicoes(raiz).filter((l) => Date.parse(l.fechadaEm) >= limite);
+    const { motivos, classes } = recorrencias(recentes);
+    return [...motivos, ...classes].filter((r) => r.threads.length >= exports.PISO_DA_PROPOSTA).map((r) => ({
+        chave: r.chave, tipo: r.tipo, nome: r.nome, threads: [...r.threads], janelaDias: exports.JANELA_DA_PROPOSTA_DIAS,
+        sugestao: `policy \`${r.nome.replace(/[^a-z0-9]+/gi, '_')}\` em warn: ` + (r.dica ?? 'revisar a causa comum antes da proxima thread'),
+    }));
+}
+/**
+ * Grava no ledger do projeto a proposta que ainda nao foi registrada nesta janela. Idempotente:
+ * rodar de novo nao duplica. Devolve so as novas.
+ */
+function registrarPropostasNovas(raiz, agoraIso = new Date().toISOString()) {
+    const dirProjeto = path.join((0, estado_thread_1.raizDoEstado)(raiz), '.orkastery');
+    const limite = Date.parse(agoraIso) - exports.JANELA_DA_PROPOSTA_DIAS * 86_400_000;
+    const jaFeitas = new Set((0, ledger_1.lerLedger)(dirProjeto)
+        .filter((e) => e.tipo === ledger_1.TIPOS_DE_EVENTO.politicaProposta && Date.parse(e.ts) >= limite)
+        .map((e) => String(e.chave)));
+    const novas = propostasDePolicy(raiz, agoraIso).filter((p) => !jaFeitas.has(p.chave));
+    for (const p of novas) {
+        // `categoria`, nao `tipo`: o `registrar` espalha os dados por cima do tipo do evento.
+        (0, ledger_1.registrar)(dirProjeto, 'projeto', ledger_1.TIPOS_DE_EVENTO.politicaProposta, { chave: p.chave, categoria: p.tipo, nome: p.nome,
+            threads: p.threads, janelaDias: p.janelaDias, sugestao: p.sugestao });
+    }
+    return novas;
+}
+/** `ork licoes`: o que volta no proximo GOAL e PLAN, e as propostas de policy. */
+function textoDeLicoes(raiz, agoraIso = new Date().toISOString()) {
+    const resumo = resumoDasLicoes(raiz, null);
+    const linhas = ['Licoes que voltam no GOAL e no PLAN da proxima thread', ''];
+    linhas.push(textoDasLicoes(resumo) || 'Nenhuma thread fechada pelo MASTER ainda: nada a ensinar.');
+    const propostas = propostasDePolicy(raiz, agoraIso);
+    linhas.push('');
+    linhas.push(`Propostas de policy (a mesma falha em ${exports.PISO_DA_PROPOSTA}+ threads nos ultimos ${exports.JANELA_DA_PROPOSTA_DIAS} dias):`);
+    if (propostas.length === 0)
+        linhas.push('  nenhuma');
+    for (const p of propostas)
+        linhas.push(`  ${p.chave} em ${p.threads.length} threads (${p.threads.slice(0, 5).join(', ')})`, `    ${p.sugestao}`);
+    linhas.push('', 'Proposta nao bloqueia nada: vira policy so quando o dono a declara em `policies:` no orkastery.yaml.');
+    return linhas.join('\n');
+}

package/dist/liveness.js

@@ -0,0 +1,218 @@
+"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.transcricaoClaude = transcricaoClaude;
+exports.detectarFasesOrfas = detectarFasesOrfas;
+const escopo_escrita_1 = require("./escopo-escrita");
+/** D3: silêncio é ausência de progresso verificável, não ausência de PID. */
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const node_crypto_1 = require("node:crypto");
+const codex_1 = require("./adapters/codex");
+const runtime_profiles_1 = require("./runtime-profiles");
+const thread_1 = require("./thread");
+const ledger_1 = require("./ledger");
+const retry_1 = require("./retry");
+const util_1 = require("./util");
+/**
+ * Transcrição local do Claude. O UUID evita interpretar identificador como caminho.
+ * I-33 (D4): `config` é o diretório já resolvido pelo perfil da sessão (ou o implícito, sem
+ * perfil); o default pelo env do processo deixou de existir aqui.
+ */
+function transcricaoClaude(sessionId, cwd, config) {
+    if (!/^[0-9a-f]{8}(?:-[0-9a-f]{4}){3}-[0-9a-f]{12}$/i.test(sessionId))
+        return undefined;
+    const projetos = path.join(config, 'projects');
+    const candidato = path.join(projetos, path.resolve(cwd).replace(/[^a-zA-Z0-9-]/g, '-'), `${sessionId}.jsonl`);
+    if (fs.existsSync(candidato))
+        return candidato;
+    if (!fs.existsSync(projetos))
+        return undefined;
+    // Também cobre a chave abreviada de projetos com caminhos extensos.
+    for (const entrada of fs.readdirSync(projetos, { withFileTypes: true })) {
+        if (!entrada.isDirectory())
+            continue;
+        const arquivo = path.join(projetos, entrada.name, `${sessionId}.jsonl`);
+        if (fs.existsSync(arquivo))
+            return arquivo;
+    }
+    return undefined;
+}
+function fontesReais(t, d) {
+    const commit = t.worktree ? (0, util_1.exec)('git', ['log', '-1', '--format=%cI'], t.worktree) : null;
+    const commitEm = commit?.ok ? commit.stdout.trim() : undefined;
+    if (typeof d.sessionId !== 'string')
+        return { commitEm };
+    // I-33 (D4): a fonte de vida mora no diretório do perfil gravado no `phase_dispatch`. Perfil
+    // inválido não vira leitura pela conta do processo: sem rollout, a prova de vida fica no commit.
+    let perfil;
+    try {
+        perfil = (0, runtime_profiles_1.perfilDoRegistro)([d], { sessionId: d.sessionId });
+    }
+    catch {
+        return { commitEm };
+    }
+    const rollout = d.runtime === 'codex' ? (0, codex_1.acharRollout)(d.sessionId, 3, (0, codex_1.casaDoCodex)(perfil))
+        : d.runtime === 'claude-bg' ? transcricaoClaude(d.sessionId, t.worktree ?? process.cwd(), (0, runtime_profiles_1.diretorioEfetivo)('claude-bg', perfil)) : null;
+    return { commitEm, rollout: rollout ?? undefined };
+}
+/** Último evento do rollout, com leitura limitada. Não carrega o histórico inteiro. */
+function instanteDoRollout(arquivo) {
+    const fd = fs.openSync(arquivo, 'r');
+    try {
+        const size = fs.fstatSync(fd).size, n = Math.min(size, 65536), buf = Buffer.alloc(n);
+        fs.readSync(fd, buf, 0, n, size - n);
+        for (const linha of buf.toString('utf8').split('\n').reverse()) {
+            try {
+                const e = JSON.parse(linha);
+                if (typeof e.timestamp === 'string' && Number.isFinite(Date.parse(e.timestamp)))
+                    return e.timestamp;
+            }
+            catch { /* última linha incompleta ou primeira linha truncada */ }
+        }
+        return null;
+    }
+    finally {
+        fs.closeSync(fd);
+    }
+}
+function detectarFasesOrfas(carregado, opcoes = {}) {
+    const autorizadas = opcoes.registrar ? (0, escopo_escrita_1.exigirEscopoDeEscrita)(opcoes.escopo) : new Set();
+    const quando = opcoes.quando ?? (0, util_1.agora)(), now = Date.parse(quando);
+    const limite = carregado.manifesto.liveness?.silencio_max_min ?? 10;
+    if (!Number.isFinite(now) || !Number.isFinite(limite) || limite <= 0)
+        throw new Error('instante ou limite de liveness inválido');
+    const orfas = [];
+    for (const id of (0, thread_1.listarIds)(carregado.raiz)) {
+        const escrever = opcoes.registrar === true && autorizadas.has(id);
+        const t = (0, thread_1.lerThread)(carregado.raiz, id), dir = (0, thread_1.dirThread)(carregado.raiz, id);
+        if (t.status !== 'aberta')
+            continue;
+        const eventos = (0, ledger_1.lerLedger)(dir), di = eventos.map(e => e.tipo).lastIndexOf('phase_dispatch');
+        if (di < 0)
+            continue;
+        const d = eventos[di], inicio = Date.parse(d.ts), fase = d.fase;
+        if (opcoes.runtimes && !opcoes.runtimes.includes(String(d.runtime)))
+            continue;
+        if (!Number.isFinite(inicio) || inicio > now)
+            continue;
+        const apos = eventos.slice(di + 1);
+        const terminal = apos.some(e => ['ship_done', 'master_done', 'thread_closed_admin'].includes(e.tipo) ||
+            (e.tipo === 'phase_result' && e.fase === fase && (!e.sessionId || e.sessionId === d.sessionId) &&
+                (e.estado === 'concluida' || e.ok === true || e.exitCode === 0 || e.status === 'ok')));
+        if (terminal || opcoes.estados?.get(String(d.sessionId)) === 'blocked')
+            continue;
+        // Gate explícito em aberto não é falta de progresso. Pausa futura do modo não conta.
+        const gate = apos.filter(e => (!e.fase || e.fase === fase) && (!e.sessionId || e.sessionId === d.sessionId) &&
+            (e.tipo === 'gate_blocked' || e.tipo === 'gate_passed' || (e.tipo === 'human_gate' && e.acao === 'approve'))).at(-1);
+        if (gate?.tipo === 'gate_blocked' && gate.motivo !== 'runtime.silencio' &&
+            !(gate.motivo === 'human.pending' && gate.origem === 'retry.run'))
+            continue;
+        let heartbeat = inicio;
+        const evidencia = [`phase_dispatch ${d.ts} sessão ${String(d.sessionId ?? '')}`];
+        const incorporar = (ts, fonte) => {
+            const n = ts ? Date.parse(ts) : NaN;
+            if (n > heartbeat && n <= now) {
+                heartbeat = n;
+                evidencia.push(`${fonte}: ${ts}`);
+            }
+        };
+        for (const e of apos) {
+            if (['runtime_event', 'runtime_heartbeat', 'phase_heartbeat', 'sessao_heartbeat', 'commit',
+                'runtime_stop', 'runtime_subagent_stop', 'sessao_destravada'].includes(e.tipo) &&
+                typeof d.sessionId === 'string' && e.sessionId === d.sessionId && (!e.fase || e.fase === fase)) {
+                incorporar(e.ts, e.tipo);
+            }
+        }
+        const fontes = (opcoes.fontes ?? fontesReais)(t, d);
+        incorporar(fontes.commitEm, 'commit na worktree');
+        const file = path.join(dir, 'liveness.json'), chave = `${d.ts}|${d.sessionId}`;
+        let anterior = null;
+        let snapshotInvalido = false;
+        if (fs.existsSync(file)) {
+            try {
+                anterior = JSON.parse(fs.readFileSync(file, 'utf8'));
+                if (!anterior || typeof anterior.despacho !== 'string' || typeof anterior.arquivo !== 'string' ||
+                    !Number.isFinite(anterior.tamanho) || anterior.tamanho < 0 || !Number.isFinite(Date.parse(anterior.heartbeatEm))) {
+                    throw new Error('snapshot invalido');
+                }
+            }
+            catch {
+                anterior = null;
+                snapshotInvalido = true;
+                const diagnostico = `liveness.snapshot.invalid:${id}`;
+                evidencia.push(diagnostico);
+                opcoes.diagnosticos?.push(diagnostico);
+            }
+        }
+        if (anterior?.despacho === chave)
+            incorporar(anterior.heartbeatEm, 'rollout observado');
+        if (fontes.rollout && fs.existsSync(fontes.rollout)) {
+            const stat = fs.statSync(fontes.rollout);
+            if (anterior?.despacho !== chave || anterior.arquivo !== fontes.rollout || stat.size > anterior.tamanho) {
+                incorporar(instanteDoRollout(fontes.rollout), 'evento no rollout em crescimento');
+            }
+            if (escrever && !snapshotInvalido) {
+                const snapshot = { despacho: chave, tamanho: stat.size, heartbeatEm: new Date(heartbeat).toISOString(), arquivo: fontes.rollout };
+                const tmp = file + `.${(0, node_crypto_1.randomUUID)()}.tmp`;
+                fs.writeFileSync(tmp, JSON.stringify(snapshot) + '\n');
+                fs.renameSync(tmp, file);
+            }
+        }
+        const silencio = (now - heartbeat) / 60000;
+        const episodio = apos.filter(e => ['gate_blocked', 'gate_passed'].includes(e.tipo) &&
+            e.motivo === 'runtime.silencio' && e.despacho === chave).at(-1);
+        if (silencio < limite) {
+            if (escrever && gate === episodio && episodio?.tipo === 'gate_blocked') {
+                (0, ledger_1.registrar)(dir, id, 'gate_passed', { fase, motivo: 'runtime.silencio', despacho: chave,
+                    sessionId: d.sessionId, origem: 'pulse', detalhe: 'heartbeat observado após silêncio', evidencia });
+            }
+            continue;
+        }
+        const estado = opcoes.estados?.get(String(d.sessionId));
+        const retry = (0, retry_1.planejarRetry)(carregado, id, { motivo: 'runtime.silencio', fase,
+            estadoDaSessao: estado ? { sessionId: String(d.sessionId), estado } : undefined });
+        const resultado = { classe: 'fase_orfa', motivo: 'runtime.silencio', thread: id, fase,
+            sessionId: String(d.sessionId ?? ''), despachadaEm: d.ts, ultimoHeartbeatEm: new Date(heartbeat).toISOString(),
+            silencioHaMin: Math.floor(silencio), desdeEm: new Date(heartbeat + limite * 60000).toISOString(), evidencia, retry };
+        orfas.push(resultado);
+        if (escrever && episodio?.tipo !== 'gate_blocked') {
+            (0, ledger_1.registrar)(dir, id, 'gate_blocked', { fase, motivo: 'runtime.silencio', gate: 'phase.dispatch',
+                despacho: chave, sessionId: d.sessionId, detalhe: `${resultado.silencioHaMin} minutos sem heartbeat`,
+                origem: 'pulse', correcao: `ork retry run ${id} --motivo runtime.silencio --fase ${fase}`, evidencia });
+        }
+    }
+    return orfas;
+}

package/dist/maestro-actions.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ACTION_TRANSPORT = void 0;
+exports.proposeMaestroActions = proposeMaestroActions;
+exports.performMaestroAction = performMaestroAction;
+/** Ações são propostas. A autoridade continua nos endpoints existentes do núcleo. */
+const zod_1 = require("zod");
+const maestro_discovery_1 = require("./maestro-discovery");
+const maestro_sources_1 = require("./maestro-sources");
+exports.ACTION_TRANSPORT = {
+    'thread.status': 'ork_thread_status', 'thread.observe': 'ork_observe', 'hitl.decide': 'ork_request_decision',
+    'git.status': 'ork_git_status', 'git.commit': 'ork_git_commit', verify: 'ork_verify', ship: 'ork_ship',
+    retry: 'ork retry', master: 'ork master', phase: 'ork_phase_run', creation: 'ork creation',
+};
+function proposeMaestroActions(threads, host) {
+    const items = [];
+    for (const t of threads) {
+        const operations = ['thread.status', 'thread.observe', 'git.status', 'git.commit', 'verify', 'ship', 'hitl.decide', 'retry', 'master', 'phase'];
+        for (const operation of operations) {
+            const tool = exports.ACTION_TRANSPORT[operation], ownerOnly = ['hitl.decide', 'phase', 'master', 'creation'].includes(operation);
+            const supported = host.tools.includes(tool), available = supported && !(host.child && ownerOnly);
+            items.push({ ...(0, maestro_sources_1.item)(`${operation}:${t.id}`, operation, available ? 'proposed' : 'unavailable', [{ kind: 'thread', id: t.id }], {}),
+                action: { operation, available, reason: available ? '' : host.child && ownerOnly ? 'authority.conductor_required' : 'transport.unavailable',
+                    preconditions: ['state.revalidate', ...(!['thread.status', 'thread.observe', 'git.status'].includes(operation) ? ['native.authorization', 'core.gates', 'operation.required_arguments'] : [])], readback: 'ork_thread_status' } });
+        }
+    }
+    return { source: 'ork.maestro.actions/v1', items, gaps: [] };
+}
+const requestSchema = zod_1.z.object({ id: zod_1.z.string().min(1).max(160), expectedFingerprint: zod_1.z.string().regex(/^[a-f0-9]{64}$/) }).strict();
+function performMaestroAction(context, input, ports) {
+    const request = requestSchema.parse(input);
+    (0, maestro_discovery_1.revalidateMaestroContext)(context);
+    const current = ports.snapshot();
+    const selected = current.sections.nextActions.items.find(a => a.id === request.id), action = selected?.action;
+    if (!selected || !action?.available)
+        throw Error(action?.reason || 'maestro.action.unavailable');
+    const target = selected.refs.find(r => r.kind === 'thread')?.id;
+    if (!target || !/^[a-zA-Z0-9][a-zA-Z0-9._-]{0,79}$/.test(target))
+        throw Error('maestro.project.scope');
+    const previous = ports.receipts(request.id, request.expectedFingerprint);
+    if (previous !== null)
+        return { receipt: previous, readback: ports.readback(target), repeated: true };
+    if (current.fingerprint !== request.expectedFingerprint || current.conflicts.length || Object.values(current.sections).some(s => ['stale', 'conflict'].includes(s.state)))
+        throw Error('maestro.snapshot.stale');
+    const execute = ports.operations[action.operation];
+    if (!execute)
+        throw Error('transport.unavailable');
+    (0, maestro_discovery_1.revalidateMaestroContext)(context);
+    const receipt = execute(target);
+    return { receipt, readback: ports.readback(target), repeated: false };
+}