@loicngr/kobo 1.11.36 → 1.11.38

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

@@ -1,7 +1,9 @@
 import { readFileSync, writeFileSync } from 'node:fs';
 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 * as autoLoopService from '../auto-loop-service.js';
 import * as cleanupScriptService from '../cleanup-script-service.js';
 import * as cronService from '../cron-service.js';
@@ -39,6 +41,33 @@ export function getBackendPort() {
 }
 /** workspaceId -> SessionController */
 const controllers = new Map();
+/** Replacements waiting for the previous controller to release its worktree. */
+const pendingStarts = new Map();
+let shuttingDown = false;
+let capacityTimer;
+const stoppedCapacityOwners = new Set();
+function notifyCapacityAvailable(stoppedWorkspaceId) {
+    if (shuttingDown)
+        return;
+    stoppedCapacityOwners.add(stoppedWorkspaceId);
+    if (capacityTimer)
+        return;
+    // Let the stopping caller finish disabling/archiving before scheduling other work.
+    capacityTimer = setTimeout(() => {
+        capacityTimer = undefined;
+        const excluded = new Set(stoppedCapacityOwners);
+        stoppedCapacityOwners.clear();
+        if (shuttingDown)
+            return;
+        try {
+            autoLoopService.resumeWaitingWorkspaces(excluded);
+        }
+        catch (err) {
+            console.error('[orchestrator] capacity resume failed:', err);
+        }
+    }, 0);
+    capacityTimer.unref?.();
+}
 /**
  * Latest controller generation per persisted session row. A resumed run can
  * reuse an agentSessionId while its predecessor is still draining events, so
@@ -102,6 +131,25 @@ const pendingQueue = new Map();
  * returns to that status instead of being yanked to `executing`.
  */
 const preAwaitStatus = new Map();
