agentic-qe 3.9.9 → 3.9.10

package/dist/routing/advisor/redaction.js

@@ -0,0 +1,187 @@
+/**
+ * Secrets / PII Redaction Pre-Flight
+ * ADR-092 Phase 1: mandatory before non-self-hosted advisors see the transcript
+ *
+ * Scans transcript content for credential patterns, API keys, PII, and other
+ * sensitive data. Replaces matches with typed redaction markers. Returns the
+ * list of redaction categories applied so the audit log can record them.
+ *
+ * Three modes:
+ *   strict   — redacts credentials + PII + env values (default)
+ *   balanced — redacts credentials + env values only
+ *   off      — no redaction (rejected for non-self-hosted providers by MultiModelExecutor)
+ */
+const PATTERNS = [
+    {
+        category: 'aws_key',
+        regex: /\b(AKIA[0-9A-Z]{16})\b/g,
+        replacement: '<REDACTED:aws_key>',
+        modes: ['strict', 'balanced'],
+    },
+    {
+        category: 'env_value',
+        regex: /^([A-Z][A-Z0-9_]{2,})=(.+)$/gm,
+        replacement: '$1=<REDACTED:env_value>',
+        modes: ['strict', 'balanced'],
+    },
+    {
+        category: 'api_key_header',
+        regex: /(Authorization:\s*Bearer\s+)\S+/gi,
+        replacement: '$1<REDACTED:api_key>',
+        modes: ['strict', 'balanced'],
+    },
+    {
+        category: 'api_key_header',
+        regex: /(x-api-key:\s*)\S+/gi,
+        replacement: '$1<REDACTED:api_key>',
+        modes: ['strict', 'balanced'],
+    },
+    {
+        category: 'private_key',
+        regex: /-----BEGIN\s[\w\s]*PRIVATE KEY-----[\s\S]*?-----END\s[\w\s]*PRIVATE KEY-----/g,
+        replacement: '<REDACTED:private_key>',
+        modes: ['strict', 'balanced'],
+    },
+    {
+        category: 'jwt',
+        regex: /\beyJ[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}\b/g,
+        replacement: '<REDACTED:jwt>',
+        modes: ['strict', 'balanced'],
+    },
+    {
+        category: 'github_token',
+        regex: /\b(ghp_|gho_|ghs_|ghr_|github_pat_)[A-Za-z0-9_]{16,}\b/g,
+        replacement: '<REDACTED:github_token>',
+        modes: ['strict', 'balanced'],
+    },
+    {
+        category: 'gitlab_token',
+        regex: /\b(glpat-)[A-Za-z0-9_-]{20,}\b/g,
+        replacement: '<REDACTED:gitlab_token>',
+        modes: ['strict', 'balanced'],
+    },
+    {
+        category: 'slack_token',
+        regex: /\b(xoxb-|xoxp-|xoxs-|xoxa-)[A-Za-z0-9-]{10,}\b/g,
+        replacement: '<REDACTED:slack_token>',
+        modes: ['strict', 'balanced'],
+    },
+    {
+        category: 'stripe_key',
+        regex: /\b(sk_live_|pk_live_|sk_test_|pk_test_|rk_live_|rk_test_)[A-Za-z0-9]{10,}\b/g,
+        replacement: '<REDACTED:stripe_key>',
+        modes: ['strict', 'balanced'],
+    },
+    {
+        category: 'google_api_key',
+        regex: /\bAIzaSy[A-Za-z0-9_-]{33}\b/g,
+        replacement: '<REDACTED:google_api_key>',
+        modes: ['strict', 'balanced'],
+    },
+    {
+        category: 'aws_session_token',
+        regex: /\bASIA[0-9A-Z]{16}\b/g,
+        replacement: '<REDACTED:aws_session_token>',
+        modes: ['strict', 'balanced'],
+    },
+    {
+        category: 'connection_string',
+        regex: /\b(mongodb(\+srv)?|postgres(ql)?|mysql|redis|amqp):\/\/[^\s"']+/gi,
+        replacement: '<REDACTED:connection_string>',
+        modes: ['strict', 'balanced'],
+    },
+    {
+        category: 'generic_secret',
+        regex: /\b(password|secret|token|apikey|api_key|access_key|secret_key)\s*[:=]\s*['"]?(?!ghp_|gho_|ghs_|ghr_|github_pat_|glpat-|xoxb-|xoxp-|xoxs-|xoxa-|sk_live_|pk_live_|sk_test_|pk_test_|rk_live_|rk_test_|AIzaSy|AKIA|ASIA|<REDACTED:)[^\s'"]{8,}['"]?/gi,
+        replacement: '<REDACTED:generic_secret>',
+        modes: ['strict', 'balanced'],
+    },
+    {
+        category: 'email',
+        regex: /\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,}\b/g,
+        replacement: '<REDACTED:pii_email>',
+        modes: ['strict'],
+    },
+    {
+        category: 'phone',
+        regex: /\b(\+?1?[-.\s]?)?\(?\d{3}\)?[-.\s]?\d{3}[-.\s]?\d{4}\b/g,
+        replacement: '<REDACTED:pii_phone>',
+        modes: ['strict'],
+    },
+    {
+        category: 'ssn',
+        regex: /\b\d{3}-\d{2}-\d{4}\b/g,
+        replacement: '<REDACTED:pii_ssn>',
+        modes: ['strict'],
+    },
+];
+/**
+ * Self-hosted providers that may receive unredacted transcripts.
+ * All other providers require redaction.
+ */
+const SELF_HOSTED_PROVIDERS = new Set(['ollama']);
+/**
+ * Providers allowed for security-sensitive agents.
+ * OpenRouter is explicitly excluded (third-party proxy).
+ */
+const SECURITY_AGENT_ALLOWED_PROVIDERS = new Set(['claude', 'ollama']);
+export function isSelfHosted(provider) {
+    return SELF_HOSTED_PROVIDERS.has(provider);
+}
+export function isSecurityAgentAllowed(provider) {
+    return SECURITY_AGENT_ALLOWED_PROVIDERS.has(provider);
+}
+export function isSecurityAgent(agentName) {
+    return /^qe-security|^qe-pentest/.test(agentName);
+}
+/**
+ * Redact sensitive patterns from text.
+ * Returns the redacted text and a list of categories found.
+ */
+export function redact(text, mode = 'strict') {
+    if (mode === 'off') {
+        return { text, redactions: [], replacementCount: 0 };
+    }
+    let result = text;
+    const foundCategories = new Set();
+    let totalReplacements = 0;
+    for (const pattern of PATTERNS) {
+        if (!pattern.modes.includes(mode))
+            continue;
+        const regex = new RegExp(pattern.regex.source, pattern.regex.flags);
+        const matches = result.match(regex);
+        if (matches && matches.length > 0) {
+            foundCategories.add(pattern.category);
+            totalReplacements += matches.length;
+            result = result.replace(regex, pattern.replacement);
+        }
+    }
+    return {
+        text: result,
+        redactions: Array.from(foundCategories).sort(),
+        replacementCount: totalReplacements,
+    };
+}
+/**
+ * Validate that the advisor call is allowed given the agent and provider.
+ * Throws with a descriptive message if the combination is forbidden.
+ */
+export function validateProviderForAgent(agentName, provider, redactionMode) {
+    if (isSecurityAgent(agentName) && !isSecurityAgentAllowed(provider)) {
+        throw new AdvisorRedactionError(`Security agent "${agentName}" may only use providers: ${[...SECURITY_AGENT_ALLOWED_PROVIDERS].join(', ')}. ` +
+            `Got: "${provider}". OpenRouter is excluded (third-party proxy risk).`, 6);
+    }
+    if (redactionMode === 'off' && !isSelfHosted(provider)) {
+        throw new AdvisorRedactionError(`Redaction mode "off" is only allowed for self-hosted providers (${[...SELF_HOSTED_PROVIDERS].join(', ')}). ` +
+            `Got: "${provider}".`, 6);
+    }
+}
+export class AdvisorRedactionError extends Error {
+    exitCode;
+    constructor(message, exitCode) {
+        super(message);
+        this.exitCode = exitCode;
+        this.name = 'AdvisorRedactionError';
+    }
+}
+//# sourceMappingURL=redaction.js.map

