@loicngr/kobo 1.11.35 → 1.11.37

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

@@ -255,6 +255,7 @@ export function createClaudeCodeEngine() {
             let iteratorRunning = false;
             let userInterrupted = false;
             let completedResponses = 0;
+            let waitingForBackground = false;
             let turnCompletedEmittedForResponse = 0;
             // `result` is the Claude Agent SDK's per-turn completion signal. Keep
             // it distinct from iterator completion: the SDK may still drain
@@ -433,6 +434,11 @@ export function createClaudeCodeEngine() {
                 turnLiveness.start();
                 try {
                     for await (const msg of q) {
+                        // A parent continuation owns the foreground again. Background
+                        // progress notifications alone do not end the between-turn wait.
+                        if (msg.type === 'assistant' || msg.type === 'user' || msg.type === 'stream_event') {
+                            waitingForBackground = false;
+                        }
                         // This SDK message proves that any drain condition armed by a
                         // *previous* message is no longer current. A drain armed while
                         // processing this message remains active if the generator then
@@ -495,6 +501,7 @@ export function createClaudeCodeEngine() {
                         turnLiveness.setTimeoutMs(pendingToolCallIds.size > 0 ? CLAUDE_TOOL_IDLE_TIMEOUT_MS : CLAUDE_STREAM_IDLE_TIMEOUT_MS);
                         reevaluateLivenessPause();
                         if (msg.type === 'result') {
+                            waitingForBackground = false;
                             pendingToolCallIds.clear();
                             completedResponses++;
                             emitTurnCompletedIfSettled();
@@ -506,6 +513,7 @@ export function createClaudeCodeEngine() {
                                     armResultDrainWatchdog();
                                 }
                                 else {
+                                    waitingForBackground = true;
                                     armSubagentStallWatchdog();
                                 }
                             }
@@ -583,6 +591,24 @@ export function createClaudeCodeEngine() {
                         throw new Error(`Claude ${AGENT_NO_LONGER_RUNNING_TEXT}`);
                     inputStream.send(text);
                 },
+                sendWakeupIfWaiting(text) {
+                    if (!iteratorRunning ||
+                        abortController.signal.aborted ||
+                        mapperState.sawErrorResult ||
+                        !waitingForBackground ||
+                        activeSubagentTaskIds.size === 0 ||
+                        pendingToolCallIds.size > 0 ||
+                        pendingResolvers.size > 0 ||
+                        isCompacting ||
+                        inputStream.hasUnansweredInput(completedResponses))
+                        return false;
+                    inputStream.send(text);
+                    waitingForBackground = false;
+                    // The wakeup starts another turn on this stream; its result will
+                    // re-arm the stall deadline if background work is still outstanding.
+                    clearSubagentStallWatchdog();
+                    return true;
+                },
                 interrupt() {
                     userInterrupted = true;
                     // The SDK ends an interrupted run by emitting a `result` with

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

@@ -63,20 +63,20 @@ function normalizeRateLimitInfo(info) {
 }
 // ── Public API ────────────────────────────────────────────────────────────────
 /**
- * Canonical "out of quota" surfaces from the Claude SDK and CLI. Centralised
- * so the three call-sites stay in sync:
- *  - `result` events with an error subtype (`parsed.error` / `parsed.result`)
- *  - assistant `message:text` blocks (the SDK occasionally streams the user-
- *    visible quota notice as plain assistant text instead of a structured
- *    error result; see workspace `-GyiAYM7X4xTWyZbcHGiR` session #25 for the
- *    repro that motivated this path)
- *  - CLI stderr in `engine.ts`
+ * Quota keywords for error results and CLI stderr. Assistant prose uses
+ * the narrower ASSISTANT_QUOTA_NOTICE below, because summaries may mention
+ * a previous quota failure while the current run is working normally.
  *
  * Patterns are kept loose on purpose to absorb minor wording drift between
  * Anthropic's surfaces (`rate_limit_exceeded`, `Claude AI usage limit
  * reached`, `You're out of extra usage`, `quota exceeded`).
  */
 export const QUOTA_PATTERN = /\b429\b|out of extra usage|rate[_ ]limit|usage limit|quota exceeded/i;
+/** Only canonical, standalone notices qualify on the assistant prose surface.
+ * Broad quota keywords remain appropriate for structured errors, not summaries
+ * of a previous attempt, a sub-agent failure, or application HTTP handling.
+ */
+const ASSISTANT_QUOTA_NOTICE = /^(?:you(?:'|’)re out of extra usage|you(?:'|’)ve hit your (?:session|weekly|usage) limit|claude ai usage limit reached|usage limit reached|quota exceeded|rate limit exceeded)(?:[.!]?(?:[ \t]*[·—-]?[ \t]*resets?\b[^\r\n]*)?)?[.!]?$/i;
 export function createMapperState() {
     return {
         sessionStartedEmitted: false,
@@ -274,8 +274,8 @@ export function mapSdkMessage(msg, state) {
                 // Last-resort fallback: some SDK runs surface the quota notice as
                 // plain assistant text without setting `assistant.error` or a
                 // `result.error`. The structured signals above cover modern SDK
-                // versions; this regex absorbs older or drifted wordings.
-                if (QUOTA_PATTERN.test(text)) {
+                // versions; only a standalone notice qualifies on this prose surface.
+                if (ASSISTANT_QUOTA_NOTICE.test(text.trim())) {
                     tryEmitQuotaError(state, events, text);
                 }
             }

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

@@ -302,13 +302,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. */
+            }
         },
     };
 }