agentic-qe 3.15.12 → 3.15.13

package/dist/mcp/handlers/domain-handler-configs.d.ts

@@ -148,6 +148,9 @@ export interface AccessibilityTestResult {
     score: number;
     violations: unknown[];
     warnings: unknown[];
+    /** #1145: false when no page was audited; `passed` is then not a verdict and `score` is -1. */
+    measured?: boolean;
+    note?: string;
     duration: number;
     savedFiles?: string[];
     /** #933: true when result files were written; see savedFiles for their paths. */
@@ -247,6 +250,11 @@ export interface CodeIndexResult {
         tests: number;
         toolsUsed: string[];
     };
+    /**
+     * #1224: non-fatal indexing warnings, e.g. that code search does not cover
+     * every indexed file. Absent when there are none.
+     */
+    warnings?: string[];
     /**
      * #1096: discovered paths that were not indexed (missing, not a regular
      * file, outside the project root, filtered out), with the reason. Absent

package/dist/mcp/handlers/domain-handler-configs.js

@@ -687,11 +687,15 @@ export const accessibilityTestConfig = {
     }),
     mapToResult: (taskId, data, duration, savedFiles) => ({
         taskId,
-        status: 'completed',
+        status: data.measured === true ? 'completed' : 'not-measured',
         passed: data.passed || false,
-        score: data.score || 0,
+        // #1145: an unmeasured score is -1, never a 0/100 grade
+        score: data.measured === true && typeof data.score === 'number' ? data.score : -1,
         violations: data.violations || [],
         warnings: data.warnings || [],
+        // #1145: fail closed; only an explicit measurement counts as one
+        measured: data.measured === true,
+        ...(typeof data.note === 'string' ? { note: data.note } : {}),
         duration,
         savedFiles,
     }),
@@ -813,6 +817,9 @@ export const codeIndexConfig = {
         symbolsExtracted: data.symbolsExtracted || 0,
         relationsFound: data.relationsFound || 0,
         ...(data.projectMetrics ? { projectMetrics: data.projectMetrics } : {}),
+        ...(Array.isArray(data.warnings) && data.warnings.length > 0
+            ? { warnings: data.warnings }
+            : {}),
         ...(Array.isArray(data.skipped) && data.skipped.length > 0
             ? { skipped: data.skipped }
             : {}),

package/dist/mcp/handlers/handler-factory.js

@@ -224,6 +224,9 @@ async function recordDomainFeedback(domain, data, durationMs, params) {
                 coverageMethod: data.coverageMethod ?? 'instrumented-report',
                 branchDataCollected: data.branchCoverage !== null && data.branchCoverage !== undefined,
                 functionDataCollected: data.functionCoverage !== null && data.functionCoverage !== undefined,
+                // #1030: coverage from a run whose tests failed says so, as
+                // coverage:latest and the per-file records already do (#1027 N4).
+                ...(data.runStatus === 'passed' || data.runStatus === 'failed' ? { runStatus: data.runStatus } : {}),
             },
         };
         await loop.recordCoverageSession(session);

package/dist/mcp/handlers/model-route-handlers.d.ts

@@ -0,0 +1,107 @@
+/**
+ * Agentic QE v3 - Model routing MCP handlers (ADR-051)
+ * Routing decisions, routing metrics and routing economics.
+ */
+import type { ToolResult } from '../types';
+import { type RoutingLogEntry, type RoutingStats } from '../services/task-router';
+import type { ModelTier } from '../../integrations/agentic-flow';
+export interface ModelRouteParams {
+    /** Task description to analyze */
+    task: string;
+    /** Optional code context for complexity analysis */
+    codeContext?: string;
+    /** Optional file paths */
+    filePaths?: string[];
+    /** Manual tier override */
+    manualTier?: ModelTier;
+    /** Mark as critical task */
+    isCritical?: boolean;
+    /** Agent type making the request */
+    agentType?: string;
+    /** Domain context */
+    domain?: string;
+}
+export interface ModelRouteResult {
+    tier: ModelTier;
+    tierName: string;
+    modelId: string;
+    executionStrategy: string;
+    useAgentBooster: boolean;
+    agentBoosterTransform?: string;
+    complexity: {
+        overall: number;
+        code: number;
+        reasoning: number;
+        scope: number;
+    };
+    confidence: number;
+    rationale: string;
+    warnings: string[];
+    budget: {
+        allowed: boolean;
+        wasDowngraded: boolean;
+        estimatedCostUsd: number;
+    };
+    decisionTimeMs: number;
+}
+/**
+ * Handle model routing query - returns routing decision without submitting task
+ */
+export declare function handleModelRoute(params: ModelRouteParams): Promise<ToolResult<ModelRouteResult>>;
+export interface RoutingMetricsParams {
+    /** Include routing log entries */
+    includeLog?: boolean;
+    /** Max log entries to return */
+    logLimit?: number;
+}
+export interface RoutingMetricsResult {
+    stats: RoutingStats;
+    log?: RoutingLogEntry[];
+    modelRouterMetrics: {
+        totalDecisions: number;
+        avgDecisionTimeMs: number;
+        agentBoosterStats: {
+            eligible: number;
+            used: number;
+            successRate: number;
+        };
+        budgetStats: {
+            totalSpentUsd: number;
+            budgetUtilization: number;
+            downgradeCount: number;
+        };
+    };
+}
+/**
+ * Handle routing metrics query
+ */
+export declare function handleRoutingMetrics(params: RoutingMetricsParams): Promise<ToolResult<RoutingMetricsResult>>;
+export interface RoutingEconomicsParams {
+    /** Task complexity score 0-1 for tier scoring (default: 0.5) */
+    taskComplexity?: number;
+}
+export interface RoutingEconomicsResult {
+    tierEfficiency: Array<{
+        tier: string;
+        qualityScore: number;
+        estimatedCostUsd: number;
+        qualityPerDollar: number | string;
+        economicScore: number;
+    }>;
+    currentHourlyCostUsd: number;
+    currentDailyCostUsd: number;
+    budgetRemaining: {
+        hourly: number | null;
+        daily: number | null;
+    };
+    recommendation: string;
+    savingsOpportunity: {
+        usd: number;
+        description: string;
+    } | null;
+}
+/**
+ * Handle economic routing report query
+ */
+export declare function handleRoutingEconomics(params: RoutingEconomicsParams): Promise<ToolResult<RoutingEconomicsResult>>;
+//# sourceMappingURL=model-route-handlers.d.ts.map

package/dist/mcp/handlers/model-route-handlers.js

@@ -0,0 +1,139 @@
+/**
+ * Agentic QE v3 - Model routing MCP handlers (ADR-051)
+ * Routing decisions, routing metrics and routing economics.
+ */
+import { getTaskRouter, } from '../services/task-router.js';
+import { toErrorMessage } from '../../shared/error-utils.js';
+import { inferDomainFromDescription } from './task-inference.js';
+/**
+ * Handle model routing query - returns routing decision without submitting task
+ */
+export async function handleModelRoute(params) {
+    try {
+        const router = await getTaskRouter();
+        // Enrich routing input: infer domain and metadata from task description
+        // when the caller doesn't provide them explicitly
+        const inferredDomain = params.domain || inferDomainFromDescription(params.task);
+        const inferredIsCritical = params.isCritical ??
+            /\b(security|vulnerability|cve|owasp|critical|production|exploit)\b/i.test(params.task);
+        const result = await router.routeTask({
+            task: params.task,
+            codeContext: params.codeContext,
+            filePaths: params.filePaths,
+            manualTier: params.manualTier,
+            isCritical: inferredIsCritical,
+            agentType: params.agentType || `qe-${inferredDomain}`,
+            domain: inferredDomain,
+            // Pass metadata to help the complexity analyzer
+            metadata: {
+                inferredDomain,
+                hasCodeContext: !!params.codeContext,
+                fileCount: params.filePaths?.length,
+            },
+        });
+        return {
+            success: true,
+            data: {
+                tier: result.decision.tier,
+                tierName: result.tierInfo.name,
+                modelId: result.modelId,
+                executionStrategy: result.executionStrategy,
+                useAgentBooster: result.useAgentBooster,
+                agentBoosterTransform: result.decision.agentBoosterTransform,
+                complexity: {
+                    overall: result.decision.complexityAnalysis.overall,
+                    code: result.decision.complexityAnalysis.codeComplexity,
+                    reasoning: result.decision.complexityAnalysis.reasoningComplexity,
+                    scope: result.decision.complexityAnalysis.scopeComplexity,
+                },
+                confidence: result.decision.confidence,
+                rationale: result.decision.rationale,
+                warnings: result.decision.warnings,
+                budget: {
+                    allowed: result.decision.budgetDecision.allowed,
+                    wasDowngraded: result.decision.budgetDecision.wasDowngraded,
+                    estimatedCostUsd: result.decision.budgetDecision.estimatedCostUsd,
+                },
+                decisionTimeMs: result.decision.metadata.decisionTimeMs,
+            },
+        };
+    }
+    catch (error) {
+        return {
+            success: false,
+            error: `Failed to route task: ${toErrorMessage(error)}`,
+        };
+    }
+}
+/**
+ * Handle routing metrics query
+ */
+export async function handleRoutingMetrics(params) {
+    try {
+        const router = await getTaskRouter();
+        const stats = router.getRoutingStats();
+        const metrics = router.getMetrics();
+        const result = {
+            stats,
+            modelRouterMetrics: {
+                totalDecisions: metrics.totalDecisions,
+                avgDecisionTimeMs: metrics.avgDecisionTimeMs,
+                agentBoosterStats: metrics.agentBoosterStats,
+                budgetStats: metrics.budgetStats,
+            },
+        };
+        if (params.includeLog) {
+            result.log = router.getRoutingLog(params.logLimit || 100);
+        }
+        return {
+            success: true,
+            data: result,
+        };
+    }
+    catch (error) {
+        return {
+            success: false,
+            error: `Failed to get routing metrics: ${toErrorMessage(error)}`,
+        };
+    }
+}
+/**
+ * Handle economic routing report query
+ */
+export async function handleRoutingEconomics(params) {
+    try {
+        const { createRoutingFeedbackCollector } = await import('../../routing/routing-feedback.js');
+        const { getGlobalCostTracker } = await import('../../shared/llm/cost-tracker.js');
+        // Create collector, initialize to load persisted state from DB, then enable economic routing
+        const collector = createRoutingFeedbackCollector(100);
+        await collector.initialize();
+        collector.enableEconomicRouting({ ...(params.taskComplexity != null ? {} : {}) }, getGlobalCostTracker());
+        const report = collector.getEconomicReport();
+        if (!report) {
+            return { success: false, error: 'Economic routing is not available' };
+        }
+        // Convert Infinity to string for JSON serialization
+        const tierEfficiency = report.tierEfficiency.map(t => ({
+            ...t,
+            qualityPerDollar: isFinite(t.qualityPerDollar) ? t.qualityPerDollar : 'Infinity',
+        }));
+        return {
+            success: true,
+            data: {
+                tierEfficiency,
+                currentHourlyCostUsd: report.currentHourlyCostUsd,
+                currentDailyCostUsd: report.currentDailyCostUsd,
+                budgetRemaining: report.budgetRemaining,
+                recommendation: report.recommendation,
+                savingsOpportunity: report.savingsOpportunity,
+            },
+        };
+    }
+    catch (error) {
+        return {
+            success: false,
+            error: `Failed to get economic routing report: ${toErrorMessage(error)}`,
+        };
+    }
+}
+//# sourceMappingURL=model-route-handlers.js.map

package/dist/mcp/handlers/orchestrate-routes.js

@@ -13,6 +13,7 @@ import { resolve } from 'node:path';
 import { findProjectRoot } from '../../kernel/project-root.js';
 import { confineIndexPaths } from '../../domains/code-intelligence/index-path-guard.js';
 import { requirePayloadPath } from '../../shared/io/payload-path-guard.js';
+import { isCodeSearch, namesTestGeneration } from './task-inference.js';
 const needs = (type, what) => ({
     kind: 'needs-input',
     error: `task_orchestrate inferred '${type}' from the description, but ${what}`,
@@ -75,6 +76,31 @@ async function coverageRoute(request) {
         payload: { target, detectGaps: true },
     };
 }
+/**
+ * #1225: test generation reads source files. Without filePaths, the files the
+ * description names are used; with none, the task is refused up front instead
+ * of being accepted and failing with "missing sourceFiles". `generate-tests`
+ * is also the fallback for a description that names no task, which the
+ * refusal says.
+ */
+async function testGenerationRoute(request) {
+    const type = 'generate-tests';
+    if ((request.filePaths ?? []).length > 0)
+        return { kind: 'as-inferred' };
+    const named = pathsInDescription(request.task);
+    if (named.length === 0) {
+        const why = namesTestGeneration(request.task)
+            ? 'no source files were given and the description names none.'
+            : 'no task type could be inferred from the description, and test generation (the fallback) needs ' +
+                'source files: none were given and the description names none.';
+        return needs(type, `${why} Pass filePaths with the source files to generate tests for, or use ` +
+            'test_generate_enhanced, or task_submit with a task type and its payload.');
+    }
+    const confined = await projectFiles(type, named);
+    if ('kind' in confined)
+        return confined;
+    return { kind: 'route', type, domain: 'test-generation', payload: { sourceFiles: confined.files } };
+}
 /** Decide how task_orchestrate runs an inferred task type. */
 export async function routeInferredTask(type, request) {
     const filePaths = request.filePaths ?? [];
@@ -89,7 +115,16 @@ export async function routeInferredTask(type, request) {
                 return confined;
             return { kind: 'route', type: 'sast-scan', domain: 'security-compliance', payload: { files: confined.files } };
         }
-        case 'index-code':
+        case 'index-code': {
+            // #1146: a search description ("semantic search for auth code") is not
+            // an index request. Running the domain's search could answer "no
+            // results" for code that exists (#1224), so it is refused with what to
+            // use instead of the misleading "no files to index".
+            if (isCodeSearch(request.task)) {
+                return needs(type, 'the description asks for a code search, which task_orchestrate does not run: the ' +
+                    'code-intelligence search can report no results for code that exists (#1224). Search the source ' +
+                    'directly (e.g. grep), or use code_index with a target for dependency and impact analysis.');
+            }
             // #1134: indexing reads exactly the files it is given; without them the
             // task could only fail after it was accepted. The indexer confines the
             // paths to the project itself (#1096).
@@ -98,6 +133,7 @@ export async function routeInferredTask(type, request) {
                     'or use code_index with a target.');
             }
             return { kind: 'as-inferred' };
+        }
         case 'assess-quality': {
             if (filePaths.length === 0) {
                 return needs(type, 'no source files were given. Pass filePaths with the source files to assess, ' +
@@ -119,8 +155,8 @@ export async function routeInferredTask(type, request) {
                 'Lighthouse), and the domain task handler cannot guarantee one. Use accessibility_test with the page URL.');
         case 'optimize-learning':
             // optimize-strategies overwrites the stored learned strategies
-            // (persist: true). Words like "improve" or "optimize" in a description
-            // must not change learning data as a side effect.
+            // (persist: true), so learning wording alone does not run it (#1146:
+            // "improve"/"optimize" alone no longer infer it at all).
             return needs(type, 'learning optimization overwrites the stored learned strategies, so it is not run from ' +
                 'a description. Use task_submit with type optimize-strategies in domain learning-optimization.');
         case 'run-chaos':
@@ -134,6 +170,8 @@ export async function routeInferredTask(type, request) {
             return needs(type, 'requirement validation needs a structured requirement (title, description, ' +
                 'acceptance criteria). Use requirements_validate, or task_submit with type validate and ' +
                 'payload.requirement in domain requirements-validation.');
+        case 'generate-tests':
+            return testGenerationRoute(request);
         default:
             return { kind: 'as-inferred' };
     }

package/dist/mcp/handlers/task-handlers.d.ts

@@ -6,11 +6,9 @@
  * Issue #206: Workflow auto-execution for task types with associated workflows
  */
 import { ToolResult, TaskSubmitParams, TaskSubmitResult, TaskListParams, TaskStatusParams, TaskStatusResult, TaskCancelParams } from '../types';
-import { TaskType } from '../../coordination/queen-coordinator';
-import { type RoutingLogEntry, type RoutingStats } from '../services/task-router';
-import type { ExperienceGuidanceStatus } from '../../integrations/agentic-flow/reasoning-bank/index.js';
-import type { ModelTier } from '../../integrations/agentic-flow';
-import { type Priority } from '../../shared/types/index.js';
+export * from './task-orchestrate-handler.js';
+export * from './model-route-handlers.js';
+export * from './task-learning-handlers.js';
 export declare function handleTaskSubmit(params: TaskSubmitParams): Promise<ToolResult<TaskSubmitResult>>;
 export declare function handleTaskList(params: TaskListParams): Promise<ToolResult<TaskStatusResult[]>>;
 export declare function handleTaskStatus(params: TaskStatusParams): Promise<ToolResult<TaskStatusResult>>;
@@ -19,250 +17,4 @@ export declare function handleTaskCancel(params: TaskCancelParams): Promise<Tool
     cancelled: boolean;
     cancellationResultPending: boolean;
 }>>;
-export interface TaskOrchestrateParams {
-    task: string;
-    strategy?: 'parallel' | 'sequential' | 'adaptive';
-    /** Named levels, or a canonical p0-p3 priority (p0 stays p0). */
-    priority?: 'low' | 'medium' | 'high' | 'critical' | Priority;
-    maxAgents?: number;
-    /** Manual tier override (0-4) */
-    manualTier?: ModelTier;
-    /** Code context for complexity analysis */
-    codeContext?: string;
-    /** File paths involved */
-    filePaths?: string[];
-    context?: {
-        project?: string;
-        branch?: string;
-        environment?: string;
-        requirements?: string[];
-    };
-}
-/**
- * #1022: how learned patterns informed task_orchestrate.
- * - 'vector': embedding similarity plus text matching
- * - 'lexical-only': no working embedder (absent, or failed at runtime, #1187);
- *   text matching only, no similarity
- *   scores, and experience guidance unavailable
- * - 'unavailable': the ReasoningBank could not start; no learned guidance
- *
- * #1204: `experienceGuidance` says the same for similar-experience guidance:
- * 'unavailable' (with the reason) when its embedder failed or is absent.
- * Omitted when experience replay is disabled or the ReasoningBank is down.
- */
-export interface OrchestrateLearningStatus {
-    patternSearch: 'vector' | 'lexical-only' | 'unavailable';
-    reason?: string;
-    experienceGuidance?: ExperienceGuidanceStatus;
-}
-export interface TaskOrchestrateResult {
-    taskId: string;
-    /** The task type submitted to the domain. */
-    type: TaskType;
-    /** #1125: the type inferred from the description, when another handler type runs it. */
-    inferredType?: TaskType;
-    priority: 'p0' | 'p1' | 'p2' | 'p3';
-    strategy: string;
-    status: string;
-    message: string;
-    /** ADR-051: Model routing decision */
-    routing: {
-        tier: ModelTier;
-        tierName: string;
-        modelId: string;
-        executionStrategy: string;
-        complexity: number;
-        confidence: number;
-        useAgentBooster: boolean;
-        rationale: string;
-        decisionTimeMs: number;
-    };
-    /** #1022: how learned patterns informed this orchestration */
-    learning: OrchestrateLearningStatus;
-}
-export declare function handleTaskOrchestrate(params: TaskOrchestrateParams): Promise<ToolResult<TaskOrchestrateResult>>;
-export interface ModelRouteParams {
-    /** Task description to analyze */
-    task: string;
-    /** Optional code context for complexity analysis */
-    codeContext?: string;
-    /** Optional file paths */
-    filePaths?: string[];
-    /** Manual tier override */
-    manualTier?: ModelTier;
-    /** Mark as critical task */
-    isCritical?: boolean;
-    /** Agent type making the request */
-    agentType?: string;
-    /** Domain context */
-    domain?: string;
-}
-export interface ModelRouteResult {
-    tier: ModelTier;
-    tierName: string;
-    modelId: string;
-    executionStrategy: string;
-    useAgentBooster: boolean;
-    agentBoosterTransform?: string;
-    complexity: {
-        overall: number;
-        code: number;
-        reasoning: number;
-        scope: number;
-    };
-    confidence: number;
-    rationale: string;
-    warnings: string[];
-    budget: {
-        allowed: boolean;
-        wasDowngraded: boolean;
-        estimatedCostUsd: number;
-    };
-    decisionTimeMs: number;
-}
-/**
- * Handle model routing query - returns routing decision without submitting task
- */
-export declare function handleModelRoute(params: ModelRouteParams): Promise<ToolResult<ModelRouteResult>>;
-export interface RoutingMetricsParams {
-    /** Include routing log entries */
-    includeLog?: boolean;
-    /** Max log entries to return */
-    logLimit?: number;
-}
-export interface RoutingMetricsResult {
-    stats: RoutingStats;
-    log?: RoutingLogEntry[];
-    modelRouterMetrics: {
-        totalDecisions: number;
-        avgDecisionTimeMs: number;
-        agentBoosterStats: {
-            eligible: number;
-            used: number;
-            successRate: number;
-        };
-        budgetStats: {
-            totalSpentUsd: number;
-            budgetUtilization: number;
-            downgradeCount: number;
-        };
-    };
-}
-/**
- * Handle routing metrics query
- */
-export declare function handleRoutingMetrics(params: RoutingMetricsParams): Promise<ToolResult<RoutingMetricsResult>>;
-export interface RoutingEconomicsParams {
-    /** Task complexity score 0-1 for tier scoring (default: 0.5) */
-    taskComplexity?: number;
-}
-export interface RoutingEconomicsResult {
-    tierEfficiency: Array<{
-        tier: string;
-        qualityScore: number;
-        estimatedCostUsd: number;
-        qualityPerDollar: number | string;
-        economicScore: number;
-    }>;
-    currentHourlyCostUsd: number;
-    currentDailyCostUsd: number;
-    budgetRemaining: {
-        hourly: number | null;
-        daily: number | null;
-    };
-    recommendation: string;
-    savingsOpportunity: {
-        usd: number;
-        description: string;
-    } | null;
-}
-/**
- * Handle economic routing report query
- */
-export declare function handleRoutingEconomics(params: RoutingEconomicsParams): Promise<ToolResult<RoutingEconomicsResult>>;
-export interface TaskOutcomeRecordParams {
-    /** Task ID */
-    taskId: string;
-    /** Task description */
-    task: string;
-    /** Task type */
-    taskType: string;
-    /** Whether the task succeeded */
-    success: boolean;
-    /** Execution time in ms */
-    executionTimeMs: number;
-    /** Agent that executed the task */
-    agentId?: string;
-    /** Domain */
-    domain?: string;
-    /** Model tier used */
-    modelTier?: number;
-    /** Quality score (0-1) */
-    qualityScore?: number;
-    /** Error message if failed */
-    error?: string;
-    /** Additional metrics */
-    metrics?: {
-        tokensUsed?: number;
-        testsGenerated?: number;
-        testsPassed?: number;
-        coverageImprovement?: number;
-    };
-}
-export interface TaskOutcomeRecordResult {
-    recorded: boolean;
-    patternStored: boolean;
-    message: string;
-}
-/**
- * Record a task outcome for ReasoningBank learning
- * ADR-051: Enables cross-session learning from task execution
- */
-export declare function handleTaskOutcomeRecord(params: TaskOutcomeRecordParams): Promise<ToolResult<TaskOutcomeRecordResult>>;
-export interface ReasoningBankStatsResult {
-    service: {
-        tasksRecorded: number;
-        successfulTasks: number;
-        failedTasks: number;
-        successRate: number;
-        patternsStored: number;
-        routingRequests: number;
-    };
-    patterns: {
-        totalPatterns: number;
-        byDomain: Record<string, number>;
-        byTier: Record<string, number>;
-        learningOutcomes: number;
-        patternSuccessRate: number;
-    };
-    embeddings: {
-        cacheSize: number;
-        dimension: number;
-        transformerAvailable: boolean;
-    };
-    performance: {
-        avgRoutingLatencyMs: number;
-        p95RoutingLatencyMs: number;
-    };
-}
-/**
- * Get ReasoningBank statistics
- * ADR-051: Provides visibility into learning system
- */
-export declare function handleReasoningBankStats(): Promise<ToolResult<ReasoningBankStatsResult>>;
-/**
- * Enhanced task status that records outcomes for learning
- * ADR-051: Automatically records completed task outcomes
- * INTEGRATION FIX: Now synchronous to ensure learning occurs
- */
-export declare function handleTaskStatusWithLearning(params: TaskStatusParams): Promise<ToolResult<TaskStatusResult>>;
-/**
- * Subscribe to task lifecycle events to auto-close trajectories.
- * Must be called after the CrossDomainEventRouter is initialized.
- */
-export declare function subscribeTrajectoryEvents(router: import('../../coordination/cross-domain-router').CrossDomainEventRouter): void;
-/**
- * Unsubscribe trajectory event listeners. Called during fleet dispose.
- */
-export declare function unsubscribeTrajectoryEvents(router: import('../../coordination/cross-domain-router').CrossDomainEventRouter): void;
 //# sourceMappingURL=task-handlers.d.ts.map