@orkastery/cli 0.2.0

package/dist/policies.js

@@ -0,0 +1,176 @@
+"use strict";
+/**
+ * Policies executaveis do manifesto (bloco B1).
+ *
+ * O bloco `policies:` do `orkastery.yaml` deixa de ser prosa e passa a ser codigo:
+ * cada policy conhecida tem um gate (`when`), uma severidade (`block` ou `warn`) e um
+ * avaliador deterministico. Policy `block` violada reprova em QUALQUER modo, inclusive
+ * `#Auto`, porque o modo afrouxa a pausa e nunca a verificacao.
+ *
+ * Policy declarada no manifesto que o `ork` nao conhece nao e silenciosamente ignorada:
+ * ela volta na lista de desconhecidas, para o `doctor` e o CLI dizerem que ela nao vale.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.POLICIES_CONHECIDAS = void 0;
+exports.procurarSegredos = procurarSegredos;
+exports.policiesDesconhecidas = policiesDesconhecidas;
+exports.avaliarPolicies = avaliarPolicies;
+exports.bloqueantes = bloqueantes;
+exports.motivoDominante = motivoDominante;
+exports.textoDeViolacoes = textoDeViolacoes;
+/**
+ * Variaveis que REDIRECIONAM o despacho do `claude` para um provider pago.
+ * Mesma lista do `ork doctor`: presenca delas com `subscription-only` e bloqueante.
+ */
+const ENVS_QUE_REDIRECIONAM = [
+    'ANTHROPIC_API_KEY',
+    'ANTHROPIC_AUTH_TOKEN',
+    'ANTHROPIC_BASE_URL',
+    'CLAUDE_CODE_USE_BEDROCK',
+    'CLAUDE_CODE_USE_VERTEX',
+];
+/**
+ * Padroes de segredo procurados no prompt antes do despacho.
+ * O `ork` reporta o NOME do padrao e a posicao, nunca o trecho casado: relatorio de
+ * vazamento que imprime o segredo e um segundo vazamento.
+ */
+const PADROES_DE_SEGREDO = [
+    { nome: 'chave da Anthropic', regex: /sk-ant-[A-Za-z0-9_-]{16,}/ },
+    { nome: 'chave da OpenAI', regex: /\bsk-[A-Za-z0-9]{32,}\b/ },
+    { nome: 'chave de acesso AWS', regex: /\bAKIA[0-9A-Z]{16}\b/ },
+    { nome: 'token do GitHub', regex: /\bgh[pousr]_[A-Za-z0-9]{20,}\b/ },
+    { nome: 'chave privada PEM', regex: /-----BEGIN (?:[A-Z ]+ )?PRIVATE KEY-----/ },
+    {
+        nome: 'segredo atribuido em texto',
+        regex: /\b(?:api[_-]?key|secret|token|senha|password)\s*[:=]\s*['"][^'"\s]{16,}['"]/i,
+    },
+];
+/**
+ * Procura os padroes de segredo em um texto qualquer (prompt de fase, template de prompt).
+ * Devolve o NOME do padrao e a linha, nunca o trecho: relatorio que imprime o segredo vaza de novo.
+ */
+function procurarSegredos(texto) {
+    const achados = [];
+    for (const padrao of PADROES_DE_SEGREDO) {
+        const casado = padrao.regex.exec(texto);
+        if (!casado)
+            continue;
+        achados.push({ nome: padrao.nome, linha: texto.slice(0, casado.index).split('\n').length });
+    }
+    return achados;
+}
+/** Catalogo das policies que o `ork` sabe executar, com o gate em que cada uma vale. */
+exports.POLICIES_CONHECIDAS = {
+    provider: {
+        quando: ['phase.dispatch', 'ship'],
+        descricao: 'proibe despacho por provider pago quando a politica e subscription-only',
+    },
+    segredo_em_prompt: {
+        quando: ['phase.dispatch'],
+        descricao: 'proibe despachar prompt que carrega credencial',
+    },
+    push_direto_na_base: {
+        quando: ['ship'],
+        descricao: 'proibe entregar sem branch de thread (push direto na base)',
+    },
+};
+function severidade(bruta) {
+    if (bruta === 'block' || bruta === 'warn' || bruta === 'off')
+        return bruta;
+    return 'warn';
+}
+/** Policies declaradas no manifesto que o `ork` nao sabe executar. */
+function policiesDesconhecidas(manifesto) {
+    return Object.keys(manifesto.policies ?? {}).filter((p) => !(p in exports.POLICIES_CONHECIDAS));
+}
+/** Avalia as policies aplicaveis ao gate informado. Nunca lanca: devolve as violacoes. */
+function avaliarPolicies(manifesto, ctx) {
+    const declaradas = manifesto.policies ?? {};
+    const violacoes = [];
+    for (const [nome, bruta] of Object.entries(declaradas)) {
+        const conhecida = exports.POLICIES_CONHECIDAS[nome];
+        if (!conhecida || !conhecida.quando.includes(ctx.gate))
+            continue;
+        const sev = severidade(bruta);
+        if (sev === 'off')
+            continue;
+        if (nome === 'provider') {
+            if (manifesto.runtime.provider_policy !== 'subscription-only')
+                continue;
+            const ativas = ENVS_QUE_REDIRECIONAM.filter((e) => (process.env[e] ?? '').trim() !== '');
+            if (ativas.length > 0) {
+                violacoes.push({
+                    policy: nome,
+                    severidade: sev,
+                    // Bloco B3: a policy `provider` deixa de sair como `policy.violation` generica e
+                    // passa a carregar o motivo de CUSTO. E o que permite a politica de retry recusar
+                    // a reexecucao automatica dela sem precisar reabrir o nome da policy em cada gate.
+                    motivo: 'cost.violation',
+                    detalhe: `${ativas.join(', ')} redireciona o despacho do claude para provider pago`,
+                    correcao: `remova do ambiente: ${ativas.join(', ')} (o despacho usa a assinatura Claude local)`,
+                });
+            }
+            continue;
+        }
+        if (nome === 'segredo_em_prompt') {
+            for (const achado of procurarSegredos(ctx.prompt ?? '')) {
+                violacoes.push({
+                    policy: nome,
+                    severidade: sev,
+                    motivo: 'policy.violation',
+                    detalhe: `padrao "${achado.nome}" casou na linha ${achado.linha} do prompt (trecho omitido de proposito)`,
+                    correcao: 'tire a credencial do pedido; referencie a variavel de ambiente pelo nome',
+                });
+            }
+            continue;
+        }
+        if (nome === 'push_direto_na_base') {
+            const de = ctx.de ?? '';
+            const para = ctx.para ?? '';
+            const base = ctx.baseBranch ?? '';
+            if (de && para && de === para) {
+                violacoes.push({
+                    policy: nome,
+                    severidade: sev,
+                    motivo: 'policy.violation',
+                    detalhe: `origem e destino sao a mesma branch ("${de}"): isso e push direto na base, nao merge de thread`,
+                    correcao: 'entregue a partir da branch da thread: ork ship <thread> --para ' + (base || 'main'),
+                });
+            }
+            else if (de && base && de === base) {
+                violacoes.push({
+                    policy: nome,
+                    severidade: sev,
+                    motivo: 'policy.violation',
+                    detalhe: `a origem "${de}" e a propria branch base do projeto: nenhuma branch de thread foi usada`,
+                    correcao: 'crie a thread com --worktree auto e entregue a branch ork/<slug>',
+                });
+            }
+            continue;
+        }
+    }
+    return violacoes;
+}
+/** So as violacoes com severidade `block` (as que reprovam em qualquer modo). */
+function bloqueantes(violacoes) {
+    return violacoes.filter((v) => v.severidade === 'block');
+}
+/**
+ * O motivo tipado que representa um conjunto de violacoes bloqueantes.
+ *
+ * Custo vence: se qualquer violacao do lote for de custo, o lote inteiro sai como
+ * `cost.violation`, porque e o unico motivo que NUNCA pode ser reexecutado sozinho.
+ * Sem este helper, cada gate carimbaria `policy.violation` na mao e a regra de custo
+ * viraria uma segunda regra paralela, mais frouxa, em cada arquivo.
+ */
+function motivoDominante(violacoes) {
+    return violacoes.some((v) => v.motivo === 'cost.violation')
+        ? 'cost.violation'
+        : 'policy.violation';
+}
+/** Texto das violacoes para a saida do CLI. */
+function textoDeViolacoes(violacoes) {
+    return violacoes
+        .map((v) => `  [${v.severidade}] policy ${v.policy}: ${v.detalhe}\n` + `           correcao: ${v.correcao}`)
+        .join('\n');
+}

