@orkastery/cli 0.4.2 → 0.5.0

package/assets/orkmind_bridge.py

@@ -1,4 +1,4 @@
-"""Transporte de fabrica: OrkMind instalado, stdin JSON, sem provider ou embedder."""
+"""Transporte de fabrica: OrkMind instalado, stdin JSON; embedder so na operacao embed (I-38)."""
 from __future__ import annotations
 import asyncio
 import contextlib
@@ -6,7 +6,9 @@ import hashlib
 import io
 import json
 import logging
+import math
 import os
+import re
 import sys
 
 
@@ -188,6 +190,205 @@ def query_contract(request):
     return {k: list(v) for k, v in tags.items()}, request['collection'], limit
 
 
+# I-38 (D1, D4, D8): a chave de embedding chega so ao ambiente desta operacao, com este nome.
+EMBED_KEY_ENV = 'ORKMIND_EMBEDDING_API_KEY'
+EMBED_TIMEOUT_S = 10.0
+EMBED_MAX_TEXTS = 32
+EMBED_MAX_CHARS = 24000
+LOCAL_MAX_TOKENS = 8192
+MODEL_NAME = re.compile(r'[A-Za-z0-9][A-Za-z0-9._-]*/[A-Za-z0-9][A-Za-z0-9._-]*')
+# Mesmos padroes da policy segredo_em_prompt, mais URL com credencial: recusados antes da rede.
+SECRET_PATTERNS = [re.compile(p) for p in (
+    r'sk-ant-[A-Za-z0-9_-]{16,}', r'sk-or-v1-[A-Za-z0-9]{32,}', r'\bsk-[A-Za-z0-9]{32,}\b',
+    r'\bAKIA[0-9A-Z]{16}\b', r'\bgh[pousr]_[A-Za-z0-9]{20,}\b', r'-----BEGIN (?:[A-Z ]+ )?PRIVATE KEY-----',
+    r'(?i)\b(?:api[_-]?key|secret|token|senha|password)\s*[:=]\s*[\'"][^\'"\s]{16,}[\'"]',
+    r'\b[a-z][a-z0-9+.-]*://[^\s/:@]+:[^\s/@]+@')]
+
+
+def embed_contract(request):
+    valid = isinstance(request, dict) and set(request) == {'op', 'papel', 'alvo', 'modelo', 'dim', 'textos'}
+    textos = request.get('textos') if valid else None
+    dim = request.get('dim') if valid else None
+    if (not valid or request['papel'] not in ('consulta', 'documento')
+            or request['alvo'] not in ('primario', 'fallback')
+            or not isinstance(request['modelo'], str) or MODEL_NAME.fullmatch(request['modelo']) is None
+            or type(dim) is not int or not 32 <= dim <= 4096
+            or not isinstance(textos, list) or not 1 <= len(textos) <= EMBED_MAX_TEXTS
+            or any(not isinstance(t, str) or not t.strip() or len(t) > EMBED_MAX_CHARS for t in textos)):
+        raise QueryError('memory.embed.invalid')
+
+
+def model_prefix(modelo, papel):
+    """Instrucao de uso do proprio modelo; o conteudo da entrada vai inteiro depois dela."""
+    nome = modelo.lower().split('/')[-1]
+    if nome.startswith('qwen3-embedding'):
+        return ('Instruct: Given a search query, retrieve relevant memory entries that answer the query\nQuery:'
+                if papel == 'consulta' else '')
+    if re.search(r'(^|[-_])e5([-_]|$)', nome):
+        return 'query: ' if papel == 'consulta' else 'passage: '
+    return ''
+
+
+async def embed_primary(modelo, dim, textos):
+    if not os.environ.get(EMBED_KEY_ENV, '').strip():
+        raise QueryError('embeddings.chave-ausente')
+    import httpx
+    from orkmind.embeddings.provider import OpenRouterEmbeddingProvider
+    provider = OpenRouterEmbeddingProvider(api_key_env=EMBED_KEY_ENV, model=modelo, embedding_dim=dim,
+                                           timeout_s=EMBED_TIMEOUT_S, request_dimensions=True)
+    try:
+        return await provider.embed_batch(textos)
+    except Exception as error:
+        # Nunca repassar texto do provider: ele pode ecoar a entrada ou o cabecalho.
+        cause = error.__cause__ or error
+        raise QueryError('embeddings.timeout' if isinstance(cause, httpx.TimeoutException)
+                         else 'embeddings.provider-indisponivel') from None
+
+
+def local_model_dir(modelo):
+    """Pasta do modelo no cache local, sem rede. None quando nao foi baixado."""
+    os.environ['HF_HUB_OFFLINE'] = '1'
+    os.environ['TRANSFORMERS_OFFLINE'] = '1'
+    try:
+        from huggingface_hub import snapshot_download
+    except ImportError:
+        raise QueryError('embeddings.dependencia-ausente') from None
+    try:
+        return snapshot_download(modelo, local_files_only=True)
+    except Exception:
+        return None
+
+
+def local_pooling(pasta):
+    from pathlib import Path
+    modules = Path(pasta, 'modules.json')
+    if modules.exists() and any('Dense' in m.get('type', '') for m in json.loads(modules.read_text())):
+        raise QueryError('embeddings.dimensao-divergente')
+    config = Path(pasta, '1_Pooling', 'config.json')
+    modos = json.loads(config.read_text()) if config.exists() else {}
+    return ('lasttoken' if modos.get('pooling_mode_lasttoken') else
+            'cls' if modos.get('pooling_mode_cls_token') else 'mean')
+
+
+class LocalEmbeddingProvider:
+    """Fallback local (D4): mesma interface do EmbeddingProvider da biblioteca, offline, em CPU."""
+
+    def __init__(self, modelo):
+        pasta = local_model_dir(modelo)
+        if pasta is None:
+            raise QueryError('embeddings.local-ausente')
+        try:
+            import torch
+            from transformers import AutoModel, AutoTokenizer
+        except ImportError:
+            raise QueryError('embeddings.dependencia-ausente') from None
+        torch.set_num_threads(min(4, os.cpu_count() or 1))
+        self._torch = torch
+        self._pooling = local_pooling(pasta)
+        self._tokenizer = AutoTokenizer.from_pretrained(
+            pasta, local_files_only=True, padding_side='left' if self._pooling == 'lasttoken' else 'right')
+        self._model = AutoModel.from_pretrained(pasta, local_files_only=True)
+        self._model.eval()
+        self._dim = int(self._model.config.hidden_size)
+        self._max = min(int(getattr(self._tokenizer, 'model_max_length', LOCAL_MAX_TOKENS) or LOCAL_MAX_TOKENS),
+                        LOCAL_MAX_TOKENS)
+        # Texto acima do contexto do modelo local e embedado pelo comeco e DECLARADO (nunca em silencio).
+        self.truncados = []
+
+    @property
+    def dim(self):
+        return self._dim
+
+    async def embed(self, text):
+        return (await self.embed_batch([text]))[0]
+
+    async def embed_batch(self, texts):
+        torch = self._torch
+        self.truncados = [i for i, ids in enumerate(self._tokenizer(texts, truncation=False)['input_ids'])
+                          if len(ids) > self._max]
+        lote = self._tokenizer(texts, padding=True, truncation=True, max_length=self._max, return_tensors='pt')
+        with torch.inference_mode():
+            saida = self._model(**lote).last_hidden_state
+        if self._pooling == 'lasttoken':
+            vetores = saida[:, -1]
+        elif self._pooling == 'cls':
+            vetores = saida[:, 0]
+        else:
+            mascara = lote['attention_mask'].unsqueeze(-1).to(saida.dtype)
+            vetores = (saida * mascara).sum(1) / mascara.sum(1).clamp(min=1e-9)
+        return torch.nn.functional.normalize(vetores, p=2, dim=1).tolist()
+
+
+async def embed(request):
+    """Operacao embed: unica que instancia embedder; nao toca a base nem recebe a DSN."""
+    embed_contract(request)
+    textos = request['textos']
+    if any(p.search(t) for p in SECRET_PATTERNS for t in textos):
+        raise QueryError('embeddings.conteudo-recusado')
+    prefixo = model_prefix(request['modelo'], request['papel'])
+    entrada = [prefixo + t for t in textos]
+    truncados = []
+    if request['alvo'] == 'primario':
+        vetores = await embed_primary(request['modelo'], request['dim'], entrada)
+    else:
+        local = LocalEmbeddingProvider(request['modelo'])
+        vetores = await local.embed_batch(entrada)
+        truncados = list(local.truncados)
+    # A biblioteca nao confere a dimensao devolvida (D8): a ponte confere vetor a vetor.
+    if (not isinstance(vetores, list) or len(vetores) != len(textos)
+            or any(not isinstance(v, list) or len(v) != request['dim']
+                   or not all(isinstance(x, float) and math.isfinite(x) for x in v) for v in vetores)):
+        raise QueryError('embeddings.dimensao-divergente')
+    return {'alvo': request['alvo'], 'modelo': request['modelo'], 'dim': request['dim'], 'truncados': truncados,
+            'vetores': [[round(x, 7) for x in v] for v in vetores]}
+
+
+def health_contract(request):
+    if not isinstance(request, dict) or set(request) != {'op'}:
+        raise QueryError('memory.health.invalid')
+
+
+async def health(store):
+    """Sonda barata (I-38 T4): contagens, versao da biblioteca e dependencias do fallback, sem rede nem torch."""
+    import importlib.metadata
+    import importlib.util
+    # Versao e dependencias sao informacao, nao saude: falha nelas nunca derruba o regime.
+    try:
+        versao = importlib.metadata.version('orkmind')
+    except Exception:
+        versao = None
+    def presente(modulo):
+        try:
+            return importlib.util.find_spec(modulo) is not None
+        except Exception:
+            return False
+    dependencias = all(presente(m) for m in ('torch', 'transformers', 'huggingface_hub'))
+    return {'contagens': {c: await store.count(c) for c in await store.list_collections()},
+            'orkmind': versao, 'fallback': {'dependencias': dependencias}}
+
+
+ORK_COLLECTIONS = ('decision', 'handoff', 'rule', 'learning', 'roadmap')
+
+
+def fts_contract(request):
+    valid = isinstance(request, dict) and set(request) == {'op', 'tenant', 'texto'}
+    def text(value, maximum):
+        return isinstance(value, str) and 0 < len(value.strip()) and len(value) <= maximum and re.search(r'[\x00-\x1f\x7f]', value) is None
+    if not valid or not text(request['tenant'], 128) or not text(request['texto'], 2000):
+        raise QueryError('memory.fts.invalid')
+
+
+async def fts(request, store):
+    """FTS da biblioteca (I-38 D9) com fronteira de tenant obrigatoria: devolve so ids, na ordem do ranking."""
+    # A janela cobre a base inteira: ausencia so conta quando nada ficou de fora do corte.
+    limit = await store.count() + 1
+    entries = await store.search_by_text(request['texto'], limit=limit)
+    if len(entries) >= limit:
+        raise QueryError('memory.query.window-saturated')
+    return {'ids': [e.id for e in entries if e.collection in ORK_COLLECTIONS
+                    and request['tenant'] in (e.tags or {}).get('project', [])]}
+
+
 async def execute(request, store):
     from orkmind.core.models import MemoryEntry
     from orkmind.core.semantic_layer import SemanticLayer
