@orkastery/cli 0.2.0 → 0.4.1

package/dist/modos.js

@@ -1,16 +1,22 @@
 "use strict";
 /**
- * Modos de conducao por #TAG (visao unificada, secao 3.5).
+ * Modos de conducao por #TAG (guia: docs/guias/modos.md).
  *
  * Regra central, nao negociavel: o modo afrouxa a PAUSA, nunca a VERIFICACAO.
  * Claims, verify, policies e gates tipados rodam identicos em todos os modos;
  * o que muda e se o veredito espera o humano ou segue sozinho com registro no ledger.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.TAG_DE_MODO_DESCONHECIDO = exports.ORDEM_DOS_MODOS = exports.MODOS = exports.INVARIANTES = void 0;
+exports.TAG_DE_MODO_DESCONHECIDO = exports.MOTIVO_MODO_APOSENTADO = exports.ORDEM_DOS_MODOS = exports.MODOS_LEGADOS = exports.MODOS_APOSENTADOS = exports.MODOS = exports.INVARIANTES = void 0;
 exports.slugDasFases = slugDasFases;
+exports.substitutosVivos = substitutosVivos;
+exports.cicloCompleto = cicloCompleto;
+exports.modoAposentado = modoAposentado;
+exports.recusaDeModoAposentado = recusaDeModoAposentado;
+exports.exigirModoVivo = exigirModoVivo;
 exports.parseModo = parseModo;
 exports.extrairTagDoPedido = extrairTagDoPedido;
+exports.extrairTagAposentadaDoPedido = extrairTagAposentadaDoPedido;
 exports.tagDoModo = tagDoModo;
 exports.definicaoDoModo = definicaoDoModo;
 exports.pausasDoModo = pausasDoModo;
@@ -23,7 +29,7 @@ exports.INVARIANTES = [
     'Claims, verify e policies rodam identicos em todos os modos.',
     'Policy `block` pausa qualquer modo, inclusive #Auto.',
     'Escalacao tipada para humano pausa qualquer modo, inclusive #Auto.',
-    'Um score humano por entrega sempre; nos modos sem pausa de MASTER ele vai para a fila de batch.',
+    'Toda entrega fecha com indice derivado do ledger; a nota humana, quando vier, sobrescreve.',
     'Toda decisao autonoma vai ao ledger com quem decidiu, evidencia e razao.',
 ];
 /** Monta a parte 3 do slug para um conjunto de fases (visao, secao 3.4). */
@@ -45,7 +51,14 @@ function bloco(fases, pausaSobre) {
     };
 }
 const SEM_PAUSA = '';
