@loicngr/kobo 1.11.44 → 1.11.45

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

@@ -3,7 +3,7 @@ import { nanoid } from 'nanoid';
 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 } from '../../utils/workspace-lifecycle-guard.js';
+import { assertWorkspaceLifecycleAvailable, workspaceLifecycleReason } from '../../utils/workspace-lifecycle-guard.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';
@@ -12,6 +12,8 @@ import { resolveForge } from '../forge/resolve.js';
 import * as lifecycleHookService from '../lifecycle-hook-service.js';
 import * as quotaBackoffService from '../quota-backoff-service.js';
 import { buildReviewReturnPrompt, getReviewReturn, restoreReviewConfiguration } 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';
 import { refreshNow } from '../usage/poller.js';
 import * as wakeupService from '../wakeup-service.js';
@@ -474,7 +476,7 @@ function readEffectiveSettingsSafe(projectPath) {
         };
     }
 }
-function buildMcpServers(workspaceId) {
+function buildMcpServers(workspaceId, extraEnv) {
     const mcpServerCompiled = getCompiledMcpServerPath();
     const mcpServerSource = getMcpServerSourcePath();
     return [
@@ -484,6 +486,7 @@ function buildMcpServers(workspaceId) {
             args: mcpServerCompiled ? [mcpServerCompiled] : ['tsx', mcpServerSource],
             env: {
                 KOBO_WORKSPACE_ID: workspaceId,
+                ...extraEnv,
                 KOBO_DB_PATH: getDbPath(),
                 KOBO_SETTINGS_PATH: getSettingsPath(),
                 KOBO_BACKEND_URL: `http://127.0.0.1:${backendPort}`,
@@ -540,7 +543,7 @@ 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 ORDER BY started_at DESC LIMIT 1")
+            .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`)
             .get(workspaceId, engineId);
     }
     // A workspace can now contain conversations from multiple engines. The
@@ -841,6 +844,13 @@ function handleEvent(workspaceId, agentSessionId, sourceController, ev, terminal
         return;
     const routedEvent = ev.kind === 'session:ended' && (hasReplacement || sourceIsSuperseded) ? { ...ev, superseded: true } : ev;
     routeEvent(workspaceId, agentSessionId, routedEvent);
+    const launch = sourceController ? launchOptions.get(sourceController) : undefined;
+    if (ev.kind === 'error')
+        launch?.onError?.(ev.message);
+    // Summary turns can read and report, but must not drive loop/quota/scheduler side effects.
+    if (launch?.handoffGeneration &&
+        !['session:started', 'session:ended', 'session:user-input-requested'].includes(ev.kind))
+        return;
     if (sourceController && !sourceControllerIsStopping) {
         if (ev.kind === 'session:compacting' && ev.active) {
             const status = getWs(workspaceId)?.status;
@@ -958,9 +968,10 @@ function handleEvent(workspaceId, agentSessionId, sourceController, ev, terminal
             console.error('[orchestrator] Failed to transition to executing:', err);
         }
     }
+    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) {
+    if (quotaError && !sourceControllerIsStopping && !returningReview && !transferring) {
         void handleQuota(workspaceId, agentSessionId);
     }
     if (ev.kind === 'error' &&
@@ -968,6 +979,7 @@ function handleEvent(workspaceId, agentSessionId, sourceController, ev, terminal
         ev.category !== 'resume_failed' &&
         TRANSIENT_SERVER_ERROR_PATTERN.test(ev.message) &&
         !returningReview &&
+        !transferring &&
         getWs(workspaceId)?.autoLoop &&
         !sourceControllerIsStopping) {
         scheduleTransientAutoLoopRecovery(workspaceId, sourceController);
@@ -989,6 +1001,22 @@ function handleEvent(workspaceId, agentSessionId, sourceController, ev, terminal
         // its persisted prompts too, otherwise a reconnect resurrects a panel
         // whose backend callback has already been discarded.
         purgeAllPersistedUserInputRequests(workspaceId, agentSessionId);
+        if (transferring) {
+            onSessionEnded(workspaceId, agentSessionId, sourceController, ev.exitCode, ev.reason, isResumeFailed);
+            launch?.onEnded?.(ev);
+            if (workspaceLifecycleReason(workspaceId) === 'session-handoff') {
+                if (!launch?.handoffGeneration) {
+                    settleLoopMessages(workspaceId, agentSessionId, ev.reason === 'completed');
+                    if (listLoopMessages(workspaceId).some((message) => message.state === 'unknown'))
+                        autoLoopService.block(workspaceId, 'message-delivery-unknown');
+                }
+                notifyCapacityAvailable(workspaceId);
+                return;
+            }
+            // A target can finish before its ready/start promise settles. Its callback
+            // completed the transfer and released ownership: process this actual work
+            // session through the ordinary terminal/auto-loop path below exactly once.
+        }
         // A watchdog end means Kōbō forced the stream closed after the engine
         // failed to drain. It is neither a clean completion nor evidence of an
         // agent stall. Move auto-loop work onto the existing persisted, bounded
@@ -1190,6 +1218,11 @@ function onSessionEnded(workspaceId, agentSessionId, sourceController, exitCode,
         preCompactionStatus.delete(sourceController);
     if (isSuperseded)
         return false;
+    if (workspaceLifecycleReason(workspaceId) === 'session-handoff') {
+        if (registeredController === sourceController && sourceController?.status !== 'stopping')
+            controllers.delete(workspaceId);
+        return false;
+    }
     // A superseded end (above) is a session that was replaced, not one that
     // ended; everything past this point is a real end the user may want to act
     // on, whatever the reason — the script reads KOBO_SESSION_END_REASON.
@@ -1254,6 +1287,7 @@ function onSessionEnded(workspaceId, agentSessionId, sourceController, exitCode,
     }
     return true;
 }
+const launchOptions = new WeakMap();
 // ── Public API ────────────────────────────────────────────────────────────────
 /**
  * Spawn an agent (via the resolved engine) for a workspace. Returns
@@ -1261,10 +1295,10 @@ function onSessionEnded(workspaceId, agentSessionId, sourceController, exitCode,
  * after `engine.start` resolves — callers should subscribe to WS events or
  * query the controller via `_getControllers()` for tests.
  */
-export function startAgent(workspaceId, workingDir, prompt, model, resume = false, agentPermissionMode, existingSessionId, reasoningEffort, beforeDispatch) {
+export function startAgent(workspaceId, workingDir, prompt, model, resume = false, agentPermissionMode, existingSessionId, reasoningEffort, beforeDispatch, launch) {
     if (shuttingDown)
         throw new Error('Cannot start an agent while the server is shutting down');
-    assertWorkspaceLifecycleAvailable(workspaceId);
+    assertWorkspaceLifecycleAvailable(workspaceId, launch?.lifecycleOwner);
     const workspace = getWs(workspaceId);
     if (!workspace)
         throw new Error(`Workspace '${workspaceId}' not found`);
@@ -1334,6 +1368,7 @@ export function startAgent(workspaceId, workingDir, prompt, model, resume = fals
     }
     // Persist before the asynchronous engine can emit its first event. This
     // survives a Kōbō restart and does not depend on SDK system:init delivery.
+    activateSession(workspaceId, agentSessionId);
     captureTaskProgressBaseline(workspaceId, agentSessionId);
     const settings = ws ? readEffectiveSettingsSafe(ws.projectPath) : readEffectiveSettingsSafe(workingDir);
     const options = {
@@ -1355,12 +1390,14 @@ export function startAgent(workspaceId, workingDir, prompt, model, resume = fals
             }
         })(),
         settings,
-        mcpServers: buildMcpServers(workspaceId),
+        mcpServers: buildMcpServers(workspaceId, launch?.mcpEnv),
         env: ws ? buildAgentEnv(ws.projectPath) : undefined,
     };
     beforeDispatch?.();
     let controller;
     controller = new SessionController(workspaceId, agentSessionId, engine, (ev) => handleEvent(workspaceId, agentSessionId, controller, ev));
+    if (launch)
+        launchOptions.set(controller, launch);
     registerSessionLifecycleOwner(workspaceId, agentSessionId, controller);
     if (!existingCtrl)
         controllers.set(workspaceId, controller);
@@ -1377,7 +1414,7 @@ export function startAgent(workspaceId, workingDir, prompt, model, resume = fals
             return;
         if (pendingStarts.get(workspaceId) === controller)
             pendingStarts.delete(workspaceId);
-        assertWorkspaceLifecycleAvailable(workspaceId);
+        assertWorkspaceLifecycleAvailable(workspaceId, launch?.lifecycleOwner);
         const current = getWs(workspaceId);
         if (!current || current.archivedAt || current.worktreePurgedAt)
             throw new Error('Workspace is no longer available');
@@ -1387,7 +1424,11 @@ export function startAgent(workspaceId, workingDir, prompt, model, resume = fals
         controllers.set(workspaceId, controller);
         return controller.start(options);
     })
-        .then(() => {
+        .then(async () => {
+        if (launch?.onStarted)
+            await controller.engineProcess?.ready;
+        if (controller.status !== 'stopping')
+            launch?.onStarted?.();
         const pid = controller.pid;
         if (pid !== undefined) {
             try {
@@ -1524,6 +1565,9 @@ 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') {
+    const finishHandoffStop = ['user', 'delete', 'purge', 'archive'].includes(cause)
+        ? requestHandoffStop(workspaceId)
+        : undefined;
     const pending = pendingStarts.get(workspaceId);
     let pendingStop = Promise.resolve();
     if (pending) {
@@ -1544,7 +1588,8 @@ cause = 'user') {
     // Shutdown only suspends timers: persisted intent belongs to the next boot.
     const cancelSchedules = new Promise((resolve) => {
         if (cause !== 'shutdown') {
-            wakeupService.cancel(workspaceId, 'stopped');
+            if (cause !== 'handoff')
+                wakeupService.cancel(workspaceId, 'stopped');
             quotaBackoffService.cancel(workspaceId, 'user');
         }
         resolve();
@@ -1561,6 +1606,7 @@ cause = 'user') {
     if (outcome === 'timeout') {
         console.error(`[orchestrator] Agent '${workspaceId}' did not stop within ${timeoutMs}ms; retaining its controller`);
     }
+    finishHandoffStop?.(outcome);
     return outcome;
 }
 /**
@@ -1584,6 +1630,7 @@ export async function stopAllAgents(timeoutMs = 3_000) {
     wakeupService.suspendForShutdown();
     cronService.suspendForShutdown();
     shuttingDown = true;
+    suspendHandoffTransfers();
     if (capacityTimer)
         clearTimeout(capacityTimer);
     capacityTimer = undefined;
@@ -1603,6 +1650,8 @@ export function isShuttingDown() {
 }
 /** Deliver a scheduled check without stopping background work or cancelling the wakeup as user input. */
 export function sendWakeupIfWaiting(workspaceId, content, expectedSessionId) {
+    if (workspaceLifecycleReason(workspaceId) === 'session-handoff')
+        return false;
     const ctrl = controllers.get(workspaceId);
     if (ctrl?.status !== 'running')
         return false;
@@ -1620,6 +1669,7 @@ export function sendWakeupIfWaiting(workspaceId, content, expectedSessionId) {
 }
 /** Write a user message to the running agent. */
 export async function sendMessage(workspaceId, content, expectedSessionId, beforeDispatch) {
+    assertWorkspaceLifecycleAvailable(workspaceId);
     assertWorkspaceNotCompacting(workspaceId);
     const ctrl = controllers.get(workspaceId);
     if (!ctrl) {
@@ -1633,6 +1683,7 @@ export async function sendMessage(workspaceId, content, expectedSessionId, befor
     await ctrl.sendMessage(content);
 }
 export async function sendMessageForFallback(workspaceId, content) {
+    assertWorkspaceLifecycleAvailable(workspaceId);
     assertWorkspaceNotCompacting(workspaceId);
     const capturedController = controllers.get(workspaceId);
     wakeupService.cancel(workspaceId, 'user-message');
@@ -1643,6 +1694,7 @@ export async function sendMessageForFallback(workspaceId, content) {
         return { status: 'sent', sessionId: capturedController.agentSessionId };
     }
     catch {
+        assertWorkspaceLifecycleAvailable(workspaceId);
         assertWorkspaceNotCompacting(workspaceId);
         const deadline = Date.now() + FALLBACK_CONTROLLER_TURNOVER_TIMEOUT_MS;
         while (controllers.get(workspaceId) === capturedController) {
@@ -1657,6 +1709,7 @@ export async function sendMessageForFallback(workspaceId, content) {
         const replacementController = controllers.get(workspaceId);
         if (!replacementController)
             return { status: 'stopped' };
+        assertWorkspaceLifecycleAvailable(workspaceId);
         assertWorkspaceNotCompacting(workspaceId);
         await replacementController.sendMessage(content);
         return { status: 'sent', sessionId: replacementController.agentSessionId };

package/dist/server/services/engine-handoff-service.js

@@ -8,13 +8,13 @@ function runGit(worktreePath, args) {
         return '';
     }
 }
-function recentConversation(workspaceId) {
+function recentConversation(workspaceId, sessionId) {
     const rows = getDb()
         .prepare(`SELECT type, payload FROM ws_events
-       WHERE workspace_id = ?
+       WHERE workspace_id = ? AND (? IS NULL OR session_id = ?)
          AND (type = 'user:message' OR (type = 'agent:event' AND json_extract(payload, '$.kind') = 'message:text'))
        ORDER BY rowid DESC LIMIT 6`)
-        .all(workspaceId);
+        .all(workspaceId, sessionId ?? null, sessionId ?? null);
     return rows
         .reverse()
         .flatMap((row) => {
@@ -30,12 +30,12 @@ function recentConversation(workspaceId) {
         .join('\n\n');
 }
 /** Build a deterministic, secret-free handoff for a fresh session on another engine. */
-export function buildEngineHandoff(workspace, sourceEngine, targetEngine) {
+export function buildEngineHandoff(workspace, sourceEngine, targetEngine, sourceSessionId) {
     const taskLines = workspace.tasks.length
         ? workspace.tasks.map((task) => `- [${task.status === 'done' ? 'x' : ' '}] ${task.title}`).join('\n')
         : '- No Kōbō task recorded.';
     const changedFiles = runGit(workspace.worktreePath, 'status --short') || 'No uncommitted changes detected.';
     const diffStat = runGit(workspace.worktreePath, 'diff --stat') || 'No uncommitted diff stat available.';
-    const history = recentConversation(workspace.id) || 'No recent conversation message available.';
+    const history = recentConversation(workspace.id, sourceSessionId) || 'No recent conversation message available.';
     return `# Kōbō engine handoff\n\nYou are taking over this workspace from ${sourceEngine} using ${targetEngine}. Work in the existing worktree and verify the repository state before making changes.\n\n## Objective\n${workspace.description ?? workspace.name}\n\n## Tasks\n${taskLines}\n\n## Git state\n- Branch: ${workspace.workingBranch}\n- Base: ${workspace.sourceBranch}\n- Worktree: ${workspace.worktreePath}\n\nChanged files:\n\`\`\`\n${changedFiles}\n\`\`\`\n\nDiff summary:\n\`\`\`\n${diffStat}\n\`\`\`\n\n## Recent conversation\n${history}\n\n## Recover more context\nIf this handoff is insufficient, use \`kobo__read_workspace_events_csv\` to read the previous workspace conversation in pages (optionally filter by \`session_id\`). Use \`kobo__search_codebase\` to find a precise past decision or user request. Read only the context needed, then continue the task.\n`;
 }

package/dist/server/services/session-activity-service.js

@@ -0,0 +1,17 @@
+import { getDb } from '../db/index.js';
+// Preserve legacy last-use ordering until a session is started or restored.
+export const SESSION_RECENCY_ORDER = 'activation_order DESC, MAX(started_at, COALESCE(ended_at, started_at)) DESC, started_at DESC';
+/** Make a conversation current without changing its execution history or starting an agent. */
+export function activateSession(workspaceId, sessionId) {
+    getDb()
+        .prepare(`UPDATE agent_sessions SET activation_order =
+      (SELECT COALESCE(MAX(activation_order), 0) + 1 FROM agent_sessions WHERE workspace_id = ? AND activation_order >= 0)
+      WHERE workspace_id = ? AND id = ? AND status != 'idle'`)
+        .run(workspaceId, workspaceId, sessionId);
+}
+/** Keep a rolled-back target in history without selecting or resuming it implicitly. */
+export function deactivateSession(workspaceId, sessionId) {
+    getDb()
+        .prepare("UPDATE agent_sessions SET activation_order = -1 WHERE workspace_id = ? AND id = ? AND status != 'running'")
+        .run(workspaceId, sessionId);
+}

package/dist/server/services/session-handoff-runtime.js

@@ -0,0 +1,26 @@
+/** Decouples the orchestrator's explicit Stop path from the transfer service. */
+const handlers = new Map();
+export function registerHandoffStopHandler(workspaceId, handler) {
+    handlers.set(workspaceId, handler);
+    return () => {
+        if (handlers.get(workspaceId) === handler)
+            handlers.delete(workspaceId);
+    };
+}
+export function requestHandoffStop(workspaceId) {
+    const handler = handlers.get(workspaceId);
+    handler?.requested();
+    if (!handler)
+        return undefined;
+    let settled = false;
+    return (outcome) => {
+        if (settled)
+            return;
+        settled = true;
+        handler.settled(outcome);
+    };
+}
+export function suspendHandoffTransfers() {
+    for (const handler of handlers.values())
+        handler.shutdown();
+}