agentic-qe 3.9.8 → 3.9.10

package/dist/mcp/protocol-server.js

@@ -1225,6 +1225,93 @@ export class MCPProtocolServer {
             },
             handler: (params) => handleMigrationPromote(params),
         });
+        // ADR-092: Thin MCP wrapper for advisor consultation (Phase 6)
+        this.registerTool({
+            definition: {
+                name: 'advisor_consult',
+                description: 'Consult a stronger advisor model for strategic guidance. Forwards a task description and context to the advisor and returns enumerated action steps. Auto-detects the best available provider. Example: advisor_consult({ agent: "qe-test-architect", task: "Generate tests for auth module", context: "Found 4 classes with external deps" })',
+                category: 'routing',
+                parameters: [
+                    { name: 'agent', type: 'string', description: 'Agent name requesting advice (e.g., qe-test-architect)' },
+                    { name: 'task', type: 'string', description: 'Task description' },
+                    { name: 'context', type: 'string', description: 'What the executor has found so far' },
+                    { name: 'provider', type: 'string', description: 'Provider override (openrouter, claude, ollama)' },
+                    { name: 'model', type: 'string', description: 'Model override' },
+                ],
+            },
+            handler: async (params) => {
+                const { execFileSync } = await import('child_process');
+                const { writeFileSync, unlinkSync, mkdirSync } = await import('fs');
+                const { join } = await import('path');
+                const { tmpdir } = await import('os');
+                const p = params;
+                const transcriptDir = join(tmpdir(), 'aqe-advisor');
+                mkdirSync(transcriptDir, { recursive: true });
+                const transcriptPath = join(transcriptDir, `mcp-${Date.now()}.json`);
+                const transcript = {
+                    taskDescription: p.task ?? '',
+                    messages: [
+                        { role: 'user', content: p.task ?? '' },
+                        ...(p.context ? [{ role: 'assistant', content: p.context }] : []),
+                    ],
+                };
+                writeFileSync(transcriptPath, JSON.stringify(transcript));
+                try {
+                    const cliArgs = [
+                        'llm', 'advise',
+                        '--transcript', transcriptPath,
+                        '--agent', p.agent ?? 'unknown',
+                        '--json',
+                    ];
+                    if (p.provider)
+                        cliArgs.push('--provider', p.provider);
+                    if (p.model)
+                        cliArgs.push('--model', p.model);
+                    // Resolve aqe binary with fallback to npx (MCP server may not have aqe on PATH)
+                    let aqeBin = 'aqe';
+                    try {
+                        execFileSync('which', ['aqe'], { encoding: 'utf-8' });
+                    }
+                    catch {
+                        aqeBin = 'npx';
+                        cliArgs.unshift('aqe');
+                    }
+                    const result = execFileSync(aqeBin, cliArgs, {
+                        encoding: 'utf-8',
+                        timeout: 60000,
+                        env: process.env,
+                    });
+                    try {
+                        unlinkSync(transcriptPath);
+                    }
+                    catch { }
+                    const lines = result.split('\n');
+                    let jsonStr = '';
+                    let depth = 0;
+                    let inJson = false;
+                    for (const line of lines) {
+                        const t = line.trim();
+                        if (!inJson && t.startsWith('{'))
+                            inJson = true;
+                        if (inJson) {
+                            jsonStr += line + '\n';
+                            depth += (t.match(/{/g) || []).length;
+                            depth -= (t.match(/}/g) || []).length;
+                            if (depth <= 0)
+                                break;
+                        }
+                    }
+                    return JSON.parse(jsonStr || '{}');
+                }
+                catch (err) {
+                    try {
+                        unlinkSync(transcriptPath);
+                    }
+                    catch { }
+                    return { error: err.message?.slice(0, 300) ?? 'Unknown error' };
+                }
+            },
+        });
         // Register QE domain tools not already covered by hardcoded handlers above
         const bridgedCount = registerMissingQETools((entry) => this.registerTool(entry));
         console.error(`[MCP] Registered ${this.tools.size} tools (${bridgedCount} via QE bridge)`);

package/dist/routing/advisor/circuit-breaker.d.ts

