@orkastery/cli 0.6.1 → 0.6.2

package/adapters/claude-code/agents/ork-check.md

@@ -27,7 +27,7 @@ ork phase list <thread>        # o que ja aconteceu, com evidencia
 
 - O modo de conducao afrouxa a PAUSA, nunca a VERIFICACAO.
 - Nada de self-report: toda alegacao vem com o comando que a comprova e a saida real.
-- Esperas: nunca dispare verify, build ou suite com `&` dentro do comando, porque o processo se perde e a sessao espera um aviso que nunca vem; rode o `ork verify` em primeiro plano, com `timeout` (ele espera a vez na fila de recursos pesados), ou use a execucao em segundo plano do host, que avisa quando termina; nunca espere com `pgrep -f` cujo padrao aparece no proprio comando, porque o laco acha a si mesmo e nao termina: espere pelo arquivo de saida com prazo, ou pelo PID guardado.
+- Esperas: nunca dispare verify, build ou suite com `&` dentro do comando, porque o processo se perde e a sessao espera um aviso que nunca vem; prefira `ork_verify` assíncrono e consulte `ork_verify_status` a cada 30–60 s; sem essa ferramenta, rode o `ork verify` em primeiro plano, com `timeout` (ele espera a vez na fila de recursos pesados), ou use a execucao em segundo plano do host, que avisa quando termina; nunca espere com `pgrep -f` cujo padrao aparece no proprio comando, porque o laco acha a si mesmo e nao termina: espere pelo arquivo de saida com prazo, ou pelo PID guardado.
 - Passo irreversivel (push, merge, delecao) so acontece quando o modo autoriza, e a autorizacao
   fica registrada no ledger.
 - Termine dizendo, em uma linha, em que ponto a thread esta e o que acontece agora.

package/adapters/claude-code/agents/ork-go.md

@@ -27,7 +27,7 @@ ork phase list <thread>        # o que ja aconteceu, com evidencia
 
 - O modo de conducao afrouxa a PAUSA, nunca a VERIFICACAO.
 - Nada de self-report: toda alegacao vem com o comando que a comprova e a saida real.
-- Esperas: nunca dispare verify, build ou suite com `&` dentro do comando, porque o processo se perde e a sessao espera um aviso que nunca vem; rode o `ork verify` em primeiro plano, com `timeout` (ele espera a vez na fila de recursos pesados), ou use a execucao em segundo plano do host, que avisa quando termina; nunca espere com `pgrep -f` cujo padrao aparece no proprio comando, porque o laco acha a si mesmo e nao termina: espere pelo arquivo de saida com prazo, ou pelo PID guardado.
+- Esperas: nunca dispare verify, build ou suite com `&` dentro do comando, porque o processo se perde e a sessao espera um aviso que nunca vem; prefira `ork_verify` assíncrono e consulte `ork_verify_status` a cada 30–60 s; sem essa ferramenta, rode o `ork verify` em primeiro plano, com `timeout` (ele espera a vez na fila de recursos pesados), ou use a execucao em segundo plano do host, que avisa quando termina; nunca espere com `pgrep -f` cujo padrao aparece no proprio comando, porque o laco acha a si mesmo e nao termina: espere pelo arquivo de saida com prazo, ou pelo PID guardado.
 - Passo irreversivel (push, merge, delecao) so acontece quando o modo autoriza, e a autorizacao
   fica registrada no ledger.
 - Termine dizendo, em uma linha, em que ponto a thread esta e o que acontece agora.

package/adapters/claude-code/agents/ork-goal.md

@@ -28,7 +28,7 @@ ork phase list <thread>        # o que ja aconteceu, com evidencia
 
 - O modo de conducao afrouxa a PAUSA, nunca a VERIFICACAO.
 - Nada de self-report: toda alegacao vem com o comando que a comprova e a saida real.
-- Esperas: nunca dispare verify, build ou suite com `&` dentro do comando, porque o processo se perde e a sessao espera um aviso que nunca vem; rode o `ork verify` em primeiro plano, com `timeout` (ele espera a vez na fila de recursos pesados), ou use a execucao em segundo plano do host, que avisa quando termina; nunca espere com `pgrep -f` cujo padrao aparece no proprio comando, porque o laco acha a si mesmo e nao termina: espere pelo arquivo de saida com prazo, ou pelo PID guardado.
+- Esperas: nunca dispare verify, build ou suite com `&` dentro do comando, porque o processo se perde e a sessao espera um aviso que nunca vem; prefira `ork_verify` assíncrono e consulte `ork_verify_status` a cada 30–60 s; sem essa ferramenta, rode o `ork verify` em primeiro plano, com `timeout` (ele espera a vez na fila de recursos pesados), ou use a execucao em segundo plano do host, que avisa quando termina; nunca espere com `pgrep -f` cujo padrao aparece no proprio comando, porque o laco acha a si mesmo e nao termina: espere pelo arquivo de saida com prazo, ou pelo PID guardado.
 - Passo irreversivel (push, merge, delecao) so acontece quando o modo autoriza, e a autorizacao
   fica registrada no ledger.
 - Termine dizendo, em uma linha, em que ponto a thread esta e o que acontece agora.

package/adapters/claude-code/agents/ork-master.md

@@ -29,7 +29,7 @@ ork phase list <thread>        # o que ja aconteceu, com evidencia
 
 - O modo de conducao afrouxa a PAUSA, nunca a VERIFICACAO.
 - Nada de self-report: toda alegacao vem com o comando que a comprova e a saida real.
-- Esperas: nunca dispare verify, build ou suite com `&` dentro do comando, porque o processo se perde e a sessao espera um aviso que nunca vem; rode o `ork verify` em primeiro plano, com `timeout` (ele espera a vez na fila de recursos pesados), ou use a execucao em segundo plano do host, que avisa quando termina; nunca espere com `pgrep -f` cujo padrao aparece no proprio comando, porque o laco acha a si mesmo e nao termina: espere pelo arquivo de saida com prazo, ou pelo PID guardado.
+- Esperas: nunca dispare verify, build ou suite com `&` dentro do comando, porque o processo se perde e a sessao espera um aviso que nunca vem; prefira `ork_verify` assíncrono e consulte `ork_verify_status` a cada 30–60 s; sem essa ferramenta, rode o `ork verify` em primeiro plano, com `timeout` (ele espera a vez na fila de recursos pesados), ou use a execucao em segundo plano do host, que avisa quando termina; nunca espere com `pgrep -f` cujo padrao aparece no proprio comando, porque o laco acha a si mesmo e nao termina: espere pelo arquivo de saida com prazo, ou pelo PID guardado.
 - Passo irreversivel (push, merge, delecao) so acontece quando o modo autoriza, e a autorizacao
   fica registrada no ledger.
 - Termine dizendo, em uma linha, em que ponto a thread esta e o que acontece agora.

