@orkastery/cli 0.5.3 → 0.6.0

package/dist/vida-da-thread.js

@@ -0,0 +1,254 @@
+"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.VALIDADE_DA_VIDA_NO_RETRATO_MS = exports.VIDA_NAO_VERIFICADA = exports.chaveDaConta = exports.PRAZO_DA_LEITURA_MS = void 0;
+exports.motivoDaCausa = motivoDaCausa;
+exports.lerRuntime = lerRuntime;
+exports.vidaDaThread = vidaDaThread;
+exports.paradaDesde = paradaDesde;
+exports.textoDaParada = textoDaParada;
+exports.sessaoVivaNaThread = sessaoVivaNaThread;
+exports.vidaDoRetrato = vidaDoRetrato;
+/**
+ * RM-063 (F2): a sessao de cada thread, verificada no runtime, para as superficies que dizem "sigo".
+ *
+ * Incidente de 12/10/2026 (P2 da pagina da RM-063): com o despacho do GO da K7 morto e o daemon do
+ * claude-bg fora do ar, o `ork roadmap status` disse "sigo ork-rm026k7conhe na fase GO". O "sigo" saia de
+ * toda thread aberta com fase, ou do lease de conducao, que sobrevive a sessao morta ate a prova do fim.
+ *
+ * Agora so diz "sigo" quem tem sessao viva verificada no runtime: o `claude agents --json --all` de cada
+ * conta e os rollouts do codex, pela mesma consulta do inventario da RM-056 (fantasma e a sessao sem
+ * processo). Sessao fantasma, despacho falho ou nenhuma sessao viram "<thread> parada desde HH:MM:
+ * <motivo>", com o ultimo sinal de vida que o ledger guarda.
+ */
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const sessoes_contas_1 = require("./sessoes-contas");
+const estado_thread_1 = require("./estado-thread");
+const ledger_1 = require("./ledger");
+const horario_1 = require("./horario");
+const locale_roadmap_1 = require("./locale-roadmap");
+/** O prazo do `claude agents` na leitura da vida: o status nao espera um daemon travado por minutos. */
+exports.PRAZO_DA_LEITURA_MS = 20_000;
+/** A chave de uma conta que respondeu: o runtime, e o perfil quando a conta e de um perfil do store. */
+const chaveDaConta = (runtime, perfil) => `${runtime}:${perfil ?? ''}`;
+exports.chaveDaConta = chaveDaConta;
+/** O motivo de uma causa, no catalogo pedido (pt-BR por padrao: e o que vai ao `--json` e ao retrato). */
+function motivoDaCausa(c, m = locale_roadmap_1.ROADMAP_PT_BR.motivoDaParada) {
+    switch (c.tipo) {
+        case 'nenhumaSessao': return m.nenhumaSessao(c.fase);
+        case 'despachoFalhou': return m.despachoFalhou(c.fase, c.detalhe);
+        case 'sessaoCaiu': return m.sessaoCaiu(c.sessao, c.motivo);
+        case 'runtimeSemResposta': return m.runtimeSemResposta(c.runtime, c.detalhe, c.sessao);
+        case 'naoAparece': return m.naoAparece(c.sessao);
+        case 'fantasma': return m.fantasma(c.sessao);
+        case 'encerrada': return m.encerrada(c.sessao, c.estado);
+        case 'naoLida': return m.naoLida(c.detalhe);
+        case 'semAtividade': return m.semAtividade(c.sessao, c.minutos);
+        case 'retratoVelho': return m.retratoVelho(c.minutos);
+    }
+}
+const curto = (texto, teto = 100) => {
+    const limpo = String(texto ?? '').replace(/[\p{Cc}\s]+/gu, ' ').trim();
+    return limpo.length > teto ? `${limpo.slice(0, teto - 3)}...` : limpo;
+};
+/**
+ * `claude agents` e os rollouts do codex de cada conta desta maquina (a do processo e cada perfil do store), conta a
+ * conta: o que uma conta nao respondeu nao vira "a sessao nao aparece". Falha vira falha, nunca "sem sessao".
+ */
+function lerRuntime(raiz, prazoMs = exports.PRAZO_DA_LEITURA_MS) {
+    const responderam = new Set(), falhas = [], sessoes = [];
+    try {
+        const canonica = (0, estado_thread_1.raizDoEstado)(raiz);
+        const { contas, fontes } = (0, sessoes_contas_1.contasDeSessoes)(canonica);
+        for (const f of fontes)
+            if (!f.ok)
+                falhas.push(curto(f.detalhe, 120));
+        for (const conta of contas) {
+            const r = (0, sessoes_contas_1.consultarContas)(canonica, { todas: true, contas: [conta], prazoMs });
+            if (r.fontes.some((f) => f.ok)) {
+                responderam.add(conta.runtime);
+                responderam.add((0, exports.chaveDaConta)(conta.runtime, conta.perfil?.id ?? null));
+            }
+            else
+                falhas.push(...r.fontes.filter((f) => !f.ok).map((f) => `${f.origem}: ${curto(f.detalhe, 120)}`));
+            for (const s of r.sessoes) {
+                sessoes.push({ sessionId: s.sessionId, runtime: s.runtime, viva: s.viva, fantasma: s.fantasma,
+                    estado: String(s.state ?? s.status ?? '').trim().toLowerCase(), perfil: s.perfil,
+                    atividadeEm: typeof s.atividadeEm === 'number' ? s.atividadeEm : null });
+            }
+        }
+    }
+    catch (e) {
+        falhas.push(curto(e.message, 160));
+    }
+    return { responderam: [...responderam], falhas, sessoes };
+}
+/** O motivo tipado com o detalhe, sem repetir o motivo quando o detalhe ja comeca por ele. */
+function motivoComDetalhe(e) {
+    const motivo = typeof e.motivo === 'string' ? e.motivo : '';
+    const detalhe = typeof e.detalhe === 'string' ? e.detalhe : typeof e.erro === 'string' ? e.erro : '';
+    return !detalhe ? motivo || 'sem detalhe' : !motivo || detalhe.startsWith(motivo) ? detalhe : `${motivo}: ${detalhe}`;
+}
+function causaDaFalha(e, sessionId) {
+    if (sessionId && e.sessionId === sessionId)
+        return { tipo: 'sessaoCaiu', sessao: sessionId.slice(0, 8), motivo: curto(e.motivo, 40) };
+    return { tipo: 'despachoFalhou', fase: typeof e.fase === 'string' && e.fase ? e.fase : null, detalhe: curto(motivoComDetalhe(e), 90) };
+}
+/** Eventos que o proprio `ork` grava sobre a sessao: nao sao sinal de vida dela. */
+const SO_DO_ORK = /^(conducao_|retry_|despacho_idempotente$)/;
+/**
+ * A vida da thread: a sessao do despacho mais recente, de qualquer fase (o despacho de GO que falha deixa a thread
+ * em GOAL), e a falha do runtime depois dele. `leitura` so e chamada quando ha sessao a conferir: thread sem
+ * despacho nao custa consulta ao runtime.
+ */
+function vidaDaThread(t, eventos, leitura, agoraMs = Date.now()) {
+    const fase = t.faseAtual;
+    const parada = (desdeEm, causa, sessionId = null) => ({ viva: false, sessionId, desdeEm: desdeEm ?? null, motivo: motivoDaCausa(causa), causa });
+    const ultimoSinal = eventos.at(-1)?.ts ?? t.atualizadaEm ?? t.criadaEm ?? null;
+    let iDespacho = -1;
+    for (let i = eventos.length - 1; i >= 0; i--) {
+        const e = eventos[i];
+        if (e.tipo === ledger_1.TIPOS_DE_EVENTO.faseDespachada && typeof e.sessionId === 'string' && e.sessionId) {
+            iDespacho = i;
+            break;
+        }
+    }
+    const despacho = iDespacho >= 0 ? eventos[iDespacho] : null;
+    const registrada = (t.sessoes ?? []).at(-1) ?? null;
+    const sessionId = despacho ? String(despacho.sessionId) : registrada?.sessionId ?? null;
+    const runtime = (typeof despacho?.runtime === 'string' && despacho.runtime) || registrada?.runtime || 'claude-bg';
+    const perfilDoDespacho = despacho?.perfil?.id ??
+        registrada?.perfil?.id;
+    const perfil = typeof perfilDoDespacho === 'string' && perfilDoDespacho ? perfilDoDespacho : null;
+    // A falha que vale e a de depois do despacho corrente (a de antes ja foi superada por ele), e que nada superou depois:
+    // o gate liberado do mesmo motivo ou da mesma sessao, ou a fase que terminou bem.
+    const depois = eventos.slice(iDespacho + 1);
+    const falha = [...depois.entries()].reverse().find(([k, e]) => (e.tipo === ledger_1.TIPOS_DE_EVENTO.despachoFalhou ||
+        (e.tipo === ledger_1.TIPOS_DE_EVENTO.gateBloqueado && typeof e.motivo === 'string' && e.motivo.startsWith('runtime.'))) &&
+        !depois.slice(k + 1).some((p) => (p.tipo === ledger_1.TIPOS_DE_EVENTO.gateLiberado && (p.motivo === e.motivo ||
+            (!!e.sessionId && p.sessionId === e.sessionId))) || (p.tipo === 'phase_result' && p.ok === true)))?.[1] ?? null;
+    if (!sessionId) {
+        return falha ? parada(falha.ts, causaDaFalha(falha, null)) : parada(ultimoSinal, { tipo: 'nenhumaSessao', fase });
+    }
+    const l = leitura();
+    const s = l.sessoes.find((x) => x.runtime === runtime && (x.sessionId === sessionId || x.sessionId.startsWith(sessionId)));
+    if (s?.viva)
+        return { viva: true, sessionId, desdeEm: null, motivo: null };
+    if (falha)
+        return parada(falha.ts, causaDaFalha(falha, sessionId), sessionId);
+    const id = sessionId.slice(0, 8);
+    const daSessao = [...eventos].reverse().find((e) => e.sessionId === sessionId && !SO_DO_ORK.test(e.tipo))?.ts ?? despacho?.ts ?? ultimoSinal;
+    // A conta do despacho precisa ter respondido: a do perfil, ou qualquer uma do runtime quando o despacho nao teve perfil.
+    if (!l.responderam.includes(perfil ? (0, exports.chaveDaConta)(runtime, perfil) : runtime)) {
+        return parada(daSessao, { tipo: 'runtimeSemResposta', runtime, detalhe: l.falhas.length ? curto(l.falhas[0], 80) : null, sessao: id }, sessionId);
+    }
+    if (!s)
+        return parada(daSessao, { tipo: 'naoAparece', sessao: id }, sessionId);
+    if (s.fantasma)
+        return parada(daSessao, { tipo: 'fantasma', sessao: id }, sessionId);
+    // O codex so conta como vivo com atividade recente no rollout: sem ela e sem estado final, e silencio, nao fim.
+    if (s.runtime === 'codex' && s.estado !== 'completed' && typeof s.atividadeEm === 'number') {
+        return parada(new Date(s.atividadeEm).toISOString(), { tipo: 'semAtividade', sessao: id, minutos: Math.max(0, Math.floor((agoraMs - s.atividadeEm) / 60000)) }, sessionId);
+    }
+    return parada(daSessao, { tipo: 'encerrada', sessao: id, estado: s.estado || 'sem estado' }, sessionId);
+}
+/** "parada desde HH:MM: <motivo>", no fuso do dono; sem o instante, so o motivo. */
+function paradaDesde(v, opcoes = {}) {
+    const desde = v.desdeEm && Number.isFinite(Date.parse(v.desdeEm)) ? ` desde ${(0, horario_1.formatarHora)(v.desdeEm, opcoes)}` : '';
+    return `parada${desde}: ${v.motivo ?? 'sem sessão viva verificada no runtime'}`;
+}
+/** "<thread> parada desde HH:MM: <motivo>": a linha que substitui o "sigo" quando a sessao nao esta viva. */
+function textoDaParada(thread, v, opcoes = {}) {
+    return `${thread} ${paradaDesde(v, opcoes)}`;
+}
+/**
+ * RM-063 (F3, GO-FIX): ha sessao viva trabalhando na thread? Pelo sessionId conhecido ou pela worktree dela (o
+ * adaptador que falha ou lanca depois de abrir a sessao nao devolve o id). E a prova que o `ork retry run` pede antes
+ * de redespachar: sem ela, a fase pode ganhar uma segunda sessao na mesma worktree. `respondeu: false` quando o
+ * runtime nao respondeu: sem prova, nada e redespachado.
+ */
+function sessaoVivaNaThread(raiz, thread, ids, consultar = () => (0, sessoes_contas_1.consultarContas)((0, estado_thread_1.raizDoEstado)(raiz), { todas: false, prazoMs: exports.PRAZO_DA_LEITURA_MS })) {
+    let r;
+    try {
+        r = consultar();
+    }
+    catch (e) {
+        return { respondeu: false, sessionId: null, detalhe: curto(e.message, 120) };
+    }
+    const falha = r.fontes.find((f) => f.origem.startsWith('claude agents') && !f.ok);
+    if (falha)
+        return { respondeu: false, sessionId: null, detalhe: curto(`${f(falha.origem)}: ${falha.detalhe}`, 160) };
+    const real = (p) => { try {
+        return fs.realpathSync(p);
+    }
+    catch {
+        return path.resolve(p);
+    } };
+    const worktree = thread.worktree ? real(thread.worktree) : null;
+    const naWorktree = (cwd) => typeof cwd === 'string' && !!worktree &&
+        (real(cwd) === worktree || real(cwd).startsWith(worktree + path.sep));
+    const viva = r.sessoes.find((s) => s.viva && (ids.some((id) => id && (s.sessionId === id || s.sessionId.startsWith(id))) || naWorktree(s.cwd)));
+    return { respondeu: true, sessionId: viva?.sessionId ?? null, detalhe: null };
+}
+const f = (origem) => origem.replace(/\s+/g, ' ');
+/** A vida de quem nao foi verificado: o retrato de outra maquina que nao publica a sessao. */
+exports.VIDA_NAO_VERIFICADA = Object.freeze({ viva: false, sessionId: null, desdeEm: null, motivo: null });
+/**
+ * A vida que vem no retrato de outra maquina (`ork/fabrica-estado`): so vale com os tipos certos. Retrato
+ * antigo, sem o campo, ou com o campo fora do formato, vira "nao verificada", e a linha nao diz "sigo".
+ */
+function vidaDoRetrato(bruto, publicadoEm, quando) {
+    if (!bruto || typeof bruto !== 'object')
+        return exports.VIDA_NAO_VERIFICADA;
+    const v = bruto;
+    const textoOuNulo = (x) => x === null || typeof x === 'string';
+    if (typeof v.viva !== 'boolean' || !textoOuNulo(v.desdeEm) || !textoOuNulo(v.motivo))
+        return exports.VIDA_NAO_VERIFICADA;
+    // A sessao viva de um retrato velho nao e "sigo": a maquina que morreu depois de publicar seguiria "viva" para sempre.
+    const idadeMs = publicadoEm && quando ? Date.parse(quando) - Date.parse(publicadoEm) : NaN;
+    if (v.viva && Number.isFinite(idadeMs) && idadeMs > exports.VALIDADE_DA_VIDA_NO_RETRATO_MS) {
+        const causa = { tipo: 'retratoVelho', minutos: Math.floor(idadeMs / 60000) };
+        return { viva: false, sessionId: null, desdeEm: publicadoEm ?? null, motivo: motivoDaCausa(causa), causa };
+    }
+    // Parada sem motivo publicado nao vira "nao verificada": a outra maquina disse que a sessao nao esta viva.
+    const motivo = v.motivo === null ? (v.viva ? null : 'sem sessão viva') : curto(v.motivo, 120);
+    return { viva: v.viva, sessionId: null, desdeEm: v.desdeEm, motivo };
+}
+/**
+ * Ate quando a sessao viva de um retrato publicado vale: o retrato igual so volta ao remoto de hora em hora
+ * (`PULSACAO_MS` da fabrica), mais uma batida do pulse de folga.
+ */
+exports.VALIDADE_DA_VIDA_NO_RETRATO_MS = 75 * 60 * 1000;

