@loicngr/kobo 1.11.36 → 1.11.38

package/dist/server/services/agent/engines/claude-code/engine.js

@@ -353,6 +353,7 @@ export function createClaudeCodeEngine() {
                         return;
                     console.warn(`[claude-engine] Compaction still reported active ${COMPACTION_STALL_TIMEOUT_MS}ms after it started — resuming the liveness deadline.`);
                     isCompacting = false;
+                    safeEmit({ kind: 'session:compacting', active: false });
                     reevaluateLivenessPause();
                     if (activeSubagentTaskIds.size > 0 && !subagentStallTimer) {
                         // Resume declined because a subagent is still tracked — but the
@@ -468,6 +469,16 @@ export function createClaudeCodeEngine() {
                                 clearCompactionStallTimer();
                             }
                         }
+                        // Actual foreground output proves work resumed even if the SDK
+                        // omitted its trailing status/compact_boundary message. Tool results
+                        // and background progress can drain during compaction, so exclude them.
+                        if (isCompacting &&
+                            !('parent_tool_use_id' in msg && msg.parent_tool_use_id != null) &&
+                            events.some((ev) => ev.kind === 'message:text' || ev.kind === 'message:thinking' || ev.kind === 'tool:call')) {
+                            isCompacting = false;
+                            clearCompactionStallTimer();
+                            safeEmit({ kind: 'session:compacting', active: false });
+                        }
                         for (const ev of events) {
                             if (ev.kind === 'tool:call')
                                 pendingToolCallIds.add(ev.toolCallId);

package/dist/server/services/agent/engines/codex/client.js

@@ -15,6 +15,7 @@ export function createAppServerClient(opts) {
         onNotification: opts.onNotification ?? (() => { }),
         onServerRequest: opts.onServerRequest ?? (() => { }),
         onError: opts.onError,
+        onDisconnect: opts.onDisconnect,
     });
     return {
         peer,

package/dist/server/services/agent/engines/codex/engine.js

@@ -11,6 +11,7 @@ import { buildResponseForResolve, handleServerRequest } from './server-requests.
 import { spawnAppServer } from './spawn.js';
 /** Long enough for normal tool work, short enough to recover a lost turn event. */
 export const CODEX_TURN_IDLE_TIMEOUT_MS = 120_000;
+export const CODEX_TOOL_IDLE_TIMEOUT_MS = 30 * 60_000;
 export const CODEX_GRACEFUL_INTERRUPT_TIMEOUT_MS = 3_000;
 /** Grace given to a SIGTERM before the child is killed outright. */
 const CODEX_FORCE_KILL_TIMEOUT_MS = 3_000;
@@ -24,6 +25,35 @@ export const CODEX_SUBAGENT_STALL_TIMEOUT_MS = 10 * 60_000;
 function wait(ms) {
     return new Promise((resolve) => setTimeout(resolve, ms));
 }
+/** A sent signal is only a request; resolve true exclusively on confirmed exit. */
+function signalAndWaitForExit(child, signal, timeoutMs) {
+    if (child.exitCode !== null || child.signalCode !== null || child.pid === undefined)
+        return Promise.resolve(true);
+    return new Promise((resolve, reject) => {
+        const cleanup = () => {
+            clearTimeout(timer);
+            child.removeListener('exit', onExit);
+        };
+        const onExit = () => {
+            cleanup();
+            resolve(true);
+        };
+        const timer = setTimeout(() => {
+            cleanup();
+            resolve(false);
+        }, timeoutMs);
+        timer.unref?.();
+        // Install before signalling so an immediate exit cannot be missed.
+        child.once('exit', onExit);
+        try {
+            child.kill(signal);
+        }
+        catch (err) {
+            cleanup();
+            reject(err);
+        }
+    });
+}
 class CodexTurnTimeoutError extends Error {
     constructor() {
         super('Codex stopped reporting activity for this turn');
@@ -77,7 +107,17 @@ export function createCodexEngine() {
                 }
             };
             const streamingBatcher = createStreamingBatcher(emitDirect);
-            const safeEmit = (ev) => streamingBatcher.push(ev);
+            const pendingToolCalls = new Set();
+            const safeEmit = (ev) => {
+                if (ev.kind === 'tool:call')
+                    pendingToolCalls.add(ev.toolCallId);
+                if (ev.kind === 'tool:result')
+                    pendingToolCalls.delete(ev.toolCallId);
+                if (ev.kind === 'tool:call' || ev.kind === 'tool:result') {
+                    turnLiveness.setTimeoutMs(pendingToolCalls.size ? CODEX_TOOL_IDLE_TIMEOUT_MS : CODEX_TURN_IDLE_TIMEOUT_MS);
+                }
+                streamingBatcher.push(ev);
+            };
             let rejectChildFailure;
             const childFailurePromise = new Promise((_resolve, reject) => {
                 rejectChildFailure = reject;
@@ -324,6 +364,7 @@ export function createCodexEngine() {
                         autoApprove: (toolName, payload) => isWorkspacePermissionAllowed(options.workspaceId, { engine: 'codex', toolName, payload }),
                     });
                 },
+                onDisconnect: rejectChildFailure,
                 onError(err) {
                     console.error('[codex] JSON-RPC transport error:', err);
                     rejectTurnDone(err);
@@ -428,6 +469,7 @@ export function createCodexEngine() {
                         }
                     }
                     pendingByCallId.clear();
+                    pendingToolCalls.clear();
                     client.close();
                     try {
                         child.kill('SIGTERM');
@@ -515,15 +557,10 @@ export function createCodexEngine() {
                     // stop, the archive, the delete and Kōbō's own shutdown, holding the
                     // worktree and its share of the model quota, with nothing left in
                     // this process tracking it.
-                    if (child.exitCode === null && child.signalCode === null) {
-                        child.kill('SIGTERM');
-                        const exited = await Promise.race([
-                            new Promise((resolve) => child.once('exit', () => resolve(true))),
-                            wait(CODEX_FORCE_KILL_TIMEOUT_MS).then(() => false),
-                        ]);
-                        if (!exited) {
-                            console.warn('[codex] app-server ignored SIGTERM — sending SIGKILL');
-                            child.kill('SIGKILL');
+                    if (!(await signalAndWaitForExit(child, 'SIGTERM', CODEX_FORCE_KILL_TIMEOUT_MS))) {
+                        console.warn('[codex] app-server ignored SIGTERM — sending SIGKILL');
+                        if (!(await signalAndWaitForExit(child, 'SIGKILL', CODEX_FORCE_KILL_TIMEOUT_MS))) {
+                            throw new Error('Codex app-server did not exit after SIGKILL');
                         }
                     }
                 },

package/dist/server/services/agent/engines/codex/event-mapper.js

@@ -179,7 +179,7 @@ export function handleItemStarted(item, state) {
         return events;
     }
     if (item.type === 'contextCompaction') {
-        events.push({ kind: 'session:compacted' });
+        events.push({ kind: 'session:compacting', active: true });
         return events;
     }
     return events;
@@ -189,6 +189,8 @@ export function handleItemStarted(item, state) {
  */
 export function handleItemCompleted(item, state) {
     const events = [];
+    if (item.type === 'contextCompaction')
+        return [{ kind: 'session:compacted' }];
     if (item.type === 'agentMessage') {
         const text = item.text ?? '';
         const messageId = scopedId(state, item.id);
@@ -302,13 +304,17 @@ export function handleItemCompleted(item, state) {
     }
     if (item.type === 'plan') {
         // Codex's `plan` is a markdown blob, not a structured list — parse bullets.
+        const toolCallId = scopedId(state, item.id);
         events.push({
             kind: 'tool:call',
             messageId: '',
-            toolCallId: scopedId(state, item.id),
+            toolCallId,
             name: 'TodoWrite',
             input: { todos: parseCodexPlanText(item.text) },
         });
+        // The plan has already completed. Close the synthetic update so both the
+        // tool card and the engine's idle watchdog see no outstanding operation.
+        events.push({ kind: 'tool:result', toolCallId, output: null, isError: false });
         return events;
     }
     if (item.type === 'error') {

package/dist/server/services/agent/engines/codex/jsonrpc/peer.js

@@ -19,6 +19,7 @@ export class JsonRpcTimeoutError extends Error {
 }
 export function createJsonRpcPeer(opts) {
     let nextId = 1;
+    let closedError;
     const pending = new Map();
     /** Remove a pending slot and clear its deadline in one place. */
     const takePending = (id) => {
@@ -30,10 +31,21 @@ export function createJsonRpcPeer(opts) {
         pending.delete(id);
         return slot;
     };
+    const rejectPending = (err) => {
+        if (closedError)
+            return;
+        closedError = err;
+        for (const id of pending.keys())
+            takePending(id)?.reject(err);
+    };
     const transport = createJsonRpcTransport({
         stdin: opts.stdin,
         stdout: opts.stdout,
         onError: opts.onError ?? (() => { }),
+        onDisconnect(err) {
+            rejectPending(err);
+            opts.onDisconnect?.(err);
+        },
         onMessage(msg) {
             // Response to one of our requests
             if (msg.id != null && (msg.result !== undefined || msg.error !== undefined)) {
@@ -61,6 +73,8 @@ export function createJsonRpcPeer(opts) {
     });
     return {
         request(method, params, timeoutMs) {
+            if (closedError)
+                return Promise.reject(closedError);
             const id = nextId++;
             const deadlineMs = timeoutMs ?? opts.defaultRequestTimeoutMs ?? DEFAULT_JSONRPC_REQUEST_TIMEOUT_MS;
             return new Promise((resolve, reject) => {
@@ -73,7 +87,12 @@ export function createJsonRpcPeer(opts) {
                     slot.timer.unref?.();
                 }
                 pending.set(id, slot);
-                transport.send({ jsonrpc: '2.0', id, method, params });
+                try {
+                    transport.send({ jsonrpc: '2.0', id, method, params });
+                }
+                catch (err) {
+                    takePending(id)?.reject(err instanceof Error ? err : new Error(String(err)));
+                }
             });
         },
         notify(method, params) {
@@ -86,14 +105,8 @@ export function createJsonRpcPeer(opts) {
             transport.send({ jsonrpc: '2.0', id, error: { code, message } });
         },
         close() {
+            rejectPending(new Error('peer closed'));
             transport.close();
-            const err = new Error('peer closed');
-            for (const slot of pending.values()) {
-                if (slot.timer)
-                    clearTimeout(slot.timer);
-                slot.reject(err);
-            }
-            pending.clear();
         },
     };
 }

package/dist/server/services/agent/engines/codex/jsonrpc/transport.js

@@ -1,5 +1,17 @@
 export function createJsonRpcTransport(opts) {
     let buffer = '';
+    let closed = false;
+    const fail = (err) => {
+        if (closed)
+            return;
+        closed = true;
+        opts.onDisconnect?.(err);
+        opts.onError(err);
+    };
+    // Keep listeners installed through teardown: late pipe errors must stay handled.
+    opts.stdin.on('error', fail);
+    opts.stdout.on('error', fail);
+    opts.stdout.on('end', () => fail(new Error('JSON-RPC transport closed')));
     opts.stdout.setEncoding?.('utf-8');
     opts.stdout.on('data', (chunk) => {
         buffer += chunk;
@@ -19,13 +31,28 @@ export function createJsonRpcTransport(opts) {
             }
         }
     });
-    opts.stdout.on('error', opts.onError);
     return {
         send(msg) {
-            opts.stdin.write(`${JSON.stringify(msg)}\n`);
+            if (closed)
+                throw new Error('JSON-RPC transport closed');
+            try {
+                opts.stdin.write(`${JSON.stringify(msg)}\n`);
+            }
+            catch (err) {
+                fail(err instanceof Error ? err : new Error(String(err)));
+                throw err;
+            }
         },
         close() {
-            opts.stdin.end();
+            if (closed)
+                return;
+            closed = true;
+            try {
+                opts.stdin.end();
+            }
+            catch {
+                /* Already disconnected. */
+            }
         },
     };
 }

package/dist/server/services/agent/event-router.js

@@ -3,7 +3,7 @@ export function routeEvent(workspaceId, agentSessionId, event) {
     // The compaction "in progress" signal is a transient live indicator — deliver
     // it once and never persist/replay it. The persistent trace is `session:compacted`.
     if (event.kind === 'session:compacting') {
-        emitEphemeral(workspaceId, 'agent:event', event);
+        emitEphemeral(workspaceId, 'agent:event', event, agentSessionId);
         return;
     }
     if (event.kind === 'mcp:status' && event.status !== 'error') {