package/adapters/claude-code/agents/ork-plan.md

@@ -27,7 +27,7 @@ ork phase list <thread>        # o que ja aconteceu, com evidencia
 
 - O modo de conducao afrouxa a PAUSA, nunca a VERIFICACAO.
 - Nada de self-report: toda alegacao vem com o comando que a comprova e a saida real.
-- Esperas: nunca dispare verify, build ou suite com `&` dentro do comando, porque o processo se perde e a sessao espera um aviso que nunca vem; rode o `ork verify` em primeiro plano, com `timeout` (ele espera a vez na fila de recursos pesados), ou use a execucao em segundo plano do host, que avisa quando termina; nunca espere com `pgrep -f` cujo padrao aparece no proprio comando, porque o laco acha a si mesmo e nao termina: espere pelo arquivo de saida com prazo, ou pelo PID guardado.
+- Esperas: nunca dispare verify, build ou suite com `&` dentro do comando, porque o processo se perde e a sessao espera um aviso que nunca vem; prefira `ork_verify` assíncrono e consulte `ork_verify_status` a cada 30–60 s; sem essa ferramenta, rode o `ork verify` em primeiro plano, com `timeout` (ele espera a vez na fila de recursos pesados), ou use a execucao em segundo plano do host, que avisa quando termina; nunca espere com `pgrep -f` cujo padrao aparece no proprio comando, porque o laco acha a si mesmo e nao termina: espere pelo arquivo de saida com prazo, ou pelo PID guardado.
 - Passo irreversivel (push, merge, delecao) so acontece quando o modo autoriza, e a autorizacao
   fica registrada no ledger.
 - Termine dizendo, em uma linha, em que ponto a thread esta e o que acontece agora.

package/adapters/claude-code/agents/ork-ship.md

@@ -27,7 +27,7 @@ ork phase list <thread>        # o que ja aconteceu, com evidencia
 
 - O modo de conducao afrouxa a PAUSA, nunca a VERIFICACAO.
 - Nada de self-report: toda alegacao vem com o comando que a comprova e a saida real.
-- Esperas: nunca dispare verify, build ou suite com `&` dentro do comando, porque o processo se perde e a sessao espera um aviso que nunca vem; rode o `ork verify` em primeiro plano, com `timeout` (ele espera a vez na fila de recursos pesados), ou use a execucao em segundo plano do host, que avisa quando termina; nunca espere com `pgrep -f` cujo padrao aparece no proprio comando, porque o laco acha a si mesmo e nao termina: espere pelo arquivo de saida com prazo, ou pelo PID guardado.
+- Esperas: nunca dispare verify, build ou suite com `&` dentro do comando, porque o processo se perde e a sessao espera um aviso que nunca vem; prefira `ork_verify` assíncrono e consulte `ork_verify_status` a cada 30–60 s; sem essa ferramenta, rode o `ork verify` em primeiro plano, com `timeout` (ele espera a vez na fila de recursos pesados), ou use a execucao em segundo plano do host, que avisa quando termina; nunca espere com `pgrep -f` cujo padrao aparece no proprio comando, porque o laco acha a si mesmo e nao termina: espere pelo arquivo de saida com prazo, ou pelo PID guardado.
 - Passo irreversivel (push, merge, delecao) so acontece quando o modo autoriza, e a autorizacao
   fica registrada no ledger.
 - Termine dizendo, em uma linha, em que ponto a thread esta e o que acontece agora.

package/adapters/claude-code/commands/ork.md

@@ -1,7 +1,7 @@
 ---
 description: Reconhece orkastery maestro e conduz pedidos, retomadas e status na conversa com o Maestro/Builder.
 argument-hint: "[pedido em linguagem natural|thread|status|board|plan|doctor|modos]"
-allowed-tools: Bash(ork:*), Read, mcp__orkastery__ork_thread_status, mcp__orkastery__ork_phase_list, mcp__orkastery__ork_hitl_pending, mcp__orkastery__ork_observe, mcp__orkastery__ork_artifact_read, mcp__orkastery__ork_claims_list, mcp__orkastery__ork_git_status, mcp__orkastery__ork_thread_new, mcp__orkastery__ork_phase_run, mcp__orkastery__ork_preflight
+allowed-tools: Bash(ork:*), Read, mcp__orkastery__ork_thread_status, mcp__orkastery__ork_phase_list, mcp__orkastery__ork_hitl_pending, mcp__orkastery__ork_observe, mcp__orkastery__ork_artifact_read, mcp__orkastery__ork_claims_list, mcp__orkastery__ork_verify_status, mcp__orkastery__ork_git_status, mcp__orkastery__ork_thread_new, mcp__orkastery__ork_phase_run, mcp__orkastery__ork_preflight
 ---
 
 # /orkastery:ork

package/adapters/claude-code/mods/ork-torre/hooks/frases.ts

