@loicngr/kobo 1.11.12 → 1.11.13

package/CHANGELOG.md

@@ -4,6 +4,10 @@ All notable changes to Kōbō are documented here. The format is based on
 [Keep a Changelog](https://keepachangelog.com/). Each release is an `## <version>`
 section — the in-app "What's new" dialog reads this file.
 
+## 1.11.13
+
+- fix(engines): unstick agent sessions that never emit session:ended
+
 ## 1.11.12
 
 - ✨ develop - feat(engines): Garder les sessions ouvertes pour les subagents en arrière-plan

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

@@ -20,6 +20,12 @@ const RESULT_DRAIN_TIMEOUT_MS = 15_000;
 // without producing a result message. Keep a separate, conservative guard for
 // that shape; active tool/message traffic always cancels and re-arms it.
 const TEXT_IDLE_TIMEOUT_MS = 120_000;
+// Safety net for a subagent whose terminal `task_notification` carries a
+// status outside the mapper's known-terminal set (SDK schema drift) — it
+// never clears `activeSubagentToolCallIds`, which otherwise blocks
+// `inputStream.close()`/the result-drain watchdog forever. Generous window:
+// legitimate subagents can run for several minutes.
+const SUBAGENT_STALL_TIMEOUT_MS = 10 * 60_000;
 const MAX_PENDING_USER_MESSAGES = 20;
 function toMcpServersMap(specs) {
     if (!specs || specs.length === 0)
@@ -278,6 +284,41 @@ export function createClaudeCodeEngine() {
                 }, RESULT_DRAIN_TIMEOUT_MS);
                 resultDrainTimer.unref?.();
             };
