@orkastery/cli 0.5.3 → 0.6.0

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_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.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.BATIDA_DA_SENTINELA_MS = exports.PRAZO_DA_PRESENCA_MS = exports.CANAL_DA_SENTINELA = exports.CONTRATO_DA_SENTINELA = exports.ERRO_CANAL_DESCONHECIDO = exports.CANAIS_DE_CONDUCAO = exports.conducaoDoLease = void 0;
 exports.validarCanal = validarCanal;
 exports.canalDoProcesso = canalDoProcesso;
 exports.ambienteDaConducao = ambienteDaConducao;
@@ -85,10 +85,13 @@ const ledger_1 = require("./ledger");
 const maquina_1 = require("./maquina");
 const thread_1 = require("./thread");
 const horario_1 = require("./horario");
+const locale_1 = require("./locale");
 const util_1 = require("./util");
+const procedencia_1 = require("./procedencia");
 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; } });
+const projeto_alvo_1 = require("./projeto-alvo");
 // ---------------------------------------------------------------------------
 // Canais (D5, D6): registro fechado, declarado pela borda.
 // ---------------------------------------------------------------------------
@@ -121,6 +124,18 @@ exports.CANAIS_DE_CONDUCAO = {
 };
 /** Codigo tipado da recusa de canal fora do registro. */
 exports.ERRO_CANAL_DESCONHECIDO = 'conducao.canal-desconhecido';
