@orkastery/cli 0.6.4 → 0.6.5

package/dist/check-paralelo.js

@@ -34,7 +34,9 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.argvDoItem = argvDoItem;
+exports.workersDaLane = workersDaLane;
 exports.chaveDoPerfilIntegracao = chaveDoPerfilIntegracao;
+exports.picoDaArvoreParaPerfil = picoDaArvoreParaPerfil;
 exports.picoCpuPorFonte = picoCpuPorFonte;
 exports.esperaDoGrupo = esperaDoGrupo;
 exports.rodarEmParalelo = rodarEmParalelo;
@@ -59,7 +61,7 @@ const integracoes_locais_1 = require("./integracoes-locais");
 const TIMEOUT_BIN = '/usr/bin/timeout';
 const NICE_BIN = '/usr/bin/nice';
 const TIME_BIN = '/usr/bin/time';
-const CONTRATO_PERFIL_INTEGRACAO = 'ork.check.cpu-integracao/v1';
+const CONTRATO_PERFIL_INTEGRACAO = 'ork.check.cpu-integracao/v2';
 const INTERVALO_CPU_MS = 100;
 /** O argv de um item: `nice` (se pedido e existir), `timeout(1)` (se existir) e o `argv` do item ou `bash -c`. */
 function argvDoItem(item, comGrupo = fs.existsSync(TIMEOUT_BIN), comNice = fs.existsSync(NICE_BIN)) {
@@ -84,6 +86,49 @@ function vagas(max) {
             livres++; },
     };
 }
