@orkastery/cli 0.5.3 → 0.6.0

package/dist/auditrun.js

@@ -51,6 +51,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.PACK_DA_SUPERFICIE = exports.VERSAO_DA_RODADA = void 0;
 exports.dirAuditorias = dirAuditorias;
 exports.dirRodada = dirRodada;
+exports.exigirIdDeRodada = exigirIdDeRodada;
 exports.caminhoRodada = caminhoRodada;
 exports.listarRodadas = listarRodadas;
 exports.lerRodada = lerRodada;
@@ -76,6 +77,7 @@ const adapter = __importStar(require("./adapters/claude-bg"));
 const auditoria_1 = require("./auditoria");
 const phase_1 = require("./phase");
 const policies_1 = require("./policies");
+const projeto_alvo_1 = require("./projeto-alvo");
 const manifest_1 = require("./manifest");
 const ledger_1 = require("./ledger");
 const divida_1 = require("./divida");
@@ -85,6 +87,7 @@ const thread_1 = require("./thread");
 const util_1 = require("./util");
 const verify_1 = require("./verify");
 const horario_1 = require("./horario");
+const locale_1 = require("./locale");
 /** Versao do formato de `run.json`. */
 exports.VERSAO_DA_RODADA = 1;
 /** Diretorio das rodadas de auditoria do projeto. */