+// ---------------------------------------------------------------------------
+// RM-059 (F6, T6.4; DD5 do plano dos mods): a conducao pela Sentinela do Condutor. A presenca e o passo
+// do condutor moram em `conducao-sentinela.ts`; as constantes ficam aqui, para quem so conhece a conducao.
+// ---------------------------------------------------------------------------
+/** O contrato do `ork conducao sentinela status --json`. */
+exports.CONTRATO_DA_SENTINELA = 'ork.conducao-sentinela/v1';
+/** A Sentinela roda na sessao do dono no Claude Code: e o canal dela, sempre. */
+exports.CANAL_DA_SENTINELA = 'claude-code';
+/** A presenca vale ate 3 min depois da ultima batida; vencida, o condutor externo volta a conduzir. */
+exports.PRAZO_DA_PRESENCA_MS = 3 * 60 * 1000;
+/** A Sentinela bate a cada 60 s: tres batidas perdidas e a presenca vence. */
+exports.BATIDA_DA_SENTINELA_MS = 60 * 1000;
 /** Canal fora do registro e recusado com motivo tipado, nunca adivinhado (T9). */
 function validarCanal(bruto) {
     const canal = bruto.trim();
@@ -149,9 +164,14 @@ function canalDoProcesso(explicito, ambiente = process.env) {
         return 'hermes';
     return 'cli';
 }
-/** O que o despacho poe no ambiente da sessao filha: identidade, thread e canal de origem. */
+/**
+ * O que o despacho poe no ambiente da sessao filha: identidade, thread e canal de origem. RM-052
+ * (fatia 2, D2): tambem neutraliza o projeto-alvo de quem despachou, porque a sessao roda dentro do
+ * projeto (a worktree da thread) e le o projeto pelo proprio cwd; o modo host do gateway nao a segue.
+ */
 function ambienteDaConducao(identidade, threadId, canal) {
-    return { [runtime_ambiente_1.ENV_IDENTIDADE_DE_DESPACHO]: identidade, [runtime_ambiente_1.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,
+        ...projeto_alvo_1.AMBIENTE_SEM_PROJETO_HERDADO };
 }
 /** 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';
@@ -219,10 +239,30 @@ function nomeDaConducao(threadId) {
 }
 /** Estados em que o runtime ja deu a sessao por encerrada. */
 const TERMINAIS = ['done', 'completed', 'exited', 'stopped', 'failed'];
+/** Os eventos que sao contabilidade do proprio ork, e nao sinal de que a sessao voltou a trabalhar. */
+const SO_DA_CONTABILIDADE = /^(conducao_|retry_|session_watcher_|despacho_idempotente$|varredura_acao$)/;
+/**
+ * RM-063 (fatia 3, achado c): o observador viu a sessao num estado terminal do runtime (`done`, `failed`, `stopped`) e
+ * encerrou sem inferir a conclusao da fase (`session_watcher_error` com `estadoNativo`). A fase pode nao estar provada,
+ * mas a sessao nao executa mais nada: o lease dela cai. Vale o ultimo desses vistos, se nenhum evento da mesma sessao
+ * depois dele mostra trabalho (a sessao retomada por alguem).
+ */
+function terminalVistoPeloObservador(eventos, sessionId, desde) {
+    let visto = null;
+    for (const e of eventos) {
+        if (e.sessionId !== sessionId || Date.parse(e.ts) < desde)
+            continue;
+        if (e.tipo === 'session_watcher_error' && typeof e.estadoNativo === 'string' && TERMINAIS.includes(e.estadoNativo))
+            visto = e;
+        else if (visto && !SO_DA_CONTABILIDADE.test(e.tipo))
+            visto = null;
+    }
+    return visto;
+}
 /**
  * O evento que prova que a sessao dona do lease acabou: o resultado da fase dela (a prova da I-34
- * que o observador grava), a morte registrada, a superacao, ou a thread fechada. So conta evento
- * posterior ao inicio da conducao.
+ * que o observador grava), a morte registrada, a superacao, o estado terminal que o observador viu
+ * no runtime (RM-063), ou a thread fechada. So conta evento posterior ao inicio da conducao.
  */
 function fimDaSessao(eventos, lease) {
     const dono = lease.conducao?.dono;
@@ -230,7 +270,7 @@ function fimDaSessao(eventos, lease) {
         return null;
     const desde = Date.parse(lease.adquiridoEm);
     return eventos.find((e) => Date.parse(e.ts) >= desde && ((['phase_result', 'sessao_morta', 'session_superseded'].includes(e.tipo) && e.sessionId === dono.sessionId) ||
-        ['thread_closed_admin', 'master_done'].includes(e.tipo))) ?? null;
+        ['thread_closed_admin', 'master_done'].includes(e.tipo))) ?? terminalVistoPeloObservador(eventos, dono.sessionId, desde);
 }
 /**
  * A leitura pura, para quem so tem os dados (o snapshot do Maestro le por um leitor confinado).
@@ -355,16 +395,49 @@ const emCurso = new Map();
 function chave(raiz, threadId) {
     return `${(0, leases_1.caminhoLease)(raiz, nomeDaConducao(threadId))}`;
 }
+/**
+ * RM-063 (fatia 3, achado c): a consulta do claude-bg na conta do perfil da sessao (`CLAUDE_CONFIG_DIR` dele). A conta do
+ * processo nao lista a sessao de outro perfil, e a ausencia la nao prova nada; na conta dela, prova. `null` quando o
+ * perfil nao esta mais no store desta maquina (vale a consulta de sempre).
+ */
+function consultaNaContaDoPerfil(dono, raiz) {
+    if (dono.runtime !== 'claude-bg' || !dono.perfil)
+        return null;
+    // Carregados na hora, como o controle nativo: a leitura da conducao nao puxa o adapter inteiro.
+    const { lerPerfis, perfilDeDespacho } = require('./runtime-profiles');
+    const { ambienteDoPerfil, consultarSessoes } = require('./adapters/claude-bg');
+    let perfil = null;
+    try {
+        const p = lerPerfis(raiz).perfis.find((x) => x.id === dono.perfil && x.runtime === 'claude-bg');
+        perfil = p ? perfilDeDespacho(p) : null;
+    }
+    catch {
+        return null;
+    }
+    if (!perfil?.configDir)
+        return null;
+    const r = consultarSessoes(undefined, true, ambienteDoPerfil(perfil));
+    if (!r.ok)
+        return { ok: false, estado: null, detalhe: `o runtime nao respondeu a consulta na conta do perfil ${dono.perfil}`, naConta: true };
+    const achada = r.sessoes.find((x) => x.sessionId === dono.sessionId);
+    const estado = achada ? String(achada.state ?? achada.status ?? '') : null;
+    return { ok: true, estado, detalhe: achada ? `estado ${estado} na conta do perfil ${dono.perfil}` : `sessao ausente da conta do perfil ${dono.perfil}`,
+        naConta: true };
+}
 /** A consulta padrao: o controle nativo do runtime (claude-bg ou o controller do codex). */
 const consultaNativa = (dono, raiz, threadId) => {
     try {
+        const naConta = consultaNaContaDoPerfil(dono, raiz);
+        if (naConta)
+            return naConta;
         // Carregado na hora: o modulo de sessoes puxa o HITL inteiro, que nao pertence a leitura.
         const { controleNativo } = require('./hitl-sessions');
         const r = controleNativo(dono.runtime, raiz, threadId, dono.sessionId).consultar();
         if (!r.ok)
             return { ok: false, estado: null, detalhe: 'o runtime nao respondeu a consulta' };
         const achadas = r.sessoes.filter((s) => s.sessionId === dono.sessionId);
-        return { ok: true, estado: achadas[0]?.estado ?? null, detalhe: achadas.length ? `estado ${achadas[0].estado}` : 'sessao ausente' };
+        return { ok: true, estado: achadas[0]?.estado ?? null, detalhe: achadas.length ? `estado ${achadas[0].estado}` : 'sessao ausente',
+            naConta: !dono.perfil };
     }
     catch (e) {
         return { ok: false, estado: null, detalhe: e.message };
@@ -405,7 +478,9 @@ function provaDeFimDaSessao(raiz, threadId, lease, pedido, anotarEstado = () =>
     anotarEstado(r.estado);
     if (r.estado && TERMINAIS.includes(r.estado))
         return { motivo: 'sessao-orfa', prova: `runtime ${dono.runtime}: ${r.detalhe}` };
-    if (r.estado === null && !dono.perfil)
+    // A ausencia so prova o fim quando a consulta foi feita na conta da sessao: sem perfil, a do processo; com perfil, a
+    // dele (RM-063, fatia 3, achado c).
+    if (r.estado === null && (!dono.perfil || r.naConta === true))
         return { motivo: 'sessao-orfa', prova: `runtime ${dono.runtime}: ${r.detalhe}` };
     return null;
 }
@@ -604,9 +679,10 @@ function sucessaoAindaVale(raiz, threadId, estado) {
     // Sem resposta do runtime nao ha prova de que ela segue parada: a sucessao nao vale.
     if (!r.ok)
         return false;
-    // S1 do CHECK 6: a sessao que sumiu do runtime, sem perfil, acabou; a mesma prova de `provaDeFimDaSessao`.
+    // S1 do CHECK 6: a sessao que sumiu do runtime, sem perfil (ou da conta do perfil dela), acabou; a mesma prova de
+    // `provaDeFimDaSessao`.
     if (r.estado === null)
-        return !dono.perfil;
+        return !dono.perfil || r.naConta === true;
     return r.estado === 'blocked' || TERMINAIS.includes(r.estado);
 }
 function renovar(raiz, threadId, estado, prazoDoProximoMs, agoraMs) {
@@ -698,6 +774,7 @@ function comandoDeEsperar(threadId, pedido) {
         case 'baseline': return `ork verify ${threadId} --baseline --esperar 30`;
         case 'fix.open': return `ork fix open ${threadId} --esperar 30`;
         case 'fix.reverify': return `ork fix reverify ${threadId} --esperar 30`;
+        case 'branch.atualizar': return `ork conducao atualizar ${threadId} --esperar 30`;
         default: return `ork verify ${threadId} --esperar 30`;
     }
 }
@@ -711,32 +788,30 @@ function comandoDeAcompanhar(threadId, atual) {
  * aconteceu e o que fazer: o texto sai daqui e de lugar nenhum mais, e o JSON e a mesma estrutura.
  */
 function recusaDeConducao(threadId, atual, pedido, opcoes = {}) {
+    const m = (0, locale_1.msg)().conducao.recusa;
     const conducao = atual
         ? { ...atual, desdeLocal: (0, horario_1.formatarDataHoraRotulada)(atual.desde, opcoes), linha: (0, conducao_texto_1.linhaDeConducao)(atual, opcoes) }
         : null;
     const acoes = [
-        { acao: 'esperar', comando: comandoDeEsperar(threadId, pedido),
-            explicacao: 'Esperar a vez: repete este pedido e segue sozinho quando a conducao atual terminar (ate 30 min).' },
-        { acao: 'acompanhar', comando: comandoDeAcompanhar(threadId, atual),
-            explicacao: 'Acompanhar quem conduz, sem mexer em nada.' },
-        { acao: 'assumir', comando: `ork conducao assumir ${threadId} --por <voce> --motivo "<por que>"`,
-            explicacao: 'Assumir a conducao: encerra a atual pelo proprio runtime e registra no ledger quem assumiu, de qual canal e por que.' },
+        { acao: 'esperar', comando: comandoDeEsperar(threadId, pedido), explicacao: m.esperar },
+        { acao: 'acompanhar', comando: comandoDeAcompanhar(threadId, atual), explicacao: m.acompanhar },
+        { acao: 'assumir', comando: m.comandoAssumir(threadId),
+            explicacao: m.assumir },
     ];
     const linhas = [
-        `Pedido nao executado: a thread ${threadId} ja esta sendo conduzida agora, e duas execucoes na mesma worktree ` +
-            'se corrompem (foi o que aconteceu em 19/09/2026).',
+        m.titulo(threadId),
     ];
     if (conducao) {
-        linhas.push(`  Quem conduz: canal ${conducao.canal}, ${(0, conducao_texto_1.quemConduz)(conducao)}, fase ${conducao.fase ?? '-'}, desde ${conducao.desdeLocal}.`);
+        linhas.push(m.quem(conducao.canal, (0, conducao_texto_1.quemConduz)(conducao), conducao.fase ?? '-', conducao.desdeLocal));
         if (conducao.promptSha256)
-            linhas.push(`  Pedido em curso: prompt sha256 ${conducao.promptSha256.slice(0, 12)}.`);
+            linhas.push(m.prompt(conducao.promptSha256.slice(0, 12)));
     }
     else {
-        linhas.push('  Outra operacao esta tomando a conducao neste instante; o registro dela ainda nao apareceu.');
+        linhas.push(m.entrando);
     }
-    linhas.push(`  Pedido recusado: ${conducao_texto_1.NOME_DA_OPERACAO[pedido.operacao]}${pedido.fase ? ` da fase ${pedido.fase}` : ''}, pelo canal ${pedido.canal}.`);
-    linhas.push('O que voce pode fazer:');
-    acoes.forEach((a, i) => { linhas.push(`  ${i + 1}. ${a.explicacao}`); linhas.push(`     ${a.comando}`); });
+    linhas.push(m.pedido((0, locale_1.msg)().thread.operacoes[pedido.operacao], pedido.fase ?? null, pedido.canal));
+    linhas.push(m.opcoes);
+    acoes.forEach((a, i) => { linhas.push(m.passo(i + 1, a.explicacao)); linhas.push(`     ${a.comando}`); });
     return {
         contrato: 'ork.conducao-recusa/v1',
         motivo: 'conducao.em-andamento',
@@ -752,12 +827,12 @@ function recusaDeConducao(threadId, atual, pedido, opcoes = {}) {
  * e o texto diz onde acompanhar a sessao que ja atende o pedido.
  */
 function textoDoPedidoRepetido(threadId, atual, opcoes = {}) {
+    // RM-061 (F2a): texto de impressao (o despacho nao o grava), no locale do comando.
+    const m = (0, locale_1.msg)().phase;
     return [
-        `Pedido ja em andamento: a fase ${atual.fase ?? '-'} da thread ${threadId} roda com este mesmo prompt ` +
-            `(sha256 ${(atual.promptSha256 ?? '').slice(0, 12)}) desde ${(0, horario_1.formatarDataHoraRotulada)(atual.desde, opcoes)}. ` +
-            'Nenhuma sessao nova foi aberta e nenhuma cota foi gasta.',
+        m.repetido(atual.fase ?? '-', threadId, (atual.promptSha256 ?? '').slice(0, 12), (0, horario_1.formatarDataHoraRotulada)(atual.desde, opcoes)),
         `  ${(0, conducao_texto_1.linhaDeConducao)(atual, opcoes)}`,
-        `  acompanhar: ${comandoDeAcompanhar(threadId, atual)}`,
+        m.acompanhar(comandoDeAcompanhar(threadId, atual)),
     ].join('\n');
 }
 /** A recusa tipada como erro, para quem nao tem um resultado estruturado onde devolve-la. */
@@ -843,7 +918,8 @@ function liberarSeOrfa(raiz, threadId, opcoes = {}) {
 function estadoDaWorktree(raiz, threadId) {
     try {
         const t = (0, thread_1.lerThread)(raiz, threadId);
-        const dir = t.worktree ?? raiz;
+        // RM-047 (P2): o git do handoff so roda na worktree registrada.
+        const dir = (0, procedencia_1.diretorioDaThread)(raiz, t);
         const head = (0, util_1.exec)('git', ['rev-parse', 'HEAD'], dir);
         const st = (0, util_1.exec)('git', ['status', '--porcelain'], dir);
         return { head: head.ok ? head.stdout.trim() : null, alterados: st.ok ? st.stdout.split('\n').filter(Boolean).slice(0, 40) : [] };
@@ -860,6 +936,68 @@ const controleNativoDoHandoff = (runtime, raiz, threadId, sessionId) => {
         parar: (s) => ctl.parar(s),
     };
 };
+/**
+ * A fonte fixada pelo sensor contém a identidade capturada no spawn, não um PID descoberto.
+ * Todos os watchers, o controller e o runtime precisam estar ausentes por identidade.
+ * Quem chama segura a trava da condução; nenhum prazo ou heartbeat autoriza esta soltura.
+ */
+function morteLocalDoCodex(raiz, threadId, lease) {
+    const dono = lease.conducao?.dono;
+    if (dono?.tipo !== 'sessao' || dono.runtime !== 'codex' || dono.maquina !== (0, maquina_1.nomeDaMaquina)())
+        return null;
+    try {
+        const t = (0, thread_1.lerThread)(raiz, threadId), sessao = t.sessoes.at(-1);
+        if (!sessao || sessao.sessionId !== dono.sessionId || sessao.runtime !== 'codex' || !sessao.despachadaEm ||
+            sessao.fase !== lease.conducao?.fase || sessao.promptSha256 !== lease.conducao?.promptSha256)
+            return null;
+        const dir = (0, thread_1.dirThread)(raiz, threadId), eventos = (0, ledger_1.lerLedger)(dir);
+        if (fimDaSessao(eventos, lease))
+            return null;
+        const mesmo = (e) => e.sessionId === dono.sessionId && e.despachoEm === sessao.despachadaEm;
+        const watchers = eventos.filter(e => e.tipo === 'session_watcher_started' && mesmo(e));
+        if (!watchers.length || watchers.some(watcher => {
+            const identidade = watcher.identidade;
+            return !identidade || watcher.pid !== identidade.pid || (0, codex_runner_1.estadoProcesso)(identidade) !== 'ausente';
+        }))
+            return null;
+        const registro = eventos.filter(e => e.tipo === 'session_sensor_registered' && mesmo(e)).at(-1);
+        const despacho = eventos.filter(e => e.tipo === 'phase_dispatch' && e.sessionId === dono.sessionId).at(-1);
+        if (!registro || typeof registro.controlador !== 'string' || typeof registro.cwd !== 'string' ||
+            registro.logPath || registro.processoPath || registro.reciboPath || registro.nativo ||
+            despacho?.controlador !== registro.controlador || despacho.cwd !== registro.cwd ||
+            (sessao.controlador && sessao.controlador !== registro.controlador))
+            return null;
+        const chave = (0, node_crypto_1.createHash)('sha256').update(dono.sessionId + '|' + sessao.despachadaEm).digest('hex');
+        const fixacao = path.join(dir, 'sessoes', `watcher-source-${chave}.json`);
+        // Recuperação não cria uma fonte nova nem depende do state.json mutável de um controller morto.
+        if (!fs.existsSync(fixacao))
+            return null;
+        const { registrarFonteController } = require('./adapters/codex-controller-sensor');
+        const fonte = registrarFonteController(registro.controlador, { dirSessoes: path.join(dir, 'sessoes'), fixacao,
+            sessionId: dono.sessionId, cwd: registro.cwd, despachoEm: sessao.despachadaEm,
+            vinculo: { thread: threadId, fase: sessao.fase, promptSha256: sessao.promptSha256 } });
+        const controller = fonte.processoController;
+        if (!controller || (0, codex_runner_1.estadoProcesso)({ pid: controller.pid, inicio: controller.inicio, boot: controller.bootId }) !== 'ausente')
+            return null;
+        const runtime = fonte.processoRuntime;
+        if (!runtime || (0, codex_runner_1.estadoProcesso)({ pid: runtime.pid, inicio: runtime.inicio, boot: runtime.bootId }) !== 'ausente')
+            return null;
+        // O watcher pode ter gravado o terminal e saído durante a prova dos processos.
+        if (fimDaSessao((0, ledger_1.lerLedger)(dir), lease))
+            return null;
+        return { sessionId: dono.sessionId, despachoEm: sessao.despachadaEm, fase: sessao.fase, runtime: 'codex',
+            origem: 'conducao.assumir', motivo: 'watchers-controlador-e-runtime-ausentes',
+            prova: { fonte: 'session_sensor_registered+controller-source-pin+/proc',
+                registroEventId: registro.eventId,
+                watchers: watchers.map(w => ({ eventId: w.eventId, identidade: w.identidade, estado: 'ausente' })),
+                controlador: { pid: controller.pid, inicio: controller.inicio, boot: controller.bootId, uid: controller.uid },
+                runtime: { pid: runtime.pid, inicio: runtime.inicio, boot: runtime.bootId, uid: runtime.uid },
+                estadoControlador: 'ausente', estadoRuntime: 'ausente' } };
+    }
+    catch {
+        return null;
+    } // Fonte ilegível, divergente ou identidade desconhecida nunca prova morte.
+}
 /**
  * `ork conducao assumir` (T15): encerra a conducao atual pelo mecanismo suportado do runtime, toma
  * uma reserva curta para o canal de quem assumiu e registra quem, de qual canal e por que. Processo
@@ -873,7 +1011,8 @@ function assumirConducao(raiz, threadId, opcoes) {
         throw new Error('conducao.assumir: informe --motivo; handoff sem razao registrada e o mesmo kill de antes, com outro nome');
     const dir = (0, thread_1.dirThread)(raiz, threadId);
     (0, thread_1.lerThread)(raiz, threadId);
-    liberarSeOrfa(raiz, threadId, { consultarSessao: opcoes.consultarSessao });
+    // A prova local vem antes de qualquer consulta ao runtime; ledger ainda libera sessões terminadas.
+    liberarSeOrfa(raiz, threadId, { consultarRuntime: false });
     const fd = tentarTrava(raiz, threadId);
     if (fd === null) {
         const atual = conducaoDaThread(raiz, threadId);
@@ -889,30 +1028,38 @@ function assumirConducao(raiz, threadId, opcoes) {
         let prova = 'lease exec ausente';
         if (lease && anterior?.dono.tipo === 'sessao') {
             const dono = anterior.dono;
-            const ctl = (opcoes.controle ?? controleNativoDoHandoff)(dono.runtime, raiz, threadId, dono.sessionId);
-            const antes = ctl.consultar();
-            if (!antes.ok) {
-                return { ok: false, thread: threadId, anterior, mecanismo: 'nenhum',
-                    detalhe: 'runtime.unavailable: nao consegui consultar a sessao no runtime; nada foi encerrado e a conducao segue com ela' };
+            const morte = morteLocalDoCodex(raiz, threadId, lease);
+            if (morte) {
+                (0, ledger_1.registrar)(dir, threadId, 'sessao_morta', morte);
+                mecanismo = 'recuperação local: watchers, controlador e runtime ausentes por identidade';
+                prova = 'ledger: sessao_morta com identidades capturadas e ausência conferida no kernel';
             }
-            const s = antes.sessoes.find((x) => x.sessionId === dono.sessionId);
-            if (s && !TERMINAIS.includes(s.estado)) {
-                if (!ctl.parar(s)) {
-                    return { ok: false, thread: threadId, anterior, mecanismo: `parar ${dono.runtime}`,
-                        detalhe: `runtime.unavailable: o runtime ${dono.runtime} nao confirmou o encerramento; a conducao segue com a sessao ${dono.sessionId.slice(0, 8)}` };
+            else {
+                const ctl = (opcoes.controle ?? controleNativoDoHandoff)(dono.runtime, raiz, threadId, dono.sessionId);
+                const antes = ctl.consultar();
+                if (!antes.ok) {
+                    return { ok: false, thread: threadId, anterior, mecanismo: 'nenhum',
+                        detalhe: 'runtime.unavailable: nao consegui consultar a sessao no runtime; nada foi encerrado e a conducao segue com ela' };
                 }
-                const depois = ctl.consultar();
-                const ainda = depois.ok ? depois.sessoes.find((x) => x.sessionId === dono.sessionId) : s;
-                if (!depois.ok || (ainda && !TERMINAIS.includes(ainda.estado))) {
-                    return { ok: false, thread: threadId, anterior, mecanismo: `parar ${dono.runtime}`,
-                        detalhe: 'runtime.unavailable: a consulta depois do encerramento nao confirma a sessao parada; o lease foi mantido' };
+                const s = antes.sessoes.find((x) => x.sessionId === dono.sessionId);
+                if (s && !TERMINAIS.includes(s.estado)) {
+                    if (!ctl.parar(s)) {
+                        return { ok: false, thread: threadId, anterior, mecanismo: `parar ${dono.runtime}`,
+                            detalhe: `runtime.unavailable: o runtime ${dono.runtime} nao confirmou o encerramento; a conducao segue com a sessao ${dono.sessionId.slice(0, 8)}` };
+                    }
+                    const depois = ctl.consultar();
+                    const ainda = depois.ok ? depois.sessoes.find((x) => x.sessionId === dono.sessionId) : s;
+                    if (!depois.ok || (ainda && !TERMINAIS.includes(ainda.estado))) {
+                        return { ok: false, thread: threadId, anterior, mecanismo: `parar ${dono.runtime}`,
+                            detalhe: 'runtime.unavailable: a consulta depois do encerramento nao confirma a sessao parada; o lease foi mantido' };
+                    }
+                    mecanismo = `parar pelo runtime ${dono.runtime} (controle homologado)`;
+                    prova = `runtime: ${s.estado} -> ${ainda?.estado ?? 'ausente'}`;
+                }
+                else {
+                    mecanismo = 'nenhum: a sessao ja tinha terminado';
+                    prova = `runtime: ${s?.estado ?? 'sessao ausente'}`;
                 }
-                mecanismo = `parar pelo runtime ${dono.runtime} (controle homologado)`;
-                prova = `runtime: ${s.estado} -> ${ainda?.estado ?? 'ausente'}`;
-            }
-            else {
-                mecanismo = 'nenhum: a sessao ja tinha terminado';
-                prova = `runtime: ${s?.estado ?? 'sessao ausente'}`;
             }
         }
         else if (lease && anterior?.dono.tipo === 'reserva') {
@@ -940,8 +1087,7 @@ function assumirConducao(raiz, threadId, opcoes) {
             worktree: estadoDaWorktree(raiz, threadId),
         });
         return { ok: true, thread: threadId, anterior, mecanismo,
-            detalhe: `conducao assumida por ${por} pelo canal ${opcoes.canal}; a proxima operacao desse canal usa a reserva ate ` +
-                `${(0, horario_1.formatarDataHoraRotulada)(reserva.expiraEm)}` };
+            detalhe: (0, locale_1.msg)().conducao.cli.detalheAssumida(por, opcoes.canal, (0, horario_1.formatarDataHoraRotulada)(reserva.expiraEm)) };
     }
     finally {
         fs.closeSync(fd);
@@ -949,14 +1095,15 @@ function assumirConducao(raiz, threadId, opcoes) {
 }
 /** Texto de `ork conducao status`. */
 function textoDoStatusDaConducao(threadId, atual) {
+    const m = (0, locale_1.msg)().conducao.status;
     if (!atual)
-        return `Thread ${threadId}: ninguem conduz agora. Qualquer canal pode despachar ou verificar.`;
-    const linhas = [`Thread ${threadId}: ${(0, conducao_texto_1.linhaDeConducao)(atual)}`];
+        return m.livre(threadId);
+    const linhas = [m.titulo(threadId, (0, conducao_texto_1.linhaDeConducao)(atual))];
     if (atual.promptSha256)
-        linhas.push(`  prompt sha256 ${atual.promptSha256.slice(0, 12)}`);
-    linhas.push(`  prazo do lease (metadado, nao prova): ${(0, horario_1.formatarDataHoraRotulada)(atual.expiraEm)}`);
+        linhas.push(m.prompt(atual.promptSha256.slice(0, 12)));
+    linhas.push(m.prazo((0, horario_1.formatarDataHoraRotulada)(atual.expiraEm)));
     if (atual.sessao)
-        linhas.push(`  acompanhar: ork sessions logs ${atual.sessao.slice(0, 8)}`);
-    linhas.push(`  assumir: ork conducao assumir ${threadId} --por <voce> --motivo "<por que>"`);
+        linhas.push(m.acompanhar(atual.sessao.slice(0, 8)));
+    linhas.push(m.assumir(threadId));
     return linhas.join('\n');
 }