@orkastery/cli 0.5.3 → 0.6.0

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,7 +58,12 @@ exports.avisoDeThreadSemWorktree = avisoDeThreadSemWorktree;
 exports.avisoDeWorktreeQueFalharia = avisoDeWorktreeQueFalharia;
 exports.avisoDeChaveSemCommit = avisoDeChaveSemCommit;
 exports.avisoDaWorktree = avisoDaWorktree;
+exports.prepararPedido = prepararPedido;
+exports.pedidoDaThread = pedidoDaThread;
 exports.novaThread = novaThread;
+exports.dependenciasPendentes = dependenciasPendentes;
+exports.prepararDependenciasPendentes = prepararDependenciasPendentes;
+exports.prepararDependenciasDaThread = prepararDependenciasDaThread;
 exports.exigirVarianteCompativel = exigirVarianteCompativel;
 exports.blocoDaThread = blocoDaThread;
 exports.pausaNaThread = pausaNaThread;
@@ -67,20 +73,26 @@ 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");
 const estado_thread_1 = require("./estado-thread");
 const creation_operation_store_1 = require("./creation-operation-store");
 const horario_1 = require("./horario");
+const check_modo_1 = require("./check-modo");
 const maquina_1 = require("./maquina");
 const conducao_texto_1 = require("./conducao-texto");
