@loicngr/kobo 2.1.13 → 2.1.16

package/dist/server/services/review-return-service.js

@@ -4,9 +4,10 @@ import { updateWorkspaceEngineConfiguration } from './workspace-service.js';
 export function registerReviewReturn(pending) {
     getDb()
         .prepare(`INSERT INTO pending_review_returns
-    (workspace_id, review_session_id, original_session_id, original_configuration, review_configuration, created_at)
-    VALUES (?, ?, ?, ?, ?, ?)`)
-        .run(pending.workspaceId, pending.reviewSessionId, pending.originalSessionId, JSON.stringify(pending.original), JSON.stringify(pending.review), new Date().toISOString());
+    (workspace_id, review_session_id, original_session_id, original_configuration, review_configuration, created_at, review_prompt)
+    VALUES (?, ?, ?, ?, ?, ?, ?)`)
+        .run(pending.workspaceId, pending.reviewSessionId, pending.originalSessionId, JSON.stringify(pending.original), JSON.stringify(pending.review), new Date().toISOString(), pending.reviewPrompt ?? null);
+    emitEphemeral(pending.workspaceId, 'review:return-status', getReviewReturnStatus(pending.workspaceId));
 }
 export function getReviewReturn(workspaceId, reviewSessionId) {
     const row = getDb().prepare('SELECT * FROM pending_review_returns WHERE workspace_id = ?').get(workspaceId);
@@ -18,26 +19,73 @@ export function getReviewReturn(workspaceId, reviewSessionId) {
         originalSessionId: row.original_session_id,
         original: JSON.parse(row.original_configuration),
         review: JSON.parse(row.review_configuration),
+        phase: row.phase,
+        reviewPrompt: row.review_prompt,
+        returnPrompt: row.return_prompt,
+        error: row.last_error,
     };
 }
-/** Consume before dispatch: a repeated end or a restart must never send twice. */
-export function restoreReviewConfiguration(workspaceId, reviewSessionId) {
+/** Restore initial settings; cancellation removes intent, suspension preserves it. */
+export function restoreReviewConfiguration(workspaceId, reviewSessionId, preserve = false) {
     const pending = getReviewReturn(workspaceId, reviewSessionId);
     if (!pending)
         return null;
     getDb().transaction(() => {
-        getDb().prepare('DELETE FROM pending_review_returns WHERE workspace_id = ?').run(workspaceId);
+        if (!preserve)
+            getDb().prepare('DELETE FROM pending_review_returns WHERE workspace_id = ?').run(workspaceId);
         const original = pending.original;
         updateWorkspaceEngineConfiguration(workspaceId, original.engine, original.model, original.reasoningEffort, original.agentPermissionMode);
     })();
     emitEphemeral(workspaceId, 'workspace:configuration', pending.original);
+    if (!preserve)
+        emitEphemeral(workspaceId, 'review:return-status', null);
     return pending;
 }
-/** On restart, restore settings but do not replay a possibly delivered handoff. */
+/** Restore user settings without discarding an unfinished review/return. */
 export function reconcileReviewReturns() {
-    const rows = getDb().prepare('SELECT workspace_id FROM pending_review_returns').all();
-    for (const row of rows)
-        restoreReviewConfiguration(row.workspace_id);
+    for (const pending of listReviewReturns()) {
+        if (pending.phase === 'dispatching')
+            setReviewReturnPhase(pending.workspaceId, 'unknown', 'The server stopped while sending the review report. Check the original session before retrying to avoid duplicate delivery.');
+        restoreReviewConfiguration(pending.workspaceId, undefined, true);
+    }
+}
+export function getReviewReturnStatus(workspaceId) {
+    const pending = getReviewReturn(workspaceId);
+    return pending
+        ? {
+            reviewSessionId: pending.reviewSessionId,
+            originalSessionId: pending.originalSessionId,
+            phase: pending.phase ?? 'reviewing',
+            error: pending.error ?? null,
+        }
+        : null;
+}
+export function listReviewReturns() {
+    return getDb().prepare('SELECT workspace_id FROM pending_review_returns').all()
+        .map((row) => getReviewReturn(row.workspace_id))
+        .filter((row) => row !== null);
+}
+export function setReviewReturnPhase(workspaceId, phase, error = null, prompt) {
+    getDb()
+        .prepare('UPDATE pending_review_returns SET phase = ?, last_error = ?, return_prompt = COALESCE(?, return_prompt) WHERE workspace_id = ?')
+        .run(phase, error, prompt ?? null, workspaceId);
+    emitEphemeral(workspaceId, 'review:return-status', getReviewReturnStatus(workspaceId));
+}
+/** Claim the known-unsent report before any asynchronous engine dispatch. */
+export function claimReviewReturn(workspaceId) {
+    const claimed = getDb()
+        .prepare("UPDATE pending_review_returns SET phase = 'dispatching', last_error = NULL WHERE workspace_id = ? AND phase = 'ready'")
+        .run(workspaceId).changes === 1;
+    if (claimed)
+        emitEphemeral(workspaceId, 'review:return-status', getReviewReturnStatus(workspaceId));
+    return claimed;
+}
+export function completeReviewReturn(workspaceId) {
+    const removed = getDb()
+        .prepare("DELETE FROM pending_review_returns WHERE workspace_id = ? AND phase = 'dispatching'")
+        .run(workspaceId).changes;
+    if (removed)
+        emitEphemeral(workspaceId, 'review:return-status', null);
 }
 /** Reassemble the last assistant message, handling deltas and final snapshots. */
 export function buildReviewReturnPrompt(workspaceId, reviewSessionId) {

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

@@ -1,17 +1,20 @@
 import { execFile } from 'node:child_process';
 import { promisify } from 'node:util';
 import { reviewConfigurationChanged } from '../../shared/review.js';
+import { getDb } from '../db/index.js';
 import { assertAgentStopped } from '../utils/agent-stop-result.js';
 import * as gitOps from '../utils/git-ops.js';
 import { assertWorkspaceLifecycleAvailable } from '../utils/workspace-lifecycle-guard.js';
 import { listEngines } from './agent/engines/registry.js';
 import * as agentManager from './agent/orchestrator.js';
+import { bindReviewSession, getFinalReviewSourceSession } from './auto-loop-final-review-service.js';
+import { canStartAutomatically } from './auto-loop-service.js';
+import { beginReviewLaunch, finishReviewLaunch } from './review-launch-runtime.js';
 import { getReviewReturn, registerReviewReturn, restoreReviewConfiguration } from './review-return-service.js';
 import { getActiveReviewTemplate, renderReviewTemplate } from './review-template-service.js';
 import * as wsService from './websocket-service.js';
 import * as workspaceService from './workspace-service.js';
 const execFileAsync = promisify(execFile);
-const launching = new Set();
 export class ReviewRequestError extends Error {
     status;
     constructor(message, status) {
@@ -19,6 +22,11 @@ export class ReviewRequestError extends Error {
         this.status = status;
     }
 }
+export class ReviewAdmissionDeferred extends Error {
+    constructor() {
+        super('Automatic review is waiting for agent capacity');
+    }
+}
 export function parseReviewRequest(input) {
     if (!input || typeof input !== 'object' || Array.isArray(input))
         throw new ReviewRequestError('Request body must be a JSON object', 400);
@@ -34,7 +42,7 @@ export function parseReviewRequest(input) {
     }
     return body;
 }
-function resolveConfiguration(workspace, body) {
+function resolveConfiguration(workspace, body, allowCustomModel = false) {
     const engineId = body.engine ?? workspace.engine;
     const engine = listEngines().find((e) => e.id === engineId);
     if (!engine)
@@ -48,7 +56,8 @@ function resolveConfiguration(workspace, body) {
         agentPermissionMode: body.returnToSession ? 'plan' : (body.agentPermissionMode ?? workspace.agentPermissionMode),
     };
     // Preserve an existing custom model when unchanged; reject incompatible selections.
-    if ((changedEngine || config.model !== workspace.model) &&
+    if (!allowCustomModel &&
+        (changedEngine || config.model !== workspace.model) &&
         !engine.capabilities.models.some((m) => m.id === config.model))
         throw new ReviewRequestError(`Model '${config.model}' is not supported by '${engineId}'`, 400);
     if ((changedEngine || config.reasoningEffort !== workspace.reasoningEffort) &&
@@ -62,22 +71,25 @@ function configure(id, config) {
     workspaceService.updateWorkspaceEngineConfiguration(id, config.engine, config.model, config.reasoningEffort, config.agentPermissionMode);
     wsService.emitEphemeral(id, 'workspace:configuration', config);
 }
-export async function startWorkspaceReview(id, input) {
-    if (launching.has(id))
+export async function startWorkspaceReview(id, input, internal) {
+    const launch = beginReviewLaunch(id);
+    if (!launch)
         throw new ReviewRequestError('A review is already being started for this workspace', 409);
-    launching.add(id);
     try {
         const workspace = workspaceService.getWorkspace(id);
         if (!workspace)
             throw new ReviewRequestError(`Workspace '${id}' not found`, 404);
         const body = parseReviewRequest(input);
-        const configuration = resolveConfiguration(workspace, body);
+        const configuration = resolveConfiguration(workspace, body, internal?.autoLoopFinalReview);
         assertWorkspaceLifecycleAvailable(id);
         if (workspace.archivedAt || workspace.worktreePurgedAt)
             throw new ReviewRequestError('Restore the workspace before starting a review', 409);
         if (getReviewReturn(id))
             throw new ReviewRequestError('A review with an automatic return is already in progress', 409);
-        const originalSession = workspaceService.getActiveSession(id);
+        const sourceSessionId = internal?.autoLoopFinalReview ? getFinalReviewSourceSession(id) : null;
+        const originalSession = internal?.autoLoopFinalReview
+            ? workspaceService.listSessions(id).find((session) => session.id === sourceSessionId)
+            : workspaceService.getActiveSession(id);
         const changed = reviewConfigurationChanged(workspace, configuration);
         const differsFromSession = !!originalSession &&
             ((!!originalSession.engine && originalSession.engine !== configuration.engine) ||
@@ -127,20 +139,34 @@ export async function startWorkspaceReview(id, input) {
                 '\n\nThis is a read-only review session; these rules override any template instruction or skill that suggests fixing issues. Do not modify, create or delete files, and do not commit or push: the original agent session applies the fixes. Running read-only checks such as tests or linters is fine. Do not ask the user questions or wait for input: note any decision that needs the user in your summary instead.' +
                     '\n\nFinish with a standalone summary of your review findings, including severity, file/line references, recommended fixes and any remaining uncertainty. This final message will be handed back to the original agent session. Do not rely on earlier messages to explain your findings.';
         assertWorkspaceLifecycleAvailable(id);
+        if (launch.cancelled)
+            throw new ReviewRequestError('Review launch was cancelled', 409);
         const current = workspaceService.getWorkspace(id);
         if (!current || current.archivedAt || current.worktreePurgedAt || current.status === 'compacting')
             throw new ReviewRequestError('The workspace is no longer available for a review', 409);
         if (reviewConfigurationChanged(current, workspace))
             throw new ReviewRequestError('The workspace configuration changed; reopen the review dialog', 409);
-        if (body.returnToSession && workspaceService.getActiveSession(id)?.id !== originalSession?.id)
+        if (body.returnToSession &&
+            (internal?.autoLoopFinalReview ? getFinalReviewSourceSession(id) : workspaceService.getActiveSession(id)?.id) !==
+                originalSession?.id)
             throw new ReviewRequestError('The current session changed; reopen the review dialog', 409);
+        if (internal?.autoLoopFinalReview && (!current.autoLoop || internal.shouldLaunch?.() === false))
+            throw new ReviewRequestError('Final review was cancelled before launch', 409);
         let emitSessionId;
         if (newSession) {
             assertAgentStopped(await agentManager.stopAgentAndWait(id, undefined, 'replacement'));
             assertWorkspaceLifecycleAvailable(id);
+            if (launch.cancelled)
+                throw new ReviewRequestError('Review launch was cancelled', 409);
+            if (internal?.autoLoopFinalReview &&
+                (!workspaceService.getWorkspace(id)?.autoLoop || internal.shouldLaunch?.() === false))
+                throw new ReviewRequestError('Final review was cancelled before launch', 409);
             if (agentManager.getAgentStatus(id))
                 throw new ReviewRequestError('Another agent has started in this workspace', 409);
+            if (internal?.autoLoopFinalReview && !canStartAutomatically(id))
+                throw new ReviewAdmissionDeferred();
             let pendingSessionId;
+            let reviewLaunch = null;
             try {
                 if (body.returnToSession && originalSession) {
                     pendingSessionId = workspaceService.createIdleSession(id).id;
@@ -156,11 +182,33 @@ export async function startWorkspaceReview(id, input) {
                             agentPermissionMode: workspace.agentPermissionMode,
                         },
                         review: configuration,
+                        reviewPrompt: rendered,
                     });
                 }
+                if (internal?.autoLoopFinalReview && pendingSessionId && originalSession) {
+                    reviewLaunch = bindReviewSession(id, pendingSessionId, originalSession.id);
+                    rendered += reviewLaunch.promptSuffix;
+                    getDb()
+                        .prepare('UPDATE pending_review_returns SET review_prompt = ? WHERE workspace_id = ?')
+                        .run(rendered, id);
+                }
                 if (changed)
                     configure(id, configuration);
-                const agent = agentManager.startAgent(id, worktreePath, rendered, configuration.model, false, configuration.agentPermissionMode, pendingSessionId, configuration.reasoningEffort);
+                const startArgs = [
+                    id,
+                    worktreePath,
+                    rendered,
+                    configuration.model,
+                    false,
+                    configuration.agentPermissionMode,
+                    pendingSessionId,
+                    configuration.reasoningEffort,
+                ];
+                if (reviewLaunch) {
+                    startArgs[8] = undefined;
+                    startArgs[9] = { mcpEnv: reviewLaunch.mcpEnv };
+                }
+                const agent = agentManager.startAgent(...startArgs);
                 workspaceService.updateWorkspaceStatus(id, 'executing');
                 emitSessionId = agent.agentSessionId;
             }
@@ -190,6 +238,6 @@ export async function startWorkspaceReview(id, input) {
         return { ok: true, messageSent: true, newSession };
     }
     finally {
-        launching.delete(id);
+        finishReviewLaunch(id);
     }
 }

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

@@ -0,0 +1,198 @@
+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';
+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) {
+    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;
+    }
+}