@orkastery/cli 0.2.0 → 0.3.0

package/dist/pulse.js

@@ -0,0 +1,262 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JANELA_DAS_DECISOES_MS = exports.CONTRATO_PULSE = void 0;
+exports.comporPulse = comporPulse;
+exports.montarPulse = montarPulse;
+exports.textoDoPulse = textoDoPulse;
+const escopo_escrita_1 = require("./escopo-escrita");
+/** D4: uma fila para quem precisa de humano, com fontes e espera observada. */
+const claude_bg_1 = require("./adapters/claude-bg");
+const hitl_1 = require("./hitl");
+const liveness_1 = require("./liveness");
+const master_1 = require("./master");
+const master_batch_1 = require("./master-batch");
+const orquestracao_1 = require("./orquestracao");
+const thread_1 = require("./thread");
+const sessoes_adopt_1 = require("./sessoes-adopt");
+const ledger_1 = require("./ledger");
+const types_1 = require("./types");
+const util_1 = require("./util");
+const horario_1 = require("./horario");
+const hitl_presentation_1 = require("./hitl-presentation");
+const hitl_contract_1 = require("./hitl-contract");
+const decisao_autonoma_1 = require("./decisao-autonoma");
+const docs_1 = require("./docs");
+const conducao_1 = require("./conducao");
+const conducao_texto_1 = require("./conducao-texto");
+exports.CONTRATO_PULSE = 'ork.pulse/v1';
+/** Uma semana: o resumo cita a decisao uma vez, e ela continua lida ate sair da janela. */
+exports.JANELA_DAS_DECISOES_MS = 7 * 24 * 60 * 60 * 1000;
+const impacto = (fase) => types_1.FASES.indexOf(fase) + 1;
+const ordenar = (a, b) => (b.paradaHaMin ?? -1) - (a.paradaHaMin ?? -1) || b.impacto - a.impacto || a.id.localeCompare(b.id);
+const minutos = (desde, quando) => desde && Number.isFinite(Date.parse(desde)) ? Math.max(0, Math.floor((Date.parse(quando) - Date.parse(desde)) / 60000)) : null;
+function comporPulse(carregado, entrada) {
+    const { radar, monitor, batch, orfas } = entrada, quando = radar.consultadoEm;
+    const humanos = [], automaticas = [];
+    const registros = new Map();
+    const ehRegistro = (id) => {
+        if (!id)
+            return false;
+        if (!registros.has(id)) {
+            try {
+                registros.set(id, (0, sessoes_adopt_1.ehRegistroDeAdocao)((0, thread_1.lerThread)(carregado.raiz, id)));
+            }
+            catch {
+                registros.set(id, false);
+            } // Não esconder atenção sem confirmar proveniência.
+        }
+        return registros.get(id);
+    };
+    // I-45: so pede o dono quem pode receber resposta. Em 24/09/2026 a fila tinha 92 itens e 2 eram
+    // do dono: o resto era sessao morta, de thread fechada ou sem thread, que ninguem pode responder.
+    const statusDaThread = new Map();
+    const threadAberta = (id) => {
+        if (!id)
+            return false;
+        if (!statusDaThread.has(id)) {
+            try {
+                statusDaThread.set(id, (0, thread_1.lerThread)(carregado.raiz, id).status);
+            }
+            catch {
+                statusDaThread.set(id, null);
+            } // Thread ilegivel nao prova fechamento: fica visivel.
+        }
+        return statusDaThread.get(id) !== 'fechada';
+    };
+    const TERMINAIS = ['failed', 'done', 'stopped', 'completed'];
+    for (const s of radar.sessoes.filter(s => s.precisaDeHumano)) {
+        // Job morto ou estado terminal é história. Bloqueio vivo ou desconhecido continua visível.
+        if (ehRegistro(s.thread?.id ?? null) && s.jobVivo !== true &&
+            (s.jobVivo === false || TERMINAIS.includes(s.estadoBruto)))
+            continue;
+        const semThread = !s.thread?.id, aberta = threadAberta(s.thread?.id ?? null);
+        const encerrada = s.jobVivo !== true && (s.jobVivo === false || TERMINAIS.includes(s.estadoBruto));
+        // Morta ou terminal, sem thread ou de thread fechada: historia, ninguem para responder.
+        if (encerrada && !aberta)
+            continue;
+        // Incerta de thread fechada tambem e historia. Incerta SEM thread continua visivel: pode ser
+        // uma sessao do proprio dono esperando resposta (o alerta I-01, fixado no fx-hitl-latency).
+        if (s.jobVivo !== true && !encerrada && !aberta && !semThread)
+            continue;
+        // Thread aberta com sessao morta ou terminal: quem resolve e o retry de orfas, nao o dono.
+        const destino = encerrada ? automaticas : humanos;
+        destino.push({ id: `sessao:${s.sessionId || s.id}`, classe: s.classe, motivo: s.tipoDeHitl ?? s.classe,
+            thread: s.thread?.id ?? null, fase: s.thread?.fase ?? null, sessionId: s.sessionId,
+            desdeEm: s.bloqueadaDesdeEm ?? null, paradaHaMin: s.paradaHaMin ?? null, impacto: impacto(s.thread?.fase ?? null),
+            pergunta: s.pergunta || s.detalhe, opcoes: s.alternativas, recomendacao: s.recomendacao,
+            comandoResposta: s.classe === 'abandonada' ? s.comandos.logs : s.comandos.attach,
+            evidencia: [`claude agents: state=${s.estadoBruto}`, s.comandos.logs], fontes: ['sessions hitl'], contextoLogs: s.contextoLogs ?? [] });
+    }
+    // I-45: verificacao reprovada de uma candidata cujo codigo ja esta na base nao e pendencia do
+    // dono: o CHECK independente decidiu e o merge aconteceu. Vale o primeiro merge (regra do `ork docs`).
+    const base = (0, docs_1.resolverBase)(carregado.raiz, carregado.manifesto.worktree?.base_branch ?? 'main');
+    const mesclada = new Map();
+    const jaMesclada = (thread) => {
+        if (!base)
+            return false;
+        if (!mesclada.has(thread)) {
+            try {
+                mesclada.set(thread, (0, docs_1.mergeDaThread)(carregado.raiz, thread, base) !== null);
+            }
+            catch {
+                mesclada.set(thread, false);
+            }
+        }
+        return mesclada.get(thread);
+    };
+    const VERIFICACAO = ['claims.failed', 'claims.unverifiable', 'verify.failed', 'verify.regression', 'verify.timeout', 'verify.sem-veredito', 'ci.failed'];
+    for (const l of monitor.linhas)
+        for (const p of l.paradas) {
+            if (VERIFICACAO.includes(p.motivo) && jaMesclada(l.thread))
+                continue;
+            if (ehRegistro(l.thread)) {
+                if (p.fonte === 'escalonador' || ['lease.busy', 'conducao.em-andamento', 'concurrency.limite', 'vaga.stale', 'runtime.silencio'].includes(p.motivo))
+                    continue;
+                const sessoes = radar.sessoes.filter(s => s.thread?.id === l.thread && s.thread.fase === p.fase);
+                // Escalada explícita de ledger não é apagada pela conclusão de uma sessão.
+                if (p.fonte !== 'ledger' && sessoes.length > 0 && sessoes.every(s => s.jobVivo !== true &&
+                    (s.jobVivo === false || ['failed', 'done', 'stopped', 'completed'].includes(s.estadoBruto))))
+                    continue;
+            }
+            if (p.sessaoViva === true)
+                continue;
+            if (orfas.some(o => o.thread === l.thread && o.fase === p.fase) &&
+                ['runtime.silencio', 'vaga.stale'].includes(p.motivo))
+                continue;
+            const mesmaEspera = humanos.find(s => s.thread === l.thread && s.fase === p.fase &&
+                p.sessaoEstado === 'blocked' && !!s.sessionId && p.evidencia.includes(s.sessionId.slice(0, 8)));
+            if (mesmaEspera) {
+                mesmaEspera.fontes.push('monitor');
+                mesmaEspera.evidencia.push(p.evidencia);
+                continue;
+            }
+            const item = { id: `thread:${l.thread}:${p.fase}:${p.motivo}:${p.fonte}`, classe: 'thread', motivo: p.motivo,
+                thread: l.thread, fase: p.fase, sessionId: null, desdeEm: p.desdeEm, paradaHaMin: p.paradaHaMin, impacto: impacto(p.fase),
+                pergunta: p.detalhe, opcoes: [], recomendacao: p.correcao, comandoResposta: p.correcao, evidencia: [p.evidencia],
+                fontes: ['monitor'], contextoLogs: [] };
+            // I-45: vaga parada e sinal do escalonador (`ork board reap` devolve a vaga), nao pergunta ao dono.
+            const esperaAutomatica = ['lease.busy', 'conducao.em-andamento', 'concurrency.limite', 'runtime.rate-limited', 'vaga.stale'].includes(p.motivo);
+            (esperaAutomatica ? automaticas : humanos).push(item);
+        }
+    for (const b of batch) {
+        const eventos = (0, ledger_1.lerLedger)((0, thread_1.dirThread)(carregado.raiz, b.thread.id));
+        const desde = eventos.filter(e => e.tipo === 'ship_done').at(-1)?.ts ??
+            eventos.filter(e => e.tipo === 'phase_result' && e.fase === 'MASTER').at(-1)?.ts ?? b.thread.atualizadaEm;
+        const proposta = b.thread.score_proposto;
+        const respostas = proposta && b.entregou ? master_1.ORDEM_DAS_CLASSES.map(c => `ratificar ${b.thread.id} ${(0, master_batch_1.assinaturaProposta)(proposta)} ${c}`) : [];
+        // I-45: a fila de nota foi aposentada na I-43. A entrega sem nota e aceita por padrao, com
+        // registro; ela sai da atencao do dono e fica na faixa automatica. A nota humana, quando vier,
+        // continua sobrescrevendo, e as respostas de ratificacao seguem no item.
+        automaticas.push({ id: `score:${b.thread.id}`, classe: 'score_pendente', motivo: 'master.score-pendente', thread: b.thread.id,
+            fase: 'MASTER', sessionId: null, desdeEm: desde, paradaHaMin: minutos(desde, quando), impacto: impacto('MASTER'),
+            pergunta: proposta ? `Proposta para ${b.thread.nome}: ${proposta.valor}/5. ${proposta.justificativa}` : `Entrega ${b.thread.nome} sem nota: aceita por padrão, com registro.`,
+            opcoes: respostas.length ? respostas : ['0', '1', '2', '3', '4', '5'],
+            recomendacao: 'Aceitar por padrão com registro; a nota humana, quando vier, sobrescreve.',
+            comandoResposta: 'ork master --aceitar-omissao',
+            evidencia: [`ork master; regime ${b.regime}`], fontes: ['master'], contextoLogs: [] });
+    }
+    for (const o of orfas) {
+        if (ehRegistro(o.thread))
+            continue;
+        const item = { id: `orfa:${o.thread}:${o.fase}:${o.sessionId}`, classe: o.classe, motivo: o.motivo,
+            thread: o.thread, fase: o.fase, sessionId: o.sessionId, desdeEm: o.desdeEm, paradaHaMin: minutos(o.desdeEm, quando),
+            impacto: impacto(o.fase), pergunta: `Fase ${o.fase} sem heartbeat desde ${o.ultimoHeartbeatEm}.`,
+            opcoes: [], recomendacao: o.retry.razao,
+            comandoResposta: o.retry.automatica ? `ork retry run ${o.thread} --motivo runtime.silencio --fase ${o.fase}` :
+                `ork retry plan ${o.thread} --motivo runtime.silencio --fase ${o.fase}`,
+            evidencia: [...o.evidencia, `retry ${o.retry.tentativas}/${o.retry.limite}`], fontes: ['liveness'], contextoLogs: [] };
+        (o.retry.automatica ? automaticas : humanos).push(item);
+    }
+    const unicos = (items) => [...new Map(items.map(i => [i.id, i])).values()].sort(ordenar);
+    const h = unicos(humanos), a = unicos(automaticas);
+    for (const item of h) {
+        if (!item.thread || item.classe === 'score_pendente')
+            continue;
+        try {
+            // T6: o pedido vem primeiro, porque e ele quem diz quanta evidencia esta pergunta merece.
+            // Sem pedido aberto, `apresentarHitl` cai no default do modo, como sempre fez.
+            const pedido = (0, hitl_presentation_1.pedidoHitlAberto)(carregado.raiz, item.thread, item.fase, item.sessionId);
+            item.apresentacao = (0, hitl_presentation_1.apresentarHitl)(carregado.raiz, item.thread, pedido?.profundidade);
+            if (pedido) {
+                // I-41 (T4b): o pulse le o pedido pelos leitores uniformes, e o que muda para o dono e a
+                // CHAVE que ele digita: numero no v1, letra no v2. `pedidoHitlAberto` ja descartou
+                // `decidido`, que nao tem alvo; e por isso que existe alvo para ler aqui.
+                item.pedido = pedido;
+                item.pergunta = (0, hitl_contract_1.textoDoPedido)(pedido);
+                item.opcoes = (0, hitl_contract_1.escolhasDoPedido)(pedido).map(o => `${(0, hitl_contract_1.chaveDaEscolha)(pedido, o.numero)}. ${o.texto}`);
+                item.recomendacao = (0, hitl_contract_1.recomendacaoDoPedido)(pedido);
+                item.comandoResposta = `/ork ${(0, hitl_contract_1.alvoDoPedido)(pedido)?.tipo === 'session' ? 'session' : 'gate'} ${pedido.thread} ${pedido.id} <resposta>`;
+                // O Pulse nao e uma conexao MCP: nenhum canal mcp-local sai `disponivel` daqui.
+                item.canais = (0, hitl_presentation_1.ofertaDoPedido)(pedido);
+            }
+        }
+        catch {
+            item.evidencia.push('Apresentação indisponível; conferir estado canônico da thread.');
+        }
+    }
+    return { contrato: exports.CONTRATO_PULSE, consultadoEm: quando, runtime: { ok: radar.runtimeConsultado, detalhe: radar.runtimeDetalhe },
+        precisaDeHumanoAgora: h, acoesAutomaticas: a, resumo: { humanos: h.length, automaticas: a.length, scores: batch.length, fasesOrfas: orfas.length } };
+}
+function montarPulse(carregado, opcoes = {}) {
+    if (opcoes.registrar)
+        (0, escopo_escrita_1.exigirEscopoDeEscrita)(opcoes.escopo);
+    const diagnosticos = [];
+    const quando = opcoes.quando ?? (0, util_1.agora)();
+    const consulta = opcoes.consulta ?? (opcoes.semRuntime
+        ? { ok: false, sessoes: [], detalhe: 'runtime não consultado por --sem-runtime' } : (0, claude_bg_1.consultarSessoes)(undefined, true));
+    const estados = consulta.ok ? new Map(consulta.sessoes.map(s => [s.sessionId ?? '', (0, hitl_1.estadoBruto)(s)])) : null;
+    const radar = (0, hitl_1.varrerSessoes)({ raiz: carregado.raiz, consulta, agora: quando, registrar: opcoes.registrar, escopo: opcoes.escopo, linhasLogs: opcoes.linhasLogs });
+    if (radar.telasAdiadas)
+        diagnosticos.push(`radar.orcamento: ${radar.telasAdiadas} tela(s) de sessão ficaram para a próxima varredura`);
+    // Falha de observação não prova silêncio: Claude indisponível preserva sua guarda de HITL e Codex mantém sua coleta independente.
+    const orfas = (0, liveness_1.detectarFasesOrfas)(carregado, { quando, registrar: opcoes.registrar, escopo: opcoes.escopo, diagnosticos,
+        fontes: opcoes.fontes, estados: estados ?? undefined, runtimes: consulta.ok ? undefined : ['codex'] });
+    // I-36 (T16): conducao sem dono vivo sai aqui, com prova no ledger, so dentro do escopo de escrita.
+    if (opcoes.registrar)
+        for (const id of opcoes.escopo ?? []) {
+            try {
+                (0, conducao_1.liberarSeOrfa)(carregado.raiz, id);
+            }
+            catch (e) {
+                diagnosticos.push(`conducao.recuperacao: ${id}: ${e.message.slice(0, 120)}`);
+            }
+        }
+    const monitor = (0, orquestracao_1.montarMonitor)(carregado, { agora: quando, estados });
+    const pulse = comporPulse(carregado, { radar, monitor, orfas, batch: (0, master_1.pendentesDeScore)(carregado.raiz) });
+    const conducoes = monitor.linhas.filter((l) => l.conducao).map((l) => ({ thread: l.thread, linha: (0, conducao_texto_1.linhaDeConducao)(l.conducao, { agora: quando }) }));
+    if (conducoes.length > 0)
+        pulse.conducoes = conducoes;
+    // B4: a metade que presta contas. Leitura pura; falhar aqui nunca derruba a fila de atencao.
+    try {
+        const { decisoes, acimaDoLimiar } = (0, decisao_autonoma_1.decisoesParaODono)(carregado.raiz, new Date(Date.parse(quando) - exports.JANELA_DAS_DECISOES_MS).toISOString());
+        pulse.decisoes = decisoes;
+        pulse.acimaDoLimiar = acimaDoLimiar;
+    }
+    catch (e) {
+        diagnosticos.push(`decisoes.indisponiveis: ${e.message.slice(0, 120)}`);
+    }
+    if (diagnosticos.length)
+        pulse.runtime.detalhe = [pulse.runtime.detalhe, ...diagnosticos].filter(Boolean).join('; ');
+    return pulse;
+}
+function textoDoPulse(p) {
+    // I-35: o pulse guarda ISO; o texto ao dono sai no fuso dele, rotulado no cabeçalho.
+    const local = (texto) => (0, horario_1.localizarTexto)(texto, { agora: p.consultadoEm });
+    const linhas = [`Pulse (${p.contrato}) ${(0, horario_1.formatarDataHoraRotulada)(p.consultadoEm, { agora: p.consultadoEm })}`, `Precisa de humano agora: ${p.resumo.humanos}`, `${p.resumo.scores} entrega(s) sem nota, aceitas por padrão com registro`];
+    if (p.runtime.ok && p.runtime.detalhe.includes('liveness.snapshot.invalid'))
+        linhas.push(`[diagnostico] ${local(p.runtime.detalhe)}`);
+    if (!p.runtime.ok)
+        linhas.push(`[consulta incompleta] ${local(p.runtime.detalhe)}`);
+    for (const i of p.precisaDeHumanoAgora) {
+        linhas.push('', `${i.thread ?? i.sessionId} [${i.classe}] ${i.paradaHaMin == null ? 'desconhecido' : i.paradaHaMin < 1 ? 'menos de 1' : i.paradaHaMin} min`, local(i.pergunta), ...i.opcoes.map(o => `  opção: ${o}`), `Recomendação: ${i.recomendacao}`, `Responder: ${i.comandoResposta}`, ...i.contextoLogs.map(l => `  log: ${l}`));
+    }
+    if (p.conducoes?.length) {
+        linhas.push('', `Conduzidas agora: ${p.conducoes.length}`);
+        for (const c of p.conducoes)
+            linhas.push(`${c.thread}: ${c.linha}`);
+    }
+    linhas.push('', `Ações automáticas pendentes: ${p.resumo.automaticas}`);
+    for (const i of p.acoesAutomaticas)
+        linhas.push(`${i.thread}: ${i.motivo}; ${i.comandoResposta}`);
+    return linhas.join('\n');
+}

