@saptools/service-flow 0.1.52 → 0.1.54

package/src/trace/evidence.ts

@@ -4,6 +4,12 @@ import { normalizeODataOperationInvocationPath } from '../linker/odata-path-norm
 import { resolveOperation, type OperationTarget } from '../linker/service-resolver.js';
 import type { DynamicMode } from '../types.js';
 import { analyzeDynamicTargetCandidates, type DynamicTargetAnalysis, type DynamicTargetCandidate } from './dynamic-targets.js';
+import { boundCandidateLikeEvidence } from '../utils/000-bounded-projection.js';
+import {
+  dynamicMissingReason,
+  isStructuralContextualBlocker,
+  type ContextualRuntimeState,
+} from './008-contextual-runtime-state.js';
 
 export interface TraceGraphRow extends Record<string, unknown> {
   id: number;
@@ -34,6 +40,12 @@ interface RuntimeDiagnosticTotals {
   rejectedCandidates: Record<string, unknown>[];
   suggestedVarSets: Record<string, unknown>[];
 }
+interface RuntimeResolutionResult {
+  row: TraceGraphRow;
+  evidence: Record<string, unknown>;
+  target?: OperationTarget;
+  unresolvedReason?: string;
+}
 
 export function baseTraceEvidence(
   row: TraceGraphRow,
@@ -66,17 +78,18 @@ export function runtimeResolution(
   evidence: Record<string, unknown>,
   options: { vars?: Record<string, string>; dynamicMode?: DynamicMode; maxDynamicCandidates?: number },
   workspaceId: number | undefined,
-  contextualUnresolvedReason?: string,
-): { row: TraceGraphRow; evidence: Record<string, unknown>; target?: OperationTarget; unresolvedReason?: string } {
+  contextualState?: ContextualRuntimeState,
+): RuntimeResolutionResult {
   const dynamicMode = options.dynamicMode ?? 'strict';
   const candidateCap = positiveCandidateCap(options.maxDynamicCandidates);
+  const boundedEvidence = boundCandidateLikeEvidence(evidence, candidateCap);
   if (!isDynamicRemoteOperationEdge(row, evidence))
     return unchangedRuntimeResolution(
       row,
-      boundDynamicEvidence(evidence, candidateCap),
-      contextualUnresolvedReason,
+      boundDynamicEvidence(boundedEvidence, candidateCap),
+      contextualState,
     );
-  const substituted = evidenceWithRuntimeVariables(evidence, options.vars);
+  const substituted = evidenceWithRuntimeVariables(boundedEvidence, options.vars);
   const analysis = analyzeDynamicTargetCandidates(
     db, substituted, workspaceId, dynamicMode, candidateCap,
   );
@@ -84,41 +97,83 @@ export function runtimeResolution(
     analysis ? evidenceWithDynamicAnalysis(substituted, analysis) : substituted,
     candidateCap,
   );
-  if (analysis && analysis.candidateCount > 0
-    && analysis.viableCandidateCount === 0
-    && Object.keys(analysis.appliedSuppliedVariables).length > 0)
-    return noCandidateRuntimeResolution(row, enriched);
-  if (dynamicMode === 'infer') {
-    const inferred = inferredTarget(analysis);
-    if (inferred)
-      return resolvedRuntimeResolution(row, enriched, inferred, inferred.reasons);
-  }
-  if (!hasApplicableRuntimeVariables(evidence, options.vars)) {
-    const unresolvedReason = contextualUnresolvedReason ?? row.unresolved_reason;
-    const withSections = withEffectiveResolution(enriched, row, unresolvedReason);
+  const appliedRuntimeValues = hasApplicableRuntimeVariables(evidence, options.vars);
+  const analyzed = analyzedRuntimeResolution(
+    row, enriched, analysis, dynamicMode, appliedRuntimeValues, contextualState,
+  );
+  if (analyzed) return analyzed;
+  if (!appliedRuntimeValues) {
+    const unresolvedReason = contextualReason(contextualState) ?? row.unresolved_reason;
+    const withSections = withEffectiveResolution(
+      enriched, row, unresolvedReason, undefined, contextualState,
+    );
     return { row, evidence: withSections, unresolvedReason };
   }
-  const resolution = resolveRuntimeOperation(db, enriched, workspaceId);
+  return resolveSuppliedRuntimeOperation(db, row, enriched, workspaceId, contextualState);
+}
+
+function analyzedRuntimeResolution(
+  row: TraceGraphRow,
+  evidence: Record<string, unknown>,
+  analysis: DynamicTargetAnalysis | undefined,
+  dynamicMode: DynamicMode,
+  appliedRuntimeValues: boolean,
+  contextualState: ContextualRuntimeState | undefined,
+): RuntimeResolutionResult | undefined {
+  if (analysis && analysis.viableCandidateCount === 0
+    && Object.keys(analysis.appliedSuppliedVariables).length > 0)
+    return noCandidateRuntimeResolution(row, evidence, contextualState);
+  const inferred = dynamicMode === 'infer' ? inferredTarget(analysis) : undefined;
+  if (inferred && !isStructuralContextualBlocker(contextualState))
+    return resolvedRuntimeResolution(row, evidence, inferred, inferred.reasons);
+  if (analysis && analysis.missingVariables.length > 0 && appliedRuntimeValues) {
+    const unresolvedReason = dynamicMissingReason(analysis.missingVariables);
+    return {
+      row,
+      evidence: withEffectiveResolution(
+        evidence, row, unresolvedReason, undefined, contextualState,
+      ),
+      unresolvedReason,
+    };
+  }
+  return isStructuralContextualBlocker(contextualState)
+    ? unchangedRuntimeResolution(row, evidence, contextualState)
+    : undefined;
+}
+
+function resolveSuppliedRuntimeOperation(
+  db: Db,
+  row: TraceGraphRow,
+  evidence: Record<string, unknown>,
+  workspaceId: number | undefined,
+  contextualState: ContextualRuntimeState | undefined,
+): RuntimeResolutionResult {
+  const resolution = resolveRuntimeOperation(db, evidence, workspaceId);
   if (resolution.target)
     return resolvedRuntimeResolution(
-      row, enriched, resolution.target, resolution.reasons,
+      row, evidence, resolution.target, resolution.reasons,
     );
-  if (analysis && analysis.viableCandidateCount === 0
-    && Object.keys(analysis.appliedSuppliedVariables).length > 0)
-    return noCandidateRuntimeResolution(row, enriched);
   const unresolvedReason = runtimeUnresolvedReason(resolution);
-  return { row, evidence: withEffectiveResolution(enriched, row, unresolvedReason, resolution), unresolvedReason };
+  return {
+    row,
+    evidence: withEffectiveResolution(
+      evidence, row, unresolvedReason, resolution, contextualState,
+    ),
+    unresolvedReason,
+  };
 }
 
 function unchangedRuntimeResolution(
   row: TraceGraphRow,
   evidence: Record<string, unknown>,
-  contextualUnresolvedReason: string | undefined,
-): ReturnType<typeof runtimeResolution> {
-  const unresolvedReason = contextualUnresolvedReason ?? row.unresolved_reason;
+  contextualState: ContextualRuntimeState | undefined,
+): RuntimeResolutionResult {
+  const unresolvedReason = contextualReason(contextualState) ?? row.unresolved_reason;
   return {
     row,
-    evidence: withEffectiveResolution(evidence, row, unresolvedReason),
+    evidence: withEffectiveResolution(
+      evidence, row, unresolvedReason, undefined, contextualState,
+    ),
     unresolvedReason,
   };
 }
@@ -126,11 +181,14 @@ function unchangedRuntimeResolution(
 function noCandidateRuntimeResolution(
   row: TraceGraphRow,
   evidence: Record<string, unknown>,
-): ReturnType<typeof runtimeResolution> {
+  contextualState: ContextualRuntimeState | undefined,
+): RuntimeResolutionResult {
   const unresolvedReason = 'No candidate remained after runtime substitution';
   return {
     row,
-    evidence: withEffectiveResolution(evidence, row, unresolvedReason),
+    evidence: withEffectiveResolution(
+      evidence, row, unresolvedReason, undefined, contextualState,
+    ),
     unresolvedReason,
   };
 }
@@ -140,7 +198,7 @@ function resolvedRuntimeResolution(
   evidence: Record<string, unknown>,
   target: OperationTarget,
   reasons: string[],
-): ReturnType<typeof runtimeResolution> {
+): RuntimeResolutionResult {
   const resolvedRow = {
     ...row,
     status: 'resolved',
@@ -320,6 +378,7 @@ function effectiveResolution(
   evidence: Record<string, unknown>,
   unresolvedReason: string | undefined,
   resolution?: ReturnType<typeof resolveRuntimeOperation>,
+  contextualState?: ContextualRuntimeState,
 ): Record<string, unknown> {
   const target = resolution?.target;
   return {
@@ -334,6 +393,8 @@ function effectiveResolution(
     reasons: resolution?.reasons ?? evidence.resolutionReasons,
     unresolvedReason,
     edgeType: target ? 'REMOTE_CALL_RESOLVES_TO_OPERATION' : row.edge_type,
+    contextualBlocker: isStructuralContextualBlocker(contextualState)
+      ? contextualState : undefined,
   };
 }
 
@@ -342,11 +403,30 @@ function withEffectiveResolution(
   row: TraceGraphRow,
   unresolvedReason: string | undefined,
   resolution?: ReturnType<typeof resolveRuntimeOperation>,
+  contextualState?: ContextualRuntimeState,
 ): Record<string, unknown> {
-  const current = effectiveResolution(row, evidence, unresolvedReason, resolution);
+  const current = effectiveResolution(
+    row, evidence, unresolvedReason, resolution, contextualState,
+  );
   const rest = { ...evidence };
   delete rest.runtimeResolvedCandidate;
-  return { ...rest, effectiveResolution: current, linker: { status: current.status, confidence: current.confidence, reason: unresolvedReason, edgeType: current.edgeType } };
+  return {
+    ...rest,
+    effectiveResolution: current,
+    linker: {
+      status: current.status,
+      confidence: current.confidence,
+      reason: unresolvedReason,
+      edgeType: current.edgeType,
+      contextualBlocker: current.contextualBlocker,
+    },
+  };
+}
+
+function contextualReason(
+  state: ContextualRuntimeState | undefined,
+): string | undefined {
+  return state?.category === 'none' ? undefined : state?.message;
 }
 
 function resolveRuntimeOperation(db: Db, evidence: Record<string, unknown>, workspaceId: number | undefined): ReturnType<typeof resolveOperation> {
@@ -384,14 +464,23 @@ function evidenceWithDynamicAnalysis(
 ): Record<string, unknown> {
   const persistedCandidates = recordArray(evidence.candidates);
   const persistedScores = recordArray(evidence.candidateScores);
+  const persistedCandidateCount = numeric(evidence.persistedCandidateCount)
+    || numeric(evidence.candidateCount)
+    || persistedCandidates.length;
+  const persistedScoreCount = numeric(evidence.candidateScoreCount)
+    || persistedScores.length;
   return {
     ...evidence,
     candidates: persistedCandidates.slice(0, analysis.maxCandidates),
     candidateScores: persistedScores.slice(0, analysis.maxCandidates),
-    persistedCandidateCount: persistedCandidates.length,
+    persistedCandidateCount,
     persistedCandidateOmittedCount: Math.max(
       0,
-      persistedCandidates.length - analysis.maxCandidates,
+      persistedCandidateCount - Math.min(persistedCandidates.length, analysis.maxCandidates),
+    ),
+    persistedCandidateScoreCount: persistedScoreCount,
+    persistedCandidateScoreOmittedCount: Math.max(
+      0, persistedScoreCount - Math.min(persistedScores.length, analysis.maxCandidates),
     ),
     dynamicTargetExploration: {
       mode: analysis.mode,
@@ -410,9 +499,16 @@ function evidenceWithDynamicAnalysis(
       omittedRejectedCandidateCount: analysis.omittedRejectedCandidateCount,
       rejectedCandidates: analysis.rejectedCandidates,
       suggestedVarSets: analysis.suggestedVarSets,
+      suggestedVarSetCount: analysis.suggestedVarSetCount,
+      shownSuggestedVarSetCount: analysis.shownSuggestedVarSetCount,
+      omittedSuggestedVarSetCount: analysis.omittedSuggestedVarSetCount,
+      routingContext: analysis.routingContext,
     },
     dynamicTargetCandidates: analysis.candidates,
     dynamicTargetCandidateSuggestions: analysis.shownCandidates,
+    dynamicTargetCandidateSuggestionCount: analysis.viableCandidateCount,
+    shownDynamicTargetCandidateSuggestionCount: analysis.shownCandidateCount,
+    omittedDynamicTargetCandidateSuggestionCount: analysis.omittedCandidateCount,
     rejectedCandidates: analysis.rejectedCandidates,
     dynamicTargetInference: analysis.inference,
   };
@@ -429,6 +525,7 @@ const boundedDynamicListKeys = new Set([
   'rejectedCandidateSuggestions',
   'copyableExamples',
   'conflicts',
+  'bindingAlternatives',
 ]);
 
 function boundDynamicEvidence(
@@ -436,6 +533,7 @@ function boundDynamicEvidence(
   limit: number,
 ): Record<string, unknown> {
   const candidateCount = numeric(evidence.persistedCandidateCount)
+    || numeric(evidence.candidateCount)
     || (Array.isArray(evidence.candidates) ? evidence.candidates.length : 0);
   const projected = boundDynamicValue(evidence, limit);
   const next = parseObject(projected);

package/src/trace/implementation-hints.ts

@@ -1,4 +1,5 @@
 import type { ImplementationHint } from '../types.js';
+import { projectBounded } from '../utils/000-bounded-projection.js';
 
 interface Candidate {
   accepted?: boolean;
@@ -25,6 +26,13 @@ export interface ImplementationSelection {
   evidence: Record<string, unknown>;
 }
 
+export interface ImplementationHintSuggestionProjection {
+  suggestions: Array<Record<string, unknown>>;
+  suggestionCount: number;
+  shownSuggestionCount: number;
+  omittedSuggestionCount: number;
+}
+
 export function parseImplementationHint(value: string): ImplementationHint {
   const hint: Partial<ImplementationHint> = {};
   for (const part of value.split(',')) {
@@ -40,8 +48,9 @@ export function selectImplementation(
   rawEvidence: Record<string, unknown>,
   hints: ImplementationHint[] | undefined,
   legacyRepo: string | undefined,
+  canonicalEvidence?: Record<string, unknown>,
 ): ImplementationSelection {
-  const evidence = asEvidence(rawEvidence);
+  const evidence = asEvidence(canonicalEvidence ?? rawEvidence);
   const scoped = hints ?? [];
   const matchingHints = scoped.filter((hint) => hintMatchesEdge(hint, evidence));
   if (matchingHints.length === 0) {
@@ -50,14 +59,18 @@ export function selectImplementation(
     return { blocksAutomatic: false, evidence: { status: 'not_matched', reason, strategy: 'scoped_implementation_hint' } };
   }
   if (matchingHints.length > 1) {
+    const projection = projectBounded(matchingHints, compareHints);
     return {
       blocksAutomatic: true,
       evidence: {
         status: 'tied',
         reason: 'multiple_scoped_hints_matched_edge',
         strategy: 'scoped_implementation_hint',
-        matchedHints: matchingHints,
+        matchedHints: projection.items,
         candidateCount: matchingHints.length,
+        matchedHintCount: projection.totalCount,
+        shownMatchedHintCount: projection.shownCount,
+        omittedMatchedHintCount: projection.omittedCount,
       },
     };
   }
@@ -67,26 +80,48 @@ export function selectImplementation(
 
 export function implementationHintDiagnostic(
   selection: ImplementationSelection,
-  suggestions?: unknown,
+  suggestionEvidence?: unknown,
 ): Record<string, unknown> | undefined {
   if (!selection.blocksAutomatic || selection.methodId) return undefined;
+  const suggestions = projectedSuggestions(suggestionEvidence);
   return {
     severity: 'warning',
     code: 'implementation_hint_mismatch',
     message: 'Implementation hint did not select exactly one viable candidate',
     hintStatus: selection.evidence.status,
     candidateCount: selection.evidence.candidateCount,
-    implementationHintSuggestions: Array.isArray(suggestions) && suggestions.length > 0 ? suggestions : undefined,
+    implementationHintSuggestions: suggestions.suggestions.length > 0
+      ? suggestions.suggestions
+      : undefined,
+    implementationHintSuggestionCount: suggestions.suggestionCount,
+    shownImplementationHintSuggestionCount: suggestions.shownSuggestionCount,
+    omittedImplementationHintSuggestionCount: suggestions.omittedSuggestionCount,
     implementationSelection: selection.evidence,
   };
 }
 
 export function implementationHintSuggestions(rawEvidence: Record<string, unknown>): Array<Record<string, unknown>> {
+  return implementationHintSuggestionProjection(rawEvidence).suggestions;
+}
+
+export function implementationHintSuggestionProjection(
+  rawEvidence: Record<string, unknown>,
+): ImplementationHintSuggestionProjection {
   const evidence = asEvidence(rawEvidence);
   const accepted = (evidence.candidates ?? []).filter((candidate) => candidate.accepted);
-  if (accepted.length < 2) return [];
+  if (accepted.length < 2) {
+    return {
+      suggestions: [],
+      suggestionCount: 0,
+      shownSuggestionCount: 0,
+      omittedSuggestionCount: 0,
+    };
+  }
   const repos = selectableRepositories(accepted);
-  return accepted
+  const repositoryProjection = projectBounded(
+    repos, (left, right) => left.localeCompare(right),
+  );
+  const suggestions = accepted
     .flatMap((candidate) => {
       const repo = candidate.handlerPackage?.name;
       if (!repo || !repos.includes(repo)) return [];
@@ -96,12 +131,71 @@ export function implementationHintSuggestions(rawEvidence: Record<string, unknow
         operationPath: hint.operationPath,
         ambiguityReason: evidence.ambiguityReasons?.[0],
         candidateFamily: hint.candidateFamily,
-        selectableImplementationRepositories: repos,
+        selectableImplementationRepositories: repositoryProjection.items,
+        selectableImplementationRepositoryCount: repositoryProjection.totalCount,
+        shownSelectableImplementationRepositoryCount:
+          repositoryProjection.shownCount,
+        omittedSelectableImplementationRepositoryCount:
+          repositoryProjection.omittedCount,
         implementationRepo: repo,
         hint,
         cli: `--implementation-hint ${hintString(hint)}`,
       }];
     });
+  const projection = projectBounded(suggestions, compareSuggestion);
+  return {
+    suggestions: projection.items,
+    suggestionCount: projection.totalCount,
+    shownSuggestionCount: projection.shownCount,
+    omittedSuggestionCount: projection.omittedCount,
+  };
+}
+
+function projectedSuggestions(value: unknown): ImplementationHintSuggestionProjection {
+  const evidence = objectRecord(value);
+  const values = Array.isArray(value)
+    ? recordSuggestions(value)
+    : recordSuggestions(evidence.implementationHintSuggestions);
+  const projection = projectBounded(values, compareSuggestion);
+  const total = Math.max(
+    numericValue(evidence.implementationHintSuggestionCount),
+    projection.totalCount,
+  );
+  return {
+    suggestions: projection.items,
+    suggestionCount: total,
+    shownSuggestionCount: projection.shownCount,
+    omittedSuggestionCount: Math.max(0, total - projection.shownCount),
+  };
+}
+
+function compareHints(left: ImplementationHint, right: ImplementationHint): number {
+  return hintString(left).localeCompare(hintString(right));
+}
+
+function compareSuggestion(
+  left: Record<string, unknown>,
+  right: Record<string, unknown>,
+): number {
+  return String(left.cli ?? '').localeCompare(String(right.cli ?? ''))
+    || String(left.implementationRepo ?? '').localeCompare(
+      String(right.implementationRepo ?? ''),
+    );
+}
+
+function objectRecord(value: unknown): Record<string, unknown> {
+  return isRecord(value) ? value : {};
+}
+
+function recordSuggestions(value: unknown): Array<Record<string, unknown>> {
+  return Array.isArray(value)
+    ? value.filter((item): item is Record<string, unknown> =>
+        Boolean(item && typeof item === 'object' && !Array.isArray(item)))
+    : [];
+}
+
+function numericValue(value: unknown): number {
+  return typeof value === 'number' && Number.isFinite(value) ? value : 0;
 }
 
 function selectableRepositories(candidates: Candidate[]): string[] {
@@ -219,5 +313,51 @@ function legacyHint(implementationRepo: string): ImplementationHint {
 }
 
 function asEvidence(value: Record<string, unknown>): EdgeEvidence {
-  return value as EdgeEvidence;
+  return {
+    servicePath: stringValue(value.servicePath),
+    operationPath: stringValue(value.operationPath),
+    ambiguityReasons: stringArray(value.ambiguityReasons),
+    candidateFamilies: candidateFamilies(value.candidateFamilies),
+    candidates: candidates(value.candidates),
+    modelPackage: packageValue(value.modelPackage),
+  };
+}
+
+function candidates(value: unknown): Candidate[] {
+  return recordSuggestions(value).map((candidate) => ({
+    accepted: candidate.accepted === true,
+    methodId: numericValue(candidate.methodId) || undefined,
+    sourceFile: stringValue(candidate.sourceFile),
+    handlerPackage: packageValue(candidate.handlerPackage),
+    modelPackage: packageValue(candidate.modelPackage),
+    servicePath: stringValue(candidate.servicePath),
+    operationPath: stringValue(candidate.operationPath),
+  }));
+}
+
+function candidateFamilies(value: unknown): Array<{ packageName?: string }> {
+  return recordSuggestions(value).map((family) => ({
+    packageName: stringValue(family.packageName),
+  }));
+}
+
+function packageValue(value: unknown): { name?: string; packageName?: string } | undefined {
+  const candidate = objectRecord(value);
+  const name = stringValue(candidate.name);
+  const packageName = stringValue(candidate.packageName);
+  return name || packageName ? { name, packageName } : undefined;
+}
+
+function stringArray(value: unknown): string[] {
+  return Array.isArray(value)
+    ? value.filter((item): item is string => typeof item === 'string')
+    : [];
+}
+
+function stringValue(value: unknown): string | undefined {
+  return typeof value === 'string' ? value : undefined;
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return Boolean(value && typeof value === 'object' && !Array.isArray(value));
 }

package/src/trace/selectors.ts

@@ -1,5 +1,9 @@
 import type { Db } from '../db/connection.js';
 import type { TraceStart } from '../types.js';
+import {
+  projectBounded,
+  type BoundedProjection,
+} from '../utils/000-bounded-projection.js';
 
 export interface SelectorSourceScope {
   files?: Set<string>;
@@ -65,14 +69,27 @@ export function selectorRepoAmbiguousDiagnostic(
       return [`--repo ${candidate.packageName}`];
     return [];
   });
+  const candidateProjection = projectBounded(candidates, (left, right) =>
+    left.name.localeCompare(right.name)
+    || String(left.packageName ?? '').localeCompare(String(right.packageName ?? ''))
+    || left.id - right.id);
+  const suggestionProjection = projectBounded(
+    [...new Set(suggestions)], (left, right) => left.localeCompare(right),
+  );
   return {
     severity: 'warning',
     code: 'selector_repo_ambiguous',
     message: `Repository selector matched multiple indexed repositories: ${requested}`,
     selectorKind: 'repo',
     requestedRepository: requested,
-    candidates,
-    selectorSuggestions: [...new Set(suggestions)].sort(),
+    candidates: candidateProjection.items,
+    candidateCount: candidateProjection.totalCount,
+    shownCandidateCount: candidateProjection.shownCount,
+    omittedCandidateCount: candidateProjection.omittedCount,
+    selectorSuggestions: suggestionProjection.items,
+    selectorSuggestionCount: suggestionProjection.totalCount,
+    shownSelectorSuggestionCount: suggestionProjection.shownCount,
+    omittedSelectorSuggestionCount: suggestionProjection.omittedCount,
     remediation: suggestions.length > 0
       ? 'Use one of the unique --repo selectors shown.'
       : 'Repository names and package names must be unique before this selector can be traced safely.',
@@ -250,6 +267,8 @@ function operationHandlerScope(
       ? [`--repo ${candidate.repoName} --handler ${candidate.className}`]
       : [];
   });
+  const projection = boundedSelectorCandidates(candidates);
+  const suggestionProjection = boundedSelectorSuggestions(suggestions);
   return { diagnostics: [{
     severity: 'warning',
     code: 'trace_start_ambiguous',
@@ -258,8 +277,14 @@ function operationHandlerScope(
     normalizedSelectorValue: requested,
     resolutionStage: 'handler',
     resolutionStatus: 'ambiguous_handler_operation',
-    candidates,
-    selectorSuggestions: [...new Set(suggestions)].sort(),
+    candidates: projection.items,
+    candidateCount: projection.totalCount,
+    shownCandidateCount: projection.shownCount,
+    omittedCandidateCount: projection.omittedCount,
+    selectorSuggestions: suggestionProjection.items,
+    selectorSuggestionCount: suggestionProjection.totalCount,
+    shownSelectorSuggestionCount: suggestionProjection.shownCount,
+    omittedSelectorSuggestionCount: suggestionProjection.omittedCount,
     remediation: 'Select one handler class explicitly; no operation was chosen automatically.',
   }] };
 }
@@ -358,6 +383,8 @@ function handlerSelectorAmbiguity(
       return [`${repoName ? `--repo ${repoName} ` : ''}--handler ${candidate.className}`];
     return [];
   });
+  const projection = boundedSelectorCandidates(candidates);
+  const suggestionProjection = boundedSelectorSuggestions(suggestions);
   return {
     severity: 'warning',
     code: 'trace_start_ambiguous',
@@ -366,8 +393,14 @@ function handlerSelectorAmbiguity(
     requestedHandler: requested,
     resolutionStage: 'handler',
     resolutionStatus: 'ambiguous_handler',
-    candidates,
-    selectorSuggestions: [...new Set(suggestions)].sort(),
+    candidates: projection.items,
+    candidateCount: projection.totalCount,
+    shownCandidateCount: projection.shownCount,
+    omittedCandidateCount: projection.omittedCount,
+    selectorSuggestions: suggestionProjection.items,
+    selectorSuggestionCount: suggestionProjection.totalCount,
+    shownSelectorSuggestionCount: suggestionProjection.shownCount,
+    omittedSelectorSuggestionCount: suggestionProjection.omittedCount,
     remediation: suggestions.length > 0
       ? 'Use one of the scoped handler selectors shown.'
       : 'No current CLI selector uniquely identifies these duplicate handler classes.',
@@ -510,6 +543,9 @@ export function ambiguousStartDiagnostic(
     .flatMap((row) => typeof row.servicePath === 'string'
       ? [`--service ${row.servicePath}`]
       : []))].sort();
+  const projection = boundedSelectorCandidates(candidates);
+  const serviceProjection = boundedSelectorSuggestions(serviceSuggestions);
+  const selectorProjection = boundedSelectorSuggestions(fullSelectorSuggestions(candidates));
   return {
     severity: 'warning',
     code: 'trace_start_ambiguous',
@@ -517,11 +553,40 @@ export function ambiguousStartDiagnostic(
     normalizedSelectorValue: requested,
     resolutionStage: 'operation',
     resolutionStatus: 'ambiguous_operation',
-    candidates,
-    serviceSuggestions,
-    selectorSuggestions: fullSelectorSuggestions(candidates),
+    candidates: projection.items,
+    candidateCount: projection.totalCount,
+    shownCandidateCount: projection.shownCount,
+    omittedCandidateCount: projection.omittedCount,
+    serviceSuggestions: serviceProjection.items,
+    serviceSuggestionCount: serviceProjection.totalCount,
+    shownServiceSuggestionCount: serviceProjection.shownCount,
+    omittedServiceSuggestionCount: serviceProjection.omittedCount,
+    selectorSuggestions: selectorProjection.items,
+    selectorSuggestionCount: selectorProjection.totalCount,
+    shownSelectorSuggestionCount: selectorProjection.shownCount,
+    omittedSelectorSuggestionCount: selectorProjection.omittedCount,
   };
 }
+
+function boundedSelectorCandidates(
+  candidates: Array<Record<string, unknown>>,
+): BoundedProjection<Record<string, unknown>> {
+  return projectBounded(candidates, (left, right) =>
+    String(left.repoName ?? '').localeCompare(String(right.repoName ?? ''))
+    || String(left.servicePath ?? '').localeCompare(String(right.servicePath ?? ''))
+    || String(left.className ?? '').localeCompare(String(right.className ?? ''))
+    || String(left.sourceFile ?? '').localeCompare(String(right.sourceFile ?? ''))
+    || Number(left.sourceLine ?? 0) - Number(right.sourceLine ?? 0)
+    || Number(left.handlerClassId ?? left.operationId ?? 0)
+      - Number(right.handlerClassId ?? right.operationId ?? 0));
+}
+
+function boundedSelectorSuggestions(
+  suggestions: string[],
+): BoundedProjection<string> {
+  return projectBounded([...new Set(suggestions)], (left, right) =>
+    left.localeCompare(right));
+}
 function fullSelectorSuggestions(
   candidates: Array<Record<string, unknown>>,
 ): string[] {