labre-mcp 0.1.0

package/dist/frameworks/wardley/chain/_legacy/write/component/lib/verification/dual-verification-orchestrator.mjs

@@ -0,0 +1,288 @@
+// Dual-verification orchestrator for solution vs capability classification
+//
+// Accepts a component name and partial classification context, then runs a
+// multi-tier verification pipeline to determine whether the component is a
+// concrete SOLUTION (Kubernetes, Salesforce...) or an abstract CAPABILITY
+// (container orchestration, CRM...).
+//
+// Pipeline (ordered by cost, short-circuits when confident):
+//   Tier 1: Naming convention heuristics     (free, sub-ms)
+//           → If confidence >= 90%, return immediately
+//   Tier 2: LLM semantic classification      (moderate cost)
+//           → Invoked when naming confidence < 90% and llmCall available
+//   Tier 3: Web search evidence              (higher cost, highest accuracy)
+//           → Invoked when LLM does not resolve above threshold
+//   Tier 4: Reconciliation                   (combine all available signals)
+//
+// The result includes the verified classification plus the raw tier results
+// for traceability. It also carries the ComponentTypeDetection from the
+// existing solution-capability-router so downstream routing can use it
+// without re-computing.
+//
+// This module does NOT modify any existing strategy files or the capability
+// evaluation pipeline. It sits AFTER the classification gate and BEFORE
+// strategy dispatch — called by estimate-evolution.mjs as a replacement for
+// the direct detectComponentType() call when dual verification is desired.
+//
+// Usage:
+//   import { verifyClassification } from './dual-verification-orchestrator.mjs';
+//
+//   const result = await verifyClassification('Kubernetes', {
+//     description: 'Container platform for microservices',
+//     llmCall: myLlmCall,
+//   });
+//   // → { classification: 'solution', confidence: 0.98, verified: true, ... }
+import { detectComponentType, COMPONENT_TYPE, CONFIDENCE_THRESHOLD, } from '#lib/component-detection.mjs';
+import { classifySolutionLLM } from '#work-on-evolution/write/routing/detect-solution.mjs';
+import { verifyViaWebSearch, combineWithPriorResult } from './web-search-verification.mjs';
+import { logDebug } from '#lib/mcp-notifications.mjs';
+import { raceWithTimeout, buildSuccessSignal, buildTimeoutSignal, buildErrorSignal, buildSkippedSignal, } from './verification-signals.mjs';
+import { toIntermediateResult, reconcileTwoTiers, reconcileSignalPair, buildResult, } from './verification-reconciliation.mjs';
+// ─── Constants ────────────────────────────────────────────────────────────────
+const TOOL = 'dual-verification';
+/**
+ * Confidence thresholds for each tier transition.
+ *
+ * - NAMING_SKIP: If naming convention confidence >= this, skip LLM tier.
+ *   Reuses the CONFIDENCE_THRESHOLD from solution-capability-router (0.90).
+ * - LLM_SKIP: If combined naming+LLM confidence >= this, skip web search tier.
+ * - MIN_VERIFIED: Minimum confidence to consider the classification "verified".
+ */
+export const THRESHOLDS = {
+    NAMING_SKIP: CONFIDENCE_THRESHOLD, // 0.90
+    LLM_SKIP: 0.85,
+    MIN_VERIFIED: 0.70,
+};
+// ─── Type Definitions ────────────────────────────────────────────────────────
+/**
+ * @typedef {Object} ClassificationContext
+ * @property {string}  [description]    - Business/usage context for the component
+ * @property {string}  [type]           - OWM DSL type hint (component, pipeline, anchor, etc.)
+ * @property {string}  [capability]     - Already-identified underlying capability (if any)
+ * @property {string}  [nature]         - Already-identified capability nature (if any)
+ * @property {function(string): Promise<string>} [llmCall]
+ *   LLM call function for Tier 2 fallback (from llm-call.mjs).
+ *   If not provided, the pipeline stops after Tier 1 naming convention.
+ * @property {function(string): Promise<string>} [webSearchCall]
+ *   Web search call function for Tier 3 evidence (from web-search-verification.mjs).
+ *   If not provided, the pipeline stops after Tier 2 LLM.
+ * @property {boolean} [skipLLM=false]  - Force-skip the LLM tier (e.g. for cost control)
+ * @property {boolean} [skipWebSearch=false] - Force-skip the web search tier
+ */
+/**
+ * @typedef {Object} VerifiedClassificationResult
+ * @property {'solution'|'capability'} classification - Verified component type
+ * @property {number}  confidence      - Final confidence score (0-1)
+ * @property {string}  method          - Detection method chain used:
+ *   'naming' | 'naming+llm' | 'naming+web-search' | 'naming+llm+web-search'
+ * @property {string}  reasoning       - Human-readable explanation of the final classification
+ * @property {boolean} isSolution      - Convenience flag: classification === 'solution'
+ * @property {boolean} verified        - true if at least two tiers agreed or a single tier had >= 90% confidence
+ * @property {string[]} tiersUsed      - Which tiers were actually invoked: ['naming'], ['naming', 'llm'], etc.
+ * @property {import('../routing/solution-capability-router.mjs').ComponentTypeDetection} routingDetection
+ *   - Full detection result from Tier 1 (solution-capability-router), preserved for downstream routing
+ * @property {{ useSolutionStrategies: boolean, useCapabilityStrategies: boolean, mode: string }} routingTargets
+ *   - Pre-computed routing targets based on the verified classification
+ * @property {Object}  [namingResult]  - Raw result from Tier 1 naming convention
+ * @property {Object}  [llmResult]     - Raw result from Tier 2 LLM (if invoked)
+ * @property {Object}  [webSearchResult] - Raw result from Tier 3 web search (if invoked)
+ */
+// ─── Core Orchestrator ──────────────────────────────────────────────────────
+/**
+ * Dual-verification orchestrator: classify a component as solution or capability
+ * using a multi-tier verification pipeline.
+ *
+ * The pipeline short-circuits at the earliest tier that produces a high-confidence
+ * result, minimizing cost. Each subsequent tier adds evidence to increase
+ * confidence or resolve ambiguity.
+ *
+ * Verification logic:
+ *   - Tier 1 alone at >= 90% confidence → verified = true (dictionary match)
+ *   - Tier 1 + Tier 2 agree → verified = true (boosted confidence)
+ *   - Tier 1 + Tier 2 disagree → Tier 3 invoked as tiebreaker (if available)
+ *   - Any final confidence >= MIN_VERIFIED (0.70) → verified = true
+ *
+ * @param {string} componentName - Component name to classify
+ * @param {ClassificationContext} [context={}] - Partial classification context
+ * @returns {Promise<VerifiedClassificationResult>} Verified classification result
+ */
+// any: context bag (description, llmCall, webSearchCall, timeoutMs, etc.) — heterogeneous result shape
+export async function verifyClassification(componentName, context = {}) {
+    const name = (componentName || '').trim();
+    if (!name) {
+        return buildResult({
+            classification: COMPONENT_TYPE.CAPABILITY,
+            confidence: 0,
+            method: 'error',
+            reasoning: 'Empty or invalid component name',
+            verified: false,
+            tiersUsed: [],
+            routingDetection: detectComponentType('', ''),
+        });
+    }
+    const description = context.description || '';
+    // ── Tier 1: Naming convention heuristics ─────────────────────────────────
+    logDebug(TOOL, `Tier 1 (naming) for "${name}"...`);
+    const namingResult = detectComponentType(name, description);
+    const tiersUsed = ['naming'];
+    logDebug(TOOL, `Tier 1 result: type=${namingResult.type}, confidence=${namingResult.confidence}, ` +
+        `method=${namingResult.method}, needsFallback=${namingResult.needsFallback}`);
+    // Short-circuit: high-confidence naming match → no further verification needed
+    if (namingResult.confidence >= THRESHOLDS.NAMING_SKIP) {
+        logDebug(TOOL, `Tier 1 sufficient (confidence=${namingResult.confidence} >= ${THRESHOLDS.NAMING_SKIP}) — skipping LLM/web`);
+        return buildResult({
+            classification: namingResult.type,
+            confidence: namingResult.confidence,
+            method: 'naming',
+            reasoning: namingResult.reason,
+            verified: true,
+            tiersUsed,
+            routingDetection: namingResult,
+            namingResult,
+        });
+    }
+    // ── Tier 2: LLM semantic classification ──────────────────────────────────
+    let llmResult = null;
+    let currentBest = toIntermediateResult(namingResult);
+    const canUseLLM = !context.skipLLM && typeof context.llmCall === 'function';
+    if (canUseLLM) {
+        logDebug(TOOL, `Tier 2 (LLM) for "${name}" (naming confidence=${namingResult.confidence} < ${THRESHOLDS.NAMING_SKIP})...`);
+        tiersUsed.push('llm');
+        try {
+            llmResult = await classifySolutionLLM(name, context.llmCall, {
+                context: description,
+            });
+            logDebug(TOOL, `Tier 2 result: ${llmResult.classification} (confidence=${llmResult.confidence})`);
+            // Reconcile naming + LLM
+            currentBest = reconcileTwoTiers(currentBest, {
+                classification: llmResult.classification,
+                confidence: llmResult.confidence,
+                method: 'llm',
+                reasoning: llmResult.reasoning,
+            });
+            logDebug(TOOL, `After reconciliation: ${currentBest.classification} (confidence=${currentBest.confidence})`);
+            // Short-circuit: if combined result is above LLM_SKIP threshold, stop
+            if (currentBest.confidence >= THRESHOLDS.LLM_SKIP) {
+                logDebug(TOOL, `Tier 1+2 sufficient (confidence=${currentBest.confidence} >= ${THRESHOLDS.LLM_SKIP}) — skipping web search`);
+                return buildResult({
+                    ...currentBest,
+                    method: 'naming+llm',
+                    verified: currentBest.confidence >= THRESHOLDS.MIN_VERIFIED,
+                    tiersUsed,
+                    routingDetection: namingResult,
+                    namingResult,
+                    llmResult,
+                });
+            }
+        }
+        catch (err) {
+            logDebug(TOOL, `Tier 2 (LLM) failed for "${name}": ${toErrorMessage(err)}`);
+            llmResult = { error: toErrorMessage(err) };
+        }
+    }
+    else {
+        logDebug(TOOL, `Tier 2 (LLM) skipped: ${context.skipLLM ? 'forced skip' : 'no llmCall provided'}`);
+    }
+    // ── Tier 3: Web search evidence ──────────────────────────────────────────
+    let webSearchResult = null;
+    const canUseWebSearch = !context.skipWebSearch &&
+        (typeof context.webSearchCall === 'function' || canUseLLM);
+    if (canUseWebSearch && currentBest.confidence < THRESHOLDS.LLM_SKIP) {
+        logDebug(TOOL, `Tier 3 (web search) for "${name}" (combined confidence=${currentBest.confidence} < ${THRESHOLDS.LLM_SKIP})...`);
+        tiersUsed.push('web-search');
+        try {
+            // any: web search options (Claude Agent SDK loose shape)
+            const webSearchOptions = {};
+            if (typeof context.webSearchCall === 'function') {
+                webSearchOptions.webSearchCall = context.webSearchCall;
+            }
+            if (description) {
+                webSearchOptions.context = description;
+            }
+            webSearchResult = await verifyViaWebSearch(name, webSearchOptions);
+            logDebug(TOOL, `Tier 3 result: ${webSearchResult.classification} (confidence=${webSearchResult.confidence})`);
+            // Combine web search with current best using the existing combiner
+            const combined = combineWithPriorResult(currentBest, webSearchResult);
+            currentBest = {
+                classification: combined.classification,
+                confidence: combined.confidence,
+                method: combined.method,
+                reasoning: combined.reasoning,
+            };
+            logDebug(TOOL, `After web search reconciliation: ${currentBest.classification} (confidence=${currentBest.confidence})`);
+        }
+        catch (err) {
+            logDebug(TOOL, `Tier 3 (web search) failed for "${name}": ${toErrorMessage(err)}`);
+            webSearchResult = { error: toErrorMessage(err) };
+        }
+    }
+    else {
+        logDebug(TOOL, `Tier 3 (web search) skipped: ${context.skipWebSearch ? 'forced skip' : currentBest.confidence >= THRESHOLDS.LLM_SKIP ? 'confidence sufficient' : 'no search backend'}`);
+    }
+    // ── Final result ─────────────────────────────────────────────────────────
+    const methodChain = tiersUsed.join('+');
+    return buildResult({
+        classification: currentBest.classification,
+        confidence: currentBest.confidence,
+        method: methodChain || currentBest.method,
+        reasoning: currentBest.reasoning,
+        verified: currentBest.confidence >= THRESHOLDS.MIN_VERIFIED,
+        tiersUsed,
+        routingDetection: namingResult,
+        namingResult,
+        llmResult,
+        webSearchResult,
+    });
+}
+// ─── Reconciliation Helpers ─────────────────────────────────────────────────
+// toIntermediateResult, reconcileTwoTiers, buildResult — imported from ./verification-reconciliation.mjs
+// ─── Concurrent Dual-Verification ───────────────────────────────────────────
+// Extracted to ./concurrent-verification.mjs for single-responsibility.
+// Re-exported here for backward compatibility.
+import { verifyConcurrent, verifyConcurrentFull, DEFAULT_SIGNAL_TIMEOUT_MS, } from './concurrent-verification.mjs';
+import { toErrorMessage } from '#lib/errors.mjs';
+export { verifyConcurrent, verifyConcurrentFull };
+// ─── Convenience: classify without fallback ─────────────────────────────────
+/**
+ * Quick classification using only Tier 1 naming convention (no LLM, no web search).
+ *
+ * This is a thin wrapper around detectComponentType() that returns the same
+ * VerifiedClassificationResult shape for API consistency.
+ *
+ * Useful for hot paths where cost must be zero and the caller can tolerate
+ * lower confidence on unknown components.
+ *
+ * @param {string} componentName - Component name to classify
+ * @param {string} [description] - Optional business context
+ * @returns {VerifiedClassificationResult}
+ */
+export function classifyNamingOnly(componentName, description = '') {
+    const name = (componentName || '').trim();
+    const namingResult = detectComponentType(name, description);
+    return buildResult({
+        classification: namingResult.type,
+        confidence: namingResult.confidence,
+        method: 'naming',
+        reasoning: namingResult.reason,
+        verified: namingResult.confidence >= THRESHOLDS.NAMING_SKIP,
+        tiersUsed: ['naming'],
+        routingDetection: namingResult,
+        namingResult,
+    });
+}
+// ─── Re-exports for consumer convenience ────────────────────────────────────
+export { COMPONENT_TYPE, CONFIDENCE_THRESHOLD };
+/**
+ * Exported for testing: signal builders and reconciliation.
+ * These are implementation details exposed to enable thorough unit testing.
+ */
+export const _internal = {
+    buildSuccessSignal,
+    buildTimeoutSignal,
+    buildErrorSignal,
+    buildSkippedSignal,
+    reconcileSignalPair,
+    raceWithTimeout,
+    DEFAULT_SIGNAL_TIMEOUT_MS,
+};
+//# sourceMappingURL=dual-verification-orchestrator.mjs.map