package/dist/ratelimit.js

@@ -60,6 +60,8 @@ exports.caminhoDaFila = caminhoDaFila;
 exports.lerFilaDeRetomada = lerFilaDeRetomada;
 exports.janelaPadraoMs = janelaPadraoMs;
 exports.enfileirar = enfileirar;
+exports.prazoDaConta = prazoDaConta;
+exports.marcarContaDaFalha = marcarContaDaFalha;
 exports.gravarPedido = gravarPedido;
 exports.exigirPedido = exigirPedido;
 exports.aguardando = aguardando;
@@ -69,6 +71,8 @@ exports.tabelaDaFila = tabelaDaFila;
 const path = __importStar(require("node:path"));
 const manifest_1 = require("./manifest");
 const util_1 = require("./util");
+const horario_1 = require("./horario");
+const runtime_profiles_1 = require("./runtime-profiles");
 var claude_bg_1 = require("./adapters/claude-bg");
 Object.defineProperty(exports, "parseRateLimit", { enumerable: true, get: function () { return claude_bg_1.parseRateLimit; } });
 /** Diretorio de estado da autonomia do B3. */
@@ -81,6 +85,11 @@ function dirRetry(raiz) {
  * Fica no projeto, e nao na thread, porque o limite de uso e da ASSINATURA: uma fase de
  * outra thread que morre no mesmo minuto espera a mesma janela, e quem olha a fila
  * precisa ver as duas de uma vez.
+ *
+ * I-33 (P4, R3): com perfis, a assinatura deixa de ser uma so. A fila vira o ULTIMO recurso,
+ * quando nenhum perfil ativo resta em nenhum runtime da ordem de fallback, e o prazo e o menor
+ * `esgotadoAte` entre os perfis. O formato do `fila.jsonl` nao muda: o pedido so ganha campos
+ * opcionais (runtime, perfil e motivo), e pedido antigo continua legivel sem eles.
  */
 function caminhoDaFila(raiz) {
     return path.join(dirRetry(raiz), 'fila.jsonl');
@@ -123,10 +132,34 @@ function enfileirar(carregado, novo, agoraMs = Date.now()) {
         criadoEm: (0, util_1.agora)(),
         atualizadoEm: (0, util_1.agora)(),
         detalhe: novo.detalhe,
+        ...(novo.runtime !== undefined ? { runtime: novo.runtime } : {}),
+        ...(novo.perfil !== undefined ? { perfil: novo.perfil } : {}),
+        ...(novo.motivo !== undefined ? { motivo: novo.motivo } : {}),
     };
     (0, util_1.anexarJsonl)(caminhoDaFila(raiz), pedido);
     return pedido;
 }
+/**
+ * I-33 (D5): ate quando a conta sai do rodizio. Cota esgotada: a hora dita pelo runtime ou, sem
+ * ela, a janela padrao do manifesto (estimativa declarada, nunca chute). Auth ausente: sem prazo.
+ */
+function prazoDaConta(manifesto, falha, agoraMs = Date.now()) {
+    if (falha.motivo === 'runtime.auth-missing')
+        return null;
+    // A10: horario dito que ja passou nao devolve o perfil ao rodizio na hora: vale a janela padrao.
+    if (falha.resetEm !== null && Date.parse(falha.resetEm) > agoraMs)
+        return falha.resetEm;
+    return new Date(agoraMs + janelaPadraoMs(manifesto)).toISOString();
+}
+/** Marca no store o perfil que falhou pela conta. Sem perfil (ambiente do processo), nada a marcar. */
+function marcarContaDaFalha(carregado, perfil, falha, agoraMs = Date.now()) {
+    if (!perfil)
+        return null;
+    const esgotado = falha.motivo === 'runtime.quota-exhausted';
+    return (0, runtime_profiles_1.marcarFalhaDePerfil)(carregado.raiz, perfil.id, { estado: esgotado ? 'esgotado' : 'sem-auth',
+        esgotadoAte: prazoDaConta(carregado.manifesto, falha, agoraMs), motivo: falha.motivo, detalhe: falha.trecho,
+        em: new Date(agoraMs).toISOString() });
+}
 /** Regrava um pedido (append-only: a versao nova vence, o historico fica). */
 function gravarPedido(raiz, pedido) {
     const atualizado = { ...pedido, atualizadoEm: (0, util_1.agora)() };
@@ -170,10 +203,10 @@ function tabelaDaFila(raiz, quando = (0, util_1.agora)()) {
         p.thread,
         p.fase,
         p.estado,
-        p.liberaEm.replace('T', ' ').slice(0, 16),
+        (0, horario_1.formatarDataHora)(p.liberaEm, { agora: quando }),
         p.janelaEstimada ? `estimada (${p.sinal.fonte})` : `dita pelo runtime (${p.sinal.fonte})`,
         p.estado === 'aguardando' ? faltaPara(p, quando) : '',
         String(p.tentativas),
     ]);
-    return (0, util_1.tabela)(['ID', 'THREAD', 'FASE', 'ESTADO', 'LIBERA EM', 'ORIGEM DA HORA', 'FALTA', 'TENT'], linhas);
+    return (0, util_1.tabela)(['ID', 'THREAD', 'FASE', 'ESTADO', 'LIBERA EM', 'ORIGEM DA HORA', 'FALTA', 'TENT'], linhas) + `\n${(0, horario_1.legendaDoFuso)(undefined, quando)}`;
 }

