@orkastery/cli 0.5.6 → 0.6.0

package/adapters/README.md

@@ -42,7 +42,25 @@ nos perfis `coding` e `messaging` (`toolMetadata`): sem isso, no perfil `coding`
 plugin chega ao modelo. `ork_network_status` espera a RM-053 na `main`. `network-roadmap-hosts.test.ts` prova a rota de cada host e o aceite do incidente de 29/09
 pela extensão do OpenClaw com o `ork` real.
 
+## Paridade do conhecimento escrito
+
+O conhecimento escrito ([RM-026](../docs/roadmap/RM-026-workspace-empresarial.md) K7) chega aos quatro hosts pelas
+mesmas quatro tools `ork_conhecimento_*`: tools do MCP no Claude Code e no Codex, tool argv no OpenClaw (só no
+perfil `coding`) e wrapper no Hermes, cada uma uma chamada de `ork conhecimento <consulta> --json`. A descrição
+das tools do OpenClaw e a skill do Hermes dizem a mesma regra: a lacuna tipada é lacuna, nunca resposta.
+`conhecimento-hosts.test.ts` confere os nomes, o schema e a frase e, com o `ork` real, o mesmo JSON nas três
+superfícies.
+
 Usabilidade HITL é prioridade máxima: recomendação, opções claras e canal disponível
 associado ao pedido. MCP local conserva elicitation; Telegram segue disponível
 quando configurado. Ingresso nativo Hermes/Discord e OpenClaw depende de callback
 autenticado e binding privado; terminal Hermes/ACP não está homologado.
+
+## Batida do host e canal (RM-063)
+
+Os dois hosts de canal ganham a mesma segunda linha da fábrica: `bin/ork-vigia-batida.js` numa
+automação de comando do OpenClaw e `bin/ork-vigia-batida.py` no cron do Hermes leem o
+`ork doctor --json` a cada 30 min e avisam o dono quando a batida passou de 30 min, sem chamada de
+modelo. `#OrkRetomar` e `#OrkFabrica` entram pelo mesmo ingresso assinado do pulse nos dois, e o
+`ork onboarding` grava o `pulse-host.json` do host escolhido. `conducao-canal.test.mjs` e
+`conducao_canal_test.py` provam os dois lados com `ork` e host SIMULADOS.

package/adapters/claude-code/.claude-plugin/plugin.json

@@ -20,6 +20,7 @@
     "./skills/phases/goal-definition",
     "./skills/phases/master-metrics",
     "./skills/phases/plan-specification",
+    "./skills/phases/security-remediation",
     "./skills/phases/ship-release",
     "./skills/reviewers/code-reviewer",
     "./skills/reviewers/security-auditor",

package/adapters/claude-code/README.md

@@ -72,11 +72,11 @@ descartável; o recibo traz o sha256 dos arquivos globais antes e depois. Modelo
 | `/ork` | Painel: doctor, board, escalonador, modos, fila de score |
 
 Mais seis subagentes (`ork-goal`, `ork-plan`, `ork-go`, `ork-check`, `ork-ship`, `ork-master`) para
-isolar o contexto de cada fase, e o guard `PreToolUse`.
+isolar o contexto de cada fase, o guard `PreToolUse` e o hook `UserPromptSubmit` da resposta curta do dono.
 
 ## O guard PreToolUse
 
-Um hook, em `Bash`, chamando `hooks/ork-guard.js`. Ele bloqueia seis classes de comando:
+Um hook, em `Bash`, chamando `hooks/ork-guard.js`. Ele bloqueia sete classes de comando:
 
 | Bloqueio | Por que |
 |---|---|
@@ -86,12 +86,44 @@ Um hook, em `Bash`, chamando `hooks/ork-guard.js`. Ele bloqueia seis classes de
 | `git push` | Push na mao nao e provado: a entrega passa por `ork ship` |
 | `git reset --hard`, `git clean -fd`, `git checkout -- .` | Descarte em massa sem rastro |
 | `rm -rf` com alvo amplo ou variavel | Apaga o que ninguem pediu |
+| `ork noctum terminal` e o hook da resposta chamados pela ferramenta | A resposta do dono no terminal vem do hook da sessão dele; o agente que chama esse ingresso se passa pelo dono (RM-057) |
 
 **O guard nao tem regra de negocio.** Ele nao le ledger, nao sabe quem autorizou o que e nao
 conhece thread nenhuma: ele reconhece a forma do comando e manda o agente pelo caminho que o `ork`
 verifica. Comando que comeca com `ork` passa direto, porque quem prova o push e serializa o merge e