@@ -0,0 +1,56 @@
+/**
+ * Advisor Circuit Breaker
+ * ADR-092: hard per-session ceiling on advisor calls
+ *
+ * Three protection layers:
+ *   1. per-task max_uses (enforced by caller)
+ *   2. per-call budget_usd (enforced by caller)
+ *   3. per-session hard ceiling (enforced here) — 10 advisor calls absolute max
+ *
+ * State persists to a JSON file at `.agentic-qe/advisor/circuit-breaker.json`
+ * so the ceiling survives across CLI invocations within the same session.
+ * Each CLI call to `aqe llm advise` is a fresh process — without file-based
+ * persistence, each invocation would get a fresh counter.
+ */
+export interface CircuitBreakerConfig {
+    /** Max advisor calls per session (default: 10) */
+    maxCallsPerSession: number;
+    /** Path to persist state (default: .agentic-qe/advisor/circuit-breaker.json) */
+    statePath?: string;
+}
+export interface CircuitBreakerState {
+    sessionId: string;
+    callCount: number;
+    maxCalls: number;
+    remaining: number;
+    tripped: boolean;
+}
+export declare class AdvisorCircuitBreaker {
+    private readonly maxCalls;
+    private readonly statePath;
+    constructor(config?: Partial<CircuitBreakerConfig>);
+    /**
+     * Check whether another advisor call is allowed for this session.
+     * If allowed, increments the counter and persists. Throws on trip.
+     */
+    acquire(sessionId: string): CircuitBreakerState;
+    /**
+     * Get the current state without incrementing.
+     */
+    getState(sessionId: string): CircuitBreakerState;
+    /**
+     * Reset a specific session or all sessions.
+     */
+    reset(sessionId?: string): void;
+    private load;
+    private save;
+    private evictStale;
+}
+export declare class AdvisorCircuitBreakerError extends Error {
+    readonly sessionId: string;
+    readonly callCount: number;
+    readonly maxCalls: number;
+    readonly exitCode = 3;
+    constructor(message: string, sessionId: string, callCount: number, maxCalls: number);
+}
+//# sourceMappingURL=circuit-breaker.d.ts.map

package/dist/routing/advisor/circuit-breaker.js

