@orkastery/cli 0.5.1 → 0.5.6

package/dist/worktree-local.js

@@ -0,0 +1,165 @@
+"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.COMANDO_CONFIRMAR_WORKTREE = exports.ARQUIVO_WORKTREE_LOCAL = exports.CONTRATO_WORKTREE_LOCAL = void 0;
+exports.caminhoRealPrevisto = caminhoRealPrevisto;
+exports.pastaDasWorktreesPedida = pastaDasWorktreesPedida;
+exports.lerWorktreeLocal = lerWorktreeLocal;
+exports.recusaDePastaDasWorktrees = recusaDePastaDasWorktrees;
+exports.exigirPastaDasWorktrees = exigirPastaDasWorktrees;
+exports.confirmarWorktreeLocal = confirmarWorktreeLocal;
+exports.revogarWorktreeLocal = revogarWorktreeLocal;
+/**
+ * RM-047 (fronteira de confiança, P3): a pasta das worktrees fora da raiz vale só com a confirmação
+ * desta máquina.
+ *
+ * O `worktree.dir` mora no `orkastery.yaml`, que vem com o repositório, e o `git worktree add` cria o
+ * checkout (e o `.gitignore` da pasta) onde ele apontar. Dentro da raiz do projeto, pelo caminho real,
+ * nada muda. Fora dela (`..`, caminho absoluto ou um link versionado que leva para fora), a criação
+ * recusa com `worktree.dir-fora-da-raiz` até a máquina confirmar a mesma pasta com
+ * `ork setup worktree confirmar`. A confirmação fica em `.orkastery/private/worktree-local.json`, com
+ * as mesmas regras da postura de sandbox (P1): pasta 0700, arquivo 0600, nunca link, nunca rastreado
+ * pelo git, e só para este checkout e esta pasta.
+ */
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const estado_thread_1 = require("./estado-thread");
+const postura_local_1 = require("./postura-local");
+const util_1 = require("./util");
+exports.CONTRATO_WORKTREE_LOCAL = 'ork.worktree-local/v1';
+exports.ARQUIVO_WORKTREE_LOCAL = 'worktree-local.json';
+/**
+ * Caminho real de um caminho que talvez ainda não exista: o real do ancestral mais próximo que existe,
+ * mais o resto. Um link no caminho (inclusive versionado no clone) é resolvido aqui.
+ */
+function caminhoRealPrevisto(alvo) {
+    let atual = path.resolve(alvo);
+    const resto = [];
+    for (;;) {
+        try {
+            return path.join(fs.realpathSync(atual), ...resto.reverse());
+        }
+        catch { /* sobe */ }
+        const pai = path.dirname(atual);
+        if (pai === atual)
+            return path.resolve(alvo);
+        resto.push(path.basename(atual));
+        atual = pai;
+    }
+}
+/** A pasta das worktrees que o manifesto pede, pelo caminho real, e se ela fica dentro da raiz. */
+function pastaDasWorktreesPedida(raiz, manifesto) {
+    let principal;
+    try {
+        principal = (0, estado_thread_1.raizDoEstado)(raiz);
+    }
+    catch {
+        principal = path.resolve(raiz);
+    }
+    const raizReal = caminhoRealPrevisto(principal);
+    const dir = caminhoRealPrevisto(path.resolve(principal, manifesto.worktree.dir));
+    const rel = path.relative(raizReal, dir);
+    const primeiro = rel.split(path.sep)[0];
+    const dentro = !rel.startsWith('..') && !path.isAbsolute(rel) && primeiro !== '.git';
+    return { dir, dentro };
+}
+/** Lê a confirmação local; `null` com o motivo quando ela não existe ou não vale. */
+function lerWorktreeLocal(raiz) {
+    const { bruto: o, motivo } = (0, postura_local_1.lerArquivoPrivado)(raiz, exports.ARQUIVO_WORKTREE_LOCAL);
+    if (!o)
+        return { local: null, motivo };
+    if (o.contrato !== exports.CONTRATO_WORKTREE_LOCAL || typeof o.dir !== 'string' || typeof o.raiz !== 'string' ||
+        typeof o.confirmadoEm !== 'string' || typeof o.por !== 'string') {
+        return { local: null, motivo: `${exports.ARQUIVO_WORKTREE_LOCAL} fora do contrato ${exports.CONTRATO_WORKTREE_LOCAL}` };
+    }
+    if (o.raiz !== (0, postura_local_1.raizRealDoEstado)(raiz))
+        return { local: null, motivo: 'a confirmação local é de outro checkout' };
+    return { local: o, motivo: null };
+}
+/** Comando que confirma a pasta nesta máquina; vai em toda recusa. */
+exports.COMANDO_CONFIRMAR_WORKTREE = 'ork setup worktree confirmar';
+/**
+ * A recusa da criação de worktree: `null` quando a pasta do manifesto fica dentro da raiz, ou quando
+ * a máquina confirmou exatamente essa pasta; senão o erro tipado com o comando que confirma.
+ */
+function recusaDePastaDasWorktrees(raiz, manifesto) {
+    const { dir, dentro } = pastaDasWorktreesPedida(raiz, manifesto);
+    if (dentro)
+        return null;
+    const { local, motivo } = lerWorktreeLocal(raiz);
+    if (local && local.dir === dir)
+        return null;
+    const porque = local ? `a máquina confirmou ${local.dir}` : motivo ?? 'sem confirmação local';
+    return `worktree.dir-fora-da-raiz: o orkastery.yaml pede worktree.dir: ${JSON.stringify(manifesto.worktree.dir).slice(0, 200)}, ` +
+        `que leva a ${dir}, fora da raiz do projeto (pelo caminho real), e esta máquina não confirmou essa pasta (${porque}). ` +
+        'Nenhuma worktree foi criada. O manifesto vem com o repositório; quem decide criar checkout fora da raiz é a ' +
+        `máquina. Para aceitar nesta máquina: ${exports.COMANDO_CONFIRMAR_WORKTREE} (ou volte worktree.dir para dentro do projeto, ` +
+        'como .claude/worktrees).';
+}
+/** Lança a recusa, quando houver. */
+function exigirPastaDasWorktrees(raiz, manifesto) {
+    const recusa = recusaDePastaDasWorktrees(raiz, manifesto);
+    if (recusa)
+        throw new Error(recusa);
+}
+/**
+ * Grava a confirmação local da pasta que o manifesto pede hoje. Com `esperado`, ele precisa levar à
+ * mesma pasta: a máquina confirma o que leu, não o que o manifesto pode passar a dizer depois.
+ */
+function confirmarWorktreeLocal(raiz, manifesto, por, esperado) {
+    const { dir, dentro } = pastaDasWorktreesPedida(raiz, manifesto);
+    if (esperado !== undefined) {
+        let principal;
+        try {
+            principal = (0, estado_thread_1.raizDoEstado)(raiz);
+        }
+        catch {
+            principal = path.resolve(raiz);
+        }
+        const pedido = caminhoRealPrevisto(path.resolve(principal, esperado));
+        if (pedido !== dir) {
+            throw new Error(`worktree.dir-divergente: o orkastery.yaml leva a ${dir}, não a ${pedido}; nada foi confirmado`);
+        }
+    }
+    if (dentro)
+        throw new Error(`worktree.dir-dentro-da-raiz: ${dir} fica dentro do projeto e não precisa de confirmação`);
+    const local = { contrato: exports.CONTRATO_WORKTREE_LOCAL, dir, raiz: (0, postura_local_1.raizRealDoEstado)(raiz), confirmadoEm: (0, util_1.agora)(), por };
+    (0, postura_local_1.gravarArquivoPrivado)(raiz, exports.ARQUIVO_WORKTREE_LOCAL, local);
+    return local;
+}
+/** Apaga a confirmação local; devolve se havia uma. */
+function revogarWorktreeLocal(raiz) {
+    return (0, postura_local_1.revogarArquivoPrivado)(raiz, exports.ARQUIVO_WORKTREE_LOCAL);
+}

