@loicngr/kobo 2.1.15 → 2.1.18

package/dist/server/services/update-maintenance-service.js

@@ -0,0 +1,44 @@
+/** Process-local reservation: restart clears it; only its owner may cancel it. */
+let owner;
+const deferred = new Map();
+const creations = new Set();
+/** Reserve the entire creation/checkout, including asynchronous setup and rollback. */
+export function beginWorkspaceCreation() {
+    if (owner !== undefined)
+        return null;
+    const creation = Symbol('workspace-creation');
+    creations.add(creation);
+    return () => {
+        creations.delete(creation);
+    };
+}
+export function isUpdateMaintenanceActive() {
+    return owner !== undefined;
+}
+/** No await between inspecting runtime ownership and closing admission. */
+export function acquireUpdateMaintenance(candidate, isIdle) {
+    if (owner !== undefined)
+        return owner === candidate ? 'acquired' : 'conflict';
+    if (creations.size || !isIdle())
+        return 'busy';
+    owner = candidate;
+    return 'acquired';
+}
+/** Keep scheduler rows/deadlines untouched while delivery is suspended. */
+export function deferForUpdateMaintenance(key, callback) {
+    if (owner === undefined)
+        return false;
+    deferred.set(key, callback);
+    return true;
+}
+export function releaseUpdateMaintenance(candidate) {
+    if (owner !== candidate)
+        return false;
+    owner = undefined;
+    for (const callback of deferred.values()) {
+        const timer = setTimeout(callback, 0);
+        timer.unref?.();
+    }
+    deferred.clear();
+    return true;
+}

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

@@ -5,6 +5,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, isUpdateMaintenanceActive } from './update-maintenance-service.js';
 import { emitEphemeral } from './websocket-service.js';
 const MIN_DELAY_SECONDS = 60;
 const MAX_DELAY_SECONDS = 21600;
@@ -22,6 +23,17 @@ export function suspendForShutdown() {
         clearTimeout(timer);
     timers.clear();
 }
+/** Claim valid pending wakeups before planned downtime, without changing their requested deadline. */
+export function preserveForUpdateMaintenance() {
+    const cutoff = new Date(Date.now() - STALE_WAKEUP_GRACE_MS).toISOString();
+    getDb()
+        .prepare(`UPDATE pending_wakeups SET retry_at = target_at
+       WHERE retry_at IS NULL AND julianday(target_at) >= julianday(?)
+       AND workspace_id IN (
+         SELECT id FROM workspaces WHERE archived_at IS NULL AND worktree_purged_at IS NULL
+       )`)
+        .run(cutoff);
+}
 function clamp(n, lo, hi) {
     return Math.max(lo, Math.min(hi, n));
 }
