@loicngr/kobo 2.1.13 → 2.1.16

package/dist/server/services/agent/orchestrator.js

@@ -5,6 +5,7 @@ import { getDb } from '../../db/index.js';
 import { assertAgentStopped } from '../../utils/agent-stop-result.js';
 import { ensureKoboHome, getCompiledMcpServerPath, getDbPath, getKoboHome, getMcpServerSourcePath, getSettingsPath, getSkillsPath, } from '../../utils/paths.js';
 import { assertWorkspaceLifecycleAvailable, workspaceLifecycleReason } from '../../utils/workspace-lifecycle-guard.js';
+import { cancelAutoLoopFinalReview, getAutoLoopReviewLaunch, isAutoLoopReview, prepareAutoLoopReviewReturn, retryAutoLoopReviewReturn, } from '../auto-loop-final-review-service.js';
 import { listLoopMessages, settleLoopMessages } from '../auto-loop-message-service.js';
 import * as autoLoopService from '../auto-loop-service.js';
 import * as cleanupScriptService from '../cleanup-script-service.js';
@@ -14,7 +15,8 @@ import * as lifecycleHookService from '../lifecycle-hook-service.js';
 import { advanceMemoryConversationEpoch, allocateMemoryConversationKey, bindMemoryNativeConversation, createMemoryCapability, revokeMemoryCapability, } from '../memory-agent-runtime.js';
 import { buildMemoryContext, markMemoryContextFailed, markMemoryContextInitialized, markMemoryContextSubmitted, } from '../memory-context-service.js';
 import * as quotaBackoffService from '../quota-backoff-service.js';
-import { buildReviewReturnPrompt, getReviewReturn, restoreReviewConfiguration } from '../review-return-service.js';
+import { cancelReviewLaunch } from '../review-launch-runtime.js';
+import { buildReviewReturnPrompt, claimReviewReturn, completeReviewReturn, getReviewReturn, listReviewReturns, restoreReviewConfiguration, setReviewReturnPhase, } from '../review-return-service.js';
 import { activateSession, SESSION_RECENCY_ORDER } from '../session-activity-service.js';
 import { requestHandoffStop, suspendHandoffTransfers } from '../session-handoff-runtime.js';
 import { getEffectiveSettings, getGlobalSettings } from '../settings-service.js';
@@ -22,7 +24,7 @@ import { refreshNow } from '../usage/poller.js';
 import * as wakeupService from '../wakeup-service.js';
 import { emit, emitEphemeral } from '../websocket-service.js';
 import * as permissionPolicyService from '../workspace-permission-policy-service.js';
-import { getWorkspace as getWs, markWorkspaceUnread, updateWorkspaceStatus, } from '../workspace-service.js';
+import { getWorkspace as getWs, markWorkspaceUnread, updateWorkspaceEngineConfiguration, updateWorkspaceStatus, } from '../workspace-service.js';
 import { resolveEngine } from './engines/registry.js';
 import { AGENT_NO_LONGER_RUNNING_TEXT, } from './engines/types.js';
 import { routeEvent } from './event-router.js';
