@orkastery/cli 0.5.1 → 0.5.3

package/dist/thread.js

@@ -47,7 +47,16 @@ exports.lerThread = lerThread;
 exports.gravarThread = gravarThread;
 exports.avisoDeThreadSemBase = avisoDeThreadSemBase;
 exports.idDisponivel = idDisponivel;
+exports.pastaDaWorktree = pastaDaWorktree;
+exports.alvoDaWorktree = alvoDaWorktree;
+exports.worktreePrevista = worktreePrevista;
 exports.criarWorktree = criarWorktree;
+exports.pedidoDeWorktree = pedidoDeWorktree;
+exports.linhaDaWorktree = linhaDaWorktree;
+exports.avisoDeThreadSemWorktree = avisoDeThreadSemWorktree;
+exports.avisoDeWorktreeQueFalharia = avisoDeWorktreeQueFalharia;
+exports.avisoDeChaveSemCommit = avisoDeChaveSemCommit;
+exports.avisoDaWorktree = avisoDaWorktree;
 exports.novaThread = novaThread;
 exports.exigirVarianteCompativel = exigirVarianteCompativel;
 exports.blocoDaThread = blocoDaThread;
@@ -141,6 +150,43 @@ function idDisponivel(raiz, abbrev, assunto) {
     }
     return { id: `${abbrev}-${candidato}`, assunto: candidato };
 }