@@ -0,0 +1,128 @@
+/**
+ * Advisor Circuit Breaker
+ * ADR-092: hard per-session ceiling on advisor calls
+ *
+ * Three protection layers:
+ *   1. per-task max_uses (enforced by caller)
+ *   2. per-call budget_usd (enforced by caller)
+ *   3. per-session hard ceiling (enforced here) — 10 advisor calls absolute max
+ *
+ * State persists to a JSON file at `.agentic-qe/advisor/circuit-breaker.json`
+ * so the ceiling survives across CLI invocations within the same session.
+ * Each CLI call to `aqe llm advise` is a fresh process — without file-based
+ * persistence, each invocation would get a fresh counter.
+ */
+import { readFileSync, writeFileSync, mkdirSync, renameSync } from 'node:fs';
+import { join, dirname } from 'node:path';
+import { homedir } from 'node:os';
+const DEFAULT_CONFIG = {
+    maxCallsPerSession: 10,
+};
+// Use home directory for stable path across CWDs and MCP contexts (M5 fix)
+const DEFAULT_STATE_PATH = join(homedir(), '.agentic-qe', 'advisor', 'circuit-breaker.json');
+const SESSION_TTL_MS = 24 * 60 * 60 * 1000; // 24 hours
+export class AdvisorCircuitBreaker {
+    maxCalls;
+    statePath;
+    constructor(config) {
+        this.maxCalls = config?.maxCallsPerSession ?? DEFAULT_CONFIG.maxCallsPerSession;
+        this.statePath = config?.statePath ?? DEFAULT_STATE_PATH;
+    }
+    /**
+     * Check whether another advisor call is allowed for this session.
+     * If allowed, increments the counter and persists. Throws on trip.
+     */
+    acquire(sessionId) {
+        const state = this.load();
+        const entry = state.sessions[sessionId];
+        const current = entry?.count ?? 0;
+        if (current >= this.maxCalls) {
+            throw new AdvisorCircuitBreakerError(`Advisor circuit breaker tripped: ${current} calls in session "${sessionId}" ` +
+                `(max: ${this.maxCalls}). Do not retry — continue without the advisor.`, sessionId, current, this.maxCalls);
+        }
+        const next = current + 1;
+        state.sessions[sessionId] = { count: next, lastUpdated: new Date().toISOString() };
+        this.save(state);
+        return {
+            sessionId,
+            callCount: next,
+            maxCalls: this.maxCalls,
+            remaining: this.maxCalls - next,
+            tripped: false,
+        };
+    }
+    /**
+     * Get the current state without incrementing.
+     */
+    getState(sessionId) {
+        const state = this.load();
+        const current = state.sessions[sessionId]?.count ?? 0;
+        return {
+            sessionId,
+            callCount: current,
+            maxCalls: this.maxCalls,
+            remaining: this.maxCalls - current,
+            tripped: current >= this.maxCalls,
+        };
+    }
+    /**
+     * Reset a specific session or all sessions.
+     */
+    reset(sessionId) {
+        if (sessionId) {
+            const state = this.load();
+            delete state.sessions[sessionId];
+            this.save(state);
+        }
+        else {
+            this.save({ sessions: {} });
+        }
+    }
+    load() {
+        try {
+            const raw = readFileSync(this.statePath, 'utf-8');
+            const state = JSON.parse(raw);
+            this.evictStale(state);
+            return state;
+        }
+        catch {
+            return { sessions: {} };
+        }
+    }
+    save(state) {
+        try {
+            mkdirSync(dirname(this.statePath), { recursive: true });
+            // Atomic write via rename to prevent TOCTOU race when concurrent
+            // CLI processes write simultaneously (H3 fix from devil's-advocate review)
+            const tmpPath = this.statePath + '.tmp.' + process.pid;
+            writeFileSync(tmpPath, JSON.stringify(state, null, 2));
+            renameSync(tmpPath, this.statePath);
+        }
+        catch {
+            // Best-effort — if we can't persist, fall back to in-memory-only
+        }
+    }
+    evictStale(state) {
+        const now = Date.now();
+        for (const [sid, entry] of Object.entries(state.sessions)) {
+            const age = now - new Date(entry.lastUpdated).getTime();
+            if (age > SESSION_TTL_MS) {
+                delete state.sessions[sid];
+            }
+        }
+    }
+}
+export class AdvisorCircuitBreakerError extends Error {
+    sessionId;
+    callCount;
+    maxCalls;
+    exitCode = 3;
+    constructor(message, sessionId, callCount, maxCalls) {
+        super(message);
+        this.sessionId = sessionId;
+        this.callCount = callCount;
+        this.maxCalls = maxCalls;
+        this.name = 'AdvisorCircuitBreakerError';
+    }
+}
+//# sourceMappingURL=circuit-breaker.js.map

package/dist/routing/advisor/domain-prompts.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Domain-Specific Advisor System Prompts (ADR-092 Phase 4)
+ *
+ * Per-domain advisor prompts that replace the generic prompt when the
+ * agent's domain is known. These produce more targeted, actionable advice
+ * because the advisor knows what KIND of work the executor is doing.
+ */
+export declare const DOMAIN_ADVISOR_PROMPTS: Record<string, string>;
+/**
+ * Get the domain-specific advisor prompt, falling back to undefined (which
+ * causes MultiModelExecutor to use the default generic prompt).
+ */
+export declare function getDomainAdvisorPrompt(domain: string): string | undefined;
+//# sourceMappingURL=domain-prompts.d.ts.map

package/dist/routing/advisor/domain-prompts.js

