@orkastery/cli 0.4.1 → 0.4.3

package/README.md

@@ -13,6 +13,9 @@ append-only ledger.
   it again on an independent runner before the merge.
 - **You choose how often you are called.** One mode per #TAG, in the request itself, decides
   where the cycle pauses. Verification is the same in all of them.
+- **Decisions sized for a full day.** Every question `ork` brings you is short, with alternatives
+  and one recommendation, so a person running dozens of things at once, including people with
+  ADHD, decides in seconds.
 - **Subscription, never pay-per-token.** Dispatch uses the runtime CLI's own login. `ork` never
   reads credentials, and the `subscription-only` policy blocks paid providers.
 

package/adapters/openclaw/README.md

@@ -57,7 +57,6 @@ fallback: usa `ORK_BIN` do ambiente ou o `ork` do PATH.
 | `ork_claims_add` | Registra alegacao verificavel com o comando que a comprova |
 | `ork_verify` / `ork_verify_baseline` | Reexecuta no HEAD real; grava a baseline antes do GO |
 | `ork_worktree_ensure` / `ork_worktree_audit` | Worktree isolada, conferida no proprio git |
-| `ork_objective_status` / `ork_objective_message` | Aposentadas com o `ork objective` na I-43: devolvem a recusa tipada `objective.aposentado` |
 | `ork_portfolio_list` | Lista produtos, projetos e iniciativas canônicos |
 | `ork_gate_answer` | Resposta humana correlacionada a um gate |
 | `ork_session_answer` | Resposta humana correlacionada a uma sessão |

package/adapters/openclaw/dist/index.js

@@ -254,25 +254,6 @@ const FERRAMENTAS = [
         parameters: schema({ thread: { type: 'string' } }),
         argv: (p) => ['phase', 'list', texto(p, 'thread')],
     },
