@loicngr/kobo 2.1.15 → 2.1.18

package/dist/server/index.js

@@ -20,6 +20,7 @@ import gitRouter from './routes/git.js';
 import healthRouter from './routes/health.js';
 import imagesRouter from './routes/images.js';
 import integrationsRouter from './routes/integrations.js';
+import maintenanceRouter from './routes/maintenance.js';
 import mcpRouter from './routes/mcp.js';
 import memoryRouter from './routes/memory.js';
 import { migrationRouter } from './routes/migration.js';
@@ -32,6 +33,7 @@ import soundsRouter from './routes/sounds.js';
 import templatesRouter from './routes/templates.js';
 import usageRoutes from './routes/usage.js';
 import voiceRouter from './routes/voice.js';
+import workspaceMessagesRouter from './routes/workspace-messages.js';
 import workspaceTemplatesRouter from './routes/workspace-templates.js';
 import workspacesRouter from './routes/workspaces.js';
 import { getAvailableSkills, reconcileOrphanSessions, restoreRetryCountsFromDb, resumePendingReviewReturns, setBackendPort, startAgent, startWatchdog, stopAgentAndWait, stopAllAgents, stopWatchdog, } from './services/agent/orchestrator.js';
@@ -57,6 +59,7 @@ import { startUpdateChecker, stopUpdateChecker } from './services/update-check-s
 import { startUsagePoller, stopUsagePoller } from './services/usage/index.js';
 import * as wakeupService from './services/wakeup-service.js';
 import { handleConnection, setMessageHandler } from './services/websocket-service.js';
+import { reconcileGroupMessageBatches, stopGroupMessageBatches } from './services/workspace-group-message-service.js';
 import { deliverWorkspaceMessage } from './services/workspace-message-service.js';
 import { getWorkspace } from './services/workspace-service.js';
 import { resolveRetentionConfig } from './services/ws-events-retention-service.js';
@@ -84,6 +87,7 @@ catch (err) {
 }
 runMigrations(db);
 reconcileMessageRequests(db);
+reconcileGroupMessageBatches(db);
 reconcileMemoryContextsOnStartup();
 startSearchIndex();
 // Event retention. OPT-IN: disabled by default, so this is a no-op until the
@@ -155,6 +159,7 @@ app.use('/api/*', networkAuthMiddleware);
 app.get('/api/health', (c) => c.json({ status: 'ok', version: getPackageVersion() }));
 // Mount route sub-routers
 app.route('/api/workspaces', workspacesRouter);
+app.route('/api/workspace-messages', workspaceMessagesRouter);
 app.route('/api/mcp', mcpRouter);
 app.route('/api/memory', memoryRouter);
 app.route('/api/pull-requests', pullRequestsRouter);
@@ -174,6 +179,7 @@ app.route('/api/workspaces', documentsRouter);
 app.route('/api/workspaces', exportRouter);
 app.route('/api/search', searchRouter);
 app.route('/api/health', healthRouter);
+app.route('/api/maintenance', maintenanceRouter);
 app.route('/api/engines', enginesRouter);
 app.route('/api/environment', environmentRouter);
 app.route('/api/integrations', integrationsRouter);