+/**
+ * Recursos exclusivos sem dependencia artificial. Cada pedido adquire o conjunto inteiro ou espera, o que evita
+ * deadlock entre listas cruzadas; pedidos disjuntos continuam livres para avancar.
+ */
+function recursosExclusivos() {
+    const ocupados = new Set();
+    const fila = [];
+    const despachar = () => {
+        for (let i = 0; i < fila.length;) {
+            const pedido = fila[i];
+            if (pedido.nomes.some((nome) => ocupados.has(nome))) {
+                i++;
+                continue;
+            }
+            fila.splice(i, 1);
+            pedido.nomes.forEach((nome) => ocupados.add(nome));
+            pedido.pronto(() => {
+                pedido.nomes.forEach((nome) => ocupados.delete(nome));
+                despachar();
+            });
+        }
+    };
+    return {
+        tomar: (nomes) => new Promise((pronto) => {
+            fila.push({ nomes: [...new Set(nomes)], pronto });
+            despachar();
+        }),
+    };
+}
+/** A reserva que vira ORK_WORKERS quando a lane e efetivamente lancada. */
+function workersDaLane(item, plano, cpus, totalDeLanes) {
+    if (!item.nome.startsWith('test:'))
+        return null;
+    const capacidade = (0, agendador_cpu_1.workersDaReserva)(cpus);
+    if (!plano)
+        return Math.max(1, Math.floor(capacidade / Math.max(1, Math.min(capacidade, totalDeLanes))));
+    if (item.papelCpu === 'hermetica')
+        return (0, agendador_cpu_1.workersDaReserva)(plano.cpusHermetica);
+    if (item.papelCpu === 'integracao')
+        return (0, agendador_cpu_1.workersDaReserva)(plano.cpusIntegracao);
+    // Outros fecham a cadeia depois que as reservas da varredura e da integracao voltaram.
+    return capacidade;
+}
 function arquivoDoPerfilIntegracao() {
     const base = process.env.XDG_CACHE_HOME && path.isAbsolute(process.env.XDG_CACHE_HOME)
         ? process.env.XDG_CACHE_HOME : path.join(os.homedir(), '.cache');
@@ -124,22 +169,27 @@ function lerPerfilIntegracao(chave, cpus) {
     try {
         const p = JSON.parse(fs.readFileSync(arquivoDoPerfilIntegracao(), 'utf8'));
         return p?.contrato === CONTRATO_PERFIL_INTEGRACAO && p.chave === chave && p.cpus === cpus && p.completa
-            && Number.isFinite(p.picoCpus) && p.picoCpus > 0 && p.picoCpus <= cpus ? p : null;
+            && Number.isFinite(p.picoCpusDaArvore) && p.picoCpusDaArvore > 0 && p.picoCpusDaArvore <= cpus ? p : null;
     }
     catch {
         return null;
     }
 }
+/** Somente uma arvore completa e fisicamente possivel pode ensinar a reserva; lacunas de conteiner ficam na evidencia. */
+function picoDaArvoreParaPerfil(medicao, cpus) {
+    const pico = medicao.picoCpusDaArvore;
+    return medicao.arvoreCompleta && !medicao.anomaliaDaArvore && pico !== null && pico > 0 && pico <= cpus ? pico : null;
+}
 function gravarPerfilIntegracao(chave, cpus, medicao) {
-    if (!chave || !medicao.completa || medicao.anomalia || medicao.picoCpus === null
-        || !(medicao.picoCpus > 0) || medicao.picoCpus > cpus)
+    const picoCpusDaArvore = picoDaArvoreParaPerfil(medicao, cpus);
+    if (!chave || picoCpusDaArvore === null)
         return;
     const arquivo = arquivoDoPerfilIntegracao();
     try {
         fs.mkdirSync(path.dirname(arquivo), { recursive: true });
         const temporario = `${arquivo}.${process.pid}.tmp`;
         const perfil = { contrato: CONTRATO_PERFIL_INTEGRACAO, chave, cpus,
-            picoCpus: medicao.picoCpus, completa: true, medidoEm: new Date().toISOString() };
+            picoCpusDaArvore, completa: true, medidoEm: new Date().toISOString() };
         fs.writeFileSync(temporario, JSON.stringify(perfil) + '\n', { mode: 0o600 });
         fs.renameSync(temporario, arquivo);
     }
@@ -271,16 +321,18 @@ function sondarCpuDaIntegracao(pid, registro, cpus) {
     const fontes = new Map();
     const motivos = new Map();
     const amostras = [];
+    const amostrasDaArvore = [];
     const primeiraCpuDosContainers = new Map();
     const ultimaCpuDosContainers = new Map();
     const amostrar = () => {
         const tabela = processosCpu();
-        const atuais = {};
+        const arvore = {};
         for (const p of arvoreDeProcessos(pid, tabela)) {
             const x = tabela.get(p);
             if (x)
-                atuais[`processo:${p}:${x.inicio}`] = x.cpuMs;
+                arvore[`processo:${p}:${x.inicio}`] = x.cpuMs;
         }
+        const atuais = { ...arvore };
         for (const nome of nomesDosContainers(registro)) {
             let fonte = fontes.get(nome);
             if (!fonte) {
@@ -304,7 +356,9 @@ function sondarCpuDaIntegracao(pid, registro, cpus) {
             else if (fonte)
                 motivos.set(nome, 'contador de CPU do cgroup ilegivel');
         }
-        amostras.push({ em: Date.now(), fontes: atuais });
+        const em = Date.now();
+        amostrasDaArvore.push({ em, fontes: arvore });
+        amostras.push({ em, fontes: atuais });
     };
     return {
         amostrar,
@@ -314,10 +368,14 @@ function sondarCpuDaIntegracao(pid, registro, cpus) {
             const containersMs = nomes.reduce((total, nome) => total + Math.max(0, (ultimaCpuDosContainers.get(nome) ?? 0) - (primeiraCpuDosContainers.get(nome) ?? 0)), 0);
             const ausentes = nomes.filter((nome) => !ultimaCpuDosContainers.has(nome));
             const pico = picoCpuPorFonte(amostras, cpus);
+            const picoDaArvore = picoCpuPorFonte(amostrasDaArvore, cpus);
+            const arvoreCompleta = arvoreMs > 0 && picoDaArvore.picoCpus !== null && !picoDaArvore.anomalia;
             return { arvoreMs, containersMs, totalMs: arvoreMs + containersMs, paredeMs,
-                picoCpus: pico.picoCpus, completa: ausentes.length === 0 && !pico.anomalia,
+                picoCpus: pico.picoCpus, picoCpusDaArvore: picoDaArvore.picoCpus,
+                completa: arvoreCompleta && ausentes.length === 0 && !pico.anomalia, arvoreCompleta,
                 containers: nomes, ausentes, motivosDosAusentes: ausentes.map((container) => ({ container,
-                    motivo: motivos.get(container) ?? 'conteiner terminou antes de uma amostra completa' })), anomalia: pico.anomalia };
+                    motivo: motivos.get(container) ?? 'conteiner terminou antes de uma amostra completa' })),
+                anomalia: pico.anomalia, anomaliaDaArvore: picoDaArvore.anomalia };
         },
     };
 }