@@ -196,6 +397,12 @@ async def execute(request, store):
     op = request['op']
     if op == 'stats':
         return {c: await store.count(c) for c in await store.list_collections()}
+    if op == 'health':
+        health_contract(request)
+        return await health(store)
+    if op == 'fts':
+        fts_contract(request)
+        return await fts(request, store)
     if op == 'query':
         tags, collection, limit = query_contract(request)
         # GovernedStore conserva validade, anti-injection e visibilidade existentes.
@@ -323,8 +530,14 @@ async def main(request):
             return {'schema':'orkmind.company-brain-api/v1','state':'conflict','error':'brain.api.invalid'}
         from orkmind.cli.company_brain import service_request
         return service_request(request['request'])
+    if isinstance(request, dict) and request.get('op') == 'embed':
+        return await embed(request)
     if isinstance(request, dict) and request.get('op') == 'query':
         query_contract(request)
+    if isinstance(request, dict) and request.get('op') == 'health':
+        health_contract(request)
+    if isinstance(request, dict) and request.get('op') == 'fts':
+        fts_contract(request)
     native_schema_fields()
     from orkmind.core.config import OrkMindConfig
     from orkmind.store.factory import create_store

package/dist/adapters/claude-bg.js

@@ -44,6 +44,7 @@ var __importStar = (this && this.__importStar) || (function () {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.JANELA_CURTA_MAX_MS = exports.NOME_ADAPTER = void 0;
 exports.ambienteDoPerfil = ambienteDoPerfil;
+exports.semContextoDeDespacho = semContextoDeDespacho;
 exports.disponivel = disponivel;
 exports.versao = versao;
 exports.montarComando = montarComando;
@@ -62,6 +63,8 @@ exports.limparAnsi = limparAnsi;
 exports.logs = logs;
 exports.logsDaSessao = logsDaSessao;
 exports.parar = parar;
+exports.pararAchada = pararAchada;
+exports.acharSessaoNasContas = acharSessaoNasContas;
 exports.ocupacaoDeContexto = ocupacaoDeContexto;
 const util_1 = require("../util");
 const runtime_ambiente_1 = require("../runtime-ambiente");
@@ -82,6 +85,14 @@ function ambienteDoPerfil(perfil) {
     return (0, runtime_profiles_1.ambienteComPerfil)((0, runtime_ambiente_1.ambienteDeAssinatura)(), perfil);
 }
 exports.NOME_ADAPTER = 'claude-bg';
+/** RM-037 (defeitosdeco D-4): o ambiente do `claude --bg` sem canal nem chave do contexto do despacho. */
+function semContextoDeDespacho(base, contexto) {
+    const env = { ...base };
+    delete env.ORK_CANAL;
+    for (const chave of Object.keys(contexto ?? {}))
+        delete env[chave];
+    return env;
+}
 /** Consultas do perfil interactive; gates e respostas humanas nunca recebem grant. */
 const CONSULTAS_MCP = [
     'mcp__orkastery__ork_thread_status',
@@ -91,8 +102,9 @@ const CONSULTAS_MCP = [
     'mcp__orkastery__ork_artifact_read',
     'mcp__orkastery__ork_claims_list',
 ];
+// RM-037 (defeito 1): a decisao autonoma pelo MCP tem o mesmo grant nos dois runtimes.
 const MUTACOES_WORKTREE = [
-    'mcp__orkastery__ork_artifact_write', 'mcp__orkastery__ork_claim_add',
+    'mcp__orkastery__ork_artifact_write', 'mcp__orkastery__ork_claim_add', 'mcp__orkastery__ork_decision_record',
     '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. */
@@ -129,6 +141,13 @@ function montarComando(pedido) {
         args.push('--model', pedido.model);
     if (pedido.effort)
         args.push('--effort', pedido.effort);
+    // RM-037 (defeitosdeco D-4): o contexto do despacho (identidade, thread, canal) chega POR SESSAO.
+    // O `claude --bg` entrega a sessao a um processo reserva do daemon da conta, e o daemon guarda o
+    // ambiente de quem o iniciou: pelo ambiente, a sessao nascia com a identidade de outro despacho.
+    // Medido em 28/09/2026 (2.1.284): o `env` de `--settings` chega ao Bash da sessao e vence o herdado.
+    const doDespacho = pedido.ambienteExtra ?? {};
+    if (Object.keys(doDespacho).length)
+        args.push('--settings', JSON.stringify({ env: doDespacho }));
     if (pedido.contextoRuntime) {
         if (pedido.contextoRuntime.host !== 'claude-code')
             throw Error('runtime.context.invalid: host Claude esperado');
@@ -136,8 +155,10 @@ function montarComando(pedido) {
         // 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];
+        // PLAN não implementa: nem commit, nem claim, nem verify, nem ship, em nenhum perfil. Decidir não é
+        // implementar, e o PLAN é onde as decisões nascem (RM-037, achado S7 do CHECK): a decisão autônoma fica.
+        const allow = plano ? [...CONSULTAS_MCP, 'mcp__orkastery__ork_artifact_write', 'mcp__orkastery__ork_decision_record']
+            : 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)
@@ -255,8 +276,10 @@ function acharSessao(chave, sessoes) {
 function despachar(pedido) {
     const comando = montarComando(pedido);
     let ambiente;
+    // D-4: nada do contexto do despacho vai ao ambiente do processo `claude`, para um daemon novo nunca
+    // nascer com ele; a identidade herdada ja sai em `ambienteDeAssinatura`, e o canal sai aqui.
     try {
-        ambiente = { ...ambienteDoPerfil(pedido.perfil), ...(pedido.ambienteExtra ?? {}) };
+        ambiente = semContextoDeDespacho(ambienteDoPerfil(pedido.perfil), pedido.ambienteExtra);
     }
     catch (e) {
         return { ok: false, comando, sessionId: null, verificada: false, stdout: '', stderr: '', erro: e.message };
@@ -497,6 +520,13 @@ const FRASES_DE_AUTH_AUSENTE = [
  * 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];
+/**
+ * RM-037 (defeitosdeco D-6): modelo inexistente ou sem acesso na conta. Medido na transcricao da
+ * sessao af32834f (28/09/2026, `fable-5-1` num perfil de conta sem esse modelo): `error: "model_not_found"` e o texto
+ * "There's an issue with the selected model (fable-5-1). It may not exist or you may not have access
+ * to it". Frase de sobrecarga ("model is overloaded") nao entra: e falha transitoria da infra.
+ */
+const FRASES_DE_MODELO_INACESSIVEL = [/\bmodel_not_found\b/i, /issue with the selected model/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
@@ -593,6 +623,9 @@ function naturezaDoLimite(saida, agoraMs = Date.now()) {
 }
 function parseFalhaDeConta(saida, agoraMs = Date.now()) {
     const texto = saida ?? '';
+    const modelo = FRASES_DE_MODELO_INACESSIVEL.find((r) => r.test(texto));
+    if (modelo)
+        return { motivo: 'runtime.model-unavailable', resetEm: null, fonte: 'sem-horario', trecho: trechoDa(texto, modelo) };
     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) };
@@ -645,9 +678,15 @@ function conferirAuth(perfil) {
     }
     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}`;
+/**
+ * Comando de anexar a sessao (precisa de TTY, entao o CLI imprime em vez de executar). RM-037
+ * (defeitosdeco D-2): sessao de um perfil so e anexada com o `CLAUDE_CONFIG_DIR` daquela conta.
+ */
+function comandoAttach(sessionId, configDir) {
+    if (!configDir)
+        return `claude attach ${sessionId}`;
+    const dir = /^[A-Za-z0-9_./-]+$/.test(configDir) ? configDir : `'${configDir.replace(/'/g, `'\\''`)}'`;
+    return `CLAUDE_CONFIG_DIR=${dir} claude attach ${sessionId}`;
 }
 /**
  * Transforma o dump de tela que o `claude logs` devolve em texto legivel.
@@ -736,10 +775,50 @@ function logsDaSessao(id, linhas = 60, ambiente = (0, runtime_ambiente_1.ambient
 /** Para uma sessao em background (o `claude stop` tambem trabalha com o id curto). */
 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 = exec('claude', ['stop', id], undefined, 60000, ambiente);
+    return pararAchada(sessao ?? { sessionId: chave }, ambiente);
+}
+/** Para a sessao ja achada numa conta, com o ambiente dessa conta, sem listar de novo. */
+function pararAchada(sessao, ambiente = (0, runtime_ambiente_1.ambienteDeAssinatura)()) {
+    const r = exec('claude', ['stop', sessao.id ?? sessao.sessionId.slice(0, 8)], undefined, 60000, ambiente);
     return { ok: r.ok, texto: limparAnsi(r.stdout + r.stderr).trim() };
 }
+/**
+ * RM-037 (defeitosdeco D-2): o `claude agents` so lista a sessao para a conta que a despachou, entao
+ * uma chave e procurada no ambiente do processo e em cada perfil claude-bg informado, sem repetir
+ * diretorio efetivo. Consulta que falha nao vira "nao encontrada": vai para `falhas`.
+ */
+function acharSessaoNasContas(chave, perfis) {
+    const achadas = [], falhas = [], vistos = new Set();
+    // GO-FIX (R5a): cada consulta pode custar dezenas de segundos sob carga. UUID completo e unico em
+    // qualquer conta, entao a busca para na primeira que acha; prefixo ou nome consulta todas, para
+    // recusar a chave ambigua.
+    const unica = UUID_CLAUDE.test(chave);
+    for (const perfil of [null, ...perfis.filter(p => p.runtime === 'claude-bg')]) {
+        let ambiente, configDir;
+        try {
+            ambiente = ambienteDoPerfil(perfil);
+            configDir = path.resolve((0, runtime_profiles_1.diretorioEfetivo)('claude-bg', perfil, ambiente));
+        }
+        catch (e) {
+            falhas.push(`${perfil?.id ?? 'processo'}: ${e.message}`);
+            continue;
+        }
+        if (vistos.has(configDir))
+            continue;
+        vistos.add(configDir);
+        const consulta = consultarSessoes(undefined, true, ambiente);
+        if (!consulta.ok) {
+            falhas.push(`${perfil?.id ?? 'processo'}: ${consulta.detalhe}`);
+            continue;
+        }
+        const sessao = acharSessao(chave, consulta.sessoes);
+        if (sessao)
+            achadas.push({ sessao, perfil, configDir, ambiente });
+        if (sessao && unica)
+            break;
+    }
+    return { achadas, falhas };
+}
 /**
  * Ocupacao da janela de contexto de uma sessao, entre 0 e 1.
  *

package/dist/adapters/codex-events.js

@@ -12,7 +12,9 @@ const falha = () => ({ classificacao: 'gate_blocked', motivo: 'runtime.unavailab
 const sucesso = () => ({ classificacao: 'fase_concluida', motivo: null });
 const humano = () => ({ classificacao: 'human.pending', motivo: 'human.pending' });
 /** I-33 (D12): motivos da conta so saem de erro estruturado do runtime (`falhaDeContaDoErroCodex`). */
-const MOTIVOS_DA_CONTA = ['runtime.quota-exhausted', 'runtime.auth-missing'];
+const MOTIVOS_DA_CONTA = ['runtime.quota-exhausted', 'runtime.auth-missing',
+    // GO-FIX (R3, RM-037): o modelo inacessivel tambem so vale do erro estruturado, nunca do texto do agente.
+    'runtime.model-unavailable'];
 function motivo(v) {
     if (v === undefined || v === null)
         return null;

package/dist/board.js

@@ -50,6 +50,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.perfisDetectados = perfisDetectados;
 exports.threadsDeTodosOsPerfis = threadsDeTodosOsPerfis;
 exports.estadosDeSessao = estadosDeSessao;
+exports.vagaDoDespacho = vagaDoDespacho;
+exports.esperarVaga = esperarVaga;
 exports.planejar = planejar;
 exports.devolverVagas = devolverVagas;
 exports.textoDoReap = textoDoReap;
@@ -123,6 +125,78 @@ function estadosDeSessao() {
         .filter((s) => !!s.sessionId)
         .map((s) => [s.sessionId, (0, hitl_1.estadoBruto)(s)]));
 }
+/**
+ * RM-037 (rm037defeito, defeito 3): o portao de vaga do `ork phase run`. Com `max_parallel_threads: 5`,
+ * um sexto despacho saiu as 09h03 de 29/09/2026 com cinco sessoes vivas: o `phase run` nao consultava
+ * vaga nenhuma, e o escalonador so via as sessoes `claude agents` de uma conta.
+ *
+ * Ocupa vaga a outra thread cuja conducao `exec:<thread>` e de uma sessao viva (a prova que vale para
+ * claude-bg de qualquer conta e para codex, liberada por `phase_result`, `sessao_morta` ou
+ * `session_superseded`), salvo a sessao parada ou escalada para o humano (`sessaoLivreDaVaga`; achados A1 e
+ * N1 do CHECK: a pausa prevista e o verify reprovado nao param a sessao, e ela segue contando). Ocupa tambem o
+ * despacho em curso de outra thread (conducao de processo do `phase.run` ou do `retry.run`), senao dois
+ * pedidos simultaneos passariam juntos. A conducao da propria thread tem portao proprio. Somente leitura.
+ */
+function vagaDoDespacho(carregado, threadId, quando = (0, util_1.agora)(), 
+/** S-5 do CHECK 3: o `desde` da tomada deste despacho; despacho em curso de outra thread so conta se veio antes. */
+desdeProprio) {
+    const { raiz, manifesto } = carregado;
+    const limite = Math.max(1, manifesto.concurrency.max_parallel_threads);
+    const staleMin = manifesto.concurrency.stale_after_min;
+    const ocupam = [];
+    for (const id of (0, thread_1.listarIds)(raiz)) {
+        if (id === threadId)
+            continue;
+        let atual = null;
+        try {
+            atual = (0, conducao_1.conducaoDaThread)(raiz, id);
+        }
+        catch {
+            continue;
+        }
+        if (!atual)
+            continue;
+        const despachando = atual.dono.tipo === 'processo' && (atual.operacao === 'phase.run' || atual.operacao === 'retry.run');
+        if (atual.dono.tipo !== 'sessao' && !despachando)
+            continue;
+        // Dois despachos disputando a ultima vaga nao se recusam um ao outro: quem tomou antes fica com ela.
+        if (despachando && desdeProprio && (atual.desde > desdeProprio || (atual.desde === desdeProprio && id > threadId)))
+            continue;
+        if (atual.dono.tipo === 'sessao') {
+            try {
+                if ((0, ocupacao_1.sessaoLivreDaVaga)((0, ledger_1.lerLedger)((0, thread_1.dirThread)(raiz, id)), atual.desde, quando, staleMin, atual.dono.sessionId))
+                    continue;
+            }
+            catch { /* ledger ilegivel: a conducao viva continua contando */ }
+        }
+        ocupam.push({ thread: id, fase: atual.fase, desde: atual.desde,
+            sessao: atual.dono.tipo === 'sessao' ? atual.dono.sessionId : null,
+            runtime: atual.dono.tipo === 'sessao' ? atual.dono.runtime : null });
+    }
+    if (ocupam.length < limite)
+        return null;
+    ocupam.sort((a, b) => a.desde.localeCompare(b.desde));
+    return {
+        limite,
+        ocupam,
+        detalhe: `concurrency.limite: o projeto ja tem ${ocupam.length} sessao(oes) viva(s) em outras threads e o limite e ${limite} ` +
+            `(concurrency.max_parallel_threads): ${ocupam.map((o) => `${o.thread} ${o.fase ?? '-'} ` +
+                (o.sessao ? `${o.runtime} ${o.sessao.slice(0, 8)}` : 'despacho em curso')).join('; ')}`,
+        correcao: 'espere uma sessao terminar e repita com --esperar <min>; sessao que morreu sem evento sai com ' +
+            'ork conducao status <thread>; ou suba concurrency.max_parallel_threads no orkastery.yaml',
+    };
+}
+/** `--esperar`: espera a vaga do projeto ate o prazo. Devolve true quando ha vaga. */
+function esperarVaga(carregado, threadId, esperarMs) {
+    const prazo = Date.now() + esperarMs;
+    for (;;) {
+        if (!vagaDoDespacho(carregado, threadId))
+            return true;
+        if (Date.now() >= prazo)
+            return false;
+        (0, conducao_1.dormir)(Math.min(2000, prazo - Date.now()));
+    }
+}
 /**
  * Escalonador por maquina: decide quem avanca agora e quem espera, com motivo tipado.
  *

package/dist/branch-de-estado.js

@@ -79,8 +79,8 @@ function pontaLocal(raiz, remoto, branch) {
  * Traz a ponta da branch. `ponta: null` quando ela ainda nao existe no remoto; sem rede, a ultima
  * copia local com `atualizado: false`.
  */
-function buscarBranch(raiz, remoto, branch, prefixo, timeoutMs) {
-    const r = git(raiz, ['fetch', '--quiet', '--no-tags', remoto, `+refs/heads/${branch}:${(0, exports.refRemota)(remoto, branch)}`], { timeoutMs });
+function buscarBranch(raiz, remoto, branch, prefixo, timeoutMs, env) {
+    const r = git(raiz, ['fetch', '--quiet', '--no-tags', remoto, `+refs/heads/${branch}:${(0, exports.refRemota)(remoto, branch)}`], { timeoutMs, env });
     if (r.ok)
         return { ponta: exigirGit(raiz, ['rev-parse', '--verify', (0, exports.refRemota)(remoto, branch)], prefixo).trim(), atualizado: true };
     if (/couldn't find remote ref|could not find remote ref/i.test(r.stderr)) {
@@ -102,7 +102,7 @@ function jsonsDaPonta(raiz, ponta, dir, prefixo) {
  * Grava uma versao nova da branch em cima de `ponta`, sem tocar arvore de trabalho nem indice:
  * indice temporario, blobs, `write-tree` e `commit-tree`. Push sem forca; recusa volta `false`.
  */
-function gravarNaBranch(raiz, remoto, branch, ponta, mudancas, mensagem, prefixo) {
+function gravarNaBranch(raiz, remoto, branch, ponta, mudancas, mensagem, prefixo, rede = {}) {
     const indice = path.join(fs.mkdtempSync(path.join(os.tmpdir(), 'ork-branch-estado-')), 'index');
     const env = { GIT_INDEX_FILE: indice };
     try {
@@ -121,7 +121,8 @@ function gravarNaBranch(raiz, remoto, branch, ponta, mudancas, mensagem, prefixo
         }
         const arvore = exigirGit(raiz, ['write-tree'], prefixo, { env }).trim();
         const commit = exigirGit(raiz, ['commit-tree', arvore, ...(ponta ? ['-p', ponta] : []), '-m', mensagem], prefixo).trim();
-        const push = git(raiz, ['push', '--quiet', remoto, `${commit}:refs/heads/${branch}`]);
+        // `rede`: prazo e ambiente so do que vai a rede (RM-037, achado A3: o fechamento nao espera 60 s).
+        const push = git(raiz, ['push', '--quiet', remoto, `${commit}:refs/heads/${branch}`], rede);
         if (push.ok) {
             git(raiz, ['update-ref', (0, exports.refRemota)(remoto, branch), commit]);
             return commit;