@orkastery/cli 0.4.2 → 0.5.0

package/dist/projeto-alvo.js

@@ -0,0 +1,551 @@
+"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.ORIGENS_DO_PROJETO = exports.FORA_DA_CONSULTA = exports.OFERTA_DA_REDE = exports.ErroDeProjeto = exports.PADRAO_DO_NOME_DE_PROJETO = exports.SAIDA_DE_PROJETO = exports.ENV_PROJETO_EXPLICITO = exports.ENV_PROJETO = exports.CONTRATO_CONSULTA = exports.CONTRATO_PROJETOS = void 0;
+exports.caminhoDoRegistro = caminhoDoRegistro;
+exports.lerRegistroDeProjetos = lerRegistroDeProjetos;
+exports.listarProjetos = listarProjetos;
+exports.raizCanonica = raizCanonica;
+exports.remotoSemCredencial = remotoSemCredencial;
+exports.remotoDoProjeto = remotoDoProjeto;
+exports.registrarProjeto = registrarProjeto;
+exports.registrarProjetoEmSilencio = registrarProjetoEmSilencio;
+exports.esquecerProjeto = esquecerProjeto;
+exports.candidatosDoHost = candidatosDoHost;
+exports.resolverProjetoAlvo = resolverProjetoAlvo;
+exports.fixarProjetoAlvo = fixarProjetoAlvo;
+exports.projetoAlvoAtual = projetoAlvoAtual;
+exports.raizParaExibir = raizParaExibir;
+exports.outrosProjetosConhecidos = outrosProjetosConhecidos;
+exports.semRemoto = semRemoto;
+exports.consultaDoProjeto = consultaDoProjeto;
+exports.linhasDaConsulta = linhasDaConsulta;
+/**
+ * RM-052: o projeto-alvo explicito.
+ *
+ * Em 29/09/2026 o dono pediu pelo Telegram o status do roadmap do orkastery e recebeu o panorama de
+ * `~/.openclaw/workspace`: as tools do host chamavam o `ork` sem projeto, o nucleo resolvia pelo
+ * `process.cwd()` do gateway e a saida nao dizia qual projeto tinha lido. Este modulo e a correcao
+ * no nucleo, em tres pecas:
+ *
+ *   1. o REGISTRO dos projetos desta maquina, `~/.orkastery/projetos.json` (contrato
+ *      `ork.projetos/v1`), alimentado por `ork init`, `ork thread new` e `ork fabrica entrar`. So
+ *      identificadores: nome, abbrev, raiz, remoto sem credencial e datas. Nenhum segredo;
+ *   2. a RESOLUCAO do projeto-alvo, com precedencia explicita sobre o cwd:
+ *      `--projeto` > `ORK_PROJETO` > host sem cwd (`ORK_PROJETO_EXPLICITO=1`) > cwd. Nome ambiguo ou
+ *      desconhecido recusa com `ErroDeProjeto` e a lista de candidatos; o nucleo nunca chuta;
+ *   3. o CABECALHO da consulta (`ork.consulta/v1`): qual projeto foi lido, por que ele, e o que NAO
+ *      foi lido, para nenhum leitor concluir "roadmap vazio" a partir de um board sem threads.
+ *
+ * O registro e por MAQUINA e nao reusa o portfolio da RM-019 (D1): o portfolio e estado canonico de
+ * UM projeto e nao conhece as raizes locais das copias. RM-053 e RM-054 leem este contrato.
+ */
+const fs = __importStar(require("node:fs"));
+const os = __importStar(require("node:os"));
+const path = __importStar(require("node:path"));
+const estado_thread_1 = require("./estado-thread");
+const manifest_1 = require("./manifest");
+const maquina_1 = require("./maquina");
+const policies_1 = require("./policies");
+const redacao_url_1 = require("./redacao-url");
+const util_1 = require("./util");
+exports.CONTRATO_PROJETOS = 'ork.projetos/v1';
+exports.CONTRATO_CONSULTA = 'ork.consulta/v1';
+/** O projeto pedido pelo ambiente, abaixo de `--projeto` e acima do cwd. */
+exports.ENV_PROJETO = 'ORK_PROJETO';
+/** Declarado pelos adaptadores de host: o cwd do gateway nao e projeto de ninguem (D3). */
+exports.ENV_PROJETO_EXPLICITO = 'ORK_PROJETO_EXPLICITO';
+/** Codigo de saida da recusa de projeto-alvo no CLI (D3). */
+exports.SAIDA_DE_PROJETO = 4;
+const ARQUIVO = 'projetos.json';
+const TRAVA = 'projetos.json.lock';
+/** Nome ou abbrev de projeto: o mesmo alfabeto dos identificadores de thread, sem barra. */
+exports.PADRAO_DO_NOME_DE_PROJETO = /^[a-zA-Z0-9][a-zA-Z0-9._-]{0,79}$/;
+/** A recusa tipada: o texto para o humano, o JSON para o host, os candidatos para escolher. */
+class ErroDeProjeto extends Error {
+    codigo;
+    detalhe;
+    candidatos;
+    correcao;
+    constructor(codigo, detalhe, candidatos, correcao) {
+        super(`${codigo}: ${detalhe}`);
+        this.codigo = codigo;
+        this.detalhe = detalhe;
+        this.candidatos = candidatos;
+        this.correcao = correcao;
+        this.name = 'ErroDeProjeto';
+    }
+    get recusa() {
+        return { erro: this.codigo, detalhe: this.detalhe, candidatos: this.candidatos, correcao: this.correcao };
+    }
+    get texto() {
+        return [
+            `${this.codigo}: ${this.detalhe}`,
+            ...(this.candidatos.length ? ['Candidatos:', ...this.candidatos.map((c) => `  • ${linhaDoCandidato(c)}`)] : []),
+            this.correcao,
+        ].join('\n');
+    }
+}
+exports.ErroDeProjeto = ErroDeProjeto;
+function linhaDoCandidato(c) {
+    return `${c.nome} (${c.abbrev || '-'}) · ${c.raiz} · ${c.remoto ?? 'sem remoto'}${c.presente ? '' : ' · ausente do disco'}`;
+}
+// ---------------------------------------------------------------------------
+// O registro.
+// ---------------------------------------------------------------------------
+function caminhoDoRegistro() {
+    return path.join((0, maquina_1.pastaDoUsuario)(), ARQUIVO);
+}
+const iso = (v) => typeof v === 'string' && Number.isFinite(Date.parse(v));
+const textoCurto = (v, teto) => typeof v === 'string' && !!v.trim() && v.length <= teto &&
+    !/[\x00-\x1f\x7f]/.test(v);
+const FONTES = ['init', 'thread new', 'fabrica entrar', 'projetos registrar', 'mcp thread new'];
+function entradaValida(v) {
+    if (!v || typeof v !== 'object' || Array.isArray(v))
+        return false;
+    const e = v;
+    return textoCurto(e.nome, 120) && typeof e.abbrev === 'string' && e.abbrev.length <= 16 &&
+        textoCurto(e.raiz, 4096) && path.isAbsolute(e.raiz) &&
+        (e.remoto === null || textoCurto(e.remoto, 2048)) && iso(e.registradoEm) && iso(e.atualizadoEm) &&
+        FONTES.includes(e.fonte);
+}
+/** Leitura tolerante: arquivo ausente, corrompido ou de outro contrato vale registro vazio. */
+function lerRegistroDeProjetos() {
+    const vazio = { contrato: exports.CONTRATO_PROJETOS, atualizadoEm: null, projetos: [] };
+    let bruto;
+    try {
+        bruto = JSON.parse(fs.readFileSync(caminhoDoRegistro(), 'utf8'));
+    }
+    catch {
+        return vazio;
+    }
+    if (!bruto || typeof bruto !== 'object' || bruto.contrato !== exports.CONTRATO_PROJETOS)
+        return vazio;
+    const projetos = bruto.projetos;
+    const atualizadoEm = bruto.atualizadoEm;
+    return { contrato: exports.CONTRATO_PROJETOS, atualizadoEm: iso(atualizadoEm) ? atualizadoEm : null,
+        projetos: Array.isArray(projetos) ? projetos.filter(entradaValida) : [] };
+}
+/** O manifesto ainda esta na raiz registrada? */
+function manifestoPresente(raiz) {
+    return [manifest_1.NOME_MANIFESTO, manifest_1.NOME_MANIFESTO_LEGADO].some((n) => fs.existsSync(path.join(raiz, n)));
+}
+function listarProjetos() {
+    return lerRegistroDeProjetos().projetos.map((p) => ({ ...p, presente: manifestoPresente(p.raiz) }))
+        .sort((a, b) => a.nome.localeCompare(b.nome) || a.raiz.localeCompare(b.raiz));
+}
+/** A raiz canonica de uma copia: a arvore principal da worktree, com caminho real. */
+function raizCanonica(raiz) {
+    const real = fs.realpathSync(path.resolve(raiz));
+    try {
+        return fs.realpathSync((0, estado_thread_1.raizDoEstado)(real));
+    }
+    catch {
+        return real;
+    }
+}
+/**
+ * A URL do remoto sem usuario nem senha: saem inteiros, nao so redigidos, como a RM-053 le o
+ * registro. A forma scp do git (`git@host:dono/repo.git`) e caminho local ficam como estao: o
+ * usuario de transporte nao e segredo. URL que nao se deixa ler cai na redacao de sempre.
+ */
+function remotoSemCredencial(url) {
+    if (!/^[a-z][a-z0-9+.-]*:\/\//i.test(url))
+        return url;
+    try {
+        const u = new URL(url);
+        if (!u.username && !u.password)
+            return url;
+        u.username = '';
+        u.password = '';
+        return u.toString();
+    }
+    catch {
+        return (0, redacao_url_1.redigirCredenciaisUrl)(url);
+    }
+}
+/** URL do remoto, sem credencial. `null` quando o projeto nao tem aquele remoto. */
+function remotoDoProjeto(raiz, remoto = 'origin') {
+    const r = (0, util_1.exec)('git', ['remote', 'get-url', remoto], raiz, 5000);
+    const url = r.ok ? r.stdout.trim() : '';
+    return url ? remotoSemCredencial(url) : null;
+}
+/**
+ * Trava curta do registro. O registro e um indice de conveniencia (D7): quem segura a trava e um
+ * processo vivo; trava de processo que ja morreu e retomada, porque ninguem mais vai solta-la.
+ */
+function comTrava(alterar, esperaMs = 2000) {
+    const dir = (0, maquina_1.pastaDoUsuario)(), trava = path.join(dir, TRAVA);
+    fs.mkdirSync(dir, { recursive: true });
+    const limite = Date.now() + esperaMs;
+    let fd;
+    for (;;) {
+        try {
+            fd = fs.openSync(trava, 'wx', 0o600);
+            break;
+        }
+        catch (e) {
+            if (e.code !== 'EEXIST')
+                throw e;
+            let dono = 0;
+            try {
+                dono = Number(JSON.parse(fs.readFileSync(trava, 'utf8')).pid);
+            }
+            catch { /* trava sendo escrita */ }
+            if (Number.isSafeInteger(dono) && dono > 0 && !processoVivo(dono)) {
+                fs.rmSync(trava, { force: true });
+                continue;
+            }
+            if (Date.now() >= limite)
+                throw new Error(`registro de projetos ocupado (${trava}); tente de novo`);
+            Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 10);
+        }
+    }
+    try {
+        fs.writeSync(fd, JSON.stringify({ pid: process.pid, em: new Date().toISOString() }));
+        return alterar();
+    }
+    finally {
+        fs.closeSync(fd);
+        fs.rmSync(trava, { force: true });
+    }
+}
+function processoVivo(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (e) {
+        return e.code === 'EPERM';
+    }
+}
+function gravarRegistro(registro) {
+    const dir = (0, maquina_1.pastaDoUsuario)(), destino = caminhoDoRegistro();
+    const conteudo = JSON.stringify(registro, null, 2) + '\n';
+    // Varredura final: o arquivo nunca carrega credencial, nem por um remoto mal redigido.
+    if ((0, policies_1.procurarSegredos)(conteudo).length)
+        throw new Error('registro de projetos recusado: o conteudo parece carregar segredo');
+    const temp = path.join(dir, `.${ARQUIVO}.${process.pid}.${Date.now()}.tmp`);
+    try {
+        fs.writeFileSync(temp, conteudo, { mode: 0o600, flag: 'wx' });
+        fs.renameSync(temp, destino);
+    }
+    finally {
+        fs.rmSync(temp, { force: true });
+    }
+}
+/**
+ * O projeto de um caminho qualquer dentro dele: a raiz do manifesto e, quando ela e a worktree de
+ * uma thread, a arvore principal (se a principal tem o proprio manifesto). `null` sem manifesto.
+ */
+function projetoDoCaminho(caminho) {
+    const local = (0, manifest_1.carregarManifesto)(caminho);
+    if (!local)
+        return null;
+    const raizLocal = fs.realpathSync(local.raiz), canonica = raizCanonica(raizLocal);
+    if (canonica !== raizLocal) {
+        const principal = (0, manifest_1.carregarManifesto)(canonica);
+        if (principal && fs.realpathSync(principal.raiz) === canonica)
+            return { raiz: canonica, carregado: principal };
+    }
+    return { raiz: raizLocal, carregado: local };
+}
+/**
+ * Registra (ou atualiza) o projeto do caminho informado. A raiz vira a canonica: registrar de dentro
+ * da worktree de uma thread registra a arvore principal.
+ */
+function registrarProjeto(caminho, fonte, opcoes = {}) {
+    const achado = projetoDoCaminho(caminho);
+    if (!achado) {
+        throw new ErroDeProjeto('projeto.sem-manifesto', `nenhum manifesto do ork em ${raizParaExibir(path.resolve(caminho))}`, [], 'Rode `ork init` na raiz do projeto antes de registrá-lo.');
+    }
+    const { raiz: canonica, carregado } = achado;
+    if (carregado.erros.length)
+        throw new Error(`registro de projetos: manifesto inválido em ${carregado.caminho}`);
+    const quando = opcoes.quando ?? new Date().toISOString();
+    const novo = {
+        nome: carregado.manifesto.project.name, abbrev: carregado.manifesto.project.abbrev, raiz: canonica,
+        remoto: remotoDoProjeto(canonica, carregado.manifesto.fabrica?.remoto ?? 'origin'), atualizadoEm: quando, fonte,
+    };
+    if ((0, policies_1.procurarSegredos)(JSON.stringify(novo)).length) {
+        throw new Error('registro de projetos recusado: a entrada parece carregar segredo');
+    }
+    return comTrava(() => {
+        const registro = lerRegistroDeProjetos();
+        const anterior = registro.projetos.find((p) => p.raiz === canonica);
+        const entrada = { ...novo, registradoEm: anterior?.registradoEm ?? quando };
+        registro.projetos = [...registro.projetos.filter((p) => p.raiz !== canonica), entrada]
+            .sort((a, b) => a.nome.localeCompare(b.nome) || a.raiz.localeCompare(b.raiz));
+        registro.atualizadoEm = quando;
+        gravarRegistro(registro);
+        return entrada;
+    }, opcoes.esperaMs);
+}
+/**
+ * D7: o registro nunca derruba o comando que o alimenta. Devolve o aviso para o terminal, ou `null`.
+ */
+function registrarProjetoEmSilencio(raiz, fonte) {
+    try {
+        registrarProjeto(raiz, fonte);
+        return null;
+    }
+    catch (e) {
+        return `aviso: projeto não registrado em ${caminhoDoRegistro()} (${e.message})`;
+    }
+}
+/** Tira do registro por nome, abbrev ou caminho. Nada casou e recusa, com os registrados. */
+function esquecerProjeto(alvo, cwd = process.cwd()) {
+    const valor = alvo.trim();
+    return comTrava(() => {
+        const registro = lerRegistroDeProjetos();
+        const porCaminho = ehCaminho(valor) ? caminhoPossivel(valor, cwd) : null;
+        const sai = registro.projetos.filter((p) => porCaminho ? p.raiz === porCaminho : casaNome(p, valor));
+        if (!sai.length) {
+            throw new ErroDeProjeto('projeto.desconhecido', `"${valor}" não está no registro de projetos desta máquina`, registro.projetos.map(candidatoDoRegistro), 'Veja os registrados com `ork projetos`.');
+        }
+        registro.projetos = registro.projetos.filter((p) => !sai.includes(p));
+        registro.atualizadoEm = new Date().toISOString();
+        gravarRegistro(registro);
+        return sai;
+    });
+}
+// ---------------------------------------------------------------------------
+// A resolucao.
+// ---------------------------------------------------------------------------
+function ehCaminho(valor) {
+    return valor.includes('/') || valor.startsWith('.') || valor.startsWith('~') || path.isAbsolute(valor);
+}
+function expandirHome(valor) {
+    return valor === '~' ? os.homedir() : valor.startsWith('~/') ? path.join(os.homedir(), valor.slice(2)) : valor;
+}
+/** Caminho real quando existe; o resolvido quando nao (esquecer uma raiz que sumiu do disco). */
+function caminhoPossivel(valor, cwd) {
+    const resolvido = path.resolve(cwd, expandirHome(valor));
+    try {
+        return fs.realpathSync(resolvido);
+    }
+    catch {
+        return resolvido;
+    }
+}
+function casaNome(p, valor) {
+    const v = valor.toLowerCase();
+    return p.nome.toLowerCase() === v || (!!p.abbrev && p.abbrev.toLowerCase() === v);
+}
+function candidatoDoRegistro(p) {
+    return { nome: p.nome, abbrev: p.abbrev, raiz: raizParaExibir(p.raiz), remoto: p.remoto, presente: manifestoPresente(p.raiz) };
+}
+/** A raiz do manifesto a partir de um caminho qualquer dentro do projeto. */
+function raizPorCaminho(valor, cwd) {
+    const dir = path.resolve(cwd, expandirHome(valor));
+    if (!fs.existsSync(dir)) {
+        throw new ErroDeProjeto('projeto.sem-manifesto', `o caminho ${raizParaExibir(dir)} não existe`, [], 'Informe o caminho da raiz de um projeto com orkastery.yaml, ou o nome de um projeto registrado (`ork projetos`).');
+    }
+    const achada = (0, util_1.subirAte)(dir, manifest_1.NOME_MANIFESTO) ?? (0, util_1.subirAte)(dir, manifest_1.NOME_MANIFESTO_LEGADO);
+    if (!achada) {
+        throw new ErroDeProjeto('projeto.sem-manifesto', `nenhum orkastery.yaml em ${raizParaExibir(dir)} nem acima dele`, [], 'Rode `ork init` na raiz do projeto, ou informe o nome de um projeto registrado (`ork projetos`).');
+    }
+    return fs.realpathSync(achada);
+}
+function raizPorNome(valor) {
+    if (!exports.PADRAO_DO_NOME_DE_PROJETO.test(valor)) {
+        throw new ErroDeProjeto('projeto.desconhecido', `"${valor}" não é um nome de projeto válido`, lerRegistroDeProjetos().projetos.map(candidatoDoRegistro), 'Use o nome ou o abbrev de um projeto de `ork projetos`.');
+    }
+    const registrados = lerRegistroDeProjetos().projetos;
+    const casados = registrados.filter((p) => casaNome(p, valor));
+    const presentes = casados.filter((p) => manifestoPresente(p.raiz));
+    if (presentes.length === 1)
+        return presentes[0].raiz;
+    if (presentes.length > 1) {
+        throw new ErroDeProjeto('projeto.ambiguo', `"${valor}" casa ${presentes.length} projetos registrados nesta máquina`, presentes.map(candidatoDoRegistro), 'Repita com o caminho da raiz (`--projeto <caminho>`), ou tire a cópia que sobra com `ork projetos esquecer <caminho>`.');
+    }
+    throw new ErroDeProjeto('projeto.desconhecido', casados.length ? `"${valor}" está registrado, mas o manifesto não está mais na raiz` : `"${valor}" não está no registro de projetos desta máquina`, registrados.map(candidatoDoRegistro), 'Veja os registrados com `ork projetos`; registre uma cópia com `ork projetos registrar <caminho>`.');
+}
+/**
+ * F2 do CHECK: o nome aponta a arvore principal; quem ja esta numa copia DESSE projeto (a worktree de
+ * uma thread) fica nela. Sem isso, `ORK_PROJETO` herdado numa worktree faria `ork docs verificar` ler
+ * a `main`. Caminho explicito nao passa por aqui: vale o caminho pedido.
+ */
+function copiaDoCwd(raiz, cwd) {
+    const local = (0, util_1.subirAte)(path.resolve(cwd), manifest_1.NOME_MANIFESTO) ?? (0, util_1.subirAte)(path.resolve(cwd), manifest_1.NOME_MANIFESTO_LEGADO);
+    if (!local)
+        return raiz;
+    try {
+        return raizCanonica(local) === raiz ? fs.realpathSync(local) : raiz;
+    }
+    catch {
+        return raiz;
+    }
+}
+function resolverValor(valor, cwd) {
+    return ehCaminho(valor) ? raizPorCaminho(valor, cwd) : copiaDoCwd(raizPorNome(valor), cwd);
+}
+/** Os candidatos de um host sem cwd de projeto: o registro presente e o projeto do cwd, sem repetir. */
+function candidatosDoHost(cwd) {
+    const saida = new Map();
+    for (const p of lerRegistroDeProjetos().projetos) {
+        if (manifestoPresente(p.raiz))
+            saida.set(p.raiz, candidatoDoRegistro(p));
+    }
+    const temManifesto = (0, util_1.subirAte)(path.resolve(cwd), manifest_1.NOME_MANIFESTO) ?? (0, util_1.subirAte)(path.resolve(cwd), manifest_1.NOME_MANIFESTO_LEGADO);
+    const local = temManifesto ? projetoDoCaminho(temManifesto) : null;
+    if (local && !saida.has(local.raiz)) {
+        const { raiz, carregado } = local;
+        saida.set(raiz, { nome: carregado.manifesto.project.name, abbrev: carregado.manifesto.project.abbrev,
+            raiz: raizParaExibir(raiz), remoto: remotoDoProjeto(raiz, carregado.manifesto.fabrica?.remoto ?? 'origin'), presente: true });
+    }
+    return [...saida.entries()].map(([raiz, candidato]) => ({ raiz, candidato }))
+        .sort((a, b) => a.candidato.nome.localeCompare(b.candidato.nome) || a.raiz.localeCompare(b.raiz));
+}
+/**
+ * RM-054 (fatia 2, D-G3): sem projeto pedido, a recusa oferece o panorama da rede, que le todos os
+ * projetos conhecidos sem escolher nenhum. A oferta sai do nucleo para valer em todo host, mesmo
+ * quando o modelo pula a instrucao da entrada dele.
+ */
+exports.OFERTA_DA_REDE = 'Para ver todos os projetos e as threads de todas as máquinas sem escolher, com a fonte e a hora de cada parte: ' +
+    '`ork network roadmap` (tool ork_network_roadmap).';
+/**
+ * O projeto-alvo do processo, ou `null` quando vale o cwd de sempre. Precedencia (D2):
+ * `--projeto` > `ORK_PROJETO` > host sem cwd (`ORK_PROJETO_EXPLICITO=1`, D3) > cwd.
+ */
+function resolverProjetoAlvo(entrada = {}) {
+    const ambiente = entrada.ambiente ?? process.env, cwd = entrada.cwd ?? process.cwd();
+    const host = (ambiente[exports.ENV_PROJETO_EXPLICITO] ?? '').trim() === '1';
+    if (entrada.opcao !== undefined && entrada.opcao !== null) {
+        const valor = entrada.opcao.trim();
+        if (!valor) {
+            throw new ErroDeProjeto('projeto.desconhecido', '--projeto sem valor', lerRegistroDeProjetos().projetos.map(candidatoDoRegistro), 'Uso: --projeto <nome|caminho>; os nomes registrados estão em `ork projetos`.');
+        }
+        // D4 (F1 do CHECK): no host, quem pede escolhe entre os projetos da maquina pelo NOME. Caminho nao
+        // entra por nenhuma tool, nem pela que repassa os argumentos como dados (os scripts do Hermes).
+        if (host && ehCaminho(valor)) {
+            throw new ErroDeProjeto('projeto.desconhecido', `no host o projeto vem pelo nome registrado; o caminho "${valor}" não é aceito`, lerRegistroDeProjetos().projetos.map(candidatoDoRegistro), 'Use o nome de um projeto de `ork projetos` (ex.: --projeto orkastery).');
+        }
+        return { raiz: resolverValor(valor, cwd), origem: 'opcao', pedido: valor };
+    }
+    const doAmbiente = (ambiente[exports.ENV_PROJETO] ?? '').trim();
+    if (doAmbiente)
+        return { raiz: resolverValor(doAmbiente, cwd), origem: 'ambiente', pedido: doAmbiente };
+    if (host) {
+        const candidatos = candidatosDoHost(cwd);
+        if (candidatos.length === 1)
+            return { raiz: copiaDoCwd(candidatos[0].raiz, cwd), origem: 'unico-conhecido', pedido: null };
+        if (candidatos.length > 1) {
+            throw new ErroDeProjeto('projeto.escolha', `${candidatos.length} projetos conhecidos nesta máquina e nenhum foi pedido; o ork não escolhe pelo diretório do gateway`, candidatos.map((c) => c.candidato), `Repita com o projeto pedido: parâmetro \`projeto\` da tool, ou \`--projeto <nome>\`. ${exports.OFERTA_DA_REDE}`);
+        }
+        throw new ErroDeProjeto('projeto.nenhum', 'nenhum projeto conhecido nesta máquina e nenhum foi pedido', [], 'Registre o projeto com `ork projetos registrar <caminho>` (ou `ork init` na raiz dele) e repita com o nome. ' +
+            'Sem clone nesta máquina, o roadmap de um projeto vem da forja: `ork network roadmap --projeto github:dono/repo` (tool ork_network_roadmap).');
+    }
+    return null;
+}
+// ---------------------------------------------------------------------------
+// O alvo do processo.
+// ---------------------------------------------------------------------------
+let alvoDoProcesso = null;
+/** Fixa o alvo do processo: as raizes padrao do manifesto passam a partir dele (`diretorioDoProjeto`). */
+function fixarProjetoAlvo(alvo) {
+    alvoDoProcesso = alvo;
+    (0, manifest_1.fixarDiretorioDoProjeto)(alvo?.raiz ?? null);
+}
+function projetoAlvoAtual() {
+    return alvoDoProcesso;
+}
+/** D8: `~` no lugar da pasta da conta. O texto vai a canais de conversa. */
+function raizParaExibir(raiz) {
+    const home = os.homedir();
+    if (raiz === home)
+        return '~';
+    return raiz.startsWith(home + path.sep) ? `~${path.sep}${raiz.slice(home.length + 1)}` : raiz;
+}
+/** Quantos OUTROS projetos presentes o registro desta maquina conhece. */
+function outrosProjetosConhecidos(raiz) {
+    let canonica;
+    try {
+        canonica = raizCanonica(raiz);
+    }
+    catch {
+        canonica = path.resolve(raiz);
+    }
+    return listarProjetos().filter((p) => p.presente && p.raiz !== canonica).length;
+}
+/**
+ * As fontes que uma leitura pode deixar de fora, na mesma frase em todo comando e canal. A ponteira
+ * entre parenteses e o panorama da rede (RM-054, fatia 2), que le as tres com a fonte e a hora: o
+ * agente que chega pelo shell, e nao pela tool do host, le esta linha antes de responder.
+ */
+exports.FORA_DA_CONSULTA = Object.freeze({
+    roadmap: 'roadmap (ork network roadmap)',
+    reservas: 'reservas do roadmap (ork network roadmap)',
+    outrasMaquinas: 'outras máquinas (ork network roadmap)',
+    threadsDaMaquina: 'threads deste projeto nesta máquina',
+});
+/** A lacuna de quem nao tem o remoto: nada foi lido de la, e isso nao e "nenhuma publicou". */
+function semRemoto(remoto) {
+    return `outras máquinas: o projeto não tem o remoto ${remoto}, nada foi lido de ork/fabrica-estado`;
+}
+exports.ORIGENS_DO_PROJETO = Object.freeze({
+    opcao: 'pela opção --projeto',
+    ambiente: 'por ORK_PROJETO',
+    'unico-conhecido': 'único projeto conhecido nesta máquina',
+    cwd: 'pelo diretório atual',
+    instalacao: 'fixado na instalação do servidor MCP',
+});
+/**
+ * Monta o cabecalho. `origem` explicita vence; sem ela, vale o alvo do processo quando ele e este
+ * projeto, e o cwd quando nao. `outrosProjetos: false` omite a contagem (o MCP e fixado num projeto
+ * e nao revela os demais).
+ */
+function consultaDoProjeto(carregado, opcoes) {
+    const alvo = projetoAlvoAtual();
+    const origem = opcoes.origem ?? (alvo && path.resolve(alvo.raiz) === path.resolve(carregado.raiz) ? alvo.origem : 'cwd');
+    const outros = opcoes.outrosProjetos === false ? 0 : outrosProjetosConhecidos(carregado.raiz);
+    const remoto = opcoes.remoto !== undefined ? opcoes.remoto
+        : remotoDoProjeto(carregado.raiz, carregado.manifesto.fabrica?.remoto ?? 'origin');
+    return {
+        contrato: exports.CONTRATO_CONSULTA,
+        projeto: { nome: carregado.manifesto.project.name, abbrev: carregado.manifesto.project.abbrev,
+            raiz: raizParaExibir(carregado.raiz), remoto, origem },
+        lido: [...opcoes.lido],
+        naoLido: [...opcoes.naoLido, ...(outros > 0 ? [`outros projetos desta máquina: ${outros} (ork projetos)`] : [])],
+    };
+}
+/** As duas linhas do cabecalho em texto: o projeto consultado e o que nao foi lido. */
+function linhasDaConsulta(c) {
+    const p = c.projeto;
+    return [
+        `Projeto consultado: ${p.nome} (${p.abbrev || '-'}) · ${p.raiz} · ${p.remoto ?? 'sem remoto'} · ${exports.ORIGENS_DO_PROJETO[p.origem]}`,
+        `Não lido: ${c.naoLido.length ? c.naoLido.join(' · ') : 'nada fora do projeto consultado'}`,
+    ];
+}