@@ -0,0 +1,53 @@
+/**
+ * Domain-Specific Advisor System Prompts (ADR-092 Phase 4)
+ *
+ * Per-domain advisor prompts that replace the generic prompt when the
+ * agent's domain is known. These produce more targeted, actionable advice
+ * because the advisor knows what KIND of work the executor is doing.
+ */
+export const DOMAIN_ADVISOR_PROMPTS = {
+    'test-generation': `You are the advisor for a test-generation executor. The executor is writing a test suite for source code it has read.
+
+Respond in under 100 words, enumerated steps. Name concrete classes, methods, and dependencies from the source. Focus on:
+1. What to mock (external deps, I/O, time, randomness)
+2. Which methods need priority coverage (public API, error paths, state transitions)
+3. Edge cases the executor will likely miss (boundary values, empty inputs, concurrent access, error cascades)
+4. Test structure recommendations (fixtures, parametrize, grouping)
+
+Do NOT write test code — the executor does that. Give strategic direction only.`,
+    'security-compliance': `You are the advisor for a security-focused executor (security audit or penetration test validation).
+
+Respond in under 100 words, enumerated steps. Name concrete attack vectors, CWE IDs, and code locations. Focus on:
+1. Which input boundaries lack validation (identify specific parameters, headers, query strings)
+2. Authentication/authorization gaps (token handling, session management, privilege escalation paths)
+3. Data exposure risks (logging sensitive data, error messages leaking internals, unredacted PII)
+4. Dependency vulnerabilities (known CVEs in imports, outdated packages)
+
+Prioritize by exploitability, not by count. One exploitable finding outweighs ten theoretical ones.`,
+    'coverage-analysis': `You are the advisor for a coverage analysis executor examining test gaps.
+
+Respond in under 100 words, enumerated steps. Name concrete uncovered files, functions, and branches. Focus on:
+1. Which uncovered code carries the highest business risk (payment paths, auth, data mutations)
+2. Which branches are missed (error handlers, fallback paths, race conditions)
+3. Whether the coverage gaps indicate missing test TYPES (integration tests, edge cases, negative tests)
+4. Quick wins — functions with 0% coverage that are simple to test
+
+Do NOT suggest increasing coverage for its own sake. Prioritize by risk.`,
+    'cross-domain': `You are the advisor for a fleet commander coordinating multiple QE agents across domains.
+
+Respond in under 100 words, enumerated steps. Focus on:
+1. Which domains need the most attention based on the current task context
+2. Agent delegation recommendations (which agent type for which subtask)
+3. Coordination risks (shared state, ordering dependencies, resource contention)
+4. Whether the task decomposition is correct or if subtasks are missing
+
+Think about the task holistically — the executor manages agents, not code directly.`,
+};
+/**
+ * Get the domain-specific advisor prompt, falling back to undefined (which
+ * causes MultiModelExecutor to use the default generic prompt).
+ */
+export function getDomainAdvisorPrompt(domain) {
+    return DOMAIN_ADVISOR_PROMPTS[domain];
+}
+//# sourceMappingURL=domain-prompts.js.map

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

@@ -0,0 +1,10 @@
+/**
+ * Advisor Strategy public exports.
+ * ADR-092: Provider-Agnostic Advisor Strategy for QE Agents
+ */
+export type { AdvisorTranscript, ConsultOptions, AdvisorResult, AdvisorConsultation, IMultiModelExecutor, } from './types.js';
+export { MultiModelExecutor, createMultiModelExecutor, DEFAULT_ADVISOR_PROVIDER, DEFAULT_ADVISOR_MODEL, DEFAULT_MAX_WORDS, } from './multi-model-executor.js';
+export { redact, validateProviderForAgent, isSelfHosted, isSecurityAgentAllowed, isSecurityAgent, AdvisorRedactionError, type RedactionMode, type RedactionResult, } from './redaction.js';
+export { AdvisorCircuitBreaker, AdvisorCircuitBreakerError, type CircuitBreakerConfig, type CircuitBreakerState, } from './circuit-breaker.js';
+export { DOMAIN_ADVISOR_PROMPTS, getDomainAdvisorPrompt, } from './domain-prompts.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/routing/advisor/index.js

@@ -0,0 +1,9 @@
+/**
+ * Advisor Strategy public exports.
+ * ADR-092: Provider-Agnostic Advisor Strategy for QE Agents
+ */
+export { MultiModelExecutor, createMultiModelExecutor, DEFAULT_ADVISOR_PROVIDER, DEFAULT_ADVISOR_MODEL, DEFAULT_MAX_WORDS, } from './multi-model-executor.js';
+export { redact, validateProviderForAgent, isSelfHosted, isSecurityAgentAllowed, isSecurityAgent, AdvisorRedactionError, } from './redaction.js';
+export { AdvisorCircuitBreaker, AdvisorCircuitBreakerError, } from './circuit-breaker.js';
+export { DOMAIN_ADVISOR_PROMPTS, getDomainAdvisorPrompt, } from './domain-prompts.js';
+//# sourceMappingURL=index.js.map

package/dist/routing/advisor/multi-model-executor.d.ts