@@ -333,13 +391,16 @@ async function rodarEspecificacao(esp) {
     const perfil = esp.medicaoCpu?.cpusIntegracao === undefined ? lerPerfilIntegracao(chaveDoPerfil, cpus) : null;
     const medicao = esp.medicaoCpu ?? await (0, agendador_cpu_1.medirCpuDoGrupo)();
     if (perfil)
-        Object.assign(medicao, { cpusIntegracao: perfil.picoCpus, fonteCpusIntegracao: 'medida' });
+        Object.assign(medicao, { cpusIntegracao: perfil.picoCpusDaArvore, fonteCpusIntegracao: 'medida' });
     else if (medicao.cpusIntegracao === undefined)
         Object.assign(medicao, { cpusIntegracao: null, fonteCpusIntegracao: 'conservadora' });
     const plano = usaAgendador ? (0, agendador_cpu_1.planejarCpuDoGrupo)(cpus, medicao) : undefined;
     const sinalDaReserva = plano && !plano.saturado ? path.join(esp.dir, 'reserva-devolvida.json') : undefined;
     const itens = plano ? aplicarPlano(esp.itens, plano, sinalDaReserva) : esp.itens;
-    const limite = vagas(esp.maxParalelo && esp.maxParalelo > 0 ? esp.maxParalelo : itens.length);
+    const tetoInformado = esp.maxParalelo && esp.maxParalelo > 0 ? esp.maxParalelo : itens.length;
+    const limite = vagas(Math.max(1, Math.min(tetoInformado, (0, agendador_cpu_1.workersDaReserva)(cpus))));
+    const exclusivos = recursosExclusivos();
+    const totalDeLanes = itens.filter((item) => item.nome.startsWith('test:')).length;
     const porNome = new Map();
     const indice = new Map(itens.map((item, i) => [item.nome, i]));
     const vezDoItem = (item, i) => {
@@ -354,12 +415,14 @@ async function rodarEspecificacao(esp) {
                 if (j !== undefined)
                     await vezDoItem(itens[j], j);
             }
+            const soltarRecursos = await exclusivos.tomar(item.recursos ?? []);
             await limite.tomar();
             try {
                 return await lancar(item, i);
             }
             finally {
                 limite.soltar();
+                soltarRecursos();
             }
         });
         porNome.set(item.nome, vez);
@@ -434,15 +497,14 @@ async function rodarEspecificacao(esp) {
                     catch { /* medida incompleta abaixo */ }
                 }
                 const medicaoCpu = medirIntegracao && sonda ? sonda.fechar(arvoreMs, t.duracaoMs) : undefined;
-                if (medicaoCpu && !(arvoreMs > 0))
-                    medicaoCpu.completa = false;
                 fim = { ...t, ...(medicaoCpu ? { medicaoCpu } : {}) };
                 fs.closeSync(saida);
                 fs.closeSync(erro);
                 resolve(fim);
             };
             // Sem o `timeout(1)`, o proprio auxiliar mata pelo prazo, como o `spawnSync` do `exec` faria.