-    {
-        name: 'ork_objective_status',
-        description: 'Aposentado na I-43 junto com ork objective: devolve a recusa tipada objective.aposentado, com saida != 0. Estado de uma entrega: ork_thread_status. Ciclos ligados a um produto, projeto ou iniciativa: ork portfolio inspect <id> --json.',
-        parameters: schema({ objective: { type: 'string', description: 'ID obj-* do ticket' } }),
-        argv: (p) => ['objective', 'status', texto(p, 'objective'), '--json'],
-    },
-    {
-        name: 'ork_objective_message',
-        description: 'Aposentado na I-43 junto com ork objective: devolve a recusa tipada objective.aposentado, com saida != 0, e nao grava nada. Resposta do dono a uma pausa vai por ork_gate_answer ou ork_session_answer.',
-        parameters: schema({
-            objective: { type: 'string', description: 'ID obj-* do ticket' },
-            author: { type: 'string', description: 'Identidade fornecida pelo gateway autenticado' },
-            message: { type: 'string', description: 'Texto integral recebido do dono' },
-        }),
-        argv: (p) => [
-            'objective', 'message', texto(p, 'objective'),
-            '--text', texto(p, 'message'), '--por', texto(p, 'author'), '--role', 'human',
-        ],
-    },
     {
         name: 'ork_portfolio_list',
         description: 'Lista produtos, projetos e iniciativas do catálogo canônico usado pelo Kanban.',

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.",
-  "version": "0.4.1",
+  "version": "0.4.3",
   "configSchema": {
     "type": "object",
     "properties": {},
@@ -21,8 +21,6 @@
       "ork_thread_status",
       "ork_phase_run",
       "ork_phase_list",
-      "ork_objective_status",
-      "ork_objective_message",
       "ork_portfolio_list",
       "ork_brain_status",
       "ork_brain_query",

package/adapters/openclaw/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@orkastery/openclaw-plugin",
-  "version": "0.4.1",
-  "description": "Plugin Orkastery para OpenClaw: 25 tools ork_* que traduzem intencao em chamada de CLI do nucleo `ork`. Zero regra de negocio no host.",
+  "version": "0.4.3",
+  "description": "Plugin Orkastery para OpenClaw: 23 tools ork_* que traduzem intencao em chamada de CLI do nucleo `ork`. Zero regra de negocio no host.",
   "type": "module",
   "private": true,
   "license": "MIT",

package/adapters/openclaw/src/index.ts

@@ -265,27 +265,6 @@ const FERRAMENTAS: FerramentaOrk[] = [
     parameters: schema({ thread: { type: 'string' } }),
     argv: (p) => ['phase', 'list', texto(p, 'thread')],
   },
-  {
-    name: 'ork_objective_status',
-    description:
-      'Aposentado na I-43 junto com ork objective: devolve a recusa tipada objective.aposentado, com saida != 0. Estado de uma entrega: ork_thread_status. Ciclos ligados a um produto, projeto ou iniciativa: ork portfolio inspect <id> --json.',
-    parameters: schema({ objective: { type: 'string', description: 'ID obj-* do ticket' } }),
-    argv: (p) => ['objective', 'status', texto(p, 'objective'), '--json'],
-  },
-  {
-    name: 'ork_objective_message',
-    description:
-      'Aposentado na I-43 junto com ork objective: devolve a recusa tipada objective.aposentado, com saida != 0, e nao grava nada. Resposta do dono a uma pausa vai por ork_gate_answer ou ork_session_answer.',
-    parameters: schema({
-      objective: { type: 'string', description: 'ID obj-* do ticket' },
-      author: { type: 'string', description: 'Identidade fornecida pelo gateway autenticado' },
-      message: { type: 'string', description: 'Texto integral recebido do dono' },
-    }),
-    argv: (p) => [
-      'objective', 'message', texto(p, 'objective'),
-      '--text', texto(p, 'message'), '--por', texto(p, 'author'), '--role', 'human',
-    ],
-  },
   {
     name: 'ork_portfolio_list',
     description: 'Lista produtos, projetos e iniciativas do catálogo canônico usado pelo Kanban.',

package/dist/adapters/claude-bg.js

@@ -44,6 +44,7 @@ var __importStar = (this && this.__importStar) || (function () {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.JANELA_CURTA_MAX_MS = exports.NOME_ADAPTER = void 0;
 exports.ambienteDoPerfil = ambienteDoPerfil;
+exports.semContextoDeDespacho = semContextoDeDespacho;
 exports.disponivel = disponivel;
 exports.versao = versao;
 exports.montarComando = montarComando;
@@ -62,6 +63,8 @@ exports.limparAnsi = limparAnsi;
 exports.logs = logs;
 exports.logsDaSessao = logsDaSessao;
 exports.parar = parar;
+exports.pararAchada = pararAchada;
+exports.acharSessaoNasContas = acharSessaoNasContas;
 exports.ocupacaoDeContexto = ocupacaoDeContexto;
 const util_1 = require("../util");
 const runtime_ambiente_1 = require("../runtime-ambiente");
@@ -82,6 +85,14 @@ function ambienteDoPerfil(perfil) {
     return (0, runtime_profiles_1.ambienteComPerfil)((0, runtime_ambiente_1.ambienteDeAssinatura)(), perfil);
 }
 exports.NOME_ADAPTER = 'claude-bg';
+/** RM-037 (defeitosdeco D-4): o ambiente do `claude --bg` sem canal nem chave do contexto do despacho. */
+function semContextoDeDespacho(base, contexto) {
+    const env = { ...base };
+    delete env.ORK_CANAL;
+    for (const chave of Object.keys(contexto ?? {}))
+        delete env[chave];
+    return env;
+}
 /** Consultas do perfil interactive; gates e respostas humanas nunca recebem grant. */
 const CONSULTAS_MCP = [
     'mcp__orkastery__ork_thread_status',
@@ -129,6 +140,13 @@ function montarComando(pedido) {
         args.push('--model', pedido.model);
     if (pedido.effort)
         args.push('--effort', pedido.effort);
+    // RM-037 (defeitosdeco D-4): o contexto do despacho (identidade, thread, canal) chega POR SESSAO.
+    // O `claude --bg` entrega a sessao a um processo reserva do daemon da conta, e o daemon guarda o
+    // ambiente de quem o iniciou: pelo ambiente, a sessao nascia com a identidade de outro despacho.
+    // Medido em 28/09/2026 (2.1.284): o `env` de `--settings` chega ao Bash da sessao e vence o herdado.
+    const doDespacho = pedido.ambienteExtra ?? {};
+    if (Object.keys(doDespacho).length)
+        args.push('--settings', JSON.stringify({ env: doDespacho }));
     if (pedido.contextoRuntime) {
         if (pedido.contextoRuntime.host !== 'claude-code')
             throw Error('runtime.context.invalid: host Claude esperado');
@@ -255,8 +273,10 @@ function acharSessao(chave, sessoes) {
 function despachar(pedido) {
     const comando = montarComando(pedido);
     let ambiente;
+    // D-4: nada do contexto do despacho vai ao ambiente do processo `claude`, para um daemon novo nunca
+    // nascer com ele; a identidade herdada ja sai em `ambienteDeAssinatura`, e o canal sai aqui.
     try {
-        ambiente = { ...ambienteDoPerfil(pedido.perfil), ...(pedido.ambienteExtra ?? {}) };
+        ambiente = semContextoDeDespacho(ambienteDoPerfil(pedido.perfil), pedido.ambienteExtra);
     }
     catch (e) {
         return { ok: false, comando, sessionId: null, verificada: false, stdout: '', stderr: '', erro: e.message };
@@ -497,6 +517,13 @@ const FRASES_DE_AUTH_AUSENTE = [
  * so vale como auth ausente quando o mesmo texto nao traz frase de cota: a cota, mais especifica, vence.
  */
 const FRASES_AMPLAS_DE_AUTH = [/\bcodex login\b/i];
+/**
+ * RM-037 (defeitosdeco D-6): modelo inexistente ou sem acesso na conta. Medido na transcricao da
+ * sessao af32834f (28/09/2026, `fable-5-1` num perfil de conta sem esse modelo): `error: "model_not_found"` e o texto
+ * "There's an issue with the selected model (fable-5-1). It may not exist or you may not have access
+ * to it". Frase de sobrecarga ("model is overloaded") nao entra: e falha transitoria da infra.
+ */
+const FRASES_DE_MODELO_INACESSIVEL = [/\bmodel_not_found\b/i, /issue with the selected model/i];
 /**
  * I-33 (D16): CRITERIO UNICO entre ESGOTAMENTO da conta e RATE LIMIT comum. Decisao do dono em
  * 19/09/2026 (opcao a do A3 do CHECK aa279e17): esgotamento de cota, credito ou limite do plano
@@ -593,6 +620,9 @@ function naturezaDoLimite(saida, agoraMs = Date.now()) {
 }
 function parseFalhaDeConta(saida, agoraMs = Date.now()) {
     const texto = saida ?? '';
+    const modelo = FRASES_DE_MODELO_INACESSIVEL.find((r) => r.test(texto));
+    if (modelo)
+        return { motivo: 'runtime.model-unavailable', resetEm: null, fonte: 'sem-horario', trecho: trechoDa(texto, modelo) };
     const auth = FRASES_DE_AUTH_AUSENTE.find((r) => r.test(texto));
     if (auth)
         return { motivo: 'runtime.auth-missing', resetEm: null, fonte: 'sem-horario', trecho: trechoDa(texto, auth) };
@@ -645,9 +675,15 @@ function conferirAuth(perfil) {
     }
     return { ok: true, detalhe: `claude auth status: loggedIn (${metodo})` };
 }
-/** Comando de anexar a sessao (precisa de TTY, entao o CLI imprime em vez de executar). */
-function comandoAttach(sessionId) {
-    return `claude attach ${sessionId}`;
+/**
+ * Comando de anexar a sessao (precisa de TTY, entao o CLI imprime em vez de executar). RM-037
+ * (defeitosdeco D-2): sessao de um perfil so e anexada com o `CLAUDE_CONFIG_DIR` daquela conta.
+ */
+function comandoAttach(sessionId, configDir) {
+    if (!configDir)
+        return `claude attach ${sessionId}`;
+    const dir = /^[A-Za-z0-9_./-]+$/.test(configDir) ? configDir : `'${configDir.replace(/'/g, `'\\''`)}'`;
+    return `CLAUDE_CONFIG_DIR=${dir} claude attach ${sessionId}`;
 }
 /**
  * Transforma o dump de tela que o `claude logs` devolve em texto legivel.
@@ -736,10 +772,50 @@ function logsDaSessao(id, linhas = 60, ambiente = (0, runtime_ambiente_1.ambient
 /** Para uma sessao em background (o `claude stop` tambem trabalha com o id curto). */
 function parar(chave, ambiente = (0, runtime_ambiente_1.ambienteDeAssinatura)()) {
     const sessao = acharSessao(chave, listarSessoes(undefined, true, ambiente));
-    const id = sessao?.id ?? (sessao?.sessionId ?? chave).slice(0, 8);
-    const r = exec('claude', ['stop', id], undefined, 60000, ambiente);
+    return pararAchada(sessao ?? { sessionId: chave }, ambiente);
+}
+/** Para a sessao ja achada numa conta, com o ambiente dessa conta, sem listar de novo. */
+function pararAchada(sessao, ambiente = (0, runtime_ambiente_1.ambienteDeAssinatura)()) {
+    const r = exec('claude', ['stop', sessao.id ?? sessao.sessionId.slice(0, 8)], undefined, 60000, ambiente);
     return { ok: r.ok, texto: limparAnsi(r.stdout + r.stderr).trim() };
 }
+/**
+ * RM-037 (defeitosdeco D-2): o `claude agents` so lista a sessao para a conta que a despachou, entao
+ * uma chave e procurada no ambiente do processo e em cada perfil claude-bg informado, sem repetir
+ * diretorio efetivo. Consulta que falha nao vira "nao encontrada": vai para `falhas`.
+ */
+function acharSessaoNasContas(chave, perfis) {
+    const achadas = [], falhas = [], vistos = new Set();
+    // GO-FIX (R5a): cada consulta pode custar dezenas de segundos sob carga. UUID completo e unico em
+    // qualquer conta, entao a busca para na primeira que acha; prefixo ou nome consulta todas, para
+    // recusar a chave ambigua.
+    const unica = UUID_CLAUDE.test(chave);
+    for (const perfil of [null, ...perfis.filter(p => p.runtime === 'claude-bg')]) {
+        let ambiente, configDir;
+        try {
+            ambiente = ambienteDoPerfil(perfil);
+            configDir = path.resolve((0, runtime_profiles_1.diretorioEfetivo)('claude-bg', perfil, ambiente));
+        }
+        catch (e) {
+            falhas.push(`${perfil?.id ?? 'processo'}: ${e.message}`);
+            continue;
+        }
+        if (vistos.has(configDir))
+            continue;
+        vistos.add(configDir);
+        const consulta = consultarSessoes(undefined, true, ambiente);
+        if (!consulta.ok) {
+            falhas.push(`${perfil?.id ?? 'processo'}: ${consulta.detalhe}`);
+            continue;
+        }
+        const sessao = acharSessao(chave, consulta.sessoes);
+        if (sessao)
+            achadas.push({ sessao, perfil, configDir, ambiente });
+        if (sessao && unica)
+            break;
+    }
+    return { achadas, falhas };
+}
 /**
  * Ocupacao da janela de contexto de uma sessao, entre 0 e 1.
  *

package/dist/adapters/codex-controller-sensor.js

@@ -70,23 +70,47 @@ function conferirDiretorioDaFonte(dir, dirSessoes, uid) {
     }
     return real;
 }
+/**
+ * Quantas vezes a conferência lstat/abertura se repete quando o inode muda entre as duas. O worker
+ * grava o state.json por arquivo temporário e rename: cada gravação é um inode novo, e sob carga
+ * ela cai entre o lstat e o open. Só se aceita descritor cujo inode é o conferido; o limite impede
+ * laço sem fim contra quem troca o arquivo sem parar.
+ */
+const TENTATIVAS_DE_INODE = 5;
 /** Abre sem seguir link, confere descritor/inode, modo, dono e limite antes de decodificar. */
 function lerMetadado(dir, nome, uid, obrigatorio = true) {
     const file = path.join(dir, nome);
-    let antes;
-    try {
-        antes = fs.lstatSync(file);
-    }
-    catch (e) {
-        if (e.code === 'ENOENT' && !obrigatorio)
-            return null;
-        return recusar(`metadado ${nome} de controller ausente`);
+    for (let tentativa = 1;; tentativa++) {
+        let antes;
+        try {
+            antes = fs.lstatSync(file);
+        }
+        catch (e) {
+            if (e.code === 'ENOENT' && !obrigatorio)
+                return null;
+            return recusar(`metadado ${nome} de controller ausente`);
+        }
+        if (!antes.isFile() || antes.isSymbolicLink())
+            recusar(`metadado ${nome} de controller não é arquivo regular`);
+        const fd = fs.openSync(file, fs.constants.O_RDONLY | fs.constants.O_NOFOLLOW);
+        let st;
+        try {
+            st = fs.fstatSync(fd);
+        }
+        catch (e) {
+            fs.closeSync(fd);
+            throw e;
+        }
+        if (st.isFile() && (st.ino !== antes.ino || st.dev !== antes.dev) && tentativa < TENTATIVAS_DE_INODE) {
+            // Substituído por rename entre o lstat e o open: confere e abre de novo, do zero.
+            fs.closeSync(fd);
+            continue;
+        }
+        return lerDescritorConferido(fd, st, antes, nome, uid);
     }
-    if (!antes.isFile() || antes.isSymbolicLink())
-        recusar(`metadado ${nome} de controller não é arquivo regular`);
-    const fd = fs.openSync(file, fs.constants.O_RDONLY | fs.constants.O_NOFOLLOW);
+}
+function lerDescritorConferido(fd, st, antes, nome, uid) {
     try {
-        const st = fs.fstatSync(fd);
         if (!st.isFile() || st.ino !== antes.ino || st.dev !== antes.dev)
             recusar(`descritor de ${nome} divergente do inode conferido`);
         if (st.uid !== uid)
@@ -395,11 +419,14 @@ function registrarFonteController(dir, esperado) {
 }
 /** Releitura da fonte fixada. Nunca descobre outro processo, nem aceita override de rollout. */
 function lerSnapshotController(fonte, opcoes = {}) {
-    const agora = opcoes.agoraMs ?? Date.now();
     const real = conferirDiretorioDaFonte(fonte.dir, path.dirname(fonte.dir), fonte.uid);
     if (real !== fonte.dir)
         recusar('fonte de controller mudou de caminho real');
     const estado = conferirEstado(lerMetadado(real, 'state.json', fonte.uid), fonte);
+    // O relógio de referência é o do fim da leitura. O worker grava o close quando o runtime fecha,
+    // e isso pode acontecer entre o início desta releitura e a leitura do state.json: esse close não
+    // está no futuro. Com o relógio lido antes, ele era recusado e o watcher morria sem phase_result.
+    const agora = opcoes.agoraMs ?? Date.now();
     if (!mesmaIdentidade(identidadeValida(estado.processoController, fonte.uid), fonte.processoController))
         recusar('identidade do controller divergente da registrada');
     if (!mesmaIdentidade(identidadeValida(estado.processoRuntime, fonte.uid), fonte.processoRuntime))

package/dist/adapters/codex-events.js

@@ -12,7 +12,9 @@ const falha = () => ({ classificacao: 'gate_blocked', motivo: 'runtime.unavailab
 const sucesso = () => ({ classificacao: 'fase_concluida', motivo: null });
 const humano = () => ({ classificacao: 'human.pending', motivo: 'human.pending' });
 /** I-33 (D12): motivos da conta so saem de erro estruturado do runtime (`falhaDeContaDoErroCodex`). */
-const MOTIVOS_DA_CONTA = ['runtime.quota-exhausted', 'runtime.auth-missing'];
+const MOTIVOS_DA_CONTA = ['runtime.quota-exhausted', 'runtime.auth-missing',
+    // GO-FIX (R3, RM-037): o modelo inacessivel tambem so vale do erro estruturado, nunca do texto do agente.
+    'runtime.model-unavailable'];
 function motivo(v) {
     if (v === undefined || v === null)
         return null;

package/dist/conducao.js

@@ -33,7 +33,7 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ErroDeConducao = exports.ESPERA_PADRAO_MS = exports.PRAZO_DA_RESERVA_MS = exports.PRAZO_DE_SESSAO_PADRAO_MS = exports.MARGEM_DO_PRAZO_MS = exports.ENV_THREAD_DO_DESPACHO = exports.ENV_IDENTIDADE_DE_DESPACHO = exports.ENV_CANAL = exports.ERRO_CANAL_DESCONHECIDO = exports.CANAIS_DE_CONDUCAO = exports.conducaoDoLease = void 0;
+exports.ErroDeConducao = exports.ESPERA_PADRAO_MS = exports.PRAZO_DA_RESERVA_MS = exports.PRAZO_DE_SESSAO_PADRAO_MS = exports.MARGEM_DO_PRAZO_MS = exports.ENV_SESSAO_CLAUDE = exports.ENV_THREAD_DO_DESPACHO = exports.ENV_IDENTIDADE_DE_DESPACHO = exports.ENV_CANAL = exports.ERRO_CANAL_DESCONHECIDO = exports.CANAIS_DE_CONDUCAO = exports.conducaoDoLease = void 0;
 exports.validarCanal = validarCanal;
 exports.canalDoProcesso = canalDoProcesso;
 exports.ambienteDaConducao = ambienteDaConducao;
@@ -86,6 +86,9 @@ const maquina_1 = require("./maquina");
 const thread_1 = require("./thread");
 const horario_1 = require("./horario");
 const util_1 = require("./util");
+const runtime_ambiente_1 = require("./runtime-ambiente");
+Object.defineProperty(exports, "ENV_IDENTIDADE_DE_DESPACHO", { enumerable: true, get: function () { return runtime_ambiente_1.ENV_IDENTIDADE_DE_DESPACHO; } });
+Object.defineProperty(exports, "ENV_THREAD_DO_DESPACHO", { enumerable: true, get: function () { return runtime_ambiente_1.ENV_THREAD_DO_DESPACHO; } });
 // ---------------------------------------------------------------------------
 // Canais (D5, D6): registro fechado, declarado pela borda.
 // ---------------------------------------------------------------------------
@@ -146,21 +149,51 @@ function canalDoProcesso(explicito, ambiente = process.env) {
         return 'hermes';
     return 'cli';
 }
-// ---------------------------------------------------------------------------
-// Identidade de despacho (D4): a reentrada da sessao que ja conduz.
-// ---------------------------------------------------------------------------
-/** Identidade do despacho no ambiente da sessao filha, para as chamadas do CLI de dentro dela. */
-exports.ENV_IDENTIDADE_DE_DESPACHO = 'ORK_DISPATCH_ID';
-exports.ENV_THREAD_DO_DESPACHO = 'ORK_DISPATCH_THREAD';
 /** O que o despacho poe no ambiente da sessao filha: identidade, thread e canal de origem. */
 function ambienteDaConducao(identidade, threadId, canal) {
-    return { [exports.ENV_IDENTIDADE_DE_DESPACHO]: identidade, [exports.ENV_THREAD_DO_DESPACHO]: threadId, [exports.ENV_CANAL]: canal };
+    return { [runtime_ambiente_1.ENV_IDENTIDADE_DE_DESPACHO]: identidade, [runtime_ambiente_1.ENV_THREAD_DO_DESPACHO]: threadId, [exports.ENV_CANAL]: canal };
 }
-/** A identidade de despacho que este processo herdou, quando ela e desta thread. */
-function identidadeDoAmbiente(threadId, ambiente = process.env) {
-    const id = (ambiente[exports.ENV_IDENTIDADE_DE_DESPACHO] ?? '').trim();
-    const thread = (ambiente[exports.ENV_THREAD_DO_DESPACHO] ?? '').trim();
-    return /^[a-f0-9-]{36}$/.test(id) && thread === threadId ? id : null;
+/** Variavel que o Claude Code poe em cada sessao, com o UUID dela; nao vem do daemon. */
+exports.ENV_SESSAO_CLAUDE = 'CLAUDE_CODE_SESSION_ID';
+/**
+ * A identidade de despacho deste processo, quando ela e desta thread.
+ *
+ * RM-037 (defeitosdeco D-4): dentro de uma sessao Claude Code, o ambiente pode trazer o par de OUTRO
+ * despacho (o daemon do `claude --bg` guardava o do primeiro despacho da conta e o passava as sessoes
+ * reserva). Com `raiz`, a sessao se reconhece pelo ledger: vale o ultimo `phase_dispatch` desta thread
+ * com o `sessionId` dela. O par do ambiente so vale se bater com esse despacho; par que aponta para um
+ * despacho claude-bg de outra sessao e recusado, para nunca reentrar a conducao de quem nao e. Fora de
+ * sessao Claude, ou com despacho codex (processo proprio por despacho), vale o ambiente, como antes.
+ */
+function identidadeDoAmbiente(threadId, ambiente = process.env, raiz) {
+    const id = (ambiente[runtime_ambiente_1.ENV_IDENTIDADE_DE_DESPACHO] ?? '').trim();
+    const thread = (ambiente[runtime_ambiente_1.ENV_THREAD_DO_DESPACHO] ?? '').trim();
+    const doAmbiente = /^[a-f0-9-]{36}$/.test(id) && thread === threadId ? id : null;
+    const sessao = (ambiente[exports.ENV_SESSAO_CLAUDE] ?? '').trim();
+    if (!raiz || !/^[0-9a-f]{8}(?:-[0-9a-f]{4}){3}-[0-9a-f]{12}$/i.test(sessao))
+        return doAmbiente;
+    let eventos;
+    try {
+        eventos = (0, ledger_1.lerLedger)((0, thread_1.dirThread)(raiz, threadId));
+    }
+    catch {
+        return doAmbiente;
+    }
+    const despachoId = (e) => e.identidade?.dispatchId;
+    const despachos = eventos.filter(e => e.tipo === ledger_1.TIPOS_DE_EVENTO.faseDespachada);
+    const doPar = doAmbiente ? despachos.filter(e => despachoId(e) === doAmbiente).at(-1) : undefined;
+    // GO-FIX (R2 do CHECK): o codex despachado de dentro de uma sessao Claude herda o
+    // CLAUDE_CODE_SESSION_ID dela, mas o par do ambiente e do proprio processo codex, por despacho.
+    if (doPar?.runtime === 'codex')
+        return doAmbiente;
+    const daSessao = despachos.filter(e => e.sessionId === sessao && typeof despachoId(e) === 'string').at(-1);
+    if (daSessao)
+        return String(despachoId(daSessao));
+    if (!doAmbiente)
+        return null;
+    if (doPar && (doPar.runtime ?? 'claude-bg') === 'claude-bg' && typeof doPar.sessionId === 'string' && doPar.sessionId !== sessao)
+        return null;
+    return doAmbiente;
 }
 // ---------------------------------------------------------------------------
 // Prazos (D3): derivados do teto real da operacao; metadado, nunca prova.

package/dist/fix.js

@@ -196,7 +196,7 @@ function sobConducao(carregado, threadId, operacao, conducao, executar) {
         canal: conducao.canal ?? (0, conducao_1.canalDoProcesso)(),
         correlacao: conducao.correlacao ?? null,
         operacao,
-        identidade: conducao.identidade ?? (0, conducao_1.identidadeDoAmbiente)(threadId),
+        identidade: conducao.identidade ?? (0, conducao_1.identidadeDoAmbiente)(threadId, process.env, carregado.raiz),
         prazoMs: (0, conducao_1.prazoDaVerificacao)(carregado.manifesto.verify.timeout_ms ?? 10 * 60 * 1000, 8),
         esperarMs: conducao.esperarMs,
     }, executar);

package/dist/gates.js

@@ -44,6 +44,7 @@ exports.DESCRICAO_DO_MOTIVO = {
     'runtime.rate-limited': 'o runtime bateu o limite de uso da assinatura e a fase morreu antes de terminar (bloco B3: entra na fila duravel e e retomada na janela seguinte)',
     'runtime.quota-exhausted': 'a cota ou os creditos da conta do runtime acabaram (I-33: o perfil sai do rodizio e a fase segue em outro perfil, outro runtime ou na fila)',
     'runtime.auth-missing': 'a conta do runtime nao esta autenticada (I-33: o perfil nunca recebe despacho ate o login ser refeito pelo proprio CLI)',
+    'runtime.model-unavailable': 'o modelo pedido nao existe ou a conta nao tem acesso a ele (RM-037: o perfil segue no rodizio e a fase vai a outro perfil com o mesmo modelo ou ao fallback do bloco)',
     'cost.violation': 'o despacho seria redirecionado para provider pago (violacao de custo: e o unico motivo que NUNCA recebe retry automatico)',
     'tree.blocked': 'a arvore de destino nao esta disponivel para o merge (branch em check-out com alteracao nao commitada, ou worktree que nao pode ser montada)',
     'lease.busy': 'lease ocupado por outra thread',

package/dist/index.js

@@ -144,6 +144,8 @@ const licoes_1 = require("./licoes");
 const demo_1 = require("./demo");
 const entrega_pr_1 = require("./entrega-pr");
 /** A versao publicada em `@orkastery/cli`, lida do package.json (`versao.ts`). */
+// Antes de qualquer arquivo ou despacho: sem escrita de grupo nem de outros, que o sensor recusaria.
+(0, preflight_1.endurecerUmask)();
 const VERSAO = versao_1.VERSAO_DO_ORK;
 /** Parse simples de argumentos: `--chave valor`, `--chave=valor` e flags booleanas. */
 function parseArgs(argv) {
@@ -1219,17 +1221,17 @@ function comandoSessions(args) {
     }
     if (sub === 'logs') {
         const n = Number(texto(args.opcoes.linhas) ?? '60');
-        const r = (0, sessoes_2.logsDaSessao)(chave, Number.isFinite(n) ? n : 60);
+        const r = (0, sessoes_2.logsDaSessao)(chave, Number.isFinite(n) ? n : 60, carregado ? raiz : null);
         console.log(r.texto);
         return r.codigo;
     }
     if (sub === 'stop') {
-        const r = (0, sessoes_2.pararSessao)(chave);
+        const r = (0, sessoes_2.pararSessao)(chave, carregado ? raiz : null);
         console.log(r.texto);
         return r.codigo;
     }
     if (sub === 'attach') {
-        const r = (0, sessoes_2.comandoDeAttach)(chave);
+        const r = (0, sessoes_2.comandoDeAttach)(chave, carregado ? raiz : null);
         console.log(r.texto);
         return r.codigo;
     }

package/dist/mcp-git.js

@@ -33,6 +33,7 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.HOOKS_ESTRITOS = exports.HOOKS_DO_COMMIT = exports.HOOKS_INERTES_DO_COMMIT = void 0;
 exports.estadoGitMcp = estadoGitMcp;
 exports.commitMcp = commitMcp;
 exports.perfilGitMcp = perfil;
@@ -41,8 +42,8 @@ exports.caminhoFisicoGitMcp = fisico;
 exports.metadadosGitMcp = arvoreMetadados;
 exports.configuracaoPassivaGitMcp = configPassiva;
 exports.ambienteGitMcp = ambiente;
-/** Commit estreito no núcleo instalado. Repositórios com hooks/helpers ficam
- * explicitamente indisponíveis; nenhum hook ou configuração é desativado. */
+/** Commit estreito no núcleo instalado. Repositórios com hooks/helpers que as operações
+ * executariam ficam explicitamente indisponíveis; nenhum hook ou configuração é desativado. */
 const fs = __importStar(require("node:fs"));
 const path = __importStar(require("node:path"));
 const node_crypto_1 = require("node:crypto");
@@ -130,6 +131,10 @@ function configPassiva(chave, valor, credenciaisInertes = false) {
         return valor.length <= 8192 && !valor.includes('\0');
     if (['user.name', 'user.email'].includes(chave))
         return !!valor.trim() && valor.length <= 512 && !/[\x00-\x1f]/.test(valor);
+    // RM-037 (defeitosdeco D-3): a seção do próprio produto (por exemplo `orkastery.cortefeito`, lida
+    // pela trava do corte no pre-push). O Git nunca lê essa seção, então ela não executa nada.
+    if (/^orkastery\.[a-z0-9-]+$/.test(chave))
+        return valor.length <= 512 && !/[\x00-\x1f\x7f]/.test(valor);
     if (['core.filemode', 'core.logallrefupdates', 'core.ignorecase', 'core.precomposeunicode'].includes(chave))
         return /^(true|false)$/.test(valor);
     if (chave === 'core.repositoryformatversion')
@@ -195,7 +200,22 @@ function atributosPassivos(wt, id, selecionados) {
     }
     return resultados.join('\0');
 }
-function perfil(wt, comum, gitdir, id, selecionados) {
+/**
+ * RM-037 (defeitosdeco D-3): hooks que os comandos Git do status e do commit (`config`, `ls-files`,
+ * `check-attr`, `rev-parse`, `symbolic-ref`, `diff`, `diff-tree`, `add` e `commit` sem `--amend`)
+ * nunca invocam. Lista positiva: nome fora dela (`pre-commit`, `commit-msg`, `reference-transaction`,
+ * `post-index-change`, nome que o Git criar amanhã) continua recusado, e nada é desativado.
+ */
+exports.HOOKS_INERTES_DO_COMMIT = new Set(['pre-push', 'pre-rebase', 'post-checkout', 'post-merge',
+    'pre-receive', 'update', 'proc-receive', 'post-receive', 'post-update', 'push-to-checkout', 'applypatch-msg',
+    'pre-applypatch', 'post-applypatch', 'sendemail-validate', 'pre-merge-commit', 'post-rewrite',
+    'p4-changelist', 'p4-prepare-changelist', 'p4-post-changelist', 'p4-pre-submit']);
+exports.HOOKS_DO_COMMIT = { inertes: exports.HOOKS_INERTES_DO_COMMIT,
+    correcao: 'o commit do MCP o executaria; commite pelo shell da worktree, onde o hook roda como sempre' };
+/** Padrão estrito (SHIP): merge e push executariam qualquer hook, inclusive o pre-push. */
+exports.HOOKS_ESTRITOS = { inertes: new Set(),
+    correcao: 'o SHIP do MCP o executaria (merge ou push); entregue por PR com o bundle do ork ci prepare, ou pelo ork ship do CLI' };
+function perfil(wt, comum, gitdir, id, selecionados, hooksDaOperacao = exports.HOOKS_ESTRITOS) {
     fisico(path.dirname(comum), comum);
     fisico(comum, gitdir);
     for (const nome of ['objects', 'refs', 'logs', 'info'])
@@ -224,9 +244,11 @@ function perfil(wt, comum, gitdir, id, selecionados) {
         if (fs.lstatSync(hooks, { throwIfNoEntry: false })) {
             fisico(base, hooks);
             for (const nome of fs.readdirSync(hooks)) {
-                const f = path.join(hooks, nome), s = fs.lstatSync(f);
-                if (!s.isFile() || s.isSymbolicLink() || (!nome.endsWith('.sample') && (s.mode & 0o111) !== 0))
-                    falha('execution-profile.unsupported: hooks preservados');
+                const f = path.join(hooks, nome), s = fs.lstatSync(f), rotulo = nome.replace(/[^A-Za-z0-9._-]/g, '?').slice(0, 64);
+                if (!s.isFile() || s.isSymbolicLink())
+                    falha(`execution-profile.unsupported: hooks preservados (${rotulo} nao e arquivo regular)`);
+                if (!nome.endsWith('.sample') && (s.mode & 0o111) !== 0 && !hooksDaOperacao.inertes.has(nome))
+                    falha(`execution-profile.unsupported: hooks preservados (${rotulo}); ${hooksDaOperacao.correcao}`);
             }
         }
     }
@@ -259,7 +281,7 @@ function estadoGitMcp(raiz, threadId) {
     if (!match)
         falha('worktree.invalid');
     const comum = path.join(raiz, '.git'), gitdir = path.resolve(wt, match[1].trim());
-    perfil(wt, comum, gitdir, t.id, []);
+    perfil(wt, comum, gitdir, t.id, [], exports.HOOKS_DO_COMMIT);
     if ((0, estado_thread_1.raizDoEstado)(wt) !== raiz)
         falha('worktree.invalid');
     const branch = (0, worktree_1.branchDaWorktree)(t), destino = c.manifesto.worktree.base_branch;
@@ -300,10 +322,10 @@ function executar(raiz, p) {
         fisico(comum, gitdir);
         if ((0, estado_thread_1.raizDoEstado)(wt) !== raiz)
             falha('worktree.invalid');
-        const originalPerfil = perfil(wt, comum, gitdir, t.id, p.paths);
+        const originalPerfil = perfil(wt, comum, gitdir, t.id, p.paths, exports.HOOKS_DO_COMMIT);
         const conferir = () => {
             (0, mcp_artifacts_1.validarArquivosEstadoMcp)(raiz, t.id);
-            if (perfil(wt, comum, gitdir, t.id, p.paths) !== originalPerfil)
+            if (perfil(wt, comum, gitdir, t.id, p.paths, exports.HOOKS_DO_COMMIT) !== originalPerfil)
                 falha('execution-profile.changed');
             if (git(wt, ['rev-parse', 'HEAD']).trim() !== p.expectedHead)
                 falha('head.stale');
@@ -344,7 +366,7 @@ function executar(raiz, p) {
             git(wt, ['commit', '-m', p.mensagem, '--', ...p.paths]);
             commit = git(wt, ['rev-parse', 'HEAD']).trim();
         });
-        if (perfil(wt, comum, gitdir, t.id, p.paths) !== originalPerfil)
+        if (perfil(wt, comum, gitdir, t.id, p.paths, exports.HOOKS_DO_COMMIT) !== originalPerfil)
             falha('execution-profile.changed');
         estadoAuditado = (0, estado_thread_1.auditarEstado)(raiz, t.id, wt).nivel === 'ok';
         if (!estadoAuditado)

package/dist/preflight.js

@@ -33,6 +33,7 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.endurecerUmask = endurecerUmask;
 exports.umaskDoProcesso = umaskDoProcesso;
 exports.sondasDeAmbiente = sondasDeAmbiente;
 exports.checkDeContas = checkDeContas;
@@ -61,6 +62,18 @@ const sensoresPadrao = {
     sandboxCodex: () => (0, codex_2.sondarSandbox)().ok,
     auth: authPadrao,
 };
+/**
+ * O sensor recusa fonte com escrita de grupo ou de outros (bits 0o022). O ork acrescenta esses bits
+ * ao umask do proprio processo, sem nunca afrouxar um umask mais restrito (077 continua 077): tudo o
+ * que ele cria, e tudo o que ele despacha (claude, codex), nasce sem escrita alheia, qualquer que
+ * seja o umask do shell de quem roda. Devolve o umask anterior e o que ficou valendo.
+ */
+function endurecerUmask() {
+    const anterior = process.umask(0o077);
+    const atual = anterior | 0o022;
+    process.umask(atual);
+    return { anterior, atual };
+}
 /** umask efetivo do processo, lido de /proc (Linux) para nao usar o getter deprecado. */
 function umaskDoProcesso() {
     try {

package/dist/ratelimit.js

@@ -144,7 +144,7 @@ function enfileirar(carregado, novo, agoraMs = Date.now()) {
  * ela, a janela padrao do manifesto (estimativa declarada, nunca chute). Auth ausente: sem prazo.
  */
 function prazoDaConta(manifesto, falha, agoraMs = Date.now()) {
-    if (falha.motivo === 'runtime.auth-missing')
+    if (falha.motivo !== 'runtime.quota-exhausted')
         return null;
     // A10: horario dito que ja passou nao devolve o perfil ao rodizio na hora: vale a janela padrao.
     if (falha.resetEm !== null && Date.parse(falha.resetEm) > agoraMs)
@@ -153,7 +153,8 @@ function prazoDaConta(manifesto, falha, agoraMs = Date.now()) {
 }
 /** Marca no store o perfil que falhou pela conta. Sem perfil (ambiente do processo), nada a marcar. */
 function marcarContaDaFalha(carregado, perfil, falha, agoraMs = Date.now()) {
-    if (!perfil)
+    // RM-037 (defeitosdeco D-6): modelo inacessivel nao e falha da conta inteira; o perfil fica no rodizio.
+    if (!perfil || falha.motivo === 'runtime.model-unavailable')
         return null;
     const esgotado = falha.motivo === 'runtime.quota-exhausted';
     return (0, runtime_profiles_1.marcarFalhaDePerfil)(carregado.raiz, perfil.id, { estado: esgotado ? 'esgotado' : 'sem-auth',

package/dist/retry.js

@@ -93,6 +93,7 @@ const policies_1 = require("./policies");
 const ratelimit_1 = require("./ratelimit");
 const session_watcher_claude_1 = require("./session-watcher-claude");
 const runtime_profiles_1 = require("./runtime-profiles");
+const modos_1 = require("./modos");
 const thread_1 = require("./thread");
 const tokens_1 = require("./tokens");
 const util_1 = require("./util");
@@ -241,6 +242,15 @@ exports.POLITICA_DE_RETRY = {
         porque: 'a conta do runtime perdeu a autenticacao: o perfil nunca mais recebe despacho ate o login ser refeito pelo proprio CLI, e o MESMO prompt segue no proximo perfil ou no runtime de fallback',
         correcao: 'ork accounts check confere o login de cada perfil; ork retry run <thread> rotaciona o prompt ja gravado',
     },
+    // RM-037 (defeitosdeco D-6): o modelo e que falta, nao a conta. Repetir o mesmo modelo na mesma conta
+    // so repete a recusa; o perfil continua no rodizio para os outros modelos.
+    'runtime.model-unavailable': {
+        motivo: 'runtime.model-unavailable',
+        acao: 'reexecutar',
+        automatica: true,
+        porque: 'o modelo pedido nao existe ou a conta nao tem acesso a ele: o MESMO prompt, com o mesmo sha256, segue no proximo perfil do mesmo runtime com o mesmo modelo e depois no fallback do bloco, nunca de novo no par que ja recusou',
+        correcao: 'ork retry run <thread> troca o destino; sem destino, ork setup <modo> --bloco N --model <modelo acessivel> ou --fallback runtime:modelo',
+    },
     'tree.blocked': {
         motivo: 'tree.blocked',
         acao: 'sincronizar-worktree',
@@ -1218,6 +1228,9 @@ function executarRetry(carregado, threadId, opcoes = {}) {
     if (plano.motivo === 'runtime.quota-exhausted' || plano.motivo === 'runtime.auth-missing') {
         return rotacionarConta(carregado, thread, plano, opcoes, vazio, registrarTentativa);
     }
+    if (plano.motivo === 'runtime.model-unavailable') {
+        return trocarDestinoDoModelo(carregado, thread, plano, opcoes, vazio, registrarTentativa);
+    }
     // `reexecutar` e `escalar-esforco`: o MESMO prompt volta ao runtime.
     const falho = ultimoDespachoFalho(raiz, threadId, plano.fase, plano.motivo === 'runtime.silencio');
     if (!falho || typeof falho.promptPath !== 'string' || typeof falho.promptSha256 !== 'string') {
@@ -1337,7 +1350,10 @@ function rotacionarConta(carregado, thread, plano, opcoes, vazio, registrarTenta
         else
             implicitos.push(alvo.runtime);
         atual = { runtime: alvo.runtime, perfil: alvo.perfil };
-        falhaAtual = ultimo.falhaDeConta ?? falhaAtual;
+        // GO-FIX (R4b): destino que recusou o MODELO sai da rotacao, mas a falha que manda (e o motivo da
+        // fila) continua sendo a da conta; o modelo inacessivel tem troca propria (trocarDestinoDoModelo).
+        if (ultimo.falhaDeConta?.motivo !== 'runtime.model-unavailable')
+            falhaAtual = ultimo.falhaDeConta ?? falhaAtual;
         if (tentativas >= plano.limite) {
             return escalar('limite de tentativas na rotacao', `${tentativas} tentativa(s) de rotacao por ${motivo} em ${fase}, no limite de ` +
                 `${plano.limite} do manifesto: escalacao tipada pausa qualquer modo`);
@@ -1369,6 +1385,168 @@ function rotacionarConta(carregado, thread, plano, opcoes, vazio, registrarTenta
     registrarTentativa(true, `fila duravel: pedido ${pedido.id} libera em ${pedido.liberaEm}`);
     return { ...vazio, executada: true, fila: [pedido], redespacho: ultimo, detalhe: `pedido ${pedido.id} na fila ate ${pedido.liberaEm}` };
 }
+/** RM-037 (defeitosdeco D-6): chave de um destino (runtime, perfil, modelo) que recusou o modelo. */
+function chaveDoModelo(runtime, perfil, model) {
+    return `${runtime}|${perfil ?? ''}|${model ?? ''}`;
+}
+/**
+ * D-6: todo destino que ja recusou o modelo nesta fase, lido do ledger. O gate do observador traz o
+ * `sessionId` (o modelo vem do `phase_dispatch` dele); o do despacho sincrono, o ultimo
+ * `phase_dispatch_failed` da fase antes dele.
+ */
+function destinosQueRecusaramOModelo(eventos, fase) {
+    const chaves = [];
+    const chaveDo = (origem) => {
+        if (typeof origem.runtime !== 'string')
+            return null;
+        let perfil = null;
+        try {
+            perfil = perfilDoEvento(origem);
+        }
+        catch { /* perfil ilegivel nao exclui ninguem */ }
+        return chaveDoModelo(origem.runtime, perfil?.id ?? null, typeof origem.model === 'string' ? origem.model : null);
+    };
+    eventos.forEach((e, i) => {
+        // GO-FIX (R4a): a recusa sincrona do redespacho (nada rodou) so grava `phase_dispatch_failed`.
+        if (e.tipo === ledger_1.TIPOS_DE_EVENTO.despachoFalhou && e.fase === fase && String(e.erro ?? '').startsWith('runtime.model-unavailable')) {
+            const chave = chaveDo(e);
+            if (chave)
+                chaves.push(chave);
+            return;
+        }
+        if (e.tipo !== ledger_1.TIPOS_DE_EVENTO.gateBloqueado || e.fase !== fase || e.motivo !== 'runtime.model-unavailable')
+            return;
+        const origem = typeof e.sessionId === 'string'
+            ? eventos.filter(d => d.tipo === ledger_1.TIPOS_DE_EVENTO.faseDespachada && d.sessionId === e.sessionId).at(-1)
+            : eventos.slice(0, i).filter(d => d.tipo === ledger_1.TIPOS_DE_EVENTO.despachoFalhou && d.fase === fase).at(-1);
+        const chave = origem ? chaveDo(origem) : null;
+        if (chave)
+            chaves.push(chave);
+    });
+    return chaves;
+}
+/**
+ * D-6: o proximo destino do MESMO prompt depois de `runtime.model-unavailable`. Primeiro outro perfil do
+ * mesmo runtime com o MESMO modelo (outra conta pode ter acesso), depois cada runtime da ordem de
+ * fallback do bloco com o modelo dele. Perfil fora do rodizio (esgotado, sem login, desativado, pago)
+ * nao entra, e nenhum destino que ja recusou volta. Sem destino, `null`.
+ */
+function proximoDestinoDoModelo(raiz, runtime, model, fallback, recusados) {
+    const store = (0, runtime_profiles_1.lerPerfisComContas)(raiz);
+    const utilizavel = (p) => !['desativado', 'provider-pago', 'sem-auth'].includes(p.estado) && (0, runtime_profiles_1.perfilDisponivel)(p);
+    const mesmo = (0, runtime_profiles_1.perfisDoRuntime)(store, runtime).find(p => utilizavel(p) && !recusados.has(chaveDoModelo(runtime, p.id, model)));
+    if (mesmo)
+        return { runtime, perfil: (0, runtime_profiles_1.perfilDeDespacho)(mesmo), model, effort: null };
+    for (const f of fallback) {
+        const perfis = (0, runtime_profiles_1.perfisDoRuntime)(store, f.runtime);
+        if (perfis.length) {
+            const p = perfis.find(x => utilizavel(x) && !recusados.has(chaveDoModelo(f.runtime, x.id, f.model)));
+            if (p)
+                return { runtime: f.runtime, perfil: (0, runtime_profiles_1.perfilDeDespacho)(p), model: f.model, effort: f.effort ?? null };
+            continue;
+        }
+        if (!recusados.has(chaveDoModelo(f.runtime, null, f.model)))
+            return { runtime: f.runtime, perfil: null, model: f.model, effort: f.effort ?? null };
+    }
+    return null;
+}
+/** D-6: a correcao exata quando nenhum destino tem o modelo: o bloco do setup que conduz a fase. */
+function correcaoDoModelo(thread, fase) {
+    const indice = modos_1.MODOS[thread.modo]?.blocos.findIndex(b => b.fases.includes(fase)) ?? -1;
+    const bloco = indice >= 0 ? String(indice + 1) : 'N';
+    return `ork setup ${thread.modo} --bloco ${bloco} --model <modelo acessivel>, ou declare no mesmo bloco --fallback runtime:modelo`;
+}
+/**
+ * RM-037 (defeitosdeco D-6): troca de destino depois de `runtime.model-unavailable`. O modelo pedido nao
+ * existe ou a conta nao tem acesso a ele (`model_not_found` na transcricao); o perfil continua no
+ * rodizio e o MESMO prompt segue no proximo destino (`proximoDestinoDoModelo`). Producao no intervalo
+ * escala ao humano, como na rotacao por conta. Recusa do modelo no redespacho (nada rodou) continua a
+ * troca na mesma chamada, dentro do limite de tentativas. Sem destino, o humano recebe a correcao exata.
+ */
+function trocarDestinoDoModelo(carregado, thread, plano, opcoes, vazio, registrarTentativa) {
+    const { raiz, manifesto } = carregado;
+    const dir = (0, thread_1.dirThread)(raiz, thread.id);
+    const fase = plano.fase;
+    const motivo = 'runtime.model-unavailable';
+    const eventos = (0, ledger_1.lerLedger)(dir);
+    const gate = ultimaReprovacao(raiz, thread.id);
+    const despacho = despachoDaFalha(eventos, gate, fase);
+    const escalar = (razao, diagnostico) => {
+        if (!opcoes.dryRun) {
+            (0, gates_1.registrarGateBloqueado)(dir, thread.id, { gate: 'phase.dispatch', motivo: 'human.pending', modo: thread.modo, detalhe: diagnostico,
+                diagnostico, correcao: `ork gate request ${thread.id}`, fase, origem: 'retry.modelo', pausaQualquerModo: true });
+            (0, ledger_1.registrar)(dir, thread.id, ledger_1.TIPOS_DE_EVENTO.retryEscalado, { fase, motivo, origem: 'retry.modelo', acao: plano.acao,
+                tentativas: plano.tentativas, limite: plano.limite, modo: thread.modo, razao });
+        }
+        return { ...vazio, detalhe: diagnostico };
+    };
+    if (!despacho || typeof despacho.promptPath !== 'string' || typeof despacho.promptSha256 !== 'string') {
+        const detalhe = `nao ha despacho com prompt gravado para ${motivo} em ${fase}: rode a fase de novo com ork phase run`;
+        registrarTentativa(false, detalhe);
+        return { ...vazio, detalhe };
+    }
+    const runtime = typeof despacho.runtime === 'string' ? despacho.runtime : manifesto.runtime.adapter;
+    const model = typeof despacho.model === 'string' ? despacho.model : null;
+    const rotulo = model ?? '(padrao do runtime)';
+    let perfil;
+    try {
+        perfil = typeof gate?.sessionId === 'string'
+            ? (0, runtime_profiles_1.perfilDoRegistro)(eventos, { sessionId: gate.sessionId, despachadaEm: typeof gate.despachoEm === 'string' ? gate.despachoEm : undefined })
+            : perfilDoEvento(despacho);
+    }
+    catch (e) {
+        return escalar('perfil registrado invalido', `troca de destino recusada: ${e.message}`);
+    }
+    if (typeof gate?.sessionId === 'string' && typeof gate.despachoEm === 'string') {
+        const producao = producaoNoIntervalo(raiz, thread, { sessionId: gate.sessionId, fase, despachadaEm: gate.despachoEm }, eventos);
+        if (producao.produziu) {
+            return escalar('producao parcial com modelo inacessivel', `producao parcial com o modelo ${rotulo} inacessivel: ${producao.evidencia}; ` +
+                'a sessao nao e redespachada sobre a worktree alterada e a fase nao conclui sem o humano');
+        }
+    }
+    const recusados = new Set([...destinosQueRecusaramOModelo(eventos, fase), chaveDoModelo(runtime, perfil?.id ?? null, model)]);
+    const doBloco = (0, setup_1.configDoBloco)((0, setup_1.lerSetup)(raiz), thread.modo, fase);
+    const fallback = alvosDeFallback(doBloco, doBloco?.runtime ?? manifesto.runtime.adapter);
+    let atual = { runtime, perfil, model };
+    let tentativas = plano.tentativas;
+    for (;;) {
+        const alvo = proximoDestinoDoModelo(raiz, runtime, model, fallback, recusados);
+        if (!alvo)
+            break;
+        if (!opcoes.dryRun)
+            (0, ledger_1.registrar)(dir, thread.id, ledger_1.TIPOS_DE_EVENTO.perfilRotacionado, { fase, motivo, origem: 'retry.modelo',
+                de: { runtime: atual.runtime, perfil: atual.perfil?.id ?? null, model: atual.model },
+                para: { runtime: alvo.runtime, perfil: alvo.perfil?.id ?? null, model: alvo.model },
+                razao: alvo.runtime === runtime ? 'outro perfil do mesmo runtime com o mesmo modelo' : 'fallback de runtime pela ordem do bloco',
+                promptSha256: despacho.promptSha256, modo: thread.modo,
+                autorizadoPor: `politica de retry da RM-037 (D-6), bloco sem pausa ou delegado no modo ${thread.modo}` });
+        const mudouRuntime = alvo.runtime !== runtime;
+        const r = redespachar(carregado, thread, fase, despacho.promptPath, despacho.promptSha256, {
+            runtime: alvo.runtime, perfil: alvo.perfil?.id ?? null, model: alvo.model,
+            effort: mudouRuntime ? alvo.effort ?? (typeof despacho.effort === 'string' ? despacho.effort : null) : plano.effort,
+            origem: 'retry.modelo', dryRun: opcoes.dryRun,
+        });
+        if (opcoes.dryRun)
+            return { ...vazio, redespacho: r, detalhe: `ensaio: o mesmo prompt iria a ${alvo.runtime}` +
+                    `${alvo.perfil ? ` (perfil ${alvo.perfil.id})` : ''} com o modelo ${alvo.model ?? '(padrao do runtime)'}; ${r.detalhe}` };
+        registrarTentativa(r.ok, r.detalhe);
+        tentativas += 1;
+        if (r.ok)
+            return { ...vazio, executada: true, redespacho: r, detalhe: r.detalhe };
+        // So a recusa do MODELO no redespacho (nada rodou) continua a troca; outra falha para aqui.
+        if (r.falhaDeConta?.motivo !== 'runtime.model-unavailable')
+            return { ...vazio, redespacho: r, detalhe: r.detalhe };
+        recusados.add(chaveDoModelo(alvo.runtime, alvo.perfil?.id ?? null, alvo.model));
+        atual = { runtime: alvo.runtime, perfil: alvo.perfil, model: alvo.model };
+        if (tentativas >= plano.limite) {
+            return escalar('limite de tentativas na troca de modelo', `${tentativas} tentativa(s) de troca por ${motivo} em ${fase}, no limite de ` +
+                `${plano.limite} do manifesto: escalacao tipada pausa qualquer modo`);
+        }
+    }
+    const tentados = [...recusados].map(k => { const [rt, p, m] = k.split('|'); return `${rt}${p ? `/${p}` : ''}:${m || '(padrao)'}`; });
+    return escalar('modelo inacessivel sem outro destino', `o modelo ${rotulo} nao esta acessivel em ${tentados.join(', ')} e o bloco ` +
+        `nao tem outro destino: ${correcaoDoModelo(thread, fase)}`);
+}
 /** Texto de `ork retry plan`. */
 function textoDoPlano(p) {
     const linhas = [];

package/dist/runtime-ambiente.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ENVS_DE_PROVIDER_PAGO = void 0;
+exports.ENV_THREAD_DO_DESPACHO = exports.ENV_IDENTIDADE_DE_DESPACHO = exports.ENVS_DE_PROVIDER_PAGO = void 0;
 exports.nomesDeProviderAtivos = nomesDeProviderAtivos;
 exports.ambienteDeAssinatura = ambienteDeAssinatura;
 const hitl_public_receipt_1 = require("./hitl-public-receipt");
@@ -20,6 +20,13 @@ exports.ENVS_DE_PROVIDER_PAGO = [
 function nomesDeProviderAtivos(base = process.env) {
     return exports.ENVS_DE_PROVIDER_PAGO.filter(nome => (base[nome] ?? '').trim() !== '');
 }
+/**
+ * Identidade do despacho no ambiente da sessao filha (I-36, D4). RM-037 (defeitosdeco D-4): o domicilio
+ * dos nomes e aqui porque nenhum filho de runtime herda a identidade de quem despachou; o despacho
+ * acrescenta a sua explicitamente, e o `claude --bg` a leva por sessao em `--settings`.
+ */
+exports.ENV_IDENTIDADE_DE_DESPACHO = 'ORK_DISPATCH_ID';
+exports.ENV_THREAD_DO_DESPACHO = 'ORK_DISPATCH_THREAD';
 /** Copia, sem alterar o ambiente em que as policies ainda precisam ser avaliadas. */
 function ambienteDeAssinatura(base = process.env) {
     const env = { ...base };
@@ -31,6 +38,10 @@ function ambienteDeAssinatura(base = process.env) {
     for (const nome of Object.keys(env))
         if (nome.startsWith('ORK_HITL_'))
             delete env[nome];
+    // RM-037 (defeitosdeco D-4): a identidade herdada e de OUTRO despacho (o daemon do `claude --bg`
+    // guardava a do primeiro despacho e a passava a todas as sessoes reserva da conta).
+    delete env[exports.ENV_IDENTIDADE_DE_DESPACHO];
+    delete env[exports.ENV_THREAD_DO_DESPACHO];
     delete env[hitl_public_receipt_1.ENV_HITL_VERIFIERS];
     if (publicVerifiers)
         env[hitl_public_receipt_1.ENV_HITL_VERIFIERS] = publicVerifiers;

package/dist/session-watcher-claude.js

@@ -158,6 +158,20 @@ function classificarSessaoClaude(e) {
                 : { terminal: true, classificacao: 'fase_concluida', motivo: null, fonte: `${sinal}; ${prova.fonte}`, conclusaoNativa, stop };
         return { ...c, dependeDoStop: true };
     };
+    // RM-037 (defeitosdeco D-1): turno encerrado pelo Stop e sessão viva em `blocked` é o Claude Code
+    // dizendo que o texto final pediu resposta. Nunca conclui direto, e a pausa humana abre sempre
+    // (`human.pending`): GO-FIX (R6 do CHECK), sem a prova o motivo também é o humano, porque um
+    // `artifact.missing` automático abriria correção sobre uma sessão viva que espera resposta.
+    const esperaHumana = () => {
+        const sinal = 'Stop correlacionado e sessão viva à espera humana (blocked)';
+        const prova = e.prova();
+        const c = !prova.ok
+            ? { ...bloqueio(`${sinal}; sem prova do ork: ${prova.fonte}; o humano decide`, 'human.pending'),
+                diagnostico: `a sessão espera resposta humana (blocked) e a fase ainda não tem a prova do ork: ${prova.fonte}` }
+            : { ...bloqueio(`${sinal}; ${prova.fonte}; o humano decide`, 'human.pending'),
+                diagnostico: 'a fase tem a prova do ork e a sessão espera resposta humana (blocked): o humano decide' };
+        return { ...c, dependeDoStop: true };
+    };
     const venceu = (desde) => agora - desde >= e.limiteMs;
     // Sem prova para concluir nem para bloquear: `runtime.unavailable` reexecutaria o mesmo prompt
     // sobre uma fase que pode ter terminado. O observador encerra sem gate e o radar de liveness
@@ -183,6 +197,8 @@ function classificarSessaoClaude(e) {
         delete cursor.doneDesde;
     if (estado !== 'working' && estado !== 'blocked')
         delete cursor.mortoDesde;
+    if (estado !== 'blocked')
+        delete cursor.bloqueadoDesde;
     if (['done', 'failed', 'stopped', 'working', 'blocked'].includes(estado ?? ''))
         delete cursor.desconhecidoDesde;
     switch (estado) {
@@ -220,6 +236,16 @@ function classificarSessaoClaude(e) {
                 return bloqueio(`processo da sessão morreu sem terminal nativo nem Stop correlacionado (estado ${estado})`);
             }
             delete cursor.mortoDesde;
+            // D-1: a segunda leitura, com pelo menos um intervalo do observador, separa o `blocked` estável
+            // de um instante de transição logo depois do Stop. `status` ocupado ainda é trabalho.
+            const ocupado = ['busy', 'running', 'working'].includes(r.status ?? '');
+            if (estado === 'blocked' && stop && !bloqueioPendente(e.eventos, e.sessao) && !ocupado) {
+                cursor.bloqueadoDesde ??= agora;
+                if (agora - cursor.bloqueadoDesde < exports.INTERVALO_WATCH_CLAUDE_MS)
+                    return espera('turno encerrado pelo Stop com a sessão à espera humana (blocked); aguardando a segunda observação');
+                return esperaHumana();
+            }
+            delete cursor.bloqueadoDesde;
             return espera(estado === 'blocked' ? 'sessão bloqueada à espera humana' : 'sessão trabalhando');
         }
         default:

package/dist/session-watcher.js

@@ -183,6 +183,11 @@ function comLockWatcher(dir, action) {
         }
     }
 }
+/**
+ * `agoraMs` só vem quando o relógio é injetado. Sem ele, a referência de "evento do futuro" é o
+ * relógio depois da leitura: a linha que o runtime anexou durante a observação não é futura, e
+ * descartá-la perdia o terminal do turno.
+ */
 function lerFonte(file, anterior, agoraMs, sessionId, fixada) {
     const fd = fs.openSync(file, fixada
         ? fs.constants.O_RDONLY | fs.constants.O_NOFOLLOW | fs.constants.O_NONBLOCK : 'r');
@@ -206,6 +211,7 @@ function lerFonte(file, anterior, agoraMs, sessionId, fixada) {
         let offset = mesmo ? anterior.offset : 0;
         const buffer = Buffer.alloc(Math.min(exports.BLOCO_WATCH_BYTES, stat.size - offset));
         const n = fs.readSync(fd, buffer, 0, buffer.length, offset);
+        const agora = agoraMs ?? Date.now();
         const fim = buffer.subarray(0, n).lastIndexOf(10);
         let terminal = mesmo ? anterior.terminal : null;
         if (fim >= 0) {
@@ -221,7 +227,7 @@ function lerFonte(file, anterior, agoraMs, sessionId, fixada) {
                     (e?.type === 'session_meta' && e.payload?.id !== sessionId))
                     throw new Error('log/rollout pertence a outra sessão');
             }
-            for (const t of parser.push(buffer.subarray(0, fim + 1), agoraMs))
+            for (const t of parser.push(buffer.subarray(0, fim + 1), agora))
                 terminal = t;
             offset += fim + 1;
         }
@@ -235,7 +241,7 @@ function lerFonte(file, anterior, agoraMs, sessionId, fixada) {
         const parcial = n < exports.BLOCO_WATCH_BYTES && stat.size > offset;
         return { cursor: { file, ino: stat.ino, tamanho: stat.size, offset, parser: parser.estado, terminal, parcial },
             cresceu: parser.eventosValidos > 0,
-            quando: Math.min(agoraMs, stat.mtimeMs), bytes: n, temMais: stat.size > offset };
+            quando: Math.min(agora, stat.mtimeMs), bytes: n, temMais: stat.size > offset };
     }
     finally {
         fs.closeSync(fd);
@@ -352,7 +358,8 @@ function observarSessao(carregado, sessionId, opcoes = {}) {
                     fixacao: path.join(dir, 'sessoes', `watcher-source-${chave}.json`),
                     vinculo: { thread: thread.id, fase: sessao.fase, promptSha256: sessao.promptSha256 }
                 });
-                snapshot = (0, codex_controller_sensor_1.lerSnapshotController)(fonteControlador, { agoraMs: now });
+                // Relógio injetado vale como está; o real é lido pelo sensor depois do state.json.
+                snapshot = (0, codex_controller_sensor_1.lerSnapshotController)(fonteControlador, opcoes.agoraMs === undefined ? {} : { agoraMs: now });
             }
             const file = path.join(pasta, 'cursor.json');
             const cursor = lerJson(file) ?? { schema: 'ork.session-cursor/v1', sessionId,
@@ -370,7 +377,7 @@ function observarSessao(carregado, sessionId, opcoes = {}) {
                     continue;
                 let leitura;
                 try {
-                    leitura = lerFonte(fonte, cursor.fontes[nome], now, sessionId, nome === 'rollout' ? fonteControlador ?? undefined : undefined);
+                    leitura = lerFonte(fonte, cursor.fontes[nome], opcoes.agoraMs === undefined ? undefined : now, sessionId, nome === 'rollout' ? fonteControlador ?? undefined : undefined);
                 }
                 catch (e) {
                     if (nome !== 'rollout' || e.message !== 'log/rollout pertence a outra sessão')

package/dist/sessoes.js

@@ -46,6 +46,7 @@ exports.pararSessao = pararSessao;
 exports.comandoDeAttach = comandoDeAttach;
 const adapter = __importStar(require("./adapters/claude-bg"));
 const sessoes_inventario_1 = require("./sessoes-inventario");
+const runtime_profiles_1 = require("./runtime-profiles");
 const util_1 = require("./util");
 function textoDoInventario(r) {
     const linhas = [
@@ -63,23 +64,56 @@ function textoDoInventario(r) {
 function tabelaDeSessoes(raiz, todas = false) {
     return textoDoInventario((0, sessoes_inventario_1.inventariarSessoes)(raiz, { todas }));
 }
-/** Logs de uma sessao pelo id curto, id completo ou nome. */
-function logsDaSessao(chave, linhas) {
-    const r = adapter.logs(chave, linhas);
+/**
+ * RM-037 (defeitosdeco D-2): a sessao pelo id curto, id completo ou nome, procurada no ambiente do
+ * processo e em cada perfil claude-bg do projeto (inclusive desativado, que ainda pode ter sessao
+ * viva). So uma conta pode responder; duas viram recusa, nenhuma mantem a mensagem de antes.
+ */
+function localizarSessao(chave, raiz) {
+    let perfis = [];
+    const falhas = [];
+    if (raiz) {
+        try {
+            perfis = (0, runtime_profiles_1.lerPerfis)(raiz).perfis.filter(p => p.runtime === 'claude-bg').map(runtime_profiles_1.perfilDeDespacho);
+        }
+        catch (e) {
+            falhas.push(`perfis: ${e.message}`);
+        }
+    }
+    const r = adapter.acharSessaoNasContas(chave, perfis);
+    falhas.push(...r.falhas);
+    if (r.achadas.length === 1)
+        return { achada: r.achadas[0] };
+    if (r.achadas.length > 1) {
+        const contas = r.achadas.map(a => `${a.perfil?.id ?? 'processo'} (${a.sessao.sessionId})`).join(', ');
+        return { texto: `sessao "${chave}" encontrada em mais de uma conta: ${contas}; use o id completo`, codigo: 1 };
+    }
+    return { texto: `sessao "${chave}" nao encontrada no runtime` + (falhas.length ? `; contas sem resposta: ${falhas.join('; ')}` : ''),
+        codigo: 1 };
+}
+/** Logs de uma sessao pelo id curto, id completo ou nome, lidos na conta onde ela esta. */
+function logsDaSessao(chave, linhas, raiz) {
+    const l = localizarSessao(chave, raiz);
+    if (!('achada' in l))
+        return l;
+    const { sessao, ambiente } = l.achada;
+    const r = adapter.logsDaSessao(sessao.id ?? sessao.sessionId.slice(0, 8), linhas, ambiente);
     return { texto: r.texto, codigo: r.ok ? 0 : 1 };
 }
-/** Para uma sessao pelo id curto, id completo ou nome. */
-function pararSessao(chave) {
-    const s = adapter.acharSessao(chave);
-    if (!s)
-        return { texto: `sessao "${chave}" nao encontrada no runtime`, codigo: 1 };
-    const r = adapter.parar(s.id ?? s.sessionId);
-    return { texto: r.texto || `sessao ${s.sessionId} parada`, codigo: r.ok ? 0 : 1 };
+/** Para uma sessao pelo id curto, id completo ou nome, com o `CLAUDE_CONFIG_DIR` da conta dela. */
+function pararSessao(chave, raiz) {
+    const l = localizarSessao(chave, raiz);
+    if (!('achada' in l))
+        return l;
+    const { sessao, perfil, ambiente } = l.achada;
+    const r = adapter.pararAchada(sessao, ambiente);
+    return { texto: r.texto || `sessao ${sessao.sessionId} parada${perfil ? ` (perfil ${perfil.id})` : ''}`, codigo: r.ok ? 0 : 1 };
 }
 /** Comando de attach (precisa de TTY, entao o CLI imprime em vez de executar). */
-function comandoDeAttach(chave) {
-    const s = adapter.acharSessao(chave);
-    if (!s)
-        return { texto: `sessao "${chave}" nao encontrada no runtime`, codigo: 1 };
-    return { texto: adapter.comandoAttach(s.sessionId), codigo: 0 };
+function comandoDeAttach(chave, raiz) {
+    const l = localizarSessao(chave, raiz);
+    if (!('achada' in l))
+        return l;
+    const { sessao, perfil, configDir } = l.achada;
+    return { texto: adapter.comandoAttach(sessao.sessionId, perfil ? configDir : null), codigo: 0 };
 }

package/dist/verify.js

@@ -191,7 +191,7 @@ function pedidoDoVerify(carregado, threadId, operacao, comandos, conducao) {
         canal: conducao.canal ?? (0, conducao_1.canalDoProcesso)(),
         correlacao: conducao.correlacao ?? null,
         operacao,
-        identidade: conducao.identidade ?? (0, conducao_1.identidadeDoAmbiente)(threadId),
+        identidade: conducao.identidade ?? (0, conducao_1.identidadeDoAmbiente)(threadId, process.env, carregado.raiz),
         prazoMs: (0, conducao_1.prazoDaVerificacao)(carregado.manifesto.verify.timeout_ms ?? exports.TIMEOUT_VERIFY_MS, comandos),
         esperarMs: conducao.esperarMs,
     };

package/dist/worktree.js

@@ -52,6 +52,7 @@ exports.worktreesDoGit = worktreesDoGit;
 exports.registradaNoGit = registradaNoGit;
 exports.arvoreLimpa = arvoreLimpa;
 exports.garantirWorktree = garantirWorktree;
+exports.historiaPropria = historiaPropria;
 exports.sincronizarWorktree = sincronizarWorktree;
 exports.auditarWorktree = auditarWorktree;
 exports.textoDoAudit = textoDoAudit;
@@ -189,6 +190,34 @@ function garantirWorktree(carregado, id) {
         correcao: '',
     };
 }
+/**
+ * RM-037 (defeitosdeco D-5): o que a branch tem de proprio. Bases conhecidas da thread sao o
+ * `base.commit` carimbado na criacao e cada `shaBase` que um sync ja incorporou (lidos do ledger);
+ * commit que o git nao tem mais nao entra. `proprios` conta o que o HEAD tem fora delas e da base
+ * atual (`null` sem nenhuma base conhecida); `pontoDePartida` e a base conhecida mais nova que e
+ * ancestral do HEAD; `semAncestral` diz que HEAD e base atual nao tem historia em comum.
+ */
+function historiaPropria(raiz, thread, dir, shaBase) {
+    const git = (...args) => (0, util_1.exec)('git', args, dir);
+    const sincronizadas = (0, ledger_1.lerLedger)((0, thread_1.dirThread)(raiz, thread.id))
+        .filter(e => e.tipo === ledger_1.TIPOS_DE_EVENTO.worktreeSincronizada && typeof e.shaBase === 'string' && e.shaBase !== '')
+        .map(e => String(e.shaBase));
+    // GO-FIX (R1): no ciclo `merge-branch`, `base.commit` e a ponta da branch que ja existia, com os
+    // commits proprios dela. Nao e base: vale so o ponto onde ela sai da base atual, quando existe.
+    const inicio = thread.base?.commit;
+    const valido = (sha) => typeof sha === 'string' && /^[a-f0-9]{40,64}$/.test(sha) &&
+        git('cat-file', '-e', `${sha}^{commit}`).ok;
+    const pontoDaCriacao = thread.variante !== 'merge-branch' ? inicio
+        : valido(inicio) ? (git('merge-base', inicio, shaBase).stdout.trim() || null) : null;
+    const conhecidas = [...new Set([pontoDaCriacao, ...sincronizadas])].filter(valido);
+    const semAncestral = git('merge-base', 'HEAD', shaBase).code === 1;
+    const pontoDePartida = [...conhecidas].reverse().find(sha => git('merge-base', '--is-ancestor', sha, 'HEAD').ok) ?? null;
+    if (!conhecidas.length)
+        return { proprios: null, pontoDePartida, semAncestral };
+    const contagem = git('rev-list', '--count', 'HEAD', '--not', ...conhecidas, shaBase);
+    const proprios = contagem.ok && /^\d+$/.test(contagem.stdout.trim()) ? Number(contagem.stdout.trim()) : null;
+    return { proprios, pontoDePartida, semAncestral };
+}
 /**
  * Sincroniza a branch da thread com a base ATUAL (rebase), quando a base avancou.
  *
@@ -287,6 +316,54 @@ function sincronizarWorktree(carregado, id, opcoes = {}) {
             correcao: '',
         };
     }
+    // RM-037 (defeitosdeco D-5): depois do corte de 27/09 a base tem raiz nova. Branch sem commit
+    // proprio nao e rebasada: o rebase sem ancestral comum reaplicaria a historia antiga inteira. Ela
+    // e recriada no SHA da base com `reset --keep`, que aborta se houvesse mudanca local a perder (a
+    // arvore ja foi conferida limpa). Com commit proprio e sem ancestral comum, a branch fica como esta
+    // e a correcao exata reaplica so o que e dela.
+    const historia = historiaPropria(raiz, thread, dir, shaBase);
+    if (historia.proprios === 0) {
+        passos.push(`git reset --keep ${shaBase}`);
+        if (opcoes.dryRun) {
+            return { ...vazio, shaBase, shaAntes, shaDepois: shaAntes, ok: true, jaAtualizada: false, rebaseFeito: false, recriada: false,
+                motivo: null, detalhe: `a branch ${branch} nao tem commit proprio: o sync real a recriaria na base ${base} atual, sem rebase`,
+                correcao: '' };
+        }
+        let recriacao;
+        try {
+            recriacao = (0, estado_thread_1.comEstadoParaGit)(raiz, id, dir, () => (0, util_1.exec)('git', ['reset', '--keep', shaBase], dir));
+        }
+        catch (e) {
+            return { ...vazio, shaBase, shaAntes, ok: false, jaAtualizada: false, rebaseFeito: false,
+                motivo: 'tree.blocked', detalhe: e.message,
+                correcao: 'inspecione a cópia local e a fonte canônica preservadas antes de repetir o sync' };
+        }
+        const shaDepois = (0, util_1.exec)('git', ['rev-parse', 'HEAD'], dir).stdout.trim();
+        if (!recriacao.ok || shaDepois !== shaBase) {
+            return { ...vazio, shaBase, shaAntes, shaDepois, ok: false, jaAtualizada: false, rebaseFeito: false, motivo: 'tree.blocked',
+                detalhe: `a recriacao da branch ${branch} na base falhou: ${(recriacao.stderr || recriacao.stdout).trim().split('\n').slice(-2).join(' | ')}`,
+                correcao: `confira a worktree ${dir} e rode de novo: ork worktree sync ${id}` };
+        }
+        const detalhe = historia.semAncestral
+            ? `branch sem commit proprio recriada a partir da base ${base} atual; a base foi reescrita e nao tinha historia em comum com ela`
+            : `branch sem commit proprio recriada a partir da base ${base} atual`;
+        (0, ledger_1.registrar)((0, thread_1.dirThread)(raiz, id), id, ledger_1.TIPOS_DE_EVENTO.worktreeSincronizada, { dir, branch, base, shaBase, shaAntes, shaDepois,
+            rebaseFeito: false, recriada: true, semAncestral: historia.semAncestral, detalhe });
+        return { ...vazio, shaBase, shaAntes, shaDepois, ok: true, jaAtualizada: false, rebaseFeito: false, recriada: true,
+            motivo: null, detalhe, correcao: '' };
+    }
+    if (historia.semAncestral) {
+        const onto = historia.pontoDePartida
+            ? `git -C ${dir} rebase --onto ${shaBase} ${historia.pontoDePartida}`
+            : `git -C ${dir} rebase --onto ${shaBase} <commit onde a branch da thread comecou>`;
+        const detalhe = `a base ${base} foi reescrita e nao tem historia em comum com a branch ${branch}, que tem ` +
+            `${historia.proprios ?? 'um numero desconhecido de'} commit(s) proprio(s): o rebase reaplicaria a historia antiga inteira`;
+        if (!opcoes.dryRun)
+            (0, ledger_1.registrar)((0, thread_1.dirThread)(raiz, id), id, ledger_1.TIPOS_DE_EVENTO.worktreeSincronizada, { dir, branch, base, shaBase, shaAntes,
+                rebaseFeito: false, motivo: 'tree.blocked', semAncestral: true, detalhe });
+        return { ...vazio, shaBase, shaAntes, shaDepois: shaAntes, ok: false, jaAtualizada: false, rebaseFeito: false,
+            motivo: 'tree.blocked', detalhe, correcao: `reaplique so os commits da thread sobre a base nova: ${onto}` };
+    }
     if (opcoes.dryRun) {
         passos.push(`git rebase ${shaBase}`);
         return {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@orkastery/cli",
-  "version": "0.4.1",
+  "version": "0.4.3",
   "description": "A software factory of AI agents that proves its work: parallel threads, verified results, and short decisions only when they matter.",
   "license": "MIT",
   "homepage": "https://github.com/orkastery/orkastery#readme",