@orkastery/cli 0.5.1 → 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;
@@ -47,7 +48,18 @@ exports.lerThread = lerThread;
 exports.gravarThread = gravarThread;
 exports.avisoDeThreadSemBase = avisoDeThreadSemBase;
 exports.idDisponivel = idDisponivel;
+exports.pastaDaWorktree = pastaDaWorktree;
+exports.alvoDaWorktree = alvoDaWorktree;
+exports.worktreePrevista = worktreePrevista;
 exports.criarWorktree = criarWorktree;
+exports.pedidoDeWorktree = pedidoDeWorktree;
+exports.linhaDaWorktree = linhaDaWorktree;
+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;
@@ -58,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");
@@ -72,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');
@@ -99,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);
 }
@@ -124,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) {
@@ -141,6 +152,43 @@ function idDisponivel(raiz, abbrev, assunto) {
     }
     return { id: `${abbrev}-${candidato}`, assunto: candidato };
 }
+/**
+ * Pasta da worktree de uma thread: `worktree.dir` resolvido na arvore principal, nunca na worktree de onde o comando
+ * roda. P4 do ensaio da 0.5.0 (CHECK): com a chave valendo, o `ork thread new` rodado de dentro da worktree de outra
+ * thread aninhava a nova na pasta da mae, e o release da mae levava a da filha junto.
+ */
+function pastaDaWorktree(carregado, id) {
+    return path.resolve((0, estado_thread_1.raizDoEstado)(carregado.raiz), carregado.manifesto.worktree.dir, id);
+}
+/** Pasta e branch da worktree de uma thread: o que `criarWorktree` cria e o `--dry-run` preve. */
+function alvoDaWorktree(carregado, id, slug, opcoes = {}) {
+    return { dir: pastaDaWorktree(carregado, id), branch: opcoes.branchExistente ?? `ork/${slug}` };
+}
+/**
+ * P4 do ensaio da 0.5.0: a worktree que `criarWorktree` criaria para este id, sem criar nada. Mesma pasta, mesma
+ * branch e o commit de onde ela partiria: a branch existente (ciclo `merge-branch`), senao a base do manifesto,
+ * senao o HEAD. Diz tambem o que faria a criacao recusar: a pasta que ja existe, o repositorio sem commit ou a
+ * branch nova que ja existe.
+ */
+function worktreePrevista(carregado, id, slug, opcoes = {}) {
+    const alvo = alvoDaWorktree(carregado, id, slug, opcoes);
+    const refs = opcoes.branchExistente
+        ? [opcoes.branchExistente]
+        : [opcoes.base ?? carregado.manifesto.worktree.base_branch, 'HEAD'];
+    let commit = null;
+    for (const ref of refs) {
+        const r = (0, util_1.exec)('git', ['rev-parse', '--verify', ref], carregado.raiz);
+        if (r.ok) {
+            commit = r.stdout.trim();
+            break;
+        }
+    }
+    const branchJaExiste = !opcoes.branchExistente &&
+        (0, util_1.exec)('git', ['rev-parse', '--verify', '--quiet', `refs/heads/${alvo.branch}`], carregado.raiz).ok;
+    const falha = fs.existsSync(alvo.dir) ? 'pasta-existe'
+        : commit === null ? 'sem-commit' : branchJaExiste ? 'branch-existe' : null;
+    return { ...alvo, commit, falha };
+}
 /**
  * Cria a worktree isolada da thread (paralelismo sem colisao entre threads).
  *
@@ -150,8 +198,9 @@ function idDisponivel(raiz, abbrev, assunto) {
  */
 function criarWorktree(carregado, id, slug, opcoes = {}) {
     const { raiz, manifesto } = carregado;
-    const dir = path.resolve(raiz, manifesto.worktree.dir, id);
-    const branch = opcoes.branchExistente ?? `ork/${slug}`;
+    // 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}`);
     }
@@ -170,7 +219,7 @@ function criarWorktree(carregado, id, slug, opcoes = {}) {
         throw new Error(`git worktree add falhou: ${(r.stderr || r.stdout).trim()}`);
     }
     if (pastaNova)