@@ -0,0 +1,60 @@
+/**
+ * MultiModelExecutor — the execution layer for ADR-082's `triggerMultiModel` flag.
+ * ADR-092: Provider-Agnostic Advisor Strategy for QE Agents
+ *
+ * All phases implemented (ADR-092):
+ * - Consultation via HybridRouter.chat() with provider auto-detection
+ * - Secrets/PII redaction pre-flight (16 pattern categories)
+ * - Per-session circuit breaker (file-persisted, atomic writes)
+ * - Domain-specific advisor prompts via --advisor-prompt
+ * - Consultation sidecar persistence for RoutingFeedbackCollector
+ *
+ * Architecturally this class is small on purpose. TinyDancerRouter already
+ * decides WHEN advice is warranted (via `triggerMultiModel`). HybridRouter
+ * already handles provider dispatch, fallback, and cost tracking. This class
+ * is the narrow bridge between those two existing layers.
+ */
+import type { HybridRouter } from '../../shared/llm/router/hybrid-router.js';
+import type { ExtendedProviderType } from '../../shared/llm/router/types.js';
+import type { AdvisorResult, AdvisorTranscript, ConsultOptions, IMultiModelExecutor } from './types.js';
+import { type CircuitBreakerState } from './circuit-breaker.js';
+/**
+ * Default advisor model per ADR-092 Phase 0.
+ * OpenRouter exposes Anthropic Opus — chosen for vendor-independence as the
+ * default while direct Anthropic remains available for security-sensitive agents.
+ */
+export declare const DEFAULT_ADVISOR_PROVIDER: ExtendedProviderType;
+export declare const DEFAULT_ADVISOR_MODEL = "anthropic/claude-opus-4";
+export declare const DEFAULT_MAX_WORDS = 100;
+/**
+ * Phase 0 MultiModelExecutor implementation.
+ *
+ * Takes a transcript, calls HybridRouter.chat() with a stronger-tier model,
+ * returns structured advice. No redaction, no circuit breaker, no cache —
+ * those arrive in Phase 1+.
+ */
+export declare class MultiModelExecutor implements IMultiModelExecutor {
+    private readonly router;
+    private readonly circuitBreaker;
+    constructor(router: HybridRouter, circuitBreakerConfig?: {
+        maxCallsPerSession?: number;
+        statePath?: string;
+    });
+    getCircuitBreakerState(sessionId: string): CircuitBreakerState;
+    resetCircuitBreaker(sessionId?: string): void;
+    consult(transcript: AdvisorTranscript, opts?: ConsultOptions): Promise<AdvisorResult>;
+    private persistConsultation;
+    /**
+     * Serialize a transcript into a single user message for the advisor.
+     * Kept simple for Phase 0 — no XML tags, no tool-result wrapping beyond
+     * role labels. This matches what most providers accept cleanly and is
+     * easy to evolve in Phase 1.
+     */
+    private serializeTranscript;
+}
+/**
+ * Factory for convenience — most callers construct directly, but this keeps
+ * the import surface consistent with other factories in `src/routing/`.
+ */
+export declare function createMultiModelExecutor(router: HybridRouter): MultiModelExecutor;
+//# sourceMappingURL=multi-model-executor.d.ts.map

package/dist/routing/advisor/multi-model-executor.js