-/** A matriz dos 5 modos, do mais HITL ao mais autonomo. */
+/**
+ * A matriz dos modos, do mais HITL ao mais autonomo.
+ *
+ * I-43: ela guarda tambem os aposentados, de proposito. Quem encolhe e
+ * `ORDEM_DOS_MODOS`, que alimenta todo ESCRITOR. Se `look` saisse daqui,
+ * `tagDoModo` devolveria `#?look` para a thread `ork-smokeb0` de 02/09 e o
+ * board passaria a mostrar lixo no lugar da tag de uma thread que existe.
+ */
 exports.MODOS = {
     look: {
         modo: 'look',
@@ -84,7 +97,7 @@ exports.MODOS = {
             bloco(['SHIP', 'MASTER'], SEM_PAUSA),
         ],
         pausas: 3,
-        recomendadoPara: 'O padrao: premissas delicadas com entrega confiavel; score em batch',
+        recomendadoPara: 'O padrao: premissas delicadas com entrega confiavel',
     },
     maestro: {
         modo: 'maestro',
@@ -95,7 +108,7 @@ exports.MODOS = {
             bloco(['MASTER'], SEM_PAUSA),
         ],
         pausas: 1,
-        recomendadoPara: 'Solucoes claras e ageis, sem muitos riscos ou tradeoffs; score em batch',
+        recomendadoPara: 'Solucoes claras e ageis, sem muitos riscos ou tradeoffs',
     },
     auto: {
         modo: 'auto',
@@ -104,9 +117,101 @@ exports.MODOS = {
         pausas: 0,
         recomendadoPara: 'Solucoes menores, docs, estudos, pesquisas, configuracoes, auditorias, migracoes',
     },
+    // I-42: uma fase so, a GO, sem cerimonia. Nao autoriza push sozinho (fora de
+    // MODOS_QUE_AUTORIZAM_PUSH) e nao escreve contrato publico (ver contrato-publico.ts).
+    fast: {
+        modo: 'fast',
+        tag: '#Fast',
+        blocos: [bloco(['GO'], SEM_PAUSA)],
+        pausas: 0,
+        recomendadoPara: 'Pedido pequeno e claro, de minutos: uma fase so (GO), sem cerimonia; o push pede autorizacao',
+    },
 };
-/** Todos os modos na ordem do espectro, do mais HITL ao mais autonomo. */
-exports.ORDEM_DOS_MODOS = ['look', 'ork', 'classic', 'maestro', 'auto'];
+/**
+ * Os modos APOSENTADOS pela I-43, na ordem do espectro.
+ *
+ * Domicilio unico da lista. Nenhum outro arquivo repete estes dois literais.
+ */
+exports.MODOS_APOSENTADOS = ['look', 'ork'];
+/**
+ * Todos os modos que podem estar GRAVADOS em disco, na ordem do espectro.
+ *
+ * Domicilio unico do literal de todos. Antes da I-43 ele existia em tres copias
+ * (`hitl-contract.ts`, `creation-operation-store.ts` e aqui), e encolher uma sem
+ * encolher as outras quebraria recibo historico em silencio. Esta lista NUNCA encolhe.
+ */
+exports.MODOS_LEGADOS = ['look', 'ork', 'classic', 'maestro', 'auto', 'fast'];
+/**
+ * Os modos VIVOS na ordem do espectro, do mais HITL ao mais autonomo.
+ *
+ * E a unica lista que alimenta ESCRITOR: `parseModo`, `extrairTagDoPedido`, a tabela
+ * de `ork modos`, a entrevista do `#setup` e o fallback do manifesto. Encolher aqui
+ * apaga o modo de toda entrada de uma vez, sem tocar em nenhum leitor. Uma thread que
+ * acrescente um modo (a I-42 e `#Fast`) cresce esta mesma lista e mais nada.
+ */
+exports.ORDEM_DOS_MODOS = ['classic', 'maestro', 'auto', 'fast'];
+/**
+ * As #TAGs vivas oferecidas como substituto de um modo aposentado (D7).
+ *
+ * DERIVADA de `ORDEM_DOS_MODOS`, nunca escrita a mao, e essa e a propriedade que
+ * importa: no dia em que a I-42 acrescentar `fast` a lista viva, toda mensagem de
+ * recusa passa a nomear `#Fast` sozinha, sem uma linha de edicao e sem conflito de
+ * merge nessa linha. Nomear um modo que ainda nao existe seria o pecado que o produto
+ * combate; derivar a lista e o que garante que isso nunca aconteca.
+ *
+ * `#Maestro` fica de fora porque ele nao e substituto de `#Look` nem de `#Ork`: e o
+ * modo de gate, com bloco e pausa de outra natureza.
+ *
+ * I-42: so modo de ciclo completo substitui um aposentado. `#Look` e `#Ork` eram os modos
+ * de maior vigilancia; oferecer o `#Fast` (so a GO, sem PLAN nem CHECK) no lugar deles
+ * trocaria o regime de supervisao pelas costas de quem pediu, que e o defeito que a
+ * recusa existe para impedir. A regra e por desenho de ciclo, nao pelo nome do modo.
+ */
+function substitutosVivos() {
+    return exports.ORDEM_DOS_MODOS.filter((m) => m !== 'maestro' && cicloCompleto(m)).map((m) => exports.MODOS[m].tag);
+}
+/** O modo percorre as seis fases canonicas? */
+function cicloCompleto(modo) {
+    return exports.MODOS[modo].blocos.reduce((n, b) => n + b.fases.length, 0) === types_1.FASES.length;
+}
+/** O modo esta aposentado? (esta gravado em disco, e nao pode mais ser escrito) */
+function modoAposentado(modo) {
+    return typeof modo === 'string' && exports.MODOS_APOSENTADOS.includes(modo);
+}
+/** O motivo tipado de quem tentou escrever um modo aposentado (I-43). */
+exports.MOTIVO_MODO_APOSENTADO = 'modo.aposentado';
+/**
+ * A recusa tipada de um modo aposentado, no formato `<dominio>.<motivo>` do produto.
+ *
+ * Ignorar em silencio esta PROIBIDO: e o pecado que o produto inteiro combate, e seria
+ * o pior resultado possivel desta aposentadoria (o builder pede `#Look` e recebe `#Auto`
+ * sem saber). A recusa nomeia o modo pedido e os substitutos VIVOS.
+ *
+ * O texto e DERIVADO de `ORDEM_DOS_MODOS` (ver `substitutosVivos`), nunca escrito a mao.
+ */
+function recusaDeModoAposentado(modo) {
+    const tag = exports.MODOS[modo].tag;
+    return `${exports.MOTIVO_MODO_APOSENTADO}: ${tag} foi aposentado e nao abre trabalho novo. `
+        + `Use ${substitutosVivos().join(' ou ')}. `
+        + `Thread ja gravada em ${tag} continua abrindo normalmente.`;
+}
+/**
+ * O portao de ESCRITA de modo, com recusa tipada em vez de silencio.
+ *
+ * Devolve o modo vivo, ou lanca: `modo.aposentado` para quem saiu do produto e
+ * `modo.desconhecido` para quem nunca existiu. Sao dois erros diferentes de proposito,
+ * porque a acao do dono tambem e diferente: um troca a #TAG, o outro corrige um typo.
+ */
+function exigirModoVivo(entrada) {
+    const vivo = parseModo(entrada);
+    if (vivo)
+        return vivo;
+    const cru = (entrada ?? '').trim().replace(/^--?modo[= ]/i, '').replace(/^#/, '').toLowerCase();
+    if (modoAposentado(cru))
+        throw new Error(recusaDeModoAposentado(cru));
+    throw new Error(`modo.desconhecido: "${entrada ?? ''}" nao e um modo de conducao. `
+        + `Use um de: ${exports.ORDEM_DOS_MODOS.map((m) => exports.MODOS[m].tag).join(', ')}.`);
+}
 /**
  * Parseia a #TAG de modo de conducao.
  * Aceita `#Auto`, `auto`, `--modo auto`, com ou sem caixa. Retorna null se nao reconhecer.
@@ -118,14 +223,40 @@ function parseModo(entrada) {
     return exports.ORDEM_DOS_MODOS.includes(limpo) ? limpo : null;
 }
 /**
- * Extrai a primeira #TAG de modo presente no texto livre de um pedido do builder.
- * E o caminho usado pelos adaptadores de host antes de chamar `ork thread new --modo`.
+ * A primeira #TAG de modo do texto, VIVA OU APOSENTADA, sem julgar qual das duas.
+ *
+ * A lista e derivada de `MODOS_LEGADOS`: nenhuma lista de modos e escrita a mao aqui.
+ * Reconhecer o aposentado e o que permite RECUSAR em vez de ignorar em silencio.
  */
-function extrairTagDoPedido(texto) {
-    const achadas = texto.match(/#(look|ork|classic|maestro|auto)\b/gi);
+function primeiraTagDoPedido(texto) {
+    const alternativas = exports.MODOS_LEGADOS.join('|');
+    const achadas = texto.match(new RegExp(`#(?:${alternativas})\\b`, 'gi'));
     if (!achadas || achadas.length === 0)
         return null;
-    return parseModo(achadas[0]);
+    const cru = achadas[0].slice(1).toLowerCase();
+    return exports.MODOS_LEGADOS.includes(cru) ? cru : null;
+}
+/**
+ * Extrai a primeira #TAG de modo VIVO presente no texto livre de um pedido do builder.
+ * E o caminho usado pelos adaptadores de host antes de chamar `ork thread new --modo`.
+ *
+ * Uma #TAG aposentada devolve null AQUI e e reconhecida por `extrairTagAposentadaDoPedido`:
+ * quem chama decide recusar com motivo, nunca seguir como se nada tivesse sido escrito.
+ */
+function extrairTagDoPedido(texto) {
+    const achada = primeiraTagDoPedido(texto);
+    return achada && !modoAposentado(achada) ? achada : null;
+}
+/**
+ * A #TAG do pedido nomeia um modo APOSENTADO? E o caminho da recusa tipada da I-43.
+ *
+ * Devolve o modo aposentado quando ele e a PRIMEIRA tag do texto, que e a mesma regra
+ * de precedencia de `extrairTagDoPedido`: um pedido com `#Look` antes de `#Auto` e um
+ * pedido em `#Look`, e recusar e diferente de escolher o proximo da fila por conta.
+ */
+function extrairTagAposentadaDoPedido(texto) {
+    const achada = primeiraTagDoPedido(texto);
+    return achada && modoAposentado(achada) ? achada : null;
 }
 /** Tag mostrada quando a thread em disco nao traz um modo reconhecido. */
 exports.TAG_DE_MODO_DESCONHECIDO = '#?';
@@ -156,7 +287,12 @@ function tagDoModo(modo) {
     }
     return exports.TAG_DE_MODO_DESCONHECIDO;
 }
-/** Definicao de um modo, com erro tipado quando o modo nao existe. */
+/**
+ * Definicao de um modo, com erro tipado quando o modo nao existe.
+ *
+ * Leitor: aceita modo aposentado, porque `MODOS` mantem os cinco e porque abrir
+ * thread antiga nao pode estourar. Quem VALIDA entrada usa `parseModo`.
+ */
 function definicaoDoModo(modo) {
     const def = exports.MODOS[modo];
     if (!def)
@@ -180,7 +316,7 @@ function fasePausa(modo, fase) {
     const b = blocoDaFase(modo, fase);
     return b.pausa && b.fases[b.fases.length - 1] === fase;
 }
-/** Tabela dos 5 modos em texto, usada por `ork modos`. */
+/** Tabela dos modos VIVOS em texto, usada por `ork modos`. O numero vem da lista. */
 function tabelaDeModos() {
     const linhas = [];
     linhas.push('Modos de conducao (a #TAG vai no proprio pedido ao orquestrador)');

package/dist/monitor-lock.js

@@ -0,0 +1,110 @@
+"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.adquirirLockMonitor = adquirirLockMonitor;
+exports.comLockDaConversa = comLockDaConversa;
+/**
+ * Locks dos monitores do projeto (`.orkastery/monitor/`).
+ *
+ * `adquirirLockMonitor` morava em `pulse-delivery.ts`. I-41 (GO-FIX 1) o trouxe para ca porque o
+ * receptor do pulse (`pulse-resposta.ts`) tambem precisa dele, e `pulse-delivery` importa o
+ * receptor: um ciclo de modulos em tempo de execucao so aparece como `undefined is not a function`.
+ * `pulse-delivery` continua reexportando o nome, para quem ja o importava de la.
+ */
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+/** Lock compartilhado pelos monitores. ESRCH comprova que o dono morreu. */
+function adquirirLockMonitor(lock) {
+    const pidFile = path.join(lock, 'pid');
+    try {
+        try {
+            fs.mkdirSync(lock);
+        }
+        catch (erro) {
+            if (erro.code !== 'EEXIST')
+                throw erro;
+            const pid = Number(fs.readFileSync(pidFile, 'utf8'));
+            if (!Number.isInteger(pid) || pid <= 0)
+                throw new Error(`lock sem proprietário válido: ${lock}`);
+            try {
+                process.kill(pid, 0);
+                return { ok: false, ativo: true, detalhe: 'varredura já em andamento' };
+            }
+            catch (e) {
+                if (e.code !== 'ESRCH')
+                    throw e;
+            }
+            fs.unlinkSync(pidFile);
+            fs.rmdirSync(lock);
+            fs.mkdirSync(lock);
+        }
+        fs.writeFileSync(pidFile, String(process.pid), { flag: 'wx' });
+        return { ok: true, liberar: () => {
+                if (fs.readFileSync(pidFile, 'utf8') !== String(process.pid))
+                    throw new Error(`lock mudou de proprietário: ${lock}`);
+                fs.unlinkSync(pidFile);
+                fs.rmdirSync(lock);
+            } };
+    }
+    catch (e) {
+        return { ok: false, ativo: false, detalhe: `lock ocupado ou ilegível em ${lock}: ${e.message}` };
+    }
+}
+const pausa = (ms) => { Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms); };
+/**
+ * I-41 (GO-FIX 1): o estado da conversa do pulse (consentimento aberto e lote servido) tem dois
+ * escritores: a varredura, que abre o pedido do resumo, e o receptor, que grava o sim e o lote.
+ * Sem este lock, um sim chegando no meio de uma varredura podia ser sobrescrito por ela. A espera
+ * e curta e limitada: nenhum dos dois segura o lock enquanto fala com o transporte.
+ */
+function comLockDaConversa(dir, executar, esperaMs = 5000) {
+    fs.mkdirSync(dir, { recursive: true });
+    const lock = path.join(dir, 'pulse-conversa.lock');
+    const limite = Date.now() + esperaMs;
+    for (;;) {
+        const trava = adquirirLockMonitor(lock);
+        if (trava.ok) {
+            try {
+                return executar();
+            }
+            finally {
+                trava.liberar();
+            }
+        }
+        if (Date.now() >= limite)
+            throw new Error(`conversa do pulse ocupada: ${trava.detalhe}`);
+        pausa(50);
+    }
+}