package/dist/recall.js

@@ -61,6 +61,7 @@ exports.textoDoRecall = textoDoRecall;
 const fs = __importStar(require("node:fs"));
 const handoff_1 = require("./handoff");
 const ledger_1 = require("./ledger");
+const memoria_1 = require("./memoria");
 const orkmind_1 = require("./orkmind");
 const thread_1 = require("./thread");
 const util_1 = require("./util");
@@ -93,18 +94,62 @@ function naoResolvido(p, motivo, detalhe) {
         detalhe,
     };
 }
+/** O contexto da sessão não pode ser reutilizado para outra thread ou tenant. */
+function conferirEscopo(carregado, memoria, threadId) {
+    const escopo = memoria.leituraRestrita;
+    if (escopo && (escopo.thread !== threadId ||
+        escopo.tenant !== (0, memoria_1.tagsDoProjeto)(carregado.manifesto).project[0])) {
+        throw Error('memory.query.scope-conflict');
+    }
+}
+/** Somente códigos conhecidos atravessam a fronteira; detalhes do driver podem conter segredos. */
+function falhaDeConsulta(erro) {
+    const permitidos = new Set([
+        'memory.query.invalid', 'memory.query.unsupported', 'memory.query.window-saturated',
+        'memory.query.scope-conflict', 'memory.query.scope-violation', 'memory.query.response-invalid',
+        'memory.transport.interpreter', 'memory.transport.secret', 'memory.transport.bridge',
+        'memory.transport.timeout', 'memory.transport.spawn', 'memory.transport.failed',
+        'memory.transport.json', 'memory.transport.unavailable', 'memory.schema.absent',
+        'memory.legacy.provenance-collision', 'memory.prospective.marker-invalid',
+        'memory.native.schema-mismatch', 'cli.ausente',
+    ]);
+    const codigo = erro instanceof Error ? erro.message.split(':', 1)[0] : '';
+    return permitidos.has(codigo) ? codigo : 'memory.query.failed';
+}
 /**
  * Resolve UM ponteiro, escolhendo a via pelo regime efetivo.
  *
  * Preferencia pela memoria semantica quando ela existe e o ponteiro tem endereco; queda
  * para o arquivo quando ela nao existe, quando o endereco nao resolve ou quando o
- * ponteiro nunca teve endereco (todo handoff do regime `files`).
+ * ponteiro nunca teve endereco (todo handoff do regime `files`). No contexto restrito
+ * ativo, falha ou ausência semântica permanece explícita, sem queda silenciosa.
  */
 function resolverPonteiro(carregado, memoria, threadId, p) {
+    conferirEscopo(carregado, memoria, threadId);
+    const restrito = memoria.leituraRestrita !== undefined;
     if (memoria.ativo && p.orkmind) {
         const endereco = (0, orkmind_1.lerEndereco)(p.orkmind);
-        const entrada = endereco ? memoria.porId(endereco.colecao, endereco.id) : null;
-        if (entrada) {
+        if (restrito && !endereco)
+            return naoResolvido(p, 'nao-resolve', 'memory.query.invalid');
+        let entrada = null;
+        try {
+            entrada = endereco ? memoria.porId(endereco.colecao, endereco.id) : null;
+        }
+        catch (erro) {
+            if (restrito)
+                return naoResolvido(p, 'orkmind-indisponivel', falhaDeConsulta(erro));
+            // Compatibilidade da API de manutenção: queda dirigida para arquivo.
+        }
+        if (restrito && !entrada)
+            return naoResolvido(p, 'nao-resolve', 'memory.query.not-found');
+        if (restrito && entrada && (entrada.collection !== endereco.colecao ||
+            entrada.id !== endereco.id ||
+            !entrada.tags.situation?.includes((0, memoria_1.situacaoDaThread)(threadId)))) {
+            return naoResolvido(p, 'nao-resolve', 'memory.query.scope-violation');
+        }
+        const tenant = (0, memoria_1.tagsDoProjeto)(carregado.manifesto).project[0];
+        if (entrada && entrada.tags.project?.includes(tenant) &&
+            (entrada.collection !== 'handoff' || (0, memoria_1.threadDaEntrada)(entrada) === threadId)) {
             return {
                 id: p.id,
                 titulo: p.titulo,
@@ -121,6 +166,8 @@ function resolverPonteiro(carregado, memoria, threadId, p) {
                 detalhe: `orkmind://${entrada.collection}/${entrada.id}`,
             };
         }
+        if (restrito)
+            return naoResolvido(p, 'nao-resolve', 'memory.query.scope-violation');
     }
     try {
         const r = (0, handoff_1.recall)(carregado, threadId, p.location);
@@ -155,6 +202,7 @@ function resolverPonteiro(carregado, memoria, threadId, p) {
  * secao 6.1 da visao (rastreabilidade): nada some, nada entra sem hora marcada.
  */
 function recallDaThread(carregado, memoria, threadId, opcoes = {}) {
+    conferirEscopo(carregado, memoria, threadId);
     const { raiz } = carregado;
     // Thread inexistente e erro, nao lista vazia: o CLI precisa reprovar o id errado.
     (0, thread_1.lerThread)(raiz, threadId);
@@ -183,6 +231,35 @@ function recallDaThread(carregado, memoria, threadId, opcoes = {}) {
         else
             falhas.push(r);
     }
+    // Descoberta de handoffs destinados exatamente a esta fase. Referencias explicitas
+    // continuam obedecendo retrieve_when, inclusive para um handoff anterior.
+    if (memoria.ativo && momento && opcoes.id === undefined && !opcoes.todos && !opcoes.forcar) {
+        const fase = momento.trim().toUpperCase();
+        const tags = { project: (0, memoria_1.tagsDoProjeto)(carregado.manifesto).project,
+            skill: [fase], situation: [(0, memoria_1.situacaoDaThread)(threadId)] };
+        const vistos = new Set(resolvidos.map(r => r.orkmind));
+        try {
+            const entradas = memoria.buscar({ collection: 'handoff', tags }).filter(e => e.collection === 'handoff' && (0, memoria_1.threadDaEntrada)(e) === threadId &&
+                Object.entries(tags).every(([k, values]) => values.every(v => e.tags[k]?.includes(v))));
+            for (const e of entradas) {
+                const endereco = `orkmind://handoff/${e.id}`;
+                if (vistos.has(endereco))
+                    continue;
+                vistos.add(endereco);
+                resolvidos.push({ id: `memoria-${e.id}`, titulo: `Handoff destinado a ${fase}`,
+                    location: `${(0, memoria_1.arquivoDoHandoff)(e) ?? ''}#tudo`, orkmind: endereco,
+                    retrieve_when: fase, resolvido: true, motivo: 'ok', via: 'orkmind', conteudo: e.content,
+                    metodo: 'busca exata por tenant, thread e fase', sha256: String(e.metadata.sha256 ?? ''),
+                    intervalo: null, detalhe: endereco });
+            }
+        }
+        catch (erro) {
+            falhas.push({ id: 'memoria-busca', titulo: 'Descoberta de handoffs da fase', location: '',
+                orkmind: null, retrieve_when: fase, resolvido: false, motivo: 'orkmind-indisponivel', via: null,
+                conteudo: '', metodo: '', sha256: '', intervalo: null,
+                detalhe: `${memoria.leituraRestrita ? falhaDeConsulta(erro) : 'memory.transport.export'}: busca semantica falhou; resultado nao comprova colecao vazia` });
+        }
+    }
     if (opcoes.id !== undefined && resolvidos.length === 0 && falhas.length === 0 && adiados.length === 0) {
         throw new Error(`ponteiro "${opcoes.id}" nao existe no handoff da thread ${threadId} ` +
             `(ids: ${handoff.pointers.map((p) => p.id).join(', ') || 'nenhum'})`);

package/dist/redacao-saida.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LIMITE_DE_TESTES = exports.LIMITE_DO_TRECHO = void 0;
+exports.redigirSaida = redigirSaida;
+exports.testesQueCairam = testesQueCairam;
+/**
+ * I-37 (D9): a saida de um comando que falhou, pronta para ir ao ledger.
+ *
+ * O ledger e append-only e cresce para sempre, e ele viaja: CI, pulse, memoria. Por isso o
+ * trecho e curto (1024 caracteres, o fim da saida, onde o erro mora) e passa pela mesma
+ * disciplina que o nucleo ja aplica ao prompt: credencial em URL e redigida, e se qualquer
+ * padrao de segredo casar, o trecho inteiro e descartado. Relatorio que imprime o segredo e
+ * um segundo vazamento.
+ */
+const policies_1 = require("./policies");
+const redacao_url_1 = require("./redacao-url");
+exports.LIMITE_DO_TRECHO = 1024;
+exports.LIMITE_DE_TESTES = 10;
+const LIMITE_DO_NOME = 200;
+/** O trecho que vai ao ledger, ou o aviso de que ele foi omitido de proposito. */
+function redigirSaida(saida) {
+    const redigida = (0, redacao_url_1.redigirCredenciaisUrl)(saida.trim()).slice(-exports.LIMITE_DO_TRECHO);
+    const achado = (0, policies_1.procurarSegredos)(redigida)[0];
+    return achado ? `[trecho omitido: padrao ${achado.nome} casou]` : redigida;
+}
+/**
+ * Os testes que o runner reportou como reprovados, sem reexecutar nada.
+ *
+ * Reconhece a saida TAP do `node --test` (`not ok N - nome`, ignorando o sumario de arquivo
+ * quando ha subteste) e as linhas `FAIL <arquivo>` de jest e vitest. Ate 10 nomes.
+ */
+function testesQueCairam(saida) {
+    const nomes = [];
+    for (const linha of saida.split('\n')) {
+        const tap = /^\s*not ok \d+ - (.+?)\s*(?:#.*)?$/.exec(linha);
+        const fail = /^\s*(?:FAIL|✕|×)\s+(\S.*?)\s*$/.exec(linha);
+        const nome = (tap?.[1] ?? fail?.[1] ?? '').trim();
+        if (!nome || nomes.includes(nome))
+            continue;
+        nomes.push(nome.slice(0, LIMITE_DO_NOME));
+        if (nomes.length === exports.LIMITE_DE_TESTES)
+            break;
+    }
+    return nomes;
+}

package/dist/redacao-url.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.redigirCredenciaisUrl = redigirCredenciaisUrl;
+/**
+ * Redacao de logs, inclusive userinfo malformado com /?# e varias arrobas.
+ * Cada delimitador :// e cada trecho sao percorridos uma vez: O(n) tempo/espaco.
+ * Userinfo candidato atravessa :// internos ate o ultimo @ do grupo. Esquemas
+ * colados sem separador podem ser senha: nesses casos a URL publica ambigua se
+ * perde. Espaco, delimitadores de citacao e , ; )( entre URLs encerram o grupo.
+ * URLs publicas sem login: antes de /?# preservam @ no caminho e na query.
+ */
+function redigirCredenciaisUrl(texto) {
+    const esquemas = [];
+    const delimitador = /:\/\//g;
+    const caractere = (c) => (c >= 65 && c <= 90) || (c >= 97 && c <= 122) ||
+        (c >= 48 && c <= 57) || c === 43 || c === 45 || c === 46;
+    for (let m; (m = delimitador.exec(texto));) {
+        let inicio = m.index;
+        while (inicio > 0 && caractere(texto.charCodeAt(inicio - 1)))
+            inicio--;
+        const c = texto.charCodeAt(inicio);
+        if ((c >= 65 && c <= 90) || (c >= 97 && c <= 122))
+            esquemas.push({ inicio, fim: m.index + 3 });
+    }
+    const partes = [];
+    let copiado = 0;
+    let inicioCredencial = null, ultimoAtDoGrupo = -1;
+    for (let n = 0; n < esquemas.length; n++) {
+        const { fim } = esquemas[n];
+        const limite = esquemas[n + 1]?.inicio ?? texto.length;
+        let ultimoAt = -1, primeiroAt = -1, separador = limite, colon = -1;
+        let terminouTexto = false;
+        for (let i = fim; i < limite; i++) {
+            const c = texto[i];
+            if (/\s|[<>"']/.test(c)) {
+                terminouTexto = true;
+                break;
+            }
+            if ('/?#'.includes(c) && separador === limite)
+                separador = i;
+            if (c === ':' && colon < 0)
+                colon = i;
+            if (c === '@') {
+                ultimoAt = i;
+                if (primeiroAt < 0)
+                    primeiroAt = i;
+            }
+        }
+        const credencial = primeiroAt >= fim && primeiroAt < separador || colon >= fim && colon < separador;
+        if (credencial)
+            inicioCredencial ??= fim;
+        if (ultimoAt >= fim)
+            ultimoAtDoGrupo = ultimoAt;
+        const separacaoExplicita = terminouTexto || /[,;)(]$/.test(texto.slice(Math.max(fim, limite - 1), limite));
+        if (separacaoExplicita || n + 1 === esquemas.length) {
+            if (inicioCredencial !== null && ultimoAtDoGrupo >= inicioCredencial) {
+                partes.push(texto.slice(copiado, inicioCredencial), '[credencial redigida]@');
+                copiado = ultimoAtDoGrupo + 1;
+            }
+            inicioCredencial = null;
+            ultimoAtDoGrupo = -1;
+        }
+    }
+    partes.push(texto.slice(copiado));
+    return partes.join('');
+}