@@ -0,0 +1,176 @@
+/**
+ * MultiModelExecutor — the execution layer for ADR-082's `triggerMultiModel` flag.
+ * ADR-092: Provider-Agnostic Advisor Strategy for QE Agents
+ *
+ * All phases implemented (ADR-092):
+ * - Consultation via HybridRouter.chat() with provider auto-detection
+ * - Secrets/PII redaction pre-flight (16 pattern categories)
+ * - Per-session circuit breaker (file-persisted, atomic writes)
+ * - Domain-specific advisor prompts via --advisor-prompt
+ * - Consultation sidecar persistence for RoutingFeedbackCollector
+ *
+ * Architecturally this class is small on purpose. TinyDancerRouter already
+ * decides WHEN advice is warranted (via `triggerMultiModel`). HybridRouter
+ * already handles provider dispatch, fallback, and cost tracking. This class
+ * is the narrow bridge between those two existing layers.
+ */
+import { createHash } from 'crypto';
+import { redact, validateProviderForAgent, isSelfHosted, } from './redaction.js';
+import { AdvisorCircuitBreaker } from './circuit-breaker.js';
+/**
+ * Default advisor model per ADR-092 Phase 0.
+ * OpenRouter exposes Anthropic Opus — chosen for vendor-independence as the
+ * default while direct Anthropic remains available for security-sensitive agents.
+ */
+export const DEFAULT_ADVISOR_PROVIDER = 'openrouter';
+export const DEFAULT_ADVISOR_MODEL = 'anthropic/claude-opus-4';
+export const DEFAULT_MAX_WORDS = 100;
+/**
+ * System prompt prepended to every advisor consultation.
+ *
+ * Text adapted from Anthropic's published canonical system prompt for the
+ * advisor tool (platform.claude.com/docs/en/agents-and-tools/tool-use/advisor-tool).
+ * Conciseness instruction reduces advisor output tokens by ~35-45% per published
+ * measurements without degrading call frequency.
+ */
+const ADVISOR_SYSTEM_PROMPT = `You are the advisor in an executor/advisor pattern. The executor has forwarded its full conversation transcript to you and is waiting for brief strategic guidance.
+
+You see the task, every tool call the executor has made, every result it has seen.
+
+Respond with a brief plan or correction in under 100 words. Use enumerated steps. No prose explanations. No pleasantries. Do not restate the task — the executor already knows the task. Focus on the next 1-3 concrete actions the executor should take, in order, with one-line reasons.
+
+If you see the executor about to commit to a wrong approach, say so in step 1. If you see the executor is on track, say so in one line and name the specific next action. If the transcript lacks enough information to give useful advice, say "INSUFFICIENT CONTEXT" and name the missing piece.`;
+/**
+ * Phase 0 MultiModelExecutor implementation.
+ *
+ * Takes a transcript, calls HybridRouter.chat() with a stronger-tier model,
+ * returns structured advice. No redaction, no circuit breaker, no cache —
+ * those arrive in Phase 1+.
+ */
+export class MultiModelExecutor {
+    router;
+    circuitBreaker;
+    constructor(router, circuitBreakerConfig) {
+        this.router = router;
+        this.circuitBreaker = new AdvisorCircuitBreaker(circuitBreakerConfig);
+    }
+    getCircuitBreakerState(sessionId) {
+        return this.circuitBreaker.getState(sessionId);
+    }
+    resetCircuitBreaker(sessionId) {
+        this.circuitBreaker.reset(sessionId);
+    }
+    async consult(transcript, opts = {}) {
+        const provider = opts.provider ?? DEFAULT_ADVISOR_PROVIDER;
+        const model = opts.model ?? DEFAULT_ADVISOR_MODEL;
+        const maxWords = opts.maxWords ?? DEFAULT_MAX_WORDS;
+        const agentName = opts.agentName ?? 'unknown';
+        const triggerReason = opts.triggerReason ?? 'manual';
+        const sessionId = opts.sessionId ?? 'default';
+        const redactionMode = opts.redact ?? 'strict';
+        // Phase 1 safety: validate provider is allowed for this agent
+        validateProviderForAgent(agentName, provider, redactionMode);
+        // Phase 1 safety: enforce per-session hard ceiling
+        const cbState = this.circuitBreaker.acquire(sessionId);
+        // Phase 1 safety: redact secrets before non-self-hosted providers see the transcript
+        let redactions = [];
+        let serialized = this.serializeTranscript(transcript, maxWords);
+        if (!isSelfHosted(provider)) {
+            const redactionResult = redact(serialized, redactionMode);
+            serialized = redactionResult.text;
+            redactions = redactionResult.redactions;
+        }
+        const messages = [{ role: 'user', content: serialized }];
+        const systemPrompt = opts.advisorSystemPrompt ?? ADVISOR_SYSTEM_PROMPT;
+        const params = {
+            messages,
+            systemPrompt,
+            agentType: agentName,
+            preferredProvider: provider,
+            model,
+            maxTokens: Math.max(300, Math.ceil(maxWords * 1.6)),
+            temperature: 0.2,
+            metadata: {
+                advisorCall: true,
+                triggerReason,
+                adrRef: 'ADR-092',
+            },
+        };
+        const response = await this.router.chat(params);
+        const advice = response.content.trim();
+        const adviceHash = createHash('sha256').update(advice).digest('hex');
+        const result = {
+            advice,
+            model: response.model,
+            provider: response.provider,
+            tokensIn: response.usage?.promptTokens ?? 0,
+            tokensOut: response.usage?.completionTokens ?? 0,
+            latencyMs: response.latencyMs,
+            costUsd: response.cost?.totalCost ?? 0,
+            adviceHash,
+            triggerReason,
+            cacheHit: response.cached ?? false,
+            redactionsApplied: redactions,
+            circuitBreakerRemaining: cbState.remaining,
+        };
+        // M1 fix: persist consultation to sidecar file so RoutingFeedbackCollector
+        // can pick it up when recording the routing outcome for this session.
+        this.persistConsultation(sessionId, result);
+        return result;
+    }
+    persistConsultation(sessionId, result) {
+        try {
+            const { writeFileSync, mkdirSync } = require('fs');
+            const { join } = require('path');
+            const { homedir } = require('os');
+            const dir = join(homedir(), '.agentic-qe', 'advisor', 'consultations');
+            mkdirSync(dir, { recursive: true });
+            const filePath = join(dir, `${sessionId}.json`);
+            writeFileSync(filePath, JSON.stringify({
+                model: result.model,
+                provider: result.provider,
+                tokensIn: result.tokensIn,
+                tokensOut: result.tokensOut,
+                latencyMs: result.latencyMs,
+                costUsd: result.costUsd,
+                adviceHash: result.adviceHash,
+                triggerReason: result.triggerReason,
+                redactionsApplied: result.redactionsApplied,
+                timestamp: new Date().toISOString(),
+            }, null, 2));
+        }
+        catch {
+            // Best-effort — don't fail the advisor call if persistence fails
+        }
+    }
+    /**
+     * Serialize a transcript into a single user message for the advisor.
+     * Kept simple for Phase 0 — no XML tags, no tool-result wrapping beyond
+     * role labels. This matches what most providers accept cleanly and is
+     * easy to evolve in Phase 1.
+     */
+    serializeTranscript(transcript, maxWords) {
+        const parts = [];
+        if (transcript.systemPrompt) {
+            parts.push(`# Executor System Prompt\n${transcript.systemPrompt}`);
+        }
+        if (transcript.taskDescription) {
+            parts.push(`# Task\n${transcript.taskDescription}`);
+        }
+        parts.push('# Conversation so far');
+        for (const msg of transcript.messages) {
+            const tag = msg.role.toUpperCase();
+            parts.push(`[${tag}] ${msg.content}`);
+        }
+        parts.push(`\n# Your job\nRespond with brief strategic guidance in under ${maxWords} words. Use enumerated steps. No prose.`);
+        return parts.join('\n\n');
+    }
+}
+/**
+ * Factory for convenience — most callers construct directly, but this keeps
+ * the import surface consistent with other factories in `src/routing/`.
+ */
+export function createMultiModelExecutor(router) {
+    return new MultiModelExecutor(router);
+}
+//# sourceMappingURL=multi-model-executor.js.map

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

@@ -0,0 +1,40 @@
+/**
+ * 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)
+ */
+export type RedactionMode = 'strict' | 'balanced' | 'off';
+export interface RedactionResult {
+    /** The redacted text */
+    text: string;
+    /** Categories of patterns found and redacted */
+    redactions: string[];
+    /** Total number of individual replacements made */
+    replacementCount: number;
+}
+export declare function isSelfHosted(provider: string): boolean;
+export declare function isSecurityAgentAllowed(provider: string): boolean;
+export declare function isSecurityAgent(agentName: string): boolean;
+/**
+ * Redact sensitive patterns from text.
+ * Returns the redacted text and a list of categories found.
+ */
+export declare function redact(text: string, mode?: RedactionMode): RedactionResult;
+/**
+ * Validate that the advisor call is allowed given the agent and provider.
+ * Throws with a descriptive message if the combination is forbidden.
+ */
+export declare function validateProviderForAgent(agentName: string, provider: string, redactionMode: RedactionMode): void;
+export declare class AdvisorRedactionError extends Error {
+    readonly exitCode: number;
+    constructor(message: string, exitCode: number);
+}
+//# sourceMappingURL=redaction.d.ts.map