agentic-qe 3.14.6 → 3.14.8

package/dist/cli/handlers/init-handler.d.ts

@@ -94,6 +94,8 @@ interface InitOptions {
     wizard?: boolean;
     auto?: boolean;
     upgrade?: boolean;
+    /** Explicitly install the optional browser engine and browser payload. */
+    browserEngine?: boolean;
     minimal?: boolean;
     skipPatterns?: boolean;
     skipCodeIndex?: boolean;

package/dist/cli/handlers/init-handler.js

@@ -37,6 +37,8 @@ export class InitHandler {
             .option('--wizard', 'Run interactive setup wizard')
             .option('--auto', 'Auto-configure based on project analysis')
             .option('-u, --upgrade', 'Upgrade existing installation (overwrite skills, agents, validation)')
+            .option('--browser-engine', 'Install optional Vibium and browser payload (explicit download)', false)
+            .option('--no-browser-engine', 'Skip optional browser setup (default)')
             .option('--minimal', 'Minimal configuration (skip optional features)')
             .option('--skip-patterns', 'Skip loading pre-trained patterns')
             .option('--skip-code-index', 'Skip code intelligence pre-scan (supported escape hatch — KG can be built later via `aqe code index`, also via env AQE_SKIP_CODE_INDEX=1)')
@@ -103,7 +105,7 @@ export class InitHandler {
             if (options.wizard || options.auto) {
                 console.log(chalk.blue('\n  Agentic QE v3 Initialization\n'));
                 // Use modular orchestrator for --auto or --modular
-                if (options.auto || options.modular) {
+                if (options.auto || options.modular || options.browserEngine) {
                     await this.runModularInit(options, context);
                     return;
                 }
@@ -128,7 +130,7 @@ export class InitHandler {
             // surface it was meant to suppress.
             const noClaudeRequested = options.claude === false;
             const noStatusLineRequested = options.statusline === false;
-            if (options.modular || platformRequested || databaseFree || noClaudeRequested || noStatusLineRequested) {
+            if (options.browserEngine || options.modular || platformRequested || databaseFree || noClaudeRequested || noStatusLineRequested) {
                 console.log(chalk.blue('\n  Agentic QE v3 Initialization\n'));
                 await this.runModularInit(options, context);
                 return;
@@ -173,6 +175,7 @@ export class InitHandler {
             autoMode: options.auto,
             upgrade: options.upgrade,
             minimal: options.minimal,
+            browserEngine: options.browserEngine,
             skipPatterns: options.skipPatterns,
             skipCodeIndex: options.skipCodeIndex,
             withN8n: options.withN8n,
@@ -301,6 +304,7 @@ export class InitHandler {
             projectRoot: process.cwd(),
             autoMode: options.auto,
             minimal: options.minimal,
+            browserEngine: options.browserEngine,
             skipPatterns: options.skipPatterns,
             withN8n: options.withN8n,
         };
@@ -449,6 +453,8 @@ Options:
   -u, --upgrade              Upgrade existing installation (overwrite skills, agents, validation)
   --minimal                  Minimal configuration (skip optional features)
   --skip-patterns            Skip loading pre-trained patterns
+  --browser-engine          Install optional Vibium and browser payload
+  --no-browser-engine       Skip browser setup (default)
   --with-n8n                 Install n8n workflow testing agents and skills
   --with-opencode            Include OpenCode agent/skill provisioning
   --with-codex               Include OpenAI Codex hooks, instructions, skills, and MCP

package/dist/cli/index.js

@@ -22,7 +22,11 @@ import { ALL_DOMAINS } from '../shared/types/index.js';
 import { applyCommandVerbosity, installCliLogGate, isCliLogLevelEnabled } from './log-gate.js';
 import { LogLevel } from '../logging/index.js';
 import { formatErrorForLog } from '../logging/redaction.js';
+import { releaseCliProcessStores } from './process-store-cleanup.js';
 installCliLogGate();
+// Backstop for direct process.exit() paths as well as cleanupAndExit(). An
+// in-process MCP owner still drains before exit; this callback is synchronous.
+process.on('exit', releaseCliProcessStores);
 // ============================================================================
 // CLI State
 // ============================================================================
@@ -180,11 +184,12 @@ async function cleanupAndExit(code = 0) {
         }
     }
     catch { /* best effort */ }
-    // Force exit immediately. Native NAPI handles (@ruvector/rvf-node and
+    releaseCliProcessStores();
+    // Force exit after synchronous store cleanup. Native NAPI handles (@ruvector/rvf-node and
     // historically @ruvector/router, replaced by hnswlib-node in #399 /
     // ADR-090) create ref'd event loop handles that prevent natural exit,
     // and dynamic import() of cleanup modules can load more native
-    // bindings that make it worse. Exit now, clean later.
+    // bindings that make it worse. Do not wait for asynchronous disposers here.
     process.exit(code);
 }
 // ============================================================================
@@ -214,6 +219,7 @@ program.hook('preAction', (_thisCommand, actionCommand) => {
 // ============================================================================
 import { registerLazyCommand, registerLazyHandler } from './lazy-registry.js';
 import { isForegroundCommandActive } from './foreground-command.js';
+import { requestOwnedShutdown } from '../kernel/process-lifecycle.js';
 registerLazyHandler(program, 'init', 'Initialize the AQE v3 system', () => import('./handlers/init-handler.js').then(m => m.createInitHandler(cleanupAndExit)), context);
 registerLazyHandler(program, 'status', 'Show system status', () => import('./handlers/status-handler.js').then(m => m.createStatusHandler(cleanupAndExit, ensureInitializedStrict)), context);
 registerLazyHandler(program, 'health', 'Check system health', () => import('./handlers/status-handler.js').then(m => m.createHealthHandler(cleanupAndExit, ensureInitializedStrict)), context);
@@ -379,12 +385,19 @@ registerLazyCommand(program, {
 // ============================================================================
 // Shutdown Handlers
 // ============================================================================
+// #801: `aqe mcp` runs the MCP server in this process and it claims the
+// lifecycle; exiting here would pre-empt its graceful shutdown (which releases
+// the shared patterns RVF lock). Every other command keeps the immediate exit.
 process.on('SIGINT', async () => {
+    if (requestOwnedShutdown('SIGINT'))
+        return;
     console.log(chalk.yellow('\n\nShutting down...'));
     console.log(chalk.green('Shutdown complete\n'));
     await cleanupAndExit(0);
 });
 process.on('SIGTERM', async () => {
+    if (requestOwnedShutdown('SIGTERM'))
+        return;
     console.log(chalk.yellow('\nReceived SIGTERM, shutting down gracefully...'));
     await cleanupAndExit(0);
 });

package/dist/cli/process-store-cleanup.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Release the CLI's process-wide stores without awaiting native work (#814).
+ * Each closer owns its handle; never remove a lock file by path. Synchronous
+ * cleanup also runs when Commander or another module calls process.exit().
+ */
+export declare function releaseCliProcessStores(): void;
+//# sourceMappingURL=process-store-cleanup.d.ts.map

package/dist/cli/process-store-cleanup.js

@@ -0,0 +1,27 @@
+import { resetSharedRvfAdapter } from '../integrations/ruvector/shared-rvf-adapter.js';
+import { resetSharedRvfDualWriter } from '../integrations/ruvector/shared-rvf-dual-writer.js';
+import { closeRegisteredStores } from '../kernel/process-lifecycle.js';
+let released = false;
+/**
+ * Release the CLI's process-wide stores without awaiting native work (#814).
+ * Each closer owns its handle; never remove a lock file by path. Synchronous
+ * cleanup also runs when Commander or another module calls process.exit().
+ */
+export function releaseCliProcessStores() {
+    if (released)
+        return;
+    released = true;
+    try {
+        resetSharedRvfDualWriter();
+    }
+    catch { /* keep closing other stores */ }
+    try {
+        resetSharedRvfAdapter();
+    }
+    catch { /* keep closing other stores */ }
+    try {
+        closeRegisteredStores();
+    }
+    catch { /* best effort on process exit */ }
+}
+//# sourceMappingURL=process-store-cleanup.js.map

package/dist/cli/utils/ci-config.d.ts

@@ -67,6 +67,8 @@ export interface CIPhaseResult {
 }
 /** Result of the full CI run */
 export interface CIRunResult {
+    /** Invalid phase selections fail before execution and retain a fresh report. */
+    configurationError?: string;
     config: string;
     startedAt: Date;
     completedAt: Date;
@@ -93,9 +95,7 @@ export interface CIConfigParseResult {
  * Parse a .aqe-ci.yml file into a CIConfig.
  */
 export declare function parseCIConfigFile(filePath: string): CIConfigParseResult;
-/**
- * Parse CI config YAML content.
- */
+/** Parse CI YAML faithfully, validating typed fields before any phase executes. */
 export declare function parseCIConfigContent(content: string, sourcePath?: string): CIConfigParseResult;
 /**
  * Get the default CI config (used when no .aqe-ci.yml exists).

package/dist/cli/utils/ci-config.js

@@ -6,7 +6,7 @@
  */
 import * as fs from 'fs';
 import * as path from 'path';
-import { parseYAMLContent } from './workflow-parser.js';
+import { isCollection, isScalar, parseDocument, visit } from 'yaml';
 // ============================================================================
 // Default Config
 // ============================================================================
@@ -100,89 +100,223 @@ export function parseCIConfigFile(filePath) {
     }
     return parseCIConfigContent(content, filePath);
 }
-/**
- * Parse CI config YAML content.
- */
+const YAML_MAX_LINES = 10000;
+const YAML_MAX_LINE_LENGTH = 10000;
+const YAML_MAX_DEPTH = 20;
+const UNSAFE_YAML_KEYS = new Set(['__proto__', 'constructor', 'prototype']);
+function isRecord(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value) &&
+        (Object.getPrototypeOf(value) === Object.prototype || Object.getPrototypeOf(value) === null);
+}
+/** Keep the previous parser's input bounds; reject unsafe expanded aliases too. */
+function parseCIYAML(content) {
+    const lines = content.split('\n');
+    if (lines.length > YAML_MAX_LINES)
+        throw new Error(`YAML exceeds maximum allowed lines (${YAML_MAX_LINES})`);
+    if (lines.some(line => line.length > YAML_MAX_LINE_LENGTH)) {
+        throw new Error(`YAML exceeds maximum line length (${YAML_MAX_LINE_LENGTH})`);
+    }
+    const document = parseDocument(content, { prettyErrors: false, merge: true });
+    if (document.errors.length)
+        throw new Error(document.errors.map(error => error.message).join('; '));
+    visit(document, {
+        Collection: (_key, _node, ancestry) => {
+            if (ancestry.filter(isCollection).length >= YAML_MAX_DEPTH) {
+                throw new Error(`YAML exceeds maximum depth (${YAML_MAX_DEPTH})`);
+            }
+        },
+        Pair: (_key, pair) => {
+            if (isScalar(pair.key) && UNSAFE_YAML_KEYS.has(String(pair.key.value))) {
+                throw new Error(`Unsafe YAML key: ${pair.key.value}`);
+            }
+        },
+    });
+    const parsed = document.contents === null ? {} : document.toJS({ maxAliasCount: 100 });
+    // Alias references may add nesting or cycles that the syntax tree does not show.
+    function checkExpanded(value, depth, ancestors) {
+        if (value === null || typeof value !== 'object')
+            return;
+        if (depth > YAML_MAX_DEPTH)
+            throw new Error(`YAML exceeds maximum depth (${YAML_MAX_DEPTH})`);
+        if (ancestors.has(value))
+            throw new Error('Cyclic YAML aliases are not supported');
+        ancestors.add(value);
+        for (const child of Object.values(value))
+            checkExpanded(child, depth + 1, ancestors);
+        ancestors.delete(value);
+    }
+    checkExpanded(parsed, 0, new Set());
+    if (!isRecord(parsed))
+        throw new Error('CI config must be a YAML mapping');
+    return parsed;
+}
+/** Parse CI YAML faithfully, validating typed fields before any phase executes. */
 export function parseCIConfigContent(content, sourcePath) {
-    const errors = [];
     let parsed;
     try {
-        parsed = parseYAMLContent(content);
+        parsed = parseCIYAML(content);
     }
     catch (err) {
         return { success: false, errors: [`Invalid YAML: ${err}`] };
     }
-    // Build config with defaults
-    const config = {
-        version: parsed.version || DEFAULT_CI_CONFIG.version,
-        name: parsed.name || DEFAULT_CI_CONFIG.name,
-        phases: [],
-        output: { ...DEFAULT_CI_CONFIG.output },
-        qualityGate: { ...DEFAULT_CI_CONFIG.qualityGate, thresholds: { ...DEFAULT_CI_CONFIG.qualityGate.thresholds } },
-    };
-    // Parse output section
-    if (parsed.output && typeof parsed.output === 'object') {
-        const out = parsed.output;
-        if (out.format)
-            config.output.format = out.format;
-        if (out.directory)
-            config.output.directory = out.directory;
-        if (out.combined_report !== undefined)
-            config.output.combinedReport = out.combined_report;
-    }
-    // Parse quality_gate section
-    if (parsed.quality_gate && typeof parsed.quality_gate === 'object') {
-        const qg = parsed.quality_gate;
-        if (qg.enforced !== undefined)
-            config.qualityGate.enforced = qg.enforced;
-        if (qg.thresholds && typeof qg.thresholds === 'object') {
-            const th = qg.thresholds;
-            if (th.coverage !== undefined)
-                config.qualityGate.thresholds.coverage = th.coverage;
-            if (th.security !== undefined)
-                config.qualityGate.thresholds.security = th.security;
-            if (th.quality !== undefined)
-                config.qualityGate.thresholds.quality = th.quality;
+    const errors = [];
+    const config = getDefaultCIConfig();
+    function readString(record, key, fallback, label) {
+        const value = record[key];
+        if (value === undefined)
+            return fallback;
+        if (typeof value !== 'string' || !value.trim()) {
+            errors.push(`${label} must be a non-empty string`);
+            return fallback;
         }
+        return value;
     }
-    // Parse phases
-    if (parsed.phases && Array.isArray(parsed.phases)) {
-        for (let i = 0; i < parsed.phases.length; i++) {
-            const p = parsed.phases[i];
-            if (!p.name) {
-                errors.push(`Phase ${i + 1} must have a "name" field`);
-                continue;
-            }
-            if (!p.type) {
-                errors.push(`Phase "${p.name}" must have a "type" field`);
-                continue;
-            }
-            const validTypes = ['test', 'coverage', 'security', 'quality-gate', 'code-intelligence', 'custom'];
-            if (!validTypes.includes(p.type)) {
-                errors.push(`Phase "${p.name}" has invalid type "${p.type}". Valid: ${validTypes.join(', ')}`);
-                continue;
+    function readBoolean(record, key, fallback, label) {
+        const value = record[key];
+        if (value === undefined)
+            return fallback;
+        if (typeof value !== 'boolean') {
+            errors.push(`${label} must be a boolean`);
+            return fallback;
+        }
+        return value;
+    }
+    if (parsed.version !== undefined) {
+        if (typeof parsed.version === 'number' && Number.isFinite(parsed.version))
+            config.version = String(parsed.version);
+        else
+            config.version = readString(parsed, 'version', config.version, 'version');
+    }
+    config.name = readString(parsed, 'name', config.name, 'name');
+    if (parsed.output !== undefined) {
+        if (!isRecord(parsed.output))
+            errors.push('output must be a mapping');
+        else {
+            config.output.format = readString(parsed.output, 'format', config.output.format, 'output.format');
+            config.output.directory = readString(parsed.output, 'directory', config.output.directory, 'output.directory');
+            config.output.combinedReport = readBoolean(parsed.output, 'combined_report', config.output.combinedReport, 'output.combined_report');
+        }
+    }
+    if (parsed.quality_gate !== undefined) {
+        if (!isRecord(parsed.quality_gate))
+            errors.push('quality_gate must be a mapping');
+        else {
+            const gate = parsed.quality_gate;
+            config.qualityGate.enforced = readBoolean(gate, 'enforced', config.qualityGate.enforced, 'quality_gate.enforced');
+            if (gate.thresholds !== undefined) {
+                if (!isRecord(gate.thresholds))
+                    errors.push('quality_gate.thresholds must be a mapping');
+                else {
+                    for (const key of ['coverage', 'quality']) {
+                        const value = gate.thresholds[key];
+                        if (value === undefined)
+                            continue;
+                        if (typeof value !== 'number' || !Number.isFinite(value) || value < 0 || value > 100) {
+                            errors.push(`quality_gate.thresholds.${key} must be a finite number between 0 and 100`);
+                        }
+                        else
+                            config.qualityGate.thresholds[key] = value;
+                    }
+                    if (gate.thresholds.security !== undefined) {
+                        const value = gate.thresholds.security;
+                        if (typeof value !== 'string' || !['none', 'low', 'medium', 'high'].includes(value)) {
+                            errors.push('quality_gate.thresholds.security must be none, low, medium or high');
+                        }
+                        else
+                            config.qualityGate.thresholds.security = value;
+                    }
+                }
             }
-            const phase = {
-                name: p.name,
-                type: p.type,
-                enabled: p.enabled !== false,
-                config: p.config || {},
-                continueOnFailure: p.continue_on_failure || false,
-                timeout: p.timeout || 300,
-            };
-            config.phases.push(phase);
         }
     }
-    else {
-        // Use defaults if no phases specified
-        config.phases = [...DEFAULT_CI_CONFIG.phases];
+    if (parsed.phases !== undefined) {
+        config.phases = [];
+        if (!Array.isArray(parsed.phases))
+            errors.push('phases must be a sequence');
+        else
+            for (const [index, value] of parsed.phases.entries()) {
+                if (!isRecord(value)) {
+                    errors.push(`Phase ${index + 1} must be a mapping`);
+                    continue;
+                }
+                if (value.name === undefined)
+                    errors.push(`Phase ${index + 1} must have a name`);
+                const name = readString(value, 'name', '', `Phase ${index + 1} name`);
+                const validTypes = ['test', 'coverage', 'security', 'quality-gate', 'code-intelligence', 'custom'];
+                if (!validTypes.includes(value.type)) {
+                    errors.push(`Phase "${name}" has invalid type "${value.type}". Valid: ${validTypes.join(', ')}`);
+                    continue;
+                }
+                let timeout = 300;
+                if (value.timeout !== undefined) {
+                    if (typeof value.timeout !== 'number' || !Number.isFinite(value.timeout) || value.timeout <= 0) {
+                        errors.push(`Phase "${name}" timeout must be a positive finite number`);
+                    }
+                    else
+                        timeout = value.timeout;
+                }
+                if (value.config !== undefined && !isRecord(value.config))
+                    errors.push(`Phase "${name}" config must be a mapping`);
+                config.phases.push({
+                    name, type: value.type, timeout,
+                    enabled: readBoolean(value, 'enabled', true, `Phase "${name}" enabled`),
+                    continueOnFailure: readBoolean(value, 'continue_on_failure', false, `Phase "${name}" continue_on_failure`),
+                    config: isRecord(value.config) ? { ...value.config } : {},
+                });
+            }
     }
-    if (config.phases.length === 0) {
+    if (config.phases.length === 0)
         errors.push('Config must have at least one phase');
+    // Paths in a file are relative to that file's project, not the caller's cwd.
+    // Resolve existing ancestors too so a symlink cannot bypass containment.
+    const root = path.resolve(sourcePath ? path.dirname(sourcePath) : process.cwd());
+    function canonicalAncestor(candidate) {
+        let ancestor = candidate;
+        const suffix = [];
+        while (!fs.existsSync(ancestor)) {
+            const parent = path.dirname(ancestor);
+            if (parent === ancestor)
+                break;
+            suffix.unshift(path.basename(ancestor));
+            ancestor = parent;
+        }
+        return path.resolve(fs.realpathSync(ancestor), ...suffix);
     }
-    if (errors.length > 0) {
-        return { success: false, config, errors };
+    function containedPath(value, label) {
+        if (typeof value !== 'string' || !value.trim() || value.includes('\0')) {
+            errors.push(`${label} must be a non-empty relative path`);
+            return undefined;
+        }
+        const resolved = path.resolve(root, value);
+        const relative = path.relative(root, resolved);
+        if (path.isAbsolute(value) || path.win32.isAbsolute(value) ||
+            relative === '..' || relative.startsWith(`..${path.sep}`) || path.isAbsolute(relative)) {
+            errors.push(`${label} must stay inside the project and use a relative path`);
+            return undefined;
+        }
+        try {
+            const realRelative = path.relative(canonicalAncestor(root), canonicalAncestor(resolved));
+            if (realRelative === '..' || realRelative.startsWith(`..${path.sep}`) || path.isAbsolute(realRelative)) {
+                errors.push(`${label} must stay inside the project (symlink escapes are not allowed)`);
+                return undefined;
+            }
+        }
+        catch (error) {
+            errors.push(`${label} cannot be resolved safely: ${error}`);
+            return undefined;
+        }
+        return sourcePath ? resolved : value;
+    }
+    config.output.directory = containedPath(config.output.directory, 'output.directory') ?? config.output.directory;
+    for (const phase of config.phases) {
+        if (phase.config.target !== undefined) {
+            const target = containedPath(phase.config.target, `Phase "${phase.name}" config.target`);
+            if (target !== undefined)
+                phase.config.target = target;
+        }
     }
+    if (errors.length > 0)
+        return { success: false, config, errors };
     return { success: true, config, errors: [], configPath: sourcePath };
 }
 /**

package/dist/coordination/handlers/test-execution-handlers.js

@@ -87,7 +87,7 @@ export function registerTestExecutionHandlers(ctx) {
                 // Return a graceful fallback with warning when no source files provided
                 return ok({
                     testsGenerated: 0,
-                    coverageEstimate: 0,
+                    coverageEstimate: null,
                     tests: [],
                     patternsUsed: [],
                     warning: 'No source files or code provided for test generation. Provide sourceCode, filePath, or sourceFiles in the payload.',
@@ -111,6 +111,7 @@ export function registerTestExecutionHandlers(ctx) {
                 coverageTarget: payload.coverageGoal || 80,
                 patterns: [],
                 importPathOverrides,
+                behaviorExamples: payload.behaviorExamples,
             });
             // Always clean up the temp file we created — even on failure
             if (tempPath) {
@@ -134,6 +135,8 @@ export function registerTestExecutionHandlers(ctx) {
                     type: t.type,
                     sourceFile: rewritten.sourceFile,
                     assertions: t.assertions,
+                    generationMode: t.generationMode,
+                    generationLimits: t.generationLimits,
                     testCode: rewritten.testCode,
                 };
             });
@@ -148,13 +151,15 @@ export function registerTestExecutionHandlers(ctx) {
                 patternsUsed: generatedTests.patternsUsed,
                 llmEnhanced,
                 ...(llmEnhanced ? {} : {
-                    generationMode: 'deterministic-template',
-                    note: payload.aiEnhancement === false
-                        ? 'LLM enhancement was disabled by the caller (aiEnhancement: false).'
-                        : 'No LLM provider was available, so tests are deterministic template ' +
-                            'scaffolding rather than source-aware. Configure a provider in ' +
-                            '.agentic-qe/llm-config.json (or set a provider API key) and ensure ' +
-                            'AQE_LLM_ROUTER_DISABLED is not set.',
+                    generationMode: generatedTests.tests.some(t => t.generationMode === 'behavior-examples') ? 'behavior-examples' : 'deterministic-template',
+                    note: generatedTests.tests.some(t => t.generationMode === 'behavior-examples')
+                        ? 'Assertions use caller-supplied specification examples. Coverage is unmeasured; inspect generationLimits on each test.'
+                        : payload.aiEnhancement === false
+                            ? 'LLM enhancement was disabled by the caller (aiEnhancement: false). Coverage is unmeasured; inspect generationLimits on each test.'
+                            : 'No LLM provider was available, so tests are deterministic template ' +
+                                'scaffolding rather than source-aware. Configure a provider in ' +
+                                '.agentic-qe/llm-config.json (or set a provider API key) and ensure ' +
+                                'AQE_LLM_ROUTER_DISABLED is not set.',
                 }),
             });
         }

package/dist/coordination/index.d.ts

@@ -7,7 +7,7 @@ export * from './consensus';
 export * from './claims';
 export type { Protocol, ProtocolSchedule, ProtocolAction, ProtocolExecution, ProtocolExecutionStatus, ActionExecutionResult, ActionExecutionStatus, ProtocolExecutor, WorkflowDefinition as CrossDomainWorkflowDefinition, WorkflowStep as CrossDomainWorkflowStep, WorkflowCondition, WorkflowTrigger as CrossDomainWorkflowTrigger, WorkflowHandler, WorkflowContext as CrossDomainWorkflowContext, WorkflowExecution as CrossDomainWorkflowExecution, WorkflowExecutionStatus as CrossDomainWorkflowExecutionStatus, StepExecutionResult as CrossDomainStepExecutionResult, WorkflowExecutor, CrossDomainHandler, CrossDomainHandlerConfig, DomainRoute, EventSubscription, EventCorrelation, EventAggregation, CrossDomainRouter, } from './interfaces';
 export { TaskAuditLogger, createTaskAuditLogger, } from './services';
-export type { TaskAuditEntry, TaskAuditConfig, TaskOperation, } from './services';
+export type { TaskAuditEntry, TaskAuditSequencedEntry, TaskAuditConfig, TaskAuditFilter, TaskAuditWindow, TaskAuditSnapshot, TaskOperation, } from './services';
 export { CrossDomainEventRouter, createCrossDomainRouter, } from './cross-domain-router';
 export { DefaultProtocolExecutor, createProtocolExecutor, } from './protocol-executor';
 export { WorkflowOrchestrator, createWorkflowOrchestrator, WorkflowEvents, } from './workflow-orchestrator';

package/dist/coordination/queen-event-handlers.js

@@ -162,7 +162,7 @@ export async function handleTaskCompleted(ctx, event) {
 // Task failed handler
 // ============================================================================
 export async function handleTaskFailed(ctx, event) {
-    const { taskId, error } = event.payload;
+    const { taskId, error, callerError } = event.payload;
     const cancelled = settleCancelledTask(ctx.tasks, taskId);
     if (cancelled.ignored) {
         if (cancelled.settledNow) {
@@ -177,8 +177,10 @@ export async function handleTaskFailed(ctx, event) {
         if (execution.status === 'running' || execution.status === 'assigned') {
             ctx.runningTaskCounter = Math.max(0, ctx.runningTaskCounter - 1);
         }
-        // ADR-064: Record failure in domain circuit breaker
-        if (ctx.domainBreakerRegistry && execution.assignedDomain) {
+        // ADR-064: Record failure in domain circuit breaker. A task rejected for
+        // invalid caller input says nothing about the domain's health, so it must
+        // not open the breaker for every other caller (#795).
+        if (ctx.domainBreakerRegistry && execution.assignedDomain && !callerError) {
             ctx.domainBreakerRegistry.getBreaker(execution.assignedDomain).recordFailure(new Error(error || 'Task failed'));
         }
         // ADR-064 Phase 3: Fail the trace span for this task
@@ -189,8 +191,9 @@ export async function handleTaskFailed(ctx, event) {
                 ctx.taskTraceContexts.delete(taskId);
             }
         }
-        // Check if we should retry
-        if (execution.retryCount < ctx.config.taskRetryLimit) {
+        // Check if we should retry. Caller-input errors are deterministic, so a
+        // retry would fail the same way.
+        if (!callerError && execution.retryCount < ctx.config.taskRetryLimit) {
             ctx.auditLogger.logFail(taskId, execution.assignedAgents[0], error);
             const retried = {
                 ...execution,
@@ -227,7 +230,7 @@ export async function handleTaskFailed(ctx, event) {
             }
             // ADR-064 Phase 4A: Create competing hypotheses investigation for
             // permanent failures in critical domains (p0/p1 priority)
-            if (ctx.hypothesisManager && (execution.task.priority === 'p0' || execution.task.priority === 'p1')) {
+            if (!callerError && ctx.hypothesisManager && (execution.task.priority === 'p0' || execution.task.priority === 'p1')) {
                 try {
                     const domain = execution.assignedDomain || 'test-generation';
                     const investigation = ctx.hypothesisManager.createInvestigation(taskId, domain, `Root cause analysis for ${execution.task.type} failure: ${error}`);

package/dist/coordination/result-saver.js

@@ -372,7 +372,7 @@ end_of_record
 | Metric | Value |
 |--------|-------|
 | Tests Generated | ${data.testsGenerated} |
-| Coverage Estimate | ${data.coverageEstimate}% |
+| Coverage Estimate | ${data.coverageEstimate == null ? 'Unmeasured' : data.coverageEstimate + '%'} |
 | Patterns Used | ${data.patternsUsed.length} |
 
 ## Patterns Applied

package/dist/coordination/services/index.d.ts

@@ -2,5 +2,5 @@
  * Agentic QE v3 - Coordination Services
  * Exports services used by coordination components
  */
-export { TaskAuditLogger, createTaskAuditLogger, type TaskAuditEntry, type TaskAuditConfig, type TaskOperation, } from './task-audit-logger';
+export { TaskAuditLogger, createTaskAuditLogger, type TaskAuditEntry, type TaskAuditSequencedEntry, type TaskAuditConfig, type TaskAuditFilter, type TaskAuditWindow, type TaskAuditSnapshot, type TaskOperation, } from './task-audit-logger';
 //# sourceMappingURL=index.d.ts.map