@orkastery/cli 0.2.0 → 0.3.0

package/dist/adapters/codex.js

@@ -0,0 +1,394 @@
+"use strict";
+/** Runtime Codex governado pelo controller app-server. Assinatura ChatGPT obrigatória.
+ * Helpers exec/rollout permanecem para leitura de histórico; não são fallback de despacho.
+ */
+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.SANDBOX_PADRAO = exports.SANDBOXES_DO_CODEX = exports.ENVS_REMOVIDAS_DO_DESPACHO = exports.NOME_ADAPTER = void 0;
+exports.ambienteDoDespacho = ambienteDoDespacho;
+exports.disponivel = disponivel;
+exports.versao = versao;
+exports.casaDoCodex = casaDoCodex;
+exports.conferirAuth = conferirAuth;
+exports.consultarRollouts = consultarRollouts;
+exports.sondarSandbox = sondarSandbox;
+exports.montarComando = montarComando;
+exports.extrairThreadId = extrairThreadId;
+exports.acharRollout = acharRollout;
+exports.parseRateLimitCodex = parseRateLimitCodex;
+exports.despachar = despachar;
+exports.logs = logs;
+const codex_controller_1 = require("./codex-controller");
+const runtime_context_1 = require("../runtime-context");
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const util_1 = require("../util");
+const runtime_ambiente_1 = require("../runtime-ambiente");
+const claude_bg_1 = require("./claude-bg");
+const runtime_profiles_1 = require("../runtime-profiles");
+exports.NOME_ADAPTER = 'codex';
+/**
+ * Variaveis que REDIRECIONAM o codex para um provider pago por token.
+ *
+ * O despacho usa a sessao autenticada (`codex login`, plano ChatGPT). Uma OPENAI_API_KEY
+ * no ambiente pode virar cobranca por token sem ninguem pedir, o mesmo risco do claude-bg,
+ * entao o adapter LIMPA essas variaveis do ambiente do filho em vez de confiar que o CLI
+ * vai ignora-las.
+ */
+exports.ENVS_REMOVIDAS_DO_DESPACHO = [...runtime_ambiente_1.ENVS_DE_PROVIDER_PAGO, 'CODEX_API_KEY'];
+/**
+ * O ambiente do despacho: o do processo, sem as variaveis de provider pago e sem
+ * `CODEX_API_KEY`. A lista da higiene de runtime nao cobre a chave especifica do Codex,
+ * entao o adapter a remove aqui: a assinatura ChatGPT continua sendo a unica credencial.
+ */
+function ambienteDoDespacho(base = process.env, perfil) {
+    const env = (0, runtime_ambiente_1.ambienteDeAssinatura)(base);
+    for (const nome of exports.ENVS_REMOVIDAS_DO_DESPACHO)
+        delete env[nome];
+    // I-33 (D2): o `CODEX_HOME` do filho vem do `codexHome` do perfil; sem perfil, o do processo.
+    if (perfil && (perfil.runtime !== 'codex' || !perfil.codexHome))
+        throw new Error('runtime.profiles.invalid: perfil sem codexHome no despacho codex');
+    return (0, runtime_profiles_1.ambienteComPerfil)(env, perfil);
+}
+function exec(cmd, args, cwd, timeoutMs, ambiente = ambienteDoDespacho()) {
+    return (0, util_1.exec)(cmd, args, cwd, timeoutMs, ambiente);
+}
+/** Modos de sandbox aceitos pelo `codex exec --sandbox`. */
+exports.SANDBOXES_DO_CODEX = ['read-only', 'workspace-write', 'danger-full-access'];
+/** Sandbox padrao do despacho: escreve no workspace, sem rede para o agente. */
+exports.SANDBOX_PADRAO = 'workspace-write';
+/** O runtime esta disponivel nesta maquina? */
+function disponivel() {
+    return (0, util_1.noPath)('codex');
+}
+/** Versao do runtime, para o `ork doctor`. */
+function versao() {
+    const r = exec('codex', ['--version'], undefined, 30000);
+    return r.ok ? r.stdout.trim() : null;
+}
+/**
+ * Raiz do estado do Codex: o `codexHome` do perfil da sessao (I-33, D4) ou, sem perfil, o
+ * `CODEX_HOME` do processo com fallback `~/.codex`.
+ */
+function casaDoCodex(perfil) {
+    return (0, runtime_profiles_1.diretorioEfetivo)('codex', perfil);
+}
+/**
+ * I-33 (D7, D13): `codex login status` com o env do perfil. Aprova so o login da ASSINATURA
+ * ("Logged in using ChatGPT"); login por API key sai 0 mas cobra por token: `pago`, nunca despacha,
+ * e o trecho mascarado da chave nao vai ao detalhe. O `ork` nunca abre nada dentro do
+ * `CODEX_HOME`: quem responde e o CLI.
+ */
+function conferirAuth(perfil) {
+    let ambiente;
+    try {
+        ambiente = ambienteDoDespacho(process.env, perfil);
+    }
+    catch (e) {
+        return { ok: false, detalhe: e.message };
+    }
+    const r = exec('codex', ['login', 'status'], undefined, 30000, ambiente);
+    // A14: sem codigo de saida (timeout, sinal ou binario ausente), a conferencia e inconclusiva.
+    if (r.code === -1)
+        return { ok: false, transitorio: true, detalhe: 'codex login status sem resposta (timeout, sinal ou binario ausente)' };
+    const linha = (r.stdout + '\n' + r.stderr).split('\n').map(l => l.trim()).find(l => l !== '') ?? '';
+    const trecho = linha.replace(/\p{Cc}/gu, '').slice(0, 120);
+    if (!r.ok)
+        return { ok: false, detalhe: `codex login status saiu ${r.code}${trecho ? `: ${trecho}` : ''}` };
+    if (/logged in using chatgpt/i.test(trecho))
+        return { ok: true, detalhe: 'codex login status: Logged in using ChatGPT' };
+    return { ok: false, pago: true, detalhe: /api key/i.test(trecho) ? 'codex login status: login por API key (provider pago)'
+            : 'codex login status: login sem assinatura ChatGPT comprovada (tratado como provider pago)' };
+}
+/** Somente metadados do cabeçalho e eventos terminais; prompts nunca saem do leitor. */
+function consultarRollouts(todas = false, casa = casaDoCodex()) {
+    const fontes = [path.join(casa, 'sessions'), ...(todas ? [path.join(casa, 'archived_sessions')] : [])];
+    const resultadosFontes = [];
+    const sessoes = [];
+    const ids = new Set();
+    for (const dirFonte of fontes) {
+        const fonte = { origem: dirFonte, ok: true, detalhe: '' };
+        resultadosFontes.push(fonte);
+        const falhar = (origem, detalhe) => {
+            fonte.ok = false;
+            fonte.detalhe = 'inventário parcial; fonte contém erro de diretório, leitura ou metadados';
+            if (origem === dirFonte)
+                fonte.detalhe = detalhe;
+            else
+                resultadosFontes.push({ origem, ok: false, detalhe });
+        };
+        const visitar = (dir) => {
+            let entradas;
+            try {
+                if (!fs.lstatSync(dir).isDirectory())
+                    throw new Error('diretório inválido');
+                entradas = fs.readdirSync(dir, { withFileTypes: true });
+            }
+            catch {
+                falhar(dir, 'diretório inacessível ou inválido');
+                return;
+            }
+            for (const entrada of entradas) {
+                const arquivo = path.join(dir, entrada.name);
+                if (entrada.isSymbolicLink()) {
+                    falhar(arquivo, 'link inesperado');
+                    continue;
+                }
+                if (entrada.isDirectory()) {
+                    visitar(arquivo);
+                    continue;
+                }
+                if (!entrada.isFile() || !entrada.name.endsWith('.jsonl'))
+                    continue;
+                try {
+                    const fd = fs.openSync(arquivo, 'r');
+                    let primeira, cauda;
+                    try {
+                        const tamanho = fs.fstatSync(fd).size;
+                        const cab = Buffer.alloc(Math.min(tamanho, 65536));
+                        fs.readSync(fd, cab, 0, cab.length, 0);
+                        primeira = cab.toString('utf8').split('\n')[0];
+                        const fim = Buffer.alloc(Math.min(tamanho, 131072));
+                        fs.readSync(fd, fim, 0, fim.length, tamanho - fim.length);
+                        cauda = fim.toString('utf8');
+                    }
+                    finally {
+                        fs.closeSync(fd);
+                    }
+                    const meta = JSON.parse(primeira);
+                    const p = meta.payload;
+                    if (meta.type !== 'session_meta' || !p || typeof p.id !== 'string' ||
+                        !/^[a-f0-9-]{8,}$/i.test(p.id) || typeof p.cwd !== 'string' || !path.isAbsolute(p.cwd) ||
+                        ids.has(p.id))
+                        throw new Error('metadados inválidos ou duplicados');
+                    ids.add(p.id);
+                    // Ausência de evento terminal é desconhecimento, não prova de processo vivo.
+                    let state = 'unknown';
+                    for (const linha of cauda.split('\n')) {
+                        try {
+                            const e = JSON.parse(linha);
+                            if (e.type === 'event_msg' && e.payload?.type === 'task_started')
+                                state = 'unknown';
+                            if (e.type === 'event_msg' && ['task_complete', 'task_aborted'].includes(e.payload?.type))
+                                state = 'completed';
+                        }
+                        catch { /* primeira/última linha do recorte pode estar parcial */ }
+                    }
+                    if (todas || state !== 'completed')
+                        sessoes.push({ sessionId: p.id, cwd: p.cwd, state, kind: 'codex-rollout' });
+                }
+                catch {
+                    falhar(arquivo, 'leitura ou metadados inválidos ou duplicados');
+                }
+            }
+        };
+        // O runtime é opcional: somente ENOENT antes da consulta prova fonte ausente.
+        // Erros durante a visita (inclusive desaparecimento) continuam invalidando a fonte.
+        try {
+            fs.lstatSync(dirFonte);
+        }
+        catch (e) {
+            if (e.code === 'ENOENT') {
+                fonte.detalhe = 'diretório opcional ausente';
+                continue;
+            }
+            falhar(dirFonte, 'diretório inacessível ou inválido');
+            continue;
+        }
+        visitar(dirFonte);
+    }
+    const ok = resultadosFontes.every(f => f.ok);
+    return { ok, sessoes, fontes, resultadosFontes,
+        detalhe: ok ? '' : 'inventário Codex incompleto: consulte as fontes com erro' };
+}
+/**
+ * A sonda deterministica do sandbox: roda `true` dentro do sandbox do Codex, SEM LLM.
+ *
+ * Numa maquina sa ela sai 0. Onde o bubblewrap nao consegue criar user namespace
+ * (Ubuntu com `apparmor_restrict_unprivileged_userns=1` e sem o pacote bubblewrap do
+ * sistema), ela sai != 0 com o erro real do bwrap, e o despacho sandboxado viraria
+ * narrativa sem execucao. E por isso que ela e check de `ork doctor`, nao detalhe.
+ */
+function sondarSandbox() {
+    const r = exec('codex', ['sandbox', 'true'], undefined, 30000);
+    const saida = (r.stdout + ' ' + r.stderr).trim();
+    return {
+        ok: r.ok,
+        detalhe: r.ok ? 'codex sandbox true saiu 0' : saida.slice(0, 200) || `exit ${r.code}`,
+    };
+}
+/** Monta a linha de comando exata do despacho (usada tambem pelo `--dry-run`). */
+function montarComando(pedido) {
+    const args = [
+        'exec',
+        '--sandbox',
+        pedido.sandbox ?? exports.SANDBOX_PADRAO,
+        // Headless de verdade: sem TTY nao ha quem aprove, entao pedir aprovacao e travar.
+        '-c',
+        'approval_policy=never',
+        '--skip-git-repo-check',
+        '-C',
+        pedido.cwd,
+        '--json',
+    ];
+    if (pedido.model)
+        args.push('-m', pedido.model);
+    if (pedido.effort)
+        args.push('-c', `model_reasoning_effort=${JSON.stringify(pedido.effort)}`);
+    args.push(pedido.prompt);
+    return ['codex', ...args];
+}
+/** Extrai o `thread_id` do evento `thread.started` do stream JSONL. */
+function extrairThreadId(saida) {
+    for (const linha of saida.split('\n')) {
+        if (!linha.includes('thread.started'))
+            continue;
+        try {
+            const evento = JSON.parse(linha);
+            if (evento.type === 'thread.started' && typeof evento.thread_id === 'string') {
+                return evento.thread_id;
+            }
+        }
+        catch {
+            /* linha parcial ainda sendo escrita nao invalida a espera */
+        }
+    }
+    return null;
+}
+/**
+ * Procura o rollout da sessao no estado do proprio Codex.
+ *
+ * O Codex grava `sessions/AAAA/MM/DD/rollout-<ts>-<thread_id>.jsonl` (medido na 0.153.4).
+ * So os dias mais recentes sao varridos: um despacho de agora nao mora num rollout de
+ * semanas atras, e varrer o historico inteiro pune quem usa o runtime ha meses.
+ */
+function acharRollout(threadId, dias = 3, casa = casaDoCodex()) {
+    const raiz = path.join(casa, 'sessions');
+    if (!fs.existsSync(raiz))
+        return null;
+    const diasRecentes = [];
+    const anos = fs.readdirSync(raiz).sort().reverse();
+    for (const ano of anos) {
+        const dirAno = path.join(raiz, ano);
+        if (!fs.statSync(dirAno).isDirectory())
+            continue;
+        for (const mes of fs.readdirSync(dirAno).sort().reverse()) {
+            const dirMes = path.join(dirAno, mes);
+            if (!fs.statSync(dirMes).isDirectory())
+                continue;
+            for (const dia of fs.readdirSync(dirMes).sort().reverse()) {
+                diasRecentes.push(path.join(dirMes, dia));
+                if (diasRecentes.length >= dias)
+                    break;
+            }
+            if (diasRecentes.length >= dias)
+                break;
+        }
+        if (diasRecentes.length >= dias)
+            break;
+    }
+    for (const dir of diasRecentes) {
+        if (!fs.statSync(dir).isDirectory())
+            continue;
+        const achado = fs.readdirSync(dir).find((f) => f.startsWith('rollout-') && f.endsWith(`-${threadId}.jsonl`));
+        if (achado)
+            return path.join(dir, achado);
+    }
+    return null;
+}
+/**
+ * Rate limit na saida real do Codex.
+ *
+ * Reusa o reconhecimento do claude-bg (frases genericas + horario de reset) e acrescenta
+ * as frases proprias do plano ChatGPT. Frase reconhecida sem horario volta `sem-horario`:
+ * a janela padrao e decisao da fila do B3, nunca chute do adapter.
+ */
+const FRASES_DO_CODEX = [
+    /hit your usage limit/i,
+    /usage limit(?:s)? (?:reached|exceeded)/i,
+    /plan limit/i,
+];
+function parseRateLimitCodex(saida, agoraMs = Date.now()) {
+    const generico = (0, claude_bg_1.parseRateLimit)(saida, agoraMs);
+    if (generico)
+        return generico;
+    const frase = FRASES_DO_CODEX.find((r) => r.test(saida ?? ''));
+    if (!frase)
+        return null;
+    const linha = (saida ?? '').split('\n').find((l) => frase.test(l)) ?? saida;
+    return { resetEm: null, fonte: 'sem-horario', trecho: linha.trim().slice(0, 200) };
+}
+/** Despacho governado exige vínculo: nenhum fallback implícito para codex exec. */
+function despachar(pedido) {
+    if (!pedido.vinculo)
+        return { ok: false, comando: [], sessionId: null, verificada: false, stdout: '', stderr: '',
+            erro: 'runtime.unavailable: despacho Codex exige vínculo de thread/fase/prompt; transporte legado recusado' };
+    if (pedido.contextoRuntime) {
+        try {
+            if (pedido.contextoRuntime.host !== 'codex')
+                throw Error('runtime.context.invalid: host Codex esperado');
+            if (pedido.contextoRuntime.threadId !== pedido.vinculo.thread)
+                throw Error('runtime.context.scope: thread do contexto difere do despacho');
+            (0, runtime_context_1.validarContextoRuntime)(pedido.contextoRuntime, pedido.cwd);
+        }
+        catch (e) {
+            return { ok: false, comando: [], sessionId: null, verificada: false, stdout: '', stderr: '', erro: e.message };
+        }
+    }
+    let ambiente;
+    try {
+        ambiente = { ...ambienteDoDespacho(process.env, pedido.perfil), ...(pedido.ambienteExtra ?? {}) };
+    }
+    catch (e) {
+        return { ok: false, comando: [], sessionId: null, verificada: false, stdout: '', stderr: '', erro: e.message };
+    }
+    const r = (0, codex_controller_1.despacharComController)(pedido, ambiente);
+    if (r.ok)
+        return r;
+    // I-33 (D1): o incidente de 18/09 ("Your workspace is out of credits", usage_limit_exceeded)
+    // deixa de ser `runtime.unavailable` generico quando a frase aparece na falha do despacho.
+    const falhaDeConta = (0, claude_bg_1.parseFalhaDeConta)([r.erro ?? '', r.stderr].join('\n'));
+    return falhaDeConta ? { ...r, falhaDeConta, erro: `${falhaDeConta.motivo}: ${falhaDeConta.trecho}` } : r;
+}
+/** Le os eventos ja escritos no log de um despacho (texto cru do stream `--json`). */
+function logs(logPath, linhas = 60) {
+    if (!fs.existsSync(logPath))
+        return { ok: false, texto: `log nao encontrado: ${logPath}` };
+    const uteis = fs
+        .readFileSync(logPath, 'utf8')
+        .split('\n')
+        .filter((l) => l.trim() !== '');
+    return { ok: true, texto: uteis.slice(-linhas).join('\n') };
+}