package/dist/routing/advisor/types.d.ts

@@ -0,0 +1,101 @@
+/**
+ * Advisor Strategy Types
+ * ADR-092: Provider-Agnostic Advisor Strategy for QE Agents
+ *
+ * Completes ADR-082's dormant `triggerMultiModel` flag by providing
+ * an execution layer for multi-model consultation.
+ */
+import type { ExtendedProviderType } from '../../shared/llm/router/types.js';
+/**
+ * Transcript slice forwarded to the advisor model.
+ * Minimal structure for Phase 0 — real callers pass a synthesized string.
+ */
+export interface AdvisorTranscript {
+    /** Executor system prompt */
+    systemPrompt?: string;
+    /** Conversation history in role/content pairs */
+    messages: Array<{
+        role: 'user' | 'assistant' | 'system';
+        content: string;
+    }>;
+    /** Optional task description for context */
+    taskDescription?: string;
+}
+/**
+ * Options passed to `MultiModelExecutor.consult()`.
+ */
+export interface ConsultOptions {
+    /** Advisor provider (default: 'openrouter' per ADR-092 Phase 0) */
+    provider?: ExtendedProviderType;
+    /** Advisor model ID (provider-specific, e.g., 'anthropic/claude-opus-4' for openrouter) */
+    model?: string;
+    /** Max advice length in words (default: 100 per Anthropic published guidance) */
+    maxWords?: number;
+    /** Agent name for feedback tracking and audit */
+    agentName?: string;
+    /** Reason the executor wants advice (for trigger attribution) */
+    triggerReason?: string;
+    /** Session ID for circuit breaker tracking (default: 'default') */
+    sessionId?: string;
+    /** Redaction mode (default: 'strict'). 'off' rejected for non-self-hosted. */
+    redact?: 'strict' | 'balanced' | 'off';
+    /** Domain-specific advisor system prompt (overrides the default generic prompt). */
+    advisorSystemPrompt?: string;
+}
+/**
+ * Structured advisor response returned to the caller.
+ * Matches the `aqe llm advise --json` stdout schema in ADR-092.
+ */
+export interface AdvisorResult {
+    /** Advice text returned by the advisor model */
+    advice: string;
+    /** Canonical model ID that produced the advice */
+    model: string;
+    /** Provider that handled the request */
+    provider: ExtendedProviderType;
+    /** Tokens sent to the advisor */
+    tokensIn: number;
+    /** Tokens returned by the advisor */
+    tokensOut: number;
+    /** Sub-call latency in milliseconds */
+    latencyMs: number;
+    /** Cost in USD for the advisor sub-call */
+    costUsd: number;
+    /** sha256 of the advice text (for cache lookups and replay) */
+    adviceHash: string;
+    /** Trigger attribution (e.g., "tiny_dancer.confidence=0.71") */
+    triggerReason: string;
+    /** Whether the result came from a cache (Phase 2+) */
+    cacheHit: boolean;
+    /** Redaction categories applied before dispatch (Phase 1) */
+    redactionsApplied: string[];
+    /** Remaining advisor calls before circuit breaker trips (Phase 1) */
+    circuitBreakerRemaining: number;
+}
+/**
+ * Optional `RoutingOutcome.advisorConsultation` field (Phase 1+).
+ * Phase 0 does not yet populate this; kept here so the shape is stable.
+ */
+export interface AdvisorConsultation {
+    model: string;
+    provider: ExtendedProviderType;
+    tokensIn: number;
+    tokensOut: number;
+    latencyMs: number;
+    costUsd: number;
+    adviceHash: string;
+    /** Did the executor act on the advice? (Phase 3+ — requires outcome feedback) */
+    followedAdvice?: boolean;
+    triggerReason: string;
+    /** Redaction categories applied before dispatch (Phase 1+) */
+    redactionsApplied?: string[];
+}
+/**
+ * The execution layer ADR-082 left unfinished.
+ * Consumed by `TinyDancerRouter` when `RouteResult.triggerMultiModel === true`
+ * AND an executor is configured on the router.
+ */
+export interface IMultiModelExecutor {
+    consult(transcript: AdvisorTranscript, opts?: ConsultOptions): Promise<AdvisorResult>;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/routing/advisor/types.js

@@ -0,0 +1,9 @@
+/**
+ * Advisor Strategy Types
+ * ADR-092: Provider-Agnostic Advisor Strategy for QE Agents
+ *
+ * Completes ADR-082's dormant `triggerMultiModel` flag by providing
+ * an execution layer for multi-model consultation.
+ */
+export {};
+//# sourceMappingURL=types.js.map

package/dist/routing/queen-integration.d.ts

@@ -7,6 +7,7 @@
  * to agent pool tiers and handles fallback scenarios.
  */
 import { type TinyDancerConfig, type RouteResult } from './tiny-dancer-router.js';
+import type { AdvisorResult } from './advisor/types.js';
 import { type ClassifiableTask, type TaskComplexity, type ClaudeModel } from './task-classifier.js';
 import { type RoutingConfig, type AgentTier, type ConfidenceThresholds } from './routing-config.js';
 import type { QETask } from './types.js';
@@ -36,6 +37,8 @@ export interface QueenRouteDecision {
     readonly latencyMs: number;
     /** Original TinyDancer result */
     readonly tinyDancerResult: RouteResult;
+    /** Advisor consultation result if triggered (ADR-092) */
+    readonly advisorResult?: AdvisorResult;
     /** Timestamp */
     readonly timestamp: Date;
 }

package/dist/routing/queen-integration.js

@@ -65,8 +65,13 @@ export class QueenRouterAdapter {
         const startTime = performance.now();
         // Reset daily cost if needed
         this.checkDailyCostReset();
-        // Use TinyDancer to classify and route
+        // Use TinyDancer to classify and route.
+        // ADR-092: triggerMultiModel is surfaced as a signal to spawned agents via
+        // spawn capabilities (queen-task-management.ts). Agents consume it via the
+        // executor preamble and call `aqe llm advise` when they have a transcript.
+        // The routing layer does NOT call the advisor — transcripts don't exist here.
         const tinyDancerResult = await this.tinyDancer.route(task);
+        const advisorResult = undefined;
         // Map complexity to agent tiers
         const tiers = mapComplexityToTier(tinyDancerResult.complexity, tinyDancerResult.classification.score, this.routingConfig);
         const primaryTier = tiers[0];
@@ -94,6 +99,7 @@ export class QueenRouterAdapter {
             reasoning,
             latencyMs,
             tinyDancerResult,
+            advisorResult,
             timestamp: new Date(),
         };
         // Update cost tracking

package/dist/routing/routing-feedback.d.ts

@@ -16,6 +16,7 @@ import { CostTracker } from '../shared/llm/cost-tracker.js';
  * Collects and processes routing feedback for continuous learning
  */
 export declare class RoutingFeedbackCollector {
+    private static schemaMigrated;
     private outcomeStore;
     private router;
     private db;
@@ -45,6 +46,11 @@ export declare class RoutingFeedbackCollector {
      * Infer model tier from agent name for analytics.
      * Maps known agent patterns to ADR-026 tiers.
      */
+    /**
+     * M1 fix: read advisor consultation sidecar file written by MultiModelExecutor.
+     * Uses the task ID or a recent session file as a key.
+     */
+    private loadAdvisorConsultationSidecar;
     private inferTier;
     /**
      * Delete oldest rows beyond retention limit
@@ -114,7 +120,7 @@ export declare class RoutingFeedbackCollector {
         qualityScore: number;
         durationMs: number;
         error?: string;
-    }): RoutingOutcome;
+    }, advisorConsultation?: RoutingOutcome['advisorConsultation']): RoutingOutcome;
     /**
      * Get aggregated performance metrics for an agent
      */

package/dist/routing/routing-feedback.js

@@ -61,6 +61,7 @@ class OutcomeStore {
  * Collects and processes routing feedback for continuous learning
  */
 export class RoutingFeedbackCollector {
+    static schemaMigrated = false;
     outcomeStore;
     router = null;
     db = null;
@@ -125,6 +126,9 @@ export class RoutingFeedbackCollector {
                     error: row.error || undefined,
                 },
                 timestamp: new Date(row.created_at),
+                advisorConsultation: row.advisor_consultation_json
+                    ? safeJsonParse(row.advisor_consultation_json)
+                    : undefined,
             };
             this.outcomeStore.add(outcome);
         }
@@ -140,22 +144,32 @@ export class RoutingFeedbackCollector {
             return;
         try {
             const database = this.db.getDatabase();
-            // Ensure model_tier column exists (for databases created before this schema addition)
-            try {
-                database.prepare(`ALTER TABLE routing_outcomes ADD COLUMN model_tier TEXT`).run();
-            }
-            catch {
-                // Column already exists — expected
+            // Ensure schema columns exist for databases created before ADR-092.
+            // Runs once per process via the flag; new databases have columns from
+            // unified-memory-schemas.ts CREATE TABLE.
+            if (!RoutingFeedbackCollector.schemaMigrated) {
+                for (const col of [
+                    'ALTER TABLE routing_outcomes ADD COLUMN model_tier TEXT',
+                    'ALTER TABLE routing_outcomes ADD COLUMN advisor_consultation_json TEXT',
+                ]) {
+                    try {
+                        database.prepare(col).run();
+                    }
+                    catch { /* column already exists */ }
+                }
+                RoutingFeedbackCollector.schemaMigrated = true;
             }
-            // Extract tier from usedAgent name (e.g. "tier-0" → "booster", "qe-test-architect" → "sonnet")
             const modelTier = this.inferTier(outcome.usedAgent);
+            const advisorJson = outcome.advisorConsultation
+                ? JSON.stringify(outcome.advisorConsultation)
+                : null;
             database.prepare(`
         INSERT OR REPLACE INTO routing_outcomes (
           id, task_json, decision_json, used_agent,
           followed_recommendation, success, quality_score,
-          duration_ms, error, model_tier
-        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-      `).run(outcome.id, JSON.stringify(outcome.task), JSON.stringify(outcome.decision), outcome.usedAgent, outcome.followedRecommendation ? 1 : 0, outcome.outcome.success ? 1 : 0, outcome.outcome.qualityScore, outcome.outcome.durationMs, outcome.outcome.error || null, modelTier);
+          duration_ms, error, model_tier, advisor_consultation_json
+        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+      `).run(outcome.id, JSON.stringify(outcome.task), JSON.stringify(outcome.decision), outcome.usedAgent, outcome.followedRecommendation ? 1 : 0, outcome.outcome.success ? 1 : 0, outcome.outcome.qualityScore, outcome.outcome.durationMs, outcome.outcome.error || null, modelTier, advisorJson);
             this.persistCount++;
             if (this.persistCount % RoutingFeedbackCollector.RETENTION_CLEANUP_INTERVAL === 0) {
                 this.enforceRetention(database);
@@ -169,6 +183,31 @@ export class RoutingFeedbackCollector {
      * Infer model tier from agent name for analytics.
      * Maps known agent patterns to ADR-026 tiers.
      */
+    /**
+     * M1 fix: read advisor consultation sidecar file written by MultiModelExecutor.
+     * Uses the task ID or a recent session file as a key.
+     */
+    loadAdvisorConsultationSidecar(task) {
+        try {
+            const { readdirSync, readFileSync } = require('fs');
+            const { join } = require('path');
+            const { homedir } = require('os');
+            const dir = join(homedir(), '.agentic-qe', 'advisor', 'consultations');
+            const files = readdirSync(dir).filter(f => f.endsWith('.json')).sort().reverse();
+            if (files.length === 0)
+                return undefined;
+            // Read the most recent consultation (within last 5 minutes)
+            const newest = files[0];
+            const data = JSON.parse(readFileSync(join(dir, newest), 'utf-8'));
+            const age = Date.now() - new Date(data.timestamp).getTime();
+            if (age > 5 * 60 * 1000)
+                return undefined;
+            return data;
+        }
+        catch {
+            return undefined;
+        }
+    }
     inferTier(agentName) {
         const lower = agentName.toLowerCase();
         if (lower.includes('booster') || lower === 'tier-0')
@@ -331,7 +370,13 @@ export class RoutingFeedbackCollector {
     /**
      * Record a routing outcome
      */
-    recordOutcome(task, decision, usedAgent, outcome) {
+    recordOutcome(task, decision, usedAgent, outcome, advisorConsultation) {
+        // M1 fix: if no explicit advisorConsultation passed, check sidecar file
+        // written by MultiModelExecutor.persistConsultation()
+        let resolvedAdvisor = advisorConsultation;
+        if (!resolvedAdvisor) {
+            resolvedAdvisor = this.loadAdvisorConsultationSidecar(task);
+        }
         const routingOutcome = {
             id: `outcome-${Date.now()}-${randomUUID().slice(0, 8)}`,
             task,
@@ -340,6 +385,7 @@ export class RoutingFeedbackCollector {
             followedRecommendation: usedAgent === decision.recommended,
             outcome,
             timestamp: new Date(),
+            advisorConsultation: resolvedAdvisor,
         };
         // Store outcome
         this.outcomeStore.add(routingOutcome);

package/dist/routing/tiny-dancer-router.d.ts

@@ -52,6 +52,18 @@ export interface TinyDancerConfig {
     enableLearning?: boolean;
     /** Enable verbose logging (default: false) */
     verbose?: boolean;
+    /**
+     * Optional MultiModelExecutor that consumes `triggerMultiModel=true`
+     * and dispatches an advisor consultation (ADR-092).
+     *
+     * When omitted, `triggerMultiModel` remains a flag-only signal as before.
+     * When provided, `route()` still returns synchronously, but callers can
+     * opt in to advisor consultation via `routeWithAdvisor()`.
+     *
+     * Phase 0: hooked via the explicit `routeWithAdvisor()` method only, to
+     *          keep the hot-path `route()` API fully backward-compatible.
+     */
+    executor?: import('./advisor/types.js').IMultiModelExecutor;
 }
 /**
  * Routing outcome for learning
@@ -82,8 +94,10 @@ export interface RouterStats {
     readonly routesByModel: Record<ClaudeModel, number>;
     /** Routes by complexity */
     readonly routesByComplexity: Record<TaskComplexity, number>;
-    /** Multi-model triggers */
+    /** Multi-model triggers (triggerMultiModel flag set) */
     readonly multiModelTriggers: number;
+    /** Advisor consultations actually executed (ADR-092 — requires executor wired) */
+    readonly advisorConsultations: number;
     /** Human review triggers */
     readonly humanReviewTriggers: number;
     /** Average confidence */
@@ -109,16 +123,36 @@ export declare class TinyDancerRouter {
     private readonly securityConfidenceThreshold;
     private readonly enableLearning;
     private readonly verbose;
+    private readonly executor?;
     private totalRouted;
     private routesByModel;
     private routesByComplexity;
     private multiModelTriggers;
     private humanReviewTriggers;
+    private advisorConsultations;
     private totalConfidence;
     private totalLatencyMs;
     private outcomes;
     private readonly maxOutcomes;
     constructor(config?: TinyDancerConfig);
+    /**
+     * Whether a MultiModelExecutor is wired (ADR-092).
+     * Used by callers to decide whether to call `routeWithAdvisor()`.
+     */
+    hasExecutor(): boolean;
+    /**
+     * Route a task and, when `triggerMultiModel === true` AND an executor is
+     * configured, consult the advisor and return both the route result and the
+     * advisor consultation. Backward-compatible: when no executor is configured,
+     * returns `{ route, advisor: undefined }` identical to calling `route()`.
+     *
+     * ADR-092: this is the execution layer for ADR-082's dormant
+     * `triggerMultiModel` flag.
+     */
+    routeWithAdvisor(task: QETask | ClassifiableTask, transcript?: import('./advisor/types.js').AdvisorTranscript): Promise<{
+        route: RouteResult;
+        advisor?: import('./advisor/types.js').AdvisorResult;
+    }>;
     /**
      * Route a task to the optimal Claude model
      *

package/dist/routing/tiny-dancer-router.js

@@ -34,6 +34,7 @@ export class TinyDancerRouter {
     securityConfidenceThreshold;
     enableLearning;
     verbose;
+    executor;
     // Statistics tracking
     totalRouted = 0;
     routesByModel = { haiku: 0, sonnet: 0, opus: 0 };
@@ -42,6 +43,7 @@ export class TinyDancerRouter {
     };
     multiModelTriggers = 0;
     humanReviewTriggers = 0;
+    advisorConsultations = 0;
     totalConfidence = 0;
     totalLatencyMs = 0;
     // Learning storage
@@ -53,6 +55,35 @@ export class TinyDancerRouter {
         this.securityConfidenceThreshold = config.securityConfidenceThreshold ?? 0.85;
         this.enableLearning = config.enableLearning ?? true;
         this.verbose = config.verbose ?? false;
+        this.executor = config.executor;
+    }
+    /**
+     * Whether a MultiModelExecutor is wired (ADR-092).
+     * Used by callers to decide whether to call `routeWithAdvisor()`.
+     */
+    hasExecutor() {
+        return this.executor !== undefined;
+    }
+    /**
+     * Route a task and, when `triggerMultiModel === true` AND an executor is
+     * configured, consult the advisor and return both the route result and the
+     * advisor consultation. Backward-compatible: when no executor is configured,
+     * returns `{ route, advisor: undefined }` identical to calling `route()`.
+     *
+     * ADR-092: this is the execution layer for ADR-082's dormant
+     * `triggerMultiModel` flag.
+     */
+    async routeWithAdvisor(task, transcript) {
+        const route = await this.route(task);
+        if (!route.triggerMultiModel || !this.executor || !transcript) {
+            return { route };
+        }
+        const advisor = await this.executor.consult(transcript, {
+            agentName: task.agentId ?? task.id ?? 'unknown',
+            triggerReason: `tiny_dancer.confidence=${route.confidence.toFixed(2)}<${this.confidenceThreshold}`,
+        });
+        this.advisorConsultations++;
+        return { route, advisor };
     }
     /**
      * Route a task to the optimal Claude model
@@ -259,6 +290,7 @@ export class TinyDancerRouter {
             routesByModel: { ...this.routesByModel },
             routesByComplexity: { ...this.routesByComplexity },
             multiModelTriggers: this.multiModelTriggers,
+            advisorConsultations: this.advisorConsultations,
             humanReviewTriggers: this.humanReviewTriggers,
             avgConfidence: this.totalRouted > 0
                 ? this.totalConfidence / this.totalRouted
@@ -311,6 +343,7 @@ export class TinyDancerRouter {
         this.routesByModel = { haiku: 0, sonnet: 0, opus: 0 };
         this.routesByComplexity = { simple: 0, moderate: 0, complex: 0, critical: 0 };
         this.multiModelTriggers = 0;
+        this.advisorConsultations = 0;
         this.humanReviewTriggers = 0;
         this.totalConfidence = 0;
         this.totalLatencyMs = 0;

package/dist/routing/types.d.ts

@@ -170,6 +170,18 @@ export interface RoutingOutcome {
     };
     /** Timestamp */
     readonly timestamp: Date;
+    /** Advisor consultation details if an advisor was consulted (ADR-092 Phase 1) */
+    readonly advisorConsultation?: {
+        model: string;
+        provider: string;
+        tokensIn: number;
+        tokensOut: number;
+        latencyMs: number;
+        costUsd: number;
+        adviceHash: string;
+        triggerReason: string;
+        redactionsApplied?: string[];
+    };
 }
 /**
  * Aggregated agent performance metrics

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentic-qe",
-  "version": "3.9.9",
+  "version": "3.9.10",
   "description": "Agentic Quality Engineering V3 - Domain-Driven Design Architecture with 13 Bounded Contexts, O(log n) coverage analysis, ReasoningBank learning, 60 specialized QE agents, mathematical Coherence verification, deep Claude Flow integration",
   "type": "module",
   "main": "./dist/index.js",

package/dist/cli/chunks/adapter-XKXEZEMM.js

@@ -1,2 +0,0 @@
-import{createRequire as __cr}from"module";const require=__cr(import.meta.url);if(process.argv.includes('--version')||process.argv.includes('-v')){console.log("3.9.9");process.exit(0)}
-import{a,b,c}from"./chunk-BSES27JE.js";import"./chunk-ZTI3BATG.js";import"./chunk-DNS7DP2O.js";import"./chunk-MWZN4PYF.js";import"./chunk-BVOGMK6N.js";import"./chunk-UYKIPSRX.js";export{a as AgentBoosterAdapter,b as createAgentBoosterAdapter,c as createAgentBoosterAdapterSync};

package/dist/cli/chunks/aqe-learning-engine-K7XGBDMZ.js

@@ -1,2 +0,0 @@
-import{createRequire as __cr}from"module";const require=__cr(import.meta.url);if(process.argv.includes('--version')||process.argv.includes('-v')){console.log("3.9.9");process.exit(0)}
-import{a,b,c,d,e,f}from"./chunk-3NU4C62D.js";import"./chunk-Z7AFNZMI.js";import"./chunk-5HM66R4W.js";import"./chunk-NQ3WHTLT.js";import"./chunk-65XCVUP7.js";import"./chunk-VWHALAEO.js";import"./chunk-3FAEM5M7.js";import"./chunk-5DU4YW2S.js";import"./chunk-4CDSEZD6.js";import"./chunk-XZ2JYMFT.js";import"./chunk-3F666FYP.js";import"./chunk-2X7LDTVD.js";import"./chunk-FGW5W3YK.js";import"./chunk-MUIJVPGB.js";import"./chunk-PYTXZMXR.js";import"./chunk-VRH3YLO2.js";import"./chunk-UEKDDUGV.js";import"./chunk-MWZN4PYF.js";import"./chunk-PEEN4AAK.js";import"./chunk-BVOGMK6N.js";import"./chunk-FTF34UME.js";import"./chunk-5SWY75MJ.js";import"./chunk-OEZA7Q2Z.js";import"./chunk-WDWIJDQR.js";import"./chunk-JIPU4YQK.js";import"./chunk-QZMBJ67L.js";import"./chunk-MXMKHI2I.js";import"./chunk-QMNAELZG.js";import"./chunk-QTYTM7C7.js";import"./chunk-NLKJI73E.js";import"./chunk-UYKIPSRX.js";export{b as AQELearningEngine,a as DEFAULT_ENGINE_CONFIG,c as DEFAULT_META_LEARNING_CONFIG,d as MetaLearningEngine,e as createAQELearningEngine,f as createDefaultLearningEngine};

package/dist/cli/chunks/base-NUF35LIJ.js

@@ -1,2 +0,0 @@
-import{createRequire as __cr}from"module";const require=__cr(import.meta.url);if(process.argv.includes('--version')||process.argv.includes('-v')){console.log("3.9.9");process.exit(0)}
-import{a,b,c,d,e,f}from"./chunk-ECNPBD4Y.js";import"./chunk-2HFPJPQW.js";import"./chunk-MUIJVPGB.js";import"./chunk-PYTXZMXR.js";import"./chunk-VRH3YLO2.js";import"./chunk-UEKDDUGV.js";import"./chunk-MWZN4PYF.js";import"./chunk-BVOGMK6N.js";import"./chunk-FTF34UME.js";import"./chunk-5SWY75MJ.js";import"./chunk-OEZA7Q2Z.js";import"./chunk-WDWIJDQR.js";import"./chunk-JIPU4YQK.js";import"./chunk-QZMBJ67L.js";import"./chunk-MXMKHI2I.js";import"./chunk-QMNAELZG.js";import"./chunk-QTYTM7C7.js";import"./chunk-NLKJI73E.js";import"./chunk-UYKIPSRX.js";export{f as MCPToolBase,e as defaultToolLogger,d as getMemoryBackend,b as getSharedMemoryBackend,a as registerRvfResetFn,c as resetSharedMemoryBackend};

package/dist/cli/chunks/browser-workflow-MWPELXFA.js

@@ -1,2 +0,0 @@
-import{createRequire as __cr}from"module";const require=__cr(import.meta.url);if(process.argv.includes('--version')||process.argv.includes('-v')){console.log("3.9.9");process.exit(0)}
-import{a}from"./chunk-SVLO2DVL.js";import"./chunk-ECNPBD4Y.js";import"./chunk-2HFPJPQW.js";import"./chunk-MUIJVPGB.js";import"./chunk-PYTXZMXR.js";import"./chunk-VRH3YLO2.js";import"./chunk-UEKDDUGV.js";import"./chunk-MWZN4PYF.js";import"./chunk-BVOGMK6N.js";import"./chunk-FTF34UME.js";import"./chunk-5SWY75MJ.js";import"./chunk-OEZA7Q2Z.js";import"./chunk-WDWIJDQR.js";import"./chunk-JIPU4YQK.js";import"./chunk-QZMBJ67L.js";import"./chunk-MXMKHI2I.js";import"./chunk-QMNAELZG.js";import"./chunk-QTYTM7C7.js";import"./chunk-NLKJI73E.js";import"./chunk-UYKIPSRX.js";export{a as BrowserWorkflowTool};