@orkastery/cli 0.2.0 → 0.3.0

package/dist/adapters/claude-bg.js

@@ -8,39 +8,143 @@
  * O que vale: `claude --bg "<prompt>" --name <slug>` rodando com cwd no diretorio do projeto,
  * o que deixa a sessao visivel no app Claude e no `claude agents --json`.
  */
+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.NOME_ADAPTER = void 0;
+exports.JANELA_CURTA_MAX_MS = exports.NOME_ADAPTER = void 0;
+exports.ambienteDoPerfil = ambienteDoPerfil;
 exports.disponivel = disponivel;
 exports.versao = versao;
 exports.montarComando = montarComando;
 exports.extrairSessionId = extrairSessionId;
 exports.listarSessoes = listarSessoes;
+exports.consultarSessoes = consultarSessoes;
+exports.consultarAgentesNativos = consultarAgentesNativos;
 exports.acharSessao = acharSessao;
 exports.despachar = despachar;
 exports.parseRateLimit = parseRateLimit;
+exports.naturezaDoLimite = naturezaDoLimite;
+exports.parseFalhaDeConta = parseFalhaDeConta;
+exports.conferirAuth = conferirAuth;
 exports.comandoAttach = comandoAttach;
 exports.limparAnsi = limparAnsi;
 exports.logs = logs;
+exports.logsDaSessao = logsDaSessao;
 exports.parar = parar;
 exports.ocupacaoDeContexto = ocupacaoDeContexto;
 const util_1 = require("../util");
+const runtime_ambiente_1 = require("../runtime-ambiente");
+const path = __importStar(require("node:path"));
+const runtime_context_1 = require("../runtime-context");
+const runtime_profiles_1 = require("../runtime-profiles");
+function exec(cmd, args, cwd, timeoutMs, ambiente = (0, runtime_ambiente_1.ambienteDeAssinatura)()) {
+    return (0, util_1.exec)(cmd, args, cwd, timeoutMs, ambiente);
+}
+/**
+ * I-33 (D2): ambiente do filho com o `CLAUDE_CONFIG_DIR` do perfil sobre a assinatura
+ * higienizada (sem provider pago). Sem perfil, o ambiente do processo, como antes da I-33.
+ * A mesma conta despacha, reverifica, consulta, le logs e para a sessao.
+ */
+function ambienteDoPerfil(perfil) {
+    if (perfil && (perfil.runtime !== 'claude-bg' || !perfil.configDir))
+        throw new Error('runtime.profiles.invalid: perfil sem CLAUDE_CONFIG_DIR no despacho claude-bg');
+    return (0, runtime_profiles_1.ambienteComPerfil)((0, runtime_ambiente_1.ambienteDeAssinatura)(), perfil);
+}
 exports.NOME_ADAPTER = 'claude-bg';
+/** Consultas do perfil interactive; gates e respostas humanas nunca recebem grant. */
+const CONSULTAS_MCP = [
+    'mcp__orkastery__ork_thread_status',
+    'mcp__orkastery__ork_phase_list',
+    'mcp__orkastery__ork_hitl_pending',
+    'mcp__orkastery__ork_observe',
+    'mcp__orkastery__ork_artifact_read',
+    'mcp__orkastery__ork_claims_list',
+];
+const MUTACOES_WORKTREE = [
+    'mcp__orkastery__ork_artifact_write', 'mcp__orkastery__ork_claim_add',
+    'mcp__orkastery__ork_git_commit', 'mcp__orkastery__ork_verify', 'mcp__orkastery__ork_ship',
+];
+/** Regras nativas de arquivo, nao sandbox de processos. Edit tambem cobre Write. */
+function permissoesDaWorktree(cwd, permiteEditarProduto) {
+    if (!path.isAbsolute(cwd) || cwd === '/' || path.normalize(cwd) !== cwd || !/^[A-Za-z0-9_./-]+$/.test(cwd))
+        throw Error('runtime.context.permissions: worktree contem caracteres ambiguos para regras nativas; use caminho sem glob, espacos ou delimitadores');
+    const absoluto = '/' + cwd; // Claude exige // para caminho absoluto.
+    const deny = [];
+    for (const nome of ['.git', '.orkastery', '.claude', '.codex', '.agents', '.env', '.env*']) {
+        for (const prefixo of [`${absoluto}/${nome}`, `${absoluto}/**/${nome}`])
+            deny.push(`Edit(${prefixo})`, `Edit(${prefixo}/**)`);
+    }
+    return { allow: [...CONSULTAS_MCP, 'mcp__orkastery__ork_git_status', ...MUTACOES_WORKTREE, ...(permiteEditarProduto ? [`Edit(${absoluto}/**)`] : [])], deny };
+}
 /** O runtime esta disponivel nesta maquina? */
 function disponivel() {
     return (0, util_1.noPath)('claude');
 }
 /** Versao do runtime, para o `ork doctor`. */
 function versao() {
-    const r = (0, util_1.exec)('claude', ['--version'], undefined, 30000);
+    const r = exec('claude', ['--version'], undefined, 30000);
     return r.ok ? r.stdout.trim() : null;
 }