@@ -93,7 +96,17 @@ function dirAuditorias(raiz) {
 }
 /** Diretorio de uma rodada. */
 function dirRodada(raiz, id) {
-    return path.join(dirAuditorias(raiz), id);
+    return path.join(dirAuditorias(raiz), exigirIdDeRodada(id));
+}
+/**
+ * RM-047 (fronteira de confiança): o id da rodada vira nome de pasta e de relatório, e o `run.json` que o
+ * traz pode ter vindo do clone. Um segmento só, como o que `novoIdDeRodada` gera, sem `/` nem `..`.
+ */
+function exigirIdDeRodada(id) {
+    if (typeof id !== 'string' || !/^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/.test(id) || id.includes('..')) {
+        throw new Error(`audit.rodada-invalida: id de rodada ${JSON.stringify(String(id)).slice(0, 60)} não é um nome simples`);
+    }
+    return id;
 }
 /** Caminho do `run.json` da rodada. */
 function caminhoRodada(raiz, id) {
@@ -372,6 +385,9 @@ function rodarAuditoria(carregado, pack, opcoes = {}) {
         cwd: raiz,
         model: base.custo.model,
         effort,
+        // RM-052 (fatia 2, D2, aviso A1 do CHECK): a sessao da auditoria roda na raiz do projeto e le o
+        // projeto pelo proprio cwd; o `ORK_PROJETO` e o modo host de quem chamou (ou do daemon) nao a seguem.
+        ambienteExtra: { ...projeto_alvo_1.AMBIENTE_SEM_PROJETO_HERDADO },
     });
     if (!resultado.ok || !resultado.sessionId) {
         const rodada = {
@@ -724,7 +740,7 @@ function relatorioDaRodada(carregado, rodadaId, opcoes = {}) {
     (0, util_1.gravar)(caminho, texto);
     let publicado = null;
     if (opcoes.publicar) {
-        publicado = path.join(raiz, 'docs', 'audit', `${rodada.id}.md`);
+        publicado = path.join(raiz, 'docs', 'audit', `${exigirIdDeRodada(rodada.id)}.md`);
         (0, util_1.gravar)(publicado, texto);
     }
     rodada.status = 'relatada';
@@ -744,9 +760,10 @@ function relatorioDaRodada(carregado, rodadaId, opcoes = {}) {
 // ---------------------------------------------------------------------------
 /** Tabela de `ork audit list`. */
 function tabelaDeRodadas(raiz) {
+    const m = (0, locale_1.msg)().audit.rodadas;
     const ids = listarRodadas(raiz);
     if (ids.length === 0) {
-        return 'Nenhuma rodada de auditoria em .orkastery/audits. Rode: ork audit run <pack>';
+        return m.vazia;
     }
     const linhas = ids.map((id) => {
         const r = lerRodada(raiz, id);
@@ -758,92 +775,93 @@ function tabelaDeRodadas(raiz) {
             r.status,
             r.motivo ?? '-',
             String(r.achados.length),
-            r.veredito ? (r.veredito.ok ? 'sustentado' : 'REPROVADO') : 'nao verificado',
+            r.veredito ? (r.veredito.ok ? m.sustentado : m.reprovado) : m.naoVerificado,
             r.escopo.since ?? 'total',
         ];
     });
-    return (0, util_1.tabela)(['RODADA', 'PACK', 'PERFIL', 'ESTAGIO', 'STATUS', 'MOTIVO', 'ACHADOS', 'CLAIMS', 'ESCOPO'], linhas);
+    return (0, util_1.tabela)([...m.cabecalho], linhas);
 }
 /** Texto de `ork audit show`. */
 function textoDaRodada(raiz, id) {
     const r = lerRodada(raiz, id);
     const achados = (0, divida_1.achadosDaRodada)(raiz, id);
     const L = [];
-    L.push(`Rodada de auditoria ${r.id}`);
-    L.push(`  pack        ${r.pack} (${auditoria_1.PACKS[r.pack].titulo})`);
-    L.push(`  produto     ${r.produto} (perfil ${r.perfil})`);
-    L.push(`  estagio     ${r.estagio}, postura ${r.postura}`);
-    L.push(`  escopo      ${r.escopo.detalhe}`);
-    L.push(`  graphify    ${r.escopo.graphify}`);
-    L.push(`  custo       effort ${r.custo.effort}, model ${r.custo.model}`);
-    L.push(`  janela      ${r.custo.janela.detalhe}`);
+    const m = (0, locale_1.msg)().audit.rodadas;
+    L.push(m.titulo(r.id));
+    L.push(m.campo(m.campos.pack, `${r.pack} (${auditoria_1.PACKS[r.pack].titulo})`));
+    L.push(m.campo(m.campos.produto, `${r.produto} ${m.perfil(r.perfil)}`));
+    L.push(m.campo(m.campos.estagio, `${r.estagio}, ${m.postura(r.postura)}`));
+    L.push(m.campo(m.campos.escopo, r.escopo.detalhe));
+    L.push(m.campo(m.campos.graphify, r.escopo.graphify));
+    L.push(m.campo(m.campos.custo, m.custo(r.custo.effort, r.custo.model)));
+    L.push(m.campo(m.campos.janela, r.custo.janela.detalhe));
     if (r.custo.autorizadaPor)
-        L.push(`  autorizada  fora da janela por ${r.custo.autorizadaPor}`);
-    L.push(`  runtime     ${r.runtime}, sessao ${r.sessionId ?? '(nao despachada)'}`);
-    L.push(`  prompt      ${r.promptPath} (sha256 ${r.promptSha256 || '(nao montado)'})`);
-    L.push(`  status      ${r.status}${r.motivo ? ` (motivo tipado: ${r.motivo})` : ''}`);
+        L.push(m.campo(m.campos.autorizada, m.autorizada(r.custo.autorizadaPor)));
+    L.push(m.campo(m.campos.runtime, `${r.runtime}, ${m.detalhes.sessao(r.sessionId ?? m.sessaoAusente)}`));
+    L.push(m.campo(m.campos.prompt, `${r.promptPath} (sha256 ${r.promptSha256 || m.promptAusente})`));
+    L.push(m.campo(m.campos.status, `${r.status}${r.motivo ? ` ${m.motivo(r.motivo)}` : ''}`));
     if (r.superficie) {
-        L.push(`  superficie  ${r.superficie.detalhe}`);
-        L.push(`              registrados ${r.superficie.registrados}, a confirmar ${r.superficie.aConfirmar}, ` +
-            `frameworks: ${r.superficie.frameworks.join(', ') || '(nenhum reconhecido)'}`);
+        L.push(m.campo(m.campos.superficie, r.superficie.detalhe));
+        L.push(`              ${m.superficieResumo(r.superficie.registrados, r.superficie.aConfirmar, r.superficie.frameworks.join(', ') || m.nenhumFramework)}`);
     }
     if (r.detalhe)
-        L.push(`  detalhe     ${r.detalhe}`);
+        L.push(m.campo(m.campos.detalhe, r.detalhe));
     L.push('');
-    L.push(`  Achados (${achados.length}):`);
+    L.push(m.achados(achados.length));
     if (achados.length === 0)
-        L.push('    (nenhum achado registrado nesta rodada ainda)');
+        L.push(m.nenhumAchado);
     for (const a of achados)
         L.push((0, divida_1.textoDoAchado)(a));
     L.push('');
     if (r.veredito) {
-        L.push(`  Claims do auditor: ${r.veredito.ok ? 'SUSTENTADAS' : 'REPROVADAS'} ` +
-            `(motivos: ${r.veredito.motivos.join(', ') || 'nenhum'}) no HEAD ${(0, util_1.shaCurto)(r.veredito.commit)}`);
+        L.push(m.claims(r.veredito.ok, r.veredito.motivos.join(', '), (0, util_1.shaCurto)(r.veredito.commit)));
     }
     else {
-        L.push(`  Claims do auditor: NAO verificadas. Rode: ork audit verify ${r.id}`);
+        L.push(m.claimsPendentes(r.id));
     }
     L.push('');
-    L.push(`  Relatorio com o bloco de propostas: ork audit report ${r.id}`);
+    L.push(m.relatorio(r.id));
     return L.join('\n');
 }
 /** Ledger de uma rodada, para `ork audit show --ledger`. */
 function tabelaDoLedgerDaRodada(raiz, id) {
+    const m = (0, locale_1.msg)().audit.rodadas;
     lerRodada(raiz, id);
     const eventos = (0, ledger_1.lerLedger)(dirRodada(raiz, id));
     if (eventos.length === 0)
-        return `Ledger vazio para a rodada ${id}.`;
+        return m.ledgerVazio(id);
     const linhas = eventos.map((e) => {
         const detalhe = [];
         if (e.pack)
             detalhe.push(String(e.pack));
         if (e.achado)
-            detalhe.push(`achado ${String(e.achado)}`);
+            detalhe.push(m.detalhes.achado(String(e.achado)));
         if (e.motivo)
-            detalhe.push(`motivo ${String(e.motivo)}`);
+            detalhe.push(m.detalhes.motivo(String(e.motivo)));
         if (e.sessionId)
-            detalhe.push(`sessao ${String(e.sessionId).slice(0, 8)}`);
+            detalhe.push(m.detalhes.sessao(String(e.sessionId).slice(0, 8)));
         if (e.veredito)
-            detalhe.push(`veredito: ${String(e.veredito)}`);
+            detalhe.push(m.detalhes.veredito(String(e.veredito)));
         if (e.destino)
-            detalhe.push(`destino ${String(e.destino)}`);
+            detalhe.push(m.detalhes.destino(String(e.destino)));
         // `e.thread` e o dono do evento, que aqui e a propria rodada: so vale imprimir quando
         // for OUTRO id, que e o caso do evento finding_to_thread.
         if (e.thread && e.thread !== id)
-            detalhe.push(`thread ${String(e.thread)}`);
+            detalhe.push(m.detalhes.thread(String(e.thread)));
         if (e.detalhe)
             detalhe.push((0, horario_1.localizarTexto)(String(e.detalhe)).slice(0, 90));
         return [(0, horario_1.formatarDataHora)(e.ts, { segundos: true }), e.tipo, detalhe.join(' | ')];
     });
-    return `${(0, util_1.tabela)(['QUANDO', 'EVENTO', 'DETALHE'], linhas)}\n${(0, horario_1.legendaDoFuso)()}`;
+    return `${(0, util_1.tabela)([...m.ledgerCabecalho], linhas)}\n${(0, horario_1.legendaDoFuso)()}`;
 }
 /** Quantos achados abertos existem por pack, para o resumo do CLI. */
 function resumoDoBoard(raiz) {
+    const m = (0, locale_1.msg)().audit.rodadas;
     const board = (0, divida_1.lerBoard)(raiz);
     if (board.length === 0)
-        return 'board de divida vazio';
+        return m.boardVazio;
     const abertos = board.filter((a) => a.estado === 'aberto').length;
-    return `${board.length} achado(s) no board de divida, ${abertos} aberto(s)`;
+    return m.board(board.length, abertos);
 }
 /**
  * Abre a thread que nasce de um achado de auditoria.
@@ -857,7 +875,10 @@ function resumoDoBoard(raiz) {
 function abrirThreadDoAchado(carregado, achadoId, opcoes = {}) {
     const { raiz, manifesto } = carregado;
     const achado = (0, divida_1.exigirAchado)(raiz, achadoId);
-    const pedido = (0, divida_1.pedidoDoAchado)(achado);
+    // RM-061 F3c: o pedido vai a arquivo (pedido-goal.md e achado.json) e vira o --prompt do GOAL: e dado, na lingua
+    // declarada do dono, nunca na de quem roda nem conforme o --json. So o resultado impresso segue o locale ativo.
+    const pedido = (0, locale_1.comLocale)((0, locale_1.linguaDeclaradaDoDono)(manifesto.owner?.language), () => (0, divida_1.pedidoDoAchado)(achado));
+    const m = (0, locale_1.msg)().thread.fromFinding;
     if (achado.estado === 'virou-thread' && achado.thread) {
         return {
             ok: false,
@@ -865,8 +886,8 @@ function abrirThreadDoAchado(carregado, achadoId, opcoes = {}) {
             thread: null,
             pedido,
             motivo: 'achado.ja-virou-thread',
-            detalhe: `o achado ${achado.id} ja originou a thread ${achado.thread}`,
-            correcao: `continue naquela thread: ork thread status ${achado.thread}`,
+            detalhe: m.jaVirouThread(achado.id, achado.thread),
+            correcao: m.continueNaThread(achado.thread),
         };
     }
     if (achado.claim.estado === 'pendente') {
@@ -876,9 +897,8 @@ function abrirThreadDoAchado(carregado, achadoId, opcoes = {}) {
             thread: null,
             pedido,
             motivo: 'claims.failed',
-            detalhe: `a claim ${achado.claim.id} do achado ainda nao foi reexecutada no HEAD real: ` +
-                'o auditor nao tem direito a self-report',
-            correcao: `prove o achado antes de abrir trabalho: ork audit verify ${achado.rodada}`,
+            detalhe: m.claimPendente(achado.claim.id),
+            correcao: m.proveOAchado(achado.rodada),
         };
     }
     if (achado.claim.estado === 'reprovado') {
@@ -888,8 +908,8 @@ function abrirThreadDoAchado(carregado, achadoId, opcoes = {}) {
             thread: null,
             pedido,
             motivo: 'claims.failed',
-            detalhe: `a claim ${achado.claim.id} do achado REPROVOU na reexecucao no HEAD real`,
-            correcao: 'o achado nao se sustenta: corrija a evidencia na rodada, ou descarte o achado, em vez de abrir thread sobre ele',
+            detalhe: m.claimReprovada(achado.claim.id),
+            correcao: m.descarteOAchado,
         };
     }
     const modo = opcoes.modo ?? manifesto.conduction.default_mode;
@@ -913,7 +933,7 @@ function abrirThreadDoAchado(carregado, achadoId, opcoes = {}) {
             worktreePor,
             worktreeFalharia,
             motivo: null,
-            detalhe: 'simulacao (--dry-run): nenhuma thread e nenhum carimbo no board foram gravados',
+            detalhe: m.simulacaoDetalhe,
             correcao: '',
         };
     }
@@ -974,8 +994,8 @@ function abrirThreadDoAchado(carregado, achadoId, opcoes = {}) {
         worktreePor,
         motivo: achado.claim.estado === 'nao-verificavel' ? 'claims.unverifiable' : null,
         detalhe: achado.claim.estado === 'nao-verificavel'
-            ? `AVISO: a claim ${achado.claim.id} do achado nao tem comando de verificacao (motivo tipado claims.unverifiable, que avisa e nao bloqueia)`
-            : `achado ${achado.id} aberto como thread ${thread.id}, com a evidencia e a claim junto`,
+            ? m.claimSemComando(achado.claim.id)
+            : m.achadoAberto(achado.id, thread.id),
         correcao: '',
     };
 }

package/dist/autorizacao-duravel.js

@@ -0,0 +1,327 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PRAZO_MAXIMO_DIAS = exports.ACOES_DA_AUTORIZACAO = exports.ARQUIVO_DA_AUTORIZACAO = exports.CONTRATO_DA_AUTORIZACAO = void 0;
+exports.caminhoDaAutorizacao = caminhoDaAutorizacao;
+exports.lerAutorizacao = lerAutorizacao;
+exports.autorizada = autorizada;
+exports.referenciaDaAutorizacao = referenciaDaAutorizacao;
+exports.linhaDaAutorizacao = linhaDaAutorizacao;
+exports.prazoDoPedido = prazoDoPedido;
+exports.gravarAutorizacao = gravarAutorizacao;
+exports.textoDaAutorizacao = textoDaAutorizacao;
+/**
+ * RM-063 (F5): a autorizacao duravel do dono para a varredura agir sozinha nesta maquina.
+ *
+ * Incidente de 03 a 12/10/2026 (P4 e P5 da pagina da RM-063): o PR #112 foi mesclado e ficou dois dias sem
+ * `ork ship registrar-pr`, e as sessoes fantasmas de threads fechadas ficaram registradas, porque nada roda esses
+ * comandos sem um condutor. Agora a batida da varredura (`pulse-delivery`) faz isso sozinha, mas SO com a autorizacao
+ * do dono gravada nesta maquina, com prazo e com a lista do que ela pode. Sem autorizacao (ou com ela vencida,
+ * ilegivel, de outra maquina ou de outro projeto), cada acao vira um item da fila do pulse com o comando pronto.
+ *
+ * O arquivo e desta maquina e fica fora do git, como o `pulse-host.json` (RM-047):
+ * `.orkastery/monitor/autorizacao.json` no checkout canonico. O contrato e `ork.autorizacao-duravel/v1`; a referencia
+ * esta em `docs/referencia/contratos/autorizacao-duravel-rm063.md`. A leitura (`lerAutorizacao`) nunca grava; a F7
+ * grava pelo `ork conducao autorizar` (`gravarAutorizacao`), ato do dono, na mesma forma que a leitura confere.
+ */
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const node_crypto_1 = require("node:crypto");
+const estado_thread_1 = require("./estado-thread");
+const horario_1 = require("./horario");
+const ledger_1 = require("./ledger");
+const master_1 = require("./master");
+const master_nota_1 = require("./master-nota");
+const maquina_1 = require("./maquina");
+const procedencia_1 = require("./procedencia");
+const runtime_ambiente_1 = require("./runtime-ambiente");
+const util_1 = require("./util");
+const locale_1 = require("./locale");
+exports.CONTRATO_DA_AUTORIZACAO = 'ork.autorizacao-duravel/v1';
+exports.ARQUIVO_DA_AUTORIZACAO = 'autorizacao.json';
+/** Um arquivo de autorizacao tem poucas linhas; acima disto, nao e o que o dono gravou. */
+const TETO_DO_ARQUIVO = 64 * 1024;
+/**
+ * As acoes do contrato. A varredura da F5 faz `limpar` (sessoes fantasmas), `registrar` (a entrega de PR ja mesclado)
+ * e `master` (o MASTER por omissao); a batida da conducao da F7 (`ork conducao batida`) faz tambem `merge` (o PR verde de
+ * branch `ork/*`) e `despachar` (a fase seguinte com o prompt gravado). Tag e publicacao nunca entram.
+ */
+exports.ACOES_DA_AUTORIZACAO = ['limpar', 'registrar', 'master', 'merge', 'despachar'];
+/** O arquivo da autorizacao desta maquina, no checkout canonico (de dentro de uma worktree, o da raiz). */
+function caminhoDaAutorizacao(raiz) {
+    return path.join((0, estado_thread_1.raizDoEstado)(raiz), '.orkastery', 'monitor', exports.ARQUIVO_DA_AUTORIZACAO);
+}
+/** A data e a hora existem no calendario (o `Date.parse` aceitaria 30/02 e o levaria a marco, calado). */
+const noCalendario = (v) => {
+    const m = /^(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2})/.exec(v);
+    if (!m)
+        return false;
+    const [ano, mes, dia, hora, minuto] = m.slice(1).map(Number);
+    const d = new Date(Date.UTC(ano, mes - 1, dia));
+    return d.getUTCFullYear() === ano && d.getUTCMonth() === mes - 1 && d.getUTCDate() === dia && hora <= 23 && minuto <= 59;
+};
+/** O instante com o fuso explicito (`Z` ou `-03:00`): sem ele, o prazo dependeria do fuso de quem le. */
+const instante = (v) => typeof v === 'string' &&
+    /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}(:\d{2}(\.\d{1,9})?)?(Z|[+-]\d{2}:\d{2})$/.test(v) && noCalendario(v) &&
+    Number.isFinite(Date.parse(v));
+const textoCurto = (v, teto) => typeof v === 'string' && v.trim() !== '' && v.length <= teto &&
+    !/\p{Cc}/u.test(v);
+/**
+ * Le e confere a autorizacao desta maquina. Cada recusa tem motivo tipado e detalhe; so a valida, no prazo, desta
+ * maquina e deste projeto, autoriza alguma coisa.
+ */
+function lerAutorizacao(raiz, opcoes) {
+    const arquivo = caminhoDaAutorizacao(raiz);
+    const recusa = (motivo, detalhe, autorizacao) => ({ valida: false, arquivo, motivo, detalhe, ...(autorizacao ? { autorizacao } : {}) });
+    const st = fs.lstatSync(arquivo, { throwIfNoEntry: false });
+    if (!st)
+        return recusa('autorizacao.ausente', 'nenhuma autorizacao duravel gravada nesta maquina');
+    // RM-047: como o transporte do pulse, a autorizacao so vale do arquivo local desta maquina.
+    if (!st.isFile())
+        return recusa('autorizacao.rastreada', 'a autorizacao precisa ser um arquivo comum desta maquina, nao link nem diretorio');
+    if ((0, procedencia_1.rastreadoPeloGit)(raiz, arquivo))
+        return recusa('autorizacao.rastreada', 'a autorizacao esta versionada no git; ela so vale do arquivo local desta maquina');
+    if (st.size > TETO_DO_ARQUIVO)
+        return recusa('autorizacao.ilegivel', `o arquivo passa de ${TETO_DO_ARQUIVO} bytes`);
+    let bruto, dado;
+    try {
+        bruto = fs.readFileSync(arquivo, 'utf8');
+        const lido = JSON.parse(bruto);
+        if (!lido || typeof lido !== 'object' || Array.isArray(lido))
+            throw new Error('nao e um objeto JSON');
+        dado = lido;
+    }
+    catch (e) {
+        return recusa('autorizacao.ilegivel', `o arquivo nao e JSON valido (${e.message.slice(0, 120)})`);
+    }
+    if (dado.contrato !== exports.CONTRATO_DA_AUTORIZACAO)
+        return recusa('autorizacao.contrato', `o contrato precisa ser ${exports.CONTRATO_DA_AUTORIZACAO}`);
+    for (const [campo, teto] of [['maquina', 80], ['projeto', 80], ['por', 120]]) {
+        if (!textoCurto(dado[campo], teto))
+            return recusa('autorizacao.campo', `o campo ${campo} precisa ser texto de ate ${teto} caracteres`);
+    }
+    // A autoria e a mesma regra da nota do MASTER: nome de agente, de runtime ou generico nao autoriza nada.
+    if (!(0, master_1.autoriaHumana)(dado.por)) {
+        return recusa('autorizacao.campo', 'o campo por precisa nomear a pessoa que autorizou; agente, runtime ou nome generico nao autoriza');
+    }
+    for (const campo of ['concedidaEm', 'ate']) {
+        if (!instante(dado[campo])) {
+            return recusa('autorizacao.campo', `o campo ${campo} precisa ser um instante ISO com fuso (Z ou -03:00), como 2026-10-18T23:59:00-03:00`);
+        }
+    }
+    if (dado.nota !== undefined && !textoCurto(dado.nota, 300))
+        return recusa('autorizacao.campo', 'a nota precisa ser texto de ate 300 caracteres');
+    const pode = dado.pode;
+    if (!Array.isArray(pode) || pode.length === 0 || pode.some((a) => typeof a !== 'string') || new Set(pode).size !== pode.length) {
+        return recusa('autorizacao.campo', 'o campo pode precisa ser uma lista de acoes, sem repeticao');
+    }
+    const desconhecida = pode.find((a) => !exports.ACOES_DA_AUTORIZACAO.includes(a));
+    if (desconhecida !== undefined) {
+        return recusa('autorizacao.acao-desconhecida', `a acao ${JSON.stringify(desconhecida)} nao e do contrato (${exports.ACOES_DA_AUTORIZACAO.join(', ')})`);
+    }
+    const autorizacao = {
+        contrato: exports.CONTRATO_DA_AUTORIZACAO, maquina: dado.maquina, projeto: dado.projeto, por: dado.por,
+        concedidaEm: dado.concedidaEm, ate: dado.ate, pode: pode,
+        ...(typeof dado.nota === 'string' ? { nota: dado.nota } : {}),
+    };
+    const maquina = opcoes.maquina ?? (0, maquina_1.nomeDaMaquina)();
+    if (autorizacao.maquina !== maquina) {
+        return recusa('autorizacao.outra-maquina', `a autorizacao e da maquina ${autorizacao.maquina}, e esta e ${maquina}`, autorizacao);
+    }
+    if (autorizacao.projeto !== opcoes.projeto) {
+        return recusa('autorizacao.outro-projeto', `a autorizacao e do projeto ${autorizacao.projeto}, e este e ${opcoes.projeto}`, autorizacao);
+    }
+    const agora = opcoes.agora ?? new Date();
+    if (Date.parse(autorizacao.ate) <= agora.getTime()) {
+        return recusa('autorizacao.expirada', `o prazo acabou em ${(0, horario_1.formatarDataHoraRotulada)(autorizacao.ate, { agora: agora.toISOString() })}`, autorizacao);
+    }
+    return { valida: true, arquivo, autorizacao, sha256: (0, node_crypto_1.createHash)('sha256').update(bruto, 'utf8').digest('hex') };
+}
+/** A acao esta autorizada agora? */
+function autorizada(leitura, acao) {
+    return leitura.valida && leitura.autorizacao.pode.includes(acao);
+}
+/** A referencia que vai ao ledger com cada acao feita: quem autorizou, ate quando e qual arquivo. */
+function referenciaDaAutorizacao(leitura) {
+    if (!leitura.valida)
+        return null;
+    const a = leitura.autorizacao;
+    return { contrato: a.contrato, por: a.por, ate: a.ate, pode: a.pode, sha256: leitura.sha256, ...(a.nota ? { nota: a.nota } : {}) };
+}
+/** Uma linha para o `ork fabrica batida status` e para o pulse. */
+function linhaDaAutorizacao(leitura, agora = new Date().toISOString()) {
+    const m = (0, locale_1.msg)().conducao.autorizacao;
+    if (leitura.valida) {
+        const a = leitura.autorizacao;
+        return m.linhaValida(a.por, (0, horario_1.formatarDataHoraRotulada)(a.ate, { agora }), a.pode.join(', '));
+    }
+    if (leitura.motivo === 'autorizacao.ausente') {
+        return m.linhaAusente;
+    }
+    return m.linhaInvalida(leitura.motivo, leitura.detalhe);
+}
+// ---------------------------------------------------------------------------
+// RM-063 (F7): a gravacao, pelo `ork conducao autorizar`.
+// ---------------------------------------------------------------------------
+/** O que nunca entra na autorizacao duravel, nem com o nome que o dono der: fica sempre com ele. */
+const ACOES_PROIBIDAS = ['tag', 'tags', 'publicar', 'publicacao', 'publicação', 'release', 'publish', 'npm', 'versao', 'versão'];
+/**
+ * O prazo mais longo que uma autorizacao pode ter: o dono renova quando quiser, e a permissao esquecida nao vale para
+ * sempre.
+ */
+exports.PRAZO_MAXIMO_DIAS = 31;
+/**
+ * O prazo do `--ate`, sempre com o fuso escrito. Instante com fuso vale como veio; so a data vale ate 23:59 dela no fuso
+ * do dono; data e hora sem fuso, no fuso do dono. O resto e recusado: o prazo nao e adivinhado.
+ */
+function prazoDoPedido(bruto, fuso) {
+    const v = bruto.trim();
+    if (instante(v))
+        return v;
+    const m = /^(\d{4})-(\d{2})-(\d{2})(?:[T ](\d{2}):(\d{2}))?$/.exec(v);
+    const nome = (0, horario_1.normalizarFuso)(fuso);
+    if (!m || !nome)
+        return null;
+    const hora = m[4] ? Number(m[4]) : 23, minuto = m[5] ? Number(m[5]) : 59;
+    if (hora > 23 || minuto > 59)
+        return null;
+    const ms = (0, horario_1.instanteNoFuso)(Number(m[1]), Number(m[2]), Number(m[3]), hora, minuto, nome);
+    return Number.isFinite(ms) ? (0, horario_1.isoComFuso)(ms, nome) : null;
+}
+/** O `user.name` do git do checkout, quando nomeia uma pessoa. */
+function autorDoGit(raiz) {
+    const r = (0, util_1.exec)('git', ['config', 'user.name'], (0, estado_thread_1.raizDoEstado)(raiz), 10000);
+    const nome = r.ok ? r.stdout.trim() : '';
+    return nome && textoCurto(nome, 120) && (0, master_1.autoriaHumana)(nome) ? nome : null;
+}
+/**
+ * RM-063 (F7): grava a autorizacao duravel do dono nesta maquina, na forma que `lerAutorizacao` confere. E ato do dono:
+ * a sessao despachada pelo `ork` (com a identidade de despacho no ambiente) nunca concede autorizacao a si mesma. O
+ * arquivo novo substitui o anterior inteiro, e cada concessao vai ao ledger do projeto (`autorizacao_concedida`), com a
+ * que ela substituiu. Tag e publicacao nunca entram, nem com outro nome.
+ */
+function gravarAutorizacao(raiz, pedido) {
+    const recusa = (motivo, detalhe) => ({ ok: false, motivo, detalhe });
+    const ambiente = pedido.ambiente ?? process.env;
+    if ((ambiente[runtime_ambiente_1.ENV_IDENTIDADE_DE_DESPACHO] ?? '').trim() || (ambiente[runtime_ambiente_1.ENV_THREAD_DO_DESPACHO] ?? '').trim()) {
+        return recusa('autorizacao.sessao-despachada', 'a autorização durável é ato do dono: uma sessão despachada pelo ork não a concede ' +
+            '(rode no terminal do dono, fora da sessão da fase)');
+    }
+    // A mesma regra da nota do MASTER em nome de pessoa (D8): de dentro de um host de agente (Claude Code, Codex, Hermes,
+    // OpenClaw), quem escreve o --por e o agente. O dono autoriza no proprio terminal.
+    const host = (0, master_nota_1.marcaDeHost)(ambiente);
+    if (host) {
+        return recusa('autorizacao.host', `a autorização durável é ato do dono no terminal dele: vinda de ${host}, ela não vale ` +
+            '(o agente não autoriza a si mesmo)');
+    }
+    const agora = pedido.agora ?? new Date();
+    const ate = prazoDoPedido(pedido.ate, pedido.fuso);
+    if (!ate) {
+        return recusa('autorizacao.ate-invalido', `--ate ${JSON.stringify(pedido.ate)} não é um prazo: use 2026-10-18 (até 23:59 no fuso ` +
+            `${pedido.fuso}), 2026-10-18T18:00 ou um instante com fuso, como 2026-10-18T23:59:00-03:00`);
+    }
+    if (Date.parse(ate) <= agora.getTime()) {
+        return recusa('autorizacao.ate-passado', `o prazo ${(0, horario_1.formatarDataHoraRotulada)(ate, { agora: agora.toISOString() })} já passou`);
+    }
+    if (Date.parse(ate) - agora.getTime() > exports.PRAZO_MAXIMO_DIAS * 24 * 60 * 60 * 1000) {
+        return recusa('autorizacao.ate-longe', `o prazo vai além de ${exports.PRAZO_MAXIMO_DIAS} dias: autorize por menos e renove quando quiser`);
+    }
+    const pode = pedido.pode.split(',').map((a) => a.trim().toLowerCase()).filter(Boolean);
+    if (!pode.length)
+        return recusa('autorizacao.pode-vazio', `--pode precisa de pelo menos uma ação (${exports.ACOES_DA_AUTORIZACAO.join(', ')})`);
+    if (new Set(pode).size !== pode.length)
+        return recusa('autorizacao.pode-repetido', '--pode repete uma ação');
+    const proibida = pode.find((a) => ACOES_PROIBIDAS.includes(a));
+    if (proibida) {
+        return recusa('autorizacao.acao-proibida', `${JSON.stringify(proibida)}: tag e publicação nunca entram na autorização durável; ` +
+            'ficam sempre com o dono');
+    }
+    const desconhecida = pode.find((a) => !exports.ACOES_DA_AUTORIZACAO.includes(a));
+    if (desconhecida !== undefined) {
+        return recusa('autorizacao.acao-desconhecida', `a ação ${JSON.stringify(desconhecida)} não é do contrato (${exports.ACOES_DA_AUTORIZACAO.join(', ')})`);
+    }
+    const por = (pedido.por ?? '').trim() || autorDoGit(raiz);
+    if (!por || !textoCurto(por, 120) || !(0, master_1.autoriaHumana)(por)) {
+        return recusa('autorizacao.por', por ? `--por ${JSON.stringify(por)} não nomeia uma pessoa (agente, runtime ou nome genérico não autoriza)`
+            : 'informe --por <seu nome>: o git deste checkout não tem user.name de uma pessoa');
+    }
+    const nota = (pedido.nota ?? '').trim();
+    if (nota && !textoCurto(nota, 300))
+        return recusa('autorizacao.nota', 'a nota precisa ser texto de até 300 caracteres, sem controle');
+    const arquivo = caminhoDaAutorizacao(raiz);
+    const st = fs.lstatSync(arquivo, { throwIfNoEntry: false });
+    if ((st && !st.isFile()) || (0, procedencia_1.rastreadoPeloGit)(raiz, arquivo)) {
+        return recusa('autorizacao.rastreada', `${arquivo} está no git, ou é link ou diretório: a autorização só vale do arquivo local desta máquina`);
+    }
+    const lida = lerAutorizacao(raiz, { projeto: pedido.projeto, agora, maquina: pedido.maquina });
+    const anterior = lida.valida ? lida.autorizacao : null;
+    const autorizacao = {
+        contrato: exports.CONTRATO_DA_AUTORIZACAO, maquina: pedido.maquina ?? (0, maquina_1.nomeDaMaquina)(), projeto: pedido.projeto, por,
+        concedidaEm: (0, horario_1.isoComFuso)(agora.getTime(), (0, horario_1.normalizarFuso)(pedido.fuso) ?? 'UTC'), ate, pode: pode,
+        ...(nota ? { nota } : {}),
+    };
+    fs.mkdirSync(path.dirname(arquivo), { recursive: true });
+    const temporario = `${arquivo}.${process.pid}.${(0, node_crypto_1.randomUUID)().slice(0, 8)}.tmp`;
+    try {
+        fs.writeFileSync(temporario, JSON.stringify(autorizacao, null, 2) + '\n', { encoding: 'utf8', mode: 0o600, flag: 'wx' });
+        fs.renameSync(temporario, arquivo);
+    }
+    finally {
+        fs.rmSync(temporario, { force: true });
+    }
+    const leitura = lerAutorizacao(raiz, { projeto: pedido.projeto, agora, maquina: pedido.maquina });
+    if (!leitura.valida)
+        throw new Error(`a autorização gravada não foi aceita na releitura (${leitura.motivo}: ${leitura.detalhe})`);
+    try {
+        (0, ledger_1.registrar)(path.join((0, estado_thread_1.raizDoEstado)(raiz), '.orkastery'), 'projeto', ledger_1.TIPOS_DE_EVENTO.autorizacaoConcedida, {
+            maquina: autorizacao.maquina, por, concedidaEm: autorizacao.concedidaEm, ate, pode, ...(nota ? { nota } : {}),
+            sha256: leitura.sha256, canal: pedido.canal ?? null,
+            substituiu: anterior ? { por: anterior.por, ate: anterior.ate, pode: anterior.pode } : null,
+        });
+    }
+    catch { /* o arquivo e a autorizacao; o ledger do projeto e o rastro, e a releitura ja provou o arquivo */ }
+    return { ok: true, leitura, anterior };
+}
+/** O texto do `ork conducao autorizacao`: a vigente, ou por que nao ha, e o que isso quer dizer para a batida. */
+function textoDaAutorizacao(leitura, agora = new Date().toISOString()) {
+    const m = (0, locale_1.msg)().conducao.autorizacao;
+    if (!leitura.valida) {
+        return [m.sem(leitura.motivo, leitura.detalhe), m.semEfeito, m.autorizar].join('\n');
+    }
+    const a = leitura.autorizacao;
+    return [m.valida(a.por, (0, horario_1.formatarDataHoraRotulada)(a.ate, { agora }), a.pode.join(', ')),
+        m.concedida((0, horario_1.formatarDataHoraRotulada)(a.concedidaEm, { agora }), a.maquina, a.projeto, a.nota ?? ''),
+        m.arquivo(leitura.arquivo, leitura.sha256.slice(0, 12)), m.limite].join('\n');
+}