+/** The lifecycle phase hidden by this controller's temporary compaction. */
+const preCompactionStatus = new Map();
+function finishCompaction(workspaceId, controller) {
+    const previous = preCompactionStatus.get(controller);
+    preCompactionStatus.delete(controller);
+    if (getWs(workspaceId)?.status !== 'compacting')
+        return;
+    const restored = peekPending(workspaceId)
+        ? 'awaiting-user'
+        : previous === 'awaiting-user'
+            ? consumePreAwaitStatus(workspaceId)
+            : (previous ?? 'executing');
+    updateWorkspaceStatus(workspaceId, restored);
+}
+export function assertWorkspaceNotCompacting(workspaceId) {
+    if (getWs(workspaceId)?.status === 'compacting') {
+        throw new Error('Workspace is compacting its context; wait until compaction finishes before sending a message');
+    }
+}
 function enqueuePending(workspaceId, item) {
     const arr = pendingQueue.get(workspaceId) ?? [];
     arr.push(item);
@@ -169,6 +217,13 @@ function rememberPreAwaitStatus(workspaceId) {
         return;
     if (ws.status === 'awaiting-user')
         return;
+    if (ws.status === 'compacting') {
+        const controller = controllers.get(workspaceId);
+        const previous = controller && preCompactionStatus.get(controller);
+        if (previous && previous !== 'awaiting-user')
+            preAwaitStatus.set(workspaceId, previous);
+        return;
+    }
     preAwaitStatus.set(workspaceId, ws.status);
 }
 /**
@@ -222,8 +277,7 @@ function runWatchdog() {
     for (const [workspaceId, ctrl] of controllers) {
         // D1 — a controller already in `stopping` state is being torn down by
         // `stopController`/`stopAgentAndWait`, which has its own bounded deadline
-        // (STOP_AGENT_TIMEOUT_MS) and its own eviction path once that deadline
-        // passes. Before D1 this branch could never see a stopping controller —
+        // (STOP_AGENT_TIMEOUT_MS). A deadline alone never evicts the controller. Before D1 this branch could never see a stopping controller —
         // the entry was removed from `controllers` synchronously, before
         // `ctrl.stop()` was even awaited. Now that the entry survives the whole
         // stop, a slow-but-honest voluntary stop (the engine's iterator already
@@ -266,8 +320,11 @@ function runWatchdog() {
         catch (err) {
             console.warn('[watchdog] Failed to route death notification events:', err);
         }
-        if (controllers.get(workspaceId) === ctrl)
+        if (controllers.get(workspaceId) === ctrl) {
             controllers.delete(workspaceId);
+            notifyCapacityAvailable(workspaceId);
+        }
+        preCompactionStatus.delete(ctrl);
         retryCounts.delete(workspaceId);
         // This end never goes through handleEvent → onSessionEnded, so the user's
         // hook would otherwise miss precisely the case it is most useful for.
@@ -333,7 +390,7 @@ export function reconcileOrphanSessions() {
         const db = getDb();
         const result = db
             .prepare(`UPDATE workspaces SET status = 'idle', updated_at = ?
-          WHERE status IN ('executing', 'brainstorming', 'extracting', 'awaiting-user')`)
+          WHERE status IN ('executing', 'brainstorming', 'extracting', 'awaiting-user', 'compacting')`)
             .run(now);
         if (result.changes > 0) {
             console.log(`[orchestrator] Reconciled ${result.changes} orphan workspace status(es) at boot.`);
@@ -693,8 +750,24 @@ function handleEvent(workspaceId, agentSessionId, sourceController, ev) {
     // `awaiting-user`/`executing`. Every branch that does one of those must
     // check this guard.
     const sourceControllerIsStopping = sourceController?.status === 'stopping';
+    if (sourceControllerIsStopping && ev.kind === 'session:compacting')
+        return;
     const routedEvent = ev.kind === 'session:ended' && (hasReplacement || sourceIsSuperseded) ? { ...ev, superseded: true } : ev;
     routeEvent(workspaceId, agentSessionId, routedEvent);
+    if (sourceController && !sourceControllerIsStopping) {
+        if (ev.kind === 'session:compacting' && ev.active) {
+            const status = getWs(workspaceId)?.status;
+            if (status && ['extracting', 'brainstorming', 'executing', 'awaiting-user'].includes(status)) {
+                preCompactionStatus.set(sourceController, status);
+                updateWorkspaceStatus(workspaceId, 'compacting');
+            }
+        }
+        else if ((ev.kind === 'session:compacting' && !ev.active) ||
+            ev.kind === 'session:compacted' ||
+            ev.kind === 'error') {
+            finishCompaction(workspaceId, sourceController);
+        }
+    }
     // A fresh tool invocation proves this controller resumed working (for
     // example after an account change). Tool results can still drain after a
     // rejection, so they must never count as recovery.
@@ -785,7 +858,9 @@ function handleEvent(workspaceId, agentSessionId, sourceController, ev) {
     // nothing but this status transition (no separate bookkeeping to preserve),
     // so it is entirely behind the guard; the event itself is still
     // persisted/broadcast unconditionally via `routeEvent` above.
-    if (ev.kind === 'session:brainstorm-complete' && !sourceControllerIsStopping) {
+    if (ev.kind === 'session:brainstorm-complete' &&
+        !sourceControllerIsStopping &&
+        getWs(workspaceId)?.status !== 'compacting') {
         try {
             const ws = getWs(workspaceId);
             if (ws && ws.status !== 'executing') {
@@ -861,8 +936,10 @@ function handleEvent(workspaceId, agentSessionId, sourceController, ev) {
         const ownsWorkspaceLifecycle = onSessionEnded(workspaceId, agentSessionId, sourceController, ev.exitCode, ev.reason, isResumeFailed);
         if (!ownsWorkspaceLifecycle)
             return;
-        if (watchdogRecovery)
+        if (watchdogRecovery) {
+            notifyCapacityAvailable(workspaceId);
             return;
+        }
         // resume_failed exits with an error but the workspace is fine (stale id
         // cleared, next iteration will start fresh) — report 'completed' to
         // auto-loop so it continues.
@@ -898,7 +975,8 @@ function handleEvent(workspaceId, agentSessionId, sourceController, ev) {
         }
         rememberPreAwaitStatus(workspaceId);
         try {
-            updateWorkspaceStatus(workspaceId, 'awaiting-user');
+            if (getWs(workspaceId)?.status !== 'compacting')
+                updateWorkspaceStatus(workspaceId, 'awaiting-user');
         }
         catch (err) {
             console.warn('[orchestrator] Failed to transition to awaiting-user:', err);
@@ -975,6 +1053,8 @@ function onSessionEnded(workspaceId, agentSessionId, sourceController, exitCode,
     }
     const registeredController = controllers.get(workspaceId);
     const isSuperseded = sourceController !== undefined && registeredController !== undefined && registeredController !== sourceController;
+    if (sourceController)
+        preCompactionStatus.delete(sourceController);
     if (isSuperseded)
         return false;
     // A superseded end (above) is a session that was replaced, not one that
@@ -984,7 +1064,7 @@ function onSessionEnded(workspaceId, agentSessionId, sourceController, exitCode,
     const currentWorkspace = getWs(workspaceId);
     const preserveQuotaBackoff = currentWorkspace?.status === 'quota';
     const wasStopping = sourceController?.status === 'stopping';
-    if (registeredController === sourceController) {
+    if (!wasStopping && registeredController === sourceController) {
         controllers.delete(workspaceId);
     }
     if (!preserveQuotaBackoff) {
@@ -1055,9 +1135,13 @@ function onSessionEnded(workspaceId, agentSessionId, sourceController, exitCode,
  * query the controller via `_getControllers()` for tests.
  */
 export function startAgent(workspaceId, workingDir, prompt, model, resume = false, agentPermissionMode, existingSessionId, reasoningEffort) {
+    if (shuttingDown)
+        throw new Error('Cannot start an agent while the server is shutting down');
+    assertWorkspaceLifecycleAvailable(workspaceId);
     const workspace = getWs(workspaceId);
     if (!workspace)
         throw new Error(`Workspace '${workspaceId}' not found`);
+    assertWorkspaceNotCompacting(workspaceId);
     if (workspace.archivedAt)
         throw new Error(`Workspace '${workspaceId}' is archived`);
     if (workspace.worktreePurgedAt)
@@ -1068,26 +1152,22 @@ export function startAgent(workspaceId, workingDir, prompt, model, resume = fals
     // callback can leave its controller in the map after the workspace is
     // logically idle. Evict it instead of refusing the new session.
     //
-    // A controller already in `stopping` state is evictable too: it stays
-    // registered for the whole teardown now (D1), and refusing here would break
-    // every legitimate stop-then-start sequence.
+    // A controller already stopping keeps ownership until its stop completes;
+    // callers replacing it must await stopAgentAndWait before starting again.
     let zombieEviction = Promise.resolve();
     const existingCtrl = controllers.get(workspaceId);
     if (existingCtrl) {
+        if (existingCtrl.status === 'stopping')
+            throw new Error('Agent is still stopping; retry after its stop completes');
         const wsForCheck = getWs(workspaceId);
         const status = wsForCheck?.status;
         const isLogicallyDone = status === 'idle' || status === 'completed' || status === 'error' || status === 'quota';
-        if (isLogicallyDone || existingCtrl.status === 'stopping') {
+        if (isLogicallyDone) {
             console.warn(`[orchestrator] Evicting zombie controller for workspace '${workspaceId}' (status=${status}, controller=${existingCtrl.status}) before starting fresh session`);
             // The new engine must not touch the worktree while the zombie may still
             // be writing to it — a zombie that ignores its own stop is exactly the
-            // case this path exists for. Bounded: it cannot hold the new session
-            // hostage for more than STOP_AGENT_TIMEOUT_MS.
-            zombieEviction = stopWithTimeout(existingCtrl, STOP_AGENT_TIMEOUT_MS).then((stopped) => {
-                if (!stopped) {
-                    console.error(`[orchestrator] Zombie controller for workspace '${workspaceId}' did not stop within ${STOP_AGENT_TIMEOUT_MS}ms — starting the new session anyway`);
-                }
-            });
+            // case this path exists for. An unconfirmed stop fails the replacement.
+            zombieEviction = stopAgentAndWait(workspaceId, undefined, 'replacement').then(assertAgentStopped);
             // Drop any queued pending items + persisted user-input-requested events
             // tied to the zombie's agentSessionId so the new session doesn't inherit
             // a stale queue and so a future sync replay doesn't resurrect them.
@@ -1104,7 +1184,6 @@ export function startAgent(workspaceId, workingDir, prompt, model, resume = fals
             catch (err) {
                 console.warn('[orchestrator] Failed to purge zombie pending state:', err);
             }
-            controllers.delete(workspaceId);
         }
         else {
             throw new Error(`Agent already running for workspace '${workspaceId}'`);
@@ -1155,12 +1234,31 @@ export function startAgent(workspaceId, workingDir, prompt, model, resume = fals
     let controller;
     controller = new SessionController(workspaceId, agentSessionId, engine, (ev) => handleEvent(workspaceId, agentSessionId, controller, ev));
     registerSessionLifecycleOwner(workspaceId, agentSessionId, controller);
-    controllers.set(workspaceId, controller);
+    if (!existingCtrl)
+        controllers.set(workspaceId, controller);
+    else
+        pendingStarts.set(workspaceId, controller);
     // Kick off engine.start asynchronously, BEHIND the zombie eviction so the
     // new engine never runs concurrently with the one it replaces. Errors
     // surface as error events.
     void zombieEviction
-        .then(() => controller.start(options))
+        .then(() => {
+        // An explicit stop can cancel this replacement while its predecessor
+        // still owns the worktree. Its session row was already finalized there.
+        if (existingCtrl && controller.status === 'stopping')
+            return;
+        if (pendingStarts.get(workspaceId) === controller)
+            pendingStarts.delete(workspaceId);
+        assertWorkspaceLifecycleAvailable(workspaceId);
+        const current = getWs(workspaceId);
+        if (!current || current.archivedAt || current.worktreePurgedAt)
+            throw new Error('Workspace is no longer available');
+        const registered = controllers.get(workspaceId);
+        if (registered && registered !== controller)
+            throw new Error('Agent is still stopping');
+        controllers.set(workspaceId, controller);
+        return controller.start(options);
+    })
         .then(() => {
         const pid = controller.pid;
         if (pid !== undefined) {
@@ -1174,6 +1272,8 @@ export function startAgent(workspaceId, workingDir, prompt, model, resume = fals
         }
     })
         .catch((err) => {
+        if (existingCtrl && controller.status === 'stopping')
+            return;
         console.error('[orchestrator] engine.start failed:', err);
         const message = err instanceof Error ? err.message : String(err);
         handleEvent(workspaceId, agentSessionId, controller, {
@@ -1186,6 +1286,10 @@ export function startAgent(workspaceId, workingDir, prompt, model, resume = fals
             reason: 'error',
             exitCode: null,
         });
+    })
+        .finally(() => {
+        if (pendingStarts.get(workspaceId) === controller)
+            pendingStarts.delete(workspaceId);
     });
     return { agentSessionId, pid: undefined };
 }
@@ -1213,21 +1317,11 @@ export function interruptAgent(workspaceId, options = {}) {
         autoLoopService.disable(workspaceId, 'user-action');
     }
 }
-/**
- * Upper bound on a stop. Beyond this the engine is considered deaf to its own
- * stop path: we evict the controller so the workspace becomes usable again.
- *
- * This is an honest abandonment, not an escalation to something else that
- * watches over the process: Kōbō has no graduated SIGTERM/SIGKILL path of its
- * own, the `process-tracker` module that used to exist was removed, and the
- * session watchdog only walks the `controllers` map — the very map this
- * eviction just removed the entry from. Whatever survives past this timeout
- * is untracked by anyone in this process; only the OS or the user can end it.
- */
+/** Bound the caller's wait, retaining ownership until actual engine shutdown. */
 export const STOP_AGENT_TIMEOUT_MS = 15_000;
 async function stopController(workspaceId, ctrl, cause = 'user') {
     ctrl.stopCause = cause;
-    wakeupService.cancel(workspaceId, 'stopped');
+    preCompactionStatus.delete(ctrl);
     // Normalize the state synchronously so callers (archive, delete, manual
     // stop) see a clean workspace immediately — without waiting for the async
     // controller.stop() → session:ended round-trip, which onSessionEnded skips
@@ -1244,9 +1338,9 @@ async function stopController(workspaceId, ctrl, cause = 'user') {
     // Steps 1-2 are `awaiting-user`-specific: they only make sense when the
     // session actually left a pending question/permission behind.
     const wsBefore = getWs(workspaceId);
-    const activeStatuses = ['executing', 'brainstorming', 'extracting', 'awaiting-user'];
+    const activeStatuses = ['executing', 'brainstorming', 'extracting', 'awaiting-user', 'compacting'];
     if (wsBefore && activeStatuses.includes(wsBefore.status)) {
-        if (wsBefore.status === 'awaiting-user') {
+        if (wsBefore.status === 'awaiting-user' || wsBefore.status === 'compacting') {
             clearPendingForSession(workspaceId, ctrl.agentSessionId);
             purgeAllPersistedUserInputRequests(workspaceId, ctrl.agentSessionId);
         }
@@ -1257,25 +1351,21 @@ async function stopController(workspaceId, ctrl, cause = 'user') {
             console.warn(`[orchestrator] Failed to normalize ${wsBefore.status} → idle on stop:`, err);
         }
     }
-    // Manual stop should also drop any pending quota auto-resume.
-    quotaBackoffService.cancel(workspaceId, 'user');
     // D1 — the controller stays REGISTERED for the whole stop, in `stopping`
     // state. Removing it up-front (as we used to) made the only "is an agent
     // running?" signal of the system lie for the entire teardown window: cron
     // and auto-loop could start a second agent on the same worktree, and delete
     // could pull the worktree from under a process still writing to it.
-    try {
-        await ctrl.stop();
-    }
-    finally {
-        if (controllers.get(workspaceId) === ctrl)
-            controllers.delete(workspaceId);
+    await ctrl.stop();
+    if (controllers.get(workspaceId) === ctrl) {
+        controllers.delete(workspaceId);
+        notifyCapacityAvailable(workspaceId);
     }
 }
 /**
  * Race an arbitrary promise against a bounded deadline. Resolves to the
  * winner's value; if the deadline wins, `onTimeout()` supplies the value
- * instead. Never throws — the timer is always cleared. Single source of
+ * instead. The timer is always cleared. Single source of
  * truth for the "stop, but not forever" pattern: both `stopWithTimeout` and
  * `stopAgentAndWait` used to hand-roll their own `Promise.race` + timer, two
  * copies of the same logic that could silently drift apart.
@@ -1296,16 +1386,6 @@ async function raceWithTimeout(promise, timeoutMs, onTimeout) {
             clearTimeout(timer);
     }
 }
-/** Race a controller stop against a bounded deadline. Never throws. */
-async function stopWithTimeout(ctrl, timeoutMs) {
-    return raceWithTimeout(ctrl
-        .stop()
-        .then(() => true)
-        .catch((err) => {
-        console.error('[orchestrator] controller.stop rejected:', err);
-        return true;
-    }), timeoutMs, () => false);
-}
 /**
  * Stop the agent and wait for it to actually die. Every caller that mutates
  * the worktree afterwards — delete, archive, purge, setup script, engine
@@ -1313,21 +1393,46 @@ async function stopWithTimeout(ctrl, timeoutMs) {
  * engine may still be writing files.
  */
 export async function stopAgentAndWait(workspaceId, timeoutMs = STOP_AGENT_TIMEOUT_MS, 
-/** Why. `delete` and `purge` tell the session-ended hook to stand down. */
+/** Only `user` disables auto-loop; technical stops preserve its persisted intent. */
 cause = 'user') {
+    const pending = pendingStarts.get(workspaceId);
+    let pendingStop = Promise.resolve();
+    if (pending) {
+        pendingStarts.delete(workspaceId);
+        pending.stopCause = cause;
+        pendingStop = pending.stop().then(() => {
+            handleEvent(workspaceId, pending.agentSessionId, pending, {
+                kind: 'session:ended',
+                reason: 'killed',
+                exitCode: null,
+            });
+        });
+    }
     const ctrl = controllers.get(workspaceId);
-    if (!ctrl)
-        return 'not-running';
-    const finished = await raceWithTimeout(stopController(workspaceId, ctrl, cause).then(() => true, (err) => {
+    const controllerStop = ctrl ? stopController(workspaceId, ctrl, cause) : Promise.resolve();
+    // Cancel synchronously, including schedules whose controller already exited.
+    // A Promise executor contains DB failures within the bounded stop outcome.
+    // Shutdown only suspends timers: persisted intent belongs to the next boot.
+    const cancelSchedules = new Promise((resolve) => {
+        if (cause !== 'shutdown') {
+            wakeupService.cancel(workspaceId, 'stopped');
+            quotaBackoffService.cancel(workspaceId, 'user');
+        }
+        resolve();
+    });
+    // Mark every controller as stopping before the disable hook can run. Persist
+    // the user's intent even for a loop waiting for capacity with no controller.
+    const disableLoop = cause === 'user'
+        ? Promise.resolve().then(() => autoLoopService.disable(workspaceId, 'user-action'))
+        : Promise.resolve();
+    const outcome = await raceWithTimeout(Promise.all([pendingStop, controllerStop, cancelSchedules, disableLoop]).then(() => (ctrl || pending ? 'stopped' : 'not-running'), (err) => {
         console.error(`[orchestrator] controller.stop failed for '${workspaceId}':`, err);
-        return true;
-    }), timeoutMs, () => false);
-    if (finished)
-        return 'stopped';
-    console.error(`[orchestrator] Agent for workspace '${workspaceId}' did not stop within ${timeoutMs}ms — evicting its controller`);
-    if (controllers.get(workspaceId) === ctrl)
-        controllers.delete(workspaceId);
-    return 'timeout';
+        return 'failed';
+    }), timeoutMs, () => 'timeout');
+    if (outcome === 'timeout') {
+        console.error(`[orchestrator] Agent '${workspaceId}' did not stop within ${timeoutMs}ms; retaining its controller`);
+    }
+    return outcome;
 }
 /**
  * Fire-and-forget stop, for the few callers that cannot await (WebSocket
@@ -1346,13 +1451,26 @@ export function stopAgent(workspaceId) {
 }
 /** Stop every live engine before process shutdown, with a bounded wait per engine. */
 export async function stopAllAgents(timeoutMs = 3_000) {
+    quotaBackoffService.suspendForShutdown();
+    wakeupService.suspendForShutdown();
+    cronService.suspendForShutdown();
+    shuttingDown = true;
+    if (capacityTimer)
+        clearTimeout(capacityTimer);
+    capacityTimer = undefined;
+    stoppedCapacityOwners.clear();
     // No per-workspace try/catch here: unlike the pre-D1 shutdown path,
     // `stopAgentAndWait` never rejects — every internal failure (a rejecting
     // `controller.stop()`, or the bounded deadline firing) is already converted
-    // into a logged, returned `StopAgentOutcome` ('stopped' | 'timeout')
+    // into a logged, returned `StopAgentOutcome`
     // instead of a thrown error. A wrapping catch here would be unreachable
     // dead code pretending to guard against a failure mode that can't occur.
-    await Promise.all([...controllers.keys()].map((workspaceId) => stopAgentAndWait(workspaceId, timeoutMs)));
+    const workspaceIds = new Set([...controllers.keys(), ...pendingStarts.keys()]);
+    await Promise.all([...workspaceIds].map((workspaceId) => stopAgentAndWait(workspaceId, timeoutMs, 'shutdown')));
+}
+/** Automatic continuations must preserve their durable intent during teardown. */
+export function isShuttingDown() {
+    return shuttingDown;
 }
 /** Deliver a scheduled check without stopping background work or cancelling the wakeup as user input. */
 export function sendWakeupIfWaiting(workspaceId, content, expectedSessionId) {
@@ -1364,7 +1482,7 @@ export function sendWakeupIfWaiting(workspaceId, content, expectedSessionId) {
     const workspace = getWs(workspaceId);
     if (!workspace || workspace.archivedAt || workspace.worktreePurgedAt)
         return false;
-    if (workspace.status === 'awaiting-user' || workspace.status === 'quota')
+    if (workspace.status === 'awaiting-user' || workspace.status === 'quota' || workspace.status === 'compacting')
         return false;
     if (!ctrl.engineProcess?.sendWakeupIfWaiting?.(content))
         return false;
@@ -1373,6 +1491,7 @@ export function sendWakeupIfWaiting(workspaceId, content, expectedSessionId) {
 }
 /** Write a user message to the running agent. */
 export async function sendMessage(workspaceId, content, expectedSessionId) {
+    assertWorkspaceNotCompacting(workspaceId);
     const ctrl = controllers.get(workspaceId);
     if (!ctrl) {
         throw new Error(`No agent running for workspace '${workspaceId}'`);
@@ -1384,15 +1503,17 @@ export async function sendMessage(workspaceId, content, expectedSessionId) {
     await ctrl.sendMessage(content);
 }
 export async function sendMessageForFallback(workspaceId, content) {
+    assertWorkspaceNotCompacting(workspaceId);
     const capturedController = controllers.get(workspaceId);
+    wakeupService.cancel(workspaceId, 'user-message');
     if (!capturedController)
         return { status: 'stopped' };
-    wakeupService.cancel(workspaceId, 'user-message');
     try {
         await capturedController.sendMessage(content);
         return { status: 'sent', sessionId: capturedController.agentSessionId };
     }
     catch {
+        assertWorkspaceNotCompacting(workspaceId);
         const deadline = Date.now() + FALLBACK_CONTROLLER_TURNOVER_TIMEOUT_MS;
         while (controllers.get(workspaceId) === capturedController) {
             const remaining = deadline - Date.now();
@@ -1406,6 +1527,7 @@ export async function sendMessageForFallback(workspaceId, content) {
         const replacementController = controllers.get(workspaceId);
         if (!replacementController)
             return { status: 'stopped' };
+        assertWorkspaceNotCompacting(workspaceId);
         await replacementController.sendMessage(content);
         return { status: 'sent', sessionId: replacementController.agentSessionId };
     }
@@ -1525,7 +1647,10 @@ export async function answerPendingQuestion(workspaceId, answers, expectedToolCa
     purgePersistedUserInputRequest(workspaceId, head.toolCallId);
     const restoreTo = peekPending(workspaceId) ? 'awaiting-user' : consumePreAwaitStatus(workspaceId);
     try {
-        updateWorkspaceStatus(workspaceId, restoreTo);
+        if (getWs(workspaceId)?.status === 'compacting')
+            preCompactionStatus.set(ctrl, restoreTo);
+        else
+            updateWorkspaceStatus(workspaceId, restoreTo);
     }
     catch (err) {
         console.warn(`[orchestrator] Failed to transition awaiting-user → ${restoreTo}:`, err);
@@ -1613,7 +1738,10 @@ export async function answerPendingPermission(workspaceId, decision) {
     purgePersistedUserInputRequest(workspaceId, head.toolCallId);
     const restoreTo = peekPending(workspaceId) ? 'awaiting-user' : consumePreAwaitStatus(workspaceId);
     try {
-        updateWorkspaceStatus(workspaceId, restoreTo);
+        if (getWs(workspaceId)?.status === 'compacting')
+            preCompactionStatus.set(ctrl, restoreTo);
+        else
+            updateWorkspaceStatus(workspaceId, restoreTo);
     }
     catch (err) {
         console.warn(`[orchestrator] Failed to transition awaiting-user → ${restoreTo}:`, err);
@@ -1671,7 +1799,10 @@ export async function cancelPendingQuestion(workspaceId, reason, expectedToolCal
     purgePersistedUserInputRequest(workspaceId, head.toolCallId);
     const restoreTo = peekPending(workspaceId) ? 'awaiting-user' : consumePreAwaitStatus(workspaceId);
     try {
-        updateWorkspaceStatus(workspaceId, restoreTo);
+        if (getWs(workspaceId)?.status === 'compacting')
+            preCompactionStatus.set(ctrl, restoreTo);
+        else
+            updateWorkspaceStatus(workspaceId, restoreTo);
     }
     catch (err) {
         console.warn(`[orchestrator] Failed to transition awaiting-user → ${restoreTo}:`, err);
@@ -1896,7 +2027,12 @@ async function handleQuota(workspaceId, _agentSessionId) {
         retryCounts.set(workspaceId, retryCount + 1);
         // The quotaBackoffService owns the timer + the persistent row + the
         // 'agent:quota-backoff' WS emit. Hand off everything to it.
-        quotaBackoffService.arm(workspaceId, delayMs, { resetsAt: resetsAt ?? null, source, reason: 'quota' });
+        quotaBackoffService.arm(workspaceId, delayMs, {
+            resetsAt: resetsAt ?? null,
+            source,
+            reason: 'quota',
+            retryCount: retryCount + 1,
+        });
     }
     catch (err) {
         console.error(`[orchestrator] Could not arm the quota backoff for workspace '${workspaceId}':`, err);
@@ -1960,7 +2096,12 @@ async function handleTransientAutoLoopFailure(workspaceId) {
         const { delayMs, resetsAt, source } = await computeQuotaBackoffMs(workspaceId, retryCount, false);
         const effectiveDelayMs = retryCount === 0 ? Math.min(delayMs, TRANSIENT_FIRST_RETRY_MS) : delayMs;
         retryCounts.set(workspaceId, retryCount + 1);
-        quotaBackoffService.arm(workspaceId, effectiveDelayMs, { resetsAt: resetsAt ?? null, source, reason: 'transient' });
+        quotaBackoffService.arm(workspaceId, effectiveDelayMs, {
+            resetsAt: resetsAt ?? null,
+            source,
+            reason: 'transient',
+            retryCount: retryCount + 1,
+        });
     }
     catch (err) {
         console.error(`[orchestrator] Could not arm the transient retry for workspace '${workspaceId}':`, err);
@@ -1993,8 +2134,8 @@ export function restoreRetryCountsFromDb() {
 // in `quota` status and require manual user action (resume / new message)
 // to leave that state. This is intentional: without an auto-loop intent,
 // firing a fresh agent run in the user's absence would surprise them.
-quotaBackoffService.setOnFireCallback((workspaceId) => {
-    autoLoopService.onQuotaBackoffExpired(workspaceId);
+quotaBackoffService.setOnFireCallback((workspaceId, pending) => {
+    autoLoopService.onQuotaBackoffExpired(workspaceId, pending);
 });
 // ── Testing utilities ─────────────────────────────────────────────────────────
 /** @internal test-only */

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

@@ -11,6 +11,7 @@ export class SessionController {
     stopCause;
     _engineProcess;
     _startPromise;
+    _stopPromise;
     _status = 'running';
     /**
      * Set by `stop()`. Distinct from `_status` so the check in `startEngine` is
@@ -68,8 +69,8 @@ export class SessionController {
         const process = await this.engine.start(options, (ev) => this.handle(ev));
         this._engineProcess = process;
         if (this._status === 'stopping') {
-            this._engineProcess = undefined;
             await process.stop();
+            this._engineProcess = undefined;
             return;
         }
         this._status = 'running';
@@ -89,7 +90,16 @@ export class SessionController {
             throw new Error('SessionController not started');
         this._engineProcess.interrupt();
     }
-    async stop() {
+    stop() {
+        if (!this._stopPromise) {
+            this._stopPromise = this.stopEngine().catch((err) => {
+                this._stopPromise = undefined;
+                throw err;
+            });
+        }
+        return this._stopPromise;
+    }
+    async stopEngine() {
         this._stopRequested = true;
         this._status = 'stopping';
         // `startEngine` may still be in flight: `_engineProcess` stays undefined