package/dist/prompts.js

@@ -257,7 +257,7 @@ Execute as fases deste bloco na ordem canonica, respeitando o escopo de cada fas
 Nao abra outra thread nem redespache a si mesmo. Se houver MCP do projeto, prefira suas ferramentas para estado e operacoes suportadas.
 No Claude com servidor \`orkastery\`, use nomes completos expostos: \`ToolSearch\` com \`select:mcp__orkastery__ork_thread_status,mcp__orkastery__ork_artifact_read\` descobre essas leituras; para outra ferramenta, selecione seu nome completo. Nao busque \`select:ork_thread_status\`. Outros hosts usam seu namespace descoberto.
 Quando disponiveis, use ork_artifact_read/write para objetivo, plano e parecer, e ork_claims_list/ork_claim_add para claims; nao escreva ledger nem estado canonico diretamente.
-Decisao que voce tomar sem perguntar ao dono vai ao ledger por \`ork decisao registrar <thread>\`, com o que foi decidido, o porque, como mudar, o custo de reverter agora e depois, o criterio escrito, quem decidiu e a evidencia; e assim que ela chega ao dono no resumo, em vez de sumir na conversa.
+Decisao que voce tomar sem perguntar ao dono vai ao ledger por \`ork decisao registrar <thread>\` (no MCP, \`ork_decision_record\`, pois o sandbox do codex nao grava o ledger), com o que foi decidido, o porque, como mudar, o custo de reverter agora e depois, o criterio escrito, quem decidiu e a evidencia; e assim que ela chega ao dono no resumo, em vez de sumir na conversa.
 Artefato de autoria do agente nao e recibo oficial; cadastrar claim nao significa verifica-la.
 Para registrar produto, prefira ork_git_commit com HEAD atual e paths com claims; use ork_verify para verificacao real e ork_ship com HEADs fonte/destino conferidos para entrega. Commit local nao e SHIP; retorno incomplete exige reconciliar estado e remoto antes de repetir. Permissao para consultar nao concede essas operacoes: respeite a autorizacao nativa e os gates.
 Decisao do dono deve ser apresentada pela sessao condutora ao host; a sessao filha nao responde nem assume a identidade do dono.

package/dist/pulse-consentimento.js

@@ -72,6 +72,7 @@ const path = __importStar(require("node:path"));
 const node_crypto_1 = require("node:crypto");
 const estado_thread_1 = require("./estado-thread");
 const hitl_gates_1 = require("./hitl-gates");
+const hitl_texto_livre_1 = require("./hitl-texto-livre");
 exports.CONTRATO_CONSENTIMENTO = 'ork.pulse-consent/v1';
 /**
  * Crockford base32 sem os quatro ambiguos (I, L, O, U). Com letra na frente e ao menos um digito,
@@ -140,7 +141,8 @@ function interpretarResposta(bruto, codigo) {
         return 'sim';
     if (['b', 'n', 'nao', 'não', 'agora nao', 'agora não'].includes(corpo))
         return 'nao';
-    return undefined;
+    // RM-048 (D2): o mesmo vocabulario fechado do texto livre ("pode seguir", "aprovo", "depois").
+    return (0, hitl_texto_livre_1.consentimentoDoTrecho)((0, hitl_texto_livre_1.lerTrecho)(corpo));
 }
 /**
  * A assinatura de um conjunto de candidatos: os mesmos gates, a mesma oferta. O pedido aberto nao
@@ -234,7 +236,7 @@ function responderConsentimento(raiz, entrada) {
         }
         return { resposta: estado.respondido.resposta, repetida: true, pedido, respondido: estado.respondido };
     }
-    if (Date.parse(quando) >= Date.parse(pedido.prazo)) {
+    if (Date.parse(quando) >= Date.parse(pedido.prazo) && entrada.aceitarVencido !== true) {
         throw new Error('consentimento do pulse: pedido vencido; nenhuma autorização concedida');
     }
     if (!resposta)

package/dist/pulse-delivery.js

@@ -240,6 +240,11 @@ function varrerPulse(opcoes) {
             const consentimento = fila.candidatos.length ? (0, monitor_lock_1.comLockDaConversa)(dir, () => (0, pulse_consentimento_1.abrirConsentimento)(raiz, { quando,
                 resumoSha256: assinaturaDoResumo(resumo), candidatos: fila.candidatos, prazoMin: Math.max(janelaMin, pulse_consentimento_1.PRAZO_PADRAO_MIN), estadoDir: dir })) : undefined;
             entregar((0, hitl_resumo_1.textoDoResumo)(resumo, { canal, codigo: consentimento?.codigo }), 'o resumo');
+            // RM-048 (D3): o resumo acabou de sair; a palavra solta ("sim") vale na janela curta dele.
+            try {
+                (0, pulse_resposta_1.atualizarEscuta)(raiz, quando, dir);
+            }
+            catch { /* dica de rota; a prova nao depende dela */ }
             // Marcado so depois do recibo do transporte: envio que falhou preserva a novidade.
             for (const item of itens)
                 vistas[item.id] = assinaturaPulse(item);