package/dist/prompts.js

@@ -0,0 +1,406 @@
+"use strict";
+/**
+ * Prompts como templates versionados (bloco B4).
+ *
+ * Ate o B2 o prompt de fase era montado por concatenacao dentro do `phase.ts`: mudar uma
+ * linha do contrato de fase era mudar codigo, e nao havia como um projeto revisar o prompt
+ * sem abrir o compilador. Aqui o prompt vira TEMPLATE VERSIONADO:
+ *
+ *   - o template embutido no `ork` e a fonte de verdade quando o projeto nao tem opiniao;
+ *   - `<raiz>/prompts/<id>.md` sobrescreve o embutido de mesmo id, versionado no git do projeto;
+ *   - `ork prompt lint` reprova template quebrado ANTES de ele virar despacho;
+ *   - `ork prompt render` mostra o prompt exato, com o mesmo sha256 que iria para o ledger.
+ *
+ * A regra de ouro do bloco continua valendo: o template e dado, o renderizador e codigo, e
+ * nenhuma regra de negocio nova entra aqui. O que o template faz e dizer com que texto o
+ * nucleo despacha; quem decide o que despachar continua sendo o `ork`.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TEMPLATES_EMBUTIDOS = exports.TEMPLATE_FASE_PADRAO = exports.CONTRATO_DE_FASE = exports.REGRA_CENTRAL = exports.SECOES_OBRIGATORIAS = exports.LIMITE_TEMPLATE_BYTES = void 0;
+exports.dirDeTemplates = dirDeTemplates;
+exports.variaveisUsadas = variaveisUsadas;
+exports.renderizar = renderizar;
+exports.parseTemplate = parseTemplate;
+exports.lintTemplate = lintTemplate;
+exports.carregarTemplatesDe = carregarTemplatesDe;
+exports.carregarTemplates = carregarTemplates;
+exports.exigirTemplate = exigirTemplate;
+exports.templateDaFase = templateDaFase;
+exports.textoDoLint = textoDoLint;
+exports.tabelaDeTemplates = tabelaDeTemplates;
+exports.threadDeExemplo = threadDeExemplo;
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const modos_1 = require("./modos");
+const policies_1 = require("./policies");
+const types_1 = require("./types");
+/** Limite duro de um template, o mesmo do manifesto: prosa longa nao vira prompt. */
+exports.LIMITE_TEMPLATE_BYTES = 16384;
+/** Onde um projeto guarda os templates que sobrescrevem os embutidos. */
+function dirDeTemplates(raiz) {
+    return path.join(raiz, 'prompts');
+}
+/** Toda `{{variavel}}` usada no corpo, sem repeticao, na ordem de aparicao. */
+function variaveisUsadas(corpo) {
+    const achadas = [];
+    const regex = /\{\{\s*([a-z0-9_]+)\s*\}\}/g;
+    let casado;
+    while ((casado = regex.exec(corpo)) !== null) {
+        if (!achadas.includes(casado[1]))
+            achadas.push(casado[1]);
+    }
+    return achadas;
+}
+/**
+ * Renderiza o template com os valores informados.
+ *
+ * Duas regras, ambas deterministicas e testadas:
+ *  1. variavel usada e nao informada e ERRO, nunca string vazia silenciosa;
+ *  2. linha cujo conteudo inteiro e uma unica variavel que resolveu vazio SOME, para que um
+ *     campo opcional (a variante de ciclo, por exemplo) nao deixe linha em branco no prompt.
+ */
+function renderizar(template, valores) {
+    const faltando = variaveisUsadas(template.corpo).filter((v) => !(v in valores));
+    if (faltando.length > 0) {
+        throw new Error(`template ${template.id}: variavel sem valor na renderizacao: ${faltando.join(', ')}`);
+    }
+    const linhas = template.corpo.split('\n');
+    const saida = [];
+    for (const linha of linhas) {
+        const soUmaVariavel = /^\{\{\s*([a-z0-9_]+)\s*\}\}$/.exec(linha);
+        if (soUmaVariavel && valores[soUmaVariavel[1]] === '')
+            continue;
+        saida.push(linha.replace(/\{\{\s*([a-z0-9_]+)\s*\}\}/g, (_, nome) => valores[nome]));
+    }
+    return saida.join('\n');
+}
+function parseListaInline(bruto) {
+    const limpo = bruto.trim();
+    if (limpo === '' || limpo === '[]')
+        return [];
+    const interno = limpo.startsWith('[') && limpo.endsWith(']') ? limpo.slice(1, -1) : limpo;
+    return interno
+        .split(',')
+        .map((p) => p.trim().replace(/^["']|["']$/g, ''))
+        .filter((p) => p.length > 0);
+}
+/**
+ * Le o frontmatter e o corpo de um template.
+ *
+ * O parser aceita o subconjunto que os templates usam (`chave: valor` e lista inline), e
+ * reprova em vez de adivinhar: frontmatter ausente e erro, nao template sem metadados.
+ */
+function parseTemplate(bruto, origem) {
+    const casado = /^---\n([\s\S]*?)\n---\n([\s\S]*)$/.exec(bruto);
+    if (!casado) {
+        throw new Error(`template em ${origem}: frontmatter ausente (esperado bloco --- ... ---)`);
+    }
+    const campos = {};
+    for (const linha of casado[1].split('\n')) {
+        if (linha.trim() === '' || linha.trimStart().startsWith('#'))
+            continue;
+        const sep = linha.indexOf(':');
+        if (sep < 0)
+            continue;
+        campos[linha.slice(0, sep).trim()] = linha
+            .slice(sep + 1)
+            .trim()
+            .replace(/^["']|["']$/g, '');
+    }
+    const versao = Number(campos.versao ?? '0');
+    return {
+        id: campos.id ?? '',
+        versao: Number.isFinite(versao) ? versao : 0,
+        descricao: campos.descricao ?? '',
+        fases: parseListaInline(campos.fases ?? ''),
+        variaveis: parseListaInline(campos.variaveis ?? ''),
+        corpo: casado[2].replace(/\n$/, ''),
+        origem,
+        bruto,
+    };
+}
+/** Secoes que todo template de fase precisa carregar para o prompt continuar sendo um prompt. */
+exports.SECOES_OBRIGATORIAS = [
+    '## Ciclo canonico',
+    '## Modo de conducao',
+    '## Contexto da thread',
+    '## Pedido do builder',
+    '## Regras de evidencia',
+];
+/** A frase que nenhum template pode perder, porque ela e o contrato dos 5 modos. */
+exports.REGRA_CENTRAL = 'REGRA CENTRAL: o modo afrouxa a pausa, NUNCA a verificacao.';
+/** O contrato do prompt de fase (o do B4). */
+exports.CONTRATO_DE_FASE = {
+    nome: 'fase',
+    secoes: exports.SECOES_OBRIGATORIAS,
+    regraCentral: exports.REGRA_CENTRAL,
+    variavelObrigatoria: 'pedido',
+    validaFases: true,
+};
+/**
+ * Lint de um template. Devolve os problemas; lista vazia quer dizer aprovado.
+ *
+ * O lint e o que torna "prompt versionado" diferente de "arquivo de texto solto": ele reprova
+ * template que perdeu a regra dos modos, que esqueceu o pedido do builder, que declara variavel
+ * que nao usa (ou usa variavel que nao declara) e que carrega credencial.
+ */
+function lintTemplate(t, contrato = exports.CONTRATO_DE_FASE) {
+    const problemas = [];
+    const erro = (regra, detalhe) => {
+        problemas.push({ template: t.id || t.origem, regra, gravidade: 'erro', detalhe });
+    };
+    const aviso = (regra, detalhe) => {
+        problemas.push({ template: t.id || t.origem, regra, gravidade: 'aviso', detalhe });
+    };
+    if (!t.id)
+        erro('id', 'frontmatter sem `id`');
+    if (t.origem !== 'embutido') {
+        const esperado = path.basename(t.origem, '.md');
+        if (t.id && t.id !== esperado) {
+            erro('id', `o id "${t.id}" nao bate com o nome do arquivo "${esperado}.md"`);
+        }
+    }
+    if (!Number.isInteger(t.versao) || t.versao < 1) {
+        erro('versao', `versao "${t.versao}" invalida: esperado inteiro a partir de 1`);
+    }
+    if (t.descricao.trim() === '')
+        erro('descricao', 'frontmatter sem `descricao`');
+    if (contrato.validaFases) {
+        for (const fase of t.fases) {
+            if (!types_1.FASES.includes(fase)) {
+                erro('fases', `"${fase}" nao e fase do ciclo canonico (${types_1.FASES.join(', ')})`);
+            }
+        }
+    }
+    const usadas = variaveisUsadas(t.corpo);
+    const naoDeclaradas = usadas.filter((v) => !t.variaveis.includes(v));
+    if (naoDeclaradas.length > 0) {
+        erro('variaveis', `usadas no corpo e nao declaradas: ${naoDeclaradas.join(', ')}`);
+    }
+    const naoUsadas = t.variaveis.filter((v) => !usadas.includes(v));
+    if (naoUsadas.length > 0) {
+        erro('variaveis', `declaradas e nao usadas: ${naoUsadas.join(', ')}`);
+    }
+    for (const secao of contrato.secoes) {
+        if (!t.corpo.includes(secao))
+            erro('secoes', `secao obrigatoria ausente: ${secao}`);
+    }
+    if (!t.corpo.includes(contrato.regraCentral)) {
+        erro('regra-central', `o template perdeu a linha: ${contrato.regraCentral}`);
+    }
+    if (contrato.variavelObrigatoria && !usadas.includes(contrato.variavelObrigatoria)) {
+        erro(contrato.variavelObrigatoria, `o template nao usa {{${contrato.variavelObrigatoria}}}: despacharia uma ${contrato.nome} sem a demanda do builder`);
+    }
+    for (const achado of (0, policies_1.procurarSegredos)(t.bruto)) {
+        erro('segredo', `padrao "${achado.nome}" casou na linha ${achado.linha} do template (trecho omitido de proposito)`);
+    }
+    const bytes = Buffer.byteLength(t.bruto, 'utf8');
+    if (bytes > exports.LIMITE_TEMPLATE_BYTES) {
+        erro('tamanho', `${bytes} bytes acima do limite de ${exports.LIMITE_TEMPLATE_BYTES}`);
+    }
+    if (t.bruto.includes('—')) {
+        aviso('idioma', 'o template usa travessao longo (U+2014); o padrao do projeto e hifen ou virgula');
+    }
+    return problemas;
+}
+/**
+ * O template embutido da fase.
+ *
+ * Ele e a fonte de verdade do prompt do `ork` e a copia versionada em `prompts/fase-padrao.md`
+ * precisa ser identica byte a byte (ha teste que prova isso). Renderizado, ele produz
+ * exatamente o prompt que o B0 montava por concatenacao: mudar o texto aqui e mudar contrato.
+ */
+exports.TEMPLATE_FASE_PADRAO = `---
+id: fase-padrao
+versao: 2
+descricao: Prompt canonico de uma fase do ciclo GOAL..MASTER, com nomenclatura, modo de conducao, contexto da thread, memoria injetada e regras de evidencia.
+fases: [GOAL, PLAN, GO, CHECK, SHIP, MASTER]
+variaveis: [fase, thread, bloco, nome, ciclo_canonico, tag, blocos, pausas, linha_variante, regra_de_pausa, invariantes, slug, projeto_nome, projeto_abbrev, base_branch, base_commit, diretorio, pedido, memoria_injetada, regras_de_evidencia]
+---
+# Orkastery, fase {{fase}} da thread {{thread}}
+
+Voce conduz o bloco {{bloco}} da thread "{{nome}}".
+
+## Ciclo canonico
+{{ciclo_canonico}}
+
+## Modo de conducao: {{tag}}
+Blocos desta thread: {{blocos}}
+Pausas humanas desta thread: {{pausas}}
+{{linha_variante}}
+{{regra_de_pausa}}
+
+REGRA CENTRAL: o modo afrouxa a pausa, NUNCA a verificacao.
+{{invariantes}}
+
+## Contexto da thread
+- thread: {{thread}} (slug {{slug}})
+- projeto: {{projeto_nome}} (abbrev {{projeto_abbrev}})
+- base carimbada: {{base_branch}} @ {{base_commit}}
+- diretorio de trabalho: {{diretorio}}
+- estado da thread: .orkastery/threads/{{thread}}/thread.json
+- ledger: .orkastery/threads/{{thread}}/ledger.jsonl
+
+## Pedido do builder
+{{pedido}}
+{{memoria_injetada}}
+
+## Regras de evidencia
+{{regras_de_evidencia}}`;
+/** Os templates que vem dentro do `ork`, por id. */
+exports.TEMPLATES_EMBUTIDOS = {
+    'fase-padrao': exports.TEMPLATE_FASE_PADRAO,
+};
+/**
+ * Carrega templates de um conjunto de embutidos, sobrescritos pelos `.md` de um diretorio.
+ *
+ * Parametrizada por diretorio para que os prompts de FASE (`prompts/`) e os prompts de
+ * AUDITORIA (`auditors/`, bloco B5) usem a mesma carga, com a mesma precedencia e a mesma
+ * regra de README, em vez de duas implementacoes que divergem com o tempo.
+ */
+function carregarTemplatesDe(embutidos, dir) {
+    const porId = new Map();
+    for (const [id, bruto] of Object.entries(embutidos)) {
+        porId.set(id, parseTemplate(bruto, 'embutido'));
+    }
+    if (dir && fs.existsSync(dir)) {
+        for (const arquivo of fs.readdirSync(dir).sort()) {
+            if (!arquivo.endsWith('.md'))
+                continue;
+            // O README do diretorio documenta os templates; ele nao e um deles. Qualquer OUTRO
+            // `.md` sem frontmatter continua sendo erro, para template quebrado nao virar arquivo
+            // silenciosamente ignorado.
+            if (arquivo === 'README.md')
+                continue;
+            const caminho = path.join(dir, arquivo);
+            const t = parseTemplate(fs.readFileSync(caminho, 'utf8'), caminho);
+            porId.set(t.id || path.basename(arquivo, '.md'), t);
+        }
+    }
+    return [...porId.values()].sort((a, b) => a.id.localeCompare(b.id));
+}
+/**
+ * Todos os templates que valem para este projeto: os embutidos, sobrescritos por
+ * `<raiz>/prompts/<id>.md` quando o projeto versiona o seu proprio.
+ */
+function carregarTemplates(raiz) {
+    return carregarTemplatesDe(exports.TEMPLATES_EMBUTIDOS, raiz ? dirDeTemplates(raiz) : undefined);
+}
+/** Um template por id, com erro tipado quando ele nao existe. */
+function exigirTemplate(id, raiz) {
+    const achado = carregarTemplates(raiz).find((t) => t.id === id);
+    if (!achado) {
+        const ids = carregarTemplates(raiz).map((t) => t.id).join(', ');
+        throw new Error(`template "${id}" nao existe (conhecidos: ${ids})`);
+    }
+    return achado;
+}
+/**
+ * O template que conduz a fase: `fase-<minuscula>` quando o projeto versionou um so para ela,
+ * senao o `fase-padrao`. E o unico ponto de resolucao, para nao haver duas regras de escolha.
+ */
+function templateDaFase(fase, raiz) {
+    const templates = carregarTemplates(raiz);
+    const especifico = templates.find((t) => t.id === `fase-${fase.toLowerCase()}`);
+    if (especifico)
+        return especifico;
+    const padrao = templates.find((t) => t.id === 'fase-padrao');
+    if (!padrao)
+        throw new Error('template `fase-padrao` ausente: o `ork` nao tem prompt de fase');
+    return padrao;
+}
+/** Texto de `ork prompt lint` para a saida do CLI. */
+function textoDoLint(problemas, quantos) {
+    const linhas = [];
+    const erros = problemas.filter((p) => p.gravidade === 'erro');
+    const avisos = problemas.filter((p) => p.gravidade === 'aviso');
+    for (const p of problemas) {
+        linhas.push(`  [${p.gravidade}] ${p.template} :: ${p.regra}`);
+        linhas.push(`           ${p.detalhe}`);
+    }
+    if (problemas.length === 0) {
+        linhas.push(`  nenhum problema em ${quantos} template(s)`);
+    }
+    linhas.push('');
+    linhas.push(`templates: ${quantos} | erros: ${erros.length} | avisos: ${avisos.length}`);
+    return linhas.join('\n');
+}
+/** Texto de `ork prompt list`. */
+function tabelaDeTemplates(templates) {
+    const linhas = ['Templates de prompt (o do projeto sobrescreve o embutido de mesmo id)', ''];
+    for (const t of templates) {
+        linhas.push(`  ${t.id.padEnd(16)} v${t.versao}  origem: ${t.origem}`);
+        linhas.push(`  ${' '.repeat(16)}   fases: ${t.fases.length > 0 ? t.fases.join(' ') : 'todas'}`);
+        linhas.push(`  ${' '.repeat(16)}   ${t.descricao}`);
+    }
+    linhas.push('');
+    linhas.push('Para versionar o seu: grave em prompts/<id>.md e rode `ork prompt lint`.');
+    return linhas.join('\n');
+}
+/**
+ * Uma thread de exemplo, em memoria, para `ork prompt render --exemplo`.
+ *
+ * Ela existe para que o builder possa ver o prompt exato de um modo ANTES de criar thread
+ * nenhuma, e para que o lint tenha um alvo de renderizacao sem depender de estado em disco.
+ * Nada aqui e gravado: o exemplo nunca vira thread.
+ */
+function threadDeExemplo(modo, fase, projeto) {
+    const def = (0, modos_1.definicaoDoModo)(modo);
+    const p = projeto ?? { name: 'exemplo', abbrev: 'exe' };
+    const agora = '1970-01-01T00:00:00.000Z';
+    return {
+        id: `${p.abbrev}-exemplo`,
+        slug: `${p.abbrev}-exemplo-${def.blocos[0].slugFases}`,
+        nome: 'exemplo de prompt',
+        assunto: 'exemplo',
+        modo,
+        fases: [...types_1.FASES],
+        blocos: def.blocos,
+        faseAtual: fase,
+        status: 'aberta',
+        criadaEm: agora,
+        atualizadaEm: agora,
+        projeto: p,
+        base: { branch: 'main', commit: '0'.repeat(40) },
+        worktree: null,
+        sessoes: [],
+        decisoes: [],
+        claims: [],
+        leases: [],
+        baseline: null,
+        variante: null,
+    };
+}