@orkastery/cli 0.5.1 → 0.5.3

package/assets/orkmind_bridge.py

@@ -10,6 +10,7 @@ import math
 import os
 import re
 import sys
+from datetime import datetime, timezone
 
 
 class LegacyProvenanceCollision(ValueError):
@@ -370,6 +371,102 @@ async def health(store):
 ORK_COLLECTIONS = ('decision', 'handoff', 'rule', 'learning', 'roadmap')
 
 
+def no_universo(entry, tenant, agora=None):
+    """RM-038: o predicado unico do universo da busca (indice, vetor, FTS e status).
+
+    O search_by_tags governado ja tira expiradas e injection_risk; o search_by_text nao tira
+    injection_risk. O mesmo predicado vale nos dois caminhos, com o tenant conferido como item
+    de lista: texto nunca casa por substring. `agora` e o instante de ANTES da leitura: o que a
+    biblioteca devolveu como ativo continua ativo aqui, sem corrida de expiracao.
+    """
+    tags = getattr(entry, 'tags', None)
+    projeto = tags.get('project') if isinstance(tags, dict) else None
+    expira = getattr(entry, 'expires_at', None)
+    if expira is not None and expira.tzinfo is None:
+        expira = expira.replace(tzinfo=timezone.utc)
+    return (getattr(entry, 'collection', None) in ORK_COLLECTIONS
+            and isinstance(projeto, list) and tenant in projeto
+            and not getattr(entry, 'injection_risk', False)
+            and (expira is None or expira > (agora or datetime.now(timezone.utc))))
+
+
+async def ate_o_fim(contar, ler):
+    """RM-038: le com a janela da contagem mais um; janela cheia conta e le de novo uma vez.
+
+    Cheia so acontece com escrita concorrente entre a contagem e a leitura. Uma escrita isolada
+    se resolve na segunda leitura; cheia de novo, a resposta e falhar alto, nunca cortar.
+    """
+    for _ in range(2):
+        limite = await contar() + 1
+        lidas = await ler(limite)
+        if len(lidas) < limite:
+            return lidas
+    raise QueryError('memory.query.window-saturated')
+
+
+def universo_contract(request):
+    valid = isinstance(request, dict) and set(request) == {'op', 'tenant'}
+    tenant = request.get('tenant') if valid else None
+    if (not valid or request['op'] != 'universo' or not isinstance(tenant, str) or not tenant.strip()
+            or len(tenant) > 128 or re.search(r'[\x00-\x1f\x7f]', tenant) is not None):
+        raise QueryError('memory.universo.invalid')
+
+
+# Contagem SO de numeros: nenhuma coluna de conteudo sai da base por aqui. O tenant e o mesmo
+# predicado da leitura governada por tag (`tags @> {"project": [tenant]}`), que usa o indice de tags.
+FORA_DA_BUSCA_SQL = """
+    SELECT
+      count(*) FILTER (WHERE collection = ANY(%s) AND injection_risk
+                         AND (expires_at IS NULL OR expires_at > now())) AS injecao,
+      count(*) FILTER (WHERE collection = ANY(%s) AND expires_at IS NOT NULL AND expires_at <= now()) AS expiradas,
+      count(*) FILTER (WHERE NOT (collection = ANY(%s))) AS outras_colecoes
+    FROM memories
+    WHERE tags @> jsonb_build_object('project', jsonb_build_array(%s::text))
+"""
+
+
+async def contar_fora_da_busca(store, tenant):
+    """RM-038: quantas entradas do tenant ficam fora do universo e por que.
+
+    A API governada nao devolve o que filtra; a contagem le a tabela pela conexao do adapter
+    pgvector (o mesmo acesso do lock de add e handoff), so com count(*). Em outro backend a
+    contagem nao e medida e volta None.
+    """
+    if getattr(getattr(store, 'capabilities', None), 'backend', None) != 'pgvector':
+        return None
+    conn = await store.inner._get_conn()
+    colecoes = list(ORK_COLLECTIONS)
+    cur = await conn.execute(FORA_DA_BUSCA_SQL, (colecoes, colecoes, colecoes, tenant))
+    linha = await cur.fetchone()
+    return {'injecao': int(linha['injecao']), 'expiradas': int(linha['expiradas']),
+            'outrasColecoes': int(linha['outras_colecoes'])}
+
+
+async def universo(request, store):
+    """RM-038: o universo da busca do tenant, lido ate o fim, uma leitura governada por colecao.
+
+    O tenant e filtro na origem: texto de outro tenant nunca sai da base por aqui. A janela e a
+    colecao inteira mais um (ate_o_fim). Entrada fora do predicado e violacao. O vetor gravado na
+    base nao viaja: o ork nao o usa.
+    """
+    tenant = request['tenant']
+    agora = datetime.now(timezone.utc)
+    entradas = []
+    for colecao in ORK_COLLECTIONS:
+        async def contar(colecao=colecao):
+            return await store.count(colecao)
+        async def ler(limite, colecao=colecao):
+            return await store.search_by_tags({'project': [tenant]}, collection=colecao, limit=limite)
+        lidas = await ate_o_fim(contar, ler)
+        if any(e.collection != colecao or not no_universo(e, tenant, agora) for e in lidas):
+            raise QueryError('memory.query.scope-violation')
+        entradas.extend(lidas)
+    if len({e.id for e in entradas}) != len(entradas):
+        raise QueryError('memory.query.scope-violation')
+    return {'entradas': [e.model_dump(mode='json', exclude={'embedding'}) for e in entradas],
+            'foraDaBusca': await contar_fora_da_busca(store, tenant)}
+
+
 def fts_contract(request):
     valid = isinstance(request, dict) and set(request) == {'op', 'tenant', 'texto'}
     def text(value, maximum):
