@orkastery/cli 0.2.0 → 0.4.1

package/dist/runtime-profiles.js

@@ -0,0 +1,869 @@
+"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.COLUNAS_DE_PERFIS = exports.POLITICA_PADRAO = exports.ARQUIVO_CONTAS = exports.CONTRATO_CONTAS = exports.ESTADOS_DE_PERFIL = exports.RUNTIMES_COM_PERFIL = exports.VARIAVEL_DO_PERFIL = exports.ARQUIVO_PERFIS = exports.CONTRATO_PERFIS = void 0;
+exports.runtimeComPerfil = runtimeComPerfil;
+exports.validarDiretorioDePerfil = validarDiretorioDePerfil;
+exports.validarIdDePerfil = validarIdDePerfil;
+exports.diretorioDoPerfil = diretorioDoPerfil;
+exports.validarPerfilDeDespacho = validarPerfilDeDespacho;
+exports.perfilDeDespacho = perfilDeDespacho;
+exports.diretorioImplicito = diretorioImplicito;
+exports.diretorioEfetivo = diretorioEfetivo;
+exports.ambienteComPerfil = ambienteComPerfil;
+exports.perfilDoRegistro = perfilDoRegistro;
+exports.pastaPrivada = pastaPrivada;
+exports.caminhoDoStore = caminhoDoStore;
+exports.validarStore = validarStore;
+exports.lerPerfis = lerPerfis;
+exports.atualizarPerfis = atualizarPerfis;
+exports.caminhoRealDoPerfil = caminhoRealDoPerfil;
+exports.prepararDiretorioDoPerfil = prepararDiretorioDoPerfil;
+exports.adicionarPerfil = adicionarPerfil;
+exports.desativarPerfil = desativarPerfil;
+exports.reativarPerfil = reativarPerfil;
+exports.marcarFalhaDePerfil = marcarFalhaDePerfil;
+exports.registrarConferenciaInconclusiva = registrarConferenciaInconclusiva;
+exports.registrarUsoDePerfil = registrarUsoDePerfil;
+exports.pastaDasContas = pastaDasContas;
+exports.chaveDaConta = chaveDaConta;
+exports.lerContasCompartilhadas = lerContasCompartilhadas;
+exports.publicarEstadoDaConta = publicarEstadoDaConta;
+exports.aplicarContasCompartilhadas = aplicarContasCompartilhadas;
+exports.lerPerfisComContas = lerPerfisComContas;
+exports.perfisDoRuntime = perfisDoRuntime;
+exports.perfilDisponivel = perfilDisponivel;
+exports.politicaDeRotacao = politicaDeRotacao;
+exports.proximoPerfilDisponivel = proximoPerfilDisponivel;
+exports.prazoDoRuntime = prazoDoRuntime;
+exports.prazoDaFila = prazoDaFila;
+exports.menorEsgotadoAte = menorEsgotadoAte;
+exports.linhasDePerfis = linhasDePerfis;
+exports.perfisComHorario = perfisComHorario;
+/**
+ * I-33 (D3): perfis de conta por runtime, contrato `ork.runtime-profiles/v1`.
+ *
+ * Um perfil aponta o DIRETORIO onde o proprio CLI do runtime guarda configuracao e login
+ * (`CLAUDE_CONFIG_DIR` no claude-bg, `CODEX_HOME` no codex). O `ork` nunca le, copia nem
+ * migra o que o CLI grava la dentro: o login e feito pelo proprio CLI com o env do perfil, e
+ * o store guarda so identidade, diretorio e estado de uso. Nenhum segredo entra aqui.
+ *
+ * O arquivo mora em `<estado>/.orkastery/private/runtime-profiles.json` (diretorio 0700,
+ * arquivo 0600, dono igual ao uid do processo), com a mesma validacao do recibo local de
+ * HITL: modo exato, sem link simbolico, realpath conferido e identidade do diretorio
+ * reconferida depois de abrir o arquivo. Sem store, nao ha perfil: o despacho segue com o
+ * ambiente do processo, exatamente como antes (P8 do GOAL).
+ */
+const fs = __importStar(require("node:fs"));
+const os = __importStar(require("node:os"));
+const path = __importStar(require("node:path"));
+const node_crypto_1 = require("node:crypto");
+const estado_thread_1 = require("./estado-thread");
+const horario_1 = require("./horario");
+exports.CONTRATO_PERFIS = 'ork.runtime-profiles/v1';
+exports.ARQUIVO_PERFIS = 'runtime-profiles.json';
+/** Runtimes homologados que aceitam perfil, e a variavel que cada um le. */
+exports.VARIAVEL_DO_PERFIL = { 'claude-bg': 'CLAUDE_CONFIG_DIR', codex: 'CODEX_HOME' };
+exports.RUNTIMES_COM_PERFIL = Object.keys(exports.VARIAVEL_DO_PERFIL);
+/**
+ * I-33 (D13): `provider-pago` e o perfil cujo proprio CLI diz que o login e por API key,
+ * `api_key_helper`, Console ou provider de nuvem, e nao pela assinatura. Nunca recebe despacho;
+ * so volta ao rodizio quando `ork accounts check` confere login de assinatura.
+ */
+exports.ESTADOS_DE_PERFIL = ['ativo', 'esgotado', 'sem-auth', 'provider-pago', 'desativado'];
+const ID_DE_PERFIL = /^[a-z0-9][a-z0-9._-]{0,62}$/i;
+const LIMITE_STORE_BYTES = 256 * 1024;
+const LIMITE_DETALHE = 200;
+const uid = () => {
+    const atual = process.getuid?.();
+    if (atual === undefined)
+        throw new Error('runtime.profiles.invalid: uid do processo indisponivel');
+    return atual;
+};
+function runtimeComPerfil(nome) {
+    return Object.prototype.hasOwnProperty.call(exports.VARIAVEL_DO_PERFIL, nome);
+}
+/** Caminho absoluto, normalizado, sem controle e sem ser a raiz: e so isso que o perfil aceita. */
+function validarDiretorioDePerfil(dir) {
+    if (typeof dir !== 'string' || dir.length === 0 || dir.length > 1024 || /\p{Cc}/u.test(dir) ||
+        !path.isAbsolute(dir) || path.normalize(dir) !== dir || dir === '/' || dir.endsWith('/'))
+        throw new Error('runtime.profiles.invalid: diretorio do perfil precisa ser caminho absoluto normalizado');
+    return dir;
+}
+function validarIdDePerfil(id) {
+    if (typeof id !== 'string' || !ID_DE_PERFIL.test(id))
+        throw new Error('runtime.profiles.invalid: id do perfil aceita letras, digitos, ponto, hifen e sublinhado (ate 63)');
+    return id;
+}
+/** Diretorio do perfil, pelo campo do seu runtime. */
+function diretorioDoPerfil(p) {
+    const dir = p.runtime === 'claude-bg' ? p.configDir : p.codexHome;
+    return validarDiretorioDePerfil(dir);
+}
+/** Valida um perfil de despacho vindo do ledger, do thread.json ou do pedido da fila. */
+function validarPerfilDeDespacho(v) {
+    if (!v || typeof v !== 'object' || Array.isArray(v))
+        throw new Error('runtime.profiles.invalid: perfil de despacho ausente');
+    const o = v;
+    const runtime = o.runtime;
+    if (typeof runtime !== 'string' || !runtimeComPerfil(runtime))
+        throw new Error('runtime.profiles.invalid: runtime do perfil desconhecido');
+    const campo = runtime === 'claude-bg' ? 'configDir' : 'codexHome';
+    const outro = runtime === 'claude-bg' ? 'codexHome' : 'configDir';
+    if (o[outro] !== undefined || Object.keys(o).some(k => !['id', 'runtime', campo].includes(k)))
+        throw new Error('runtime.profiles.invalid: perfil de despacho com campo inesperado');
+    const id = validarIdDePerfil(o.id), dir = validarDiretorioDePerfil(o[campo]);
+    return runtime === 'claude-bg' ? { id, runtime, configDir: dir } : { id, runtime, codexHome: dir };
+}
+function perfilDeDespacho(p) {
+    return p.runtime === 'claude-bg' ? { id: p.id, runtime: p.runtime, configDir: diretorioDoPerfil(p) }
+        : { id: p.id, runtime: p.runtime, codexHome: diretorioDoPerfil(p) };
+}
+/**
+ * Diretorio implicito de quem despacha sem perfil: o do ambiente informado, ou o padrao do
+ * CLI na HOME. E o comportamento anterior a I-33, agora com um unico domicilio.
+ */
+function diretorioImplicito(runtime, env = process.env) {
+    const valor = (env[exports.VARIAVEL_DO_PERFIL[runtime]] ?? '').trim();
+    return valor !== '' ? valor : path.join(os.homedir(), runtime === 'claude-bg' ? '.claude' : '.codex');
+}
+/** Diretorio efetivo: o do perfil registrado, ou o implicito quando a sessao nao tem perfil. */
+function diretorioEfetivo(runtime, perfil, env = process.env) {
+    if (!perfil)
+        return diretorioImplicito(runtime, env);
+    if (perfil.runtime !== runtime)
+        throw new Error('runtime.profiles.invalid: perfil de outro runtime');
+    return diretorioDoPerfil(perfil);
+}
+/**
+ * Ambiente do filho com o perfil aplicado sobre uma base ja higienizada (sem provider pago).
+ * Sem perfil devolve a base intacta. Nunca le nada de dentro do diretorio do perfil.
+ */
+function ambienteComPerfil(base, perfil) {
+    const env = { ...base };
+    if (perfil)
+        env[exports.VARIAVEL_DO_PERFIL[perfil.runtime]] = diretorioDoPerfil(perfil);
+    return env;
+}
+/**
+ * D4: o perfil gravado no registro da sessao. O `session_sensor_registered` do despacho vence;
+ * sem ele, o `phase_dispatch` da sessao. Ausente devolve `null` (sessao sem perfil, ambiente do
+ * processo); presente e invalido LANCA, porque cair para o env do processo seria observar a
+ * sessao pela conta errada, que e o risco R2.
+ */
+function perfilDoRegistro(eventos, sessao) {
+    const doSensor = eventos.filter(e => e.tipo === 'session_sensor_registered' && e.sessionId === sessao.sessionId &&
+        (sessao.despachadaEm === undefined || e.despachoEm === sessao.despachadaEm)).at(-1);
+    const doDespacho = eventos.filter(e => e.tipo === 'phase_dispatch' && e.sessionId === sessao.sessionId).at(-1);
+    const bruto = doSensor?.perfil !== undefined ? doSensor.perfil : doDespacho?.perfil;
+    if (bruto === undefined || bruto === null)
+        return null;
+    const perfil = validarPerfilDeDespacho(bruto);
+    if (doSensor?.perfil !== undefined && doDespacho?.perfil !== undefined &&
+        JSON.stringify(validarPerfilDeDespacho(doDespacho.perfil)) !== JSON.stringify(perfil))
+        throw new Error('runtime.profiles.invalid: perfil do sensor diverge do despacho');
+    return perfil;
+}
+// ---------------------------------------------------------------------------
+// Armazenamento privado.
+// ---------------------------------------------------------------------------
+function pastaPrivada(raiz) {
+    return path.join((0, estado_thread_1.raizDoEstado)(raiz), '.orkastery', 'private');
+}
+function caminhoDoStore(raiz) {
+    return path.join(pastaPrivada(raiz), exports.ARQUIVO_PERFIS);
+}
+function validarPasta(pasta) {
+    const st = fs.lstatSync(pasta);
+    if (!st.isDirectory() || st.isSymbolicLink() || st.uid !== uid() || (st.mode & 0o777) !== 0o700 ||
+        fs.realpathSync(pasta) !== pasta)
+        throw new Error('runtime.profiles.invalid: pasta privada precisa ser 0700 do proprio usuario');
+    return st;
+}
+function garantirPasta(raiz) {
+    const pasta = pastaPrivada(raiz);
+    const estado = path.dirname(pasta);
+    const stEstado = fs.lstatSync(estado);
+    if (!stEstado.isDirectory() || stEstado.isSymbolicLink() || fs.realpathSync(estado) !== estado)
+        throw new Error('runtime.profiles.invalid: diretorio de estado invalido');
+    try {
+        fs.mkdirSync(pasta, { mode: 0o700 });
+        fs.chmodSync(pasta, 0o700);
+    }
+    catch (e) {
+        if (e.code !== 'EEXIST')
+            throw e;
+    }
+    return { pasta, st: validarPasta(pasta) };
+}
+function storeVazio() { return { contrato: exports.CONTRATO_PERFIS, perfis: [] }; }
+function data(v, campo) {
+    if (v === null)
+        return null;
+    if (typeof v !== 'string' || !Number.isFinite(Date.parse(v)))
+        throw new Error(`runtime.profiles.invalid: ${campo} invalido`);
+    return v;
+}
+function validarPerfil(v) {
+    if (!v || typeof v !== 'object' || Array.isArray(v))
+        throw new Error('runtime.profiles.invalid: perfil invalido');
+    const o = v;
+    const despacho = validarPerfilDeDespacho({ id: o.id, runtime: o.runtime,
+        ...(o.configDir !== undefined ? { configDir: o.configDir } : {}), ...(o.codexHome !== undefined ? { codexHome: o.codexHome } : {}) });
+    const permitidos = ['id', 'runtime', 'configDir', 'codexHome', 'estado', 'esgotadoAte', 'ultimaFalha', 'ultimoUso', 'criadoEm'];
+    if (Object.keys(o).some(k => !permitidos.includes(k)))
+        throw new Error('runtime.profiles.invalid: campo inesperado no perfil');
+    if (!exports.ESTADOS_DE_PERFIL.includes(o.estado))
+        throw new Error('runtime.profiles.invalid: estado do perfil desconhecido');
+    let ultimaFalha = null;
+    if (o.ultimaFalha !== null) {
+        const f = o.ultimaFalha;
+        if (!f || typeof f !== 'object' || typeof f.motivo !== 'string' || typeof f.detalhe !== 'string' ||
+            f.detalhe.length > LIMITE_DETALHE || Object.keys(f).some(k => !['motivo', 'em', 'detalhe'].includes(k)))
+            throw new Error('runtime.profiles.invalid: ultimaFalha invalida');
+        ultimaFalha = { motivo: f.motivo, em: data(f.em, 'ultimaFalha.em'), detalhe: f.detalhe };
+    }
+    return { ...despacho, estado: o.estado, esgotadoAte: data(o.esgotadoAte, 'esgotadoAte'),
+        ultimaFalha, ultimoUso: data(o.ultimoUso, 'ultimoUso'), criadoEm: data(o.criadoEm, 'criadoEm') };
+}
+/** Conteudo validado; ids unicos e diretorio unico por runtime. */
+function validarStore(v) {
+    if (!v || typeof v !== 'object' || Array.isArray(v))
+        throw new Error('runtime.profiles.invalid: store invalido');
+    const o = v;
+    if (o.contrato !== exports.CONTRATO_PERFIS || !Array.isArray(o.perfis) || Object.keys(o).sort().join(',') !== 'contrato,perfis')
+        throw new Error(`runtime.profiles.invalid: contrato ${exports.CONTRATO_PERFIS} esperado`);
+    const perfis = o.perfis.map(validarPerfil);
+    if (new Set(perfis.map(p => p.id)).size !== perfis.length)
+        throw new Error('runtime.profiles.invalid: id de perfil repetido');
+    if (new Set(perfis.map(p => `${p.runtime}|${diretorioDoPerfil(p)}`)).size !== perfis.length)
+        throw new Error('runtime.profiles.invalid: dois perfis do mesmo runtime no mesmo diretorio');
+    return { contrato: exports.CONTRATO_PERFIS, perfis };
+}
+/** Le o store. Sem pasta privada ou sem arquivo: store vazio (nenhum perfil configurado). */
+function lerPerfis(raiz) {
+    const pasta = pastaPrivada(raiz);
+    let pastaSt;
+    try {
+        pastaSt = validarPasta(pasta);
+    }
+    catch (e) {
+        if (e.code === 'ENOENT')
+            return storeVazio();
+        throw e;
+    }
+    let fd;
+    try {
+        fd = fs.openSync(path.join(pasta, exports.ARQUIVO_PERFIS), fs.constants.O_RDONLY | fs.constants.O_NOFOLLOW);
+    }
+    catch (e) {
+        if (e.code === 'ENOENT')
+            return storeVazio();
+        throw new Error('runtime.profiles.invalid: arquivo de perfis ilegivel ou link simbolico');
+    }
+    try {
+        const st = fs.fstatSync(fd), atual = fs.lstatSync(pasta);
+        if (!st.isFile() || st.nlink !== 1 || st.uid !== uid() || (st.mode & 0o777) !== 0o600 || st.size > LIMITE_STORE_BYTES ||
+            atual.dev !== pastaSt.dev || atual.ino !== pastaSt.ino)
+            throw new Error('runtime.profiles.invalid: arquivo de perfis precisa ser 0600 do proprio usuario');
+        let bruto;
+        try {
+            bruto = JSON.parse(fs.readFileSync(fd, 'utf8'));
+        }
+        catch {
+            throw new Error('runtime.profiles.invalid: arquivo de perfis com JSON invalido');
+        }
+        return validarStore(bruto);
+    }
+    finally {
+        fs.closeSync(fd);
+    }
+}
+function gravarStore(pasta, pastaSt, store) {
+    gravarArquivoPrivado(pasta, pastaSt, exports.ARQUIVO_PERFIS, JSON.stringify(validarStore(store), null, 2) + '\n');
+}
+/** Gravacao atomica de um arquivo 0600 numa pasta privada ja conferida (temp, fsync, rename). */
+function gravarArquivoPrivado(pasta, pastaSt, arquivo, conteudo) {
+    const temp = path.join(pasta, `.${arquivo}.${(0, node_crypto_1.randomUUID)()}.tmp`);
+    const fd = fs.openSync(temp, fs.constants.O_WRONLY | fs.constants.O_CREAT | fs.constants.O_EXCL | fs.constants.O_NOFOLLOW, 0o600);
+    try {
+        // O umask so tira bits; o modo exato e imposto aqui para a leitura nao reprovar depois.
+        fs.fchmodSync(fd, 0o600);
+        fs.writeFileSync(fd, conteudo);
+        fs.fsyncSync(fd);
+    }
+    finally {
+        fs.closeSync(fd);
+    }
+    const atual = fs.lstatSync(pasta);
+    if (atual.dev !== pastaSt.dev || atual.ino !== pastaSt.ino) {
+        fs.rmSync(temp, { force: true });
+        throw new Error('runtime.profiles.invalid: pasta privada trocada durante a gravacao');
+    }
+    fs.renameSync(temp, path.join(pasta, arquivo));
+    const dfd = fs.openSync(pasta, fs.constants.O_RDONLY | fs.constants.O_DIRECTORY);
+    try {
+        fs.fsyncSync(dfd);
+    }
+    finally {
+        fs.closeSync(dfd);
+    }
+}
+const PRAZO_DO_LOCK_MS = 15000;
+const LOCK_SEM_DONO_VELHO_MS = 10000;
+/** Conteudo do arquivo de dono do lock, ou `null` quando ele ainda nao existe ou ja saiu. */
+function lerDono(dono) {
+    try {
+        return fs.readFileSync(dono, 'utf8');
+    }
+    catch (e) {
+        if (e.code === 'ENOENT')
+            return null;
+        throw e;
+    }
+}
+/**
+ * D15 (A5): quebra do lock velho sem apagar lock vivo de outro processo. O diretorio e renomeado
+ * para um nome unico (so um processo ganha o `rename`); se o dono que foi junto nao e o morto que
+ * foi observado, o lock era de um dono novo e volta ao lugar.
+ */
+function quebrarLockVelho(lock, donoObservado) {
+    const velho = `${lock}.velho.${(0, node_crypto_1.randomUUID)()}`;
+    try {
+        fs.renameSync(lock, velho);
+    }
+    catch (e) {
+        if (e.code === 'ENOENT')
+            return;
+        throw e;
+    }
+    const levado = lerDono(path.join(velho, 'pid'));
+    if (levado !== donoObservado) {
+        try {
+            fs.renameSync(velho, lock);
+            return;
+        }
+        catch { /* um terceiro ja tomou o lugar: o renomeado e descartado */ }
+    }
+    fs.rmSync(path.join(velho, 'pid'), { force: true });
+    try {
+        fs.rmdirSync(velho);
+    }
+    catch { /* resto alheio fica para inspecao */ }
+}
+/**
+ * Exclusao curta entre processos `ork` que atualizam o store ao mesmo tempo. D15 (A5): o dono pode
+ * liberar o lock a qualquer instante entre as leituras de quem espera; `ENOENT` nessas leituras quer
+ * dizer "livre agora" e volta ao `mkdir`, nunca vira erro da atualizacao. A espera tem jitter para
+ * nao formar comboio e prazo folgado; so o prazo estourado vira `runtime.profiles.busy`.
+ */
+function comLockDoStore(pasta, executar, arquivo = exports.ARQUIVO_PERFIS) {
+    const lock = path.join(pasta, `${arquivo}.lock`), dono = path.join(lock, 'pid');
+    const prazo = Date.now() + PRAZO_DO_LOCK_MS, pausa = new Int32Array(new SharedArrayBuffer(4));
+    for (;;) {
+        try {
+            fs.mkdirSync(lock, { mode: 0o700 });
+            break;
+        }
+        catch (e) {
+            if (e.code !== 'EEXIST')
+                throw e;
+        }
+        const bruto = lerDono(dono);
+        let mtimeMs;
+        try {
+            mtimeMs = fs.statSync(lock).mtimeMs;
+        }
+        catch (e) {
+            if (e.code === 'ENOENT')
+                continue;
+            throw e;
+        }
+        const pid = bruto === null ? null : Number(bruto);
+        let vivo = true;
+        if (pid !== null && Number.isInteger(pid) && pid > 0) {
+            try {
+                process.kill(pid, 0);
+            }
+            catch (erro) {
+                vivo = erro.code !== 'ESRCH';
+            }
+        }
+        else
+            vivo = Date.now() - mtimeMs < LOCK_SEM_DONO_VELHO_MS;
+        if (!vivo) {
+            quebrarLockVelho(lock, bruto);
+            continue;
+        }
+        if (Date.now() >= prazo)
+            throw new Error('runtime.profiles.busy: store de perfis ocupado; tente novamente');
+        Atomics.wait(pausa, 0, 0, 2 + Math.floor(Math.random() * 18));
+    }
+    try {
+        fs.writeFileSync(dono, String(process.pid), { flag: 'wx', mode: 0o600 });
+    }
+    catch (e) {
+        try {
+            fs.rmdirSync(lock);
+        }
+        catch { /* lock ja tomado */ }
+        throw e;
+    }
+    try {
+        return executar();
+    }
+    finally {
+        // So libera o lock que ainda e deste processo.
+        if (lerDono(dono) === String(process.pid)) {
+            fs.rmSync(dono, { force: true });
+            try {
+                fs.rmdirSync(lock);
+            }
+            catch { /* ja removido */ }
+        }
+    }
+}
+/** Leitura, mutacao e gravacao sob o lock do store. A mutacao recebe uma copia. */
+function atualizarPerfis(raiz, mutar) {
+    const { pasta, st } = garantirPasta(raiz);
+    return comLockDoStore(pasta, () => {
+        const store = lerPerfis(raiz);
+        const copia = { contrato: exports.CONTRATO_PERFIS, perfis: store.perfis.map(p => ({ ...p })) };
+        const r = mutar(copia);
+        gravarStore(pasta, st, copia);
+        return r;
+    });
+}
+function exigirPerfil(store, id) {
+    const p = store.perfis.find(x => x.id === id);
+    if (!p)
+        throw new Error(`runtime.profiles.unknown: perfil "${id}" nao existe (veja: ork accounts list)`);
+    return p;
+}
+/**
+ * A7: identidade do diretorio pelo caminho REAL, resolvendo links do trecho que ja existe (o resto
+ * do caminho, ainda nao criado, entra como esta). Dois perfis que chegam a mesma conta por um link
+ * simbolico sao o mesmo perfil.
+ */
+function caminhoRealDoPerfil(dir) {
+    const faltando = [];
+    let atual = dir;
+    for (;;) {
+        try {
+            return path.join(fs.realpathSync(atual), ...faltando.reverse());
+        }
+        catch (e) {
+            const codigo = e.code;
+            if (codigo !== 'ENOENT' && codigo !== 'ENOTDIR')
+                return path.join(atual, ...faltando.reverse());
+            const pai = path.dirname(atual);
+            if (pai === atual)
+                return path.join(atual, ...faltando.reverse());
+            faltando.push(path.basename(atual));
+            atual = pai;
+        }
+    }
+}
+/**
+ * A7: cria (0700) ou confere o diretorio de um perfil ANTES de grava-lo: diretorio de verdade, do
+ * proprio usuario e com leitura e escrita. Diretorio de outro usuario ou inacessivel nunca vira perfil.
+ */
+function prepararDiretorioDoPerfil(dir) {
+    validarDiretorioDePerfil(dir);
+    try {
+        fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
+    }
+    catch (e) {
+        throw new Error(`runtime.profiles.invalid: diretorio do perfil inacessivel (${e.code ?? 'erro'})`);
+    }
+    let st;
+    try {
+        st = fs.statSync(dir);
+    }
+    catch (e) {
+        throw new Error(`runtime.profiles.invalid: diretorio do perfil inacessivel (${e.code ?? 'erro'})`);
+    }
+    if (!st.isDirectory())
+        throw new Error('runtime.profiles.invalid: o caminho do perfil nao e diretorio');
+    if (st.uid !== uid())
+        throw new Error('runtime.profiles.invalid: diretorio do perfil pertence a outro usuario');
+    try {
+        fs.accessSync(dir, fs.constants.R_OK | fs.constants.W_OK | fs.constants.X_OK);
+    }
+    catch {
+        throw new Error('runtime.profiles.invalid: diretorio do perfil sem leitura e escrita para este usuario');
+    }
+}
+function adicionarPerfil(raiz, novo, agoraIso = new Date().toISOString()) {
+    if (!runtimeComPerfil(novo.runtime))
+        throw new Error(`runtime.profiles.invalid: runtime "${novo.runtime}" nao aceita perfil`);
+    const runtime = novo.runtime;
+    const dir = validarDiretorioDePerfil(novo.dir);
+    const perfil = { id: validarIdDePerfil(novo.id), runtime,
+        ...(runtime === 'claude-bg' ? { configDir: dir } : { codexHome: dir }),
+        estado: 'ativo', esgotadoAte: null, ultimaFalha: null, ultimoUso: null, criadoEm: agoraIso };
+    return atualizarPerfis(raiz, store => {
+        const existente = store.perfis.find(p => p.id === perfil.id);
+        if (existente) {
+            // A9: `remove` desativa; o mesmo `add` (mesmo id, runtime e diretorio) devolve o perfil ao rodizio.
+            if (existente.estado === 'desativado' && existente.runtime === runtime && diretorioDoPerfil(existente) === dir) {
+                existente.estado = 'ativo';
+                existente.esgotadoAte = null;
+                return { ...existente };
+            }
+            throw new Error(`runtime.profiles.invalid: perfil "${perfil.id}" ja existe` +
+                (existente.estado === 'desativado' ? ` (desativado em ${diretorioDoPerfil(existente)}; reative com o mesmo --runtime e --dir)` : ''));
+        }
+        if (store.perfis.some(p => p.runtime === runtime && diretorioDoPerfil(p) === dir))
+            throw new Error(`runtime.profiles.invalid: ja ha perfil ${runtime} em ${dir}`);
+        // A7: o mesmo diretorio por outro caminho (link simbolico) e a mesma conta, nao outro perfil.
+        const real = caminhoRealDoPerfil(dir);
+        const mesmo = store.perfis.find(p => p.runtime === runtime && caminhoRealDoPerfil(diretorioDoPerfil(p)) === real);
+        if (mesmo)
+            throw new Error(`runtime.profiles.invalid: ${dir} e o mesmo diretorio do perfil "${mesmo.id}" (${real})`);
+        store.perfis.push(perfil);
+        return perfil;
+    });
+}
+/** `remove` desativa: o diretorio e o login do CLI ficam onde estao. */
+function desativarPerfil(raiz, id) {
+    return atualizarPerfis(raiz, store => {
+        const p = exigirPerfil(store, id);
+        p.estado = 'desativado';
+        return { ...p };
+    });
+}
+/** Volta ao rodizio (login de assinatura conferido ou prazo de cota vencido). Perfil desativado so volta por `add`. */
+function reativarPerfil(raiz, id) {
+    const p = atualizarPerfis(raiz, store => {
+        const p = exigirPerfil(store, id);
+        if (p.estado === 'desativado')
+            throw new Error(`runtime.profiles.invalid: perfil "${id}" esta desativado`);
+        p.estado = 'ativo';
+        p.esgotadoAte = null;
+        return { ...p };
+    });
+    // I-49: login conferido ou prazo vencido vale para a conta, entao sai do registro compartilhado.
+    publicarEstadoDaConta(p, (0, estado_thread_1.raizDoEstado)(raiz));
+    return p;
+}
+/**
+ * D5: marca a falha de conta. Cota esgotada sai do rodizio ate `esgotadoAte`; auth ausente
+ * sai sem prazo, ate o login ser refeito e conferido.
+ */
+function marcarFalhaDePerfil(raiz, id, falha) {
+    if (falha.estado === 'esgotado' && (falha.esgotadoAte === null || !Number.isFinite(Date.parse(falha.esgotadoAte))))
+        throw new Error('runtime.profiles.invalid: cota esgotada exige esgotadoAte');
+    const marcado = atualizarPerfis(raiz, store => {
+        const p = exigirPerfil(store, id);
+        if (p.estado !== 'desativado')
+            p.estado = falha.estado;
+        p.esgotadoAte = falha.estado === 'esgotado' ? falha.esgotadoAte : null;
+        p.ultimaFalha = { motivo: falha.motivo, em: falha.em ?? new Date().toISOString(), detalhe: detalheCurto(falha.detalhe) };
+        return { ...p };
+    });
+    // I-49: a falha e da CONTA; as outras fabricas do mesmo usuario passam a enxerga-la.
+    if (marcado.estado !== 'desativado')
+        publicarEstadoDaConta(marcado, (0, estado_thread_1.raizDoEstado)(raiz));
+    return marcado;
+}
+const detalheCurto = (detalhe) => Array.from(detalhe.replace(/\p{Cc}/gu, ' ')).slice(0, LIMITE_DETALHE).join('');
+/**
+ * A14: conferencia de login INCONCLUSIVA (timeout, resposta ilegivel, binario ausente). Nao e prova
+ * de login perdido: so a `ultimaFalha` registra o fato, o estado nao muda, e o proximo despacho
+ * confere de novo antes de usar o perfil.
+ */
+function registrarConferenciaInconclusiva(raiz, id, detalhe, em = new Date().toISOString()) {
+    return atualizarPerfis(raiz, store => {
+        const p = exigirPerfil(store, id);
+        p.ultimaFalha = { motivo: 'runtime.unavailable', em, detalhe: detalheCurto(`conferencia de login inconclusiva: ${detalhe}`) };
+        return { ...p };
+    });
+}
+/** Uso bem sucedido: carimba o instante e devolve ao rodizio o perfil cujo prazo de cota venceu. */
+function registrarUsoDePerfil(raiz, id, em = new Date().toISOString()) {
+    const p = atualizarPerfis(raiz, store => {
+        const p = exigirPerfil(store, id);
+        p.ultimoUso = em;
+        if (p.estado === 'esgotado' && p.esgotadoAte !== null && Date.parse(p.esgotadoAte) <= Date.parse(em)) {
+            p.estado = 'ativo';
+            p.esgotadoAte = null;
+        }
+        return { ...p };
+    });
+    // I-49: uso bem sucedido prova que a conta responde; se outro projeto a marcou, a marca sai.
+    if (p.estado === 'ativo' && lerContasCompartilhadas().some((c) => { try {
+        return c.chave === chaveDaConta(p);
+    }
+    catch {
+        return false;
+    } })) {
+        publicarEstadoDaConta(p, (0, estado_thread_1.raizDoEstado)(raiz), Date.parse(em));
+    }
+    return p;
+}
+// ---------------------------------------------------------------------------
+// I-49 (RM-040): estado da CONTA compartilhado entre os projetos do mesmo usuario.
+// ---------------------------------------------------------------------------
+/**
+ * O store de perfis e por projeto, mas a conta e do usuario: tres fabricas na mesma maquina
+ * apontam para o mesmo `CLAUDE_CONFIG_DIR`. Quando uma delas ve a cota esgotada, o login perdido
+ * ou a credencial paga, as outras precisam saber antes de bater na mesma parede.
+ *
+ * O registro mora em `~/.orkastery/private/contas.json`, com as mesmas garantias do store (pasta
+ * 0700, arquivo 0600 do proprio usuario, sem link simbolico, gravacao atomica sob lock). A chave
+ * e o runtime mais o caminho REAL do diretorio do perfil: o id do perfil e do projeto, a conta e
+ * do diretorio. Nenhum segredo entra aqui, como no store.
+ *
+ * O registro so escurece: ele nunca devolve ao rodizio um perfil que o projeto marcou fora, e
+ * leitura com problema vale registro vazio (o despacho segue como antes da I-49).
+ */
+exports.CONTRATO_CONTAS = 'ork.contas-compartilhadas/v1';
+exports.ARQUIVO_CONTAS = 'contas.json';
+const LIMITE_CONTAS_BYTES = 64 * 1024;
+const ESTADOS_COMPARTILHADOS = ['esgotado', 'sem-auth', 'provider-pago'];
+function pastaDasContas() {
+    // Testes e o `ork eval` apontam para uma pasta propria, para nunca tocar o registro do usuario.
+    const isolada = process.env.ORK_CONTAS_DIR;
+    if (isolada && path.isAbsolute(isolada))
+        return isolada;
+    // Pelo caminho real do home: a pasta privada so vale sem link simbolico no caminho.
+    let home = os.homedir();
+    try {
+        home = fs.realpathSync(home);
+    }
+    catch { /* home ausente: a leitura vale vazio */ }
+    return path.join(home, '.orkastery', 'private');
+}
+function chaveDaConta(p) {
+    return `${p.runtime}:${caminhoRealDoPerfil(diretorioDoPerfil(p))}`;
+}
+function validarRegistroDeContas(v) {
+    if (!v || typeof v !== 'object' || v.contrato !== exports.CONTRATO_CONTAS ||
+        !Array.isArray(v.contas))
+        throw new Error('runtime.profiles.invalid: registro de contas invalido');
+    const contas = v.contas.map((c) => {
+        const o = c;
+        if (!o || typeof o.chave !== 'string' || !ESTADOS_COMPARTILHADOS.includes(String(o.estado)) ||
+            typeof o.motivo !== 'string' || typeof o.detalhe !== 'string' || typeof o.projeto !== 'string' || typeof o.em !== 'string')
+            throw new Error('runtime.profiles.invalid: conta compartilhada invalida');
+        return { chave: o.chave, estado: o.estado, esgotadoAte: data(o.esgotadoAte ?? null, 'esgotadoAte'),
+            motivo: o.motivo, detalhe: detalheCurto(o.detalhe), em: data(o.em, 'em'), projeto: o.projeto };
+    });
+    return { contrato: exports.CONTRATO_CONTAS, contas };
+}
+/** Le o registro. Ausente, ilegivel ou com dono e modo errados vale vazio: o registro so escurece. */
+function lerContasCompartilhadas() {
+    const pasta = pastaDasContas();
+    try {
+        const pastaSt = validarPasta(pasta);
+        const fd = fs.openSync(path.join(pasta, exports.ARQUIVO_CONTAS), fs.constants.O_RDONLY | fs.constants.O_NOFOLLOW);
+        try {
+            const st = fs.fstatSync(fd), atual = fs.lstatSync(pasta);
+            if (!st.isFile() || st.nlink !== 1 || st.uid !== uid() || (st.mode & 0o777) !== 0o600 || st.size > LIMITE_CONTAS_BYTES ||
+                atual.dev !== pastaSt.dev || atual.ino !== pastaSt.ino)
+                return [];
+            return validarRegistroDeContas(JSON.parse(fs.readFileSync(fd, 'utf8'))).contas;
+        }
+        finally {
+            fs.closeSync(fd);
+        }
+    }
+    catch {
+        return [];
+    }
+}
+function garantirPastaDasContas() {
+    const pasta = pastaDasContas();
+    fs.mkdirSync(pasta, { recursive: true, mode: 0o700 });
+    fs.chmodSync(pasta, 0o700);
+    return { pasta, st: validarPasta(pasta) };
+}
+/** O diretorio da conta ainda existe? Entrada de diretorio apagado (sandbox, conta removida) sai. */
+function contaAindaExiste(c) {
+    const dir = c.chave.slice(c.chave.indexOf(':') + 1);
+    return path.isAbsolute(dir) && fs.existsSync(dir);
+}
+/**
+ * Grava no registro o estado que o projeto acabou de ver na conta do perfil: falha de conta
+ * entra (ou substitui a anterior), perfil de volta ao rodizio sai. Entradas com prazo vencido
+ * saem junto. Melhor esforco: o registro nunca derruba a operacao do projeto.
+ */
+function publicarEstadoDaConta(p, projeto, agoraMs = Date.now()) {
+    try {
+        const chave = chaveDaConta(p);
+        const { pasta, st } = garantirPastaDasContas();
+        comLockDoStore(pasta, () => {
+            const vivas = lerContasCompartilhadas().filter((c) => c.chave !== chave && contaAindaExiste(c) &&
+                !(c.estado === 'esgotado' && c.esgotadoAte !== null && Date.parse(c.esgotadoAte) <= agoraMs));
+            if (ESTADOS_COMPARTILHADOS.includes(p.estado) && !(p.estado === 'esgotado' && p.esgotadoAte === null)) {
+                vivas.push({ chave, estado: p.estado, esgotadoAte: p.estado === 'esgotado' ? p.esgotadoAte : null,
+                    motivo: p.ultimaFalha?.motivo ?? 'runtime.unavailable', detalhe: p.ultimaFalha?.detalhe ?? '',
+                    em: p.ultimaFalha?.em ?? new Date(agoraMs).toISOString(), projeto });
+            }
+            gravarArquivoPrivado(pasta, st, exports.ARQUIVO_CONTAS, JSON.stringify({ contrato: exports.CONTRATO_CONTAS, contas: vivas }, null, 2) + '\n');
+        }, exports.ARQUIVO_CONTAS);
+    }
+    catch { /* o registro compartilhado e melhor esforco: o store do projeto ja foi gravado */ }
+}
+/**
+ * O store do projeto com o que as outras fabricas viram na mesma conta. So escurece: perfil
+ * desativado ou com credencial paga continua como esta; esgotado local com prazo maior mantem o
+ * dele. Entrada vencida nao vale.
+ */
+function aplicarContasCompartilhadas(store, contas, agoraMs = Date.now()) {
+    if (contas.length === 0)
+        return store;
+    const porChave = new Map(contas.map((c) => [c.chave, c]));
+    return { contrato: store.contrato, perfis: store.perfis.map((p) => {
+            if (p.estado === 'desativado' || p.estado === 'provider-pago')
+                return p;
+            let c;
+            try {
+                c = porChave.get(chaveDaConta(p));
+            }
+            catch {
+                return p;
+            }
+            if (!c)
+                return p;
+            const falha = { motivo: c.motivo, em: c.em, detalhe: detalheCurto(`visto em outro projeto: ${c.detalhe}`) };
+            if (c.estado === 'esgotado') {
+                const ate = c.esgotadoAte === null ? NaN : Date.parse(c.esgotadoAte);
+                if (!(ate > agoraMs))
+                    return p;
+                if (p.estado === 'esgotado' && p.esgotadoAte !== null && Date.parse(p.esgotadoAte) >= ate)
+                    return p;
+                if (p.estado === 'sem-auth')
+                    return p;
+                return { ...p, estado: 'esgotado', esgotadoAte: c.esgotadoAte, ultimaFalha: falha };
+            }
+            return { ...p, estado: c.estado, esgotadoAte: null, ultimaFalha: falha };
+        }) };
+}
+/** Os perfis que o despacho enxerga: o store do projeto com o estado compartilhado das contas. */
+function lerPerfisComContas(raiz, agoraMs = Date.now()) {
+    return aplicarContasCompartilhadas(lerPerfis(raiz), lerContasCompartilhadas(), agoraMs);
+}
+// ---------------------------------------------------------------------------
+// Escolha do perfil (leitura pura do store).
+// ---------------------------------------------------------------------------
+function perfisDoRuntime(store, runtime) {
+    return store.perfis.filter(p => p.runtime === runtime);
+}
+/** Ativo, ou esgotado com o prazo ja vencido. `sem-auth`, `provider-pago` e `desativado` nunca recebem despacho. */
+function perfilDisponivel(p, agoraMs = Date.now()) {
+    if (p.estado === 'ativo')
+        return true;
+    return p.estado === 'esgotado' && p.esgotadoAte !== null && Date.parse(p.esgotadoAte) <= agoraMs;
+}
+/** Defaults da D16: por cota ligada (decisao do dono em 19/09/2026) e por login perdido ligada. */
+exports.POLITICA_PADRAO = { mesmoRuntimePorCota: true, mesmoRuntimePorAuth: true };
+function politicaDeRotacao(manifesto) {
+    const r = manifesto.runtime_profiles;
+    return { mesmoRuntimePorCota: r?.rotate_same_runtime_on_quota !== false,
+        mesmoRuntimePorAuth: r?.rotate_same_runtime_on_auth !== false };
+}
+/**
+ * D14: o perfil da vez do runtime, na ordem do store. `desativado` e `provider-pago` nunca foram
+ * elegiveis e sao pulados. `sem-auth` so e pulado com a troca por login ligada. Perfil esgotado
+ * (ou ja tentado nesta rotacao) so e pulado com a troca por cota ligada: desligada, ele SEGURA o
+ * runtime ate o prazo, e nenhum outro perfil do mesmo runtime o substitui automaticamente.
+ */
+function proximoPerfilDisponivel(store, runtime, politica, opcoes = {}) {
+    const agoraMs = opcoes.agoraMs ?? Date.now();
+    for (const p of perfisDoRuntime(store, runtime)) {
+        if (p.estado === 'desativado' || p.estado === 'provider-pago')
+            continue;
+        if (p.estado === 'sem-auth') {
+            if (politica.mesmoRuntimePorAuth)
+                continue;
+            return null;
+        }
+        if (!(opcoes.excluir ?? []).includes(p.id) && perfilDisponivel(p, agoraMs))
+            return p;
+        if (!politica.mesmoRuntimePorCota)
+            return null;
+    }
+    return null;
+}
+/**
+ * D14: quando o runtime volta a ter perfil da vez, pela mesma regra da escolha. Com a troca por
+ * cota desligada, e o prazo do perfil que segura o runtime; ligada, o menor prazo entre os
+ * esgotados. Sem prazo (so login ausente, ou perfil ainda disponivel), `null`.
+ */
+function prazoDoRuntime(store, runtime, politica, agoraMs = Date.now()) {
+    const prazos = [];
+    for (const p of perfisDoRuntime(store, runtime)) {
+        if (p.estado === 'desativado' || p.estado === 'provider-pago')
+            continue;
+        if (p.estado === 'sem-auth') {
+            if (politica.mesmoRuntimePorAuth)
+                continue;
+            break;
+        }
+        if (p.estado === 'esgotado' && p.esgotadoAte !== null && Date.parse(p.esgotadoAte) > agoraMs)
+            prazos.push(p.esgotadoAte);
+        if (!politica.mesmoRuntimePorCota)
+            break;
+    }
+    return prazos.sort()[0] ?? null;
+}
+/** Menor prazo entre os runtimes informados, pela politica da D14: prazo da fila duravel (P4). */
+function prazoDaFila(store, runtimes, politica, agoraMs = Date.now()) {
+    return runtimes.map(r => prazoDoRuntime(store, r, politica, agoraMs)).filter((p) => p !== null).sort()[0] ?? null;
+}
+/** Menor `esgotadoAte` futuro entre os perfis dos runtimes informados, sem politica (leitura do store). */
+function menorEsgotadoAte(store, runtimes, agoraMs = Date.now()) {
+    const prazos = store.perfis.filter(p => runtimes.includes(p.runtime) && p.estado === 'esgotado' && p.esgotadoAte !== null &&
+        Date.parse(p.esgotadoAte) > agoraMs).map(p => p.esgotadoAte).sort();
+    return prazos[0] ?? null;
+}
+/**
+ * Linhas da tabela de `ork accounts list` e `ork accounts check`: sem segredo, porque o store
+ * nao guarda nenhum. I-35: a tabela e texto para pessoa, entao as tres colunas de horario saem
+ * no fuso do dono; o store e a saida `--json` continuam em UTC ISO. Quem imprime diz o fuso uma
+ * vez, pela `legendaDoFuso()`, quando `perfisComHorario` acusa alguma coluna preenchida.
+ */
+function linhasDePerfis(store) {
+    return store.perfis.map(p => [p.id, p.runtime, diretorioDoPerfil(p), p.estado,
+        p.esgotadoAte ? (0, horario_1.formatarDataHora)(p.esgotadoAte) : '-', p.ultimoUso ? (0, horario_1.formatarDataHora)(p.ultimoUso) : '-',
+        p.ultimaFalha ? `${p.ultimaFalha.motivo} em ${(0, horario_1.formatarDataHora)(p.ultimaFalha.em)}` : '-']);
+}
+/** True quando a tabela mostra algum horario, e a mensagem precisa dizer o fuso uma vez. */
+function perfisComHorario(store) {
+    return store.perfis.some(p => p.esgotadoAte !== null || p.ultimoUso !== null || p.ultimaFalha !== null);
+}
+exports.COLUNAS_DE_PERFIS = ['PERFIL', 'RUNTIME', 'DIRETORIO', 'ESTADO', 'ESGOTADO ATE', 'ULTIMO USO', 'ULTIMA FALHA'];