-o nucleo. E se o proprio guard quebrar, ele **libera**: um hook que derruba a sessao por bug proprio
-e pior que nenhum hook.
+o nucleo; a exceção é o ingresso da resposta do dono (`ork noctum terminal`), barrado antes dessa
+passagem. E se o proprio guard quebrar, ele **libera**: um hook que derruba a sessao por bug proprio
+e pior que nenhum hook. A barreira do ingresso da resposta é lombada, não prova: quem roda como o
+mesmo usuário do sistema a contorna, e o limite está dito abaixo.
+
+## A resposta curta do dono no terminal (RM-057)
+
+**Desligada.** Desde o GO-FIX 2 da RM-057, o núcleo não grava nada pelo terminal. Numa sessão interativa do
+Claude Code, quando o dono digita a resposta curta a uma pergunta que espera por ele (`sim`, `a` ou
+`<código> a`), o hook `UserPromptSubmit` (`hooks/ork-resposta.js`) leva o evento ao núcleo pelo
+`ork noctum terminal --hook-stdin`, e o núcleo só devolve a recusa `noctum.terminal.desligado`: com alguém
+presente, o dono vê um aviso (`systemMessage`) para responder pelo Telegram, em reply à mensagem da
+pergunta ou com o código e a letra, ou pela janela de confirmação do Claude Code (o diálogo nativo, um
+clique). O prompt segue ao modelo, e nada é gravado nem encaminhado, nem a resposta a um gate. Conversa
+comum nem chama o núcleo, e o prompt que a máquina escreveu (o campo `source` do evento diferente de
+`user`) também não.
+
+**Por que desligada:** o Claude Code instalado (2.1.306) ainda não manda o `source` do evento, e sem ele
+nada do dono gravaria. E o agente da própria sessão do dono, pela ferramenta Bash, troca o shell pelo
+núcleo com `exec`, tira a marca `AI_AGENT` e forja o evento com `source` igual a `user`: a cadeia de
+processos e o guard são lombadas, não prova. Ligado, o ingresso não serviria ao dono e serviria a quem
+forja o evento.
+
+**O que falta para voltar**, numa fatia própria: o Claude Code mandar a origem humana do evento
+(`source`); uma prova de que o evento veio do hook do harness, e não de um processo do mesmo usuário; e,
+para a palavra solta, a pergunta mostrada exigida como a linha que o núcleo monta para ela, ou só o código
+com a letra. O código do ingresso segue no núcleo atrás da chave `TERMINAL_LIGADO`, desligada; só os
+testes a ligam, e o CLI e o hook nunca.
+
+**Limite:** a fronteira é a conta do sistema. No diálogo nativo, qualquer cliente MCP do mesmo usuário que
+declare o formulário passa, sem chave. Para separar o núcleo dos agentes, rode os agentes em outra conta
+ou sandbox. O aviso só aparece depois de reinstalar o plugin (`ork adapter install claude-code`) e do
+`ork` com o `noctum terminal`.
 
 ## Sensores de sessão
 
@@ -332,7 +364,7 @@ tres e o `--dry-run` mostra o que ele vai fazer sobre cada um.
    (`core/`, `phases/`, `reviewers/`, ...) que este catalogo usa. Por isso `plugin.json` declara os
    caminhos um a um. O teste compara esses caminhos com o catálogo fonte e exige
    `onboarding`, acrescentada por I15. Neste catálogo, `claude plugin details orkastery`
-   deve reportar 28 entradas: 20 skills e 8 comandos (a linha `Skills (28)`). O startup registra
+   deve reportar 29 entradas: 21 skills e 8 comandos (a linha `Skills (29)`). O startup registra
    separadamente skills e comandos. As provas anteriores, com 17 e 18 skills, são históricas.
    Confira também os seis agentes e seis eventos de hooks, sem erros de carregamento.
 

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

@@ -27,6 +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.
 - 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,6 +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.
 - 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,6 +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.
 - 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,6 +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.
 - 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,6 +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.
 - 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,6 +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.
 - 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/hooks/hooks.json

@@ -17,6 +17,7 @@
     "Notification": [{ "hooks": [{ "type": "command", "command": "node \"${CLAUDE_PLUGIN_ROOT}/hooks/ork-sensor.js\"", "timeout": 5 }] }],
     "Stop": [{ "hooks": [{ "type": "command", "command": "node \"${CLAUDE_PLUGIN_ROOT}/hooks/ork-sensor.js\"", "timeout": 5 }] }],
     "SubagentStop": [{ "hooks": [{ "type": "command", "command": "node \"${CLAUDE_PLUGIN_ROOT}/hooks/ork-sensor.js\"", "timeout": 5 }] }],
-    "PostToolUse": [{ "hooks": [{ "type": "command", "command": "node \"${CLAUDE_PLUGIN_ROOT}/hooks/ork-sensor.js\"", "timeout": 5 }] }]
+    "PostToolUse": [{ "hooks": [{ "type": "command", "command": "node \"${CLAUDE_PLUGIN_ROOT}/hooks/ork-sensor.js\"", "timeout": 5 }] }],
+    "UserPromptSubmit": [{ "hooks": [{ "type": "command", "command": "node \"${CLAUDE_PLUGIN_ROOT}/hooks/ork-resposta.js\"", "timeout": 10 }] }]
   }
 }

package/adapters/claude-code/hooks/ork-guard.js

@@ -62,11 +62,25 @@ const BLOQUEIOS = [
   },
 ];
 
