@orkastery/cli 0.6.0 → 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.0",
+  "version": "0.6.2",
   "configSchema": {
     "type": "object",
     "properties": {},

package/adapters/openclaw/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@orkastery/openclaw-plugin",
-  "version": "0.6.0",
+  "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

@@ -42,7 +42,7 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DAEMON_DO_CLAUDE = exports.PRAZO_DO_DAEMON_MS = exports.JANELA_CURTA_MAX_MS = exports.MOD_DA_ENTREGA = exports.MOD_DOS_TETOS = exports.MINIMO_DA_API_DE_MODS = exports.NOME_ADAPTER = void 0;
+exports.DAEMON_DO_CLAUDE = exports.PRAZO_DO_DAEMON_MS = exports.JANELA_CURTA_MAX_MS = exports.MOD_DA_ENTREGA = exports.MOD_DOS_TETOS = exports.MINIMO_DA_API_DE_MODS = exports.MUTACOES_WORKTREE = exports.CONSULTAS_MCP = exports.NOME_ADAPTER = void 0;
 exports.ambienteDoPerfil = ambienteDoPerfil;
 exports.semContextoDeDespacho = semContextoDeDespacho;
 exports.disponivel = disponivel;
@@ -103,19 +103,21 @@ function semContextoDeDespacho(base, contexto) {
         delete env[chave];
     return env;
 }
-/** Consultas do perfil interactive; gates e respostas humanas nunca recebem grant. */
-const CONSULTAS_MCP = [
+/** Consultas do perfil interactive; gates e respostas humanas nunca recebem grant. RM-067 (F4b): o grok usa as mesmas. */
+exports.CONSULTAS_MCP = [
     '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',
 ];
 // RM-037 (defeito 1): a decisao autonoma pelo MCP tem o mesmo grant nos dois runtimes.
-const MUTACOES_WORKTREE = [
+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.
@@ -133,7 +135,7 @@ function permissoesDaWorktree(cwd, permiteEditarProduto, consultas) {
         for (const prefixo of [`${absoluto}/${nome}`, `${absoluto}/**/${nome}`])
             deny.push(`Edit(${prefixo})`, `Edit(${prefixo}/**)`);
     }
-    return { allow: [...consultas, 'mcp__orkastery__ork_git_status', ...MUTACOES_WORKTREE, ...(permiteEditarProduto ? [`Edit(${absoluto}/**)`] : [])], deny };
+    return { allow: [...consultas, 'mcp__orkastery__ork_git_status', ...exports.MUTACOES_WORKTREE, ...(permiteEditarProduto ? [`Edit(${absoluto}/**)`] : [])], deny };
 }
 /** O runtime esta disponivel nesta maquina? */
 function disponivel() {
@@ -246,7 +248,7 @@ function montarComando(pedido) {
         args.push('--settings', JSON.stringify({ env: doDespacho, ...(teams ? { teammateMode: teams.teammateMode } : {}), ...(entrada ?? {}) }));
     }
     if (contexto) {
-        const consultas = [...CONSULTAS_MCP, ...(contexto.grafoMcp ? consultasDoGrafoMcp() : [])];
+        const consultas = [...exports.CONSULTAS_MCP, ...(contexto.grafoMcp ? consultasDoGrafoMcp() : [])];
         // Somente o servidor gerado: nao mesclar MCP de outros escopos nesta sessao filha.
         const permissoes = contexto.permissoesFilho === 'worktree'
             ? permissoesDaWorktree(pedido.cwd, contexto.permiteEditarProduto && !plano, consultas) : null;

package/dist/adapters/grok-events.js

@@ -0,0 +1,227 @@
+"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.ParserGrok = exports.LIMITE_ERRO_GROK = exports.LIMITE_LINHA_GROK = exports.STOP_CANCELADO = exports.STOP_FIM_NORMAL = void 0;
+exports.redigirTextoGrok = redigirTextoGrok;
+exports.redigirErroGrok = redigirErroGrok;
+exports.tokensDoFim = tokensDoFim;
+exports.falhaDeContaDoTextoGrok = falhaDeContaDoTextoGrok;
+exports.falhaDoErroGrok = falhaDoErroGrok;
+exports.lerStreamGrok = lerStreamGrok;
+/**
+ * RM-067 (F2 da ork-grokbuild, D7): o stream `streaming-json` do Grok Build (`grok -p ... --output-format
+ * streaming-json`), lido por linha.
+ *
+ * Formato do guia `14-headless-mode` do repositório `xai-org/grok-build`, lido em 25/10/2026: NDJSON com `type`. O `end`
+ * é sempre o último evento e traz `stopReason` em snake_case (`end_turn`, `max_tokens`, `max_turn_requests`, `refusal`,
+ * `cancelled`), `sessionId`, `requestId`, `usage`, `num_turns`, `modelUsage` e, só quando o servidor informa o custo
+ * inteiro, `total_cost_usd`; o `error` traz `message`. A lista de tipos não é exaustiva (`max_turns_reached`,
+ * `auto_compact_*`): tipo desconhecido é ignorado. O texto do agente (`text`, `thought`) nunca classifica nada; só o
+ * `end` e o `error`, que o próprio runtime grava, entram no resultado.
+ */
+const fs = __importStar(require("node:fs"));
+const hitl_1 = require("../hitl");
+const claude_bg_1 = require("./claude-bg");
+/** O `stopReason` do fim normal do turno. */
+exports.STOP_FIM_NORMAL = 'end_turn';
+/** O `stopReason` do turno cancelado: interrupção, como a saída 130 e a 143. */
+exports.STOP_CANCELADO = 'cancelled';
+/** Linha maior que isto não é evento: invalida o stream sem reter a memória. */
+exports.LIMITE_LINHA_GROK = 1024 * 1024;
+/** Teto da mensagem de erro do runtime que vai ao ledger. */
+exports.LIMITE_ERRO_GROK = 300;
+const STOP = /^[a-z][a-z0-9_]{0,39}$/;
+const ID = /^[A-Za-z0-9][A-Za-z0-9_.:-]{0,127}$/;
+/**
+ * D7: um texto do runtime pronto para o ledger, sem corte: os segredos que o núcleo já conhece, a chave da xAI
+ * (`xai-...`) e sem controle. GO-FIX 1 (A4): quem corta, corta depois de redigir, para nenhum segredo perder o prefixo.
+ */
+function redigirTextoGrok(texto) {
+    if (typeof texto !== 'string')
+        return '';
+    return (0, hitl_1.redigirSegredos)(texto)
+        .replace(/\bxai-[A-Za-z0-9_-]{16,}/g, '[redigido]')
+        .replace(/\p{Cc}/gu, ' ').replace(/\s+/g, ' ').trim();
+}
+/** D7: a mensagem de erro do runtime, redigida e até `LIMITE_ERRO_GROK` caracteres, sem partir par substituto. */
+function redigirErroGrok(texto) {
+    return Array.from(redigirTextoGrok(texto)).slice(0, exports.LIMITE_ERRO_GROK).join('');
+}
+const tokensIndisponiveis = () => ({ disponivel: false, input: null, cachedInput: null, output: null,
+    total: null, unidade: 'tokens', escopo: 'sessao', fonte: 'unavailable' });
+/** O `usage` do `end`, só com inteiros não negativos e total que cobre entrada e saída; fora disso, indisponível. */
+function tokensDoFim(v) {
+    if (!v || typeof v !== 'object' || Array.isArray(v))
+        return tokensIndisponiveis();
+    const u = v;
+    const inteiro = (n) => Number.isSafeInteger(n) && n >= 0;
+    const input = u.input_tokens, output = u.output_tokens, cache = u.cache_read_input_tokens;
+    if (!inteiro(input) || !inteiro(output) || (cache !== undefined && !inteiro(cache)))
+        return tokensIndisponiveis();
+    const total = u.total_tokens === undefined ? input + output : u.total_tokens;
+    if (!inteiro(total) || total < input + output)
+        return tokensIndisponiveis();
+    return { disponivel: true, input, cachedInput: cache === undefined ? null : cache, output, total, unidade: 'tokens',
+        escopo: 'sessao', fonte: 'grok.end.usage' };
+}
+class ParserGrok {
+    pendente = Buffer.alloc(0);
+    descartando = false;
+    estado;
+    /** Eventos válidos lidos por esta instância: o progresso de uma leitura. */
+    eventosValidos = 0;
+    constructor(sessaoEsperada, estado) {
+        if (estado && estado.sessaoEsperada !== sessaoEsperada)
+            throw new Error('estado do parser do grok de outra sessão');
+        this.estado = estado ? structuredClone(estado)
+            : { sessaoEsperada, fim: null, erro: null, invalido: false, sessaoDivergente: false, eventos: 0 };
+    }
+    /** Lê as linhas completas do bloco; o resto fica pendente para o próximo. */
+    push(chunk) {
+        const dados = typeof chunk === 'string' ? Buffer.from(chunk) : chunk;
+        let inicio = 0;
+        for (let i = 0; i < dados.length; i++) {
+            if (dados[i] !== 10)
+                continue;
+            const linha = Buffer.concat([this.pendente, dados.subarray(inicio, i)]);
+            if (!this.descartando && linha.length <= exports.LIMITE_LINHA_GROK) {
+                if (linha.length) {
+                    try {
+                        this.evento(JSON.parse(new TextDecoder('utf-8', { fatal: true }).decode(linha)));
+                    }
+                    catch {
+                        this.estado.invalido = true;
+                    }
+                }
+            }
+            else
+                this.estado.invalido = true;
+            this.pendente = Buffer.alloc(0);
+            this.descartando = false;
+            inicio = i + 1;
+        }
+        const resto = dados.subarray(inicio);
+        if (this.pendente.length + resto.length > exports.LIMITE_LINHA_GROK) {
+            this.descartando = true;
+            this.estado.invalido = true;
+            this.pendente = Buffer.alloc(0);
+        }
+        else if (!this.descartando)
+            this.pendente = Buffer.concat([this.pendente, resto]);
+    }
+    evento(bruto) {
+        if (!bruto || typeof bruto !== 'object' || Array.isArray(bruto)) {
+            this.estado.invalido = true;
+            return;
+        }
+        const e = bruto;
+        if (typeof e.type !== 'string' || e.type === '') {
+            this.estado.invalido = true;
+            return;
+        }
+        // O guia diz que o `end` é sempre o último: outro `end` ou um `error` depois dele é contrato quebrado.
+        if (this.estado.fim && (e.type === 'end' || e.type === 'error')) {
+            this.estado.invalido = true;
+            return;
+        }
+        this.eventosValidos++;
+        this.estado.eventos++;
+        if (e.type === 'error') {
+            this.estado.erro = { mensagem: redigirErroGrok(e.message) || 'erro do grok sem mensagem' };
+            return;
+        }
+        if (e.type !== 'end')
+            return;
+        const sessionId = typeof e.sessionId === 'string' && ID.test(e.sessionId) ? e.sessionId : null;
+        if (sessionId !== this.estado.sessaoEsperada)
+            this.estado.sessaoDivergente = true;
+        this.estado.fim = {
+            stopReason: typeof e.stopReason === 'string' && STOP.test(e.stopReason) ? e.stopReason : 'desconhecido',
+            sessionId,
+            requestId: typeof e.requestId === 'string' && ID.test(e.requestId) ? e.requestId : null,
+            numTurnos: Number.isSafeInteger(e.num_turns) && e.num_turns >= 0 ? e.num_turns : null,
+            tokens: tokensDoFim(e.usage),
+            custoUsd: typeof e.total_cost_usd === 'number' && Number.isFinite(e.total_cost_usd) && e.total_cost_usd >= 0
+                ? e.total_cost_usd : null,
+        };
+    }
+}
+exports.ParserGrok = ParserGrok;
+/**
+ * D7 e RM-067 (F3): a falha da CONTA dita por um texto do `grok` (a mensagem do `error` ou o stderr), pelo critério único
+ * da D16 (`parseFalhaDeConta`), sem a cota. O formato do erro de cota esgotada do `grok` não está confirmado (E5 da página
+ * da RM-067): a fonte não diz o campo nem a mensagem. O sinal tipado de cota só pode vir de erro estruturado do runtime, e
+ * uma frase parecida marcaria o perfil e tiraria a conta do rodízio por suposição; até o ensaio real (F5) ler o formato,
+ * nenhum texto do `grok` vira `runtime.quota-exhausted`, e o `grok` fica fora da escada automática e do fallback por
+ * cota. O login e o modelo seguem pela frase, como na F2.
+ */
+function falhaDeContaDoTextoGrok(texto, agoraMs = Date.now()) {
+    const falha = (0, claude_bg_1.parseFalhaDeConta)(texto, agoraMs);
+    return falha?.motivo === 'runtime.quota-exhausted' ? null : falha;
+}
+/**
+ * D7: a falha da CONTA dita pelo próprio runtime no objeto `error` do stream (login, modelo), sem a cota
+ * (`falhaDeContaDoTextoGrok`): o que a frase não tipa fica `null`, e a parada segue tipada como `runtime.unavailable`.
+ */
+function falhaDoErroGrok(erro, agoraMs = Date.now()) {
+    return erro ? falhaDeContaDoTextoGrok(erro.mensagem, agoraMs) : null;
+}
+/**
+ * O stream inteiro de um despacho curto (a falha antes da sessão), lido sem seguir link e até `limiteBytes`; `null`
+ * quando o arquivo não existe, não é arquivo comum ou passa do limite.
+ */
+function lerStreamGrok(arquivo, sessaoEsperada, limiteBytes = 8 * 1024 * 1024) {
+    let fd;
+    try {
+        fd = fs.openSync(arquivo, fs.constants.O_RDONLY | fs.constants.O_NOFOLLOW | fs.constants.O_NONBLOCK);
+    }
+    catch {
+        return null;
+    }
+    try {
+        const st = fs.fstatSync(fd);
+        if (!st.isFile() || st.size > limiteBytes)
+            return null;
+        const bytes = Buffer.alloc(st.size);
+        fs.readSync(fd, bytes, 0, st.size, 0);
+        const parser = new ParserGrok(sessaoEsperada);
+        // A última linha sem quebra também é evento: o processo terminou e não vai completá-la.
+        parser.push(bytes.length && bytes[bytes.length - 1] !== 10 ? Buffer.concat([bytes, Buffer.from('\n')]) : bytes);
+        return parser.estado;
+    }
+    finally {
+        fs.closeSync(fd);
+    }
+}