package/dist/worktree.js

@@ -64,9 +64,13 @@ const leases_1 = require("./leases");
 const thread_1 = require("./thread");
 const util_1 = require("./util");
 const estado_thread_1 = require("./estado-thread");
-/** Diretorio canonico da worktree de uma thread, resolvido pelo `ork`. */
+const procedencia_1 = require("./procedencia");
+/**
+ * Diretorio canonico da worktree de uma thread, resolvido pelo `ork` na arvore principal: o mesmo que a criacao usa,
+ * tambem quando o comando roda de dentro de outra worktree (P4 do ensaio da 0.5.0).
+ */
 function dirDaWorktree(carregado, id) {
-    return path.resolve(carregado.raiz, carregado.manifesto.worktree.dir, id);
+    return (0, thread_1.pastaDaWorktree)(carregado, id);
 }
 /** Branch canonica da worktree de uma thread. */
 function branchDaWorktree(thread) {
@@ -517,7 +521,18 @@ function auditarWorktree(carregado, id) {
                 correcao: `git -C ${dir} switch ${branchEsperada}`,
             });
     }
+    // RM-047 (P2): git so roda na worktree registrada e com o thread.json local.
+    let procedencia = null;
     if (existe) {
+        try {
+            (0, procedencia_1.exigirCwdLocal)(raiz, id, dir, 'thread');
+        }
+        catch (e) {
+            procedencia = e.message;
+            checks.push({ nome: 'procedencia', nivel: 'fail', detalhe: procedencia, correcao: `ork worktree ensure ${id}` });
+        }
+    }
+    if (existe && procedencia === null) {
         const limpa = arvoreLimpa(dir);
         checks.push(limpa === true
             ? { nome: 'arvore', nivel: 'ok', detalhe: 'sem alteracao nao commitada' }
@@ -638,6 +653,14 @@ function liberarWorktree(carregado, id, opcoes = {}) {
             correcao: '',
         };
     }
+    // RM-047 (P2): nada de git num diretorio que o thread.json escolheu e o git nao registra.
+    try {
+        (0, procedencia_1.exigirCwdLocal)(raiz, id, dir, 'thread');
+    }
+    catch (e) {
+        return { ok: false, removida: false, dir, branch, leasesLiberados: [], motivo: 'tree.blocked',
+            detalhe: e.message, correcao: `confira o diretorio e o thread.json da thread ${id}` };
+    }
     const limpa = arvoreLimpa(dir);
     if (limpa === false && !opcoes.forcar) {
         return {

package/dist/yaml.js

@@ -55,10 +55,16 @@ function escalar(bruto) {
     }
     return t;
 }
-function preparar(texto) {
+function preparar(texto, estrito) {
     const linhas = [];
     texto.split('\n').forEach((original, i) => {
-        const semComentario = tirarComentario(original).replace(/\s+$/, '');
+        const cortada = tirarComentario(original);
+        // D9: no modo estrito, o `#` depois do valor nao corta o valor calado (`titulo: Decisao #42`); com o `#`
+        // no texto, o valor vai entre aspas. Comentario na linha inteira segue valendo.
+        if (estrito && cortada !== original && cortada.trim() !== '') {
+            throw new Error(`YAML invalido na linha ${i + 1}: comentario depois do valor (com # no texto, use aspas)`);
+        }
+        const semComentario = cortada.replace(/\s+$/, '');
         if (semComentario.trim() === '')
             return;
         if (semComentario.trim() === '---')
@@ -68,7 +74,7 @@ function preparar(texto) {
     });
     return linhas;
 }
-function parseBloco(linhas, inicio, indent) {
+function parseBloco(linhas, inicio, indent, estrito) {
     let i = inicio;
     if (i >= linhas.length)
         return [null, i];
@@ -89,6 +95,9 @@ function parseBloco(linhas, inicio, indent) {
             throw new Error(`YAML invalido na linha ${linha.numero}: esperado "chave: valor"`);
         }
         const chave = linha.conteudo.slice(0, sep).trim().replace(/^["']|["']$/g, '');
+        if (estrito && (chave === '__proto__' || Object.hasOwn(mapa, chave))) {
+            throw new Error(`YAML invalido na linha ${linha.numero}: chave ${chave === '__proto__' ? 'reservada' : 'repetida'}`);
+        }
         const resto = linha.conteudo.slice(sep + 1).trim();
         i++;
         if (resto !== '') {
@@ -96,7 +105,7 @@ function parseBloco(linhas, inicio, indent) {
             continue;
         }
         if (i < linhas.length && linhas[i].indent > indent) {
-            const [filho, proximo] = parseBloco(linhas, i, linhas[i].indent);
+            const [filho, proximo] = parseBloco(linhas, i, linhas[i].indent, estrito);
             mapa[chave] = filho;
             i = proximo;
         }
@@ -106,11 +115,21 @@ function parseBloco(linhas, inicio, indent) {
     }
     return [mapa, i];
 }
-/** Le um documento YAML do subconjunto suportado. */
-function lerYaml(texto) {
-    const linhas = preparar(texto);
+/**
+ * Le um documento YAML do subconjunto suportado.
+ *
+ * RM-026 K7 (D9): `estrito` serve a quem le texto que nao e do `ork` (o frontmatter do conhecimento). Chave
+ * repetida no mesmo mapa, `__proto__`, comentario depois do valor e linha que sobra (indentacao fora do bloco)
+ * recusam, em vez de sumir calados como no modo padrao, que o `orkastery.yaml` e as paginas de docs seguem usando.
+ */
+function lerYaml(texto, opcoes = {}) {
+    const estrito = opcoes.estrito === true;
+    const linhas = preparar(texto, estrito);
     if (linhas.length === 0)
         return {};
-    const [valor] = parseBloco(linhas, 0, linhas[0].indent);
+    const [valor, proximo] = parseBloco(linhas, 0, linhas[0].indent, estrito);
+    if (estrito && proximo < linhas.length) {
+        throw new Error(`YAML invalido na linha ${linhas[proximo].numero}: indentacao fora do bloco`);
+    }
     return valor;
 }

package/eval/fixtures/fx-pedido-colado/caso.json

@@ -0,0 +1,20 @@
+{
+  "id": "fx-pedido-colado",
+  "sobre": "Incidente de 01/10/2026 (RM-057): o pedido colado com autorização explícita segue sem parar",
+  "precisa": [
+    "git"
+  ],
+  "esperado": {
+    "simulado": true,
+    "modoDoPedido": "auto",
+    "semPausaDoModo": true,
+    "decisaoInformada": true,
+    "confirmoRecusado": "hitl.selecao.texto-livre",
+    "nadaGravadoNaRecusa": true,
+    "humanosNoPulse": 0,
+    "perguntasDeConducao": 0,
+    "tempoParadoMs": 0,
+    "adaptadoresComARegra": 4
+  },
+  "porque": "Na noite de 01 para 02/10 o condutor parou mais de 10 h pedindo um confirmo em texto livre a um pedido colado que já trazia a autorização. O canário prova, contra o código real, que o #Auto não pausa, a dúvida vira decisão informada, o confirmo em texto é recusado sem gravar nada, ninguém aparece esperando no pulse, o tempo parado é zero e os quatro adaptadores dizem a regra."
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@orkastery/cli",
-  "version": "0.5.1",
+  "version": "0.5.6",
   "description": "A software factory of AI agents that proves its work: parallel threads, verified results, and short decisions only when they matter.",
   "license": "MIT",
   "homepage": "https://github.com/orkastery/orkastery#readme",
@@ -65,12 +65,16 @@
   },
   "devDependencies": {
     "@types/node": "^22.10.2",
-    "markdownlint-cli2": "^0.23.3",
-    "typescript": "^5.9.2"
+    "markdownlint-cli2": "^0.22.1"
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "1.29.0",
+    "decode-named-character-reference": "1.3.0",
+    "micromark": "4.0.2",
+    "micromark-extension-gfm-table": "2.1.1",
+    "micromark-util-decode-numeric-character-reference": "2.0.2",
     "smol-toml": "1.8.0",
+    "typescript": "5.9.3",
     "zod": "3.25.76",
     "zod-to-json-schema": "3.25.2"
   }

package/references/definition-of-done.md

@@ -54,7 +54,7 @@ flowchart LR
 
 | # | Verificacao | Como se comprova |
 |---|---|---|
-| 16 | Existe MASTER log valido contra o contrato congelado `ork.master-log/v1`, com POSTMORTEM tipado, classes de falha do catalogo fixo, score inteiro de 0 a 5 e justificativa nao vazia. Uma entrega sem MASTER log nao aconteceu. | `ork master <thread> --score N --justificativa "<texto>"`. O comando recusa score fora da escala, score sem justificativa e classe fora do catalogo, e nao grava nada quando recusa. |
+| 16 | Existe MASTER log valido contra o contrato congelado `ork.master-log/v1`, com POSTMORTEM tipado, classes de falha do catalogo fixo, score inteiro de 0 a 5 e justificativa nao vazia. Uma entrega sem MASTER log nao aconteceu. | `ork master <thread> --score N --justificativa "<texto>" --por <quem>`. O comando recusa score fora da escala, score sem justificativa, score sem autoria humana em `--por` e classe fora do catalogo, e nao grava nada quando recusa. |
 
 ## Toda thread, no seu inicio
 

package/schemas/code-artifact-graph.v1.schema.json

@@ -258,7 +258,8 @@
                   "imports",
                   "calls",
                   "references",
-                  "derived_from"
+                  "derived_from",
+                  "cites"
                 ]
               },
               "snapshot_id": {

package/skills/README.md

@@ -18,7 +18,7 @@ faz, o nucleo vence, e a divergencia e defeito da skill.
 | phases | [go-implementation](phases/go-implementation/SKILL.md) | `ork worktree ensure`, `ork verify --baseline` |
 | phases | [check-quality](phases/check-quality/SKILL.md) | `ork verify`, `ork gate request` |
 | phases | [ship-release](phases/ship-release/SKILL.md) | `ork ship` |
-| phases | [master-metrics](phases/master-metrics/SKILL.md) | `ork master`, `ork master --aceitar-omissao` |
+| phases | [master-metrics](phases/master-metrics/SKILL.md) | `ork master`, `ork master <thread> --aceitar-omissao` |
 | reviewers | [code-reviewer](reviewers/code-reviewer/SKILL.md) | `references/code-review-axes.md` |
 | reviewers | [security-auditor](reviewers/security-auditor/SKILL.md) | `references/security-checklist.md` |
 | reviewers | [test-engineer](reviewers/test-engineer/SKILL.md) | `references/testing-patterns.md` |

package/skills/core/orkastery-bootstrap/SKILL.md

@@ -56,6 +56,7 @@ Prefira MCP no projeto fixado pelo servidor, sem outro root/cwd. No Claude com s
 | Demanda nova | `ork_thread_new(nome, modo)` | `ork thread new "<nome>" --mode <modo> --worktree auto` |
 | Despacho | `ork_phase_run(threadId, fase, prompt, runtime?, model?, effort?, dryRun?)` | `ork phase run <thread> GOAL --prompt "<pedido>"` |
 | Progresso nativo | `ork_observe(threadId)` | `ork thread status <thread>` |
+| Contexto do grafo (somente com `grafo.mcp: true`) | `ork_grafo_contexto(threadId, tetoBytes?)`; aprofundar com `ork_grafo_vizinhos`, `ork_grafo_chamadores`, `ork_grafo_importadores`, `ork_grafo_caminho` | `ork grafo contexto <thread> --json` |
 | Pendencia/decisao | `ork_hitl_pending`, `ork_request_decision(threadId, pedidoId)` | Consulte o ingresso suportado; nao fabrique resposta. |
 
 Prefira `ork_git_commit` (HEAD atual, paths com claims), `ork_verify` e `ork_ship` (HEADs fonte/destino reais) para registrar, verificar e entregar. Autoria/commit nao e SHIP; retorno incomplete exige reconciliacao antes de repetir. Para demandas novas, use `ork modos --do-pedido "<pedido do dono>"` e `ork_preflight({modo})` (CLI: `ork doctor --modo <modo>`). A sonda por bloco não comprova autenticação, gates ou entrega.
@@ -71,8 +72,7 @@ Dry-run nao inicia modelo, mas pode gravar prompt/eventos. Confira o trio efetiv
 
 ## Conducao durante o trabalho
 
-O modo afrouxa a pausa, NUNCA a verificacao. Claims, verify, policies e gates tipados
-rodam identicos em `#Classic` e em `#Auto`; o modo decide se o veredito espera o humano.
+O modo afrouxa a pausa, NUNCA a verificacao. Claims, verify, policies e gates tipados rodam identicos em `#Classic` e em `#Auto`; o modo decide se o veredito espera o humano.
 
 Depois de uma acao, use o resultado do nucleo para executar o proximo passo autorizado.
 Em #Auto/#Maestro, nao termine um bloco apenas oferecendo continuar quando ainda ha trabalho

package/skills/phases/master-metrics/SKILL.md

@@ -1,8 +1,8 @@
 ---
 name: master-metrics
-description: "Fase MASTER (F6): POSTMORTEM tipado, MASTER log no contrato congelado ork.master-log/v1 e o score humano de 0 a 5 com justificativa. Roteia para ork master e ork master --aceitar-omissao."
+description: "Fase MASTER (F6): POSTMORTEM tipado, MASTER log no contrato congelado ork.master-log/v1 e o score humano de 0 a 5 com justificativa. Roteia para ork master e ork master <thread> --aceitar-omissao."
 bucket: phases
-roteia: "ork master <thread> --score N --justificativa \"...\" | ork master --aceitar-omissao"
+roteia: "ork master <thread> --score N --justificativa \"...\" | ork master <thread> --aceitar-omissao"
 license: MIT
 ---
 
@@ -21,9 +21,14 @@ ork master classes                            # as classes de falha do catalogo
 ork master <thread> --score 4 --justificativa "<texto>" --classe base-avancou --por <quem>
 ork master                                    # as entregas, com o indice derivado do ledger
 ork master --todas                            # inclusive as ja pontuadas
-ork master --aceitar-omissao                  # aceita as entregues, com indice e insumos no ledger
+ork master <thread> --aceitar-omissao         # aceita so a entrega desta thread, com indice e insumos no ledger
+ork master --aceitar-omissao --dry-run        # lista o que a forma sem thread fecharia, sem gravar
 ```
 
+Agente fecha so a propria thread: `ork master <thread> --aceitar-omissao`. Sem a thread, o comando
+aceita TODAS as entregues do projeto, inclusive as de outras frentes paralelas (o que aconteceu tres
+vezes em 03/10/2026); de processo de agente com mais de uma, o `ork` avisa em stderr.
+
 ## O que o MASTER entrega
 
 1. **POSTMORTEM tipado**, com as fases percorridas, o que falhou e a classe de falha vinda de um