+/**
+ * RM-057 (resposta curta, D11 da ork-rm057respost): a resposta do dono no terminal vem do hook `UserPromptSubmit` da
+ * sessao dele. Um agente que chama esse ingresso pela ferramenta se passa pelo dono, e por isso esta regra roda ANTES da
+ * passagem livre do `ork`. E lombada, nao prova: quem roda como o mesmo usuario contorna (o limite dito na RM-058), ate
+ * com o subcomando entre aspas. Desde o GO-FIX 2 (D22) o ingresso do terminal esta desligado e nao grava nada.
+ */
+const RESPOSTA_DO_DONO = {
+  nome: 'resposta-do-dono-por-ferramenta',
+  regex: /\bnoctum\s+terminal\b|ork-resposta\.js/,
+  motivo: 'a resposta do dono no terminal vem do hook UserPromptSubmit da sessao dele; o agente que chama esse ingresso se passa pelo dono',
+  caminho: 'mostre a pergunta ao dono e espere a resposta dele no Telegram ou pela janela de confirmacao do host; nunca responda por ele',
+};
+
 function decidir(entrada) {
   const nome = entrada && entrada.tool_name;
   if (nome !== 'Bash') return null;
   const comando = String((entrada.tool_input && entrada.tool_input.command) || '');
   if (comando.trim() === '') return null;
+  if (RESPOSTA_DO_DONO.regex.test(comando)) return RESPOSTA_DO_DONO;
   // Comando do proprio `ork` passa: quem verifica o push provado e o merge serializado e ele.
   if (/^\s*(?:[A-Za-z0-9_]+=\S*\s+)*(?:\S*\/)?ork\s/.test(comando)) return null;
   for (const b of BLOQUEIOS) {
@@ -127,4 +141,4 @@ process.stdin.on('end', () => {
   process.exitCode = codigo;
 });
 
-module.exports = { BLOQUEIOS, decidir };
+module.exports = { BLOQUEIOS, RESPOSTA_DO_DONO, decidir };

package/adapters/claude-code/hooks/ork-resposta.js

@@ -0,0 +1,91 @@
+#!/usr/bin/env node
+'use strict';
+/**
+ * Hook `UserPromptSubmit` do adaptador Claude Code: a resposta curta do dono no terminal (RM-057, ork-rm057respost).
+ *
+ * GO-FIX 2 (D22): o ingresso do terminal esta DESLIGADO no nucleo. Quando o dono digita a resposta curta a uma pergunta
+ * que espera por ele, o nucleo nao grava nada e devolve so a recusa `noctum.terminal.desligado`, que este hook mostra ao
+ * dono (`systemMessage`): responda pelo Telegram (em reply a mensagem da pergunta, ou com o codigo) ou pela janela de
+ * confirmacao do Claude Code (o dialogo nativo). O transporte abaixo continua o mesmo, para quando uma fatia propria
+ * religar o ingresso.
+ *
+ * O dono aprova onde estiver. Numa sessao interativa, ele responde a pergunta do arco #Noctum com "sim", "a" ou
+ * "<codigo> a"; este hook leva o evento ao nucleo (`ork noctum terminal --hook-stdin`) e transporta a decisao dele:
+ *
+ *  - gravada (ou sem efeito, detalhe, ou a pergunta de volta): a frase do nucleo substitui o prompt (`decision: block`),
+ *    e o "sim" nao chega ao modelo;
+ *  - resposta a um gate: o contexto vai ao modelo (`additionalContext`), para o condutor abrir o dialogo nativo;
+ *  - recusa pela origem com alguem presente: um aviso ao dono (`systemMessage`), e o prompt segue ao modelo;
+ *  - o resto: nada, e o prompt segue como sempre.
+ *
+ * Ele NAO tem regra de negocio: nao le ledger, nao conhece pergunta e nao prova nada; quem confere a origem da sessao e o
+ * nucleo. So texto curto de uma linha chama o nucleo. Erro do hook ou do nucleo nunca bloqueia nem quebra a sessao.
+ *
+ * GO-FIX 1 (achado 1): o prompt que a maquina injeta na sessao do dono (a tarefa agendada, a volta do /loop, a mensagem
+ * de canal ou de outra sessao, o SDK) nunca chega ao nucleo: o evento diz quem o escreveu (`source`), e so `user`, o
+ * compositor interativo, passa. Sem o campo (versao do Claude Code que ainda nao o manda), o nucleo recebe o evento,
+ * recusa e diz ao dono por que; ele tambem exige `user`, para quem chamar o nucleo sem este hook.
+ */
+const fs = require('node:fs');
+const path = require('node:path');
+const { spawnSync } = require('node:child_process');
+
+/**
+ * A forma da resposta curta, larga o bastante para o nucleo decidir e estreita o bastante para conversa comum nem chamar o
+ * nucleo: o codigo com a resposta ("NX4K a"), o numero com a letra ("1a") ou uma palavra solta de ate duas palavras e 20
+ * caracteres ("sim", "pode seguir"). Tudo numa linha so, ate 64 caracteres.
+ */
+const TETO_DO_PROMPT = 64;
+const CODIGO_E_RESPOSTA = /^[A-HJKMNP-TV-Z](?=[2-9A-HJKMNP-TV-Z]{0,2}[2-9])[2-9A-HJKMNP-TV-Z]{3}\s+\S/i;
+const NUMERO_E_LETRA = /^[0-9]{1,2}\s*[a-e][.!]?$/i;
+const PALAVRA_SOLTA = /^\S+(?:\s\S+)?$/;
+const TETO_DA_ENTRADA = 1024 * 1024;
+
+function pareceRespostaCurta(t) {
+  if (!t || t.length > TETO_DO_PROMPT || /[\r\n]/.test(t)) return false;
+  return CODIGO_E_RESPOSTA.test(t) || NUMERO_E_LETRA.test(t) || (t.length <= 20 && PALAVRA_SOLTA.test(t));
+}
+
+function lerEntrada() {
+  const buffer = Buffer.alloc(TETO_DA_ENTRADA + 1);
+  let bytes = 0;
+  while (bytes <= TETO_DA_ENTRADA) {
+    const n = fs.readSync(0, buffer, bytes, buffer.length - bytes, null);
+    if (!n) break;
+    bytes += n;
+  }
+  if (bytes > TETO_DA_ENTRADA) return null;
+  return JSON.parse(buffer.subarray(0, bytes).toString('utf8'));
+}
+
+/** O texto que o nucleo montou, com teto: o hook transporta, nunca reescreve. */
+const texto = (v, teto) => (typeof v === 'string' && v.trim() ? v.slice(0, teto) : '');
+
+function executar() {
+  const h = lerEntrada();
+  if (!h || h.hook_event_name !== 'UserPromptSubmit' || typeof h.prompt !== 'string' ||
+      typeof h.cwd !== 'string' || !path.isAbsolute(h.cwd)) return;
+  // O prompt que a maquina escreveu nao e do dono: nao chega ao nucleo, e segue ao modelo como sempre.
+  if (h.source !== undefined && h.source !== 'user') return;
+  if (!pareceRespostaCurta(h.prompt.trim())) return;
+  const r = spawnSync(process.env.ORK_SENSOR_CLI || 'ork', ['noctum', 'terminal', '--hook-stdin'], {
+    cwd: h.cwd, input: JSON.stringify(h), encoding: 'utf8', timeout: 8000, maxBuffer: 256 * 1024, windowsHide: true,
+  });
+  if (r.status !== 0 || typeof r.stdout !== 'string' || !r.stdout.trim()) return;
+  let d;
+  try { d = JSON.parse(r.stdout); } catch { return; }
+  if (!d || d.contrato !== 'ork.noctum-terminal/v1') return;
+  let saida = null;
+  if (['registrada', 'sem-efeito', 'detalhe', 'pergunta'].includes(d.acao) && texto(d.mensagem, 8000)) {
+    saida = { decision: 'block', reason: texto(d.mensagem, 8000) };
+  } else if (d.acao === 'encaminhar' && texto(d.contexto, 2000)) {
+    saida = { hookSpecificOutput: { hookEventName: 'UserPromptSubmit', additionalContext: texto(d.contexto, 2000) } };
+  } else if (d.acao === 'recusada' && d.presenca === true && texto(d.mensagem, 2000)) {
+    saida = { systemMessage: texto(d.mensagem, 2000) };
+  }
+  if (saida) process.stdout.write(JSON.stringify(saida) + '\n');
+}
+
+try { executar(); }
+catch { process.stderr.write('ork resposta: entrada invalida ou nucleo indisponivel; o prompt segue sem mudanca.\n'); }
+process.exitCode = 0;

package/adapters/claude-code/hooks/ork-sensor.js

@@ -5,6 +5,7 @@ const fs = require('node:fs');
 const path = require('node:path');
 const { spawnSync } = require('node:child_process');
 const { createHash, randomUUID } = require('node:crypto');
+const { accountFailure } = require('./quota-signal');
 
 function executar() {
   const limite = 1024 * 1024;
@@ -25,6 +26,15 @@ function executar() {
   if (!tipo) return;
   const payload = { observedAt: new Date().toISOString() };
   if (h.hook_event_name === 'Notification') payload.notificationType = h.notification_type;
+  // RM-037 (CHECK 3 da ork-rm037defeit2): o Stop conta o trabalho que ainda vai acordar a sessão. Com despertar agendado
+  // (CronCreate, ScheduleWakeup, /loop) ou tarefa MCP, o Claude Code mostra a sessão `idle`; só a entrada do Stop separa
+  // a sessão encerrada da que vai voltar a escrever. Runtime sem os campos não manda nada, e o ork não supõe zero.
+  if (h.hook_event_name === 'Stop') {
+    if (Array.isArray(h.background_tasks)) payload.backgroundTasks = h.background_tasks.length;
+    if (Array.isArray(h.session_crons)) payload.sessionCrons = h.session_crons.length;
+  }
+  const falhaDaConta = accountFailure(h);
+  if (falhaDaConta && (tipo === 'notification' || tipo === 'stop')) payload.accountFailure = falhaDaConta;
   // tool_use_id identifica replay da mesma ferramenta. Sem id do protocolo,
   // cada invocação é uma ocorrência; stat do transcript não identifica eventos.
   payload.eventId = typeof h.tool_use_id === 'string'
@@ -47,11 +57,17 @@ function executar() {
       }
     }
   }
-  const r = spawnSync(process.env.ORK_SENSOR_CLI || 'ork',
+  const enviar = (p) => spawnSync(process.env.ORK_SENSOR_CLI || 'ork',
     ['sessions', 'event', '--tipo', tipo, '--sessao', h.session_id], {
-      cwd: h.cwd, input: JSON.stringify(payload), encoding: 'utf8', timeout: 3000,
+      cwd: h.cwd, input: JSON.stringify(p), encoding: 'utf8', timeout: 3000,
       maxBuffer: 32768, windowsHide: true,
     });
+  let r = enviar(payload);
+  // O `ork` de antes das contagens recusa o campo novo antes de gravar qualquer coisa: o Stop vai de novo sem elas, como ia.
+  if (r.status === 1 && /^evento recusado: campo de payload inválido: (?:backgroundTasks|sessionCrons)$/m.test(r.stderr || '')) {
+    const { backgroundTasks: _tarefas, sessionCrons: _despertares, ...semContagens } = payload;
+    r = enviar(semContagens);
+  }
   if (r.status !== 0) {
     // Recusa conhecida não identifica o papel da sessão nem comprova ingestão.
     const semVinculo = r.status === 1 && !r.error && !r.stdout?.trim() &&

package/adapters/claude-code/hooks/quota-signal.js

@@ -0,0 +1,14 @@
+'use strict';
+
+/**
+ * RM-064 T1: reconhece apenas o fato de a conta ter esgotado. O chamador persiste
+ * o código devolvido, nunca os textos que serviram de entrada.
+ */
+function accountFailure(h) {
+  const partes = [h?.message, h?.reason, h?.stop_reason, h?.error?.message, h?.error?.code]
+    .filter((v) => typeof v === 'string').join('\n');
+  return /(?:you(?:'|’)ve hit your (?:weekly|session|individual spend|usage) limit|seu limite de uso foi atingido|usage_limit_(?:exceeded|reached)|insufficient_quota|out of credits|spend (?:cap|limit))/i.test(partes)
+    ? 'runtime.quota-exhausted' : null;
+}
+
+module.exports = { accountFailure };

package/adapters/claude-code/mods/ork-mensageiro/.claude-plugin/plugin.json

@@ -0,0 +1,14 @@
+{
+  "name": "ork-mensageiro",
+  "version": "0.1.0",
+  "description": "Mensageiro de Sessões do Orkastery no Claude Code: leva a resposta que o dono deu pelo diálogo nativo à sessão de fase claude-bg que parou esperando por ele, como mensagem entre sessões, e na sessão de fase só deixa chegar ao modelo a mensagem que o núcleo confirmou como aquela resposta. Nunca responde nem aprova pelo dono.",
+  "author": {
+    "name": "Orkastery contributors",
+    "url": "https://github.com/orkastery"
+  },
+  "homepage": "https://orkastery.com/",
+  "repository": "https://github.com/orkastery/orkastery",
+  "license": "MIT",
+  "types": "./types/index.d.ts",
+  "dependencies": ["ork-ponte"]
+}

package/adapters/claude-code/mods/ork-mensageiro/hooks/caixa.ts

@@ -0,0 +1,215 @@
+// O lado do dono do Mensageiro de Sessoes (RM-059, fatia F9, T9.2), em funcoes puras. A sessao do dono que recebeu a
+// resposta pelo dialogo nativo tem a mensagem na caixa de saida do servidor MCP dela (`ork_session_outbox`), so na
+// memoria; o Mensageiro a leva a sessao de fase por `$.session.send`, sem mexer no texto, e anota o envio no nucleo.
+// O que segue incerto noutra sessao do dono sai do retrato da ponte (secao `hitl`). Nada daqui guarda o texto da
+// resposta no estado (D12 da thread ork-rm059mensag). So importa tipos.
+import type { MensageiroDono, MensageiroEntrega, MensageiroEstadoDaEntrega, MensageiroIncerta } from '../types'
+
+export const SERVIDOR = 'orkastery'
+/** A ferramenta da caixa de saida, so no servidor do dono do Claude Code (T9.1). */
+export const FERRAMENTA_DA_CAIXA = 'ork_session_outbox'
+/** O contrato da entrega no nucleo (`core/src/entrega-por-mod.ts`), conferido pelo teste do nucleo. */
+export const CONTRATO_DA_ENTREGA = 'ork.session-delivery/v1'
+/** D10: o envio que nao entrou na fila volta depois do recuo; o que entrou e nao foi reservado, depois da espera. */
+export const RECUO_DO_ENVIO_MS = 30000
+export const ESPERA_DA_RESERVA_MS = 60000
+export const MAXIMO_DE_ENVIOS = 10
+/** D21: a reserva sem recibo por este tempo deixa de ser "confirmando" e pede o dono. */
+export const ESPERA_DO_RECIBO_MS = 5 * 60000
+/** A faixa diz "entregue" por este tempo; o painel guarda o que terminou por este outro. */
+export const FAIXA_DA_ENTREGA_MS = 10 * 60000
+export const GUARDA_DO_TERMINADO_MS = 30 * 60000
+export const MAXIMO_DE_ENTREGAS = 50
+export const DONO_VAZIO: MensageiroDono = { entregas: [], incertas: [], lidoEm: null, erro: null }
+
+const UUID = /^[0-9a-f]{8}(?:-[0-9a-f]{4}){3}-[0-9a-f]{12}$/
+const ID_DE_THREAD = /^[a-zA-Z0-9][a-zA-Z0-9._-]{0,79}$/
+const VIVOS: readonly MensageiroEstadoDaEntrega[] = ['na-fila', 'a-caminho', 'reservada', 'nao-chegou']
+
+/** Uma entrega da caixa de saida como o nucleo a lista, com o ultimo envio em ms. */
+export type EntradaDaCaixa = {
+  thread: string; pedidoId: string; envioId: string; sessionId: string
+  /** A mensagem inteira, com o cabecalho do nucleo: vai ao `$.session.send` como esta e nunca ao estado. */
+  mensagem: string
+  tentativas: number
+  ultimoEnvio: { em: number; entregue: boolean; motivo: string | null } | null
+  reservada: boolean
+  /** Quando a entrega entrou na caixa (ms desde a epoca); conta o sem-recibo quando o envio nao foi anotado. */
+  criadaEm: number | null
+}
+
+const objeto = (v: unknown): v is Record<string, any> => !!v && typeof v === 'object' && !Array.isArray(v)
+const uuid = (v: unknown): v is string => typeof v === 'string' && UUID.test(v)
+
+/** Uma linha so, sem caractere de controle e com teto: o que vem do nucleo ou de um erro nunca quebra a tela. */
+export function umaLinha(v: unknown, teto = 200): string {
+  const s = typeof v === 'string' ? v : v instanceof Error ? v.message : String(v)
+  return Array.from(s.replace(/\p{Cc}/gu, ' ').replace(/\s+/g, ' ').trim()).slice(0, teto).join('')
+}
+
+/** O JSON que uma ferramenta do nucleo devolveu; a recusa vira erro com o motivo dela. */
+export function jsonDoMcp(r: unknown, ferramenta: string): unknown {
+  const o = objeto(r) ? r : {}
+  const conteudo = Array.isArray(o.content) ? o.content : []
+  const texto = conteudo.filter(c => objeto(c) && c.type === 'text' && typeof c.text === 'string').map(c => c.text).join('')
+  let dados: unknown
+  try { dados = JSON.parse(texto) } catch { throw new Error(`${ferramenta} respondeu fora do JSON`) }
+  if (o.isError === true) throw new Error(`${ferramenta} recusou: ${umaLinha(objeto(dados) && typeof dados.erro === 'string' ? dados.erro : texto)}`)
+  return dados
+}
+
+function lerEntrada(e: unknown): EntradaDaCaixa[] {
+  if (!objeto(e) || typeof e.thread !== 'string' || !ID_DE_THREAD.test(e.thread) || !uuid(e.pedidoId) || !uuid(e.envioId) ||
+      !uuid(e.sessionId) || typeof e.mensagem !== 'string' ||
+      !e.mensagem.startsWith(`[${CONTRATO_DA_ENTREGA} pedido=${e.pedidoId} entrega=${e.envioId}] `)) return []
+  const u = objeto(e.ultimoEnvio) ? e.ultimoEnvio : null
+  const em = u && typeof u.em === 'string' ? Date.parse(u.em) : NaN
+  const criadaEm = typeof e.criadaEm === 'string' ? Date.parse(e.criadaEm) : NaN
+  return [{ thread: e.thread, pedidoId: e.pedidoId, envioId: e.envioId, sessionId: e.sessionId, mensagem: e.mensagem,
+    tentativas: Number.isSafeInteger(e.tentativas) && e.tentativas > 0 ? e.tentativas : 0,
+    ultimoEnvio: u && Number.isFinite(em) ? { em, entregue: u.entregue === true, motivo: typeof u.motivo === 'string' ? umaLinha(u.motivo) : null } : null,
+    reservada: e.reservada === true, criadaEm: Number.isFinite(criadaEm) ? criadaEm : null }]
+}
+
+/** A caixa de saida do `listar`; o que nao bate com o contrato fica de fora, e a resposta fora do contrato e erro. */
+export function lerCaixa(dados: unknown): EntradaDaCaixa[] {
+  if (!objeto(dados) || dados.contrato !== CONTRATO_DA_ENTREGA || !Array.isArray(dados.entregas)) {
+    throw new Error('a caixa de saída respondeu fora do contrato ork.session-delivery/v1')
+  }
+  return dados.entregas.flatMap(lerEntrada)
+}
+
+/** A entrega que o `enviada` devolveu, com a reserva que ela tinha na lista (o nucleo so a le no `listar`). */
+export function entradaAnotada(dados: unknown, reservada: boolean): EntradaDaCaixa | null {
+  const lida = objeto(dados) && dados.contrato === CONTRATO_DA_ENTREGA ? lerEntrada({ ...(objeto(dados.entrega) ? dados.entrega : {}), reservada }) : []
+  return lida[0] ?? null
+}
+
+/** D10: envia o que nunca foi, o que nao entrou na fila depois do recuo e o que entrou e ninguem reservou depois da espera. */
+export function deveEnviar(e: EntradaDaCaixa, agora: number): boolean {
+  if (e.reservada || e.tentativas >= MAXIMO_DE_ENVIOS) return false
+  if (!e.ultimoEnvio) return true
+  return agora - e.ultimoEnvio.em >= (e.ultimoEnvio.entregue ? ESPERA_DA_RESERVA_MS : RECUO_DO_ENVIO_MS)
+}
+
+/** O argumento do `$.session.send`: a sessao do pedido e a mensagem do nucleo, sem mexer em nada. */
+export function argsDoEnvio(e: EntradaDaCaixa): { to: { sessionId: string }; text: string } {
+  return { to: { sessionId: e.sessionId }, text: e.mensagem }
+}
+
+/** O resultado do `$.session.send` como o nucleo o anota. */
+export function resultadoDoEnvio(r: unknown): { entregue: boolean; motivo: string | null } {
+  if (objeto(r) && r.isDelivered === true) return { entregue: true, motivo: null }
+  return { entregue: false, motivo: umaLinha(objeto(r) && typeof r.reason === 'string' && r.reason ? r.reason : 'a sessão não recebeu a mensagem') }
+}
+
+export function argsDaAnotacao(e: EntradaDaCaixa, r: { entregue: boolean; motivo: string | null }): Record<string, unknown> {
+  return { operacao: 'enviada', threadId: e.thread, envioId: e.envioId, entregue: r.entregue, ...(r.motivo ? { motivo: r.motivo } : {}) }
+}
+
+/** A secao `hitl` do retrato, quando ela veio lida (disponivel ou vazia); `null` quando nao da para concluir nada. */
+function secaoHitl(retrato: unknown): Record<string, any>[] | null {
+  const secoes = objeto(retrato) && objeto(retrato.sections) ? retrato.sections : {}
+  const hitl = objeto(secoes.hitl) ? secoes.hitl : null
+  if (!hitl || (hitl.state !== 'available' && hitl.state !== 'empty')) return null
+  return Array.isArray(hitl.items) ? hitl.items.filter(objeto) : []
+}
+
+const threadDoItem = (i: Record<string, any>): string | null => {
+  const ref = Array.isArray(i.refs) ? i.refs.find((r: unknown) => objeto(r) && r.kind === 'thread' && typeof r.id === 'string') : null
+  return ref && ID_DE_THREAD.test(ref.id) ? ref.id : null
+}
+
+/** Os pedidos abertos que o retrato mostra (respondido sai da secao); `null` quando a secao nao veio lida. */
+export function pedidosNoRetrato(retrato: unknown): Set<string> | null {
+  const itens = secaoHitl(retrato)
+  return itens === null ? null : new Set(itens.flatMap(i => (typeof i.id === 'string' ? [i.id] : [])))
+}
+
+/** Os pedidos de sessao com a entrega incerta no retrato (`delivery.uncertain`): a entrega segue em alguma sessao do dono. */
+export function incertasDoRetrato(retrato: unknown): MensageiroIncerta[] {
+  return (secaoHitl(retrato) ?? []).flatMap(i => {
+    const thread = threadDoItem(i)
+    return i.status === 'delivery.uncertain' && objeto(i.facts) && i.facts.target === 'session' && uuid(i.id) && thread
+      ? [{ thread, pedidoId: i.id }] : []
+  })
+}
+
+/** O estado de uma entrega que esta na caixa, agora. */
+export function estadoDaEntrada(e: EntradaDaCaixa, agora: number): MensageiroEstadoDaEntrega {
+  if (e.reservada) {
+    const desde = e.ultimoEnvio?.em ?? e.criadaEm
+    return typeof desde === 'number' && agora - desde >= ESPERA_DO_RECIBO_MS ? 'sem-recibo' : 'reservada'
+  }
+  if (!e.ultimoEnvio) return 'na-fila'
+  if (e.tentativas >= MAXIMO_DE_ENVIOS) return 'desistiu'
+  return e.ultimoEnvio.entregue ? 'a-caminho' : 'nao-chegou'
+}
+
+function motivoDaEntrada(e: EntradaDaCaixa, estado: MensageiroEstadoDaEntrega): string | null {
+  if (estado === 'sem-recibo') return 'a sessão de fase reservou a entrega e não gravou o recibo em 5 min'
+  if (estado === 'desistiu') {
+    return e.ultimoEnvio?.entregue
+      ? `a sessão de fase não confirmou a entrega depois de ${e.tentativas} envios`
+      : e.ultimoEnvio?.motivo ?? `a mensagem não entrou na fila da sessão em ${e.tentativas} envios`
+  }
+  return estado === 'nao-chegou' ? e.ultimoEnvio?.motivo ?? null : null
+}
+
+/**
+ * As entregas desta sessao depois de uma leitura da caixa. A que saiu da caixa terminou: entregue, quando o retrato
+ * nao mostra mais o pedido (respondido); "saiu da caixa", quando o pedido segue aberto. Sem o retrato, nada se conclui.
+ */
+export function atualizarEntregas(anteriores: readonly MensageiroEntrega[], caixa: readonly EntradaDaCaixa[],
+  noRetrato: Set<string> | null, agora: number): MensageiroEntrega[] {
+  const restantes = new Map(anteriores.map(e => [e.envioId, e]))
+  const saida: MensageiroEntrega[] = []
+  for (const c of caixa) {
+    const estado = estadoDaEntrada(c, agora)
+    const antes = restantes.get(c.envioId)
+    restantes.delete(c.envioId)
+    saida.push({ thread: c.thread, pedidoId: c.pedidoId, envioId: c.envioId, sessionId: c.sessionId, estado, tentativas: c.tentativas,
+      motivo: motivoDaEntrada(c, estado), em: antes && antes.estado === estado ? antes.em : agora })
+  }
+  for (const e of restantes.values()) {
+    if (!VIVOS.includes(e.estado) && e.estado !== 'desistiu' && e.estado !== 'sem-recibo') {
+      if (agora - e.em <= GUARDA_DO_TERMINADO_MS) saida.push(e)
+      continue
+    }
+    if (noRetrato === null) { saida.push(e); continue }
+    const aberto = noRetrato.has(e.pedidoId)
+    saida.push({ ...e, estado: aberto ? 'saiu-da-caixa' : 'entregue', em: agora,
+      motivo: aberto ? 'a caixa de saída soltou a entrega sem recibo; responda pelo claude attach' : null })
+  }
+  return saida.slice(-MAXIMO_DE_ENTREGAS)
+}
+
+/** A thread do ledger que mudou, pelos caminhos que a ponte vigia (`.orkastery/threads/<thread>/ledger.jsonl`). */
+export function threadDoLedger(caminho: unknown): string | null {
+  if (typeof caminho !== 'string') return null
+  const m = /\.orkastery\/threads\/([^/]+)\/ledger\.jsonl$/.exec(caminho)
+  return m && ID_DE_THREAD.test(m[1]) ? m[1] : null
+}
+
+function daThread(entregas: readonly MensageiroEntrega[], um: string, varios: (n: number) => string): string {
+  return entregas.length === 1 ? `${um} ${entregas[0].thread}` : varios(entregas.length)
+}
+
+/**
+ * A linha da faixa (D7 do plano dos mods): o que nao chegou e precisa do dono vem primeiro; depois o que esta a caminho;
+ * depois o que acabou de ser entregue. Sem nada disso, a linha sai da faixa.
+ */
+export function textoDaFaixa(dono: MensageiroDono, agora: number): string | undefined {
+  const falhas = dono.entregas.filter(e => e.estado === 'desistiu' || e.estado === 'saiu-da-caixa')
+  if (falhas.length) return falhas.length === 1
+    ? `a resposta para a ${falhas[0].thread} não chegou; responda pelo claude attach` : `${falhas.length} respostas não chegaram; abra /mensageiro`
+  // Sem recibo, a resposta pode ter entrado na conversa: o dono confere antes de responder de novo.
+  const semRecibo = dono.entregas.filter(e => e.estado === 'sem-recibo')
+  if (semRecibo.length) return semRecibo.length === 1
+    ? `a resposta para a ${semRecibo[0].thread} ficou sem recibo; confira pelo claude attach` : `${semRecibo.length} respostas sem recibo; abra /mensageiro`
+  const vivas = dono.entregas.filter(e => VIVOS.includes(e.estado))
+  if (vivas.length) return daThread(vivas, 'resposta a caminho da', n => `${n} respostas a caminho das sessões de fase`)
+  const entregues = dono.entregas.filter(e => e.estado === 'entregue' && agora - e.em <= FAIXA_DA_ENTREGA_MS)
+  if (entregues.length) return daThread(entregues, 'resposta entregue à', n => `${n} respostas entregues às sessões de fase`)
+  return undefined
+}

package/adapters/claude-code/mods/ork-mensageiro/hooks/hooks.json

@@ -0,0 +1,3 @@
+{
+  "modules": ["./register.tsx"]
+}