+            // Safety net for the "waiting on a background subagent" branch below:
+            // if `activeSubagentToolCallIds` never empties (a missed/unrecognised
+            // terminal notification), the workspace would otherwise stay `executing`
+            // forever. Force the drain through once this fires.
+            let subagentStallTimer;
+            const clearSubagentStallWatchdog = () => {
+                if (!subagentStallTimer)
+                    return;
+                clearTimeout(subagentStallTimer);
+                subagentStallTimer = undefined;
+            };
+            // Re-armed (not merely armed-once) on every qualifying `result` so the
+            // deadline tracks the last observed activity, matching the warning
+            // message below — a long chain of legitimate subagent-backed turns
+            // must not be cut off just because 10 minutes have passed in total.
+            const armSubagentStallWatchdog = () => {
+                clearSubagentStallWatchdog();
+                subagentStallTimer = setTimeout(() => {
+                    subagentStallTimer = undefined;
+                    // A message queued between arming and firing means a new turn is
+                    // about to start on this same stream — don't discard the subagent
+                    // tracking or force-close under it; the next 'result' re-evaluates.
+                    if (inputStream.hasUnansweredInput(completedResponses))
+                        return;
+                    console.warn(`[claude-engine] Subagent(s) still tracked active ${SUBAGENT_STALL_TIMEOUT_MS}ms after the last turn ended — forcing session drain.`);
+                    activeSubagentToolCallIds.clear();
+                    // This is a forced, unclean termination (the subagent may still be
+                    // alive server-side) — never report it as a normal completion, so
+                    // auto-loop doesn't treat an orphaned run as forward progress.
+                    mapperState.sawErrorResult = true;
+                    inputStream.close();
+                    armResultDrainWatchdog();
+                }, SUBAGENT_STALL_TIMEOUT_MS);
+                subagentStallTimer.unref?.();
+            };
             const iteratorPromise = (async () => {
                 iteratorRunning = true;
                 try {
@@ -291,6 +332,17 @@ export function createClaudeCodeEngine() {
                             else
                                 activeSubagentToolCallIds.delete(ev.toolCallId);
                         }
+                        // The stall watchdog is only armed while we're waiting purely on
+                        // background subagents (no further SDK turn expected unless one
+                        // reports done). React the moment the last one clears instead of
+                        // waiting for a 'result' message that may never come.
+                        if (subagentStallTimer &&
+                            activeSubagentToolCallIds.size === 0 &&
+                            !inputStream.hasUnansweredInput(completedResponses)) {
+                            clearSubagentStallWatchdog();
+                            inputStream.close();
+                            armResultDrainWatchdog();
+                        }
                         for (const ev of events) {
                             if (ev.kind === 'session:started')
                                 discoveredSessionId = ev.engineSessionId;
@@ -307,9 +359,15 @@ export function createClaudeCodeEngine() {
                             clearTextIdleWatchdog();
                             completedResponses++;
                             // A queued forced message starts the next response on this same SDK stream.
-                            if (!inputStream.hasUnansweredInput(completedResponses) && activeSubagentToolCallIds.size === 0) {
-                                inputStream.close();
-                                armResultDrainWatchdog();
+                            if (!inputStream.hasUnansweredInput(completedResponses)) {
+                                if (activeSubagentToolCallIds.size === 0) {
+                                    clearSubagentStallWatchdog();
+                                    inputStream.close();
+                                    armResultDrainWatchdog();
+                                }
+                                else {
+                                    armSubagentStallWatchdog();
+                                }
                             }
                         }
                     }
@@ -354,6 +412,7 @@ export function createClaudeCodeEngine() {
                         resultDrainTimer = undefined;
                     }
                     clearTextIdleWatchdog();
+                    clearSubagentStallWatchdog();
                     // Drain any callback still pending (SDK terminated while awaiting an
                     // answer). canUseTool's abort path covers signalled stops; this
                     // covers natural iterator completion.
@@ -391,6 +450,20 @@ export function createClaudeCodeEngine() {
                     // subtype `error_during_execution` through the normal iterator —
                     // the mapper needs this flag to treat it as a clean stop.
                     mapperState.userInterrupted = true;
+                    // The soft interrupt below only ends the foreground turn — a
+                    // background subagent task keeps running unless told to stop via
+                    // its own API, which would otherwise leave the Stop button
+                    // appearing to do nothing for up to SUBAGENT_STALL_TIMEOUT_MS.
+                    for (const taskId of activeSubagentToolCallIds) {
+                        try {
+                            void q.stopTask(taskId).catch(() => {
+                                /* best-effort */
+                            });
+                        }
+                        catch {
+                            /* best-effort */
+                        }
+                    }
                     const qq = q;
                     if (typeof qq.interrupt === 'function') {
                         try {

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

@@ -195,10 +195,12 @@ export function mapSdkMessage(msg, state) {
             const toolCallId = typeof parsed.tool_use_id === 'string' ? parsed.tool_use_id : undefined;
             if (toolCallId) {
                 const usage = parsed.usage;
-                const taskStatus = typeof parsed.status === 'string' ? parsed.status : undefined;
-                const isDone = subtype === 'task_notification' &&
-                    taskStatus !== undefined &&
-                    ['completed', 'stopped', 'failed', 'cancelled'].includes(taskStatus);
+                // Unlike task_started/task_progress (in-flight signals), task_notification
+                // is only ever emitted once a task settles — its `status` value is a
+                // reason, not a liveness signal. Treat every task_notification as
+                // terminal instead of matching against a status whitelist, so an SDK
+                // status value added later doesn't leave the subagent stuck 'running'.
+                const isDone = subtype === 'task_notification';
                 events.push({
                     kind: 'subagent:progress',
                     toolCallId,

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

@@ -11,6 +11,13 @@ import { createTurnLiveness } from './turn-liveness.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_GRACEFUL_INTERRUPT_TIMEOUT_MS = 3_000;
+// Safety net while `turnLiveness` is paused for background subagents: that
+// pause is deliberately unbounded (a legitimate subagent can run long), but
+// if a thread never reports a terminal status (dropped notification, or the
+// sub-thread's own process hanging), nothing else would ever resume it or
+// resolve `turnDonePromise` — the session would hang forever. Generous
+// window, refreshed on every observed subagent-thread status change.
+export const CODEX_SUBAGENT_STALL_TIMEOUT_MS = 10 * 60_000;
 function wait(ms) {
     return new Promise((resolve) => setTimeout(resolve, ms));
 }
@@ -108,6 +115,30 @@ export function createCodexEngine() {
                 resolveTurnDone = resolve;
                 rejectTurnDone = reject;
             });
+            let subagentStallTimer;
+            const clearSubagentStallWatchdog = () => {
+                if (!subagentStallTimer)
+                    return;
+                clearTimeout(subagentStallTimer);
+                subagentStallTimer = undefined;
+            };
+            // Re-armed on every observed subagent-thread status change so the
+            // deadline tracks the last activity, not the start of the wait.
+            const armSubagentStallWatchdog = () => {
+                clearSubagentStallWatchdog();
+                subagentStallTimer = setTimeout(() => {
+                    subagentStallTimer = undefined;
+                    console.warn(`[codex-engine] Background subagent thread(s) still tracked active ${CODEX_SUBAGENT_STALL_TIMEOUT_MS}ms after the turn completed — forcing session drain.`);
+                    activeSubagentThreads.clear();
+                    // Forced, unclean termination (a thread may still be alive
+                    // server-side) — never report it as a normal completion, so
+                    // auto-loop doesn't treat an orphaned run as forward progress.
+                    mapperState.sawErrorResult = true;
+                    if (waitingForBackgroundSubagents)
+                        resolveTurnDone();
+                }, CODEX_SUBAGENT_STALL_TIMEOUT_MS);
+                subagentStallTimer.unref?.();
+            };
             const finishBackgroundSubagent = (threadId, alreadyEmittedToolCallId) => {
                 const tracked = activeSubagentThreads.get(threadId);
                 if (!tracked)
@@ -122,8 +153,15 @@ export function createCodexEngine() {
                         taskType: tracked.taskType,
                     });
                 }
-                if (waitingForBackgroundSubagents && activeSubagentThreads.size === 0)
-                    resolveTurnDone();
+                if (waitingForBackgroundSubagents) {
+                    if (activeSubagentThreads.size === 0) {
+                        clearSubagentStallWatchdog();
+                        resolveTurnDone();
+                    }
+                    else {
+                        armSubagentStallWatchdog();
+                    }
+                }
             };
             const turnLiveness = createTurnLiveness({
                 timeoutMs: CODEX_TURN_IDLE_TIMEOUT_MS,
@@ -227,6 +265,7 @@ export function createCodexEngine() {
                             if (n.turn?.status === 'completed' && activeSubagentThreads.size > 0) {
                                 waitingForBackgroundSubagents = true;
                                 turnLiveness.pause();
+                                armSubagentStallWatchdog();
                             }
                             else {
                                 resolveTurnDone();
@@ -364,8 +403,21 @@ export function createCodexEngine() {
                 }
                 finally {
                     turnLiveness.stop();
+                    clearSubagentStallWatchdog();
                     streamingBatcher.close();
                     iteratorRunning = false;
+                    // Drain any outstanding approval/elicitation request (SDK terminated
+                    // while awaiting a human decision) — without a response, Codex's own
+                    // process would otherwise wait forever for a reply that never comes.
+                    for (const pending of pendingByCallId.values()) {
+                        try {
+                            client.peer.respondError(pending.requestId, -32000, 'session ended');
+                        }
+                        catch {
+                            // best-effort
+                        }
+                    }
+                    pendingByCallId.clear();
                     client.close();
                     try {
                         child.kill('SIGTERM');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@loicngr/kobo",
-  "version": "1.11.12",
+  "version": "1.11.13",
   "description": "Kōbō — multi-workspace agent manager for Claude Code. Orchestrates isolated git worktrees with dev servers, Notion integration, and MCP tools.",
   "type": "module",
   "license": "GPL-3.0-or-later",