+const locale_1 = require("./locale");
+const branch_de_estado_1 = require("./branch-de-estado");
+const dependencias_da_worktree_1 = require("./dependencias-da-worktree");
 /** Diretorio de threads do projeto. */
 function dirThreads(raiz) {
     return path.join((0, manifest_1.dirEstado)((0, estado_thread_1.raizDoEstado)(raiz)), 'threads');
@@ -108,7 +120,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 +145,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) {
@@ -170,9 +178,11 @@ function alvoDaWorktree(carregado, id, slug, opcoes = {}) {
  */
 function worktreePrevista(carregado, id, slug, opcoes = {}) {
     const alvo = alvoDaWorktree(carregado, id, slug, opcoes);
+    const base = opcoes.base ?? carregado.manifesto.worktree.base_branch;
+    const remoto = (0, branch_de_estado_1.exigirRemoto)(carregado.manifesto.fabrica.remoto, 'worktree');
     const refs = opcoes.branchExistente
         ? [opcoes.branchExistente]
-        : [opcoes.base ?? carregado.manifesto.worktree.base_branch, 'HEAD'];
+        : [(0, branch_de_estado_1.refRemota)(remoto, base), base, 'HEAD'];
     let commit = null;
     for (const ref of refs) {
         const r = (0, util_1.exec)('git', ['rev-parse', '--verify', ref], carregado.raiz);
@@ -187,6 +197,36 @@ function worktreePrevista(carregado, id, slug, opcoes = {}) {
         : commit === null ? 'sem-commit' : branchJaExiste ? 'branch-existe' : null;
     return { ...alvo, commit, falha };
 }
+/**
+ * Resolve a base de uma worktree nova. Com remoto configurado e presente, a fonte e sempre
+ * `refs/remotes/<remoto>/<base>` atualizada por um fetch explicito; a branch local pode pertencer a
+ * outra worktree e ficar parada indefinidamente. Repositorio sem esse remoto preserva o caso local.
+ */
+function baseAtualDaWorktree(carregado, base) {
+    const { raiz, manifesto } = carregado;
+    const remoto = (0, branch_de_estado_1.exigirRemoto)(manifesto.fabrica.remoto, 'worktree');
+    const temRemoto = (0, util_1.exec)('git', ['remote', 'get-url', '--', remoto], raiz).ok;
+    let ref = base;
+    if (temRemoto) {
+        ref = (0, branch_de_estado_1.refRemota)(remoto, base);
+        const ambiente = { ...process.env, GIT_TERMINAL_PROMPT: '0',
+            GIT_SSH_COMMAND: process.env.GIT_SSH_COMMAND ?? 'ssh -o BatchMode=yes' };
+        const fetch = (0, util_1.exec)('git', ['fetch', '-q', '--no-tags', '--', remoto,
+            `+refs/heads/${base}:${ref}`], raiz, 120000, ambiente);
+        if (!fetch.ok) {
+            const saida = (fetch.stderr || fetch.stdout).trim().split('\n').slice(-2).join(' | ');
+            throw new locale_1.ErroDoCatalogo((m) => m.worktree.baseRemotaFalhou(remoto, base, saida));
+        }
+    }
+    const resolvida = (0, util_1.exec)('git', ['rev-parse', '--verify', ref], raiz);
+    if (!resolvida.ok) {
+        // Repositorio local ainda sem a branch do manifesto conserva a recusa historica do
+        // `git worktree add ... HEAD`; com remoto presente, o fetch acima ja teria recusado.
+        const head = (0, util_1.exec)('git', ['rev-parse', '--verify', 'HEAD'], raiz);
+        return { ref: 'HEAD', commit: head.ok ? head.stdout.trim() : util_1.COMMIT_DESCONHECIDO };
+    }
+    return { ref, commit: resolvida.stdout.trim() };
+}
 /**
  * Cria a worktree isolada da thread (paralelismo sem colisao entre threads).
  *
@@ -196,33 +236,42 @@ 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}`);
+        throw new locale_1.ErroDoCatalogo((m) => m.worktree.worktreeJaExisteEm(dir));
     }
     const base = opcoes.base ?? manifesto.worktree.base_branch;
-    const commitBase = (0, util_1.exec)('git', ['rev-parse', '--verify', base], raiz);
-    const ref = commitBase.ok ? commitBase.stdout.trim() : 'HEAD';
+    const resolvida = opcoes.branchExistente
+        ? (() => {
+            const r = (0, util_1.exec)('git', ['rev-parse', '--verify', opcoes.branchExistente], raiz);
+            if (!r.ok)
+                throw new locale_1.ErroDoCatalogo((m) => m.worktree.baseInexistente(opcoes.branchExistente));
+            return { ref: opcoes.branchExistente, commit: r.stdout.trim() };
+        })()
+        : baseAtualDaWorktree(carregado, base);
     // Fatia 2 do ensaio da 0.5.0 (P3): a pasta das worktrees que o ork cria agora nasce fora do git.
     const pastaDasWorktrees = path.dirname(dir);
     const pastaNova = !fs.existsSync(pastaDasWorktrees);
     // Branch nova (`-b`) no caso comum; branch que ja existe no ciclo `merge-branch`.
     const argumentos = opcoes.branchExistente
         ? ['worktree', 'add', dir, opcoes.branchExistente]
-        : ['worktree', 'add', '-b', branch, dir, ref];
+        : ['worktree', 'add', '-b', branch, dir, resolvida.ref];
     const r = (0, util_1.exec)('git', argumentos, raiz);
     if (!r.ok) {
-        throw new Error(`git worktree add falhou: ${(r.stderr || r.stdout).trim()}`);
+        const saida = (r.stderr || r.stdout).trim();
+        throw new locale_1.ErroDoCatalogo((m) => m.worktree.worktreeAddFalhou(saida));
     }
     if (pastaNova)
         (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) {
-        throw new Error(`worktree nao apareceu em \`git worktree list\` apos a criacao: ${dir}`);
+        throw new locale_1.ErroDoCatalogo((m) => m.worktree.worktreeNaoApareceu(dir));
     }
     (0, estado_thread_1.vincularEstado)(raiz, id, dir);
-    return { dir, branch };
+    return { dir, branch, commit: resolvida.commit };
 }
 /**
  * Resolve `--worktree`, `--sem-worktree` e `worktree.por_thread`. As flags vencem a chave; as duas juntas, ou
@@ -232,13 +281,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 +302,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 +318,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,11 +348,147 @@ 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)
         return criarThreadSerializada(carregado, opcoes);
-    return (0, creation_operation_store_1.withCreationLock)((0, estado_thread_1.raizDoEstado)(carregado.raiz), 'threads', () => criarThreadSerializada(carregado, opcoes));
+    const criada = (0, creation_operation_store_1.withCreationLock)((0, estado_thread_1.raizDoEstado)(carregado.raiz), 'threads', () => criarThreadSerializada(carregado, opcoes));
+    // RM-037 (defeito 2 de 19 e 20/10/2026): o preparo das dependencias roda depois da trava de criacao, que espera
+    // segundos, e nao os minutos de um `npm ci`.
+    if (!criada.gravada || !criada.worktreePor || !criada.thread.worktree)
+        return criada;
+    if (opcoes.adiarDependencias) {
+        adiarDependenciasDaThread(carregado, criada.thread.id, criada.thread.worktree);
+        return { ...criada, dependencias: null };
+    }
+    return { ...criada, dependencias: prepararDependenciasDaThread(carregado, criada.thread.id, criada.thread.worktree) };
+}
+/** RM-037 (CHECK 3 da ork-rm037defeit2): a criacao que nao pode esperar o preparo so o anota como pendente. */
+function adiarDependenciasDaThread(carregado, id, dir) {
+    const { dependencias } = carregado.manifesto.worktree;
+    if (!dependencias)
+        return;
+    (0, ledger_1.registrar)(dirThread(carregado.raiz, id), id, ledger_1.TIPOS_DE_EVENTO.worktreeDependenciasPendentes, { dir, comando: dependencias, fonte: 'worktree.dependencias do manifesto' });
+}
+/**
+ * RM-037 (CHECK 3 da ork-rm037defeit2): a worktree `dir` tem o preparo adiado na criacao sem um preparo ok depois dele? O
+ * preparo que falhou nao cobre: a baseline e o verify o repetem e recusam seguir enquanto ele falhar.
+ */
+function dependenciasPendentes(eventos, dir) {
+    let pendente = false;
+    for (const e of eventos) {
+        if (typeof e.dir !== 'string' || path.resolve(e.dir) !== path.resolve(dir))
+            continue;
+        if (e.tipo === ledger_1.TIPOS_DE_EVENTO.worktreeDependenciasPendentes)
+            pendente = true;
+        else if (e.tipo === ledger_1.TIPOS_DE_EVENTO.worktreeDependencias && e.ok === true)
+            pendente = false;
+    }
+    return pendente;
+}
+/**
+ * RM-037 (CHECK 3 da ork-rm037defeit2): roda o preparo que a criacao adiou, antes de a baseline ou o verify rodarem um
+ * comando, com a vez na fila pesada que eles ja seguram; `antes` so e chamado quando ha preparo a rodar (a renovacao da
+ * conducao pelo prazo dele), e o `executor` da operacao, quando ela traz um (o do sandbox do MCP), roda o preparo no lugar
+ * do executor do verify. Devolve o preparo rodado agora, ou `null` sem nada pendente; quem chama recusa a falha.
+ */
+function prepararDependenciasPendentes(carregado, id, dir, opcoes = {}) {
+    if (!dependenciasPendentes((0, ledger_1.lerLedger)(dirThread(carregado.raiz, id)), dir))
+        return null;
+    opcoes.antes?.();
+    return prepararDependenciasDaThread(carregado, id, dir, opcoes.executor);
+}
+/**
+ * RM-037 (defeito 2 de 19 e 20/10/2026): roda `worktree.dependencias` na worktree que acabou de nascer e grava o
+ * resultado no ledger da thread. Sem a chave no manifesto, nada roda e nada se grava. A falha nao desfaz nada.
+ */
+function prepararDependenciasDaThread(carregado, id, dir, executor) {
+    const comando = carregado.manifesto.worktree.dependencias;
+    if (!comando)
+        return null;
+    const preparo = (0, dependencias_da_worktree_1.prepararDependencias)(dir, comando, undefined, executor);
+    (0, ledger_1.registrar)(dirThread(carregado.raiz, id), id, ledger_1.TIPOS_DE_EVENTO.worktreeDependencias, (0, dependencias_da_worktree_1.eventoDoPreparo)(dir, preparo));
+    return preparo;
 }
 /**
  * I-42 (D12): variante que redesenha blocos nao cabe num modo de bloco unico e parcial.
@@ -342,21 +503,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 +531,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 +583,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 +606,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 +643,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) {
@@ -487,12 +653,15 @@ function criarThreadSerializada(carregado, opcoes) {
             branchExistente: opcoes.branch,
         });
         thread.worktree = worktreeCriada.dir;
-        const commitDaBranch = (0, util_1.exec)('git', ['rev-parse', worktreeCriada.branch], raiz);
         thread.base = {
             branch: worktreeCriada.branch,
-            commit: commitDaBranch.ok ? commitDaBranch.stdout.trim() : thread.base.commit,
+            commit: worktreeCriada.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 +679,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 +722,43 @@ 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))));
+    }
+    // RM-072 (D17): o modo do ultimo CHECK, so quando a thread ja teve verify.
+    if (thread.check) {
+        linhas.push(campo(r.check, m.check(check_modo_1.NOME_DO_MODO[thread.check.modo], thread.check.origem, (0, horario_1.formatarDataHoraRotulada)(thread.check.em), (0, util_1.shaCurto)(thread.check.commit))));
     }
-    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');
@@ -617,29 +792,28 @@ function threadsDaListagem(raiz, opcoes = {}) {
 /** Tabela de `ork thread list`. */
 function tabelaDeThreads(raiz, opcoes = {}) {
     const linhas = threadsDaListagem(raiz, opcoes);
+    // RM-061 (F3b): o texto pelo catalogo; o status (dado do `--json`) so se traduz na impressao, pelo id.
+    const mt = (0, locale_1.msg)().thread;
     if (linhas.length === 0) {
         // A divida paga aqui: a mensagem sugeria `--modo default`, um modo que
         // `parseModo` recusa, e e a origem provavel das 3 threads com `modo: default`
         // gravadas em disco. A sugestao agora e um modo que existe.
-        const vazio = opcoes.todas === true
-            ? 'Nenhuma thread em .orkastery/threads.'
-            : 'Nenhuma thread aberta ou pausada (use --todas para ver as fechadas).';
-        return `${vazio} Crie uma com: ork thread new "<nome>" --modo ${modos_1.ORDEM_DOS_MODOS[0]}`;
+        return mt.listaVazia(opcoes.todas === true, modos_1.ORDEM_DOS_MODOS[0]);
     }
     const corpo = linhas.map((l) => [
-        l.id, l.slug, l.tag, l.fase, l.status, String(l.pausas), String(l.sessoes),
+        l.id, l.slug, l.tag, l.fase, mt.status(l.status), String(l.pausas), String(l.sessoes),
     ]);
-    const t = (0, util_1.tabela)(['ID', 'SLUG', 'MODO', 'FASE', 'STATUS', 'PAUSAS', 'SESSOES'], corpo);
+    const t = (0, util_1.tabela)([...mt.colunasDaLista], corpo);
     if (opcoes.todas === true)
         return t;
     const fechadas = listarIds(raiz).length - linhas.length;
-    return fechadas > 0 ? `${t}\n\n  ${fechadas} fechada(s) omitida(s). Use --todas para ver todas.` : t;
+    return fechadas > 0 ? `${t}\n\n${mt.fechadasOmitidas(fechadas)}` : t;
 }
 /** Fase valida e pertencente ao ciclo da thread. */
 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;
 }