package/dist/agents-md.js

@@ -0,0 +1,84 @@
+"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.FIM_AGENTS_ORK = exports.INICIO_AGENTS_ORK = void 0;
+exports.blocoAgentsMd = blocoAgentsMd;
+exports.atualizarAgentsMd = atualizarAgentsMd;
+/** Bloco de instrucoes do Orkastery em AGENTS.md, preservando todo texto humano. */
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const util_1 = require("./util");
+exports.INICIO_AGENTS_ORK = '<!-- orkastery:begin -->';
+exports.FIM_AGENTS_ORK = '<!-- orkastery:end -->';
+function seguro(valor) {
+    return valor.replace(/[\r\n\0`]+/g, ' ').trim();
+}
+function blocoAgentsMd(manifesto) {
+    const comandos = Object.entries(manifesto.verify)
+        .filter((item) => typeof item[1] === 'string' && item[1].trim() !== '')
+        .map(([nome, comando]) => `- ${seguro(nome)}: \`${seguro(comando)}\``);
+    return `${exports.INICIO_AGENTS_ORK}
+## Orkastery
+
+Projeto: **${seguro(manifesto.project.name)}** (${seguro(manifesto.project.abbrev)}). Branch base: \`${seguro(manifesto.worktree.base_branch)}\`.
+
+- Comece com \`ork doctor\`, \`ork onboarding\` e \`ork thread status <thread>\`.
+- Conduza o ciclo GOAL → PLAN → GO → CHECK → SHIP → MASTER pelo \`ork\`.
+- Respeite o modo da thread: ${manifesto.conduction.allowed_modes.map(m => `#${m[0].toUpperCase()}${m.slice(1)}`).join(', ')}.
+- Edite produto somente na worktree vinculada; estado em \`.orkastery/\` pertence ao núcleo.
+- PLAN não implementa. GO usa commits atômicos. CHECK não corrige. SHIP acontece por \`ork ship\`.
+- Toda alegação exige claim e comando reproduzível; self-report não é evidência.
+${comandos.length ? `\nVerificações do manifesto:\n\n${comandos.join('\n')}\n` : ''}
+Este bloco é mantido por \`ork init\`. Edite livremente o restante do arquivo.
+${exports.FIM_AGENTS_ORK}`;
+}
+/** Cria ou substitui somente o bloco delimitado. Marcadores ambiguos recusam sem escrita. */
+function atualizarAgentsMd(raiz, manifesto) {
+    const caminho = path.join(raiz, 'AGENTS.md');
+    const anterior = fs.existsSync(caminho) ? fs.readFileSync(caminho, 'utf8') : '';
+    const inicios = anterior.split(exports.INICIO_AGENTS_ORK).length - 1;
+    const fins = anterior.split(exports.FIM_AGENTS_ORK).length - 1;
+    if (inicios !== fins || inicios > 1 || (inicios === 1 && anterior.indexOf(exports.INICIO_AGENTS_ORK) > anterior.indexOf(exports.FIM_AGENTS_ORK))) {
+        throw new Error('AGENTS.md possui marcadores Orkastery ambiguos; corrija o bloco antes de rodar ork init');
+    }
+    const bloco = blocoAgentsMd(manifesto);
+    const proximo = inicios === 1
+        ? anterior.slice(0, anterior.indexOf(exports.INICIO_AGENTS_ORK)) + bloco + anterior.slice(anterior.indexOf(exports.FIM_AGENTS_ORK) + exports.FIM_AGENTS_ORK.length)
+        : anterior === '' ? bloco + '\n' : anterior + (anterior.endsWith('\n') ? '\n' : '\n\n') + bloco + '\n';
+    if (proximo === anterior)
+        return { caminho, estado: 'inalterado' };
+    (0, util_1.gravar)(caminho, proximo);
+    return { caminho, estado: anterior === '' ? 'criado' : 'atualizado' };
+}

package/dist/auditoria.js

@@ -77,6 +77,7 @@ const path = __importStar(require("node:path"));
 const gates_1 = require("./gates");
 const prompts_1 = require("./prompts");
 const util_1 = require("./util");
+const horario_1 = require("./horario");
 // ---------------------------------------------------------------------------
 // Motivos tipados da auditoria
 // ---------------------------------------------------------------------------
@@ -409,7 +410,7 @@ exports.PACKS = {
         id: 'process',
         titulo: 'Processo (meta-auditor)',
         objetivo: 'O unico pack que audita o METODO e nao o produto: le o ledger, os POSTMORTEMs e os MASTER logs e propoe mudanca no proprio Orkastery.',
-        estagioMinimo: 'maduro',
+        estagioMinimo: 'nascente',
         fonte: 'ledger',
         referencias: ['references/definition-of-done.md'],
         evidencias: [
@@ -425,7 +426,7 @@ exports.PACKS = {
             {
                 id: 'PR2',
                 regra: 'Thread entregue sem score humano registrado, parada na fila de batch.',
-                evidencia: 'o thread.json com score null e o ship_done correspondente',
+                evidencia: 'thread entregue sem master_done.por humano correspondente ao score',
             },
             {
                 id: 'PR3',
@@ -545,9 +546,11 @@ function minutosDoHorario(bruto) {
  * governando o custo daquela rodada.
  */
 function janelaDeCusto(manifesto, quando = new Date()) {
-    const hh = String(quando.getHours()).padStart(2, '0');
-    const mm = String(quando.getMinutes()).padStart(2, '0');
-    const agora = `${hh}:${mm}`;
+    // I-35: a janela e o "agora" sao do fuso do dono; sem owner.timezone, o do sistema (como antes).
+    const fuso = (0, horario_1.lerFusoDoDono)(manifesto.owner?.timezone).fuso;
+    const local = (0, horario_1.partesLocais)(quando, fuso);
+    const agora = `${local.hora}:${local.minuto}`;
+    const rotulo = (0, horario_1.rotuloDoFuso)(fuso, quando);
     const bruta = (manifesto.audit?.janela_ociosa ?? '').trim();
     if (bruta === '') {
         return {
@@ -572,7 +575,7 @@ function janelaDeCusto(manifesto, quando = new Date()) {
             detalhe: `audit.janela_ociosa invalida ("${bruta}"): esperado HH:MM-HH:MM`,
         };
     }
-    const minutosAgora = quando.getHours() * 60 + quando.getMinutes();
+    const minutosAgora = Number(local.hora) * 60 + Number(local.minuto);
     const dentro = inicio <= fim
         ? minutosAgora >= inicio && minutosAgora < fim
         : minutosAgora >= inicio || minutosAgora < fim;
@@ -583,8 +586,8 @@ function janelaDeCusto(manifesto, quando = new Date()) {
         dentro,
         agora,
         detalhe: dentro
-            ? `${agora} esta dentro da janela ociosa ${bruta}`
-            : `${agora} esta FORA da janela ociosa ${bruta}`,
+            ? `${agora} (${rotulo}) esta dentro da janela ociosa ${bruta}`
+            : `${agora} (${rotulo}) esta FORA da janela ociosa ${bruta}`,
     };
 }
 /** O Graphify existe nesta maquina? Fonte externa, nunca suposicao. */

package/dist/auditrun.js

@@ -84,6 +84,7 @@ const superficie_1 = require("./superficie");
 const thread_1 = require("./thread");
 const util_1 = require("./util");
 const verify_1 = require("./verify");
+const horario_1 = require("./horario");
 /** Versao do formato de `run.json`. */
 exports.VERSAO_DA_RODADA = 1;
 /** Diretorio das rodadas de auditoria do projeto. */
@@ -708,7 +709,7 @@ function relatorioDaRodada(carregado, rodadaId, opcoes = {}) {
     else {
         const v = rodada.veredito;
         L.push(`- HEAD real: ${v.commit}`);
-        L.push(`- verificado em: ${v.verificadoEm}`);
+        L.push(`- verificado em: ${(0, horario_1.formatarDataHoraRotulada)(v.verificadoEm)}`);
         L.push(`- veredito: ${v.ok ? 'ACHADOS SUSTENTADOS' : 'REPROVADO'}`);
         L.push(`- motivos tipados: ${v.motivos.length > 0 ? v.motivos.join(', ') : '(nenhum)'}`);
         L.push('');
@@ -831,10 +832,10 @@ function tabelaDoLedgerDaRodada(raiz, id) {
         if (e.thread && e.thread !== id)
             detalhe.push(`thread ${String(e.thread)}`);
         if (e.detalhe)
-            detalhe.push(String(e.detalhe).slice(0, 90));
-        return [e.ts.replace('T', ' ').slice(0, 19), e.tipo, detalhe.join(' | ')];
+            detalhe.push((0, horario_1.localizarTexto)(String(e.detalhe)).slice(0, 90));
+        return [(0, horario_1.formatarDataHora)(e.ts, { segundos: true }), e.tipo, detalhe.join(' | ')];
     });
-    return (0, util_1.tabela)(['QUANDO', 'EVENTO', 'DETALHE'], linhas);
+    return `${(0, util_1.tabela)(['QUANDO', 'EVENTO', 'DETALHE'], linhas)}\n${(0, horario_1.legendaDoFuso)()}`;
 }
 /** Quantos achados abertos existem por pack, para o resumo do CLI. */
 function resumoDoBoard(raiz) {