@@ -78,6 +80,7 @@ function notifyCapacityAvailable(stoppedWorkspaceId) {
         if (shuttingDown)
             return;
         try {
+            resumePendingReviewReturns();
             autoLoopService.resumeWaitingWorkspaces(excluded);
         }
         catch (err) {
@@ -556,9 +559,11 @@ function resolveSessionForResume(workspaceId, existingSessionId, model, engineId
     }
     else {
         lastSession = db
-            .prepare(`SELECT id, engine_session_id, engine FROM agent_sessions WHERE workspace_id = ? AND COALESCE(engine, 'claude-code') = ? AND engine_session_id IS NOT NULL AND activation_order >= 0 ORDER BY ${SESSION_RECENCY_ORDER} LIMIT 1`)
+            .prepare(`SELECT id, engine_session_id, engine FROM agent_sessions WHERE workspace_id = ? AND COALESCE(engine, 'claude-code') = ? AND activation_order >= 0 ORDER BY ${SESSION_RECENCY_ORDER} LIMIT 1`)
             .get(workspaceId, engineId);
     }
+    // A failed latest conversation must start fresh, not silently fall back to
+    // an older, unrelated conversation whose native ID is still valid.
     // A workspace can now contain conversations from multiple engines. The
     // unscoped in-memory ID may belong to the reviewer, so only trust its DB row.
     const engineSessionId = lastSession?.engine_session_id;
@@ -790,6 +795,14 @@ function handleEvent(workspaceId, agentSessionId, sourceController, ev, terminal
         if (ev.kind === 'session:ended') {
             if (pendingTerminalControllers.has(sourceController) || finalizedControllers.has(sourceController))
                 return;
+            if (controllers.get(workspaceId) === sourceController &&
+                getReviewReturn(workspaceId, agentSessionId) &&
+                ev.reason === 'completed' &&
+                (ev.exitCode === 0 || ev.exitCode === null)) {
+                setReviewReturnPhase(workspaceId, 'ready', null, isAutoLoopReview(workspaceId, agentSessionId)
+                    ? undefined
+                    : buildReviewReturnPrompt(workspaceId, agentSessionId));
+            }
             // Real engines may announce their logical result before their writer
             // exits. Delay all terminal effects, including review return and quota
             // retries, until SessionController confirms closure.
@@ -1019,7 +1032,7 @@ function handleEvent(workspaceId, agentSessionId, sourceController, ev, terminal
     const transferring = workspaceLifecycleReason(workspaceId) === 'session-handoff';
     const returningReview = (ev.kind === 'error' || ev.kind === 'session:ended') && !!getReviewReturn(workspaceId, agentSessionId);
     const quotaError = ev.kind === 'error' && (ev.category === 'quota' || /\b429\b/.test(ev.message));
-    if (quotaError && !sourceControllerIsStopping && !returningReview && !transferring) {
+    if (quotaError && !sourceControllerIsStopping && !transferring) {
         void handleQuota(workspaceId, agentSessionId);
     }
     if (ev.kind === 'error' &&
@@ -1034,7 +1047,7 @@ function handleEvent(workspaceId, agentSessionId, sourceController, ev, terminal
     }
     if (ev.kind === 'error' && ev.category === 'resume_failed') {
         rememberResumeFailed(workspaceId, agentSessionId);
-        clearStaleEngineSessionId(workspaceId);
+        clearStaleEngineSessionId(workspaceId, agentSessionId);
     }
     if (ev.kind === 'session:ended') {
         if (sourceIsSuperseded && sourceController) {
@@ -1117,29 +1130,28 @@ function handleEvent(workspaceId, agentSessionId, sourceController, ev, terminal
             return;
         const progressDelta = consumeMonotoneTaskProgress(workspaceId, snapshot);
         if (returningReview) {
-            const pending = restoreReviewConfiguration(workspaceId, agentSessionId);
-            const workspace = getWs(workspaceId);
-            if (pending &&
-                workspace &&
-                !shuttingDown &&
-                !workspace.archivedAt &&
-                !workspace.worktreePurgedAt &&
-                autoLoopService.getStatus(workspaceId).state !== 'blocked' &&
-                (ev.reason === 'completed' || ev.reason === 'watchdog') &&
-                (ev.exitCode === null || ev.exitCode === 0)) {
-                try {
-                    const prompt = buildReviewReturnPrompt(workspaceId, agentSessionId);
-                    const original = pending.original;
-                    startAgent(workspaceId, workspace.worktreePath, prompt, original.sessionModel ?? original.model, true, original.agentPermissionMode, pending.originalSessionId, original.reasoningEffort);
-                    updateWorkspaceStatus(workspaceId, 'executing');
-                    emit(workspaceId, 'user:message', { content: prompt, sender: 'system-prompt' }, pending.originalSessionId);
+            const pending = getReviewReturn(workspaceId, agentSessionId);
+            if (pending && sourceController?.stopCause !== 'shutdown' && sourceController?.stopCause !== 'review-recovery') {
+                if (quotaBackoffService.getPending(workspaceId)) {
+                    setReviewReturnPhase(workspaceId, 'reviewing');
+                    notifyCapacityAvailable(workspaceId);
+                    return;
                 }
-                catch (err) {
-                    routeEvent(workspaceId, agentSessionId, {
-                        kind: 'error',
-                        category: 'other',
-                        message: `Could not return to the original session: ${err instanceof Error ? err.message : String(err)}`,
-                    });
+                if ((ev.reason === 'completed' || ev.reason === 'watchdog') && (ev.exitCode === null || ev.exitCode === 0)) {
+                    try {
+                        const prompt = prepareAutoLoopReviewReturn(workspaceId, agentSessionId) ??
+                            buildReviewReturnPrompt(workspaceId, agentSessionId);
+                        setReviewReturnPhase(workspaceId, 'ready', null, prompt);
+                        resumePendingReviewReturns(workspaceId);
+                    }
+                    catch (error) {
+                        restoreReviewConfiguration(workspaceId, agentSessionId, true);
+                        setReviewReturnPhase(workspaceId, 'blocked', error instanceof Error ? error.message : String(error));
+                    }
+                }
+                else {
+                    restoreReviewConfiguration(workspaceId, agentSessionId, true);
+                    setReviewReturnPhase(workspaceId, 'blocked', 'The review ended before completion. Retry the review or cancel the return.');
                 }
             }
             notifyCapacityAvailable(workspaceId);
@@ -1157,7 +1169,10 @@ function handleEvent(workspaceId, agentSessionId, sourceController, ev, terminal
         // disable() clears it, and the cleanup hook needs to know whether this was
         // a mid-loop session (never cleans) or a standalone one.
         const wasAutoLoop = autoLoopService.getStatus(workspaceId).auto_loop;
-        autoLoopService.onSessionEnded(workspaceId, effectiveReason, progressDelta, instructionIntake);
+        // Durable manual reviews also wait for capacity. Wake them before admitting
+        // another auto-loop iteration now that this controller has actually closed.
+        resumePendingReviewReturns();
+        autoLoopService.onSessionEnded(workspaceId, effectiveReason, progressDelta, instructionIntake, agentSessionId);
         // A slot just freed. Any auto-loop workspace parked on the concurrency
         // limit has no session of its own to bring it back; this one does it.
         autoLoopService.resumeWaitingWorkspaces();
@@ -1347,6 +1362,101 @@ function revokeControllerMemoryCapability(controller) {
     revokeMemoryCapability(token);
     controllerMemoryCapabilities.delete(controller);
 }
+const reviewReturnDispatchOwners = new Map();
+/** Resume durable review work only after the previous runtime has closed and admission allows it. */
+export function resumePendingReviewReturns(onlyWorkspaceId) {
+    if (shuttingDown)
+        return;
+    for (const pending of listReviewReturns()) {
+        const id = pending.workspaceId;
+        if (onlyWorkspaceId && onlyWorkspaceId !== id)
+            continue;
+        if (pending.phase === 'unknown' || pending.phase === 'blocked' || pending.phase === 'dispatching')
+            continue;
+        const workspace = getWs(id);
+        if (!workspace || !autoLoopService.canStartAutomatically(id))
+            continue;
+        try {
+            if (pending.phase === 'ready') {
+                const originalSession = getDb()
+                    .prepare('SELECT engine_session_id, engine FROM agent_sessions WHERE id = ? AND workspace_id = ?')
+                    .get(pending.originalSessionId, id);
+                if (!originalSession?.engine_session_id ||
+                    (originalSession.engine && originalSession.engine !== pending.original.engine))
+                    throw new Error('The original session cannot be resumed. Cancel the return and inspect the review report.');
+                const prompt = pending.returnPrompt ??
+                    prepareAutoLoopReviewReturn(id, pending.reviewSessionId) ??
+                    buildReviewReturnPrompt(id, pending.reviewSessionId);
+                setReviewReturnPhase(id, 'ready', null, prompt);
+                restoreReviewConfiguration(id, undefined, true);
+                const dispatchOwner = Symbol('review-return');
+                reviewReturnDispatchOwners.set(id, dispatchOwner);
+                startAgent(id, workspace.worktreePath, prompt, pending.original.sessionModel ?? pending.original.model, true, pending.original.agentPermissionMode, pending.originalSessionId, pending.original.reasoningEffort, () => {
+                    if (!claimReviewReturn(id))
+                        throw new Error('The review return is already being dispatched');
+                }, {
+                    requireInputAcceptance: true,
+                    onStarted: () => {
+                        if (reviewReturnDispatchOwners.get(id) !== dispatchOwner)
+                            return;
+                        reviewReturnDispatchOwners.delete(id);
+                        completeReviewReturn(id);
+                        if (!controllers.has(id) && !getReviewReturn(id))
+                            autoLoopService.resumeWaitingWorkspaces();
+                    },
+                    onError: (message) => {
+                        if (reviewReturnDispatchOwners.get(id) === dispatchOwner)
+                            setReviewReturnPhase(id, 'unknown', message);
+                    },
+                });
+                updateWorkspaceStatus(id, 'executing');
+                emit(id, 'user:message', { content: prompt, sender: 'system-prompt' }, pending.originalSessionId);
+            }
+            else {
+                const session = getDb()
+                    .prepare('SELECT engine_session_id FROM agent_sessions WHERE id = ? AND workspace_id = ?')
+                    .get(pending.reviewSessionId, id);
+                if (!session)
+                    throw new Error('The review session no longer exists');
+                const extra = getAutoLoopReviewLaunch(id, pending.reviewSessionId);
+                const prompt = session.engine_session_id
+                    ? 'Kōbō was restarted during this read-only review. Continue the review in this same session and finish with a standalone findings summary. Do not change files or ask questions.' +
+                        (extra?.promptSuffix ?? '')
+                    : pending.reviewPrompt;
+                if (!prompt)
+                    throw new Error('The review was interrupted before its native session was saved and has no durable launch prompt. Cancel and launch a new review.');
+                updateWorkspaceEngineConfiguration(id, pending.review.engine, pending.review.model, pending.review.reasoningEffort, 'plan');
+                emitEphemeral(id, 'workspace:configuration', { ...pending.review, agentPermissionMode: 'plan' });
+                startAgent(id, workspace.worktreePath, prompt, pending.review.model, !!session.engine_session_id, 'plan', pending.reviewSessionId, pending.review.reasoningEffort, undefined, { mcpEnv: extra?.mcpEnv });
+                updateWorkspaceStatus(id, 'executing');
+                emit(id, 'user:message', { content: prompt, sender: 'system-prompt' }, pending.reviewSessionId);
+            }
+        }
+        catch (error) {
+            restoreReviewConfiguration(id, undefined, true);
+            setReviewReturnPhase(id, 'blocked', error instanceof Error ? error.message : String(error));
+        }
+    }
+}
+export function retryReviewReturn(workspaceId) {
+    if (getAgentStatus(workspaceId))
+        throw new Error('Stop the active agent before retrying the review return');
+    const pending = getReviewReturn(workspaceId);
+    if (!pending)
+        throw new Error('No review return is pending');
+    if (isAutoLoopReview(workspaceId, pending.reviewSessionId))
+        retryAutoLoopReviewReturn(workspaceId, !pending.returnPrompt);
+    setReviewReturnPhase(workspaceId, pending.returnPrompt ? 'ready' : 'reviewing');
+    resumePendingReviewReturns(workspaceId);
+}
+export function cancelReviewReturn(workspaceId) {
+    reviewReturnDispatchOwners.delete(workspaceId);
+    cancelReviewLaunch(workspaceId);
+    cancelAutoLoopFinalReview(workspaceId, 'review-return-cancelled');
+    if (!getReviewReturn(workspaceId))
+        return;
+    restoreReviewConfiguration(workspaceId);
+}
 // ── Public API ────────────────────────────────────────────────────────────────
 /**
  * Spawn an agent (via the resolved engine) for a workspace. Returns
@@ -1539,10 +1649,6 @@ export function startAgent(workspaceId, workingDir, prompt, model, resume = fals
         if (ready && contextId) {
             void ready.then(() => markMemoryContextInitialized(contextId), () => markMemoryContextFailed(contextId));
         }
-        if (launch?.onStarted && ready)
-            await ready;
-        if (controller.status !== 'stopping')
-            launch?.onStarted?.();
         const pid = controller.pid;
         if (pid !== undefined) {
             try {
@@ -1553,6 +1659,19 @@ export function startAgent(workspaceId, workingDir, prompt, model, resume = fals
                 console.error('[orchestrator] Failed to update pid:', err);
             }
         }
+        if (launch?.onStarted && ready)
+            await ready;
+        if (launch?.requireInputAcceptance && controller.engineProcess?.initialPromptAccepted) {
+            try {
+                await controller.engineProcess.initialPromptAccepted;
+            }
+            catch (error) {
+                launch.onError?.(error instanceof Error ? error.message : String(error));
+                return;
+            }
+        }
+        if (controller.status !== 'stopping')
+            launch?.onStarted?.();
     })
         .catch((err) => {
         revokeControllerMemoryCapability(controller);
@@ -1636,7 +1755,7 @@ export const STOP_AGENT_TIMEOUT_MS = 15_000;
 async function stopController(workspaceId, ctrl, cause = 'user') {
     revokeControllerMemoryCapability(ctrl);
     ctrl.stopCause = cause;
-    restoreReviewConfiguration(workspaceId, ctrl.agentSessionId);
+    restoreReviewConfiguration(workspaceId, ctrl.agentSessionId, cause === 'shutdown' || cause === 'review-recovery');
     preCompactionStatus.delete(ctrl);
     // Normalize the state synchronously so callers (archive, delete, manual
     // stop) see a clean workspace immediately — without waiting for the async
@@ -1711,6 +1830,8 @@ async function raceWithTimeout(promise, timeoutMs, onTimeout) {
 export async function stopAgentAndWait(workspaceId, timeoutMs = STOP_AGENT_TIMEOUT_MS, 
 /** Only `user` disables auto-loop; technical stops preserve its persisted intent. */
 cause = 'user') {
+    if (['user', 'delete', 'purge', 'archive'].includes(cause))
+        cancelReviewReturn(workspaceId);
     const finishHandoffStop = ['user', 'delete', 'purge', 'archive'].includes(cause)
         ? requestHandoffStop(workspaceId)
         : undefined;
@@ -1826,8 +1947,7 @@ export async function sendMessage(workspaceId, content, expectedSessionId, befor
         throw new Error(`Session '${expectedSessionId}' is not active for workspace '${workspaceId}'`);
     }
     wakeupService.cancel(workspaceId, 'user-message');
-    beforeDispatch?.();
-    await ctrl.sendMessage(content);
+    await ctrl.sendMessage(content, beforeDispatch);
 }
 export async function sendMessageForFallback(workspaceId, content) {
     assertWorkspaceLifecycleAvailable(workspaceId);
@@ -2236,14 +2356,13 @@ export function forgetRateLimitInfo(workspaceId) {
     latestRateLimitInfo.delete(workspaceId);
 }
 /**
- * Null out every engine_session_id for the workspace and clear its cache.
- * This runs only while the failing session owns the workspace, ensuring a
- * future resume cannot fall back to an older stale engine session.
+ * Invalidate only the failed session. Other conversations (especially a
+ * pending review's source) remain valid and must stay explicitly resumable.
  */
-function clearStaleEngineSessionId(workspaceId) {
+function clearStaleEngineSessionId(workspaceId, agentSessionId) {
     try {
         const db = getDb();
-        db.prepare('UPDATE agent_sessions SET engine_session_id = NULL WHERE workspace_id = ?').run(workspaceId);
+        db.prepare('UPDATE agent_sessions SET engine_session_id = NULL WHERE workspace_id = ? AND id = ?').run(workspaceId, agentSessionId);
         sessionIds.delete(workspaceId);
     }
     catch (err) {

package/dist/server/services/agent/session-controller.js

@@ -106,7 +106,7 @@ export class SessionController {
         }
         this._status = 'running';
     }
-    async sendMessage(content) {
+    async sendMessage(content, beforeDispatch) {
         if (!this._startPromise)
             throw new Error('SessionController not started');
         await this._startPromise;
@@ -114,6 +114,9 @@ export class SessionController {
             throw new Error('SessionController is stopping');
         if (!this._engineProcess)
             throw new Error('SessionController not started');
+        // Startup may have yielded while the workspace's delivery mode changed.
+        // Validate immediately before handing the message to the engine.
+        beforeDispatch?.();
         await this._engineProcess.sendMessage(content);
     }
     interrupt() {