@orkastery/cli 0.5.3 → 0.5.6

package/dist/thread.js

@@ -39,6 +39,7 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.TETO_DO_PEDIDO = exports.ARQUIVO_DO_PEDIDO = void 0;
 exports.dirThreads = dirThreads;
 exports.dirThread = dirThread;
 exports.caminhoThread = caminhoThread;
@@ -57,6 +58,8 @@ exports.avisoDeThreadSemWorktree = avisoDeThreadSemWorktree;
 exports.avisoDeWorktreeQueFalharia = avisoDeWorktreeQueFalharia;
 exports.avisoDeChaveSemCommit = avisoDeChaveSemCommit;
 exports.avisoDaWorktree = avisoDaWorktree;
+exports.prepararPedido = prepararPedido;
+exports.pedidoDaThread = pedidoDaThread;
 exports.novaThread = novaThread;
 exports.exigirVarianteCompativel = exigirVarianteCompativel;
 exports.blocoDaThread = blocoDaThread;
@@ -67,12 +70,14 @@ exports.resumoDaThread = resumoDaThread;
 exports.threadsDaListagem = threadsDaListagem;
 exports.tabelaDeThreads = tabelaDeThreads;
 exports.exigirFase = exigirFase;
+const worktree_local_1 = require("./worktree-local");
 const fs = __importStar(require("node:fs"));
 const path = __importStar(require("node:path"));
 const ciclos_1 = require("./ciclos");
 const modos_1 = require("./modos");
 const manifest_1 = require("./manifest");
 const slug_1 = require("./slug");
+const node_crypto_1 = require("node:crypto");
 const types_1 = require("./types");
 const util_1 = require("./util");
 const ledger_1 = require("./ledger");
@@ -81,6 +86,7 @@ const creation_operation_store_1 = require("./creation-operation-store");
 const horario_1 = require("./horario");
 const maquina_1 = require("./maquina");
 const conducao_texto_1 = require("./conducao-texto");