package/dist/frameworks/wardley/chain/_legacy/write/component/lib/verification/dual-verification-orchestrator.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"dual-verification-orchestrator.mjs","sourceRoot":"","sources":["../../../../../../../../../src/frameworks/wardley/chain/_legacy/write/component/lib/verification/dual-verification-orchestrator.mts"],"names":[],"mappings":"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"}

package/dist/frameworks/wardley/chain/_legacy/write/component/lib/verification/signal-combiner.d.mts

@@ -0,0 +1,131 @@
+import type { VerificationSignal, CombinedSignalResult } from '#types/pipeline.mjs';
+/** Component type constants (mirroring solution-capability-router) */
+export declare const COMPONENT_TYPE: {
+    SOLUTION: string;
+    CAPABILITY: string;
+};
+/**
+ * Confidence adjustment parameters.
+ *
+ * These are tuned to match the existing reconciliation logic in
+ * dual-verification-orchestrator.mjs and web-search-verification.mjs,
+ * ensuring consistent behavior across the codebase.
+ */
+export declare const COMBINATION_PARAMS: {
+    /** Bonus added when both signals agree (on top of their average) */
+    AGREEMENT_BONUS: number;
+    /** Maximum confidence after combination (prevents over-confidence) */
+    MAX_CONFIDENCE: number;
+    /** Penalty applied when signals disagree (subtracted from winner) */
+    DISAGREEMENT_PENALTY: number;
+    /** Minimum confidence floor after disagreement penalty */
+    DISAGREEMENT_FLOOR: number;
+    /** Weight given to LLM signal when both are present (web search gets 1 - this) */
+    LLM_WEIGHT: number;
+    /** Weight given to web search signal when both are present */
+    WEB_SEARCH_WEIGHT: number;
+    /** Minimum confidence for a signal to be considered "usable" */
+    MIN_SIGNAL_CONFIDENCE: number;
+    /** Confidence degradation factor when a signal is missing/failed */
+    MISSING_SIGNAL_DEGRADATION: number;
+};
+/**
+ * Signal status values.
+ * Matches the VerificationSignal status enum from dual-verification-orchestrator.
+ */
+export declare const SIGNAL_STATUS: {
+    SUCCESS: string;
+    TIMEOUT: string;
+    ERROR: string;
+    SKIPPED: string;
+};
+/**
+ * @typedef {Object} ClassificationSignal
+ * @property {'solution'|'capability'|null} classification - Classified component type (null if failed)
+ * @property {number}    confidence  - Confidence score (0-1), 0 if failed/unavailable
+ * @property {string}    method      - Signal source identifier: 'llm', 'web-search', 'naming', etc.
+ * @property {string}    [reasoning] - Human-readable explanation
+ * @property {'success'|'timeout'|'error'|'skipped'} [status] - Signal outcome
+ * @property {number}    [durationMs] - Wall-clock time for this signal
+ * @property {Object}    [raw]       - Raw result from the verification backend
+ * @property {string}    [error]     - Error message (when status is 'error' or 'timeout')
+ */
+/**
+ * @typedef {Object} CombinedClassificationResult
+ * @property {'solution'|'capability'} classification - Final combined classification
+ * @property {number}    confidence   - Combined confidence score (0-1)
+ * @property {string}    method       - Method chain describing which signals contributed
+ * @property {string}    reasoning    - Combined human-readable reasoning
+ * @property {'agreement'|'disagreement'|'single-signal'|'no-signal'} mergeCase
+ *   Which of the three merge cases was applied
+ * @property {boolean}   verified     - true if confidence >= MIN_VERIFIED threshold
+ * @property {boolean}   isSolution   - Convenience flag: classification === 'solution'
+ * @property {Object}    [signals]    - Both input signals preserved for traceability
+ * @property {ClassificationSignal} [signals.llm]       - LLM signal as received
+ * @property {ClassificationSignal} [signals.webSearch]  - Web search signal as received
+ */
+/**
+ * Check if a signal is usable (successful with a valid classification).
+ *
+ * A signal is usable when:
+ *   - status is 'success' (or status field is absent, for backward compat)
+ *   - classification is a non-null string ('solution' or 'capability')
+ *   - confidence is a positive number above the minimum threshold
+ *
+ * @param {ClassificationSignal} signal - Signal to check
+ * @returns {boolean} true if the signal provides a usable classification
+ */
+export declare function isSignalUsable(signal: VerificationSignal | null | undefined): boolean;
+/**
+ * Combine LLM classification signal and web search signal into a single
+ * solution-or-capability determination.
+ *
+ * Merge cases (handled in order):
+ *
+ *   **Case 1: Agreement** (both usable, same classification)
+ *     Confidence = avg(llm, webSearch) + AGREEMENT_BONUS (capped at MAX_CONFIDENCE)
+ *     → High confidence because independent signals corroborate each other
+ *
+ *   **Case 2: Disagreement** (both usable, different classification)
+ *     Winner = signal with higher confidence
+ *     Confidence = max(weightedLlm, weightedWeb) - DISAGREEMENT_PENALTY (floor at DISAGREEMENT_FLOOR)
+ *     → Lower confidence because the signals contradict; fallback to the stronger signal
+ *     → When confidences are close (within 0.10), additional penalty applied
+ *
+ *   **Case 3: Partial/missing** (one or both signals not usable)
+ *     - One signal usable → use it, apply MISSING_SIGNAL_DEGRADATION factor
+ *     - Neither usable → default to capability with confidence 0
+ *
+ * @param {ClassificationSignal} llmSignal - LLM classification signal
+ * @param {ClassificationSignal} webSearchSignal - Web search classification signal
+ * @param {Object} [options={}]
+ * @param {number} [options.agreementBonus=0.10]       - Override agreement bonus
+ * @param {number} [options.disagreementPenalty=0.10]   - Override disagreement penalty
+ * @param {number} [options.maxConfidence=0.98]         - Override max confidence cap
+ * @param {number} [options.disagreementFloor=0.45]     - Override minimum after disagreement
+ * @param {number} [options.llmWeight=0.45]             - Override LLM weight in disagreement
+ * @param {number} [options.webSearchWeight=0.55]       - Override web search weight in disagreement
+ * @param {number} [options.minVerified=0.70]           - Min confidence for verified flag
+ * @returns {CombinedClassificationResult} Combined classification with confidence
+ */
+export declare function combineSignals(llmSignal: VerificationSignal | null, webSearchSignal: VerificationSignal | null, options?: any): CombinedSignalResult;
+/**
+ * Combine three signals: naming convention + LLM + web search.
+ *
+ * This is the full integration point for estimate-evolution.mjs when all
+ * three detection tiers have run. The naming signal carries the Tier 1
+ * result from solution-capability-router.mjs.
+ *
+ * Algorithm:
+ *   1. First combine LLM + web search using combineSignals()
+ *   2. Then reconcile the combined result with the naming signal
+ *      using a two-stage combination that preserves agreement/disagreement logic
+ *
+ * @param {ClassificationSignal} namingSignal     - Naming convention signal (Tier 1)
+ * @param {ClassificationSignal} llmSignal        - LLM classification signal (Tier 2)
+ * @param {ClassificationSignal} webSearchSignal  - Web search signal (Tier 3)
+ * @param {Object} [options={}]                   - Same options as combineSignals
+ * @returns {CombinedClassificationResult} Combined classification from all three signals
+ */
+export declare function combineAllSignals(namingSignal: VerificationSignal | null, llmSignal: VerificationSignal | null, webSearchSignal: VerificationSignal | null, options?: any): CombinedSignalResult;
+//# sourceMappingURL=signal-combiner.d.mts.map