@@ -413,6 +419,7 @@ async function gracefulShutdown(signal, exitCode = 0) {
         return;
     isShuttingDown = true;
     stopUpdateChecker();
+    const groupMessagesStopped = stopGroupMessageBatches();
     console.log(`\n[kobo] Received ${signal}, shutting down gracefully…`);
     const forceExitTimer = setTimeout(() => {
         console.error('[kobo] Graceful shutdown timed out; forcing exit');
@@ -479,6 +486,7 @@ async function gracefulShutdown(signal, exitCode = 0) {
     finally {
         try {
             const stopped = await Promise.allSettled([
+                groupMessagesStopped,
                 stopWsEventsRetention(),
                 stopSearchIndex(),
                 dailyBackupScheduler.stop(),

package/dist/server/middleware/workspace-creation-maintenance.js

@@ -0,0 +1,13 @@
+import { beginWorkspaceCreation } from '../services/update-maintenance-service.js';
+/** Admission remains held across every await and the handler's rollback paths. */
+export const workspaceCreationMaintenance = async (c, next) => {
+    const release = beginWorkspaceCreation();
+    if (!release)
+        return c.json({ code: 'update-maintenance', error: 'Workspace creation is unavailable during update maintenance' }, 503);
+    try {
+        await next();
+    }
+    finally {
+        release();
+    }
+};

package/dist/server/routes/maintenance.js

@@ -0,0 +1,32 @@
+import { Hono } from 'hono';
+import { isIdleForUpdate, resumeAfterUpdateMaintenance } from '../services/agent/orchestrator.js';
+import { acquireUpdateMaintenance, isUpdateMaintenanceActive, releaseUpdateMaintenance, } from '../services/update-maintenance-service.js';
+import { preserveForUpdateMaintenance } from '../services/wakeup-service.js';
+/** Protected by the same network-token/Host/Origin middleware as other APIs. */
+const app = new Hono();
+app.get('/update', (c) => c.json({ protocol: 1, active: isUpdateMaintenanceActive() }));
+app.on(['POST', 'DELETE'], '/update', async (c) => {
+    const body = await c.req.json().catch(() => null);
+    if (!body || typeof body.owner !== 'string' || !/^[a-f0-9]{32}$/.test(body.owner)) {
+        return c.json({ error: 'Expected a 32-character update reservation identifier' }, 400);
+    }
+    if (c.req.method === 'DELETE') {
+        if (!releaseUpdateMaintenance(body.owner))
+            return c.json({ error: 'Update reservation belongs to another owner' }, 409);
+        resumeAfterUpdateMaintenance();
+        return c.json({ protocol: 1, active: false });
+    }
+    // Both operations are synchronous: no agent can start between this check and reservation.
+    const result = acquireUpdateMaintenance(body.owner, () => {
+        if (!isIdleForUpdate())
+            return false;
+        // Commit deferral before acknowledging admission. Future wakeups may become
+        // overdue while the stopped volume is backed up and migrated.
+        preserveForUpdateMaintenance();
+        return true;
+    });
+    if (result !== 'acquired')
+        return c.json({ error: result === 'busy' ? 'Kōbō is busy' : 'Update already reserved' }, 409);
+    return c.json({ protocol: 1, active: true });
+});
+export default app;

package/dist/server/routes/mcp.js

@@ -4,21 +4,73 @@ import { CallToolRequestSchema, ListToolsRequestSchema } from '@modelcontextprot
 import { Hono } from 'hono';
 import { bodyLimit } from 'hono/body-limit';
 import { EXTERNAL_MEMORY_TOOL_DEFINITIONS, isMemoryToolName } from '../../shared/memory-tools.js';
+import { isWorkspaceCreationTool, MAX_MCP_CREATION_REQUEST_BYTES, WORKSPACE_CREATION_TOOLS, } from '../../shared/workspace-creation-tools.js';
 import { EXTERNAL_MCP_TOOLS } from '../../shared/workspace-dialogue-tools.js';
+import { isWorkspaceGroupMessageTool, WORKSPACE_GROUP_MESSAGE_TOOLS, } from '../../shared/workspace-group-message-tools.js';
+import { isWorkspaceLifecycleTool, WORKSPACE_LIFECYCLE_TOOLS } from '../../shared/workspace-lifecycle-tools.js';
 import { createMcpClientContext } from '../services/mcp-client-context.js';
 import { executeMemoryMcpTool } from '../services/memory-mcp-service.js';
+import { executeWorkspaceCreationTool, WorkspaceCreationMcpError } from '../services/workspace-creation-mcp-service.js';
 import { executeWorkspaceDialogueTool } from '../services/workspace-dialogue-service.js';
+import { executeWorkspaceGroupMessageTool, WorkspaceGroupMessageMcpError, } from '../services/workspace-group-message-mcp-service.js';
+import { executeWorkspaceLifecycleTool, WorkspaceLifecycleMcpError, } from '../services/workspace-lifecycle-mcp-service.js';
 import { prepareMemoryToolEnvelope } from '../utils/memory-token-budget.js';
 const app = new Hono();
-app.use('*', bodyLimit({ maxSize: 1024 * 1024 }));
+// Only creation envelopes may carry the larger, base64 attachment payload.
+// Other tools retain their existing 1 MiB limit, including malformed envelopes.
+app.use('*', bodyLimit({ maxSize: MAX_MCP_CREATION_REQUEST_BYTES }));
+app.use('*', async (c, next) => {
+    if (c.req.raw.body) {
+        const body = await c.req.raw.clone().arrayBuffer();
+        if (body.byteLength > 1024 * 1024) {
+            let creation = false;
+            try {
+                const envelope = JSON.parse(new TextDecoder().decode(body));
+                creation = envelope?.method === 'tools/call' && envelope?.params?.name === 'create_workspace';
+            }
+            catch {
+                /* Preserve the normal body-size rejection for malformed input. */
+            }
+            if (!creation)
+                return c.json({ error: 'MCP request is too large' }, 413);
+        }
+    }
+    return next();
+});
+/** Dispatch only the supported MCP operations through the existing UI handlers. */
+async function dispatchWorkspaceRequest(pathname, init) {
+    if (pathname === '/api/workspaces/archived')
+        throw new Error('Bulk operations are not supported by workspace MCP tools');
+    const isWorkspaceOperation = (init.method === 'POST' &&
+        (pathname === '/api/workspaces' ||
+            /^\/api\/workspaces\/[^/]+\/(unarchive|archive|purge-worktree|restore-worktree)$/.test(pathname))) ||
+        ((init.method === 'GET' || init.method === 'DELETE') && /^\/api\/workspaces\/[^/]+$/.test(pathname));
+    if (isWorkspaceOperation) {
+        const { default: routes } = await import('./workspaces.js');
+        return routes.request(`http://kobo.internal${pathname.slice('/api/workspaces'.length) || '/'}`, init);
+    }
+    if (init.method === 'POST' &&
+        (pathname === '/api/pull-requests/diagnose' || pathname === '/api/pull-requests/resolve')) {
+        const { default: routes } = await import('./pull-requests.js');
+        return routes.request(`http://kobo.internal${pathname.slice('/api/pull-requests'.length)}`, init);
+    }
+    throw new Error('Unsupported workspace operation');
+}
 app.all('/', async (c) => {
     const server = new Server({ name: 'kobo-workspaces', version: '1.0.0' }, { capabilities: { tools: {} } });
     const transport = new WebStandardStreamableHTTPServerTransport({
         sessionIdGenerator: undefined,
         enableJsonResponse: true,
+        maxRequestBodySize: MAX_MCP_CREATION_REQUEST_BYTES,
     });
     server.setRequestHandler(ListToolsRequestSchema, async () => ({
-        tools: [...EXTERNAL_MCP_TOOLS, ...EXTERNAL_MEMORY_TOOL_DEFINITIONS],
+        tools: [
+            ...EXTERNAL_MCP_TOOLS,
+            ...WORKSPACE_CREATION_TOOLS,
+            ...WORKSPACE_LIFECYCLE_TOOLS,
+            ...WORKSPACE_GROUP_MESSAGE_TOOLS,
+            ...EXTERNAL_MEMORY_TOOL_DEFINITIONS,
+        ],
     }));
     server.setRequestHandler(CallToolRequestSchema, async (request) => {
         const isMemory = isMemoryToolName(request.params.name);
@@ -26,7 +78,13 @@ app.all('/', async (c) => {
             const source = createMcpClientContext(c.req.header('X-Kobo-Client-Name'), c.req.header('X-Kobo-Client-Transport') === 'stdio' ? 'stdio' : 'http', c.req.header('X-Kobo-Client-Name-Encoding'));
             const data = isMemory
                 ? executeMemoryMcpTool(request.params.name, request.params.arguments ?? {}, source)
-                : await executeWorkspaceDialogueTool(request.params.name, request.params.arguments ?? {}, source);
+                : isWorkspaceCreationTool(request.params.name)
+                    ? await executeWorkspaceCreationTool(request.params.name, request.params.arguments ?? {}, dispatchWorkspaceRequest)
+                    : isWorkspaceLifecycleTool(request.params.name)
+                        ? await executeWorkspaceLifecycleTool(request.params.name, request.params.arguments ?? {}, dispatchWorkspaceRequest)
+                        : isWorkspaceGroupMessageTool(request.params.name)
+                            ? executeWorkspaceGroupMessageTool(request.params.name, request.params.arguments ?? {}, source)
+                            : await executeWorkspaceDialogueTool(request.params.name, request.params.arguments ?? {}, source);
             if (isMemory) {
                 const bounded = prepareMemoryToolEnvelope(data, { targetTokens: 1_000, transport: 'external' });
                 if (bounded.data.memoryOutputSuppressed === true)
@@ -46,6 +104,14 @@ app.all('/', async (c) => {
             };
         }
         catch (error) {
+            if (error instanceof WorkspaceGroupMessageMcpError) {
+                const data = { error: error.message, status: error.status };
+                return { isError: true, content: [{ type: 'text', text: JSON.stringify(data) }], structuredContent: data };
+            }
+            if (error instanceof WorkspaceCreationMcpError || error instanceof WorkspaceLifecycleMcpError) {
+                const data = { error: error.message, status: error.status, stage: error.stage, details: error.details };
+                return { isError: true, content: [{ type: 'text', text: JSON.stringify(data) }], structuredContent: data };
+            }
             if (isMemory) {
                 const bounded = prepareMemoryToolEnvelope({
                     error: error instanceof Error ? error.message : String(error),

package/dist/server/routes/pull-requests.js

@@ -1,5 +1,6 @@
 import path from 'node:path';
 import { Hono } from 'hono';
+import { workspaceCreationMaintenance } from '../middleware/workspace-creation-maintenance.js';
 import { getForgeProvider } from '../services/forge/registry.js';
 import { resolveForge } from '../services/forge/resolve.js';
 import * as prCheckout from '../services/pr-checkout-service.js';
@@ -86,7 +87,7 @@ app.post('/diagnose', async (c) => {
         return c.json({ error: err instanceof Error ? err.message : String(err) }, 500);
     }
 });
-app.post('/resolve', async (c) => {
+app.post('/resolve', workspaceCreationMaintenance, async (c) => {
     try {
         const body = await c.req
             .json()

package/dist/server/routes/workspace-messages.js

@@ -0,0 +1,22 @@
+import { Hono } from 'hono';
+import { bodyLimit } from 'hono/body-limit';
+import { MAX_GROUP_MESSAGE_REQUEST_BYTES } from '../../shared/workspace-group-messages.js';
+import { GroupMessageError, getGroupMessageBatch, startGroupMessageBatch, } from '../services/workspace-group-message-service.js';
+const app = new Hono();
+app.use('*', bodyLimit({ maxSize: MAX_GROUP_MESSAGE_REQUEST_BYTES }));
+app.post('/', async (c) => {
+    const body = await c.req.json().catch(() => null);
+    try {
+        return c.json(startGroupMessageBatch(body), 202);
+    }
+    catch (error) {
+        if (error instanceof GroupMessageError)
+            return c.json({ error: error.message }, error.status);
+        throw error;
+    }
+});
+app.get('/:id', (c) => {
+    const batch = getGroupMessageBatch(c.req.param('id'));
+    return batch ? c.json(batch) : c.json({ error: 'Group message not found' }, 404);
+});
+export default app;

package/dist/server/routes/workspaces.js

@@ -19,6 +19,7 @@ import { MAX_ATTACHMENT_REQUEST_BYTES } from '../../shared/attachments.js';
 import { AUTO_LOOP_HARD_RULES, buildAutoLoopGroomingSteps, buildGroomingIntro } from '../../shared/auto-loop-prompts.js';
 import { getDb } from '../db/index.js';
 import { migrationGuard } from '../middleware/migration-guard.js';
+import { workspaceCreationMaintenance } from '../middleware/workspace-creation-maintenance.js';
 import { listEngines } from '../services/agent/engines/registry.js';
 import * as agentManager from '../services/agent/orchestrator.js';
 import * as archiveScriptService from '../services/archive-script-service.js';
@@ -105,8 +106,16 @@ app.use('/:id/*', async (c, next) => {
     }
     await next();
 });
-// These handlers own teardown across awaits; purge/delete/restore own their guard in the service.
-for (const route of ['/:id/archive', '/:id/run-setup-script', '/:id/cancel-source-change', '/:id/rollback-file']) {
+// Branch/path mutations must also exclude teardown across awaits.
+// Purge/delete/restore own their guard in the service.
+for (const route of [
+    '/:id/archive',
+    '/:id/run-setup-script',
+    '/:id/cancel-source-change',
+    '/:id/rollback-file',
+    '/:id/rename-branch',
+    '/:id/resync-branch',
+]) {
     app.use(route, async (c, next) => {
         try {
             await withWorkspaceLifecycleGuard(c.req.param('id'), next);
@@ -444,7 +453,7 @@ const creationBodyLimit = bodyLimit({
     maxSize: MAX_ATTACHMENT_REQUEST_BYTES,
     onError: (c) => c.json({ error: 'Workspace creation request is too large', step: 'validate' }, 413),
 });
-app.post('/', migrationGuard, creationBodyLimit, async (c) => {
+app.post('/', workspaceCreationMaintenance, migrationGuard, creationBodyLimit, async (c) => {
     // Declared outside the try so the outermost catch (any unforeseen throw,
     // including a malformed request body) can still name a step instead of
     // leaving the create-progress channel silent. Updated in lockstep with
@@ -570,6 +579,7 @@ app.post('/', migrationGuard, creationBodyLimit, async (c) => {
         // the working branch from git itself — the body.workingBranch is ignored.
         let useReusedWorktree = false;
         let reusedDerivedBranch = null;
+        let reusedIdentity = null;
         if (body.worktreePath) {
             currentStep = 'inspect-worktree';
             emitCreateProgress(creationId, currentStep);
@@ -598,6 +608,14 @@ app.post('/', migrationGuard, creationBodyLimit, async (c) => {
                     return c.json({ error: failure, step: 'inspect-worktree' }, 422);
                 }
                 reusedDerivedBranch = branch;
+                const directory = fs.statSync(body.worktreePath);
+                const gitEntry = fs.statSync(path.join(body.worktreePath, '.git'));
+                reusedIdentity = {
+                    device: directory.dev,
+                    inode: directory.ino,
+                    gitDevice: gitEntry.dev,
+                    gitInode: gitEntry.ino,
+                };
             }
             catch (err) {
                 const message = err instanceof Error ? err.message : String(err);
@@ -781,6 +799,36 @@ app.post('/', migrationGuard, creationBodyLimit, async (c) => {
         const creation = await withGitRepoLock(body.projectPath, async () => {
             let prospectiveWorktreePath;
             if (useReusedWorktree) {
+                // Imports above may yield long enough for a failed PR creation to remove
+                // its checkout. Recheck the exact directory and branch under the same
+                // repository lock as compensation before any record/context files exist.
+                try {
+                    const worktreePath = body.worktreePath;
+                    const directory = fs.statSync(worktreePath);
+                    const gitEntry = fs.statSync(path.join(worktreePath, '.git'));
+                    const commonDir = execFileSync('git', ['-C', worktreePath, 'rev-parse', '--path-format=absolute', '--git-common-dir'], {
+                        encoding: 'utf-8',
+                        timeout: 30_000,
+                    }).trim();
+                    const branch = execFileSync('git', ['-C', worktreePath, 'rev-parse', '--abbrev-ref', 'HEAD'], {
+                        encoding: 'utf-8',
+                        timeout: 30_000,
+                    }).trim();
+                    if (!reusedIdentity ||
+                        !directory.isDirectory() ||
+                        directory.dev !== reusedIdentity.device ||
+                        directory.ino !== reusedIdentity.inode ||
+                        gitEntry.dev !== reusedIdentity.gitDevice ||
+                        gitEntry.ino !== reusedIdentity.gitInode ||
+                        realPathOrResolved(commonDir) !== realPathOrResolved(path.join(body.projectPath, '.git')) ||
+                        branch !== reusedDerivedBranch)
+                        throw new Error('The worktree directory, repository or branch changed during creation; retry from a fresh diagnosis');
+                }
+                catch (err) {
+                    const failure = `Failed to revalidate worktree: ${err instanceof Error ? err.message : String(err)}`;
+                    emitCreateFailed(creationId, 'inspect-worktree', failure);
+                    return c.json({ error: failure, step: 'inspect-worktree' }, 422);
+                }
                 // Another attachment may have completed while this request waited for the lock.
                 const existing = getDb().prepare('SELECT id FROM workspaces WHERE worktree_path = ?').get(body.worktreePath);
                 if (existing) {
@@ -3180,6 +3228,12 @@ app.post('/:id/unarchive', migrationGuard, (c) => {
         return c.json({ error: message }, workspaceErrorStatus(err));
     }
 });
+class WorkspaceBranchConfirmationError extends Error {
+    code = 'branch-confirmation-mismatch';
+    constructor() {
+        super('The workspace branch changed or does not match confirmationBranch. Confirm its current branch before deleting.');
+    }
+}
 // Shared teardown for a single workspace: stops the agent, destroys the
 // terminal, removes the owned worktree, optionally deletes local/remote
 // branches, then deletes the DB row (cascades to tasks/sessions/events).
@@ -3191,6 +3245,8 @@ async function deleteWorkspaceWithSideEffects(workspace, opts) {
         const current = workspaceService.getWorkspace(workspace.id);
         if (!current)
             throw new Error(`Workspace '${workspace.id}' not found`);
+        if (opts.confirmationBranch !== undefined && opts.confirmationBranch !== current.workingBranch)
+            throw new WorkspaceBranchConfirmationError();
         // A bulk deletion may have captured the list before restoration completed.
         if (workspace.archivedAt && !current.archivedAt) {
             throw new Error('Workspace was unarchived while deletion was pending. Retry from its current state.');
@@ -3335,7 +3391,7 @@ app.delete('/:id', migrationGuard, async (c) => {
         return c.json({ ok: true, warnings }, 200);
     }
     catch (err) {
-        if (err instanceof WorkspaceLifecycleBusyError)
+        if (err instanceof WorkspaceLifecycleBusyError || err instanceof WorkspaceBranchConfirmationError)
             return c.json({ code: err.code, error: err.message }, 409);
         const message = err instanceof Error ? err.message : String(err);
         return c.json({ error: message }, workspaceErrorStatus(err));

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

@@ -20,6 +20,7 @@ import { buildReviewReturnPrompt, claimReviewReturn, completeReviewReturn, getRe
 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 { isUpdateMaintenanceActive } from '../update-maintenance-service.js';
 import { refreshNow } from '../usage/poller.js';
 import * as wakeupService from '../wakeup-service.js';
 import { emit, emitEphemeral } from '../websocket-service.js';
@@ -67,7 +68,7 @@ let shuttingDown = false;
 let capacityTimer;
 const stoppedCapacityOwners = new Set();
 function notifyCapacityAvailable(stoppedWorkspaceId) {
-    if (shuttingDown)
+    if (isShuttingDown())
         return;
     stoppedCapacityOwners.add(stoppedWorkspaceId);
     if (capacityTimer)
@@ -77,7 +78,7 @@ function notifyCapacityAvailable(stoppedWorkspaceId) {
         capacityTimer = undefined;
         const excluded = new Set(stoppedCapacityOwners);
         stoppedCapacityOwners.clear();
-        if (shuttingDown)
+        if (isShuttingDown())
             return;
         try {
             resumePendingReviewReturns();
@@ -1365,7 +1366,7 @@ function revokeControllerMemoryCapability(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)
+    if (isShuttingDown())
         return;
     for (const pending of listReviewReturns()) {
         const id = pending.workspaceId;
@@ -1465,6 +1466,8 @@ export function cancelReviewReturn(workspaceId) {
  * query the controller via `_getControllers()` for tests.
  */
 export function startAgent(workspaceId, workingDir, prompt, model, resume = false, agentPermissionMode, existingSessionId, reasoningEffort, beforeDispatch, launch) {
+    if (isUpdateMaintenanceActive())
+        throw new Error('Cannot start an agent during update maintenance');
     if (shuttingDown)
         throw new Error('Cannot start an agent while the server is shutting down');
     assertWorkspaceLifecycleAvailable(workspaceId, launch?.lifecycleOwner);
@@ -1914,7 +1917,20 @@ export async function stopAllAgents(timeoutMs = 3_000) {
 }
 /** Automatic continuations must preserve their durable intent during teardown. */
 export function isShuttingDown() {
-    return shuttingDown;
+    return shuttingDown || isUpdateMaintenanceActive();
+}
+/** Used synchronously by update reservation; include runtimes still closing and pending replacements. */
+export function isIdleForUpdate() {
+    if (shuttingDown || controllers.size || pendingStarts.size)
+        return false;
+    const db = getDb();
+    return (!db.prepare("SELECT 1 FROM agent_sessions WHERE status = 'running' LIMIT 1").get() &&
+        !db
+            .prepare("SELECT 1 FROM workspaces WHERE status IN ('extracting','brainstorming','executing','compacting') LIMIT 1")
+            .get());
+}
+export function resumeAfterUpdateMaintenance() {
+    notifyCapacityAvailable('');
 }
 /** Deliver a scheduled check without stopping background work or cancelling the wakeup as user input. */
 export function sendWakeupIfWaiting(workspaceId, content, expectedSessionId) {
@@ -1947,8 +1963,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);

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() {

package/dist/server/services/cron-service.js

@@ -7,6 +7,7 @@ import { resolveWorkspaceWorktreePath } from '../utils/worktree-paths.js';
 import * as orchestrator from './agent/orchestrator.js';
 import * as autoLoopService from './auto-loop-service.js';
 import * as settingsService from './settings-service.js';
+import { deferForUpdateMaintenance } from './update-maintenance-service.js';
 import { emitEphemeral } from './websocket-service.js';
 export const MIN_DELAY_BETWEEN_FIRES_SECONDS = 60;
 // Node `setTimeout` stores the delay as a 32-bit signed int. Anything above
@@ -185,6 +186,12 @@ export function listAll() {
 function fireOrSkip(id) {
     if (suspended)
         return;
+    const pendingTimer = timers.get(id);
+    if (deferForUpdateMaintenance(`cron:${id}`, () => {
+        if (timers.get(id) === pendingTimer)
+            fireOrSkip(id);
+    }))
+        return;
     try {
         timers.delete(id);
         const db = getDb();

package/dist/server/services/pr-checkout-rollback-service.js

@@ -0,0 +1,51 @@
+import { execFileSync } from 'node:child_process';
+import fs from 'node:fs';
+import path from 'node:path';
+import { getDb } from '../db/index.js';
+import { buildNonInteractiveGitEnv } from '../utils/git-ops.js';
+import { withGitRepoLock } from '../utils/git-repo-lock.js';
+/** Undo only our unchanged checkout, never the PR branch or earlier checkout decisions. */
+export async function rollbackCreatedPrCheckout(projectPath, checkout) {
+    const retained = (reason) => ({ removed: false, worktreePath: checkout.worktreePath, reason });
+    if (!checkout.createdWorktree)
+        return retained('The checkout existed before this request');
+    try {
+        return await withGitRepoLock(projectPath, () => {
+            // Workspace adoption uses this same lock. Keep checks and removal synchronous
+            // so another request cannot attach this checkout between the ownership read and removal.
+            const owners = getDb().prepare('SELECT worktree_path FROM workspaces').all();
+            const resolved = fs.realpathSync(checkout.worktreePath);
+            if (owners.some(({ worktree_path }) => {
+                try {
+                    return fs.realpathSync(worktree_path) === resolved;
+                }
+                catch {
+                    return path.resolve(worktree_path) === resolved;
+                }
+            }))
+                return retained('The checkout is attached to a workspace');
+            const stat = fs.lstatSync(checkout.worktreePath);
+            const identity = checkout.createdWorktree;
+            if (!stat.isDirectory() || stat.dev !== identity.device || stat.ino !== identity.inode)
+                return retained('The checkout directory was replaced');
+            const git = (cwd, args) => execFileSync('git', args, {
+                cwd,
+                encoding: 'utf8',
+                timeout: 30_000,
+                maxBuffer: 16 * 1024 * 1024,
+                env: buildNonInteractiveGitEnv(),
+            }).trim();
+            if (git(resolved, ['rev-parse', 'HEAD']) !== identity.head ||
+                git(resolved, ['symbolic-ref', '--short', 'HEAD']) !== checkout.workingBranch)
+                return retained('The checkout branch or HEAD changed');
+            if (git(resolved, ['status', '--porcelain', '--untracked-files=all', '--ignored']))
+                return retained('The checkout contains local or ignored files');
+            // No --force: Git performs its own final dirty/locked-worktree checks.
+            git(projectPath, ['worktree', 'remove', '--', resolved]);
+            return { removed: true, worktreePath: checkout.worktreePath };
+        });
+    }
+    catch (error) {
+        return retained(error instanceof Error ? error.message : String(error));
+    }
+}

package/dist/server/services/pr-checkout-service.js

@@ -227,6 +227,8 @@ export async function applyBranchStrategy(repoPath, branch, strategy) {
     if (strategy === 'keep')
         return { strategy, backupBranch: null };
     if (strategy === 'fast-forward') {
+        // A caller cannot turn fast-forward into a silent reset of local commits.
+        await readGitAsync(repoPath, ['merge-base', '--is-ancestor', branch, remoteRef]);
         await runGitAsync(repoPath, ['branch', '--force', branch, remoteRef]);
         return { strategy, backupBranch: null };
     }
@@ -301,6 +303,9 @@ function resolvePrCheckoutLocked(input, owner) {
         const fresh = await diagnoseLocalState(input.projectPath, input.headBranch, input.worktreesPath, input.attachedPaths ?? new Map(), input.workspaces ?? []);
         if ((await computeFingerprint(fresh)) !== input.fingerprint)
             throw new StaleDiagnosisError(fresh);
+        if (input.decisions.divergence === 'fast-forward' &&
+            (fresh.branch.state === 'ahead' || fresh.branch.state === 'diverged'))
+            throw new Error('Fast-forward cannot discard local commits. Keep, rebase or explicitly reset the branch.');
         if ((fresh.worktree.state === 'orphan' || fresh.worktree.state === 'attached') &&
             input.decisions.orphanWorktree === 'create-elsewhere') {
             throw new Error('Branch is already checked out. Attach its existing worktree instead.');
@@ -392,7 +397,16 @@ function resolvePrCheckoutLocked(input, owner) {
         //    realignment from step 4 (if any) is NOT undone here — a `reset-hard`
         //    strategy already left its own `kobo-backup/<branch>-<ts>` safety net,
         //    and fast-forward/rebase are non-destructive by construction.
+        let createdWorktree;
         try {
+            if (created) {
+                const stat = fs.lstatSync(worktreePath);
+                createdWorktree = {
+                    device: stat.dev,
+                    inode: stat.ino,
+                    head: await runGitAsync(worktreePath, ['rev-parse', 'HEAD']),
+                };
+            }
             input.afterWorktreeHook?.();
         }
         catch (err) {
@@ -409,7 +423,13 @@ function resolvePrCheckoutLocked(input, owner) {
             }
             throw err;
         }
-        return { worktreePath, workingBranch: input.headBranch, sourceBranch: input.baseBranch, applied };
+        return {
+            worktreePath,
+            workingBranch: input.headBranch,
+            sourceBranch: input.baseBranch,
+            applied,
+            ...(createdWorktree ? { createdWorktree } : {}),
+        };
     });
 }
 /** Realign a branch from inside its own worktree, where ref surgery is refused. */

package/dist/server/services/quota-backoff-service.js

@@ -1,4 +1,5 @@
 import { getDb } from '../db/index.js';
+import { deferForUpdateMaintenance } from './update-maintenance-service.js';
 import { emitEphemeral } from './websocket-service.js';
 import { getWorkspace } from './workspace-service.js';
 const timers = new Map();
@@ -142,6 +143,12 @@ export function restoreOnBoot(onFire) {
 function fireOrSkip(workspaceId) {
     if (suspended)
         return;
+    const pendingTimer = timers.get(workspaceId);
+    if (deferForUpdateMaintenance(`quota-backoff:${workspaceId}`, () => {
+        if (timers.get(workspaceId) === pendingTimer)
+            fireOrSkip(workspaceId);
+    }))
+        return;
     timers.delete(workspaceId);
     const pending = getPending(workspaceId);
     if (!pending)