@orkastery/cli 0.6.5 → 0.6.6

package/adapters/openclaw/openclaw.plugin.json

@@ -2,7 +2,7 @@
   "id": "orkastery",
   "name": "Orkastery",
   "description": "Conducao de looping threads em 6 fases pelo nucleo `ork`, exposta ao OpenClaw como tools `ork_*`. Zero regra de negocio no host: cada tool e uma chamada de CLI. Toda tool de projeto aceita projeto (nome do projeto pedido); o cwd do gateway nunca escolhe o projeto. O status do roadmap vem de ork_network_roadmap; as maquinas da pessoa, de ork_network_status (sem projeto).",
-  "version": "0.6.5",
+  "version": "0.6.6",
   "configSchema": {
     "type": "object",
     "properties": {},

package/adapters/openclaw/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@orkastery/openclaw-plugin",
-  "version": "0.6.5",
+  "version": "0.6.6",
   "description": "Plugin Orkastery para OpenClaw: 32 tools ork_* que traduzem intencao em chamada de CLI do nucleo `ork`. Zero regra de negocio no host.",
   "type": "module",
   "private": true,

package/dist/session-watcher.js

@@ -39,6 +39,8 @@ exports.reconciliarSessaoSemWatcher = reconciliarSessaoSemWatcher;
 exports.validarRegistroWatcher = validarRegistroWatcher;
 exports.validarFonteWatcher = validarFonteWatcher;
 exports.prepararFonteWatcher = prepararFonteWatcher;
+exports.esperarProntidaoWatcher = esperarProntidaoWatcher;
+exports.esperarConfirmacaoDoPaiWatcher = esperarConfirmacaoDoPaiWatcher;
 exports.iniciarWatcher = iniciarWatcher;
 exports.acompanharSessao = acompanharSessao;
 /** D6: observador restrito a uma sessão, cursor canônico e resultados idempotentes. */
@@ -906,6 +908,61 @@ function prepararFonteWatcher(raiz, sessionId, fonte) {
             throw e;
     }
 }