+/**
+ * Pasta da worktree de uma thread: `worktree.dir` resolvido na arvore principal, nunca na worktree de onde o comando
+ * roda. P4 do ensaio da 0.5.0 (CHECK): com a chave valendo, o `ork thread new` rodado de dentro da worktree de outra
+ * thread aninhava a nova na pasta da mae, e o release da mae levava a da filha junto.
+ */
+function pastaDaWorktree(carregado, id) {
+    return path.resolve((0, estado_thread_1.raizDoEstado)(carregado.raiz), carregado.manifesto.worktree.dir, id);
+}
+/** Pasta e branch da worktree de uma thread: o que `criarWorktree` cria e o `--dry-run` preve. */
+function alvoDaWorktree(carregado, id, slug, opcoes = {}) {
+    return { dir: pastaDaWorktree(carregado, id), branch: opcoes.branchExistente ?? `ork/${slug}` };
+}
+/**
+ * P4 do ensaio da 0.5.0: a worktree que `criarWorktree` criaria para este id, sem criar nada. Mesma pasta, mesma
+ * branch e o commit de onde ela partiria: a branch existente (ciclo `merge-branch`), senao a base do manifesto,
+ * senao o HEAD. Diz tambem o que faria a criacao recusar: a pasta que ja existe, o repositorio sem commit ou a
+ * branch nova que ja existe.
+ */
+function worktreePrevista(carregado, id, slug, opcoes = {}) {
+    const alvo = alvoDaWorktree(carregado, id, slug, opcoes);
+    const refs = opcoes.branchExistente
+        ? [opcoes.branchExistente]
+        : [opcoes.base ?? carregado.manifesto.worktree.base_branch, 'HEAD'];
+    let commit = null;
+    for (const ref of refs) {
+        const r = (0, util_1.exec)('git', ['rev-parse', '--verify', ref], carregado.raiz);
+        if (r.ok) {
+            commit = r.stdout.trim();
+            break;
+        }
+    }
+    const branchJaExiste = !opcoes.branchExistente &&
+        (0, util_1.exec)('git', ['rev-parse', '--verify', '--quiet', `refs/heads/${alvo.branch}`], carregado.raiz).ok;
+    const falha = fs.existsSync(alvo.dir) ? 'pasta-existe'
+        : commit === null ? 'sem-commit' : branchJaExiste ? 'branch-existe' : null;
+    return { ...alvo, commit, falha };
+}
 /**
  * Cria a worktree isolada da thread (paralelismo sem colisao entre threads).
  *
@@ -150,8 +196,7 @@ function idDisponivel(raiz, abbrev, assunto) {
  */
 function criarWorktree(carregado, id, slug, opcoes = {}) {
     const { raiz, manifesto } = carregado;
-    const dir = path.resolve(raiz, manifesto.worktree.dir, id);
-    const branch = opcoes.branchExistente ?? `ork/${slug}`;
+    const { dir, branch } = alvoDaWorktree(carregado, id, slug, opcoes);
     if (fs.existsSync(dir)) {
         throw new Error(`worktree ja existe em ${dir}`);
     }
@@ -170,7 +215,7 @@ function criarWorktree(carregado, id, slug, opcoes = {}) {
         throw new Error(`git worktree add falhou: ${(r.stderr || r.stdout).trim()}`);
     }
     if (pastaNova)
-        (0, util_1.ignorarPastaNoGit)(pastaDasWorktrees, raiz);
+        (0, util_1.ignorarPastaNoGit)(pastaDasWorktrees, (0, estado_thread_1.raizDoEstado)(raiz));
     const lista = (0, util_1.exec)('git', ['worktree', 'list', '--porcelain'], raiz);
     const criada = lista.ok && lista.stdout.split('\n').some((l) => l.trim() === `worktree ${dir}`);
     if (!criada) {
@@ -179,6 +224,105 @@ function criarWorktree(carregado, id, slug, opcoes = {}) {
     (0, estado_thread_1.vincularEstado)(raiz, id, dir);
     return { dir, branch };
 }
+/**
+ * Resolve `--worktree`, `--sem-worktree` e `worktree.por_thread`. As flags vencem a chave; as duas juntas, ou
+ * `--sem-worktree` com valor (o parser leva o argumento seguinte), sao erro de uso. `--worktree` sozinho ou `auto`
+ * cria a worktree; outro texto e um diretorio que ja existe, como antes.
+ */
+function pedidoDeWorktree(flags, porThread) {
+    const worktree = flags.worktree === false ? undefined : flags.worktree;
+    if (typeof worktree === 'string' && !worktree.trim())
+        throw new Error('uso: --worktree pede auto ou um diretório que já existe');
+    if (typeof flags.semWorktree === 'string') {
+        throw new Error(`uso: --sem-worktree não leva valor (recebeu "${flags.semWorktree}")`);
+    }
+    const semWorktree = flags.semWorktree === true;
+    if (semWorktree && worktree !== undefined)
+        throw new Error('uso: --worktree e --sem-worktree se excluem; use um dos dois');
+    if (semWorktree)
+        return { criar: false, dir: null, origem: 'sem-worktree' };
+    if (worktree === true || worktree === 'auto')
+        return { criar: true, dir: null, origem: 'flag' };
+    if (typeof worktree === 'string')
+        return { criar: false, dir: worktree, origem: 'diretorio' };
+    return porThread ? { criar: true, dir: null, origem: 'chave' } : { criar: false, dir: null, origem: 'nenhuma' };
+}
+/**
+ * P4 do ensaio da 0.5.0: a linha que diz de onde veio a worktree da thread nova. Na criacao, so quando ela veio da
+ * chave (quem passou `--worktree auto` sabe de onde ela veio); no `--dry-run`, para qualquer origem.
+ */
+function linhaDaWorktree(por, gravada, variante) {
+    if (!por || (gravada && por !== 'chave'))
+        return null;
+    const verbo = gravada ? 'criada' : 'seria criada';
+    if (por === 'chave') {
+        return `  worktree: ${verbo} pela chave worktree.por_thread do orkastery.yaml; para criar sem ela, use --sem-worktree`;
+    }
+    if (por === 'flag')
+        return `  worktree: ${verbo} pelo --worktree auto`;
+    return `  worktree: ${verbo} pelo ciclo ${variante ?? 'da thread'}, que exige worktree isolada`;
+}
+/**
+ * P4 do ensaio da 0.5.0: o que acontece no SHIP com a thread criada por `--sem-worktree`. O `ork ship` entrega a
+ * branch em que a raiz estava na criacao (`thread.base.branch`), e a policy `push_direto_na_base` do manifesto barra
+ * (`block`), avisa (outro valor) ou deixa passar (sem ela, ou `off`) a entrega de uma branch para ela mesma ou da
+ * base. Raiz fora de branch (HEAD destacado ou repositorio sem commit) nao tem branch de origem.
+ */
+function avisoDeThreadSemWorktree(thread, manifesto, gravada = true) {
+    const base = manifesto.worktree.base_branch;
+    const branch = thread.base.branch;
+    const inicio = gravada
+        ? `Aviso: thread ${thread.id} sem worktree (--sem-worktree): ela trabalha na raiz do projeto`
+        : `Aviso: sem worktree (--sem-worktree), a thread ${thread.id} trabalharia na raiz do projeto`;
+    const ensure = `Antes do GO, ork worktree ensure ${thread.id} cria a worktree e a branch da thread`;
+    if (thread.base.commit === util_1.COMMIT_DESCONHECIDO) {
+        // Sem commit, nem o `ork worktree ensure` tem de onde partir: o caminho e o do aviso de thread sem base.
+        return `${inicio}, num repositório ainda sem commit, fora de qualquer branch, e o ork ship não tem branch de origem ` +
+            'para entregar. Faça o primeiro commit e siga o aviso de thread sem base.';
+    }
+    if (branch === 'HEAD') {
+        return `${inicio}, com o HEAD destacado, fora de qualquer branch, e o ork ship não tem branch de origem para entregar. ${ensure}.`;
+    }
+    if (branch !== base) {
+        return `${inicio}, na branch ${branch}, e o ork ship entrega essa branch como estiver, com o que mais entrar nela; ` +
+            `com --para ${branch}, a entrega vira push direto, que a policy push_direto_na_base confere. ${ensure}.`;
+    }
+    const policy = manifesto.policies?.push_direto_na_base;
+    const efeito = policy === 'block'
+        ? 'o ork ship barra a entrega por push_direto_na_base (block): não há branch de thread para mergear'
+        : policy === undefined || policy === 'off'
+            ? 'o ork ship empurra a base direto, sem branch de thread (push_direto_na_base desligada)'
+            : `o ork ship avisa push_direto_na_base (${policy}) e empurra a base direto, sem branch de thread`;
+    return `${inicio}, na branch base ${base}, e ${efeito}. ${ensure}; depois do GO, os commits já estão na base e o ship não os separa.`;
+}
+/**
+ * P4 do ensaio da 0.5.0 (CHECK): no `--dry-run`, por que a criacao de verdade recusaria a worktree, em vez de preve-la.
+ * O ciclo que exige worktree nao aceita `--sem-worktree`, entao a saida so e sugerida para a chave e a flag.
+ */
+function avisoDeWorktreeQueFalharia(f) {
+    const semWorktree = f.por === 'ciclo' ? '' : ' ou crie com --sem-worktree';
+    if (f.motivo === 'pasta-existe') {
+        return `Aviso: a pasta ${f.dir} já existe, e a criação de verdade recusaria a worktree da thread: tire a pasta${semWorktree}.`;
+    }
+    if (f.motivo === 'branch-existe') {
+        return `Aviso: a branch ${f.branch} já existe, e a criação de verdade recusaria a worktree da thread: tire a branch${semWorktree}.`;
+    }
+    return 'Aviso: o repositório ainda não tem commit, e a criação de verdade recusaria a worktree da thread no git worktree add: ' +
+        'faça o primeiro commit antes.';
+}
+/** P4 do ensaio da 0.5.0: a worktree que a chave pede nao tem de onde partir num repositorio sem commit. */
+function avisoDeChaveSemCommit(gravada) {
+    return 'Aviso: worktree.por_thread pede a worktree da thread, mas o repositório ainda não tem commit: ' +
+        `a thread ${gravada ? 'nasceu' : 'nasceria'} na raiz do projeto, sem worktree.`;
+}
+/** P4: o aviso de worktree do `ork thread new`, para o stderr, ou `null` quando nao ha o que avisar. */
+function avisoDaWorktree(origem, resultado, manifesto) {
+    if (origem === 'sem-worktree')
+        return avisoDeThreadSemWorktree(resultado.thread, manifesto, resultado.gravada);
+    if (origem === 'chave' && !resultado.worktreePor)
+        return avisoDeChaveSemCommit(resultado.gravada);
+    return null;
+}
 /** Cria a thread: valida modo contra o manifesto, gera o slug e carimba a base. */
 function novaThread(carregado, opcoes) {
     if (opcoes.dryRun)
@@ -236,6 +380,13 @@ function criarThreadSerializada(carregado, opcoes) {
     else if (opcoes.branch) {
         throw new Error('--branch so vale com --ciclo merge-branch');
     }
+    // `greenfield`, `merge-branch` e `feature-xl-faseada` exigem worktree isolada: sao os
+    // ciclos que escrevem codigo em paralelo com outras threads.
+    const exigeWorktree = variante ? (0, ciclos_1.definicaoDaVariante)(variante).exigeWorktree : false;
+    // P4 do ensaio da 0.5.0 (D4): o ciclo que exige worktree nao nasce sem ela, e a recusa sai antes de gravar.
+    if (exigeWorktree && opcoes.origemDaWorktree === 'sem-worktree') {
+        throw new Error(`o ciclo ${variante} exige worktree isolada: crie a thread sem --sem-worktree ou escolha outro ciclo`);
+    }
     const reservation = opcoes.reservation;
     const operation = reservation ? (0, creation_operation_store_1.readCreationOperation)(raiz, reservation.operationId, reservation.principal) : null;
     if (operation && (!operation.reserved.threadIds.includes(reservation.threadId)
@@ -260,11 +411,11 @@ function criarThreadSerializada(carregado, opcoes) {
         && fs.readdirSync(dirThread(raiz, reservation.threadId)).some((name) => !/^\.thread\.json\..+\.tmp$/.test(name))) {
         throw new Error('creation.conflict: diretório reservado sem origem confirmada');
     }
+    // P4 do ensaio da 0.5.0 (CHECK): o ensaio usa o mesmo id livre da criacao (o `idDisponivel` so le o disco), para a
+    // worktree que ele mostra ser a que a criacao usaria.
     const { id, assunto } = reservation
         ? { id: reservation.threadId, assunto: reservation.threadId.slice(abbrev.length + 1) }
-        : opcoes.dryRun
-            ? { id: `${abbrev}-${assuntoBruto}`, assunto: assuntoBruto }
-            : idDisponivel(raiz, abbrev, assuntoBruto);
+        : idDisponivel(raiz, abbrev, assuntoBruto);
     const slug = opcoes.slug ?? (0, slug_1.montarSlug)(abbrev, assunto, blocos[0].slugFases);
     // O override `--slug` do builder tambem passa pela regex canonica.
     if (!(0, slug_1.slugValido)(slug)) {
@@ -300,13 +451,38 @@ function criarThreadSerializada(carregado, opcoes) {
     };
     if (variante === 'feature-xl-faseada')
         thread.fatias = opcoes.fatias ?? 3;
-    if (opcoes.dryRun)
-        return { thread, gravada: false };
+    // P4 do ensaio da 0.5.0: por que a thread ganha a worktree. O ensaio e a chave preveem a worktree antes; a pedida
+    // por flag ou por ciclo segue direto ao git, como era. A pedida so pela chave espera o primeiro commit (D3): sem
+    // commit, a thread fica na raiz, como antes. O ciclo que exige worktree vence a chave e a flag na origem: a worktree
+    // e dele, e o `--sem-worktree` que a linha da chave sugeriria ele recusa (CHECK, rodada 2).
+    const pedeWorktree = opcoes.criarWorktree === true || exigeWorktree;
+    const pelaChave = opcoes.criarWorktree === true && opcoes.origemDaWorktree === 'chave';
+    const prevista = pedeWorktree && (opcoes.dryRun || pelaChave)
+        ? worktreePrevista(carregado, id, slug, { branchExistente: opcoes.branch }) : null;
+    const worktreePor = !pedeWorktree || (pelaChave && !exigeWorktree && prevista?.falha === 'sem-commit') ? null
+        : exigeWorktree ? 'ciclo' : pelaChave ? 'chave' : 'flag';
+    if (opcoes.dryRun) {
+        // P4 (D8): o ensaio mostra a worktree que a criacao usaria; quando ela recusaria, diz por que, em vez de preve-la.
+        if (worktreePor && prevista?.falha) {
+            return { thread, gravada: false, worktreePor: null,
+                worktreeFalharia: { motivo: prevista.falha, dir: prevista.dir, branch: prevista.branch, por: worktreePor } };
+        }
+        if (worktreePor && prevista?.commit) {
+            thread.worktree = prevista.dir;
+            thread.base = { branch: prevista.branch, commit: prevista.commit };
+        }
+        return { thread, gravada: false, worktreePor };
+    }
+    // P4 (CHECK): a worktree pedida so pela chave, com a pasta ou a branch ja ocupadas, recusa dizendo de onde veio o
+    // pedido e qual e a saida.
+    const ocupadaPelaChave = pelaChave && !exigeWorktree && prevista &&
+        (prevista.falha === 'pasta-existe' || prevista.falha === 'branch-existe') ? prevista : null;
+    if (ocupadaPelaChave) {
+        const qual = ocupadaPelaChave.falha === 'pasta-existe' ? `a pasta ${ocupadaPelaChave.dir}` : `a branch ${ocupadaPelaChave.branch}`;
+        throw new Error(`${qual} já existe, e a chave worktree.por_thread pede a worktree da thread: tire-a ou crie com --sem-worktree`);
+    }
     let worktreeCriada = null;
-    // `greenfield`, `merge-branch` e `feature-xl-faseada` exigem worktree isolada: sao os
-    // ciclos que escrevem codigo em paralelo com outras threads.
-    const exigeWorktree = variante ? (0, ciclos_1.definicaoDaVariante)(variante).exigeWorktree : false;
-    if (opcoes.criarWorktree || exigeWorktree) {
+    if (worktreePor) {
         worktreeCriada = criarWorktree(carregado, id, slug, {
             branchExistente: opcoes.branch,
         });
@@ -328,6 +504,8 @@ function criarThreadSerializada(carregado, opcoes) {
         base: thread.base,
         projeto: manifesto.project.name,
         worktree: thread.worktree,
+        // P4 do ensaio da 0.5.0 (D9): quem abriu a thread sem worktree de proposito fica no rastro.
+        ...(opcoes.origemDaWorktree === 'sem-worktree' ? { semWorktree: true } : {}),
         variante,
         branchDeOrigem: opcoes.branch ?? null,
         maquina: thread.maquina,
@@ -338,10 +516,11 @@ function criarThreadSerializada(carregado, opcoes) {
             dir: worktreeCriada.dir,
             branch: worktreeCriada.branch,
             base: manifesto.worktree.base_branch,
+            origem: worktreePor,
             fonte: 'git worktree list --porcelain',
         });
     }
-    return { thread, gravada: true };
+    return { thread, gravada: true, worktreePor };
 }
 /**
  * O bloco de loop que conduz a fase DESTA thread.

package/dist/worktree.js

@@ -64,9 +64,12 @@ 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`. */
+/**
+ * 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) {

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.3",
   "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/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