@loicngr/kobo 2.1.11 → 2.1.13

package/AGENTS.md

@@ -269,6 +269,18 @@ Two engines live under `src/server/services/agent/engines/`, both implementing t
 
 **Claude Code** (`claude-code/`): consumes the `@anthropic-ai/claude-agent-sdk` async iterator. The SDK manages the Claude runtime; Kōbō does not launch a separate `claude` CLI command. Authentication reuses the user's Claude login or `ANTHROPIC_API_KEY`. A settled result gets a **3 s continuation grace**, then a **15 s result-drain watchdog**. Trailing metadata and child output must not cancel the parent's drain/grace. Silence is bounded at **2 minutes** without tools, **30 minutes** for foreground tools and background shell/workflow/MCP jobs, and **10 minutes** for agents. Compaction has an absolute **10-minute** ceiling; repeated status messages cannot extend it. Human questions/permissions pause inactivity; resolution AND SDK cancellation re-evaluate that pause. Watchdogs request abort plus SDK `query.close()`; neither is proof of closure: controller ownership is released only when `EngineProcess.closed` confirms it. Never fake closure or allow a second writer if the SDK ignores termination. End emission is idempotent and timers are cleared on termination and in `finally`.
 
+After the continuation grace, Claude explicitly calls `query.close()`; closing
+the input iterator alone can leave the SDK waiting for an idle notification after
+a successful result. The 15-second drain watchdog is a failed-close backstop,
+not normal cleanup. The SDK still constructs its runtime command; Kōbō's
+`spawnClaudeCodeProcess` hook tracks actual child exit and forwards stderr.
+`EngineProcess.closed` waits for both that exit and iterator completion because
+the SDK's internal cleanup wait is bounded and can return before child exit.
+Liveness must also inspect non-empty SDK content deltas (text, thinking,
+input JSON, signature), not just mapped UI events: long reasoning/tool argument
+generation can otherwise be killed as idle. Do not count empty deltas or neutral
+metadata, or let child deltas cancel a settled parent's drain/grace.
+
 **OpenAI Codex** (`codex/`): uses the **`codex app-server` JSON-RPC protocol** (line-delimited JSON over stdio with a long-lived `codex` subprocess). The engine layers are:
 - `jsonrpc/transport.ts` + `jsonrpc/peer.ts`: generic JSON-RPC 2.0 stdio peer (request correlation, notifications, server-initiated requests)
 - `client.ts`: typed `AppServerClient` wrapping the peer (initialize / thread.start / thread.resume / turn.start / turn.interrupt)

package/CHANGELOG.md

@@ -4,6 +4,14 @@ 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.
 
+## 2.1.13
+
+- fix(claude): count streaming generation as watchdog activity
+
+## 2.1.12
+
+- fix(claude): close settled SDK sessions without false watchdogs
+
 ## 2.1.11
 
 - fix: harden agent lifecycle and workspace workflows

package/CONFIGURATION.md

@@ -1273,14 +1273,24 @@ The model selector is populated from [`src/shared/models.ts`](./src/shared/model
 #### Session watchdogs
 
 Kōbō distinguishes a finished response from a fully closed SDK session. Once a
-response is settled, it allows 3 seconds for continuation, then 15 seconds for
-SDK cleanup. Metadata alone cannot extend this cleanup deadline.
+response is settled, it allows 3 seconds for continuation, then explicitly closes
+the SDK query. Normal cleanup is reported as completion, not a watchdog failure.
+A 15-second drain watchdog remains if that close fails to end the iterator.
+Metadata alone cannot extend this cleanup deadline. Writer ownership waits for
+both iterator completion and confirmed runtime exit, even if the SDK's own
+bounded cleanup returns earlier.
 
 Silence limits are 2 minutes without a pending tool, 10 minutes for background
 agents, and 30 minutes for tools (including background Bash, workflow and MCP
 jobs). A compaction has a separate absolute 10-minute limit. Waiting for your
 answer or permission pauses the inactivity watchdog.
 
+Non-empty streaming text, reasoning, tool-argument JSON and signature fragments
+count as activity even when they are not displayed in chat. Empty deltas and
+neutral metadata do not reset inactivity, and child output cannot postpone a
+settled parent's closure. The inactivity limit measures silence, not total time
+spent generating a large plan or file.
+
 Watchdog notices remain in conversation history, but do not display a red error
 banner. Other failures retain their banners. Watchdog shutdown requests both
 cancellation and closure of the SDK transport. Kōbō still requires confirmed

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

@@ -1,3 +1,4 @@
+import { spawn } from 'node:child_process';
 import { randomUUID } from 'node:crypto';
 import { query, } from '@anthropic-ai/claude-agent-sdk';
 import { nanoid } from 'nanoid';
@@ -144,6 +145,24 @@ class ClaudeInputStream {
         return { type: 'user', uuid: randomUUID(), message: { role: 'user', content: text }, parent_tool_use_id: null };
     }
 }