@@ -7,6 +7,8 @@ export const FRASE_DO_MOTIVO: Readonly<Record<string, string>> = {
   'artifact.missing': 'falta um artefato que a fase exige',
   'claims.failed': 'uma claim reprovou no HEAD',
   'claims.unverifiable': 'há claim sem comando de verificação',
+  'concurrency.lease-indeterminado': 'não foi possível provar se a vaga está livre',
+  'conducao.acao-necessaria': 'a condução precisa executar uma ação',
   'policy.violation': 'uma policy de bloqueio foi violada',
   'runtime.autoconferencia': 'o CHECK caiu no mesmo runtime do GO',
   'verify.regression': 'um teste que passava na baseline caiu',

package/adapters/codex/skills/ork/SKILL.md

@@ -44,7 +44,7 @@ O dono conversa sobre o objetivo; voce opera o nucleo `ork` e apresenta o result
 passo. Preserve o modo e as autorizacoes da thread. Se ja recebeu uma fase do Orkastery,
 execute essa fase no escopo recebido, sem redespachar a si mesmo.
 
-- Esperas: nunca dispare verify, build ou suite com `&` dentro do comando, porque o processo se perde e a sessao espera um aviso que nunca vem; rode o `ork verify` em primeiro plano, com `timeout` (ele espera a vez na fila de recursos pesados), ou use a execucao em segundo plano do host, que avisa quando termina; nunca espere com `pgrep -f` cujo padrao aparece no proprio comando, porque o laco acha a si mesmo e nao termina: espere pelo arquivo de saida com prazo, ou pelo PID guardado.
+- Esperas: nunca dispare verify, build ou suite com `&` dentro do comando, porque o processo se perde e a sessao espera um aviso que nunca vem; prefira `ork_verify` assíncrono e consulte `ork_verify_status` a cada 30–60 s; sem essa ferramenta, rode o `ork verify` em primeiro plano, com `timeout` (ele espera a vez na fila de recursos pesados), ou use a execucao em segundo plano do host, que avisa quando termina; nunca espere com `pgrep -f` cujo padrao aparece no proprio comando, porque o laco acha a si mesmo e nao termina: espere pelo arquivo de saida com prazo, ou pelo PID guardado.
 
 Quando descobertas, prefira as ferramentas MCP vinculadas ao projeto pelo servidor:
 `ork_thread_status`, `ork_phase_list`, `ork_hitl_pending`, `ork_thread_new(nome, modo)`,

package/adapters/openclaw/openclaw.plugin.json

@@ -2,7 +2,7 @@
   "id": "orkastery",
   "name": "Orkastery",
   "description": "Conducao de looping threads em 6 fases pelo nucleo `ork`, exposta ao OpenClaw como tools `ork_*`. Zero regra de negocio no host: cada tool e uma chamada de CLI. Toda tool de projeto aceita projeto (nome do projeto pedido); o cwd do gateway nunca escolhe o projeto. O status do roadmap vem de ork_network_roadmap; as maquinas da pessoa, de ork_network_status (sem projeto).",
-  "version": "0.6.1",
+  "version": "0.6.2",
   "configSchema": {
     "type": "object",
     "properties": {},

package/adapters/openclaw/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@orkastery/openclaw-plugin",
-  "version": "0.6.1",
+  "version": "0.6.2",
   "description": "Plugin Orkastery para OpenClaw: 32 tools ork_* que traduzem intencao em chamada de CLI do nucleo `ork`. Zero regra de negocio no host.",
   "type": "module",
   "private": true,

package/assets/adapters-en/claude-code/agents/ork-check.md

@@ -27,7 +27,7 @@ ork phase list <thread>        # o que ja aconteceu, com evidencia
 
 - The conduction mode loosens the PAUSE, never the VERIFICATION.
 - No self-report: every statement comes with the command that proves it and the real output.
-- Waits: never start verify, build or the suite with `&` inside the command, because the process gets lost and the session waits for a notice that never comes; run `ork verify` in the foreground, with `timeout` (it waits its turn in the heavy-resource queue), or use the host's background execution, which tells you when it finishes; never wait with `pgrep -f` whose pattern shows up in the command itself, because the loop finds itself and never ends: wait for the output file with a deadline, or for the saved PID.
+- Waits: never start verify, build or the suite with `&` inside the command, because the process gets lost and the session waits for a notice that never comes; prefer asynchronous `ork_verify` and query `ork_verify_status` every 30–60 s; without it, run `ork verify` in the foreground, with `timeout` (it waits its turn in the heavy-resource queue), or use the host's background execution, which tells you when it finishes; never wait with `pgrep -f` whose pattern shows up in the command itself, because the loop finds itself and never ends: wait for the output file with a deadline, or for the saved PID.
 - An irreversible step (push, merge, deletion) only happens when the mode authorizes it, and the authorization
   is recorded in the ledger.
 - End by saying, in one line, where the thread stands and what happens now.

package/assets/adapters-en/claude-code/agents/ork-go.md

@@ -27,7 +27,7 @@ ork phase list <thread>        # o que ja aconteceu, com evidencia
 
 - The conduction mode loosens the PAUSE, never the VERIFICATION.
 - No self-report: every statement comes with the command that proves it and the real output.
-- Waits: never start verify, build or the suite with `&` inside the command, because the process gets lost and the session waits for a notice that never comes; run `ork verify` in the foreground, with `timeout` (it waits its turn in the heavy-resource queue), or use the host's background execution, which tells you when it finishes; never wait with `pgrep -f` whose pattern shows up in the command itself, because the loop finds itself and never ends: wait for the output file with a deadline, or for the saved PID.
+- Waits: never start verify, build or the suite with `&` inside the command, because the process gets lost and the session waits for a notice that never comes; prefer asynchronous `ork_verify` and query `ork_verify_status` every 30–60 s; without it, run `ork verify` in the foreground, with `timeout` (it waits its turn in the heavy-resource queue), or use the host's background execution, which tells you when it finishes; never wait with `pgrep -f` whose pattern shows up in the command itself, because the loop finds itself and never ends: wait for the output file with a deadline, or for the saved PID.
 - An irreversible step (push, merge, deletion) only happens when the mode authorizes it, and the authorization
   is recorded in the ledger.
 - End by saying, in one line, where the thread stands and what happens now.

package/assets/adapters-en/claude-code/agents/ork-goal.md

@@ -28,7 +28,7 @@ ork phase list <thread>        # o que ja aconteceu, com evidencia
 
 - The conduction mode loosens the PAUSE, never the VERIFICATION.
 - No self-report: every statement comes with the command that proves it and the real output.
-- Waits: never start verify, build or the suite with `&` inside the command, because the process gets lost and the session waits for a notice that never comes; run `ork verify` in the foreground, with `timeout` (it waits its turn in the heavy-resource queue), or use the host's background execution, which tells you when it finishes; never wait with `pgrep -f` whose pattern shows up in the command itself, because the loop finds itself and never ends: wait for the output file with a deadline, or for the saved PID.
+- Waits: never start verify, build or the suite with `&` inside the command, because the process gets lost and the session waits for a notice that never comes; prefer asynchronous `ork_verify` and query `ork_verify_status` every 30–60 s; without it, run `ork verify` in the foreground, with `timeout` (it waits its turn in the heavy-resource queue), or use the host's background execution, which tells you when it finishes; never wait with `pgrep -f` whose pattern shows up in the command itself, because the loop finds itself and never ends: wait for the output file with a deadline, or for the saved PID.
 - An irreversible step (push, merge, deletion) only happens when the mode authorizes it, and the authorization
   is recorded in the ledger.
 - End by saying, in one line, where the thread stands and what happens now.

package/assets/adapters-en/claude-code/agents/ork-master.md

@@ -29,7 +29,7 @@ ork phase list <thread>        # o que ja aconteceu, com evidencia
 
 - The conduction mode loosens the PAUSE, never the VERIFICATION.
 - No self-report: every statement comes with the command that proves it and the real output.
-- Waits: never start verify, build or the suite with `&` inside the command, because the process gets lost and the session waits for a notice that never comes; run `ork verify` in the foreground, with `timeout` (it waits its turn in the heavy-resource queue), or use the host's background execution, which tells you when it finishes; never wait with `pgrep -f` whose pattern shows up in the command itself, because the loop finds itself and never ends: wait for the output file with a deadline, or for the saved PID.
+- Waits: never start verify, build or the suite with `&` inside the command, because the process gets lost and the session waits for a notice that never comes; prefer asynchronous `ork_verify` and query `ork_verify_status` every 30–60 s; without it, run `ork verify` in the foreground, with `timeout` (it waits its turn in the heavy-resource queue), or use the host's background execution, which tells you when it finishes; never wait with `pgrep -f` whose pattern shows up in the command itself, because the loop finds itself and never ends: wait for the output file with a deadline, or for the saved PID.
 - An irreversible step (push, merge, deletion) only happens when the mode authorizes it, and the authorization
   is recorded in the ledger.
 - End by saying, in one line, where the thread stands and what happens now.

package/assets/adapters-en/claude-code/agents/ork-plan.md

@@ -27,7 +27,7 @@ ork phase list <thread>        # o que ja aconteceu, com evidencia
 
 - The conduction mode loosens the PAUSE, never the VERIFICATION.
 - No self-report: every statement comes with the command that proves it and the real output.
-- Waits: never start verify, build or the suite with `&` inside the command, because the process gets lost and the session waits for a notice that never comes; run `ork verify` in the foreground, with `timeout` (it waits its turn in the heavy-resource queue), or use the host's background execution, which tells you when it finishes; never wait with `pgrep -f` whose pattern shows up in the command itself, because the loop finds itself and never ends: wait for the output file with a deadline, or for the saved PID.
+- Waits: never start verify, build or the suite with `&` inside the command, because the process gets lost and the session waits for a notice that never comes; prefer asynchronous `ork_verify` and query `ork_verify_status` every 30–60 s; without it, run `ork verify` in the foreground, with `timeout` (it waits its turn in the heavy-resource queue), or use the host's background execution, which tells you when it finishes; never wait with `pgrep -f` whose pattern shows up in the command itself, because the loop finds itself and never ends: wait for the output file with a deadline, or for the saved PID.
 - An irreversible step (push, merge, deletion) only happens when the mode authorizes it, and the authorization
   is recorded in the ledger.
 - End by saying, in one line, where the thread stands and what happens now.

package/assets/adapters-en/claude-code/agents/ork-ship.md

@@ -27,7 +27,7 @@ ork phase list <thread>        # o que ja aconteceu, com evidencia
 
 - The conduction mode loosens the PAUSE, never the VERIFICATION.
 - No self-report: every statement comes with the command that proves it and the real output.
-- Waits: never start verify, build or the suite with `&` inside the command, because the process gets lost and the session waits for a notice that never comes; run `ork verify` in the foreground, with `timeout` (it waits its turn in the heavy-resource queue), or use the host's background execution, which tells you when it finishes; never wait with `pgrep -f` whose pattern shows up in the command itself, because the loop finds itself and never ends: wait for the output file with a deadline, or for the saved PID.
+- Waits: never start verify, build or the suite with `&` inside the command, because the process gets lost and the session waits for a notice that never comes; prefer asynchronous `ork_verify` and query `ork_verify_status` every 30–60 s; without it, run `ork verify` in the foreground, with `timeout` (it waits its turn in the heavy-resource queue), or use the host's background execution, which tells you when it finishes; never wait with `pgrep -f` whose pattern shows up in the command itself, because the loop finds itself and never ends: wait for the output file with a deadline, or for the saved PID.
 - An irreversible step (push, merge, deletion) only happens when the mode authorizes it, and the authorization
   is recorded in the ledger.
 - End by saying, in one line, where the thread stands and what happens now.

package/assets/adapters-en/claude-code/commands/ork.md

@@ -1,7 +1,7 @@
 ---
 description: Recognizes orkastery maestro and conducts requests, resumptions and status in the conversation with the Maestro/Builder.
 argument-hint: "[natural-language request|thread|status|board|plan|doctor|modos]"
-allowed-tools: Bash(ork:*), Read, mcp__orkastery__ork_thread_status, mcp__orkastery__ork_phase_list, mcp__orkastery__ork_hitl_pending, mcp__orkastery__ork_observe, mcp__orkastery__ork_artifact_read, mcp__orkastery__ork_claims_list, mcp__orkastery__ork_git_status, mcp__orkastery__ork_thread_new, mcp__orkastery__ork_phase_run, mcp__orkastery__ork_preflight
+allowed-tools: Bash(ork:*), Read, mcp__orkastery__ork_thread_status, mcp__orkastery__ork_phase_list, mcp__orkastery__ork_hitl_pending, mcp__orkastery__ork_observe, mcp__orkastery__ork_artifact_read, mcp__orkastery__ork_claims_list, mcp__orkastery__ork_verify_status, mcp__orkastery__ork_git_status, mcp__orkastery__ork_thread_new, mcp__orkastery__ork_phase_run, mcp__orkastery__ork_preflight
 ---
 
 # /orkastery:ork

package/assets/adapters-en/codex/skills/ork/SKILL.md

@@ -44,7 +44,7 @@ The owner talks about the goal; you operate the `ork` core and present the resul
 step. Preserve the thread's mode and authorizations. If you already received an Orkastery phase,
 run that phase within the received scope, without redispatching yourself.
 
-- Waits: never start verify, build or the suite with `&` inside the command, because the process gets lost and the session waits for a notice that never comes; run `ork verify` in the foreground, with `timeout` (it waits its turn in the heavy-resource queue), or use the host's background execution, which tells you when it finishes; never wait with `pgrep -f` whose pattern shows up in the command itself, because the loop finds itself and never ends: wait for the output file with a deadline, or for the saved PID.
+- Waits: never start verify, build or the suite with `&` inside the command, because the process gets lost and the session waits for a notice that never comes; prefer asynchronous `ork_verify` and query `ork_verify_status` every 30–60 s; without it, run `ork verify` in the foreground, with `timeout` (it waits its turn in the heavy-resource queue), or use the host's background execution, which tells you when it finishes; never wait with `pgrep -f` whose pattern shows up in the command itself, because the loop finds itself and never ends: wait for the output file with a deadline, or for the saved PID.
 
 When discovered, prefer the MCP tools bound to the project by the server:
 `ork_thread_status`, `ork_phase_list`, `ork_hitl_pending`, `ork_thread_new(nome, modo)`,

package/assets/orkmind_fixture.py

@@ -4,6 +4,7 @@ import os
 from pathlib import Path
 import re
 import stat
+import tempfile
 import time
 
 
@@ -11,8 +12,10 @@ def receipt_file(filename):
     try:
         path = Path(filename)
         root = path.parent
+        temp_root = Path(tempfile.gettempdir()).resolve()
         if (not path.is_absolute() or not re.fullmatch(r'receipt(?:-[a-f0-9]+)?\.json', path.name)
-                or not re.fullmatch(r'/tmp/ork-prospective-fixture-[a-zA-Z0-9-]+', str(root))
+                or root.parent != temp_root
+                or not re.fullmatch(r'ork-prospective-fixture-[a-zA-Z0-9-]+', root.name)
                 or root.resolve() != root or root.is_symlink()):
             raise ValueError()
         st = root.stat()

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

@@ -21,7 +21,7 @@ Distinguish the context before acting:
 - **Conductor session:** receives the owner's request, identifies or opens the thread, dispatches through `ork` and tracks the result; never writes product code in place of the dispatched session.
 - **Already dispatched phase session:** has received the thread, phase, prompt and worktree from `ork`.
   Work within that scope through the phase skill. Do not open another thread or redispatch your own phase to do the work already assigned to you.
-  - Waits: never start verify, build or the suite with `&` inside the command, because the process gets lost and the session waits for a notice that never comes; run `ork verify` in the foreground, with `timeout` (it waits its turn in the heavy-resource queue), or use the host's background execution, which tells you when it finishes; never wait with `pgrep -f` whose pattern shows up in the command itself, because the loop finds itself and never ends: wait for the output file with a deadline, or for the saved PID.
+  - Waits: never start verify, build or the suite with `&` inside the command, because the process gets lost and the session waits for a notice that never comes; prefer asynchronous `ork_verify` and query `ork_verify_status` every 30–60 s; without it, run `ork verify` in the foreground, with `timeout` (it waits its turn in the heavy-resource queue), or use the host's background execution, which tells you when it finishes; never wait with `pgrep -f` whose pattern shows up in the command itself, because the loop finds itself and never ends: wait for the output file with a deadline, or for the saved PID.
 
 ## Start or resume
 

package/assets/skills-en/phases/check-quality/SKILL.md

@@ -23,7 +23,7 @@ ork worktree audit <thread>          # a worktree confere no proprio git
 ork gate request <thread>            # o pedido da pausa; o humano responde pelo canal autenticado
 ```
 
-- Waits: never start verify, build or the suite with `&` inside the command, because the process gets lost and the session waits for a notice that never comes; run `ork verify` in the foreground, with `timeout` (it waits its turn in the heavy-resource queue), or use the host's background execution, which tells you when it finishes; never wait with `pgrep -f` whose pattern shows up in the command itself, because the loop finds itself and never ends: wait for the output file with a deadline, or for the saved PID.
+- Waits: never start verify, build or the suite with `&` inside the command, because the process gets lost and the session waits for a notice that never comes; prefer asynchronous `ork_verify` and query `ork_verify_status` every 30–60 s; without it, run `ork verify` in the foreground, with `timeout` (it waits its turn in the heavy-resource queue), or use the host's background execution, which tells you when it finishes; never wait with `pgrep -f` whose pattern shows up in the command itself, because the loop finds itself and never ends: wait for the output file with a deadline, or for the saved PID.
 
 When the verdict is PRECISA DE MUDANCA, the GO-FIX / CHECK-REVERIFY sub-loop of block B3 is
 what conducts the way back, and it does not depend on a human until the final verdict:

package/assets/skills-en/phases/go-implementation/SKILL.md

@@ -24,7 +24,7 @@ ork claims add <thread> <arquivo> --claim "<...>" --verificar "<comando>" --fase
 ork verify <thread>                           # reexecuta no HEAD real
 ```
 
-- Waits: never start verify, build or the suite with `&` inside the command, because the process gets lost and the session waits for a notice that never comes; run `ork verify` in the foreground, with `timeout` (it waits its turn in the heavy-resource queue), or use the host's background execution, which tells you when it finishes; never wait with `pgrep -f` whose pattern shows up in the command itself, because the loop finds itself and never ends: wait for the output file with a deadline, or for the saved PID.
+- Waits: never start verify, build or the suite with `&` inside the command, because the process gets lost and the session waits for a notice that never comes; prefer asynchronous `ork_verify` and query `ork_verify_status` every 30–60 s; without it, run `ork verify` in the foreground, with `timeout` (it waits its turn in the heavy-resource queue), or use the host's background execution, which tells you when it finishes; never wait with `pgrep -f` whose pattern shows up in the command itself, because the loop finds itself and never ends: wait for the output file with a deadline, or for the saved PID.
 
 ## What GO delivers
 

package/dist/adapters/claude-bg.js

@@ -111,11 +111,13 @@ exports.CONSULTAS_MCP = [
     'mcp__orkastery__ork_observe',
     'mcp__orkastery__ork_artifact_read',
     'mcp__orkastery__ork_claims_list',
+    'mcp__orkastery__ork_verify_status',
 ];
 // RM-037 (defeito 1): a decisao autonoma pelo MCP tem o mesmo grant nos dois runtimes.
 exports.MUTACOES_WORKTREE = [
     'mcp__orkastery__ork_artifact_write', 'mcp__orkastery__ork_claim_add', 'mcp__orkastery__ork_decision_record',
-    'mcp__orkastery__ork_git_commit', 'mcp__orkastery__ork_verify', 'mcp__orkastery__ork_ship',
+    'mcp__orkastery__ork_request_conduction', 'mcp__orkastery__ork_git_commit', 'mcp__orkastery__ork_verify',
+    'mcp__orkastery__ork_ship',
 ];
 /**
  * RM-031 KG5 (D7): as consultas do grafo, de leitura, so com a flag do manifesto da raiz; sem ela, nada muda.

package/dist/adapters/grok-mcp-servidor.js

@@ -37,6 +37,7 @@ exports.LIMITE_DE_RECUSAS_NO_LOG = exports.INTERVALO_DA_VIGIA_MS = exports.PRAZO
 exports.validarPedidoServidorGrok = validarPedidoServidorGrok;
 exports.recusaDaRequisicao = recusaDaRequisicao;
 exports.conferirArvore = conferirArvore;
+exports.motivoDeEncerramentoDoGrok = motivoDeEncerramentoDoGrok;
 exports.servirGrok = servirGrok;
 /**
  * RM-067 (F4c, thread ork-rm067f4cmcpd): o servidor MCP do `ork` da sessão filha do `grok`, num processo do `ork`, fora do
@@ -311,6 +312,21 @@ function lerCorpo(req, limite) {
 function existe(arquivo) {
     return fs.lstatSync(arquivo, { throwIfNoEntry: false }) !== undefined;
 }
+/**
+ * O evento terminal que a vigia ja pode afirmar. O recibo do `close` sempre vence; a ausencia do filho so e terminal
+ * depois que o supervisor tambem saiu, pois ele grava esse recibo entre os dois acontecimentos.
+ */
+function motivoDeEncerramentoDoGrok(logPath, inicio, prazoDaPartida, agora = Date.now()) {
+    if (existe(`${logPath}.exit.json`))
+        return 'recibo';
+    const processo = (0, grok_mcp_1.lerJsonPequeno)(`${logPath}.process.json`);
+    if (!processo)
+        return agora - inicio > prazoDaPartida ? 'sem-partida' : null;
+    if ((!processo.filho || (0, codex_runner_1.estadoProcesso)(processo.filho) === 'ausente') &&
+        (0, codex_runner_1.estadoProcesso)(processo.supervisor) === 'ausente')
+        return 'grok-ausente';
+    return null;
+}
 /** Roda um passo do fecho sem deixar a exceção dele impedir os seguintes. */
 function semFalhar(passo) {
     try {
@@ -554,18 +570,12 @@ async function servirGrok(pedido, token) {
         terminar();
     };
     const vigiar = () => {
-        if (existe(`${pedido.logPath}.exit.json`)) {
-            fechar('recibo');
-            return;
-        }
-        const processo = (0, grok_mcp_1.lerJsonPequeno)(`${pedido.logPath}.process.json`);
-        if (!processo) {
-            if (Date.now() - inicio > prazoDaPartida)
-                fechar('sem-partida');
-            return;
-        }
-        if (!processo.filho || (0, codex_runner_1.estadoProcesso)(processo.filho) === 'ausente')
-            fechar('grok-ausente');
+        // O `close` real do filho ocorre depois que ele ja aparece ausente e, dentro dele, o supervisor grava o recibo
+        // atomicamente antes de sair. Enquanto o supervisor vive, a ausencia do filho e so essa janela: o evento certo ainda
+        // e o recibo. `grok-ausente` fica para a queda do supervisor sem recibo, comprovada pela ausencia dos dois processos.
+        const motivo = motivoDeEncerramentoDoGrok(pedido.logPath, inicio, prazoDaPartida);
+        if (motivo)
+            fechar(motivo);
     };
     const vigia = setInterval(vigiar, exports.INTERVALO_DA_VIGIA_MS);
     return { porta, url, fechar, fechado };

package/dist/adapters/grok.js

@@ -132,7 +132,7 @@ const PREFIXO_DO_CLAUDE = 'mcp__orkastery__';
 /**
  * RM-067 (F4b, G2 e D1): as ferramentas do MCP do `ork` que um despacho do `grok` libera, as mesmas do `--allowedTools` do
  * `claude-bg` no mesmo caso, sem o prefixo: no PLAN que fecha o bloco, as consultas, `ork_artifact_write` e
- * `ork_decision_record`, em qualquer perfil; fora dele, as consultas e, no perfil `worktree`, `ork_git_status` e as seis
+ * `ork_decision_record`, em qualquer perfil; fora dele, as consultas e, no perfil `worktree`, `ork_git_status` e as sete
  * mutações. As consultas do grafo entram com a flag do manifesto da raiz. Montada na chamada, como no `claude-bg`: no
  * ciclo de imports, o valor importado pode ainda não existir quando este módulo carrega.
  */

package/dist/changelog-check.js

@@ -0,0 +1,217 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GRUPOS_NAO_PUBLICADOS = exports.SECAO_NAO_PUBLICADO = exports.CHANGELOG = void 0;
+exports.ehTeste = ehTeste;
+exports.pedeLinha = pedeLinha;
+exports.linhasDaSecao = linhasDaSecao;
+exports.versoes = versoes;
+exports.changelogAplicavel = changelogAplicavel;
+exports.checarChangelog = checarChangelog;
+exports.basePadrao = basePadrao;
+/**
+ * RM-037: regra unica do CHANGELOG para o script do CI, `docs verificar --pr` e `ork verify`.
+ * O diff decide quais linhas a thread acrescentou; o texto do HEAD decide em que secao e grupo
+ * cada linha caiu; uma tag local `v<versao>` prova que a secao ja foi publicada.
+ */
+const node_child_process_1 = require("node:child_process");
+exports.CHANGELOG = 'CHANGELOG.md';
+exports.SECAO_NAO_PUBLICADO = 'Não publicado';
+exports.GRUPOS_NAO_PUBLICADOS = ['Adicionado', 'Alterado', 'Corrigido', 'Segurança'];
+const PASTAS_DE_PRODUTO = ['core/', 'adapters/', 'marketplaces/'];
+const DE_CI = [/^\.github\//, /^\.ork-ci\//, /^core\/scripts\/test-ci\.js$/, /^core\/scripts\/checar-[a-z0-9-]+\.cjs$/];
+const CORRECAO = 'acrescente em "## Não publicado" do CHANGELOG.md uma linha que diga o que muda para quem usa, ' +
+    'sob "### Adicionado", "### Alterado", "### Corrigido" ou "### Segurança" ' +
+    '(PR só de testes ou só de CI fica de fora: docs/guias/contribuir/pull-request.md)';
+function git(raiz, args) {
+    const r = (0, node_child_process_1.spawnSync)('git', args, { cwd: raiz, encoding: 'utf8', maxBuffer: 64 * 1024 * 1024 });
+    return { ok: r.status === 0, saida: r.stdout ?? '' };
+}
+/** Arquivo de teste: pasta `test`, `tests` ou `__tests__`, ou nome `*.test.*`/`*.spec.*`. */
+function ehTeste(arquivo) {
+    const partes = arquivo.split('/');
+    return partes.slice(0, -1).some((p) => p === 'test' || p === 'tests' || p === '__tests__')
+        || /\.(test|spec)\.[A-Za-z0-9]+$/.test(partes[partes.length - 1]);
+}
+/** Arquivo de produto que exige uma entrada no CHANGELOG. */
+function pedeLinha(arquivo) {
+    return PASTAS_DE_PRODUTO.some((p) => arquivo.startsWith(p)) && !ehTeste(arquivo) && !DE_CI.some((re) => re.test(arquivo));
+}
+/** Linhas de texto de `## Não publicado`, mantida para consumidores e testes legados. */
+function linhasDaSecao(texto) {
+    const linhas = texto.replace(/\r\n/g, '\n').split('\n');
+    const inicio = linhas.findIndex((linha) => linha.trim() === `## ${exports.SECAO_NAO_PUBLICADO}`);
+    if (inicio < 0)
+        return null;
+    const corpo = [];
+    for (const linha of linhas.slice(inicio + 1)) {
+        if (/^## /.test(linha))
+            break;
+        if (linha.trim() && !/^#/.test(linha.trim()))
+            corpo.push(linha.trimEnd());
+    }
+    return corpo;
+}
+/** Versoes nos dois formatos historicos do arquivo. */
+function versoes(texto) {
+    return new Set([...texto.replace(/\r\n/g, '\n').matchAll(/^## \[?(\d+\.\d+\.\d+[0-9A-Za-z.+-]*)\]?(?=\s|$)/gm)]
+        .map((m) => m[1]));
+}
+function changelogEm(raiz, ref) {
+    const r = git(raiz, ['show', `${ref}:${exports.CHANGELOG}`]);
+    return r.ok ? r.saida : '';
+}
+/**
+ * A regra protege um histórico publicado. Repositórios ainda sem versão `v*` ou sem
+ * CHANGELOG no HEAD não têm esse contrato para comparar e ficam fora do verificador.
+ */
+function changelogAplicavel(raiz, head = 'HEAD') {
+    const arquivo = git(raiz, ['cat-file', '-e', `${head}:${exports.CHANGELOG}`]);
+    if (!arquivo.ok)
+        return false;
+    const tags = git(raiz, ['tag', '--merged', head, '--list', 'v*']);
+    return tags.ok && tags.saida.split('\n').some((tag) => tag.trim().length > 1);
+}
+/** Linhas acrescentadas no arquivo, com o numero que ocupam no HEAD. */
+function linhasAcrescentadas(raiz, base, head) {
+    const d = git(raiz, ['diff', '--no-color', '--unified=0', '--no-renames', base, head, '--', exports.CHANGELOG]);
+    if (!d.ok)
+        return [];
+    const novas = [];
+    let numero = 0, emTrecho = false;
+    for (const linha of d.saida.replace(/\r\n/g, '\n').split('\n')) {
+        const hunk = /^@@ -\d+(?:,\d+)? \+(\d+)(?:,\d+)? @@/.exec(linha);
+        if (hunk) {
+            numero = Number(hunk[1]);
+            emTrecho = true;
+            continue;
+        }
+        if (!emTrecho || linha.startsWith('\\ No newline'))
+            continue;
+        if (linha.startsWith('+')) {
+            novas.push({ numero, texto: linha.slice(1) });
+            numero++;
+        }
+        else if (!linha.startsWith('-'))
+            numero++;
+    }
+    return novas;
+}
+function contextos(texto) {
+    const porLinha = [{ secao: null, grupo: null, versao: null }];
+    let secao = null, grupo = null, versao = null;
+    for (const linha of texto.replace(/\r\n/g, '\n').split('\n')) {
+        const h2 = /^## (.+?)\s*$/.exec(linha);
+        if (h2) {
+            secao = h2[1];
+            grupo = null;
+            versao = /^\[?(\d+\.\d+\.\d+[0-9A-Za-z.+-]*)\]?(?:\s|$)/.exec(secao)?.[1] ?? null;
+        }
+        else {
+            const h3 = /^### (.+?)\s*$/.exec(linha);
+            if (h3)
+                grupo = h3[1];
+        }
+        porLinha.push({ secao, grupo, versao });
+    }
+    return porLinha;
+}
+function tagPublicada(raiz, versao) {
+    return git(raiz, ['rev-parse', '--verify', '--quiet', `refs/tags/v${versao}^{commit}`]).ok;
+}
+/**
+ * Confere o diff da thread ate `head`.
+ *
+ * A referencia local da branch alvo pode estar atrasada em relacao ao commit que abriu a
+ * worktree. Quando a base carimbada tambem e ancestral do HEAD e vem depois da merge-base,
+ * ela delimita o que a thread de fato acrescentou. Se a branch alvo avancou para alem dela,
+ * a merge-base mais nova continua vencendo.
+ */
+function checarChangelog(raiz, opcoes = {}) {
+    const head = opcoes.head ?? 'HEAD', base = opcoes.base;
+    const indisponivel = (detalhe) => ({ ok: false, motivo: 'changelog.base-indisponivel', detalhe,
+        correcao: 'rode com o histórico completo do git (fetch-depth: 0 no CI) ou passe --base <ref>', arquivos: [], linhas: [] });
+    if (!git(raiz, ['rev-parse', '--verify', '--quiet', `${head}^{commit}`]).ok)
+        return indisponivel(`o head ${head} não existe neste repositório`);
+    if (!changelogAplicavel(raiz, head)) {
+        const temArquivo = git(raiz, ['cat-file', '-e', `${head}:${exports.CHANGELOG}`]).ok;
+        return { ok: true, motivo: null, arquivos: [], linhas: [], detalhe: temArquivo
+                ? 'regra do CHANGELOG não aplicável: o repositório ainda não tem versão publicada em tag v*'
+                : `regra do CHANGELOG não aplicável: ${exports.CHANGELOG} não existe em ${head}` };
+    }
+    if (!base)
+        return indisponivel('nenhuma base para comparar');
+    if (!git(raiz, ['rev-parse', '--verify', '--quiet', `${base}^{commit}`]).ok)
+        return indisponivel(`a base ${base} não existe neste repositório`);
+    const mb = git(raiz, ['merge-base', base, head]);
+    let ancestral = mb.saida.trim();
+    if (!mb.ok || !ancestral)
+        return indisponivel(`${base} e ${head} não têm ancestral comum`);
+    const carimbada = opcoes.baseCarimbada?.trim();
+    if (carimbada
+        && git(raiz, ['rev-parse', '--verify', '--quiet', `${carimbada}^{commit}`]).ok
+        && git(raiz, ['merge-base', '--is-ancestor', carimbada, head]).ok
+        && git(raiz, ['merge-base', '--is-ancestor', ancestral, carimbada]).ok) {
+        ancestral = carimbada;
+    }
+    const mudados = git(raiz, ['diff', '--name-only', '--no-renames', '-z', ancestral, head]);
+    const arquivos = (mudados.ok ? mudados.saida.split('\0') : []).filter(Boolean);
+    const pedem = arquivos.filter(pedeLinha);
+    const antes = changelogEm(raiz, ancestral), depois = changelogEm(raiz, head);
+    const novas = linhasAcrescentadas(raiz, ancestral, head);
+    const porLinha = contextos(depois);
+    // D4: uma entrada correta em Nao publicado nunca esconde uma edicao retrospectiva.
+    for (const linha of novas) {
+        if (!linha.texto.trim())
+            continue;
+        const contexto = porLinha[linha.numero] ?? { secao: null, grupo: null, versao: null };
+        if (contexto.versao && tagPublicada(raiz, contexto.versao)) {
+            return { ok: false, motivo: 'changelog.secao-publicada', arquivos: pedem, linhas: [linha.texto], secao: contexto.secao ?? undefined,
+                detalhe: `a linha nova ${linha.numero} caiu em "## ${contexto.secao}", versão já publicada pela tag v${contexto.versao}`,
+                correcao: `mova a linha para "## ${exports.SECAO_NAO_PUBLICADO}", sob um dos grupos permitidos` };
+        }
+    }
+    const entradasNaoPublicadas = novas.filter((linha) => {
+        const t = linha.texto.trim(), contexto = porLinha[linha.numero];
+        return !!t && !/^#{2,3} /.test(t) && contexto?.secao === exports.SECAO_NAO_PUBLICADO;
+    });
+    for (const linha of entradasNaoPublicadas) {
+        const grupo = porLinha[linha.numero]?.grupo ?? null;
+        if (!grupo)
+            return { ok: false, motivo: 'changelog.grupo-ausente', arquivos: pedem, linhas: [linha.texto], grupo,
+                detalhe: `a linha nova ${linha.numero} de "## ${exports.SECAO_NAO_PUBLICADO}" não está sob um título ###`,
+                correcao: `ponha a linha sob ${exports.GRUPOS_NAO_PUBLICADOS.map((g) => `"### ${g}"`).join(', ')}` };
+        if (!exports.GRUPOS_NAO_PUBLICADOS.includes(grupo)) {
+            return { ok: false, motivo: 'changelog.grupo-invalido', arquivos: pedem, linhas: [linha.texto], grupo,
+                detalhe: `a linha nova ${linha.numero} está sob "### ${grupo}", grupo que não vale em "## ${exports.SECAO_NAO_PUBLICADO}"`,
+                correcao: `use ${exports.GRUPOS_NAO_PUBLICADOS.map((g) => `"### ${g}"`).join(', ')}` };
+        }
+    }
+    if (pedem.length === 0)
+        return { ok: true, motivo: null, arquivos: [], linhas: [],
+            detalhe: arquivos.length === 0 ? `nada a conferir: ${head} não muda nada desde ${base}`
+                : 'nada pede linha: o PR não muda core/, adapters/ nem marketplaces/ fora de teste e de CI' };
+    const versaoNova = [...versoes(depois)].filter((v) => !versoes(antes).has(v));
+    if (versaoNova.length > 0)
+        return { ok: true, motivo: null, arquivos: pedem, linhas: [],
+            detalhe: `versão nova no ${exports.CHANGELOG}: ${versaoNova.join(', ')} (o PR de versão leva as linhas para ela)` };
+    if (linhasDaSecao(depois) === null)
+        return { ok: false, motivo: 'changelog.secao-ausente', arquivos: pedem, linhas: [],
+            detalhe: `o ${exports.CHANGELOG} de ${head} não tem a seção "## ${exports.SECAO_NAO_PUBLICADO}"`,
+            correcao: `abra a seção "## ${exports.SECAO_NAO_PUBLICADO}" no alto do ${exports.CHANGELOG} e acrescente a linha da mudança` };
+    if (entradasNaoPublicadas.length > 0)
+        return { ok: true, motivo: null, arquivos: pedem,
+            linhas: entradasNaoPublicadas.map((linha) => linha.texto),
+            detalhe: `${entradasNaoPublicadas.length} linha(s) nova(s) em "## ${exports.SECAO_NAO_PUBLICADO}" sob grupo permitido` };
+    return { ok: false, motivo: 'changelog.linha-ausente', arquivos: pedem, linhas: [],
+        detalhe: `o PR muda ${pedem.length} arquivo(s) de core/, adapters/ ou marketplaces/ (${pedem.slice(0, 3).join(', ')}${pedem.length > 3 ? ', ...' : ''}) e não acrescenta linha válida em "## ${exports.SECAO_NAO_PUBLICADO}" do ${exports.CHANGELOG}`,
+        correcao: CORRECAO };
+}
+/** Base padrao do CI: alvo do PR, main remota, main local. */
+function basePadrao(raiz, env = process.env) {
+    if (env.GITHUB_BASE_REF)
+        return `origin/${env.GITHUB_BASE_REF}`;
+    for (const ref of ['origin/main', 'main'])
+        if (git(raiz, ['rev-parse', '--verify', '--quiet', `${ref}^{commit}`]).ok)
+            return ref;
+    return null;
+}