@taskforcehq/taskforce 0.3.330 → 0.3.333

package/dist/core/Taskforce.js

@@ -2033,6 +2033,7 @@ export class TaskforceCore {
                 provider TEXT NOT NULL,
                 client_name TEXT NOT NULL,
                 redirect_uris_json TEXT NOT NULL,
+                application_type TEXT NOT NULL DEFAULT 'web',
                 product_client_id TEXT,
                 status TEXT NOT NULL DEFAULT 'active',
                 created_at TEXT NOT NULL,
@@ -2385,6 +2386,9 @@ export class TaskforceCore {
             if (!mcpOauthClientColumns.some((c) => c.name === 'product_client_id')) {
                 this.db.exec(`ALTER TABLE mcp_oauth_clients ADD COLUMN product_client_id TEXT`);
             }
+            if (!mcpOauthClientColumns.some((c) => c.name === 'application_type')) {
+                this.db.exec(`ALTER TABLE mcp_oauth_clients ADD COLUMN application_type TEXT NOT NULL DEFAULT 'web'`);
+            }
             const mcpOauthGrantColumns = this.db.prepare(`PRAGMA table_info(mcp_oauth_connector_grants)`).all();
             if (!mcpOauthGrantColumns.some((c) => c.name === 'product_client_id')) {
                 this.db.exec(`ALTER TABLE mcp_oauth_connector_grants ADD COLUMN product_client_id TEXT`);
@@ -2405,6 +2409,7 @@ export class TaskforceCore {
         else {
             try {
                 this.db.exec(`ALTER TABLE mcp_oauth_clients ADD COLUMN IF NOT EXISTS product_client_id TEXT`);
+                this.db.exec(`ALTER TABLE mcp_oauth_clients ADD COLUMN IF NOT EXISTS application_type TEXT NOT NULL DEFAULT 'web'`);
                 this.db.exec(`ALTER TABLE mcp_oauth_connector_grants ADD COLUMN IF NOT EXISTS product_client_id TEXT`);
                 this.db.exec(`ALTER TABLE mcp_oauth_connector_grants ADD COLUMN IF NOT EXISTS ai_profile_id TEXT`);
                 this.db.exec(`ALTER TABLE mcp_oauth_connector_grants ADD COLUMN IF NOT EXISTS ai_profile_token TEXT`);
@@ -7749,7 +7754,7 @@ export class TaskforceCore {
             deletedAt: session.deletedAt,
         });
     }
-    upsertDocumentReviewCommentForSync(comment) {
+    upsertDocumentReviewCommentForSync(comment, options) {
         const deps = this.getDocumentReviewServiceDeps();
         return deps.commentStore.upsertForSync({
             id: comment.id,
@@ -7769,7 +7774,7 @@ export class TaskforceCore {
             createdAt: comment.createdAt,
             updatedAt: comment.updatedAt,
             deletedAt: comment.deletedAt,
-        });
+        }, options);
     }
     upsertAnnotatedAttachmentSessionForSync(session) {
         const deps = this.getAnnotatedAttachmentServiceDeps();
@@ -9975,7 +9980,7 @@ export class TaskforceCore {
             return this.getWorkstream(workstreamId, normalizedWorkspaceId) || updated;
         })();
     }
-    installDurableTaskCreateAuthoritativeForSync(task, workspaceId) {
+    installDurableTaskCreateAuthoritativeForSync(task, workspaceId, options) {
         const normalizedWorkspaceId = this.normalizeWorkspaceId(workspaceId);
         const taskId = String(task?.id || '').trim();
         const createdAt = String(task?.createdAt || '').trim();
@@ -9993,6 +9998,31 @@ export class TaskforceCore {
         return this.db.transaction(() => {
             const existing = this.getTask(taskId, normalizedWorkspaceId);
             if (!existing) {
+                const deleted = options?.preserveDeletedSuccessor
+                    ? this.getDeletedTask(taskId, normalizedWorkspaceId)
+                    : null;
+                if (deleted) {
+                    this.relocateTaskReferenceConflict(normalizedWorkspaceId, referenceNumber, taskId, updatedAt);
+                    if (this.reserveTaskReferenceNumber(normalizedWorkspaceId, referenceNumber, taskId) !== referenceNumber) {
+                        throw new TaskforceRuleError('Authoritative task reference is already in use.', 409, 'WORKSPACE_SYNC_AUTHORITATIVE_RESPONSE_INVALID');
+                    }
+                    const authoritativeSnapshot = {
+                        ...deleted.taskSnapshot,
+                        referenceNumber,
+                        localReferenceNumber: null,
+                        referenceLabel: deriveTaskReferenceLabel({ referenceNumber, localReferenceNumber: null }),
+                        createdAt,
+                        createdBy: task.createdBy,
+                    };
+                    const updated = this.db.prepare(`
+                        UPDATE deleted_tasks SET task_snapshot_json = ?
+                        WHERE tenant_id = ? AND workspace_id = ? AND task_id = ?
+                    `).run(JSON.stringify(authoritativeSnapshot), this.tenantId, normalizedWorkspaceId, taskId);
+                    if (Number(updated.changes || 0) !== 1) {
+                        throw new TaskforceRuleError('Captured deleted task history is missing.', 409, 'WORKSPACE_SYNC_AUTHORITATIVE_RESPONSE_INVALID');
+                    }
+                    return this.getDeletedTask(taskId, normalizedWorkspaceId).taskSnapshot;
+                }
                 throw new TaskforceRuleError('Task not found.', 404, 'TASK_NOT_FOUND');
             }
             const mutableCreateFields = [

package/dist/core/types.d.ts

@@ -661,6 +661,7 @@ export interface McpOAuthClientRecord {
     id: string;
     provider: McpOAuthProvider;
     clientName: string;
+    applicationType: 'native' | 'web';
     productClientId?: string | null;
     redirectUris: string[];
     status: McpOAuthClientStatus;

package/dist/documentReviews/DocumentReviewCommentStore.d.ts

@@ -77,6 +77,8 @@ export declare class DocumentReviewCommentStore {
         threadStatusUpdatedAt?: string | null;
         resolvedAt?: string | null;
         resolvedByActorId?: string | null;
+    }, options?: {
+        allowAuthoritativeThreadReconciliation?: boolean;
     }): DocumentReviewCommentSyncRecord;
     softDelete(commentIdRaw: string, workspaceIdRaw: string, deletedAtRaw?: string, deletedByActorIdRaw?: string | null): boolean;
     replaceForSession(input: {

package/dist/documentReviews/DocumentReviewCommentStore.js

@@ -235,7 +235,7 @@ export class DocumentReviewCommentStore {
             : (input.threadStatus === undefined ? existing.threadStatus : input.threadStatus), input.threadStatusUpdatedAt === undefined ? existing.threadStatusUpdatedAt : normalizeNullable(input.threadStatusUpdatedAt), input.resolvedAt === undefined ? existing.resolvedAt : normalizeNullable(input.resolvedAt), input.resolvedByActorId === undefined ? existing.resolvedByActorId : normalizeNullable(input.resolvedByActorId), normalizeId(input.updatedAt) || new Date().toISOString(), input.deletedAt === undefined ? existing.deletedAt : normalizeNullable(input.deletedAt), this.tenantId, normalizeWorkspaceId(input.workspaceId), normalizeId(input.id));
         return this.get(input.id, input.workspaceId, { includeDeleted: true });
     }
-    upsertForSync(input) {
+    upsertForSync(input, options) {
         const existing = this.get(input.id, input.workspaceId, { includeDeleted: true });
         if (!existing) {
             return this.create(input);
@@ -248,7 +248,20 @@ export class DocumentReviewCommentStore {
             ? undefined
             : normalizeNullable(input.parentCommentId);
         if (incomingParentCommentId !== undefined && incomingParentCommentId !== existing.parentCommentId) {
-            throw new Error(`Document review comment ${existing.id} cannot move between threads.`);
+            if (options?.allowAuthoritativeThreadReconciliation !== true) {
+                throw new Error(`Document review comment ${existing.id} cannot move between threads.`);
+            }
+            const incomingParent = incomingParentCommentId
+                ? this.get(incomingParentCommentId, input.workspaceId, { includeDeleted: true })
+                : null;
+            if (existing.parentCommentId
+                || !incomingParent
+                || incomingParent.deletedAt
+                || incomingParent.sessionId !== existing.sessionId
+                || incomingParent.parentCommentId
+                || incomingParent.id === existing.id) {
+                throw new Error(`Document review comment ${existing.id} cannot reconcile to an invalid thread root.`);
+            }
         }
         const incomingThreadStatusUpdatedAt = input.threadStatusUpdatedAt === undefined
             ? undefined
@@ -283,13 +296,19 @@ export class DocumentReviewCommentStore {
               AND id = ?
         `).run(normalizeId(input.sessionId) || existing.sessionId, normalizeId(input.body), input.anchor ? JSON.stringify(input.anchor) : null, normalizeNullable(input.authorActorId), normalizeNullable(input.updatedByActorId), input.deletedByActorId === undefined ? existing.deletedByActorId : normalizeNullable(input.deletedByActorId), nextParentCommentId, nextParentCommentId
             ? null
-            : (shouldApplyThreadLifecycle ? input.threadStatus : existing.threadStatus), shouldApplyThreadLifecycle
-            ? incomingThreadStatusUpdatedAt
-            : existing.threadStatusUpdatedAt, shouldApplyThreadLifecycle
-            ? normalizeNullable(input.resolvedAt)
-            : existing.resolvedAt, shouldApplyThreadLifecycle
-            ? normalizeNullable(input.resolvedByActorId)
-            : existing.resolvedByActorId, normalizePositiveInteger(input.order) ?? existing.order, normalizeId(input.createdAt) || existing.createdAt, normalizeId(input.updatedAt) || existing.updatedAt, existing.deletedAt || (input.deletedAt === undefined
+            : (shouldApplyThreadLifecycle ? input.threadStatus : existing.threadStatus), nextParentCommentId
+            ? null
+            : shouldApplyThreadLifecycle
+                ? incomingThreadStatusUpdatedAt
+                : existing.threadStatusUpdatedAt, nextParentCommentId
+            ? null
+            : shouldApplyThreadLifecycle
+                ? normalizeNullable(input.resolvedAt)
+                : existing.resolvedAt, nextParentCommentId
+            ? null
+            : shouldApplyThreadLifecycle
+                ? normalizeNullable(input.resolvedByActorId)
+                : existing.resolvedByActorId, normalizePositiveInteger(input.order) ?? existing.order, normalizeId(input.createdAt) || existing.createdAt, normalizeId(input.updatedAt) || existing.updatedAt, existing.deletedAt || (input.deletedAt === undefined
             ? null
             : normalizeNullable(input.deletedAt)), this.tenantId, normalizeWorkspaceId(input.workspaceId), normalizeId(input.id));
         return this.get(input.id, input.workspaceId, { includeDeleted: true });

package/dist/mcp/httpProtocolRouting.d.ts

@@ -1,5 +1,6 @@
 import type { IncomingMessage, ServerResponse } from 'node:http';
 import { type McpServerFactory } from '@modelcontextprotocol/server';
+export declare function createModernMcpHttpHandler(factory: McpServerFactory, onerror?: (error: Error) => void): import("@modelcontextprotocol/server").McpHttpHandler;
 export declare function isModernMcpHttpRequest(req: IncomingMessage, parsedBody: unknown): Promise<boolean>;
 export declare function handleModernMcpHttpRequest(input: {
     req: IncomingMessage;

package/dist/mcp/httpProtocolRouting.js

@@ -1,15 +1,18 @@
 import { toNodeHandler, toWebRequest } from '@modelcontextprotocol/node';
 import { createMcpHandler, isLegacyRequest, } from '@modelcontextprotocol/server';
+export function createModernMcpHttpHandler(factory, onerror) {
+    return createMcpHandler(factory, {
+        legacy: 'reject',
+        responseMode: 'auto',
+        onerror,
+    });
+}
 export async function isModernMcpHttpRequest(req, parsedBody) {
     const request = await toWebRequest(req, parsedBody);
     return !(await isLegacyRequest(request, parsedBody));
 }
 export async function handleModernMcpHttpRequest(input) {
-    const handler = createMcpHandler(input.factory, {
-        legacy: 'reject',
-        responseMode: 'auto',
-        onerror: input.onerror,
-    });
+    const handler = createModernMcpHttpHandler(input.factory, input.onerror);
     try {
         await toNodeHandler(handler, { onerror: input.onerror })(input.req, input.res, input.parsedBody);
     }

package/dist/mcp/runtime.js

@@ -119,7 +119,10 @@ class ToolProfileHiddenError extends Error {
     suggestedTool;
     constructor(name, activeProfile) {
         const requiredProfiles = getMcpToolRequiredProfiles(name);
-        const suggestedTool = getMcpToolSuccessor(name);
+        const configuredSuccessor = getMcpToolSuccessor(name);
+        const suggestedTool = configuredSuccessor && isMcpToolVisibleInProfile(configuredSuccessor.name, activeProfile)
+            ? configuredSuccessor
+            : null;
         const suffix = suggestedTool ? ` Use ${suggestedTool.name} instead.` : ` Request one of these profiles to use it: ${requiredProfiles.join(', ')}.`;
         super(`Tool ${name} is not available in the ${activeProfile} MCP tool profile.${suffix}`);
         this.activeProfile = activeProfile;
@@ -1884,6 +1887,9 @@ export function createTaskforceMcpServer(options = {}) {
             } : {}),
             title: task?.title || null,
             status: task?.status || null,
+            isArchived: Boolean(task?.isArchived),
+            completedAt: task?.completedAt || null,
+            canceledReason: task?.canceledReason || null,
             category: task?.category || null,
             type: task?.type || null,
             priority: task?.priority ?? null,
@@ -5327,6 +5333,7 @@ export function createTaskforceMcpServer(options = {}) {
                 const avatarSuggestion = resolved.created
                     && !configuredClientBlocksGeneration
                     && isAiProfileAvatarGenerationEligible(resolved.profile)
+                    && isMcpToolVisibleInProfile('generate_profile_avatar', activeToolProfile)
                     ? {
                         avatarSuggestion: {
                             nextTool: 'generate_profile_avatar',
@@ -7825,7 +7832,7 @@ export function createTaskforceMcpServer(options = {}) {
                 const { id: inputId, status, reason } = args;
                 const { id, task } = resolveTaskByIdentifierOrThrow(inputId);
                 const isCancelled = status === 'cancelled';
-                taskLifecycleCommandService.archive(task, { status, reason });
+                const result = taskLifecycleCommandService.archive(task, { status, reason });
                 recordMcpWriteAudit('archive_task', { taskId: id, status, cancelled: isCancelled });
                 await notifyResourceMutation({
                     taskIds: [id],
@@ -7833,7 +7840,15 @@ export function createTaskforceMcpServer(options = {}) {
                     includeStats: true,
                 });
                 return {
-                    content: [{ type: "text", text: `Task ${formatTaskIdentifier(task)} archived as ${status}` }],
+                    content: [{ type: "text", text: JSON.stringify({
+                                task: buildTaskWriteSummary(result.task),
+                                archive: {
+                                    archived: true,
+                                    status: result.status,
+                                    cancelled: result.cancelled,
+                                    reason: isCancelled ? String(reason || '').trim() || null : null,
+                                },
+                            }, null, 2) }],
                 };
             }
             case "get_config": {
@@ -8056,8 +8071,9 @@ export function createTaskforceMcpServer(options = {}) {
             case "unarchive_task": {
                 const { id: inputId } = args;
                 const { id, task: existingTask } = resolveTaskByIdentifierOrThrow(inputId, { notFoundMessage: buildTaskLookupFailureMessage(String(inputId || '').trim()) });
+                let result;
                 try {
-                    taskLifecycleCommandService.unarchive(existingTask);
+                    result = taskLifecycleCommandService.unarchive(existingTask);
                 }
                 catch (error) {
                     if (error instanceof TaskLifecycleCommandError && error.code === 'TASK_NOT_FOUND') {
@@ -8072,7 +8088,10 @@ export function createTaskforceMcpServer(options = {}) {
                     includeStats: true,
                 });
                 return {
-                    content: [{ type: "text", text: `Task ${formatTaskIdentifier(existingTask)} unarchived` }],
+                    content: [{ type: "text", text: JSON.stringify({
+                                task: buildTaskWriteSummary(result.task),
+                                unarchive: { unarchived: true },
+                            }, null, 2) }],
                 };
             }
             case "bulk_archive": {

package/dist/mcp/taskPlanningRegistrar.js

@@ -617,7 +617,7 @@ export function registerTaskPlanningTools(registerTool, executeTool) {
         },
     }));
     register('archive_task', (context) => ({
-        description: context.describeTool('Move a task to history by archiving it. Use status=\'done\' for completed work or status=\'cancelled\' for abandoned work. active tasks may still use status=done for final lookover without being archived.'),
+        description: context.describeTool('Move a task to history by archiving it. Use status=\'done\' for completed work or status=\'cancelled\' for abandoned work. Returns compact task and archive state so callers can verify the final status and isArchived=true.'),
         inputSchema: {
             properties: {
                 id: stringProperty('Task ID or task reference such as T-123.'),
@@ -628,7 +628,7 @@ export function registerTaskPlanningTools(registerTool, executeTool) {
         },
     }));
     register('unarchive_task', (context) => ({
-        description: context.describeTool('Restore an archived task to the active task list.'),
+        description: context.describeTool('Restore an archived task to the active task list. Returns compact task and unarchive state so callers can verify isArchived=false.'),
         inputSchema: {
             properties: {
                 id: stringProperty('Task ID or task reference such as T-123.'),

package/dist/mcp/toolProfiles.js

@@ -18,6 +18,7 @@ const MANAGED_AGENT_ALLOWED_MUTATING_TOOLS = new Set([
     'add_workstream_comment',
     'complete_workflow_step',
     'replace_task_checklist',
+    'review_document',
 ]);
 export function normalizeMcpToolProfile(value, fallback) {
     const normalized = typeof value === 'string' ? value.trim().toLowerCase() : '';

package/dist/mcp/toolRegistry.js

@@ -45,8 +45,8 @@ export const MCP_TOOL_REGISTRY = Object.freeze({
     add_workstream_comment: defaultTool({ kind: 'scope', scope: 'tasks:write' }, true),
     archive_workstream: extendedTool({ kind: 'scope', scope: 'tasks:write' }, true),
     unarchive_workstream: extendedTool({ kind: 'scope', scope: 'tasks:write' }, true),
-    update_task_workstream: defaultTool({ kind: 'scope', scope: 'tasks:write' }, true),
-    update_workstream_initiative: defaultTool({ kind: 'scope', scope: 'tasks:write' }, true),
+    update_task_workstream: extendedTool({ kind: 'scope', scope: 'tasks:write' }, true, { name: 'update_task' }),
+    update_workstream_initiative: extendedTool({ kind: 'scope', scope: 'tasks:write' }, true, { name: 'update_workstream' }),
     get_task_checklist: defaultTool({ kind: 'scope', scope: 'tasks:read' }, false),
     add_task_checklist_item: defaultTool({ kind: 'scope', scope: 'tasks:write' }, true),
     update_task_checklist_item: defaultTool({ kind: 'scope', scope: 'tasks:write' }, true),
@@ -58,19 +58,19 @@ export const MCP_TOOL_REGISTRY = Object.freeze({
     get_initiative_attachments: extendedTool({ kind: 'scope', scope: 'tasks:read' }, false),
     save_initiative_attachment: defaultTool({ kind: 'scope', scope: 'tasks:write' }, true),
     delete_initiative_attachment: extendedTool({ kind: 'scope', scope: 'tasks:write' }, true),
-    search_images: defaultTool({ kind: 'scope', scope: 'tasks:read' }, false),
-    get_image: defaultTool({ kind: 'scope', scope: 'tasks:read' }, false),
+    search_images: extendedTool({ kind: 'scope', scope: 'tasks:read' }, false),
+    get_image: extendedTool({ kind: 'scope', scope: 'tasks:read' }, false),
     search_documents: defaultTool({ kind: 'scope', scope: 'tasks:read' }, false),
     get_document: defaultTool({ kind: 'scope', scope: 'tasks:read' }, false),
     update_document: defaultTool({ kind: 'scope', scope: 'tasks:write' }, true),
     link_document: defaultTool({ kind: 'scope', scope: 'tasks:write' }, true),
     rehome_document: defaultTool({ kind: 'scope', scope: 'tasks:write' }, true),
     unlink_document: defaultTool({ kind: 'scope', scope: 'tasks:write' }, true),
-    get_image_annotations: defaultTool({ kind: 'scope', scope: 'tasks:read' }, false),
+    get_image_annotations: extendedTool({ kind: 'scope', scope: 'tasks:read' }, false),
     create_annotated_attachment_session: extendedTool({ kind: 'scope', scope: 'tasks:write' }, true),
     update_annotated_attachment_session: extendedTool({ kind: 'scope', scope: 'tasks:write' }, true),
     delete_annotated_attachment_session: extendedTool({ kind: 'scope', scope: 'tasks:write' }, true),
-    review_image: defaultTool({ kind: 'scope', scope: 'tasks:write' }, true),
+    review_image: extendedTool({ kind: 'scope', scope: 'tasks:write' }, true),
     add_annotated_attachment_marker: extendedTool({ kind: 'scope', scope: 'tasks:write' }, true, { name: 'review_image' }),
     bulk_add_annotated_attachment_markers: extendedTool({ kind: 'scope', scope: 'tasks:write' }, true, { name: 'review_image' }),
     update_annotated_attachment_marker: extendedTool({ kind: 'scope', scope: 'tasks:write' }, true),
@@ -82,14 +82,14 @@ export const MCP_TOOL_REGISTRY = Object.freeze({
     review_document: defaultTool({ kind: 'scope', scope: 'tasks:write' }, true),
     add_document_review_comment: extendedTool({ kind: 'scope', scope: 'tasks:write' }, true, { name: 'review_document' }),
     update_document_review_thread: extendedTool({ kind: 'scope', scope: 'tasks:write' }, true),
-    update_document_review_comment: defaultTool({ kind: 'scope', scope: 'tasks:write' }, true),
+    update_document_review_comment: extendedTool({ kind: 'scope', scope: 'tasks:write' }, true),
     delete_document_review_comment: extendedTool({ kind: 'scope', scope: 'tasks:write' }, true),
     get_schedule_board: defaultTool({ kind: 'scope', scope: 'tasks:read' }, false),
     update_schedule: defaultTool({ kind: 'scope', scope: 'tasks:write' }, true),
     bulk_carryover: extendedTool({ kind: 'scope', scope: 'tasks:write' }, true),
     set_schedule_preferences: fullTool({ kind: 'session-only' }, true),
     resolve_profile: defaultTool({ kind: 'scope', scope: 'tasks:write' }, true),
-    generate_profile_avatar: defaultTool({ kind: 'scope', scope: 'tasks:write' }, true),
+    generate_profile_avatar: extendedTool({ kind: 'scope', scope: 'tasks:write' }, true),
     create_task: defaultTool({ kind: 'scope', scope: 'tasks:write' }, true),
     start_task: defaultTool({ kind: 'scope', scope: 'tasks:write' }, true),
     reopen_task: defaultTool({ kind: 'scope', scope: 'tasks:write' }, true),

package/dist/server/buildInfo.d.ts

@@ -3,5 +3,6 @@ export interface TaskforceBuildInfo {
     gitSha: string | null;
     buildTime: string | null;
     deployId: string | null;
+    environmentId: string | null;
 }
 export declare function resolveBuildInfo(env?: NodeJS.ProcessEnv): TaskforceBuildInfo;

package/dist/server/buildInfo.js

@@ -88,6 +88,9 @@ export function resolveBuildInfo(env = process.env) {
         env.CF_PAGES_URL,
         env.GITHUB_RUN_ID
     ]);
+    const environmentId = resolveFirstNonEmpty([
+        env.RAILWAY_ENVIRONMENT_ID,
+    ]);
     const version = explicitVersion
         ? explicitVersion
         : appendBuildMetadata(packageVersion, [deployId, gitSha, buildTimeToken(buildTime)]);
@@ -95,6 +98,7 @@ export function resolveBuildInfo(env = process.env) {
         version,
         gitSha,
         buildTime,
-        deployId
+        deployId,
+        environmentId,
     };
 }

package/dist/server/cloudMcpCapacityTelemetry.d.ts

@@ -0,0 +1,68 @@
+import type { ServerResponse } from 'node:http';
+import type { RequestPerformanceDiagnostics } from '../storage/postgresRequestDiagnostics.js';
+export declare const TASKFORCE_CAPACITY_TRACE_HEADER = "x-taskforce-capacity-trace";
+export type CloudMcpRequestClass = 'initialize' | 'discover' | 'tools_list' | 'read' | 'write' | 'other';
+export type CloudMcpOutcome = 'success' | 'rejected' | 'client_error' | 'server_error' | 'timeout_or_abort';
+export type CloudMcpRejectionClass = 'rate_limited' | 'auth_or_scope' | 'protocol' | 'other_client';
+type EventLoopSampler = {
+    enable(): void;
+    disable?(): void;
+    reset(): void;
+    percentile(percentile: number): number;
+    readonly max: number;
+};
+type CapacityTelemetryOptions = {
+    emit?: (payload: Record<string, unknown>) => void;
+    eventLoop?: EventLoopSampler;
+    now?: () => number;
+    cpuUsage?: typeof process.cpuUsage;
+    memoryUsage?: typeof process.memoryUsage;
+    windowMs?: number;
+    maxSamples?: number;
+};
+export declare class CloudMcpCapacityTelemetry {
+    private readonly emit;
+    private readonly eventLoop;
+    private readonly now;
+    private readonly cpuUsage;
+    private readonly memoryUsage;
+    private readonly windowMs;
+    private readonly maxSamples;
+    private activeRequests;
+    private maxActiveRequests;
+    private samples;
+    private completedRequests;
+    private requestClassCounts;
+    private outcomeCounts;
+    private rejectionCounts;
+    private statusClassCounts;
+    private windowStartedAt;
+    private windowCpuStartedAt;
+    private readonly flushTimer;
+    constructor(options?: CapacityTelemetryOptions);
+    begin(requestClass?: CloudMcpRequestClass): {
+        classify: (nextClass: CloudMcpRequestClass) => void;
+        setTraceHeaders: (res: ServerResponse, postgres?: RequestPerformanceDiagnostics | null) => void;
+        finish: (input: {
+            statusCode: number;
+            aborted?: boolean;
+            postgres?: RequestPerformanceDiagnostics | null;
+        }) => void;
+    };
+    snapshot(): Record<string, unknown>;
+    flush(): Record<string, unknown> | null;
+    shutdown(): void;
+    private flushIfDue;
+    private minimumPoolIdle;
+}
+export declare function isCloudMcpCapacityTelemetryEnabled(): boolean;
+export declare function beginCloudMcpCapacityRequest(requestClass?: CloudMcpRequestClass): {
+    classify: (nextClass: CloudMcpRequestClass) => void;
+    setTraceHeaders: (res: ServerResponse, postgres?: RequestPerformanceDiagnostics | null) => void;
+    finish: (input: {
+        statusCode: number;
+        aborted?: boolean;
+        postgres?: RequestPerformanceDiagnostics | null;
+    }) => void;
+};
+export {};