-        (0, util_1.ignorarPastaNoGit)(pastaDasWorktrees, raiz);
+        (0, util_1.ignorarPastaNoGit)(pastaDasWorktrees, (0, estado_thread_1.raizDoEstado)(raiz));
     const lista = (0, util_1.exec)('git', ['worktree', 'list', '--porcelain'], raiz);
     const criada = lista.ok && lista.stdout.split('\n').some((l) => l.trim() === `worktree ${dir}`);
     if (!criada) {
@@ -179,6 +228,161 @@ function criarWorktree(carregado, id, slug, opcoes = {}) {
     (0, estado_thread_1.vincularEstado)(raiz, id, dir);
     return { dir, branch };
 }
+/**
+ * Resolve `--worktree`, `--sem-worktree` e `worktree.por_thread`. As flags vencem a chave; as duas juntas, ou
+ * `--sem-worktree` com valor (o parser leva o argumento seguinte), sao erro de uso. `--worktree` sozinho ou `auto`
+ * cria a worktree; outro texto e um diretorio que ja existe, como antes.
+ */
+function pedidoDeWorktree(flags, porThread) {
+    const worktree = flags.worktree === false ? undefined : flags.worktree;
+    if (typeof worktree === 'string' && !worktree.trim())
+        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((0, locale_1.msg)().thread.worktreeESemWorktree);
+    if (semWorktree)
+        return { criar: false, dir: null, origem: 'sem-worktree' };
+    if (worktree === true || worktree === 'auto')
+        return { criar: true, dir: null, origem: 'flag' };
+    if (typeof worktree === 'string')
+        return { criar: false, dir: worktree, origem: 'diretorio' };
+    return porThread ? { criar: true, dir: null, origem: 'chave' } : { criar: false, dir: null, origem: 'nenhuma' };
+}
+/**
+ * P4 do ensaio da 0.5.0: a linha que diz de onde veio a worktree da thread nova. Na criacao, so quando ela veio da
+ * chave (quem passou `--worktree auto` sabe de onde ela veio); no `--dry-run`, para qualquer origem.
+ */
+function linhaDaWorktree(por, gravada, variante) {
+    if (!por || (gravada && por !== 'chave'))
+        return null;
+    const m = (0, locale_1.msg)().thread;
+    if (por === 'chave')
+        return m.worktreeChave(gravada);
+    if (por === 'flag')
+        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
+ * branch em que a raiz estava na criacao (`thread.base.branch`), e a policy `push_direto_na_base` do manifesto barra
+ * (`block`), avisa (outro valor) ou deixa passar (sem ela, ou `off`) a entrega de uma branch para ela mesma ou da
+ * base. Raiz fora de branch (HEAD destacado ou repositorio sem commit) nao tem branch de origem.
+ */
+function avisoDeThreadSemWorktree(thread, manifesto, gravada = true) {
+    const base = manifesto.worktree.base_branch;
+    const branch = thread.base.branch;
+    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;
+    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) {
+    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 (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) {
+    if (origem === 'sem-worktree')
+        return avisoDeThreadSemWorktree(resultado.thread, manifesto, resultado.gravada);
+    if (origem === 'chave' && !resultado.worktreePor)
+        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)
@@ -198,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;
@@ -224,17 +430,25 @@ 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.
+    const exigeWorktree = variante ? (0, ciclos_1.definicaoDaVariante)(variante).exigeWorktree : false;
+    // P4 do ensaio da 0.5.0 (D4): o ciclo que exige worktree nao nasce sem ela, e a recusa sai antes de gravar.
+    if (exigeWorktree && opcoes.origemDaWorktree === 'sem-worktree') {
+        throw new Error(`o ciclo ${variante} exige worktree isolada: crie a thread sem --sem-worktree ou escolha outro ciclo`);
     }
     const reservation = opcoes.reservation;
     const operation = reservation ? (0, creation_operation_store_1.readCreationOperation)(raiz, reservation.operationId, reservation.principal) : null;
@@ -260,15 +474,15 @@ function criarThreadSerializada(carregado, opcoes) {
         && fs.readdirSync(dirThread(raiz, reservation.threadId)).some((name) => !/^\.thread\.json\..+\.tmp$/.test(name))) {
         throw new Error('creation.conflict: diretório reservado sem origem confirmada');
     }
+    // P4 do ensaio da 0.5.0 (CHECK): o ensaio usa o mesmo id livre da criacao (o `idDisponivel` so le o disco), para a
+    // worktree que ele mostra ser a que a criacao usaria.
     const { id, assunto } = reservation
         ? { id: reservation.threadId, assunto: reservation.threadId.slice(abbrev.length + 1) }
-        : opcoes.dryRun
-            ? { id: `${abbrev}-${assuntoBruto}`, assunto: assuntoBruto }
-            : idDisponivel(raiz, abbrev, assuntoBruto);
+        : idDisponivel(raiz, abbrev, assuntoBruto);
     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 } : {}),
@@ -291,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: [],
@@ -300,13 +515,39 @@ function criarThreadSerializada(carregado, opcoes) {
     };
     if (variante === 'feature-xl-faseada')
         thread.fatias = opcoes.fatias ?? 3;
-    if (opcoes.dryRun)
-        return { thread, gravada: false };
+    // P4 do ensaio da 0.5.0: por que a thread ganha a worktree. O ensaio e a chave preveem a worktree antes; a pedida
+    // por flag ou por ciclo segue direto ao git, como era. A pedida so pela chave espera o primeiro commit (D3): sem
+    // commit, a thread fica na raiz, como antes. O ciclo que exige worktree vence a chave e a flag na origem: a worktree
+    // e dele, e o `--sem-worktree` que a linha da chave sugeriria ele recusa (CHECK, rodada 2).
+    const pedeWorktree = opcoes.criarWorktree === true || exigeWorktree;
+    const pelaChave = opcoes.criarWorktree === true && opcoes.origemDaWorktree === 'chave';
+    const prevista = pedeWorktree && (opcoes.dryRun || pelaChave)
+        ? worktreePrevista(carregado, id, slug, { branchExistente: opcoes.branch }) : null;
+    const worktreePor = !pedeWorktree || (pelaChave && !exigeWorktree && prevista?.falha === 'sem-commit') ? null
+        : exigeWorktree ? 'ciclo' : pelaChave ? 'chave' : 'flag';
+    if (opcoes.dryRun) {
+        // P4 (D8): o ensaio mostra a worktree que a criacao usaria; quando ela recusaria, diz por que, em vez de preve-la.
+        if (worktreePor && prevista?.falha) {
+            return { thread, gravada: false, worktreePor: null,
+                worktreeFalharia: { motivo: prevista.falha, dir: prevista.dir, branch: prevista.branch, por: worktreePor } };
+        }
+        if (worktreePor && prevista?.commit) {
+            thread.worktree = prevista.dir;
+            thread.base = { branch: prevista.branch, commit: prevista.commit };
+        }
+        return { thread, gravada: false, worktreePor };
+    }
+    // P4 (CHECK): a worktree pedida so pela chave, com a pasta ou a branch ja ocupadas, recusa dizendo de onde veio o
+    // pedido e qual e a saida.
+    const ocupadaPelaChave = pelaChave && !exigeWorktree && prevista &&
+        (prevista.falha === 'pasta-existe' || prevista.falha === 'branch-existe') ? prevista : null;
+    if (ocupadaPelaChave) {
+        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;
-    // `greenfield`, `merge-branch` e `feature-xl-faseada` exigem worktree isolada: sao os
-    // ciclos que escrevem codigo em paralelo com outras threads.
-    const exigeWorktree = variante ? (0, ciclos_1.definicaoDaVariante)(variante).exigeWorktree : false;
-    if (opcoes.criarWorktree || exigeWorktree) {
+    if (worktreePor) {
         worktreeCriada = criarWorktree(carregado, id, slug, {
             branchExistente: opcoes.branch,
         });
@@ -317,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 } : {}),
@@ -328,20 +573,24 @@ function criarThreadSerializada(carregado, opcoes) {
         base: thread.base,
         projeto: manifesto.project.name,
         worktree: thread.worktree,
+        // P4 do ensaio da 0.5.0 (D9): quem abriu a thread sem worktree de proposito fica no rastro.
+        ...(opcoes.origemDaWorktree === 'sem-worktree' ? { semWorktree: true } : {}),
         variante,
         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, {
             dir: worktreeCriada.dir,
             branch: worktreeCriada.branch,
             base: manifesto.worktree.base_branch,
+            origem: worktreePor,
             fonte: 'git worktree list --porcelain',
         });
     }
-    return { thread, gravada: true };
+    return { thread, gravada: true, worktreePor };
 }
 /**
  * O bloco de loop que conduz a fase DESTA thread.
@@ -373,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');
@@ -460,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) {