+/** Ferramentas de arquivo negadas no PLAN: o plano sai pelo núcleo, não pelo disco. */
+const ESCRITA_DE_ARQUIVO = ['Edit', 'Write', 'NotebookEdit'];
 /** Monta a linha de comando exata do despacho (usada tambem pelo `--dry-run`). */
 function montarComando(pedido) {
     const args = ['--bg', pedido.prompt, '--name', pedido.nome];
+    // I-34 (D6): plan mode em `--bg` desabilita ExitPlanMode, grava o plano em ~/.claude/plans
+    // e bloqueia ork_artifact_write. O PLAN roda como sessão comum, sem escrita de arquivo e
+    // com o artefato gravado pelo núcleo; o agente `ork-plan` não lista ferramentas MCP.
+    const plano = pedido.colaboracao === 'plan';
     if (pedido.model)
         args.push('--model', pedido.model);
     if (pedido.effort)
         args.push('--effort', pedido.effort);
+    if (pedido.contextoRuntime) {
+        if (pedido.contextoRuntime.host !== 'claude-code')
+            throw Error('runtime.context.invalid: host Claude esperado');
+        const contexto = (0, runtime_context_1.validarContextoRuntime)(pedido.contextoRuntime, pedido.cwd);
+        // Somente o servidor gerado: nao mesclar MCP de outros escopos nesta sessao filha.
+        const permissoes = contexto.permissoesFilho === 'worktree'
+            ? permissoesDaWorktree(pedido.cwd, contexto.permiteEditarProduto && !plano) : null;
+        // PLAN não implementa: nem commit, nem claim, nem verify, nem ship, em nenhum perfil.
+        const allow = plano ? [...CONSULTAS_MCP, 'mcp__orkastery__ork_artifact_write'] : permissoes?.allow ?? [...CONSULTAS_MCP];
+        const deny = [...(plano ? ESCRITA_DE_ARQUIVO : []), ...(permissoes?.deny ?? [])];
+        args.push('--plugin-dir', contexto.instalacao, '--strict-mcp-config', '--mcp-config', JSON.stringify({ mcpServers: { orkastery: contexto.servidor } }), '--allowedTools', allow.join(','));
+        if (deny.length)
+            args.push('--disallowedTools', deny.join(','));
+    }
+    else if (plano)
+        args.push('--disallowedTools', ESCRITA_DE_ARQUIVO.join(','));
     return ['claude', ...args];
 }
 /**
@@ -61,25 +165,81 @@ function extrairSessionId(saida) {
  * em 02/09/2026 na versao 2.1.259, `claude agents --json --cwd <raiz>` devolve lista
  * vazia mesmo com sessoes vivas naquele diretorio.
  */