@@ -60,10 +72,10 @@ export function schedule(workspaceId, delaySeconds, prompt, reason, agentSession
     // the original durable wakeup and its timer intact, and fail the MCP receipt.
     const row = getDb()
         .prepare(`INSERT OR REPLACE INTO pending_wakeups
-       (workspace_id, target_at, prompt, reason, created_at, agent_session_id)
-     VALUES (?, ?, ?, ?, ?, ?)
+       (workspace_id, target_at, prompt, reason, created_at, agent_session_id, retry_at)
+     VALUES (?, ?, ?, ?, ?, ?, ?)
      RETURNING target_at, reason`)
-        .get(workspaceId, targetAtIso, effectivePrompt, reason ?? null, new Date().toISOString(), agentSessionId ?? null);
+        .get(workspaceId, targetAtIso, effectivePrompt, reason ?? null, new Date().toISOString(), agentSessionId ?? null, isUpdateMaintenanceActive() ? targetAtIso : null);
     const pending = { targetAt: row.target_at, reason: row.reason ?? undefined };
     const existing = timers.get(workspaceId);
     if (existing)
@@ -168,6 +180,12 @@ export function rehydrate() {
 function fire(workspaceId) {
     if (suspended)
         return;
+    const pendingTimer = timers.get(workspaceId);
+    if (deferForUpdateMaintenance(`wakeup:${workspaceId}`, () => {
+        if (timers.get(workspaceId) === pendingTimer)
+            fire(workspaceId);
+    }))
+        return;
     try {
         const db = getDb();
         const row = db.prepare('SELECT * FROM pending_wakeups WHERE workspace_id = ?').get(workspaceId);

package/dist/server/services/workspace-creation-mcp-service.js

@@ -0,0 +1,214 @@
+import { checkoutDecisionError, deriveSteps } from '../../shared/pr-checkout-steps.js';
+import { validateWorkspaceCreationArguments } from '../../shared/workspace-creation-tools.js';
+import { CLAUDE_CODE_CAPABILITIES } from './agent/engines/claude-code/capabilities.js';
+import { CODEX_CAPABILITIES } from './agent/engines/codex/capabilities.js';
+import { rollbackCreatedPrCheckout } from './pr-checkout-rollback-service.js';
+import { beginWorkspaceCreation } from './update-maintenance-service.js';
+export class WorkspaceCreationMcpError extends Error {
+    status;
+    stage;
+    details;
+    constructor(message, status, stage, details = null) {
+        super(message);
+        this.status = status;
+        this.stage = stage;
+        this.details = details;
+        this.name = 'WorkspaceCreationMcpError';
+    }
+}
+async function request(dispatch, path, stage, body, init) {
+    const response = await dispatch(path, init ?? { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify(body ?? {}) });
+    const payload = await response.json().catch(() => null);
+    if (!response.ok)
+        throw new WorkspaceCreationMcpError(payload?.error ?? `Workspace request failed (${response.status})`, response.status, stage, payload);
+    return payload;
+}
+function prIdentity(raw) {
+    const url = new URL(raw);
+    const pathname = url.pathname.replace(/\/+$/, '');
+    const last = pathname.split('/').at(-1);
+    const number = Number(last);
+    if (!/^[1-9]\d*$/.test(last) || !Number.isSafeInteger(number))
+        throw new WorkspaceCreationMcpError('pr_url must end with a PR/MR number', 400, 'validate');
+    return { number, identity: `${url.origin}${pathname}` };
+}
+function mapInput(input) {
+    const mapping = {
+        name: 'name',
+        project_path: 'projectPath',
+        source_branch: 'sourceBranch',
+        working_branch: 'workingBranch',
+        model: 'model',
+        reasoning_effort: 'reasoningEffort',
+        brainstorm_model: 'brainstormModel',
+        brainstorm_reasoning_effort: 'brainstormReasoningEffort',
+        engine: 'engine',
+        description: 'description',
+        tags: 'tags',
+        tasks: 'tasks',
+        acceptance_criteria: 'acceptanceCriteria',
+        agent_permission_mode: 'agentPermissionMode',
+        auto_loop: 'autoLoop',
+        auto_loop_session_mode: 'autoLoopSessionMode',
+        skip_setup_script: 'skipSetupScript',
+        workflow_policy: 'workflowPolicy',
+        notion_url: 'notionUrl',
+        notion_page_id: 'notionPageId',
+        sentry_url: 'sentryUrl',
+        pr_url: 'prUrl',
+        worktree_path: 'worktreePath',
+        comparison_id: 'comparisonId',
+        creation_id: 'creationId',
+    };
+    const body = {};
+    for (const [key, field] of Object.entries(mapping))
+        if (Object.hasOwn(input, key))
+            body[field] = input[key];
+    if (input.auto_loop_final_review !== undefined) {
+        const config = input.auto_loop_final_review;
+        body.autoLoopFinalReview =
+            config === null
+                ? null
+                : {
+                    engine: config.engine,
+                    model: config.model,
+                    reasoningEffort: config.reasoning_effort,
+                    additionalInstructions: config.additional_instructions ?? '',
+                };
+    }
+    return body;
+}
+/** Reuses the application's route validation, lifecycle guards, Git locks and rollback. */
+export async function executeWorkspaceCreationTool(name, raw, dispatch) {
+    if (name !== 'create_workspace')
+        return executeCreation(name, raw, dispatch);
+    // One lease spans both in-process routes and any compensating checkout rollback.
+    // Each route also guards direct HTTP callers; nested leases are safe.
+    const release = beginWorkspaceCreation();
+    if (!release)
+        throw new WorkspaceCreationMcpError('Workspace creation is unavailable during update maintenance', 503, 'maintenance');
+    try {
+        return await executeCreation(name, raw, dispatch);
+    }
+    finally {
+        release();
+    }
+}
+async function executeCreation(name, raw, dispatch) {
+    let input;
+    try {
+        input = validateWorkspaceCreationArguments(name, raw);
+    }
+    catch (error) {
+        throw new WorkspaceCreationMcpError(error instanceof Error ? error.message : 'Invalid arguments', 400, 'validate');
+    }
+    const config = input.auto_loop_final_review;
+    if (config) {
+        const capabilities = config.engine === 'codex' ? CODEX_CAPABILITIES : CLAUDE_CODE_CAPABILITIES;
+        if (!capabilities.effortLevels?.some((effort) => effort.id === config.reasoning_effort))
+            throw new WorkspaceCreationMcpError('Unsupported review reasoning effort', 400, 'validate');
+    }
+    const body = mapInput(input);
+    let resolvedCheckout;
+    if (input.pr_url) {
+        const supplied = prIdentity(input.pr_url);
+        const diagnosis = await request(dispatch, '/api/pull-requests/diagnose', 'diagnose', {
+            projectPath: input.project_path,
+            prNumber: supplied.number,
+        });
+        const requiresAction = (reason) => ({
+            created: false,
+            requiresAction: true,
+            ...diagnosis,
+            ...(reason ? { reason } : {}),
+        });
+        if (diagnosis.pr && prIdentity(diagnosis.pr.url).identity !== supplied.identity)
+            throw new WorkspaceCreationMcpError('pr_url does not belong to the selected project', 400, 'diagnose', diagnosis);
+        if (name === 'diagnose_workspace_pr')
+            return diagnosis;
+        if (!diagnosis.pr)
+            return requiresAction('Pull request unavailable');
+        const { report, pr, fingerprint } = diagnosis;
+        const plan = input.pr_checkout;
+        if (plan && plan.fingerprint !== fingerprint)
+            throw new WorkspaceCreationMcpError('The repository changed since the diagnosis was taken', 409, 'diagnose', diagnosis);
+        const decisions = plan?.decisions ?? {};
+        if (report.workspace.state === 'active' && decisions.existingWorkspace === 'open')
+            return { created: false, workspaceId: report.workspace.id, workspace: report.workspace };
+        if (report.workspace.state === 'archived' && decisions.archivedWorkspace === 'unarchive') {
+            const workspace = await request(dispatch, `/api/workspaces/${encodeURIComponent(report.workspace.id)}/unarchive`, 'unarchive');
+            return { created: false, workspaceId: report.workspace.id, workspace };
+        }
+        // A purge or an existing association must never fall through to a second creation.
+        if (report.workspace.state !== 'none')
+            return requiresAction('Use the existing workspace; automatic duplicate creation is not supported');
+        if (decisions.ongoingOperation === 'cancel')
+            return { created: false, cancelled: true, ...diagnosis };
+        const error = checkoutDecisionError(report, decisions);
+        if (error)
+            throw new WorkspaceCreationMcpError(error, 400, 'validate-checkout', diagnosis);
+        const steps = deriveSteps(report);
+        if (steps.some((step) => step.blocking))
+            return requiresAction('Checkout is blocked');
+        if (!plan && (steps.length > 0 || report.worktree.state !== 'none'))
+            return requiresAction();
+        if (plan) {
+            // Every state requiring a choice needs an explicit decision. In particular,
+            // do not inherit the UI's defaults for reset/stash/abort or path selection.
+            const missing = steps.some((step) => (step.id === 'path' && !decisions.pathCollision) ||
+                (step.id === 'worktree' && !decisions.orphanWorktree) ||
+                (step.id === 'operation' && !decisions.ongoingOperation) ||
+                (step.id === 'changes' && !decisions.localChanges) ||
+                (step.id === 'divergence' && !decisions.divergence));
+            if (missing)
+                return requiresAction('Explicit checkout decisions are required');
+        }
+        body.sourceBranch = pr.baseBranch;
+        body.workingBranch = pr.headBranch;
+        body.prUrl = pr.url;
+        body.skipSetupScript = input.skip_setup_script ?? true;
+        if (input.worktree_path) {
+            const diagnosedPath = 'path' in report.worktree ? report.worktree.path : null;
+            if (diagnosedPath !== input.worktree_path)
+                throw new WorkspaceCreationMcpError('worktree_path does not match the diagnosed PR checkout', 400, 'validate-checkout', diagnosis);
+        }
+        const resolved = await request(dispatch, '/api/pull-requests/resolve', 'resolve', {
+            projectPath: input.project_path,
+            prNumber: pr.number,
+            headBranch: pr.headBranch,
+            baseBranch: pr.baseBranch,
+            decisions,
+            fingerprint,
+        });
+        body.worktreePath = resolved.worktreePath;
+        resolvedCheckout = resolved;
+    }
+    try {
+        const attachments = input.attachments;
+        if (attachments?.length) {
+            const form = new FormData();
+            form.append('workspace', JSON.stringify(body));
+            for (const file of attachments)
+                form.append('attachments', new Blob([Buffer.from(file.data_base64, 'base64')], { type: file.mime_type }), file.name);
+            return await request(dispatch, '/api/workspaces', 'create', undefined, { method: 'POST', body: form });
+        }
+        return await request(dispatch, '/api/workspaces', 'create', body);
+    }
+    catch (error) {
+        if (!resolvedCheckout)
+            throw error;
+        if (!(error instanceof WorkspaceCreationMcpError))
+            throw new WorkspaceCreationMcpError(error instanceof Error ? error.message : String(error), 500, 'create', {
+                checkoutRecovery: {
+                    removed: false,
+                    worktreePath: resolvedCheckout.worktreePath,
+                    reason: 'Creation outcome is unknown; inspect the workspace and checkout before retrying',
+                },
+            });
+        const checkoutRecovery = await rollbackCreatedPrCheckout(input.project_path, resolvedCheckout);
+        throw new WorkspaceCreationMcpError(error.message, error.status, error.stage, {
+            ...(error.details && typeof error.details === 'object' ? error.details : {}),
+            checkoutRecovery,
+        });
+    }
+}

package/dist/server/services/workspace-group-message-mcp-service.js

@@ -0,0 +1,58 @@
+import { validateWorkspaceGroupMessageArguments } from '../../shared/workspace-group-message-tools.js';
+import { MAX_GROUP_MESSAGE_RECIPIENTS, matchesGroupMessageFilters } from '../../shared/workspace-group-messages.js';
+import { GroupMessageError, getGroupMessageBatch, startGroupMessageBatch } from './workspace-group-message-service.js';
+import { listWorkspaces } from './workspace-service.js';
+export class WorkspaceGroupMessageMcpError extends Error {
+    status;
+    constructor(message, status) {
+        super(message);
+        this.status = status;
+    }
+}
+export function executeWorkspaceGroupMessageTool(name, raw, source) {
+    let input;
+    try {
+        input = validateWorkspaceGroupMessageArguments(name, raw);
+    }
+    catch (error) {
+        throw new WorkspaceGroupMessageMcpError(error instanceof Error ? error.message : 'Invalid arguments', 400);
+    }
+    if (name === 'preview_workspace_group_message') {
+        const filters = {
+            tags: input.tags,
+            statuses: input.statuses,
+            devServerRunning: input.dev_server_running,
+        };
+        const candidates = listWorkspaces()
+            .filter((workspace) => !workspace.archivedAt && !workspace.worktreePurgedAt && matchesGroupMessageFilters(workspace, filters))
+            .sort((a, b) => (a.id < b.id ? -1 : a.id > b.id ? 1 : 0));
+        const offset = input.offset ?? 0;
+        const limit = input.limit ?? MAX_GROUP_MESSAGE_RECIPIENTS;
+        return {
+            total: candidates.length,
+            offset,
+            limit,
+            recipients: candidates.slice(offset, offset + limit).map((workspace) => ({
+                workspaceId: workspace.id,
+                name: workspace.name,
+                tags: workspace.tags,
+                status: workspace.status,
+                delivery: workspace.autoLoop ? 'next_iteration' : 'immediate',
+            })),
+        };
+    }
+    if (name === 'get_workspace_group_message') {
+        const batch = getGroupMessageBatch(input.request_id);
+        if (!batch)
+            throw new WorkspaceGroupMessageMcpError('Group message request not found', 404);
+        return batch;
+    }
+    try {
+        return startGroupMessageBatch({ requestId: input.request_id, workspaceIds: input.workspace_ids, content: input.content }, source);
+    }
+    catch (error) {
+        if (error instanceof GroupMessageError)
+            throw new WorkspaceGroupMessageMcpError(error.message, error.status);
+        throw error;
+    }
+}

package/dist/server/services/workspace-group-message-service.js

@@ -0,0 +1,182 @@
+import { createHash } from 'node:crypto';
+import { parseGroupMessageInput, } from '../../shared/workspace-group-messages.js';
+import { getDb } from '../db/index.js';
+import { isShuttingDown } from './agent/orchestrator.js';
+import { broadcastPersistedEvent, persistWorkspaceEvent } from './websocket-service.js';
+import { deliverWorkspaceMessage } from './workspace-message-service.js';
+import { getWorkspace } from './workspace-service.js';
+export class GroupMessageError extends Error {
+    status;
+    constructor(message, status) {
+        super(message);
+        this.status = status;
+    }
+}
+const jobs = [];
+const active = new Set();
+let stopping = false;
+export function getGroupMessageBatch(id) {
+    const row = getDb().prepare('SELECT receipt_json FROM workspace_message_batches WHERE id=?').get(id);
+    return row ? JSON.parse(row.receipt_json) : undefined;
+}
+function updateRecipient(id, workspaceId, state, error) {
+    const batch = getGroupMessageBatch(id);
+    if (!batch)
+        throw new Error('Group message receipt is unavailable');
+    const recipient = batch.recipients.find((item) => item.workspaceId === workspaceId);
+    recipient.state = state;
+    if (error)
+        recipient.error = error.slice(0, 1000);
+    else
+        delete recipient.error;
+    batch.complete = batch.recipients.every((item) => item.state !== 'pending' && item.state !== 'sending');
+    getDb().prepare('UPDATE workspace_message_batches SET receipt_json=? WHERE id=?').run(JSON.stringify(batch), id);
+}
+/** Persist before scheduling. Repeating an ID only observes its existing immutable request. */
+export function startGroupMessageBatch(value, source) {
+    let input;
+    try {
+        input = parseGroupMessageInput(value);
+    }
+    catch (error) {
+        throw new GroupMessageError(error instanceof Error ? error.message : String(error), 400);
+    }
+    const fingerprint = createHash('sha256')
+        .update(JSON.stringify([input.content, [...input.workspaceIds].sort(), source ?? null]))
+        .digest('hex');
+    const db = getDb();
+    const result = db
+        .transaction(() => {
+        const row = db
+            .prepare('SELECT fingerprint,receipt_json FROM workspace_message_batches WHERE id=?')
+            .get(input.requestId);
+        if (row) {
+            if (row.fingerprint !== fingerprint)
+                throw new GroupMessageError('This requestId was already used for different content, recipients or source', 409);
+            return { fresh: false, batch: JSON.parse(row.receipt_json) };
+        }
+        if (stopping || isShuttingDown())
+            throw new GroupMessageError('Kōbō is shutting down', 503);
+        const batch = {
+            id: input.requestId,
+            createdAt: new Date().toISOString(),
+            complete: false,
+            recipients: input.workspaceIds.map((workspaceId) => {
+                const workspace = getWorkspace(workspaceId);
+                const error = !workspace
+                    ? 'Workspace not found'
+                    : workspace.archivedAt || workspace.worktreePurgedAt
+                        ? 'Restore the workspace before sending a message'
+                        : undefined;
+                return {
+                    workspaceId,
+                    name: workspace?.name ?? workspaceId,
+                    delivery: workspace?.autoLoop ? 'next_iteration' : 'immediate',
+                    state: error ? 'rejected' : 'pending',
+                    ...(error ? { error } : {}),
+                };
+            }),
+        };
+        batch.complete = batch.recipients.every((item) => item.state === 'rejected');
+        db.prepare('INSERT INTO workspace_message_batches(id,fingerprint,receipt_json,created_at) VALUES (?,?,?,?)').run(batch.id, fingerprint, JSON.stringify(batch), batch.createdAt);
+        return { fresh: true, batch };
+    })
+        .immediate();
+    if (result.fresh) {
+        for (const recipient of result.batch.recipients)
+            if (recipient.state === 'pending')
+                jobs.push({ batchId: result.batch.id, recipient, content: input.content, source });
+        queueMicrotask(pump);
+    }
+    return result.batch;
+}
+async function deliver(job) {
+    const { batchId, recipient } = job;
+    let dispatched = false;
+    let accepted = false;
+    try {
+        updateRecipient(batchId, recipient.workspaceId, 'sending');
+        await deliverWorkspaceMessage(recipient.workspaceId, {
+            content: job.content,
+            source: job.source,
+            delivery: recipient.delivery,
+            clientMessageId: `group-${createHash('sha256')
+                .update(JSON.stringify([batchId, recipient.workspaceId]))
+                .digest('hex')}`,
+        }, {
+            beforeDispatch() {
+                const workspace = getWorkspace(recipient.workspaceId);
+                if (!workspace || !!workspace.autoLoop !== (recipient.delivery === 'next_iteration'))
+                    throw new Error('Auto-loop mode changed since submission; review the recipient before sending again');
+                dispatched = true;
+            },
+            persist(payload, sessionId) {
+                const event = getDb().transaction(() => {
+                    const persisted = persistWorkspaceEvent(recipient.workspaceId, 'user:message', payload, sessionId);
+                    updateRecipient(batchId, recipient.workspaceId, recipient.delivery === 'next_iteration' ? 'queued' : 'sent');
+                    return persisted;
+                })();
+                accepted = true;
+                broadcastPersistedEvent(event);
+            },
+        });
+        if (!accepted)
+            throw new Error('Delivery completed without a durable receipt');
+    }
+    catch (error) {
+        if (accepted)
+            return;
+        updateRecipient(batchId, recipient.workspaceId, dispatched ? 'unknown' : 'rejected', error instanceof Error ? error.message : String(error));
+    }
+}
+function pump() {
+    if (stopping)
+        return;
+    while (active.size < 3 && jobs.length) {
+        const job = jobs.shift();
+        const task = deliver(job)
+            .catch((error) => console.error('[group-message] Receipt persistence failed:', error))
+            .finally(() => {
+            active.delete(task);
+            pump();
+        });
+        active.add(task);
+    }
+}
+/** Startup only: persisted uncertain work is never automatically dispatched again. */
+export function reconcileGroupMessageBatches(db) {
+    stopping = false;
+    db.transaction(() => {
+        const rows = db.prepare('SELECT id,receipt_json FROM workspace_message_batches').all();
+        for (const row of rows) {
+            const batch = JSON.parse(row.receipt_json);
+            if (batch.complete)
+                continue;
+            for (const recipient of batch.recipients) {
+                if (recipient.state === 'pending') {
+                    recipient.state = 'not_sent';
+                    recipient.error = 'Server stopped before delivery';
+                }
+                else if (recipient.state === 'sending') {
+                    recipient.state = 'unknown';
+                    recipient.error = 'Server stopped during delivery; inspect workspace history before sending again';
+                }
+            }
+            batch.complete = true;
+            db.prepare('UPDATE workspace_message_batches SET receipt_json=? WHERE id=?').run(JSON.stringify(batch), row.id);
+        }
+    })();
+}
+export async function stopGroupMessageBatches() {
+    stopping = true;
+    for (const job of jobs.splice(0)) {
+        try {
+            updateRecipient(job.batchId, job.recipient.workspaceId, 'not_sent', 'Server stopped before delivery');
+        }
+        catch (error) {
+            // Startup will reconcile the durable pending row; still drain active jobs before closing SQLite.
+            console.error('[group-message] Could not persist shutdown receipt:', error);
+        }
+    }
+    await Promise.allSettled([...active]);
+}

package/dist/server/services/workspace-lifecycle-mcp-service.js

@@ -0,0 +1,72 @@
+import { validateWorkspaceLifecycleArguments } from '../../shared/workspace-lifecycle-tools.js';
+export class WorkspaceLifecycleMcpError extends Error {
+    status;
+    stage;
+    details;
+    constructor(message, status, stage, details = null) {
+        super(message);
+        this.status = status;
+        this.stage = stage;
+        this.details = details;
+        this.name = 'WorkspaceLifecycleMcpError';
+    }
+}
+async function request(dispatch, path, stage, method, body) {
+    const response = await dispatch(path, {
+        method,
+        ...(body === undefined ? {} : { headers: { 'Content-Type': 'application/json' }, body: JSON.stringify(body) }),
+    });
+    const payload = response.status === 204 ? null : await response.json().catch(() => null);
+    if (!response.ok)
+        throw new WorkspaceLifecycleMcpError(payload?.error ?? `Workspace lifecycle request failed (${response.status})`, response.status, stage, payload);
+    return payload;
+}
+/** The HTTP lifecycle remains the sole owner of stopping, locks and cleanup. */
+export async function executeWorkspaceLifecycleTool(name, raw, dispatch) {
+    let input;
+    try {
+        input = validateWorkspaceLifecycleArguments(name, raw);
+    }
+    catch (error) {
+        throw new WorkspaceLifecycleMcpError(error instanceof Error ? error.message : 'Invalid arguments', 400, 'validate');
+    }
+    const workspaceId = input.workspace_id;
+    const path = `/api/workspaces/${encodeURIComponent(workspaceId)}`;
+    if (name === 'archive_workspace')
+        return request(dispatch, `${path}/archive`, 'archive', 'POST');
+    if (name === 'purge_workspace_worktree')
+        return request(dispatch, `${path}/purge-worktree`, 'purge', 'POST');
+    if (name === 'unarchive_workspace')
+        return request(dispatch, `${path}/unarchive`, 'unarchive', 'POST');
+    if (name === 'restore_workspace') {
+        let workspace = (await request(dispatch, path, 'lookup', 'GET'));
+        if (!workspace.archivedAt && !workspace.worktreePurgedAt)
+            return { workspace, outcome: 'unchanged' };
+        let restoration = {
+            workspace,
+            outcome: 'unarchived',
+        };
+        if (workspace.worktreePurgedAt || workspace.worktreeOwned !== false) {
+            // Even without a purge flag, check an owned archived checkout on disk.
+            // The existing restore endpoint rejects missing manual deletions rather
+            // than silently announcing successful restoration of an absent folder.
+            restoration = (await request(dispatch, `${path}/restore-worktree`, 'restore', 'POST'));
+            workspace = restoration.workspace;
+        }
+        if (workspace.archivedAt)
+            workspace = (await request(dispatch, `${path}/unarchive`, 'unarchive', 'POST'));
+        return { ...restoration, workspace };
+    }
+    const workspace = (await request(dispatch, path, 'lookup', 'GET'));
+    const confirmationBranch = input.confirmation_branch.trim();
+    if (workspace?.workingBranch !== confirmationBranch)
+        throw new WorkspaceLifecycleMcpError('confirmation_branch must match the current workspace working branch', 409, 'confirm-delete');
+    const result = await request(dispatch, path, 'delete', 'DELETE', {
+        deleteLocalBranch: input.delete_local_branch ?? false,
+        deleteRemoteBranch: input.delete_remote_branch ?? false,
+        // Rechecked by the existing route under its lifecycle guard, so a changed
+        // branch between GET and DELETE cannot authorize a different deletion.
+        confirmationBranch,
+    });
+    return result ?? { ok: true, workspaceId, warnings: [] };
+}

package/dist/server/services/workspace-message-service.js

@@ -24,6 +24,11 @@ export async function deliverWorkspaceMessage(workspaceId, message, hooks) {
             if (!message.clientMessageId)
                 throw new Error('clientMessageId is required for queued delivery');
             const acceptedBefore = hasLoopMessage(workspaceId, message.clientMessageId);
+            if (!acceptedBefore) {
+                if (!workspace.autoLoop)
+                    throw new Error('Auto-loop is not enabled');
+                hooks?.beforeDispatch?.();
+            }
             if (!autoLoop.queueInstruction(workspaceId, message.content, message.clientMessageId, message.source))
                 throw new Error('Auto-loop is not enabled');
             if (!acceptedBefore)