@@ -379,14 +476,16 @@ def fts_contract(request):
 
 
 async def fts(request, store):
-    """FTS da biblioteca (I-38 D9) com fronteira de tenant obrigatoria: devolve so ids, na ordem do ranking."""
+    """FTS da biblioteca (I-38 D9) restrito ao universo da busca (RM-038): 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', [])]}
+    agora = datetime.now(timezone.utc)
+    async def contar():
+        return await store.count()
+    async def ler(limite):
+        return await store.search_by_text(request['texto'], limit=limite)
+    entries = await ate_o_fim(contar, ler)
+    # O search_by_text alcanca injection_risk; o universo nao. Mesmo predicado do indice.
+    return {'ids': [e.id for e in entries if no_universo(e, request['tenant'], agora)]}
 
 
 async def execute(request, store):
@@ -403,6 +502,9 @@ async def execute(request, store):
     if op == 'fts':
         fts_contract(request)
         return await fts(request, store)
+    if op == 'universo':
+        universo_contract(request)
+        return await universo(request, store)
     if op == 'query':
         tags, collection, limit = query_contract(request)
         # GovernedStore conserva validade, anti-injection e visibilidade existentes.
@@ -417,8 +519,12 @@ async def execute(request, store):
         return [e.model_dump(mode='json') for e in entries]
     if op == 'export':
         collection = request['collection']
-        count = await store.count(collection)
-        entries = await store.search_by_tags({}, collection=collection, limit=count + 1)
+        async def contar():
+            return await store.count(collection)
+        async def ler(limite):
+            return await store.search_by_tags({}, collection=collection, limit=limite)
+        # RM-038: le ate o fim; janela cheia de novo e falha alta, nunca corte em silencio.
+        entries = await ate_o_fim(contar, ler)
         return [e.model_dump(mode='json') for e in entries]
     if op == 'get':
         entry = await store.retrieve(request['id'])
@@ -538,6 +644,8 @@ async def main(request):
         health_contract(request)
     if isinstance(request, dict) and request.get('op') == 'fts':
         fts_contract(request)
+    if isinstance(request, dict) and request.get('op') == 'universo':
+        universo_contract(request)
     native_schema_fields()
     from orkmind.core.config import OrkMindConfig
     from orkmind.store.factory import create_store

package/dist/adapters/claude-bg.js

@@ -66,6 +66,7 @@ exports.parar = parar;
 exports.pararAchada = pararAchada;
 exports.acharSessaoNasContas = acharSessaoNasContas;
 exports.ocupacaoDeContexto = ocupacaoDeContexto;
+const horario_1 = require("../horario");
 const util_1 = require("../util");
 const runtime_ambiente_1 = require("../runtime-ambiente");
 const path = __importStar(require("node:path"));
@@ -427,12 +428,25 @@ function casarDuracao(texto, agoraMs) {
 }
 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`
+ * RM-037 (fatia 5): o fuso IANA entre parenteses logo depois da hora (`resets 4:40am (<Area>/<Cidade>)`),
+ * quando o Intl o aceita. O nome vem do texto do runtime; nenhum nome literal de fuso mora aqui (I-35).
+ */
+function fusoDito(texto, depois) {
+    const m = /^\s*\(([A-Za-z][A-Za-z0-9_+-]*(?:\/[A-Za-z0-9_+-]+)*)\)/.exec(texto.slice(depois));
+    return m ? (0, horario_1.normalizarFuso)(m[1]) : undefined;
+}
+/** A data do dia seguinte no calendario (mes de 1 a 12), sem passar por fuso nenhum. */
+function diaSeguinte(ano, mes, dia) {
+    const d = new Date(Date.UTC(ano, mes - 1, dia + 1));
+    return [d.getUTCFullYear(), d.getUTCMonth() + 1, d.getUTCDate()];
+}
+/**
+ * N5: data e hora de relogio 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).
+ * vale o ano corrente, ou o seguinte quando a data ja ficou mais de um dia para tras. RM-037 (fatia 5):
+ * com o fuso entre parenteses, a hora e a desse fuso (`fusoDito`); sem ele, ou com um nome que o Intl
+ * recusa, a hora e lida no relogio desta maquina, como antes. `agoraMs` e a ancora: o instante da mensagem.
  */
 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);
@@ -449,6 +463,16 @@ function casarData(texto, agoraMs) {
         hora = 0;
     if (dia < 1 || dia > 31 || hora > 23 || minuto > 59)
         return null;
+    const fuso = fusoDito(texto, (m.index ?? 0) + m[0].length);
+    if (fuso) {
+        const ano = m[3] !== undefined ? Number(m[3]) : Number((0, horario_1.partesLocais)(agoraMs, fuso).ano);
+        let alvo = (0, horario_1.instanteNoFuso)(ano, mes + 1, dia, hora, minuto, fuso);
+        if (!Number.isFinite(alvo))
+            return null;
+        if (m[3] === undefined && alvo < agoraMs - 24 * 3600 * 1000)
+            alvo = (0, horario_1.instanteNoFuso)(ano + 1, mes + 1, dia, hora, minuto, fuso);
+        return Number.isFinite(alvo) ? { resetEm: new Date(alvo).toISOString(), trecho: m[0].trim() } : 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);
@@ -472,7 +496,17 @@ function casarRelogio(texto, agoraMs) {
         hora = 0;
     if (hora > 23 || minuto > 59)
         return null;
-    // Proxima ocorrencia daquela hora de relogio a partir de agora, no fuso da maquina.
+    // RM-037 (fatia 5): a proxima ocorrencia daquela hora depois da ancora, no fuso dito pelo runtime.
+    const fuso = fusoDito(texto, (m.index ?? 0) + m[0].length);
+    if (fuso) {
+        const p = (0, horario_1.partesLocais)(agoraMs, fuso);
+        let alvo = (0, horario_1.instanteNoFuso)(Number(p.ano), Number(p.mes), Number(p.dia), hora, minuto, fuso);
+        if (alvo <= agoraMs)
+            alvo = (0, horario_1.instanteNoFuso)(...diaSeguinte(Number(p.ano), Number(p.mes), Number(p.dia)), hora, minuto, fuso);
+        if (Number.isFinite(alvo))
+            return { resetEm: new Date(alvo).toISOString(), trecho: m[0].trim() };
+    }
+    // Sem fuso dito: a proxima ocorrencia daquela hora de relogio a partir da ancora, no fuso da maquina.
     const base = new Date(agoraMs);
     const alvo = new Date(base.getFullYear(), base.getMonth(), base.getDate(), hora, minuto, 0, 0);
     if (alvo.getTime() <= agoraMs)

package/dist/adapters/codex.js

@@ -174,9 +174,10 @@ function consultarRollouts(todas = false, casa = casaDoCodex()) {
                     continue;
                 try {
                     const fd = fs.openSync(arquivo, 'r');
-                    let primeira, cauda;
+                    let primeira, cauda, atividadeEm;
                     try {
-                        const tamanho = fs.fstatSync(fd).size;
+                        const st = fs.fstatSync(fd), tamanho = st.size;
+                        atividadeEm = st.mtimeMs;
                         const cab = Buffer.alloc(Math.min(tamanho, 65536));
                         fs.readSync(fd, cab, 0, cab.length, 0);
                         primeira = cab.toString('utf8').split('\n')[0];
@@ -207,7 +208,7 @@ function consultarRollouts(todas = false, casa = casaDoCodex()) {
                         catch { /* primeira/última linha do recorte pode estar parcial */ }
                     }
                     if (todas || state !== 'completed')
-                        sessoes.push({ sessionId: p.id, cwd: p.cwd, state, kind: 'codex-rollout' });
+                        sessoes.push({ sessionId: p.id, cwd: p.cwd, state, kind: 'codex-rollout', atividadeEm });
                 }
                 catch {
                     falhar(arquivo, 'leitura ou metadados inválidos ou duplicados');

package/dist/agents-md.js

@@ -60,6 +60,7 @@ Projeto: **${seguro(manifesto.project.name)}** (${seguro(manifesto.project.abbre
 - Edite produto somente na worktree vinculada; estado em \`.orkastery/\` pertence ao núcleo.
 - PLAN não implementa. GO usa commits atômicos. CHECK não corrige. SHIP acontece por \`ork ship\`.
 - Toda alegação exige claim e comando reproduzível; self-report não é evidência.
+- MASTER por omissão só da sua thread: \`ork master <thread> --aceitar-omissao\`; sem a thread, fecha também as entregas de outras frentes.
 ${comandos.length ? `\nVerificações do manifesto:\n\n${comandos.join('\n')}\n` : ''}
 Este bloco é mantido por \`ork init\`. Edite livremente o restante do arquivo.
 ${exports.FIM_AGENTS_ORK}`;

package/dist/auditrun.js

@@ -893,13 +893,14 @@ function abrirThreadDoAchado(carregado, achadoId, opcoes = {}) {
         };
     }
     const modo = opcoes.modo ?? manifesto.conduction.default_mode;
-    const { thread, gravada } = (0, thread_1.novaThread)(carregado, {
+    const { thread, gravada, worktreePor, worktreeFalharia } = (0, thread_1.novaThread)(carregado, {
         nome: opcoes.nome ?? achado.titulo,
         modo,
         slug: opcoes.slug,
         assunto: opcoes.assunto,
         worktree: opcoes.worktree ?? null,
         criarWorktree: opcoes.criarWorktree,
+        origemDaWorktree: opcoes.origemDaWorktree,
         dryRun: opcoes.dryRun,
         variante: opcoes.variante ?? null,
     });
@@ -909,6 +910,8 @@ function abrirThreadDoAchado(carregado, achadoId, opcoes = {}) {
             achado,
             thread,
             pedido,
+            worktreePor,
+            worktreeFalharia,
             motivo: null,
             detalhe: 'simulacao (--dry-run): nenhuma thread e nenhum carimbo no board foram gravados',
             correcao: '',
@@ -968,6 +971,7 @@ function abrirThreadDoAchado(carregado, achadoId, opcoes = {}) {
         achado,
         thread,
         pedido,
+        worktreePor,
         motivo: achado.claim.estado === 'nao-verificavel' ? 'claims.unverifiable' : null,
         detalhe: achado.claim.estado === 'nao-verificavel'
             ? `AVISO: a claim ${achado.claim.id} do achado nao tem comando de verificacao (motivo tipado claims.unverifiable, que avisa e nao bloqueia)`

package/dist/board.js

@@ -60,7 +60,7 @@ exports.textoDoBoard = textoDoBoard;
 const fs = __importStar(require("node:fs"));
 const path = __importStar(require("node:path"));
 const adapter = __importStar(require("./adapters/claude-bg"));
-const hitl_1 = require("./hitl");
+const sessoes_contas_1 = require("./sessoes-contas");
 const leases_1 = require("./leases");
 const ledger_1 = require("./ledger");
 const manifest_1 = require("./manifest");
@@ -102,28 +102,30 @@ function threadsDeTodosOsPerfis(carregado, todos = true) {
     const saida = [];
     for (const perfil of perfis) {
         const fila = (0, leases_1.lerFila)(perfil.raiz);
+        // RM-036 (D7): uma listagem por perfil. Por thread, a leitura do legado das worktrees se repetiria.
+        // I-36: a conducao (`exec:`) tem secao propria; o escalonador segue contando so os leases de escrita.
+        const ativos = (0, leases_1.listarLeases)(perfil.raiz).filter((l) => !(0, leases_1.expirado)(l) && (0, leases_1.tipoDoLease)(l.nome) !== 'exec');
         for (const id of (0, thread_1.listarIds)(perfil.raiz)) {
             const thread = (0, thread_1.lerThread)(perfil.raiz, id);
             saida.push({
                 perfil: perfil.nome,
                 raiz: perfil.raiz,
                 thread,
-                // I-36: a conducao (`exec:`) tem secao propria; o escalonador segue contando so os leases de escrita.
-                leases: (0, leases_1.leasesDaThread)(perfil.raiz, id).filter((l) => (0, leases_1.tipoDoLease)(l.nome) !== 'exec').map((l) => l.nome),
+                leases: [...new Set(ativos.filter((l) => l.thread === id).map((l) => l.nome))],
                 naFila: fila.filter((p) => p.thread === id),
             });
         }
     }
     return saida;
 }
-/** Estados de sessao do runtime, ou null quando ele nao pode ser consultado. */
-function estadosDeSessao() {
+/**
+ * Estados de sessao do runtime, ou null quando ele nao pode ser consultado. RM-056 (D7): de todas
+ * as contas (a do processo e cada perfil do store), com o fantasma fora da vaga e o codex vivo.
+ */
+function estadosDeSessao(raiz = null, staleMin) {
     if (!adapter.disponivel())
         return null;
-    return new Map(adapter
-        .listarSessoes()
-        .filter((s) => !!s.sessionId)
-        .map((s) => [s.sessionId, (0, hitl_1.estadoBruto)(s)]));
+    return (0, sessoes_contas_1.estadosNasContas)(raiz, { staleMin });
 }
 /**
  * RM-037 (rm037defeito, defeito 3): o portao de vaga do `ork phase run`. Com `max_parallel_threads: 5`,
@@ -210,7 +212,7 @@ function planejar(carregado, opcoes = {}) {
     const max = Math.max(1, manifesto.concurrency.max_parallel_threads);
     const staleMin = manifesto.concurrency.stale_after_min;
     const quando = opcoes.agora ?? (0, util_1.agora)();
-    const estados = opcoes.estados === undefined ? estadosDeSessao() : opcoes.estados;
+    const estados = opcoes.estados === undefined ? estadosDeSessao(raiz, staleMin) : opcoes.estados;
     const fila = (0, leases_1.lerFila)(raiz);
     // I-36: a conducao (`exec:`) nao entra na conta de vagas: a ocupacao da sessao ja sai do ledger
     // e do runtime (`avaliarOcupacao`), e conta-la de novo mudaria o escalonador.
@@ -231,7 +233,7 @@ function planejar(carregado, opcoes = {}) {
         if (t.status === 'fechada' || (0, sessoes_adopt_1.ehRegistroDeAdocao)(t))
             continue;
         const oc = ocupacoes.get(t.id);
-        const meus = ativos.filter((l) => l.thread === t.id).map((l) => l.nome);
+        const meus = [...new Set(ativos.filter((l) => l.thread === t.id).map((l) => l.nome))];
         const ocupa = oc.ocupaVaga || (meus.length > 0 && oc.classe === 'ociosa');
         if (!ocupa)
             continue;
@@ -254,7 +256,7 @@ function planejar(carregado, opcoes = {}) {
     for (const t of threads) {
         if (emAndamento.has(t.id))
             continue;
-        const meus = ativos.filter((l) => l.thread === t.id).map((l) => l.nome);
+        const meus = [...new Set(ativos.filter((l) => l.thread === t.id).map((l) => l.nome))];
         if (t.status === 'fechada') {
             vagas.push({
                 thread: t.id,
@@ -286,7 +288,7 @@ function planejar(carregado, opcoes = {}) {
                 situacao: 'pausada',
                 motivo: 'human.pending',
                 detalhe: oc.detalhe,
-                correcao: `ork gate request ${t.id}`,
+                correcao: oc.correcao ?? `ork gate request ${t.id}`,
                 leases: meus,
             });
             continue;
@@ -385,7 +387,7 @@ function devolverVagas(carregado, opcoes = {}) {
     const { raiz, manifesto } = carregado;
     const staleMin = manifesto.concurrency.stale_after_min;
     const quando = opcoes.agora ?? (0, util_1.agora)();
-    const estados = opcoes.estados === undefined ? estadosDeSessao() : opcoes.estados;
+    const estados = opcoes.estados === undefined ? estadosDeSessao(raiz, staleMin) : opcoes.estados;
     const quem = opcoes.por ?? 'escalonador (ork board reap)';
     const devolvidas = [];
     for (const id of (0, thread_1.listarIds)(raiz)) {

package/dist/branch-de-estado.js

@@ -33,9 +33,11 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.refRemota = void 0;
+exports.refRemota = exports.remotoValido = exports.REMOTO_DO_GIT = void 0;
 exports.git = git;
 exports.exigirGit = exigirGit;
+exports.remotoRedigido = remotoRedigido;
+exports.exigirRemoto = exigirRemoto;
 exports.pontaLocal = pontaLocal;
 exports.buscarBranch = buscarBranch;
 exports.jsonsDaPonta = jsonsDaPonta;
@@ -57,6 +59,7 @@ const node_child_process_1 = require("node:child_process");
 const fs = __importStar(require("node:fs"));
 const os = __importStar(require("node:os"));
 const path = __importStar(require("node:path"));
+const redacao_url_1 = require("./redacao-url");
 function git(raiz, args, extra = {}) {
     const r = (0, node_child_process_1.spawnSync)('git', args, { cwd: raiz, encoding: 'utf8', input: extra.input, timeout: extra.timeoutMs ?? 60000,
         env: { ...process.env, ...extra.env } });
@@ -68,6 +71,42 @@ function exigirGit(raiz, args, prefixo, extra = {}) {
         throw new Error(`${prefixo}.git: git ${args[0]} falhou: ${r.stderr.trim().split('\n').pop() ?? ''}`);
     return r.stdout;
 }
+/**
+ * Nome de remoto do git, como `origin`, `upstream` ou `meu-remoto.2`. O valor vem do manifesto
+ * versionado (`fabrica.remoto`) ou da linha de comando (`--remoto`): quem clona um repositorio roda
+ * o `orkastery.yaml` de outra pessoa. Um valor que comece com `-` viraria opcao do git, e uma URL
+ * escolheria o transporte (`ext::` roda comando): so este formato chega ao git (RM-047).
+ */
+exports.REMOTO_DO_GIT = /^[A-Za-z0-9][A-Za-z0-9._-]*(?:\/[A-Za-z0-9][A-Za-z0-9._-]*)*$/;
+/**
+ * `true` quando o valor e nome de remoto que pode ir ao git como argumento. Suspeitas da revisao de
+ * 03/10: o git aceita `/` no nome (`time/origem`), e a 0.5.2 tambem; cada parte comeca por letra ou
+ * digito, entao a barra nao abre caminho absoluto, `.`/`..`, opcao nem transporte.
+ */
+const remotoValido = (remoto) => typeof remoto === 'string' && remoto.length <= 64 && exports.REMOTO_DO_GIT.test(remoto) && !remoto.includes('..') && !remoto.endsWith('.');
+exports.remotoValido = remotoValido;
+/**
+ * O valor recusado, para a mensagem: sem credencial de URL, sem caractere de controle e curto.
+ * A mensagem vai ao terminal, ao log da publicacao em segundo plano e ao ledger.
+ */
+function remotoRedigido(remoto) {
+    if (typeof remoto !== 'string')
+        return `(${remoto === null ? 'null' : typeof remoto})`;
+    const semCredencial = (0, redacao_url_1.redigirCredenciaisUrl)(remoto);
+    const curto = semCredencial.length > 40 ? `${semCredencial.slice(0, 40)}...` : semCredencial;
+    return JSON.stringify(curto);
+}
+/**
+ * Recusa tipada (`<prefixo>.remoto-invalido`) antes de qualquer chamada ao git com o remoto.
+ * `prefixo` e o de quem usa: `fabrica` na fabrica, `roadmap` nas reservas.
+ */
+function exigirRemoto(remoto, prefixo) {
+    if ((0, exports.remotoValido)(remoto))
+        return remoto;
+    throw new Error(`${prefixo}.remoto-invalido: o remoto ${remotoRedigido(remoto)} não é nome de remoto do git ` +
+        '(letras, dígitos, ".", "_", "-" e "/" entre partes, cada parte começando por letra ou dígito, sem URL); nada foi passado ao git. ' +
+        'Corrija fabrica.remoto no orkastery.yaml ou --remoto (padrão: origin).');
+}
 const refRemota = (remoto, branch) => `refs/remotes/${remoto}/${branch}`;
 exports.refRemota = refRemota;
 /** A ultima copia lida da branch nesta maquina, sem rede. `null` quando nunca foi lida. */
@@ -80,16 +119,32 @@ function pontaLocal(raiz, remoto, branch) {
  * copia local com `atualizado: false`.
  */
 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)) {
-        // A branch ainda nao nasceu: a primeira gravacao a cria. Copia local antiga nao vale mais.
-        git(raiz, ['update-ref', '-d', (0, exports.refRemota)(remoto, branch)]);
-        return { ponta: null, atualizado: true };
+    exigirRemoto(remoto, prefixo);
+    for (let tentativa = 1;; tentativa++) {
+        // `--`: daqui para a frente, so repositorio e refspec, nunca opcao (RM-047).
+        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)) {
+            // A branch ainda nao nasceu: a primeira gravacao a cria. Copia local antiga nao vale mais.
+            git(raiz, ['update-ref', '-d', (0, exports.refRemota)(remoto, branch)]);
+            return { ponta: null, atualizado: true };
+        }
+        if (tentativa < TENTATIVAS_NA_DISPUTA_DE_REF && DISPUTA_DE_REF.test(r.stderr)) {
+            Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 50 * tentativa);
+            continue;
+        }
+        return { ponta: pontaLocal(raiz, remoto, branch), atualizado: false };
     }
-    return { ponta: pontaLocal(raiz, remoto, branch), atualizado: false };
 }
+/**
+ * Suspeitas da revisao de 03/10: dois `fetch` simultaneos na mesma copia (o `ork network status` e a
+ * publicacao no cache da casa, a leitura e a gravacao da fabrica no clone) disputam o lock da ref
+ * remota, e o perdedor sai com "incorrect old value provided" (ou "cannot lock ref") sem que a rede
+ * tenha falhado. A ref ja foi atualizada pelo vencedor: buscar de novo da certo.
+ */
+const DISPUTA_DE_REF = /incorrect old value provided|cannot lock ref|unable to create '[^']*\.lock'|is at [0-9a-f]+ but expected/i;
+const TENTATIVAS_NA_DISPUTA_DE_REF = 5;
 /** Os `.json` de um diretorio da ponta, ja lidos. Filtro por caminho: diretorio vazio some da arvore. */
 function jsonsDaPonta(raiz, ponta, dir, prefixo) {
     if (!ponta)
@@ -103,6 +158,7 @@ function jsonsDaPonta(raiz, ponta, dir, prefixo) {
  * indice temporario, blobs, `write-tree` e `commit-tree`. Push sem forca; recusa volta `false`.
  */
 function gravarNaBranch(raiz, remoto, branch, ponta, mudancas, mensagem, prefixo, rede = {}) {
+    exigirRemoto(remoto, prefixo);
     const indice = path.join(fs.mkdtempSync(path.join(os.tmpdir(), 'ork-branch-estado-')), 'index');
     const env = { GIT_INDEX_FILE: indice };
     try {
@@ -122,7 +178,7 @@ 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();
         // `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);
+        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;

package/dist/busca-semantica.js

@@ -6,10 +6,12 @@
  * deterministicos. Esta busca e superficie separada e todo resultado sai com
  * `deterministico: false`.
  *
- * O universo e o export governado do tenant (filtro de injecao e visibilidade da biblioteca):
+ * O universo e o universo da busca do tenant (RM-038: `universoDaBusca`, o mesmo do indice e do
+ * status, com a governanca da biblioteca aplicada na ponte):
  *  - vetor: cosseno da consulta contra o indice local do MESMO modelo e dimensao, so para
  *    entradas com sha256 coerente; nunca compara vetores de espacos diferentes;
- *  - FTS: `search_by_text` da biblioteca, filtrado por tenant na ponte e intersectado aqui;
+ *  - FTS: `search_by_text` da biblioteca, restrito ao universo na ponte e intersectado aqui (id
+ *    fora do universo e descartado e declarado, nunca em silencio);
  *  - fusao: RRF com k = 60.
  * A cadeia do vetor e primario, fallback local, nenhum; sem vetor, cai para FTS com motivo tipado.
  */
@@ -18,6 +20,7 @@ exports.CANDIDATOS_DO_VETOR = exports.LIMITE_MAXIMO_DA_BUSCA = exports.LIMITE_PA
 exports.cosseno = cosseno;
 exports.fundirRrf = fundirRrf;
 exports.buscarPorSignificado = buscarPorSignificado;
+exports.textoDaBuscaPorSignificado = textoDaBuscaPorSignificado;
 const indice_vetorial_1 = require("./indice-vetorial");
 exports.MODOS_DE_BUSCA = ['hibrido', 'vetor', 'fts'];
 /** D9: constante da fusao RRF. */
@@ -44,7 +47,7 @@ function fundirRrf(listas, k = exports.RRF_K) {
 }
 const resumo = (conteudo) => conteudo.split('\n')[0].slice(0, 100);
 /** Lado vetorial: o primeiro caminho da cadeia que tem indice, responde e fala o mesmo espaco. */
-function ladoVetorial(o) {
+function ladoVetorial(o, entradas) {
     const detalhes = [];
     let motivo = null;
     const falhar = (alvo, m, d) => {
@@ -103,7 +106,7 @@ function ladoVetorial(o) {
         }
         if (resposta.truncados?.length)
             detalhes.push(`${alvo}: consulta acima do contexto do modelo, embedada pelo comeco`);
-        const ranking = [...(0, indice_vetorial_1.vetoresCoerentes)(lido.indice, o.universo)]
+        const ranking = [...(0, indice_vetorial_1.vetoresCoerentes)(lido.indice, entradas)]
             .map(([id, v]) => ({ id, sim: cosseno(vetor, v) }))
             .sort((a, b) => b.sim - a.sim || a.id.localeCompare(b.id));
         return { alvo, modelo: espaco.modelo, ranking, motivo, detalhes };
@@ -112,14 +115,21 @@ function ladoVetorial(o) {
 }
 /** `ork memory search --texto`: ranking hibrido, nunca deterministico, sempre dentro do tenant. */
 function buscarPorSignificado(o) {
-    const universo = o.universo.filter(e => (e.tags.project ?? []).includes(o.tenant));
-    const porId = new Map(universo.map(e => [e.id, e]));
+    // RM-038 (D6): entrada alheia no universo e violacao antes de embedar a consulta, nunca descarte.
+    if (o.universo.tenant !== o.tenant)
+        throw new Error('memory.query.scope-violation');
+    (0, indice_vetorial_1.conferirUniverso)(o.universo.entradas, o.tenant, o.universo.lidoEm);
+    const doUniverso = new Set(o.universo.entradas.map(e => e.id));
+    // As entradas buscadas: o universo inteiro, ou so a colecao pedida.
+    const buscadas = o.colecao ? o.universo.entradas.filter(e => e.collection === o.colecao) : o.universo.entradas;
+    const porId = new Map(buscadas.map(e => [e.id, e]));
     const saida = { texto: o.texto, modo: o.modo, origem: 'nenhum', modeloUsado: null,
-        deterministico: false, motivo: null, detalhe: '', resultados: [], listas: { vetor: [], fts: [] } };
+        deterministico: false, motivo: null, detalhe: '', resultados: [], listas: { vetor: [], fts: [] },
+        ftsForaDoUniverso: 0, coberturaDoIndice: null };
     const detalhes = [];
     let similaridade = new Map();
     if (o.modo !== 'fts') {
-        const v = ladoVetorial({ ...o, universo });
+        const v = ladoVetorial(o, buscadas);
         detalhes.push(...v.detalhes);
         saida.motivo = v.motivo;
         if (v.alvo) {
@@ -128,22 +138,33 @@ function buscarPorSignificado(o) {
             const candidatos = v.ranking.slice(0, exports.CANDIDATOS_DO_VETOR);
             saida.listas.vetor = candidatos.map(c => c.id);
             similaridade = new Map(candidatos.map(c => [c.id, c.sim]));
+            // RM-038 (D7): o vetor so ranqueia o que o indice cobre; menos que o universo e dito aqui.
+            saida.coberturaDoIndice = { coerentes: v.ranking.length, universo: buscadas.length };
+            const aviso = (0, indice_vetorial_1.avisoDeCobertura)(v.ranking.length, buscadas, v.alvo, o.colecao ? ` na colecao ${o.colecao}` : '');
+            if (aviso)
+                detalhes.push(`vetor: ${aviso}`);
         }
     }
     if (o.modo !== 'vetor') {
+        let ftsFalhou = false;
         try {
             if (!o.buscarTexto)
                 throw new Error('memory.transport.fts');
-            // A ponte ja filtra o tenant; a intersecao com o universo governado vale de novo aqui.
-            saida.listas.fts = [...new Set(o.buscarTexto(o.tenant, o.texto))].filter(id => porId.has(id));
+            // A ponte ja restringe ao universo; a intersecao vale de novo aqui e a quantidade que sobra e declarada (D5).
+            const ids = [...new Set(o.buscarTexto(o.tenant, o.texto))];
+            saida.ftsForaDoUniverso = ids.filter(id => !doUniverso.has(id)).length;
+            if (saida.ftsForaDoUniverso)
+                detalhes.push(`fts: ${saida.ftsForaDoUniverso} id(s) fora do universo da busca descartado(s)`);
+            saida.listas.fts = ids.filter(id => porId.has(id));
         }
         catch (erro) {
-            const codigo = /^[a-z]+(?:\.[a-z-]+)+/.exec(erro instanceof Error ? erro.message : '')?.[0] ?? 'memory.transport.fts';
+            ftsFalhou = true;
+            const codigo = (0, indice_vetorial_1.codigoDaFalha)(erro, 'memory.transport.fts');
             detalhes.push(`fts: ${codigo}`);
             if (o.modo === 'fts' || saida.origem === 'nenhum')
                 saida.motivo = saida.motivo ?? codigo;
         }
-        if (saida.origem === 'nenhum' && !detalhes.some(d => d.startsWith('fts:')))
+        if (saida.origem === 'nenhum' && !ftsFalhou)
             saida.origem = 'fts';
     }
     const scores = fundirRrf([saida.listas.vetor, saida.listas.fts]);
@@ -159,3 +180,22 @@ function buscarPorSignificado(o) {
     saida.detalhe = detalhes.join('; ');
     return saida;
 }
+/**
+ * Texto de `ork memory search --texto`. Revisao de 03/10 (RM-038): o detalhe sai tambem sem motivo; o
+ * id do FTS fora do universo e o aviso de cobertura vivem nele, e o texto os perdia na busca que deu certo.
+ */
+function textoDaBuscaPorSignificado(r) {
+    const linhas = [`Busca por significado (NAO deterministica; modo ${r.modo}, origem ${r.origem}${r.modeloUsado ? ` ${r.modeloUsado}` : ''})`];
+    if (r.motivo)
+        linhas.push(`  motivo: ${r.motivo}${r.detalhe ? `; ${r.detalhe}` : ''}`);
+    else if (r.detalhe)
+        linhas.push(`  detalhe: ${r.detalhe}`);
+    linhas.push('');
+    r.resultados.forEach((e, i) => {
+        const sim = e.similaridade === null ? '' : `  similaridade ${e.similaridade}`;
+        linhas.push(`  ${i + 1}. [${e.collection}] ${e.id}  score ${e.score}  ${e.fontes.join('+')}${sim}`);
+        linhas.push(`      ${e.resumo}`);
+    });
+    linhas.push('', `  ${r.resultados.length} resultado(s); busca por tag continua em ork memory search --tags`);
+    return linhas.join('\n');
+}