+class ErroDoApertoWatcher extends Error {
+    encerrarOutro;
+    constructor(message, encerrarOutro) {
+        super(message);
+        this.encerrarOutro = encerrarOutro;
+    }
+}
+const TETO_ABSOLUTO_APERTO_WATCHER_MS = 60000;
+const PAUSA_APERTO_WATCHER = new Int32Array(new SharedArrayBuffer(4));
+function conferirTetoDoAperto(tetoMs) {
+    if (!Number.isFinite(tetoMs) || tetoMs <= 0)
+        throw new Error('teto invalido para o aperto de mao do watcher');
+}
+/** Lado do dispatcher: lentidao nao encerra um watcher cuja identidade continua viva. */
+function esperarProntidaoWatcher(lerSinal, identidade, opcoes = {}) {
+    const agora = opcoes.agora ?? Date.now;
+    const estado = opcoes.estado ?? codex_runner_1.estadoProcesso;
+    const pausar = opcoes.pausar ?? ((ms) => { Atomics.wait(PAUSA_APERTO_WATCHER, 0, 0, ms); });
+    const tetoProntidaoMs = opcoes.tetoMs ?? TETO_ABSOLUTO_APERTO_WATCHER_MS;
+    conferirTetoDoAperto(tetoProntidaoMs);
+    const inicio = agora();
+    for (;;) {
+        if (agora() - inicio >= tetoProntidaoMs)
+            throw new ErroDoApertoWatcher('watcher sem prontidao confirmada', true);
+        const sinal = lerSinal();
+        if (sinal === 'confirmado')
+            return;
+        if (sinal === 'invalido')
+            throw new ErroDoApertoWatcher('watcher com prontidao invalida', true);
+        if (estado(identidade) === 'ausente')
+            throw new ErroDoApertoWatcher('watcher sem prontidao confirmada', false);
+        const restante = tetoProntidaoMs - (agora() - inicio);
+        pausar(Math.min(10, Math.max(1, restante)));
+    }
+}
+/** Lado do watcher: o ack continua pendente somente enquanto o pai capturado na partida nao saiu. */
+async function esperarConfirmacaoDoPaiWatcher(lerSinal, identidadePai, opcoes = {}) {
+    const agora = opcoes.agora ?? Date.now;
+    const estado = opcoes.estado ?? codex_runner_1.estadoProcesso;
+    const pausar = opcoes.pausar ?? ((ms) => new Promise(resolve => setTimeout(resolve, ms)));
+    const tetoConfirmacaoMs = opcoes.tetoMs ?? TETO_ABSOLUTO_APERTO_WATCHER_MS;
+    conferirTetoDoAperto(tetoConfirmacaoMs);
+    const inicio = agora();
+    for (;;) {
+        if (agora() - inicio >= tetoConfirmacaoMs)
+            throw new ErroDoApertoWatcher('watcher sem confirmacao do pai', false);
+        const sinal = lerSinal();
+        if (sinal === 'confirmado')
+            return;
+        if (sinal === 'invalido' || estado(identidadePai) === 'ausente')
+            throw new ErroDoApertoWatcher('watcher sem confirmacao do pai', false);
+        const restante = tetoConfirmacaoMs - (agora() - inicio);
+        await pausar(Math.min(10, Math.max(1, restante)));
+    }
+}
 function iniciarWatcher(raiz, sessionId) {
     const { thread, sessao: registrada } = (0, session_events_1.resolverSessao)(raiz, sessionId);
     const sessao = (0, session_events_1.exigirSessaoDespachada)(registrada, sessionId);
@@ -947,27 +1004,29 @@ function iniciarWatcher(raiz, sessionId) {
     try {
         if (!identidade)
             throw new Error('watcher sem identidade de processo');
-        const deadline = Date.now() + 5000;
-        const pausa = new Int32Array(new SharedArrayBuffer(4));
-        while (Date.now() < deadline) {
-            const ready = lerJson(readyPath);
-            if (ready && ready.token === token && ready.sessionId === sessionId && ready.despachoEm === sessao.despachadaEm &&
-                JSON.stringify(ready.identidade) === JSON.stringify(identidade) && (0, codex_runner_1.estadoProcesso)(identidade) === 'vivo') {
-                (0, ledger_1.registrar)(dir, thread.id, 'session_watcher_started', { fase: sessao.fase, sessionId,
-                    despachoEm: sessao.despachadaEm, pid: identidade.pid, identidade, readyPath, token });
-                (0, codex_runner_1.gravarAtomico)(ackPath, { token });
-                return identidade.pid;
+        esperarProntidaoWatcher(() => {
+            if (!fs.existsSync(readyPath))
+                return 'pendente';
+            let ready;
+            try {
+                ready = lerJson(readyPath);
             }
-            if ((0, codex_runner_1.estadoProcesso)(identidade) === 'ausente')
-                break;
-            Atomics.wait(pausa, 0, 0, 10);
-        }
-        throw new Error('watcher sem prontidao confirmada');
+            catch {
+                return 'invalido';
+            }
+            return ready && ready.token === token && ready.sessionId === sessionId && ready.despachoEm === sessao.despachadaEm &&
+                JSON.stringify(ready.identidade) === JSON.stringify(identidade) && (0, codex_runner_1.estadoProcesso)(identidade) === 'vivo'
+                ? 'confirmado' : 'invalido';
+        }, identidade);
+        (0, ledger_1.registrar)(dir, thread.id, 'session_watcher_started', { fase: sessao.fase, sessionId,
+            despachoEm: sessao.despachadaEm, pid: identidade.pid, identidade, readyPath, token });
+        (0, codex_runner_1.gravarAtomico)(ackPath, { token });
+        return identidade.pid;
     }
     catch (e) {
         falha();
-        // Encerrar apenas o filho cuja identidade continua sendo a capturada no spawn.
-        if (identidade && (0, codex_runner_1.estadoProcesso)(identidade) === 'vivo')
+        // Lentidao dentro do teto nao encerra o filho; so teto ou prontidao invalida autorizam o sinal.
+        if (e instanceof ErroDoApertoWatcher && e.encerrarOutro && identidade && (0, codex_runner_1.estadoProcesso)(identidade) === 'vivo')
             child.kill('SIGTERM');
         throw e;
     }
@@ -978,18 +1037,30 @@ async function acompanhar() {
     try {
         const readyPath = process.argv[5], token = process.argv[6];
         if (readyPath && token) {
+            const identidadePai = (0, codex_runner_1.identidadeProcesso)(process.ppid);
+            if (!identidadePai)
+                throw new Error('watcher sem confirmacao do pai');
             validarRegistroWatcher(carregado.raiz, sessionId);
             const sessao = (0, session_events_1.exigirSessaoDespachada)((0, session_events_1.resolverSessao)(carregado.raiz, sessionId, threadId).sessao, sessionId);
             const identidade = (0, codex_runner_1.identidadeProcesso)(process.pid);
             if (!identidade)
                 throw new Error('watcher sem identidade propria');
             (0, codex_runner_1.gravarAtomico)(readyPath, { token, sessionId, despachoEm: sessao.despachadaEm, identidade });
-            const deadline = Date.now() + 5000;
-            while (lerJson(readyPath + '.ack')?.token !== token) {
-                if (Date.now() >= deadline)
-                    throw new Error('watcher sem confirmacao do pai');
-                await new Promise(r => setTimeout(r, 10));
-            }
+            await esperarConfirmacaoDoPaiWatcher(() => {
+                if (!(0, ledger_1.threadPresente)((0, thread_1.dirThread)(carregado.raiz, threadId)))
+                    return 'invalido';
+                const ackPath = readyPath + '.ack';
+                if (!fs.existsSync(ackPath))
+                    return 'pendente';
+                let ack;
+                try {
+                    ack = lerJson(ackPath);
+                }
+                catch {
+                    return 'invalido';
+                }
+                return ack?.token === token ? 'confirmado' : 'invalido';
+            }, identidadePai);
         }
         await acompanharSessao(carregado, sessionId, { threadId });
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@orkastery/cli",
-  "version": "0.6.5",
+  "version": "0.6.6",
   "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",