-            const ambiente = { ...process.env, ...item.ambiente,
+            const workers = workersDaLane(item, plano, cpus, totalDeLanes);
+            const ambiente = { ...process.env, ...item.ambiente, ...(workers === null ? {} : { [agendador_cpu_1.ENV_WORKERS]: String(workers) }),
                 ...(medirIntegracao ? { [agendador_cpu_1.ENV_CONTAINERS_DA_LANE]: registro } : {}) };
             const filho = (0, node_child_process_1.spawn)(bin, args, { cwd: item.cwd, env: ambiente, stdio: ['ignore', saida, erro],
                 ...(comGrupo ? {} : { timeout: item.prazoMs, killSignal: 'SIGTERM' }) });

package/dist/check-selecao.js

@@ -0,0 +1,149 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CONTRATO_DA_SELECAO = void 0;
+exports.comandoDaSelecao = comandoDaSelecao;
+exports.planejarSelecaoNativa = planejarSelecaoNativa;
+/** RM-081 F5: decisão conservadora da seleção nativa por mudanças no Agile. */
+const path = __importStar(require("node:path"));
+const leases_1 = require("./leases");
+const manifest_1 = require("./manifest");
+const util_1 = require("./util");
+exports.CONTRATO_DA_SELECAO = 'ork.check.selecao/v1';
+const LOCKFILES = new Set(['package-lock.json', 'npm-shrinkwrap.json', 'pnpm-lock.yaml', 'yarn.lock', 'poetry.lock',
+    'Pipfile.lock', 'go.mod', 'go.sum', 'Package.resolved']);
+function objeto(v) {
+    return v && typeof v === 'object' && !Array.isArray(v) ? v : null;
+}
+function sha(v) {
+    return typeof v === 'string' && /^[0-9a-f]{40,64}$/i.test(v);
+}
+/** Um argumento shell fechado, como o filtro nominal da F3. */
+function argumento(valor) {
+    return `'${valor.replace(/'/g, `'"'"'`)}'`;
+}
+function comandoDaSelecao(declaracao, base, arquivos) {
+    return declaracao.comando.includes('{base}')
+        ? declaracao.comando.replace('{base}', argumento(base))
+        : declaracao.comando.replace('{arquivos}', arquivos.map(argumento).join(' '));
+}
+function baseAtual(cwd, manifesto, commit) {
+    const r = (0, util_1.exec)('git', ['merge-base', commit, manifesto.worktree.base_branch], cwd);
+    const base = r.stdout.trim();
+    return r.ok && sha(base) ? base : null;
+}
+function arvoreLimpa(cwd) {
+    const r = (0, util_1.exec)('git', ['status', '--porcelain=v1', '-z', '--untracked-files=all', '--', '.', ':(exclude).orkastery'], cwd);
+    return r.ok && r.stdout === '';
+}
+function arquivosMudados(cwd, anterior, atual) {
+    const r = (0, util_1.exec)('git', ['diff', '--name-only', '--no-renames', '-z', anterior, atual, '--', '.', ':(exclude).orkastery'], cwd);
+    if (!r.ok)
+        return null;
+    return [...new Set(r.stdout.split('\0').filter(Boolean).map((arquivo) => arquivo.split(path.sep).join('/')))].sort();
+}
+function lockfile(arquivo) {
+    const nome = path.posix.basename(arquivo);
+    return LOCKFILES.has(nome) || /^requirements(?:\.[^.]+)?\.txt$/.test(nome)
+        || /(?:^|[.-])lock(?:b|\.(?:json|ya?ml|toml))?$/i.test(nome);
+}
+function inteira(motivo, arquivos) {
+    return { modo: 'inteira', motivo, ...(arquivos?.length ? { arquivos } : {}) };
+}
+function todasInteiras(declaracoes, motivo, arquivos) {
+    return Object.fromEntries(Object.keys(declaracoes).map((lane) => [lane, inteira(motivo, arquivos)]));
+}
+/**
+ * Decide uma vez, antes dos comandos. O último `verify_run` é o cache: qualquer forma desconhecida,
+ * veredito vermelho, base diferente ou árvore suja devolve a suíte inteira.
+ */
+function planejarSelecaoNativa(cwd, manifesto, eventos, commit, modo) {
+    const declaracoes = manifesto.check?.agile?.selecao ?? {};
+    if (modo !== 'agile' || Object.keys(declaracoes).length === 0)
+        return { lanes: {}, cache: null };
+    const base = baseAtual(cwd, manifesto, commit);
+    const limpa = arvoreLimpa(cwd);
+    const cache = base && limpa ? { contrato: exports.CONTRATO_DA_SELECAO, base, head: commit } : null;
+    const ultima = [...eventos].reverse().find((evento) => evento.tipo === 'verify_run');
+    if (!ultima)
+        return { lanes: todasInteiras(declaracoes, 'rodada-fria'), cache };
+    const anterior = objeto(ultima.selecao);
+    if (!anterior)
+        return { lanes: todasInteiras(declaracoes, 'cache-ausente'), cache };
+    if (!base || !limpa || ultima.veredito !== 'verdade sustentada' || anterior.contrato !== exports.CONTRATO_DA_SELECAO
+        || !sha(anterior.base) || !sha(anterior.head) || anterior.head !== ultima.commit) {
+        return { lanes: todasInteiras(declaracoes, 'cache-invalido'), cache };
+    }
+    if (anterior.base !== base)
+        return { lanes: todasInteiras(declaracoes, 'base-mudou'), cache };
+    if (!(0, util_1.exec)('git', ['merge-base', '--is-ancestor', anterior.head, commit], cwd).ok) {
+        return { lanes: todasInteiras(declaracoes, 'cache-invalido'), cache };
+    }
+    const mudados = arquivosMudados(cwd, anterior.head, commit);
+    if (!mudados)
+        return { lanes: todasInteiras(declaracoes, 'cache-invalido'), cache };
+    const manifestos = new Set([manifest_1.NOME_MANIFESTO, manifest_1.NOME_MANIFESTO_LEGADO]);
+    const mudancaNoManifesto = mudados.filter((arquivo) => manifestos.has(path.posix.basename(arquivo)));
+    if (mudancaNoManifesto.length)
+        return { lanes: todasInteiras(declaracoes, 'manifesto-mudou', mudancaNoManifesto), cache };
+    const lockfiles = mudados.filter(lockfile);
+    if (lockfiles.length)
+        return { lanes: todasInteiras(declaracoes, 'lockfile-mudou', lockfiles), cache };
+    const lanes = {};
+    for (const [lane, declaracao] of Object.entries(declaracoes)) {
+        if (!declaracao.mapeia.length) {
+            lanes[lane] = inteira('runner-sem-garantia');
+            continue;
+        }
+        const configuracao = mudados.filter((arquivo) => (declaracao.configuracao ?? [])
+            .some((glob) => (0, leases_1.caminhoBateComGlob)(arquivo, glob)));
+        if (configuracao.length) {
+            lanes[lane] = inteira('configuracao-mudou', configuracao);
+            continue;
+        }
+        const fora = mudados.filter((arquivo) => !declaracao.mapeia.some((glob) => (0, leases_1.caminhoBateComGlob)(arquivo, glob)));
+        if (fora.length) {
+            lanes[lane] = inteira('fora-do-mapeamento', fora);
+            continue;
+        }
+        if (!mudados.length) {
+            lanes[lane] = inteira('sem-mudancas');
+            continue;
+        }
+        lanes[lane] = { modo: 'selecionada', motivo: 'selecionada', arquivos: mudados,
+            base: anterior.head, comando: comandoDaSelecao(declaracao, anterior.head, mudados) };
+    }
+    return { lanes, cache };
+}

package/dist/codex-task-complete.js

@@ -0,0 +1,95 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.taskCompleteFixadoDaFonte = taskCompleteFixadoDaFonte;
+exports.taskCompleteFixadoDaSessao = taskCompleteFixadoDaSessao;
+/** RM-075: prova somente leitura de `task_complete` no rollout já fixado pelo controller. */
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const node_crypto_1 = require("node:crypto");
+const codex_controller_sensor_1 = require("./adapters/codex-controller-sensor");
+const codex_events_1 = require("./adapters/codex-events");
+const thread_1 = require("./thread");
+const BLOCO = 256 * 1024;
+const chaveDaFonte = (sessionId, despachoEm) => (0, node_crypto_1.createHash)('sha256').update(sessionId + '|' + despachoEm).digest('hex');
+/** O parser percorre o descritor autenticado inteiro; linha parcial ou corrupção não prova terminal. */
+function taskCompleteFixadoDaFonte(fonte, agoraMs = Date.now()) {
+    return (0, codex_controller_sensor_1.consumirRolloutControllerFixado)(fonte, (fd, tamanho) => {
+        const parser = new codex_events_1.ParserCodex();
+        let terminal = null;
+        for (let offset = 0; offset < tamanho;) {
+            const buffer = Buffer.alloc(Math.min(BLOCO, tamanho - offset));
+            const lidos = fs.readSync(fd, buffer, 0, buffer.length, offset);
+            if (lidos <= 0)
+                break;
+            for (const atual of parser.push(buffer.subarray(0, lidos), agoraMs))
+                terminal = atual;
+            offset += lidos;
+        }
+        if (parser.estado.invalido || parser.bytesPendentes > 0 || parser.estado.turnoAberto ||
+            terminal?.fonte !== 'rollout.task_complete' ||
+            (terminal.numeroTurno ?? 0) < parser.estado.turnos)
+            return null;
+        return { terminal, fonte };
+    });
+}
+/**
+ * Resolve somente a fixação correspondente ao despacho. Sem pin autenticado, controller ou cwd,
+ * devolve `null`: nunca descobre outro rollout para fabricar a prova.
+ */
+function taskCompleteFixadoDaSessao(raiz, thread, sessao, eventos, agoraMs = Date.now()) {
+    if (sessao.runtime !== 'codex')
+        return null;
+    const registro = eventos.filter(e => e.tipo === 'session_sensor_registered' &&
+        e.sessionId === sessao.sessionId && e.despachoEm === sessao.despachadaEm).at(-1);
+    if (typeof registro?.controlador !== 'string')
+        return null;
+    const despacho = eventos.filter(e => e.tipo === 'phase_dispatch' && e.sessionId === sessao.sessionId).at(-1);
+    if (despacho?.controlador !== undefined && despacho.controlador !== registro.controlador)
+        throw new Error('controlador registrado divergente do despacho');
+    const cwd = (despacho?.cwd ?? registro.cwd);
+    if (!cwd)
+        return null;
+    const dir = (0, thread_1.dirThread)(raiz, thread.id);
+    const chave = chaveDaFonte(sessao.sessionId, sessao.despachadaEm);
+    const esperado = {
+        dirSessoes: path.join(dir, 'sessoes'), sessionId: sessao.sessionId, cwd,
+        despachoEm: sessao.despachadaEm, agoraMs,
+        fixacao: path.join(dir, 'sessoes', `watcher-source-${chave}.json`),
+        vinculo: { thread: thread.id, fase: sessao.fase, promptSha256: sessao.promptSha256 },
+    };
+    const fonte = (0, codex_controller_sensor_1.lerFonteControllerFixada)(esperado.fixacao, esperado);
+    return fonte ? taskCompleteFixadoDaFonte(fonte, agoraMs) : null;
+}