+const locale_1 = require("./locale");
 /** Diretorio de threads do projeto. */
 function dirThreads(raiz) {
     return path.join((0, manifest_1.dirEstado)((0, estado_thread_1.raizDoEstado)(raiz)), 'threads');
@@ -108,7 +114,7 @@ function listarIds(raiz) {
 function lerThread(raiz, id) {
     const caminho = caminhoThread(raiz, id);
     if (!fs.existsSync(caminho)) {
-        throw new Error(`thread "${id}" nao encontrada em ${dirThreads(raiz)}`);
+        throw new locale_1.ErroDoCatalogo((m) => m.thread.naoEncontrada(id, dirThreads(raiz)));
     }
     return (0, util_1.lerJson)(caminho);
 }
@@ -133,11 +139,7 @@ function carimbarBase(raiz) {
 function avisoDeThreadSemBase(thread, gravada) {
     if (thread.base.commit !== util_1.COMMIT_DESCONHECIDO)
         return null;
-    return gravada
-        ? `Aviso: o repositório ainda não tem commit, e a thread ${thread.id} nasceu sem base: o ship não tem de onde partir. ` +
-            `Faça o primeiro commit, feche esta com ork thread close ${thread.id} --motivo engano --por <quem> ` +
-            '--justificativa "aberta antes do primeiro commit" e abra outra.'
-        : 'Aviso: o repositório ainda não tem commit, e a thread nasceria sem base: faça o primeiro commit antes de abrir a primeira thread.';
+    return (0, locale_1.msg)().thread.semBase(thread.id, gravada);
 }
 /** Resolve um id livre a partir do assunto normalizado (`<abbrev>-<assunto>`). */
 function idDisponivel(raiz, abbrev, assunto) {
@@ -196,6 +198,8 @@ function worktreePrevista(carregado, id, slug, opcoes = {}) {
  */
 function criarWorktree(carregado, id, slug, opcoes = {}) {
     const { raiz, manifesto } = carregado;
+    // RM-047 (P3): worktree.dir do manifesto fora da raiz só cria checkout com a confirmação desta máquina.
+    (0, worktree_local_1.exigirPastaDasWorktrees)(raiz, manifesto);
     const { dir, branch } = alvoDaWorktree(carregado, id, slug, opcoes);
     if (fs.existsSync(dir)) {
         throw new Error(`worktree ja existe em ${dir}`);
@@ -232,13 +236,12 @@ function criarWorktree(carregado, id, slug, opcoes = {}) {
 function pedidoDeWorktree(flags, porThread) {
     const worktree = flags.worktree === false ? undefined : flags.worktree;
     if (typeof worktree === 'string' && !worktree.trim())
-        throw new Error('uso: --worktree pede auto ou um diretório que já existe');
-    if (typeof flags.semWorktree === 'string') {
-        throw new Error(`uso: --sem-worktree não leva valor (recebeu "${flags.semWorktree}")`);
-    }
+        throw new Error((0, locale_1.msg)().thread.worktreeVazia);
+    if (typeof flags.semWorktree === 'string')
+        throw new Error((0, locale_1.msg)().thread.semWorktreeComValor(flags.semWorktree));
     const semWorktree = flags.semWorktree === true;
     if (semWorktree && worktree !== undefined)
-        throw new Error('uso: --worktree e --sem-worktree se excluem; use um dos dois');
+        throw new Error((0, locale_1.msg)().thread.worktreeESemWorktree);
     if (semWorktree)
         return { criar: false, dir: null, origem: 'sem-worktree' };
     if (worktree === true || worktree === 'auto')
@@ -254,13 +257,12 @@ function pedidoDeWorktree(flags, porThread) {
 function linhaDaWorktree(por, gravada, variante) {
     if (!por || (gravada && por !== 'chave'))
         return null;
-    const verbo = gravada ? 'criada' : 'seria criada';
-    if (por === 'chave') {
-        return `  worktree: ${verbo} pela chave worktree.por_thread do orkastery.yaml; para criar sem ela, use --sem-worktree`;
-    }
+    const m = (0, locale_1.msg)().thread;
+    if (por === 'chave')
+        return m.worktreeChave(gravada);
     if (por === 'flag')
-        return `  worktree: ${verbo} pelo --worktree auto`;
-    return `  worktree: ${verbo} pelo ciclo ${variante ?? 'da thread'}, que exige worktree isolada`;
+        return m.worktreeFlag(gravada);
+    return m.worktreeCiclo(gravada, variante ?? null);
 }
 /**
  * P4 do ensaio da 0.5.0: o que acontece no SHIP com a thread criada por `--sem-worktree`. O `ork ship` entrega a
@@ -271,49 +273,27 @@ function linhaDaWorktree(por, gravada, variante) {
 function avisoDeThreadSemWorktree(thread, manifesto, gravada = true) {
     const base = manifesto.worktree.base_branch;
     const branch = thread.base.branch;
-    const inicio = gravada
-        ? `Aviso: thread ${thread.id} sem worktree (--sem-worktree): ela trabalha na raiz do projeto`
-        : `Aviso: sem worktree (--sem-worktree), a thread ${thread.id} trabalharia na raiz do projeto`;
-    const ensure = `Antes do GO, ork worktree ensure ${thread.id} cria a worktree e a branch da thread`;
-    if (thread.base.commit === util_1.COMMIT_DESCONHECIDO) {
-        // Sem commit, nem o `ork worktree ensure` tem de onde partir: o caminho e o do aviso de thread sem base.
-        return `${inicio}, num repositório ainda sem commit, fora de qualquer branch, e o ork ship não tem branch de origem ` +
-            'para entregar. Faça o primeiro commit e siga o aviso de thread sem base.';
-    }
-    if (branch === 'HEAD') {
-        return `${inicio}, com o HEAD destacado, fora de qualquer branch, e o ork ship não tem branch de origem para entregar. ${ensure}.`;
-    }
-    if (branch !== base) {
-        return `${inicio}, na branch ${branch}, e o ork ship entrega essa branch como estiver, com o que mais entrar nela; ` +
-            `com --para ${branch}, a entrega vira push direto, que a policy push_direto_na_base confere. ${ensure}.`;
-    }
+    const aviso = (c) => (0, locale_1.msg)().thread.avisoSemWorktree(thread.id, gravada, c);
+    // Sem commit, nem o `ork worktree ensure` tem de onde partir: o caminho e o do aviso de thread sem base.
+    if (thread.base.commit === util_1.COMMIT_DESCONHECIDO)
+        return aviso({ caso: 'sem-commit' });
+    if (branch === 'HEAD')
+        return aviso({ caso: 'head' });
+    if (branch !== base)
+        return aviso({ caso: 'outra', branch });
     const policy = manifesto.policies?.push_direto_na_base;
-    const efeito = policy === 'block'
-        ? 'o ork ship barra a entrega por push_direto_na_base (block): não há branch de thread para mergear'
-        : policy === undefined || policy === 'off'
-            ? 'o ork ship empurra a base direto, sem branch de thread (push_direto_na_base desligada)'
-            : `o ork ship avisa push_direto_na_base (${policy}) e empurra a base direto, sem branch de thread`;
-    return `${inicio}, na branch base ${base}, e ${efeito}. ${ensure}; depois do GO, os commits já estão na base e o ship não os separa.`;
+    return aviso({ caso: 'base', base, policy: policy === undefined ? undefined : String(policy) });
 }
 /**
  * P4 do ensaio da 0.5.0 (CHECK): no `--dry-run`, por que a criacao de verdade recusaria a worktree, em vez de preve-la.
  * O ciclo que exige worktree nao aceita `--sem-worktree`, entao a saida so e sugerida para a chave e a flag.
  */
 function avisoDeWorktreeQueFalharia(f) {
-    const semWorktree = f.por === 'ciclo' ? '' : ' ou crie com --sem-worktree';
-    if (f.motivo === 'pasta-existe') {
-        return `Aviso: a pasta ${f.dir} já existe, e a criação de verdade recusaria a worktree da thread: tire a pasta${semWorktree}.`;
-    }
-    if (f.motivo === 'branch-existe') {
-        return `Aviso: a branch ${f.branch} já existe, e a criação de verdade recusaria a worktree da thread: tire a branch${semWorktree}.`;
-    }
-    return 'Aviso: o repositório ainda não tem commit, e a criação de verdade recusaria a worktree da thread no git worktree add: ' +
-        'faça o primeiro commit antes.';
+    return (0, locale_1.msg)().thread.worktreeFalharia(f.motivo, f.dir, f.branch, f.por === 'ciclo');
 }
 /** P4 do ensaio da 0.5.0: a worktree que a chave pede nao tem de onde partir num repositorio sem commit. */
 function avisoDeChaveSemCommit(gravada) {
-    return 'Aviso: worktree.por_thread pede a worktree da thread, mas o repositório ainda não tem commit: ' +
-        `a thread ${gravada ? 'nasceu' : 'nasceria'} na raiz do projeto, sem worktree.`;
+    return (0, locale_1.msg)().thread.chaveSemCommit(gravada);
 }
 /** P4: o aviso de worktree do `ork thread new`, para o stderr, ou `null` quando nao ha o que avisar. */
 function avisoDaWorktree(origem, resultado, manifesto) {
@@ -323,6 +303,86 @@ function avisoDaWorktree(origem, resultado, manifesto) {
         return avisoDeChaveSemCommit(resultado.gravada);
     return null;
 }
+/** RM-059 (T6.0): o arquivo do pedido guardado, na pasta da thread. */
+exports.ARQUIVO_DO_PEDIDO = 'pedido.md';
+/**
+ * O prompt da fase vai inteiro como UM argumento do `claude --bg`, e o Linux recusa argumento acima de
+ * 128 KiB (MAX_ARG_STRLEN); o pedido fica com a metade, para o template caber junto.
+ */
+exports.TETO_DO_PEDIDO = 64 * 1024;
+/** O pedido como ele vai ser guardado: sem espaco nas pontas, nao vazio e dentro do teto. */
+function prepararPedido(bruto) {
+    const texto = bruto.trim();
+    if (!texto)
+        throw new locale_1.ErroDoCatalogo((m) => m.thread.pedidoVazio);
+    const bytes = Buffer.byteLength(texto, 'utf8');
+    if (bytes > exports.TETO_DO_PEDIDO)
+        throw new locale_1.ErroDoCatalogo((m) => m.thread.pedidoGrande(bytes, exports.TETO_DO_PEDIDO));
+    return { texto, meta: { arquivo: exports.ARQUIVO_DO_PEDIDO, sha256: (0, node_crypto_1.createHash)('sha256').update(texto, 'utf8').digest('hex'), bytes } };
+}
+/**
+ * RM-059 (T6.0): o pedido guardado na criacao da thread, conferido contra o sha256 gravado; `null` na
+ * thread criada sem pedido. Arquivo que falta ou que nao bate com o sha256 (editado fora do nucleo) e
+ * erro tipado: o render nunca usa um pedido sem a prova de que e o da criacao.
+ */
+function pedidoDaThread(raiz, thread) {
+    const meta = thread.pedido;
+    if (!meta)
+        return null;
+    const restaurar = 'passe --pedido no render ou restaure o arquivo';
+    // O nome do arquivo e fixo: um thread.json editado nao aponta o render para outro arquivo do projeto.
+    if (meta.arquivo !== exports.ARQUIVO_DO_PEDIDO || !/^[a-f0-9]{64}$/.test(String(meta.sha256))) {
+        throw new Error(`thread.pedido.divergente: o pedido da thread ${thread.id} no thread.json nao e o que a criacao grava; ${restaurar}`);
+    }
+    const arquivo = path.join(dirThread(raiz, thread.id), exports.ARQUIVO_DO_PEDIDO);
+    let fd;
+    try {
+        fd = fs.openSync(arquivo, fs.constants.O_RDONLY | fs.constants.O_NOFOLLOW | fs.constants.O_NONBLOCK);
+    }
+    catch (e) {
+        if (e.code === 'ENOENT')
+            throw new Error(`thread.pedido.ausente: a thread ${thread.id} guardou o pedido em ${meta.arquivo} e ele sumiu; ${restaurar}`);
+        throw new Error(`thread.pedido.divergente: ${meta.arquivo} da thread ${thread.id} nao abre como arquivo comum; ${restaurar}`);
+    }
+    try {
+        const st = fs.fstatSync(fd);
+        if (!st.isFile() || st.size > exports.TETO_DO_PEDIDO)
+            throw new Error(`thread.pedido.divergente: ${meta.arquivo} da thread ${thread.id} nao e o arquivo guardado; ${restaurar}`);
+        const bytes = fs.readFileSync(fd);
+        const sha256 = (0, node_crypto_1.createHash)('sha256').update(bytes).digest('hex');
+        if (sha256 !== meta.sha256) {
+            throw new Error(`thread.pedido.divergente: ${meta.arquivo} da thread ${thread.id} nao bate com o sha256 gravado na criacao ` +
+                `(${(0, util_1.shaCurto)(meta.sha256)}): foi editado fora do nucleo; ${restaurar}`);
+        }
+        return { texto: bytes.toString('utf8'), sha256 };
+    }
+    finally {
+        fs.closeSync(fd);
+    }
+}
+/**
+ * Grava o pedido sem meio-termo: escreve num temporario com fsync e o liga ao nome final, que nao pode existir
+ * (o `link` recusa sobrescrever). Uma falha no meio nao deixa `pedido.md` pela metade.
+ */
+function gravarPedido(dir, texto) {
+    fs.mkdirSync(dir, { recursive: true });
+    const alvo = path.join(dir, exports.ARQUIVO_DO_PEDIDO);
+    const temporario = path.join(dir, `.${exports.ARQUIVO_DO_PEDIDO}.${process.pid}.${Date.now()}.tmp`);
+    const fd = fs.openSync(temporario, 'wx', 0o600);
+    try {
+        try {
+            fs.writeFileSync(fd, texto, 'utf8');
+            fs.fsyncSync(fd);
+        }
+        finally {
+            fs.closeSync(fd);
+        }
+        fs.linkSync(temporario, alvo);
+    }
+    finally {
+        fs.rmSync(temporario, { force: true });
+    }
+}
 /** Cria a thread: valida modo contra o manifesto, gera o slug e carimba a base. */
 function novaThread(carregado, opcoes) {
     if (opcoes.dryRun)
@@ -342,21 +402,23 @@ function exigirVarianteCompativel(variante, def) {
         return;
     const [unico, ...resto] = def.blocos;
     if (unico && resto.length === 0 && unico.fases.length < types_1.FASES.length) {
-        throw new Error(`o ciclo ${variante} redesenha os blocos e o modo ${def.tag} tem um bloco so ` +
-            `(${unico.fases.join('-')}): crie a thread sem --ciclo ou escolha um modo de ciclo completo`);
+        throw new locale_1.ErroDoCatalogo((m) => m.thread.varianteIncompativel(variante, def.tag, unico.fases.join('-')));
     }
 }
 function criarThreadSerializada(carregado, opcoes) {
     const { raiz, manifesto } = carregado;
     const permitidos = manifesto.conduction.allowed_modes;
     if (!permitidos.includes(opcoes.modo)) {
-        throw new Error(`modo ${modos_1.MODOS[opcoes.modo].tag} fora de conduction.allowed_modes ` +
-            `(permitidos: ${permitidos.map((m) => modos_1.MODOS[m].tag).join(', ')})`);
+        const tag = modos_1.MODOS[opcoes.modo].tag, lista = permitidos.map((p) => modos_1.MODOS[p].tag).join(', ');
+        throw new locale_1.ErroDoCatalogo((m) => m.thread.modoNaoPermitido(tag, lista));
     }
     const assuntoBruto = (0, slug_1.normalizarAssunto)(opcoes.assunto ?? opcoes.nome);
     if (!assuntoBruto) {
-        throw new Error(`nome "${opcoes.nome}" nao produz assunto valido (esperado [a-z0-9])`);
+        const nome = opcoes.nome;
+        throw new locale_1.ErroDoCatalogo((m) => m.thread.nomeSemAssunto(nome));
     }
+    // RM-059 (T6.0): o pedido e conferido antes de qualquer gravacao, tambem no ensaio.
+    const pedido = opcoes.pedido !== undefined ? prepararPedido(opcoes.pedido) : null;
     const abbrev = manifesto.project.abbrev;
     const def = (0, modos_1.definicaoDoModo)(opcoes.modo);
     const variante = opcoes.variante ?? null;
@@ -368,17 +430,18 @@ function criarThreadSerializada(carregado, opcoes) {
     if (variante) {
         const dv = (0, ciclos_1.definicaoDaVariante)(variante);
         if (dv.exigeBranch && !opcoes.branch) {
-            throw new Error(`o ciclo ${variante} parte de uma branch que ja existe: informe --branch <branch>`);
+            throw new locale_1.ErroDoCatalogo((m) => m.thread.cicloExigeBranch(variante));
         }
-        if (opcoes.branch) {
-            const existe = (0, util_1.exec)('git', ['rev-parse', '--verify', `refs/heads/${opcoes.branch}`], raiz);
+        const branch = opcoes.branch;
+        if (branch) {
+            const existe = (0, util_1.exec)('git', ['rev-parse', '--verify', `refs/heads/${branch}`], raiz);
             if (!existe.ok) {
-                throw new Error(`branch "${opcoes.branch}" nao existe neste repositorio`);
+                throw new locale_1.ErroDoCatalogo((m) => m.thread.branchInexistente(branch));
             }
         }
     }
     else if (opcoes.branch) {
-        throw new Error('--branch so vale com --ciclo merge-branch');
+        throw new locale_1.ErroDoCatalogo((m) => m.thread.branchSemCiclo);
     }
     // `greenfield`, `merge-branch` e `feature-xl-faseada` exigem worktree isolada: sao os
     // ciclos que escrevem codigo em paralelo com outras threads.
@@ -419,7 +482,7 @@ function criarThreadSerializada(carregado, opcoes) {
     const slug = opcoes.slug ?? (0, slug_1.montarSlug)(abbrev, assunto, blocos[0].slugFases);
     // O override `--slug` do builder tambem passa pela regex canonica.
     if (!(0, slug_1.slugValido)(slug)) {
-        throw new Error(`slug invalido: "${slug}" (regex canonica: ${slug_1.REGEX_SLUG.source})`);
+        throw new locale_1.ErroDoCatalogo((m) => m.thread.slugInvalido(slug, slug_1.REGEX_SLUG.source));
     }
     const thread = {
         ...(origin ? { creationOrigin: origin } : {}),
@@ -442,6 +505,7 @@ function criarThreadSerializada(carregado, opcoes) {
         sessoes: [],
         ...(opcoes.exigeRuntimeDiferente === true ? { exigeRuntimeDiferente: true } : {}),
         ...(opcoes.doneWhen && opcoes.doneWhen.length > 0 ? { doneWhen: opcoes.doneWhen } : {}),
+        ...(pedido ? { pedido: pedido.meta } : {}),
         decisoes: [],
         claims: [],
         leases: [],
@@ -478,8 +542,9 @@ function criarThreadSerializada(carregado, opcoes) {
     const ocupadaPelaChave = pelaChave && !exigeWorktree && prevista &&
         (prevista.falha === 'pasta-existe' || prevista.falha === 'branch-existe') ? prevista : null;
     if (ocupadaPelaChave) {
-        const qual = ocupadaPelaChave.falha === 'pasta-existe' ? `a pasta ${ocupadaPelaChave.dir}` : `a branch ${ocupadaPelaChave.branch}`;
-        throw new Error(`${qual} já existe, e a chave worktree.por_thread pede a worktree da thread: tire-a ou crie com --sem-worktree`);
+        const pasta = ocupadaPelaChave.falha === 'pasta-existe';
+        const alvo = pasta ? ocupadaPelaChave.dir : ocupadaPelaChave.branch;
+        throw new locale_1.ErroDoCatalogo((m) => m.thread.ocupadaPelaChave(pasta, alvo));
     }
     let worktreeCriada = null;
     if (worktreePor) {
@@ -493,6 +558,10 @@ function criarThreadSerializada(carregado, opcoes) {
             commit: commitDaBranch.ok ? commitDaBranch.stdout.trim() : thread.base.commit,
         };
     }
+    // RM-059 (T6.0): o pedido vai ao lado do thread.json, so com permissao do dono, como ele, e antes dele: o
+    // thread.json nunca aponta para um pedido que nao foi gravado.
+    if (pedido)
+        gravarPedido(dirThread(raiz, id), pedido.texto);
     gravarThread(raiz, thread);
     (0, ledger_1.registrar)(dirThread(raiz, id), id, ledger_1.TIPOS_DE_EVENTO.threadCriada, {
         ...(origin ? { creationOrigin: origin } : {}),
@@ -510,6 +579,7 @@ function criarThreadSerializada(carregado, opcoes) {
         branchDeOrigem: opcoes.branch ?? null,
         maquina: thread.maquina,
         ...(thread.roadmap ? { roadmap: thread.roadmap } : {}),
+        ...(pedido ? { pedido: pedido.meta } : {}),
     });
     if (worktreeCriada) {
         (0, ledger_1.registrar)(dirThread(raiz, id), id, ledger_1.TIPOS_DE_EVENTO.worktreeCriada, {
@@ -552,38 +622,39 @@ function canalDaSessao(s) {
 }
 function resumoDaThread(thread, conducao) {
     const def = (0, modos_1.definicaoDoModo)(thread.modo);
+    const m = (0, locale_1.msg)().thread, r = m.rotulos;
+    // RM-061 (F2a): o rotulo vem do catalogo, na largura do locale; o valor gravado (nome, criterio) sai como esta.
+    const campo = (rotulo, valor) => `  ${rotulo.padEnd(m.largura)} ${valor}`;
     const linhas = [];
-    linhas.push(`  id        ${thread.id}`);
-    linhas.push(`  slug      ${thread.slug}`);
-    linhas.push(`  nome      ${thread.nome}`);
-    linhas.push(`  modo      ${def.tag} (${pausasDaThread(thread)} pausas humanas previstas)`);
-    linhas.push(`  ciclo     ${thread.variante ?? 'padrao do modo'}`);
-    linhas.push(`  fase      ${thread.faseAtual}`);
-    linhas.push(`  status    ${thread.status}`);
-    linhas.push(`  base      ${thread.base.branch} @ ${(0, util_1.shaCurto)(thread.base.commit)}`);
-    linhas.push(`  worktree  ${thread.worktree ?? '(raiz do projeto)'}`);
+    linhas.push(campo(r.id, thread.id));
+    linhas.push(campo(r.slug, thread.slug));
+    linhas.push(campo(r.nome, thread.nome));
+    linhas.push(campo(r.modo, m.modo(def.tag, pausasDaThread(thread))));
+    linhas.push(campo(r.ciclo, thread.variante ?? m.cicloPadrao));
+    linhas.push(campo(r.fase, thread.faseAtual));
+    linhas.push(campo(r.status, m.status(thread.status)));
+    linhas.push(campo(r.base, `${thread.base.branch} @ ${(0, util_1.shaCurto)(thread.base.commit)}`));
+    linhas.push(campo(r.worktree, thread.worktree ?? m.raizDoProjeto));
     // I-36 (T17): quem passa a leitura da conducao ve a linha unica; sem ela o resumo fica como era.
     if (conducao !== undefined)
-        linhas.push(`  conducao  ${conducao ? (0, conducao_texto_1.linhaDeConducao)(conducao) : 'ninguem conduz agora'}`);
+        linhas.push(campo(r.conducao, conducao ? (0, conducao_texto_1.linhaDeConducao)(conducao) : m.ninguemConduz));
     // I-43 (D4, viga a): a exigencia so aparece quando existe, para nao poluir o resumo
     // das threads que nao a declararam.
-    if (thread.exigeRuntimeDiferente === true) {
-        linhas.push('  validacao CHECK em runtime diferente do GO (exigido pela thread)');
-    }
+    if (thread.exigeRuntimeDiferente === true)
+        linhas.push(m.validacao);
     // I-43 (D4, viga b): o criterio aparece COM o comando. Mostrar so o criterio seria
     // reproduzir a prosa do envelope numa tela nova.
     if (thread.doneWhen && thread.doneWhen.length > 0) {
-        linhas.push(`  pronto quando (${thread.doneWhen.length} criterio(s) executaveis)`);
+        linhas.push(m.prontoQuando(thread.doneWhen.length));
         for (const d of thread.doneWhen)
             linhas.push(`    ${d.criterio}\n      $ ${d.comando}`);
     }
     if (thread.score) {
-        linhas.push(`  score     ${thread.score.valor}/5 por ${thread.score.avaliadoPor} ` +
-            `(${thread.score.regime}) em ${(0, horario_1.formatarDataHoraRotulada)(thread.score.avaliadoEm)}`);
+        linhas.push(campo(r.score, m.score(thread.score.valor, thread.score.avaliadoPor, thread.score.regime, (0, horario_1.formatarDataHoraRotulada)(thread.score.avaliadoEm))));
     }
-    linhas.push('  blocos previstos');
+    linhas.push(m.blocosPrevistos);
     for (const b of thread.blocos) {
-        const marca = b.pausa ? `pausa prevista: ${b.pausaSobre}` : 'sem pausa humana prevista';
+        const marca = b.pausa ? m.pausaPrevista(m.pausaSobre(b.pausaSobre)) : m.semPausa;
         linhas.push(`    ${b.slugFases.padEnd(6)} ${b.fases.join('-').padEnd(18)} ${marca}`);
     }
     return linhas.join('\n');
@@ -639,7 +710,7 @@ function tabelaDeThreads(raiz, opcoes = {}) {
 function exigirFase(thread, bruto) {
     const fase = bruto.toUpperCase();
     if (!thread.fases.includes(fase)) {
-        throw new Error(`fase invalida: "${bruto}" (esperado uma de ${thread.fases.join(', ')})`);
+        throw new Error((0, locale_1.msg)().phase.faseInvalida(bruto, thread.fases.join(', ')));
     }
     return fase;
 }

package/dist/util.js

@@ -197,7 +197,14 @@ function lerJsonl(caminho) {
 /** Anexa um registro ao armazem JSONL, criando o diretorio que faltar. */
 function anexarJsonl(caminho, valor) {
     fs.mkdirSync(path.dirname(caminho), { recursive: true });
-    fs.appendFileSync(caminho, JSON.stringify(valor) + '\n', 'utf8');
+    // RM-047: O_NOFOLLOW; um armazém versionado como link (claims, board) não leva o append para fora da raiz.
+    const fd = fs.openSync(caminho, fs.constants.O_WRONLY | fs.constants.O_APPEND | fs.constants.O_CREAT | fs.constants.O_NOFOLLOW, 0o644);
+    try {
+        fs.writeFileSync(fd, JSON.stringify(valor) + '\n', 'utf8');
+    }
+    finally {
+        fs.closeSync(fd);
+    }
 }
 /** Proximo id sequencial de um armazem (`C1`, `C2`, ... / `F1`, `F2`, ...). */
 function proximoIdSequencial(ids, prefixo) {