-function listarSessoes(cwd, todas = false) {
+function listarSessoes(cwd, todas = false, ambiente = (0, runtime_ambiente_1.ambienteDeAssinatura)()) {
+    return consultarSessoes(cwd, todas, ambiente).sessoes;
+}
+/** Falha de consulta não pode ser confundida com uma máquina sem sessões. */
+function consultarSessoes(cwd, todas = false, ambiente = (0, runtime_ambiente_1.ambienteDeAssinatura)()) {
     const args = ['agents', '--json'];
     if (todas)
         args.push('--all');
-    const r = (0, util_1.exec)('claude', args, undefined, 60000);
+    const r = exec('claude', args, undefined, 60000, ambiente);
     if (!r.ok)
-        return [];
+        return { ok: false, sessoes: [], detalhe: `claude agents falhou (código ${r.code})` };
     let dados;
     try {
         const bruto = JSON.parse(r.stdout);
-        dados = Array.isArray(bruto) ? bruto : [];
+        if (!Array.isArray(bruto) || bruto.some(s => !s || typeof s !== 'object' ||
+            typeof s.sessionId !== 'string' || !/^[a-f0-9-]{8,}$/i.test(s.sessionId) ||
+            typeof s.cwd !== 'string' || !path.isAbsolute(s.cwd) ||
+            (s.state !== undefined && typeof s.state !== 'string') ||
+            (s.status !== undefined && typeof s.status !== 'string')) ||
+            new Set(bruto.map(s => s.sessionId)).size !== bruto.length)
+            throw new Error('formato inválido');
+        dados = bruto;
     }
     catch {
-        return [];
+        return { ok: false, sessoes: [], detalhe: 'claude agents respondeu JSON inválido' };
     }
     if (!cwd)
-        return dados;
+        return { ok: true, sessoes: dados, detalhe: '' };
     const raiz = cwd.replace(/\/$/, '');
-    return dados.filter((s) => s.cwd === raiz || (s.cwd ?? '').startsWith(raiz + '/'));
+    return { ok: true, sessoes: dados.filter((s) => s.cwd === raiz || (s.cwd ?? '').startsWith(raiz + '/')), detalhe: '' };
+}
+const UUID_CLAUDE = /^[0-9a-f]{8}(?:-[0-9a-f]{4}){3}-[0-9a-f]{12}$/i;
+const LIMITE_CONSULTA_BYTES = 1024 * 1024;
+/**
+ * I-34 (D5): fonte nativa da conclusão claude-bg. Sem `--cwd`: medido em 19/09/2026 na
+ * versão 2.1.278, `--cwd <worktree>` devolveu `[]` com a sessão viva ali. `--all` traz
+ * sessões de todos os projetos, então só `sessionId` UUID e `cwd` absoluto são exigidos por
+ * registro: campo de tipo inesperado vira ausente (estado ausente não conclui nada) e registro
+ * sem identidade é descartado. `sessionId` duplicado invalida a consulta inteira.
+ */
+function consultarAgentesNativos(agoraMs, ambiente = (0, runtime_ambiente_1.ambienteDeAssinatura)()) {
+    // I-33 (D4): o registro nativo e da conta; o observador passa o env do perfil da sessao.
+    const consultadoEm = new Date(agoraMs ?? Date.now()).toISOString();
+    const falha = (detalhe) => ({ ok: false, registros: [], detalhe, consultadoEm });
+    const r = exec('claude', ['agents', '--json', '--all'], undefined, 60000, ambiente);
+    if (!r.ok)
+        return falha(`claude agents falhou (código ${r.code})`);
+    if (Buffer.byteLength(r.stdout) > LIMITE_CONSULTA_BYTES)
+        return falha('claude agents excedeu 1 MiB');
+    const texto = (v) => typeof v === 'string' ? v : undefined;
+    let bruto;
+    try {
+        bruto = JSON.parse(r.stdout);
+    }
+    catch {
+        return falha('claude agents respondeu JSON inválido');
+    }
+    if (!Array.isArray(bruto))
+        return falha('claude agents respondeu JSON inválido');
+    const registros = [];
+    let descartados = 0;
+    for (const s of bruto) {
+        if (!s || typeof s !== 'object' || Array.isArray(s) || typeof s.sessionId !== 'string' || !UUID_CLAUDE.test(s.sessionId) ||
+            typeof s.cwd !== 'string' || !path.isAbsolute(s.cwd)) {
+            descartados++;
+            continue;
+        }
+        registros.push({ sessionId: s.sessionId, cwd: s.cwd, id: texto(s.id), name: texto(s.name), kind: texto(s.kind),
+            state: texto(s.state), status: texto(s.status),
+            pid: Number.isSafeInteger(s.pid) && s.pid > 0 ? s.pid : undefined,
+            startedAt: typeof s.startedAt === 'number' && Number.isFinite(s.startedAt) ? s.startedAt : undefined });
+    }
+    if (new Set(registros.map(s => s.sessionId)).size !== registros.length)
+        return falha('claude agents repetiu sessionId');
+    return { ok: true, registros, detalhe: descartados ? `${descartados} registro(s) sem identidade descartado(s)` : '', consultadoEm };
 }
 /** Procura uma sessao pelo id curto, id completo ou nome. */
 function acharSessao(chave, sessoes) {
@@ -94,6 +254,13 @@ function acharSessao(chave, sessoes) {
  */
 function despachar(pedido) {
     const comando = montarComando(pedido);
+    let ambiente;
+    try {
+        ambiente = { ...ambienteDoPerfil(pedido.perfil), ...(pedido.ambienteExtra ?? {}) };
+    }
+    catch (e) {
+        return { ok: false, comando, sessionId: null, verificada: false, stdout: '', stderr: '', erro: e.message };
+    }
     if (pedido.dryRun) {
         return { ok: true, comando, sessionId: null, verificada: false, stdout: '', stderr: '' };
     }
@@ -108,13 +275,19 @@ function despachar(pedido) {
             erro: 'binario `claude` nao encontrado no PATH',
         };
     }
-    const r = (0, util_1.exec)(comando[0], comando.slice(1), pedido.cwd, 180000);
+    const r = exec(comando[0], comando.slice(1), pedido.cwd, 180000, ambiente);
     const saida = r.stdout + '\n' + r.stderr;
     const sessionId = extrairSessionId(saida);
     if (!r.ok || !sessionId) {
         // Bloco B3: rate limit nao e "runtime indisponivel". Ele tem horario de reset, e por
         // isso volta tipado daqui para virar pedido na fila duravel em vez de falha seca.
-        const rateLimit = parseRateLimit(saida);
+        // I-33 (D1): falha da CONTA vem antes, porque e mais especifica e pede outro perfil.
+        // N6 (P8): sem perfil nada muda; o esgotamento que a leitura da baseline ja lia como rate limit
+        // ("Claude AI usage limit reached|<epoch>") segue direto para a fila do B3, como antes da I-33.
+        const lida = parseFalhaDeConta(saida);
+        const legado = parseRateLimit(saida);
+        const falhaDeConta = lida?.motivo === 'runtime.quota-exhausted' && !pedido.perfil && legado ? null : lida;
+        const rateLimit = falhaDeConta ? null : legado;
         return {
             ok: false,
             comando,
@@ -123,13 +296,18 @@ function despachar(pedido) {
             stdout: r.stdout,
             stderr: r.stderr,
             rateLimit,
-            erro: rateLimit
-                ? `limite de uso do runtime atingido: ${rateLimit.trecho}`
-                : `despacho falhou (code ${r.code})`,
+            falhaDeConta,
+            erro: falhaDeConta
+                ? `${falhaDeConta.motivo}: ${falhaDeConta.trecho}`
+                : rateLimit
+                    ? `limite de uso do runtime atingido: ${rateLimit.trecho}`
+                    : `despacho falhou (code ${r.code})`,
         };
     }
-    const achada = acharSessao(sessionId);
-    const verificada = achada !== null || acharSessao(pedido.nome) !== null;
+    // I-33 (D4): a reverificacao consulta a MESMA conta que despachou.
+    const sessoes = listarSessoes(undefined, true, ambiente);
+    const achada = acharSessao(sessionId, sessoes);
+    const verificada = achada !== null || acharSessao(pedido.nome, sessoes) !== null;
     return {
         ok: true,
         comando,
@@ -177,31 +355,75 @@ function casarIso(texto) {
         return null;
     return { resetEm: data.toISOString(), trecho: m[0].trim() };
 }
+/** N5: uma parte da duracao (`4 days`, `3h`, `20m`, `1.5s`, `20ms`), com a unidade fechada sem exigir `\b`. */
+const PARTE_DA_DURACAO = /(\d+(?:\.\d+)?)\s*(milliseconds?|ms|days?|d|hours?|hrs?|h|minutes?|mins?|m|seconds?|secs?|s)(?![a-z])/gi;
+function segundosDaUnidade(unidade) {
+    const u = unidade.toLowerCase();
+    if (u === 'ms' || u.startsWith('milli'))
+        return 0.001;
+    if (u.startsWith('d'))
+        return 86400;
+    if (u.startsWith('h'))
+        return 3600;
+    if (u.startsWith('m'))
+        return 60;
+    return 1;
+}
 function casarDuracao(texto, agoraMs) {
     const m = texto.match(
-    // A unidade aceita plural (`25 minutes`): fechar em `\b` sem o `s?` fazia o padrao
-    // inteiro falhar justamente na forma que o runtime mais usa.
-    /(?:try again|retry|reset[a-z]*|available|wait)[^\n]{0,20}?\bin\b\s*(\d+)\s*(seconds?|secs?|minutes?|mins?|hours?|hrs?|s|m|h)\b|retry[- ]after[:\s]+(\d+)/i);
+    // A unidade aceita plural (`25 minutes`) e, desde o N5, dias e partes compostas nas formas reais
+    // dos runtimes: `4 days 3 hours`, `2d 5h 30m` (Claude Code), `1m30s` e `20ms` (API da OpenAI).
+    /(?:try again|retry|reset[a-z]*|available|wait)[^\n]{0,20}?\bin\b\s*((?:\d+(?:\.\d+)?\s*(?:milliseconds?|ms|days?|d|hours?|hrs?|h|minutes?|mins?|m|seconds?|secs?|s)(?![a-z])[\s,]*(?:and\s+)?)+)|retry[- ]after[:\s]+(\d+)/i);
     if (!m)
         return null;
-    if (m[3] !== undefined) {
+    if (m[2] !== undefined) {
         // `Retry-After: 3600` e sempre em segundos.
         return {
-            resetEm: new Date(agoraMs + Number(m[3]) * 1000).toISOString(),
+            resetEm: new Date(agoraMs + Number(m[2]) * 1000).toISOString(),
             trecho: m[0].trim(),
         };
     }
-    const valor = Number(m[1]);
-    const unidade = (m[2] ?? '').toLowerCase();
-    const segundos = unidade.startsWith('h')
-        ? valor * 3600
-        : unidade.startsWith('m')
-            ? valor * 60
-            : valor;
-    return { resetEm: new Date(agoraMs + segundos * 1000).toISOString(), trecho: m[0].trim() };
+    let segundos = 0;
+    for (const parte of m[1].matchAll(PARTE_DA_DURACAO))
+        segundos += Number(parte[1]) * segundosDaUnidade(parte[2]);
+    return { resetEm: new Date(agoraMs + Math.round(segundos * 1000)).toISOString(), trecho: m[0].trim().replace(/[\s,]+$/, '') };
+}
+const MESES = ['jan', 'feb', 'mar', 'apr', 'may', 'jun', 'jul', 'aug', 'sep', 'oct', 'nov', 'dec'];
+/**
+ * N5: data e hora de relogio local nas formas reais. Codex: `or try again at Sep 22nd, 2026 3:05 PM`
+ * (`%b %-d` com sufixo ordinal, `, %Y %-I:%M %p`). Claude Code, quando o reset passa de 24 h:
+ * `resets Sep 22, 3pm (<nome IANA do fuso>)` e, em outro ano, `resets Sep 22, 2027, 3:05pm`. Sem ano,
+ * vale o ano corrente, ou o seguinte quando a data ja ficou mais de um dia para tras. O fuso entre
+ * parenteses nao entra na regex nem no calculo (a hora e lida no relogio desta maquina), e por isso
+ * fica como placeholder: o nome literal de fuso mora so em `core/src/horario.ts` (I-35).
+ */
+function casarData(texto, agoraMs) {
+    const m = texto.match(/(?:try again at|reset[a-z]*(?:\s+at)?)\s+(jan|feb|mar|apr|may|jun|jul|aug|sep|oct|nov|dec)[a-z]*\.?\s+(\d{1,2})(?:st|nd|rd|th)?,?\s*(?:(\d{4}),?\s*)?(?:at\s+)?(\d{1,2})(?::(\d{2}))?\s*([ap]\.?m\.?)?(?![a-z0-9])/i);
+    if (!m)
+        return null;
+    const mes = MESES.indexOf(m[1].toLowerCase());
+    const dia = Number(m[2]);
+    let hora = Number(m[4]);
+    const minuto = Number(m[5] ?? '0');
+    const sufixo = (m[6] ?? '').toLowerCase().replace(/\./g, '');
+    if (sufixo === 'pm' && hora < 12)
+        hora += 12;
+    if (sufixo === 'am' && hora === 12)
+        hora = 0;
+    if (dia < 1 || dia > 31 || hora > 23 || minuto > 59)
+        return null;
+    const base = new Date(agoraMs);
+    const ano = m[3] !== undefined ? Number(m[3]) : base.getFullYear();
+    const alvo = new Date(ano, mes, dia, hora, minuto, 0, 0);
+    if (alvo.getMonth() !== mes)
+        return null;
+    if (m[3] === undefined && alvo.getTime() < agoraMs - 24 * 3600 * 1000)
+        alvo.setFullYear(ano + 1);
+    return { resetEm: alvo.toISOString(), trecho: m[0].trim() };
 }
 function casarRelogio(texto, agoraMs) {
-    const m = texto.match(/reset[a-z]*\s*(?:at|em|as)?\s*(\d{1,2})(?::(\d{2}))?\s*(am|pm)?\b/i);
+    // N5: o codex diz so a hora quando o reset e no mesmo dia (`or try again at 3:05 PM`).
+    const m = texto.match(/(?:reset[a-z]*\s*(?:at|em|as)?|try again at)\s*(\d{1,2})(?::(\d{2}))?\s*(am|pm)?\b/i);
     if (!m)
         return null;
     let hora = Number(m[1]);
@@ -239,6 +461,9 @@ function parseRateLimit(saida, agoraMs = Date.now()) {
     const iso = casarIso(texto);
     if (iso)
         return { resetEm: iso.resetEm, fonte: 'iso', trecho: iso.trecho };
+    const data = casarData(texto, agoraMs);
+    if (data)
+        return { resetEm: data.resetEm, fonte: 'relogio', trecho: data.trecho };
     const duracao = casarDuracao(texto, agoraMs);
     if (duracao)
         return { resetEm: duracao.resetEm, fonte: 'duracao', trecho: duracao.trecho };
@@ -248,6 +473,178 @@ function parseRateLimit(saida, agoraMs = Date.now()) {
     const linha = texto.split('\n').find((l) => frase.test(l)) ?? texto;
     return { resetEm: null, fonte: 'sem-horario', trecho: linha.trim().slice(0, 200) };
 }
+/**
+ * I-33 (D1): falha da CONTA na saida real do runtime, reconhecida por frase, nunca por codigo de
+ * saida. Auth ausente vem primeiro: sem login, nada mais da saida importa. Cota esgotada usa os
+ * mesmos padroes de horario do rate limit; sem horario, `resetEm` fica `null` e o prazo e da
+ * janela padrao do manifesto, declarado como estimado por quem marca o perfil. O que e cota
+ * esgotada e o que e rate limit comum sai do criterio unico da D16 (`naturezaDoLimite`).
+ */
+const FRASES_DE_AUTH_AUSENTE = [
+    /\bnot logged in\b/i,
+    /please run \/login/i,
+    /oauth token (?:has )?expired/i,
+    /\bauthentication_error\b/i,
+    // D15 (A6): o erro real do Claude Code quando o refresh do OAuth falha (codigo e frase).
+    /\bauthentication_failed\b/i,
+    /oauth session expired/i,
+    /\btoken_expired\b/i,
+    /refresh[_ ]token[^\n]{0,40}\b(?:expired|revoked|invalid|reused)\b/i,
+    /\b401\b[^\n]{0,40}unauthori[sz]ed|unauthori[sz]ed[^\n]{0,40}\b401\b/i,
+];
+/**
+ * A11: mencao ampla ao comando de login do codex. Aparece tambem em dica e em texto de ajuda, entao
+ * so vale como auth ausente quando o mesmo texto nao traz frase de cota: a cota, mais especifica, vence.
+ */
+const FRASES_AMPLAS_DE_AUTH = [/\bcodex login\b/i];
+/**
+ * I-33 (D16): CRITERIO UNICO entre ESGOTAMENTO da conta e RATE LIMIT comum. Decisao do dono em
+ * 19/09/2026 (opcao a do A3 do CHECK aa279e17): esgotamento de cota, credito ou limite do plano
+ * tira o perfil do rodizio e o MESMO prompt pode seguir no proximo perfil ativo do mesmo runtime;
+ * rate limit comum de curta janela NUNCA troca de perfil, espera a janela. Todo classificador de
+ * falha da conta passa por aqui: despacho claude-bg e codex, transcricao do Claude Code e erro
+ * terminal do turno codex (`parseFalhaDeConta`). Regras, na ordem, pela frase do runtime:
+ *
+ * 1. `esgotamento-explicito`: o provedor diz que a conta ficou sem cota, credito ou saldo
+ *    (`usage_limit_exceeded`, `insufficient_quota`, "out of credits", "spend cap"). Esgotamento,
+ *    com ou sem prazo, mesmo que a resposta venha como HTTP 429.
+ * 2. `janela-curta`: o provedor diz que o limite e temporario e nao e a cota ("not your usage
+ *    limit", "Request rejected (429)", "Too Many Requests", `rate_limit_exceeded`,
+ *    `rate_limit_error`, overloaded, 529, requisicoes ou tokens por minuto). Rate limit.
+ * 3. `limite-do-plano`: frase da janela da assinatura ("usage limit reached", "You've hit your
+ *    ... limit", "You've reached your ... limit", "plan limit"). Esgotamento quando o prazo dito
+ *    esta a `JANELA_CURTA_MAX_MS` ou mais, ou quando o runtime nao diz prazo futuro (a janela do
+ *    plano e de horas ou dias por construcao); rate limit quando o prazo dito e mais curto.
+ * 4. `generico`: qualquer outro sinal de limite reconhecido por `parseRateLimit` (`429`, "rate
+ *    limit", `rate_limit`, "too many requests", "quota exceeded"). Rate limit: na duvida, nao troca
+ *    de perfil. O Retry-After so conta junto de um desses sinais, como prazo.
+ */
+exports.JANELA_CURTA_MAX_MS = 15 * 60 * 1000;
+const FRASES_DE_ESGOTAMENTO = [
+    /\busage_limit_exceeded\b/i,
+    /\busage_limit_reached\b/i,
+    /\bout of credits\b/i,
+    /\binsufficient_quota\b/i,
+    /exceeded your current quota/i,
+    /credit balance is too low/i,
+    // Codigo de erro de API do Claude Code quando a conta fica sem credito (I-33, D12).
+    /\bbilling_error\b/i,
+    /\bspend (?:cap|limit)\b/i,
+    /\bworkspace credit limit\b/i,
+    /\bout of extra usage\b/i,
+    /\brequires usage credits\b/i,
+];
+const FRASES_DE_JANELA_CURTA = [
+    /not your usage limit/i,
+    /temporarily limiting requests/i,
+    /request rejected \(429\)/i,
+    /temporary capacity issue/i,
+    /too many requests/i,
+    /\brate_limit_exceeded\b/i,
+    /\brate_limit_error\b/i,
+    /\bserver_overloaded\b/i,
+    /\boverloaded(?:_error)?\b/i,
+    /\b529\b/,
+    /experiencing high load/i,
+    /\b(?:requests|tokens) per min(?:ute)?\b/i,
+];
+const FRASES_DO_LIMITE_DO_PLANO = [
+    /usage limits? (?:reached|exceeded)/i,
+    /\bhit your (?:[a-z0-9-]+ )?(?:usage )?limit\b/i,
+    /\breached your (?:[a-z0-9-]+ )?(?:usage )?limit\b/i,
+    /\bplan limit\b/i,
+    /out of (?:usage|weekly|session) limit/i,
+];
+/** N4: a linha da frase, limitada a 200 caracteres; em linha longa, a janela comeca perto da frase. */
+function trechoDa(texto, frase) {
+    const linha = (texto.split('\n').find((l) => frase.test(l)) ?? texto).trim();
+    if (linha.length <= 200)
+        return linha;
+    const inicio = Math.max(0, (linha.match(frase)?.index ?? 0) - 40);
+    return linha.slice(inicio, inicio + 200).trim();
+}
+/** Horario de volta dito pelo runtime, do padrao mais preciso para o menos; nenhum inventado. */
+function resetDito(texto, agoraMs) {
+    // N5: data e hora de relogio local (`Sep 22nd, 2026 3:05 PM`) e relogio; a fonte das duas e `relogio`.
+    const padroes = [['epoch', casarEpoch(texto)], ['iso', casarIso(texto)], ['relogio', casarData(texto, agoraMs)],
+        ['duracao', casarDuracao(texto, agoraMs)], ['relogio', casarRelogio(texto, agoraMs)]];
+    const achado = padroes.find(([, r]) => r !== null);
+    return achado ? { resetEm: achado[1].resetEm, fonte: achado[0] } : { resetEm: null, fonte: 'sem-horario' };
+}
+/** D16: a natureza do limite na saida do runtime, pelas quatro regras acima; `null` sem sinal de limite. */
+function naturezaDoLimite(saida, agoraMs = Date.now()) {
+    const texto = saida ?? '';
+    const explicito = FRASES_DE_ESGOTAMENTO.find((r) => r.test(texto));
+    if (explicito)
+        return { natureza: 'esgotamento', regra: 'esgotamento-explicito', ...resetDito(texto, agoraMs), trecho: trechoDa(texto, explicito) };
+    const curta = FRASES_DE_JANELA_CURTA.find((r) => r.test(texto));
+    if (curta)
+        return { natureza: 'rate-limit', regra: 'janela-curta', ...resetDito(texto, agoraMs), trecho: trechoDa(texto, curta) };
+    const plano = FRASES_DO_LIMITE_DO_PLANO.find((r) => r.test(texto));
+    if (plano) {
+        const reset = resetDito(texto, agoraMs);
+        const horizonte = reset.resetEm === null ? null : Date.parse(reset.resetEm) - agoraMs;
+        const curto = horizonte !== null && horizonte > 0 && horizonte < exports.JANELA_CURTA_MAX_MS;
+        return { natureza: curto ? 'rate-limit' : 'esgotamento', regra: 'limite-do-plano', ...reset, trecho: trechoDa(texto, plano) };
+    }
+    const generico = parseRateLimit(texto, agoraMs);
+    return generico ? { natureza: 'rate-limit', regra: 'generico', resetEm: generico.resetEm, fonte: generico.fonte, trecho: generico.trecho }
+        : null;
+}
+function parseFalhaDeConta(saida, agoraMs = Date.now()) {
+    const texto = saida ?? '';
+    const auth = FRASES_DE_AUTH_AUSENTE.find((r) => r.test(texto));
+    if (auth)
+        return { motivo: 'runtime.auth-missing', resetEm: null, fonte: 'sem-horario', trecho: trechoDa(texto, auth) };
+    const limite = naturezaDoLimite(texto, agoraMs);
+    if (limite?.natureza === 'esgotamento') {
+        return { motivo: 'runtime.quota-exhausted', resetEm: limite.resetEm, fonte: limite.fonte, trecho: limite.trecho };
+    }
+    const ampla = FRASES_AMPLAS_DE_AUTH.find((r) => r.test(texto));
+    return ampla ? { motivo: 'runtime.auth-missing', resetEm: null, fonte: 'sem-horario', trecho: trechoDa(texto, ampla) } : null;
+}
+/** Campo textual do `auth status`, sem controle e curto, para o detalhe legivel. */
+const campoDeAuth = (v) => typeof v === 'string' ? v.replace(/[^a-zA-Z0-9_.-]/g, '').slice(0, 32) : '';
+/**
+ * I-33 (D7, D13): `claude auth status --json` com o env do perfil. Aprova so login de ASSINATURA:
+ * `loggedIn: true`, `authMethod` `claude.ai`, sem `apiKeySource` e com provider `firstParty`.
+ * API key, `api_key_helper`, Console ou provider de nuvem cobram por token: `pago`, nunca despacha.
+ * O `configDirectory` informado precisa ser o do perfil, prova de que o env foi aplicado. O `ork`
+ * nunca abre nada dentro do diretorio: quem responde e o CLI.
+ */
+function conferirAuth(perfil) {
+    let ambiente;
+    try {
+        ambiente = ambienteDoPerfil(perfil);
+    }
+    catch (e) {
+        return { ok: false, detalhe: e.message };
+    }
+    const r = exec('claude', ['auth', 'status', '--json'], undefined, 30000, ambiente);
+    // A14: sem codigo de saida (timeout, sinal ou binario ausente) ou sem JSON, a conferencia e inconclusiva.
+    if (r.code === -1)
+        return { ok: false, transitorio: true, detalhe: 'claude auth status sem resposta (timeout, sinal ou binario ausente)' };
+    let dados;
+    try {
+        dados = JSON.parse(r.stdout);
+    }
+    catch {
+        return { ok: false, transitorio: true, detalhe: `claude auth status sem JSON legivel (codigo ${r.code})` };
+    }
+    if (!dados || typeof dados !== 'object')
+        return { ok: false, transitorio: true, detalhe: 'claude auth status sem JSON legivel' };
+    if (perfil && typeof dados.configDirectory === 'string' && dados.configDirectory !== perfil.configDir)
+        return { ok: false, detalhe: 'claude auth status respondeu por outro diretorio de configuracao; perfil nao aplicado' };
+    if (dados.loggedIn !== true)
+        return { ok: false, detalhe: 'claude auth status: loggedIn false' };
+    const metodo = campoDeAuth(dados.authMethod), fonte = campoDeAuth(dados.apiKeySource), provedor = campoDeAuth(dados.apiProvider);
+    if (metodo !== 'claude.ai' || fonte !== '' || (provedor !== '' && provedor !== 'firstParty')) {
+        const partes = [`authMethod ${metodo || 'ausente'}`, ...(fonte ? [`apiKeySource ${fonte}`] : []),
+            ...(provedor && provedor !== 'firstParty' ? [`apiProvider ${provedor}`] : [])];
+        return { ok: false, pago: true, detalhe: `claude auth status: provider pago (${partes.join(', ')}); so a assinatura claude.ai despacha` };
+    }
+    return { ok: true, detalhe: `claude auth status: loggedIn (${metodo})` };
+}
 /** Comando de anexar a sessao (precisa de TTY, entao o CLI imprime em vez de executar). */
 function comandoAttach(sessionId) {
     return `claude attach ${sessionId}`;
@@ -259,13 +656,58 @@ function comandoAttach(sessionId) {
  * nao por quebra de linha. Por isso o movimento vira quebra ANTES de as demais
  * sequencias ANSI serem removidas, senao a saida inteira colapsa numa linha so.
  */
+/**
+ * Marcador temporario de um CHA (`ESC[<n>G`), resolvido em espacos no fim da limpeza.
+ *
+ * Fica fora da faixa de controle que a limpeza apaga (`\u0000-\u001f`), entao ele
+ * atravessa os passos seguintes intacto.
+ */
+const MARCA_DE_COLUNA = '\u0091';
+const MARCA_CASADA = new RegExp(`${MARCA_DE_COLUNA}(\\d+)${MARCA_DE_COLUNA}`, 'g');
+/**
+ * Repoe os espacos que o CHA desenhava, linha a linha.
+ *
+ * O terminal anda ate a coluna pedida preenchendo com branco; quem le o log so ve a
+ * sequencia sumir. Quando a coluna alvo ja passou (o runtime reescrevendo o que estava
+ * na tela), um unico espaco separa os pedacos: e melhor errar o alinhamento do que
+ * colar duas palavras que nunca foram uma so.
+ */
+function resolverColunas(texto) {
+    if (!texto.includes(MARCA_DE_COLUNA))
+        return texto;
+    return texto
+        .split('\n')
+        .map((linha) => {
+        // `split` com grupo de captura intercala texto e coluna: [txt, col, txt, col, txt].
+        const partes = linha.split(MARCA_CASADA);
+        let saida = partes[0] ?? '';
+        for (let i = 1; i < partes.length; i += 2) {
+            const coluna = Number(partes[i]);
+            if (Number.isFinite(coluna) && coluna - 1 > saida.length) {
+                saida += ' '.repeat(coluna - 1 - saida.length);
+            }
+            else if (saida !== '' && !saida.endsWith(' ')) {
+                saida += ' ';
+            }
+            saida += partes[i + 1] ?? '';
+        }
+        return saida;
+    })
+        .join('\n');
+}
 function limparAnsi(bruto) {
-    return bruto
+    return resolverColunas(bruto
         .replace(/\u001b\][^\u0007\u001b]*(?:\u0007|\u001b\\)/g, '')
         .replace(/\u001b\[[0-9;]*[HfABEd]/g, '\n')
+        // O CHA (`ESC[<n>G`) posiciona o cursor numa coluna em vez de escrever espacos, e
+        // o `claude logs` desenha a tela INTEIRA assim. Engoli-lo junto com o resto das
+        // sequencias colava as palavras (`2newMCPserversfoundinthisproject`), o que
+        // apagava a pergunta que o radar poe na frente do humano e matava todo o
+        // reconhecimento por frase que separa credencial de permissao.
+        .replace(/\u001b\[([0-9]*)G/g, (_m, n) => `${MARCA_DE_COLUNA}${n || '1'}${MARCA_DE_COLUNA}`)
         .replace(/\u001b\[[0-9;?]*[ -/]*[@-~]/g, '')
         .replace(/\u001b[()][A-Za-z0-9]/g, '')
-        .replace(/[\u0000-\u0008\u000b\u000c\u000e-\u001f\u007f]/g, '')
+        .replace(/[\u0000-\u0008\u000b\u000c\u000e-\u001f\u007f]/g, ''))
         .replace(/[ \t]+$/gm, '')
         .replace(/\n{3,}/g, '\n\n');
 }
@@ -276,19 +718,26 @@ function limparAnsi(bruto) {
  * nao o UUID completo: passar o UUID responde "No job matching". Por isso a chave e
  * resolvida antes, e a saida (dump de tela com ANSI) e limpa aqui.
  */
-function logs(chave, linhas = 60) {
-    const sessao = acharSessao(chave);
-    const id = sessao?.id ?? (sessao?.sessionId ?? chave).slice(0, 8);
-    const r = (0, util_1.exec)('claude', ['logs', id], undefined, 60000);
+function logs(chave, linhas = 60, ambiente = (0, runtime_ambiente_1.ambienteDeAssinatura)()) {
+    const sessao = acharSessao(chave, listarSessoes(undefined, true, ambiente));
+    return logsDaSessao(sessao?.id ?? (sessao?.sessionId ?? chave).slice(0, 8), linhas, ambiente);
+}
+/**
+ * I-45: a tela de uma sessao cujo id curto o chamador ja tem. `logs` lista todas as sessoes antes
+ * de ler (`claude agents --json --all`, 57 s nesta VPS em 25/09/2026) so para achar esse id; o radar
+ * ja tem a lista na mao, e pagar a listagem de novo por sessao parada era o grosso da varredura.
+ */
+function logsDaSessao(id, linhas = 60, ambiente = (0, runtime_ambiente_1.ambienteDeAssinatura)()) {
+    const r = exec('claude', ['logs', id], undefined, 60000, ambiente);
     const bruto = limparAnsi(r.ok ? r.stdout : r.stdout + r.stderr);
     const uteis = bruto.split('\n').filter((l) => l.trim() !== '');
     return { ok: r.ok, texto: uteis.slice(-linhas).join('\n') };
 }
 /** Para uma sessao em background (o `claude stop` tambem trabalha com o id curto). */
-function parar(chave) {
-    const sessao = acharSessao(chave);
+function parar(chave, ambiente = (0, runtime_ambiente_1.ambienteDeAssinatura)()) {
+    const sessao = acharSessao(chave, listarSessoes(undefined, true, ambiente));
     const id = sessao?.id ?? (sessao?.sessionId ?? chave).slice(0, 8);
-    const r = (0, util_1.exec)('claude', ['stop', id], undefined, 60000);
+    const r = exec('claude', ['stop', id], undefined, 60000, ambiente);
     return { ok: r.ok, texto: limparAnsi(r.stdout + r.stderr).trim() };
 }
 /**