+/** Generation can be active without any user-visible mapped event. */
+function hasStreamingContent(msg) {
+    if (msg.type !== 'stream_event' || msg.event.type !== 'content_block_delta')
+        return false;
+    const delta = msg.event.delta;
+    switch (delta.type) {
+        case 'text_delta':
+            return delta.text.length > 0;
+        case 'thinking_delta':
+            return delta.thinking.length > 0;
+        case 'input_json_delta':
+            return delta.partial_json.length > 0;
+        case 'signature_delta':
+            return delta.signature.length > 0;
+        default:
+            return false;
+    }
+}
 export function createClaudeCodeEngine() {
     return {
         id: 'claude-code',
@@ -327,6 +346,31 @@ export function createClaudeCodeEngine() {
                 env: options.env,
             });
             sdkOptions.abortController = abortController;
+            // SDK cleanup has its own bounded wait. Iterator completion alone does
+            // not prove that its runtime exited: retain writer ownership until both.
+            let runtimeRunning = false;
+            let runtimeClosed = Promise.resolve();
+            sdkOptions.spawnClaudeCodeProcess = ({ command, args, cwd, env, signal }) => {
+                const child = spawn(command, args, { cwd, env, signal, windowsHide: true, stdio: 'pipe' });
+                runtimeRunning = true;
+                runtimeClosed = new Promise((resolve) => {
+                    const exited = () => {
+                        runtimeRunning = false;
+                        resolve();
+                    };
+                    child.once('exit', exited);
+                    child.once('error', () => {
+                        // A failed spawn has no process; an abort/kill error does not
+                        // establish that an already spawned runtime has actually exited.
+                        if (child.pid === undefined)
+                            exited();
+                    });
+                });
+                child.stderr.setEncoding('utf8');
+                child.stderr.on('data', (data) => sdkOptions.stderr?.(data));
+                child.stderr.on('error', () => { });
+                return child;
+            };
             // Override the SDK's libc-blind binary resolution on Linux glibc — see
             // resolve-binary.ts for the full rationale. No-op on macOS/Windows/musl.
             const explicitBinary = resolveClaudeBinaryPath();
@@ -395,6 +439,9 @@ export function createClaudeCodeEngine() {
             const safeEmit = (ev) => streamingBatcher.push(ev);
             let iteratorRunning = false;
             let userInterrupted = false;
+            // Normal post-result disposal is distinct from a watchdog/user abort.
+            // The SDK can wait for an `idle` state even after stdin's iterable ends.
+            let settledCloseRequested = false;
             let completedResponses = 0;
             let waitingForBackground = false;
             let turnCompletedEmittedForResponse = 0;
@@ -556,7 +603,9 @@ export function createClaudeCodeEngine() {
                 clearContinuationGrace();
                 continuationGraceTimer = setTimeout(() => {
                     continuationGraceTimer = undefined;
-                    if (activeSubagentTaskIds.size > 0 ||
+                    if (completedResponses === 0 ||
+                        !settlementPending ||
+                        activeSubagentTaskIds.size > 0 ||
                         pendingResolvers.size > 0 ||
                         pendingToolCallIds.size > 0 ||
                         isCompacting ||
@@ -567,6 +616,20 @@ export function createClaudeCodeEngine() {
                     emitTurnCompletedIfSettled();
                     inputStream.close();
                     armResultDrainWatchdog();
+                    // Closing the input iterable alone leaves the SDK in waitForRunEnd
+                    // when its last session state is still running. Dispose explicitly,
+                    // but let the iterator confirm actual closure before session:ended.
+                    // The drain watchdog now guards a FAILED close, not normal cleanup.
+                    if (!settledCloseRequested && typeof q.close === 'function') {
+                        settledCloseRequested = true;
+                        try {
+                            q.close();
+                        }
+                        catch (error) {
+                            settledCloseRequested = false;
+                            console.warn('[claude-engine] Post-result SDK close failed:', error);
+                        }
+                    }
                 }, delayMs);
                 continuationGraceTimer.unref?.();
             };
@@ -616,11 +679,13 @@ export function createClaudeCodeEngine() {
                     for await (const msg of q) {
                         const events = mapSdkMessage(msg, mapperState);
                         const isForeground = !('parent_tool_use_id' in msg && msg.parent_tool_use_id != null);
+                        const streamingContent = hasStreamingContent(msg);
                         const foregroundProgress = isForeground &&
-                            events.some((ev) => ev.kind === 'message:text' ||
-                                ev.kind === 'message:thinking' ||
-                                ev.kind === 'tool:call' ||
-                                ev.kind === 'tool:result');
+                            (streamingContent ||
+                                events.some((ev) => ev.kind === 'message:text' ||
+                                    ev.kind === 'message:thinking' ||
+                                    ev.kind === 'tool:call' ||
+                                    ev.kind === 'tool:result'));
                         // A parent continuation owns the foreground again. Background
                         // progress notifications alone do not end the between-turn wait.
                         if (foregroundProgress) {
@@ -757,7 +822,12 @@ export function createClaudeCodeEngine() {
                         abortController.signal.aborted ||
                         /aborted by user|process aborted|abortError|ede_diagnostic/i.test(error.message ?? '');
                     if (isAbort) {
-                        emitSessionEnded('killed', null);
+                        if (settledCloseRequested && !userInterrupted && !abortController.signal.aborted) {
+                            const reason = mapperState.sawErrorResult ? 'error' : 'completed';
+                            emitSessionEnded(reason, reason === 'completed' ? 0 : null);
+                        }
+                        else
+                            emitSessionEnded('killed', null);
                     }
                     else {
                         safeEmit({
@@ -797,7 +867,7 @@ export function createClaudeCodeEngine() {
             })();
             const engineProcess = {
                 ready,
-                closed: iteratorPromise.then(() => { }),
+                closed: iteratorPromise.then(() => runtimeClosed),
                 get pid() {
                     return undefined;
                 },
@@ -805,10 +875,10 @@ export function createClaudeCodeEngine() {
                     return discoveredSessionId;
                 },
                 isAlive() {
-                    return iteratorRunning;
+                    return iteratorRunning || runtimeRunning;
                 },
                 sendMessage(text) {
-                    if (!iteratorRunning || queryCloseRequested || sessionEndedEmitted)
+                    if (!iteratorRunning || queryCloseRequested || settledCloseRequested || sessionEndedEmitted)
                         throw new Error(`Claude ${AGENT_NO_LONGER_RUNNING_TEXT}`);
                     inputStream.send(text);
                     armSubagentStallWatchdog();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@loicngr/kobo",
-  "version": "2.1.11",
+  "version": "2.1.13",
   "description": "Kōbō — local multi-workspace orchestrator for Claude Code and OpenAI Codex, with isolated Git worktrees, live review and optional automation.",
   "type": "module",
   "license": "GPL-3.0-or-later",