package/dist/frameworks/wardley/chain/_legacy/write/component/lib/verification/signal-combiner.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"signal-combiner.d.mts","sourceRoot":"","sources":["../../../../../../../../../src/frameworks/wardley/chain/_legacy/write/component/lib/verification/signal-combiner.mts"],"names":[],"mappings":"AAkBA,OAAO,KAAK,EAAE,kBAAkB,EAAE,oBAAoB,EAAE,MAAM,qBAAqB,CAAC;AAMpF,sEAAsE;AACtE,eAAO,MAAM,cAAc;;;CAG1B,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,kBAAkB;IAC7B,oEAAoE;;IAEpE,sEAAsE;;IAEtE,qEAAqE;;IAErE,0DAA0D;;IAE1D,kFAAkF;;IAElF,8DAA8D;;IAE9D,gEAAgE;;IAEhE,oEAAoE;;CAErE,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,aAAa;;;;;CAKzB,CAAC;AAIF;;;;;;;;;;GAUG;AAEH;;;;;;;;;;;;;GAaG;AAIH;;;;;;;;;;GAUG;AACH,wBAAgB,cAAc,CAAC,MAAM,EAAE,kBAAkB,GAAG,IAAI,GAAG,SAAS,GAAG,OAAO,CAgBrF;AAoCD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AAEH,wBAAgB,cAAc,CAAC,SAAS,EAAE,kBAAkB,GAAG,IAAI,EAAE,eAAe,EAAE,kBAAkB,GAAG,IAAI,EAAE,OAAO,GAAE,GAAQ,GAAG,oBAAoB,CAuIxJ;AAID;;;;;;;;;;;;;;;;;GAiBG;AAEH,wBAAgB,iBAAiB,CAAC,YAAY,EAAE,kBAAkB,GAAG,IAAI,EAAE,SAAS,EAAE,kBAAkB,GAAG,IAAI,EAAE,eAAe,EAAE,kBAAkB,GAAG,IAAI,EAAE,OAAO,GAAE,GAAQ,GAAG,oBAAoB,CA2EpM"}