package/dist/worktree-local.js

@@ -0,0 +1,167 @@
+"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.COMANDO_CONFIRMAR_WORKTREE = exports.ARQUIVO_WORKTREE_LOCAL = exports.CONTRATO_WORKTREE_LOCAL = void 0;
+exports.caminhoRealPrevisto = caminhoRealPrevisto;
+exports.pastaDasWorktreesPedida = pastaDasWorktreesPedida;
+exports.lerWorktreeLocal = lerWorktreeLocal;
+exports.recusaDePastaDasWorktrees = recusaDePastaDasWorktrees;
+exports.exigirPastaDasWorktrees = exigirPastaDasWorktrees;
+exports.confirmarWorktreeLocal = confirmarWorktreeLocal;
+exports.revogarWorktreeLocal = revogarWorktreeLocal;
+/**
+ * RM-047 (fronteira de confiança, P3): a pasta das worktrees fora da raiz vale só com a confirmação
+ * desta máquina.
+ *
+ * O `worktree.dir` mora no `orkastery.yaml`, que vem com o repositório, e o `git worktree add` cria o
+ * checkout (e o `.gitignore` da pasta) onde ele apontar. Dentro da raiz do projeto, pelo caminho real,
+ * nada muda. Fora dela (`..`, caminho absoluto ou um link versionado que leva para fora), a criação
+ * recusa com `worktree.dir-fora-da-raiz` até a máquina confirmar a mesma pasta com
+ * `ork setup worktree confirmar`. A confirmação fica em `.orkastery/private/worktree-local.json`, com
+ * as mesmas regras da postura de sandbox (P1): pasta 0700, arquivo 0600, nunca link, nunca rastreado
+ * pelo git, e só para este checkout e esta pasta.
+ */
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const estado_thread_1 = require("./estado-thread");
+const postura_local_1 = require("./postura-local");
+const util_1 = require("./util");
+const locale_1 = require("./locale");
+exports.CONTRATO_WORKTREE_LOCAL = 'ork.worktree-local/v1';
+exports.ARQUIVO_WORKTREE_LOCAL = 'worktree-local.json';
+/**
+ * Caminho real de um caminho que talvez ainda não exista: o real do ancestral mais próximo que existe,
+ * mais o resto. Um link no caminho (inclusive versionado no clone) é resolvido aqui.
+ */
+function caminhoRealPrevisto(alvo) {
+    let atual = path.resolve(alvo);
+    const resto = [];
+    for (;;) {
+        try {
+            return path.join(fs.realpathSync(atual), ...resto.reverse());
+        }
+        catch { /* sobe */ }
+        const pai = path.dirname(atual);
+        if (pai === atual)
+            return path.resolve(alvo);
+        resto.push(path.basename(atual));
+        atual = pai;
+    }
+}
+/** A pasta das worktrees que o manifesto pede, pelo caminho real, e se ela fica dentro da raiz. */
+function pastaDasWorktreesPedida(raiz, manifesto) {
+    let principal;
+    try {
+        principal = (0, estado_thread_1.raizDoEstado)(raiz);
+    }
+    catch {
+        principal = path.resolve(raiz);
+    }
+    const raizReal = caminhoRealPrevisto(principal);
+    const dir = caminhoRealPrevisto(path.resolve(principal, manifesto.worktree.dir));
+    const rel = path.relative(raizReal, dir);
+    const primeiro = rel.split(path.sep)[0];
+    const dentro = !rel.startsWith('..') && !path.isAbsolute(rel) && primeiro !== '.git';
+    return { dir, dentro };
+}
+/** Lê a confirmação local; `null` com o motivo quando ela não existe ou não vale. */
+function lerWorktreeLocal(raiz) {
+    const { bruto: o, motivo } = (0, postura_local_1.lerArquivoPrivado)(raiz, exports.ARQUIVO_WORKTREE_LOCAL);
+    if (!o)
+        return { local: null, motivo };
+    if (o.contrato !== exports.CONTRATO_WORKTREE_LOCAL || typeof o.dir !== 'string' || typeof o.raiz !== 'string' ||
+        typeof o.confirmadoEm !== 'string' || typeof o.por !== 'string') {
+        return { local: null, motivo: `${exports.ARQUIVO_WORKTREE_LOCAL} fora do contrato ${exports.CONTRATO_WORKTREE_LOCAL}` };
+    }
+    if (o.raiz !== (0, postura_local_1.raizRealDoEstado)(raiz))
+        return { local: null, motivo: 'a confirmação local é de outro checkout' };
+    return { local: o, motivo: null };
+}
+/** Comando que confirma a pasta nesta máquina; vai em toda recusa. */
+exports.COMANDO_CONFIRMAR_WORKTREE = 'ork setup worktree confirmar';
+/**
+ * A recusa da criação de worktree: `null` quando a pasta do manifesto fica dentro da raiz, ou quando
+ * a máquina confirmou exatamente essa pasta; senão o erro tipado com o comando que confirma.
+ */
+function recusaDePastaDasWorktrees(raiz, manifesto) {
+    const montar = montadorDaRecusa(raiz, manifesto);
+    return montar ? montar((0, locale_1.msg)('pt-BR')) : null;
+}
+/** RM-061 (F3b): a recusa pelo catalogo, com o que ela cita lido antes; `null` quando a pasta vale. */
+function montadorDaRecusa(raiz, manifesto) {
+    const { dir, dentro } = pastaDasWorktreesPedida(raiz, manifesto);
+    if (dentro)
+        return null;
+    const { local, motivo } = lerWorktreeLocal(raiz);
+    if (local && local.dir === dir)
+        return null;
+    const pedido = JSON.stringify(manifesto.worktree.dir).slice(0, 200);
+    return (m) => m.worktree.dirForaDaRaiz(pedido, dir, local ? local.dir : null, motivo, exports.COMANDO_CONFIRMAR_WORKTREE);
+}
+/** Lança a recusa, quando houver, pelo catalogo: o CLI a remonta no locale do comando. */
+function exigirPastaDasWorktrees(raiz, manifesto) {
+    const montar = montadorDaRecusa(raiz, manifesto);
+    if (montar)
+        throw new locale_1.ErroDoCatalogo(montar);
+}
+/**
+ * Grava a confirmação local da pasta que o manifesto pede hoje. Com `esperado`, ele precisa levar à
+ * mesma pasta: a máquina confirma o que leu, não o que o manifesto pode passar a dizer depois.
+ */
+function confirmarWorktreeLocal(raiz, manifesto, por, esperado) {
+    const { dir, dentro } = pastaDasWorktreesPedida(raiz, manifesto);
+    if (esperado !== undefined) {
+        let principal;
+        try {
+            principal = (0, estado_thread_1.raizDoEstado)(raiz);
+        }
+        catch {
+            principal = path.resolve(raiz);
+        }
+        const pedido = caminhoRealPrevisto(path.resolve(principal, esperado));
+        if (pedido !== dir) {
+            throw new Error(`worktree.dir-divergente: o orkastery.yaml leva a ${dir}, não a ${pedido}; nada foi confirmado`);
+        }
+    }
+    if (dentro)
+        throw new Error(`worktree.dir-dentro-da-raiz: ${dir} fica dentro do projeto e não precisa de confirmação`);
+    const local = { contrato: exports.CONTRATO_WORKTREE_LOCAL, dir, raiz: (0, postura_local_1.raizRealDoEstado)(raiz), confirmadoEm: (0, util_1.agora)(), por };
+    (0, postura_local_1.gravarArquivoPrivado)(raiz, exports.ARQUIVO_WORKTREE_LOCAL, local);
+    return local;
+}
+/** Apaga a confirmação local; devolve se havia uma. */
+function revogarWorktreeLocal(raiz) {
+    return (0, postura_local_1.revogarArquivoPrivado)(raiz, exports.ARQUIVO_WORKTREE_LOCAL);
+}