agentic-qe 3.10.4 → 3.10.6

package/dist/mcp/handlers/core-handlers.d.ts

@@ -37,6 +37,26 @@ export declare function getFleetState(): FleetState;
  * Check if fleet is initialized
  */
 export declare function isFleetInitialized(): boolean;
+/**
+ * Adopt already-initialized components into the fleet state.
+ *
+ * The CLI's autoInitialize() builds the same kernel/queen/router stack as
+ * handleFleetInit but kept it in its own CLIContext, so every handler guarded
+ * by isFleetInitialized() (memory, agent, task, team, pipeline) rejected CLI
+ * invocations with "Fleet not initialized" even after a successful auto-init.
+ * Bridging the components here gives the MCP server and the CLI one shared
+ * fleet state (MCP-CLI parity).
+ *
+ * Idempotent: if a fleet is already initialized, returns the existing fleetId
+ * without touching state.
+ */
+export declare function adoptExternalFleet(components: {
+    kernel: QEKernel;
+    queen: QueenCoordinator;
+    router?: CrossDomainEventRouter | null;
+    workflowOrchestrator?: WorkflowOrchestrator | null;
+    topology?: TopologyType;
+}): string;
 /**
  * Get the current fleet topology
  */

package/dist/mcp/handlers/core-handlers.js

@@ -42,6 +42,34 @@ export function getFleetState() {
 export function isFleetInitialized() {
     return state.initialized && state.kernel !== null && state.queen !== null;
 }
+/**
+ * Adopt already-initialized components into the fleet state.
+ *
+ * The CLI's autoInitialize() builds the same kernel/queen/router stack as
+ * handleFleetInit but kept it in its own CLIContext, so every handler guarded
+ * by isFleetInitialized() (memory, agent, task, team, pipeline) rejected CLI
+ * invocations with "Fleet not initialized" even after a successful auto-init.
+ * Bridging the components here gives the MCP server and the CLI one shared
+ * fleet state (MCP-CLI parity).
+ *
+ * Idempotent: if a fleet is already initialized, returns the existing fleetId
+ * without touching state.
+ */
+export function adoptExternalFleet(components) {
+    if (isFleetInitialized()) {
+        return state.fleetId;
+    }
+    state.fleetId = `fleet-${uuidv4().slice(0, 8)}`;
+    state.kernel = components.kernel;
+    state.queen = components.queen;
+    state.router = components.router ?? null;
+    state.workflowOrchestrator = components.workflowOrchestrator ?? null;
+    state.initialized = true;
+    state.initTime = new Date();
+    state.topology = components.topology ?? 'hierarchical';
+    state.agentLevels.clear();
+    return state.fleetId;
+}
 /**
  * Get the current fleet topology
  */

package/dist/mcp/handlers/domain-handler-configs.d.ts

@@ -8,6 +8,7 @@
  */
 import { DomainHandlerConfig } from './handler-factory';
 import { TestGenerateParams, TestGenerateResult, TestExecuteParams, CoverageAnalyzeParams, CoverageAnalyzeResult, QualityAssessParams, SecurityScanParams, ContractValidateParams, AccessibilityTestParams, ChaosTestParams } from '../types';
+import { type RiskDecision } from '../../contracts/verdicts.js';
 export interface TestExecuteResult {
     taskId: string;
     status: string;
@@ -32,6 +33,8 @@ export interface QualityAssessResult {
     recommendations: string[];
     duration: number;
     savedFiles?: string[];
+    /** ADR-103: versioned, schema-validated gate verdict (additive) */
+    riskDecision?: RiskDecision;
 }
 export interface SecurityScanResult {
     taskId: string;

package/dist/mcp/handlers/domain-handler-configs.js

@@ -9,6 +9,7 @@
 import { generateV2LearningFeedback, analyzeComplexity, generateV2AIInsights, generateV2Tests, detectAntiPatterns, generateTestId, } from './handler-factory';
 import { MetricsCollector } from '../metrics';
 import { DEFAULT_FRAMEWORKS, FRAMEWORK_TO_LANGUAGE, } from '../../shared/types/test-frameworks.js';
+import { buildRiskDecisionFromQualityGate, validateRiskDecision, } from '../../contracts/verdicts.js';
 const SUPPORTED_LANGUAGES = Object.keys(DEFAULT_FRAMEWORKS);
 /**
  * Normalize a language string from MCP input. Returns the canonical
@@ -348,16 +349,27 @@ export const qualityAssessConfig = {
         useAgentBooster: routingResult?.useAgentBooster,
         compiledContext: routingResult?.compiledContext,
     }),
-    mapToResult: (taskId, data, duration, savedFiles) => ({
-        taskId,
-        status: 'completed',
-        qualityScore: data.qualityScore || 0,
-        passed: data.passed || false,
-        metrics: data.metrics || {},
-        recommendations: data.recommendations || [],
-        duration,
-        savedFiles,
-    }),
+    mapToResult: (taskId, data, duration, savedFiles) => {
+        // ADR-103: attach a schema-validated RiskDecision envelope at the MCP
+        // boundary (additive — existing fields unchanged). Omit rather than
+        // emit an invalid envelope.
+        const riskDecision = buildRiskDecisionFromQualityGate({
+            passed: typeof data.passed === 'boolean' ? data.passed : undefined,
+            qualityScore: data.qualityScore,
+            recommendations: data.recommendations || [],
+        });
+        return {
+            taskId,
+            status: 'completed',
+            qualityScore: data.qualityScore || 0,
+            passed: data.passed || false,
+            metrics: data.metrics || {},
+            recommendations: data.recommendations || [],
+            duration,
+            savedFiles,
+            ...(validateRiskDecision(riskDecision).valid ? { riskDecision } : {}),
+        };
+    },
 };
 // ============================================================================
 // Security Scan Configuration

package/dist/mcp/handlers/validation-pipeline-handler.d.ts

@@ -42,6 +42,25 @@ export interface ValidationPipelineResult {
         id: string;
         stepId: string;
         severity: string;
+        /** ADR-105: what kind of evidence backs this finding */
+        evidenceClass: string;
+        evidenceArtifact?: {
+            command?: string;
+            output?: string;
+            dataSource?: string;
+        };
+        title: string;
+        description: string;
+    }>;
+    /**
+     * INFERRED findings from failed blocking steps (ADR-105) — queued for
+     * adversarial verification, not allowed to gate. Same projection as findings.
+     */
+    needsVerification: Array<{
+        id: string;
+        stepId: string;
+        severity: string;
+        evidenceClass: string;
         title: string;
         description: string;
     }>;

package/dist/mcp/handlers/validation-pipeline-handler.js

@@ -102,9 +102,19 @@ export async function handleValidationPipeline(params) {
                     id: f.id,
                     stepId: f.stepId,
                     severity: f.severity,
+                    evidenceClass: f.evidenceClass,
+                    evidenceArtifact: f.evidenceArtifact,
                     title: f.title,
                     description: f.description,
                 }))),
+                needsVerification: result.needsVerification.map(f => ({
+                    id: f.id,
+                    stepId: f.stepId,
+                    severity: f.severity,
+                    evidenceClass: f.evidenceClass,
+                    title: f.title,
+                    description: f.description,
+                })),
             },
         };
     }

package/dist/migrations/20260611_add_pattern_nulls_table.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Agentic QE v3 - Pattern Nulls Migration (ADR-110, issue #522)
+ *
+ * Kept nulls: first-class negative pattern records. When an applied pattern
+ * fails in a context, the failure is stored and consolidated per
+ * (pattern, context_fingerprint) so retrieval can surface "succeeded 12x,
+ * failed 3x — failures clustered in <context>" and ranking can discount by
+ * context-matched null density. Nulls are information, not tombstones —
+ * never deleted on pattern success elsewhere.
+ *
+ * Additive-only: no existing table or row is touched.
+ */
+import type { Database as DatabaseType } from 'better-sqlite3';
+export declare const MIGRATION_VERSION = "20260611_add_pattern_nulls_table";
+export declare const PATTERN_NULLS_SCHEMA = "\n  -- Negative pattern records (ADR-110 kept nulls)\n  CREATE TABLE IF NOT EXISTS qe_pattern_nulls (\n    id TEXT PRIMARY KEY,\n    pattern_id TEXT NOT NULL REFERENCES qe_patterns(id),\n    context_fingerprint TEXT NOT NULL,\n    failure_mode TEXT NOT NULL,\n    trajectory_ref TEXT,\n    evidence_class TEXT NOT NULL DEFAULT 'EXECUTED'\n      CHECK (evidence_class IN ('EXECUTED','STATIC','INFERRED','CONJECTURE')),\n    consolidated_count INTEGER NOT NULL DEFAULT 1,\n    created_at TEXT DEFAULT (datetime('now')),\n    updated_at TEXT DEFAULT (datetime('now')),\n    UNIQUE (pattern_id, context_fingerprint)\n  );\n\n  CREATE INDEX IF NOT EXISTS idx_pattern_nulls_pattern ON qe_pattern_nulls(pattern_id);\n  CREATE INDEX IF NOT EXISTS idx_pattern_nulls_context ON qe_pattern_nulls(context_fingerprint);\n";
+export declare function applyMigration(db: DatabaseType): void;
+export declare function isMigrationApplied(db: DatabaseType): boolean;
+export declare function rollbackMigration(db: DatabaseType): void;
+declare const _default: {
+    version: string;
+    apply: typeof applyMigration;
+    isApplied: typeof isMigrationApplied;
+    rollback: typeof rollbackMigration;
+};
+export default _default;
+//# sourceMappingURL=20260611_add_pattern_nulls_table.d.ts.map

package/dist/migrations/20260611_add_pattern_nulls_table.js

@@ -0,0 +1,63 @@
+/**
+ * Agentic QE v3 - Pattern Nulls Migration (ADR-110, issue #522)
+ *
+ * Kept nulls: first-class negative pattern records. When an applied pattern
+ * fails in a context, the failure is stored and consolidated per
+ * (pattern, context_fingerprint) so retrieval can surface "succeeded 12x,
+ * failed 3x — failures clustered in <context>" and ranking can discount by
+ * context-matched null density. Nulls are information, not tombstones —
+ * never deleted on pattern success elsewhere.
+ *
+ * Additive-only: no existing table or row is touched.
+ */
+export const MIGRATION_VERSION = '20260611_add_pattern_nulls_table';
+export const PATTERN_NULLS_SCHEMA = `
+  -- Negative pattern records (ADR-110 kept nulls)
+  CREATE TABLE IF NOT EXISTS qe_pattern_nulls (
+    id TEXT PRIMARY KEY,
+    pattern_id TEXT NOT NULL REFERENCES qe_patterns(id),
+    context_fingerprint TEXT NOT NULL,
+    failure_mode TEXT NOT NULL,
+    trajectory_ref TEXT,
+    evidence_class TEXT NOT NULL DEFAULT 'EXECUTED'
+      CHECK (evidence_class IN ('EXECUTED','STATIC','INFERRED','CONJECTURE')),
+    consolidated_count INTEGER NOT NULL DEFAULT 1,
+    created_at TEXT DEFAULT (datetime('now')),
+    updated_at TEXT DEFAULT (datetime('now')),
+    UNIQUE (pattern_id, context_fingerprint)
+  );
+
+  CREATE INDEX IF NOT EXISTS idx_pattern_nulls_pattern ON qe_pattern_nulls(pattern_id);
+  CREATE INDEX IF NOT EXISTS idx_pattern_nulls_context ON qe_pattern_nulls(context_fingerprint);
+`;
+export function applyMigration(db) {
+    db.exec(PATTERN_NULLS_SCHEMA);
+}
+export function isMigrationApplied(db) {
+    try {
+        const result = db.prepare(`
+      SELECT COUNT(*) as count FROM sqlite_master
+      WHERE type='table' AND name = 'qe_pattern_nulls'
+    `).get();
+        return result.count === 1;
+    }
+    catch {
+        return false;
+    }
+}
+export function rollbackMigration(db) {
+    // Safety check: refuse to drop a table that contains data (kept nulls are data)
+    const count = db.prepare('SELECT COUNT(*) as cnt FROM qe_pattern_nulls').get()?.cnt ?? 0;
+    if (count > 0) {
+        throw new Error(`REFUSING rollback: qe_pattern_nulls contains ${count} kept nulls. ` +
+            'Backup and manually drop if you really need to rollback.');
+    }
+    db.exec('DROP TABLE IF EXISTS qe_pattern_nulls;');
+}
+export default {
+    version: MIGRATION_VERSION,
+    apply: applyMigration,
+    isApplied: isMigrationApplied,
+    rollback: rollbackMigration,
+};
+//# sourceMappingURL=20260611_add_pattern_nulls_table.js.map

package/dist/shared/llm/cost-tracker.js

@@ -116,8 +116,12 @@ export class CostTracker {
                 currency: 'USD',
             };
         }
-        // Convert from per-million to actual cost
-        const inputCost = (usage.promptTokens / 1_000_000) * pricing.input;
+        // Convert from per-million to actual cost.
+        // ADR-088: cache reads bill at ~0.1x input rate, cache writes at ~1.25x
+        // (5-minute TTL); promptTokens already excludes both.
+        const inputCost = (usage.promptTokens / 1_000_000) * pricing.input +
+            ((usage.cacheReadTokens ?? 0) / 1_000_000) * pricing.input * 0.1 +
+            ((usage.cacheCreationTokens ?? 0) / 1_000_000) * pricing.input * 1.25;
         const outputCost = (usage.completionTokens / 1_000_000) * pricing.output;
         return {
             inputCost,

package/dist/shared/llm/interfaces.d.ts

@@ -30,6 +30,10 @@ export interface TokenUsage {
     promptTokens: number;
     completionTokens: number;
     totalTokens: number;
+    /** ADR-088: tokens written to the prompt cache this request (billed ~1.25x input rate) */
+    cacheCreationTokens?: number;
+    /** ADR-088: tokens served from the prompt cache this request (billed ~0.1x input rate) */
+    cacheReadTokens?: number;
 }
 /**
  * Cost information for a request

package/dist/shared/llm/providers/claude.js

@@ -122,7 +122,15 @@ export class ClaudeProvider {
             messages,
         };
         if (options?.systemPrompt) {
-            body.system = options.systemPrompt;
+            // ADR-088: when caching is enabled, send the system prompt as a
+            // content-block array with an ephemeral cache breakpoint — repeated
+            // calls within the TTL read the cached prefix at ~0.1x input price.
+            // Anthropic-native provider only (ADR-092: other providers untouched).
+            // Note: prefixes below the model's minimum (1024-4096 tokens) silently
+            // don't cache; the breakpoint is harmless in that case.
+            body.system = this.config.enableCache !== false
+                ? [{ type: 'text', text: options.systemPrompt, cache_control: { type: 'ephemeral' } }]
+                : options.systemPrompt;
         }
         if (options?.stopSequences && options.stopSequences.length > 0) {
             body.stop_sequences = options.stopSequences;
@@ -164,10 +172,16 @@ export class ClaudeProvider {
                 throw this.handleApiError(response.status, errorData, model);
             }
             const data = await response.json();
+            // ADR-088: input_tokens is the uncached remainder only — cache
+            // read/creation tokens are reported separately by the API.
+            const cacheCreationTokens = data.usage.cache_creation_input_tokens ?? 0;
+            const cacheReadTokens = data.usage.cache_read_input_tokens ?? 0;
             const usage = {
                 promptTokens: data.usage.input_tokens,
                 completionTokens: data.usage.output_tokens,
-                totalTokens: data.usage.input_tokens + data.usage.output_tokens,
+                totalTokens: data.usage.input_tokens + cacheCreationTokens + cacheReadTokens + data.usage.output_tokens,
+                cacheCreationTokens,
+                cacheReadTokens,
             };
             const cost = CostTracker.calculateCost(model, usage);
             // ADR-042: Track token usage in TokenMetricsCollector

package/dist/shared/reasoning-scrub.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Agentic QE v3 - Reasoning-Tag Scrubber (ADR-099)
+ *
+ * Strips extended-thinking blocks (<think>, <thinking>, <reasoning>,
+ * <REASONING_SCRATCHPAD>) from text before it enters the learning pipeline —
+ * pattern distillation, trajectory persistence, and embedding generation.
+ *
+ * Why: reasoning-capable models (Fable 5 era) emit large scratchpad blocks
+ * inside task results and step actions. Embedding them verbatim contaminates
+ * the 384-dim pattern vectors in memory.db, degrading HNSW retrieval quality
+ * (the scratchpad dominates the signal of what the step actually did).
+ *
+ * Boundary-gated: only well-formed `<tag ...> ... </tag>` pairs are removed.
+ * Prose that merely *mentions* a tag name (e.g. documentation about
+ * "<thinking> blocks") without a closing tag is left intact.
+ */
+/**
+ * Remove reasoning scratchpad blocks from text destined for the learning
+ * pipeline. Collapses the whitespace gap a removed block leaves behind so
+ * surrounding prose re-joins cleanly. Non-string / empty input returns as-is.
+ */
+export declare function scrubReasoningBlocks(text: string): string;
+/**
+ * Scrub a value that may be a string or a JSON-serializable structure whose
+ * string leaves may contain reasoning blocks. Non-objects pass through.
+ * Used for trajectory step `result.data` payloads serialized into memory.db.
+ */
+export declare function scrubReasoningDeep<T>(value: T): T;
+//# sourceMappingURL=reasoning-scrub.d.ts.map

package/dist/shared/reasoning-scrub.js

@@ -0,0 +1,75 @@
+/**
+ * Agentic QE v3 - Reasoning-Tag Scrubber (ADR-099)
+ *
+ * Strips extended-thinking blocks (<think>, <thinking>, <reasoning>,
+ * <REASONING_SCRATCHPAD>) from text before it enters the learning pipeline —
+ * pattern distillation, trajectory persistence, and embedding generation.
+ *
+ * Why: reasoning-capable models (Fable 5 era) emit large scratchpad blocks
+ * inside task results and step actions. Embedding them verbatim contaminates
+ * the 384-dim pattern vectors in memory.db, degrading HNSW retrieval quality
+ * (the scratchpad dominates the signal of what the step actually did).
+ *
+ * Boundary-gated: only well-formed `<tag ...> ... </tag>` pairs are removed.
+ * Prose that merely *mentions* a tag name (e.g. documentation about
+ * "<thinking> blocks") without a closing tag is left intact.
+ */
+/**
+ * Tag names treated as reasoning scratchpads. Matched case-insensitively
+ * as whole tag names (open tag may carry attributes).
+ */
+const REASONING_TAG_NAMES = ['think', 'thinking', 'reasoning', 'reasoning_scratchpad'];
+/**
+ * One alternation per tag, each backreference-paired so an open tag is only
+ * consumed when its own matching close tag exists. Non-greedy body keeps
+ * adjacent blocks separate. The `\s*` before `>` tolerates `</thinking >`.
+ */
+const REASONING_BLOCK_RE = new RegExp(`<(${REASONING_TAG_NAMES.join('|')})(?:\\s[^>]*)?>[\\s\\S]*?</\\1\\s*>`, 'gi');
+/**
+ * Remove reasoning scratchpad blocks from text destined for the learning
+ * pipeline. Collapses the whitespace gap a removed block leaves behind so
+ * surrounding prose re-joins cleanly. Non-string / empty input returns as-is.
+ */
+export function scrubReasoningBlocks(text) {
+    if (!text || typeof text !== 'string' || !text.includes('<')) {
+        return text;
+    }
+    let out = text;
+    // Repeat until stable: removing an inner block can expose an outer pair
+    // (e.g. <thinking><thinking>…</thinking></thinking>).
+    for (let i = 0; i < 5; i++) {
+        const next = out.replace(REASONING_BLOCK_RE, ' ');
+        if (next === out)
+            break;
+        out = next;
+    }
+    // If nothing was removed, return the original text untouched (don't
+    // re-format whitespace of clean input).
+    if (out === text) {
+        return text;
+    }
+    // Collapse the space runs left where blocks were removed; preserve newlines.
+    return out.replace(/[ \t]{2,}/g, ' ').trim();
+}
+/**
+ * Scrub a value that may be a string or a JSON-serializable structure whose
+ * string leaves may contain reasoning blocks. Non-objects pass through.
+ * Used for trajectory step `result.data` payloads serialized into memory.db.
+ */
+export function scrubReasoningDeep(value) {
+    if (typeof value === 'string') {
+        return scrubReasoningBlocks(value);
+    }
+    if (Array.isArray(value)) {
+        return value.map((v) => scrubReasoningDeep(v));
+    }
+    if (value !== null && typeof value === 'object') {
+        const out = {};
+        for (const [k, v] of Object.entries(value)) {
+            out[k] = scrubReasoningDeep(v);
+        }
+        return out;
+    }
+    return value;
+}
+//# sourceMappingURL=reasoning-scrub.js.map

package/dist/validation/pipeline.d.ts

@@ -7,10 +7,28 @@
 export type StepCategory = 'format' | 'content' | 'quality' | 'traceability' | 'compliance';
 export type StepSeverity = 'blocking' | 'warning' | 'info';
 export type StepStatus = 'pass' | 'fail' | 'warn' | 'skip';
+/**
+ * Evidence class of a finding (ADR-105). Quality gates may pass/block only on
+ * EXECUTED or STATIC findings; INFERRED routes to adversarial verification
+ * (ADR-102) before it can gate; CONJECTURE never gates.
+ */
+export type EvidenceClass = 'EXECUTED' | 'STATIC' | 'INFERRED' | 'CONJECTURE';
+/** Provenance attached to a finding — required for EXECUTED claims. */
+export interface EvidenceArtifact {
+    /** Command that was actually run */
+    command?: string;
+    /** Captured output backing the claim */
+    output?: string;
+    /** Data source for STATIC findings (coverage file, AST, lockfile, …) */
+    dataSource?: string;
+}
 export interface Finding {
     id: string;
     stepId: string;
     severity: 'critical' | 'high' | 'medium' | 'low' | 'info';
+    /** ADR-105: what kind of evidence backs this finding */
+    evidenceClass: EvidenceClass;
+    evidenceArtifact?: EvidenceArtifact;
     title: string;
     description: string;
     location?: string;
@@ -63,7 +81,14 @@ export interface PipelineResult {
     overall: 'pass' | 'fail' | 'warn';
     score: number;
     steps: StepResult[];
+    /** Findings from failed blocking steps that may gate (EXECUTED/STATIC only, ADR-105) */
     blockers: Finding[];
+    /**
+     * INFERRED findings from failed blocking steps (ADR-105): not allowed to
+     * gate; queued for adversarial verification (ADR-102) to be promoted to
+     * blockers or demoted. Their presence downgrades overall to 'warn'.
+     */
+    needsVerification: Finding[];
     halted: boolean;
     haltedAt?: string;
     totalDuration: number;

package/dist/validation/pipeline.js

@@ -25,6 +25,7 @@ export async function runPipeline(config, content, filePath, metadata) {
     };
     const stepResults = [];
     const blockers = [];
+    const needsVerification = [];
     let halted = false;
     let haltedAt;
     // Filter steps if specified
@@ -47,6 +48,8 @@ export async function runPipeline(config, content, filePath, metadata) {
                         id: `${step.id}-error`,
                         stepId: step.id,
                         severity: 'critical',
+                        evidenceClass: 'EXECUTED',
+                        evidenceArtifact: { output: err.message },
                         title: `Step execution failed: ${step.name}`,
                         description: err.message,
                     }],
@@ -60,10 +63,15 @@ export async function runPipeline(config, content, filePath, metadata) {
         }
         stepResults.push(result);
         context.previousResults.push(result);
-        // Check for blocking failure
+        // Check for blocking failure (ADR-105: only EXECUTED/STATIC may gate)
         if (step.severity === 'blocking' && result.status === 'fail') {
-            blockers.push(...result.findings);
-            if (!config.continueOnFailure) {
+            const gating = result.findings.filter(f => f.evidenceClass === 'EXECUTED' || f.evidenceClass === 'STATIC');
+            needsVerification.push(...result.findings.filter(f => f.evidenceClass === 'INFERRED'));
+            // CONJECTURE findings stay visible on the step but never gate.
+            blockers.push(...gating);
+            // Halt only when verified evidence blocks; a step that failed purely on
+            // unverified inference must not stop the pipeline.
+            if (gating.length > 0 && !config.continueOnFailure) {
                 halted = true;
                 haltedAt = step.id;
                 break;
@@ -91,11 +99,16 @@ export async function runPipeline(config, content, filePath, metadata) {
         totalWeight += weight;
     }
     const finalScore = totalWeight > 0 ? Math.round(weightedScore / totalWeight) : 0;
-    // Determine overall status
+    // Determine overall status (ADR-105: unverified inference warns, never fails)
     let overall;
     if (blockers.length > 0) {
         overall = 'fail';
     }
+    else if (needsVerification.length > 0 || stepResults.some(r => r.status === 'fail')) {
+        // A failed step without gating evidence (INFERRED queued, or CONJECTURE
+        // suppressed) must never silently read as a clean pass.
+        overall = 'warn';
+    }
     else if (stepResults.some(r => r.status === 'warn')) {
         overall = 'warn';
     }
@@ -112,6 +125,7 @@ export async function runPipeline(config, content, filePath, metadata) {
         score: finalScore,
         steps: stepResults,
         blockers,
+        needsVerification,
         halted,
         haltedAt,
         totalDuration: Date.now() - startTime,
@@ -146,13 +160,22 @@ export function formatPipelineReport(result) {
         lines.push('## Blockers');
         lines.push('');
         for (const blocker of result.blockers) {
-            lines.push(`- **${blocker.title}** (${blocker.severity}): ${blocker.description}`);
+            lines.push(`- **${blocker.title}** (${blocker.severity}, ${blocker.evidenceClass}): ${blocker.description}`);
             if (blocker.suggestion) {
                 lines.push(`  - Suggestion: ${blocker.suggestion}`);
             }
         }
         lines.push('');
     }
+    // Unverified inference awaiting adversarial verification (ADR-105/ADR-102)
+    if (result.needsVerification.length > 0) {
+        lines.push('## Needs Verification (INFERRED — did not gate)');
+        lines.push('');
+        for (const f of result.needsVerification) {
+            lines.push(`- **${f.title}** (${f.severity}): ${f.description}`);
+        }
+        lines.push('');
+    }
     // Detailed findings
     const allFindings = result.steps.flatMap(s => s.findings);
     if (allFindings.length > 0) {

package/dist/validation/steps/requirements.js

@@ -9,6 +9,11 @@ function createFinding(stepId, severity, title, description, opts) {
         id: `${stepId}-${Date.now()}-${Math.random().toString(36).slice(2, 6)}`,
         stepId,
         severity,
+        // Every step in this file is deterministic structure/content analysis of
+        // the document itself — STATIC per ADR-105. LLM-derived steps must pass
+        // evidenceClass explicitly.
+        evidenceClass: opts?.evidenceClass ?? 'STATIC',
+        evidenceArtifact: opts?.evidenceArtifact,
         title,
         description,
         location: opts?.location,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentic-qe",
-  "version": "3.10.4",
+  "version": "3.10.6",
   "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",
@@ -72,6 +72,7 @@
     "mcp:parity": "node scripts/audit-mcp-tool-parity.mjs",
     "mcp:report": "echo 'MCP Report: uses vitest for test reporting' && exit 0",
     "test:code-intelligence": "npm test -- --run tests/unit/domains/code-intelligence/ tests/unit/coordination/mincut/",
+    "verify:invariants": "tsx scripts/verify-shipped-invariants.ts",
     "verify:counts": "node -e \"const fs=require('fs'),g=require('glob'),p=require('path');const src=g.globSync('src/**/*.ts',{ignore:'src/**/*.test.ts'});const tests=g.globSync('tests/**/*.test.ts');const agents=g.globSync('.claude/agents/v3/qe-*.md');const skills=g.globSync('.claude/skills/**/*.md');const ok=src.length>500&&tests.length>300;const r={status:ok?'pass':'fail',srcFiles:src.length,testFiles:tests.length,agents:agents.length,skills:skills.length};fs.mkdirSync('reports',{recursive:true});fs.writeFileSync(p.join('reports','verification-counts.json'),JSON.stringify(r,null,2));console.log('Counts:',JSON.stringify(r));if(!ok)process.exit(1)\"",
     "verify:agent-skills": "node -e \"const fs=require('fs'),g=require('glob'),p=require('path');const agents=g.globSync('.claude/agents/v3/qe-*.md');const skills=g.globSync('.claude/skills/**/*.md');const missing=[];for(const a of agents){const name=p.basename(a,'.md');const hasSkill=skills.some(s=>s.includes(name.replace('qe-','')));if(!hasSkill)missing.push(name)}const ok=missing.length<agents.length/2;const r={status:ok?'pass':'fail',agents:agents.length,skills:skills.length,unmatchedAgents:missing.length,missing:missing.slice(0,10)};fs.mkdirSync('reports',{recursive:true});fs.writeFileSync(p.join('reports','verification-agent-skills.json'),JSON.stringify(r,null,2));console.log('Agent-Skills:',JSON.stringify(r));if(!ok)process.exit(1)\"",
     "verify:features": "node -e \"const fs=require('fs'),p=require('path');const pkg=JSON.parse(fs.readFileSync('package.json','utf8'));const hasBin=!!pkg.bin&&Object.keys(pkg.bin).length>=2;const hasExports=!!pkg.exports&&Object.keys(pkg.exports).length>=3;const cliBundleExists=fs.existsSync('dist/cli/bundle.js');const mcpBundleExists=fs.existsSync('dist/mcp/bundle.js');const ok=hasBin&&hasExports&&cliBundleExists&&mcpBundleExists;const r={status:ok?'pass':'fail',binCount:Object.keys(pkg.bin||{}).length,exportsCount:Object.keys(pkg.exports||{}).length,cliBundleExists,mcpBundleExists};fs.mkdirSync('reports',{recursive:true});fs.writeFileSync(p.join('reports','verification-features.json'),JSON.stringify(r,null,2));console.log('Features:',JSON.stringify(r));if(!ok)process.exit(1)\"",

package/dist/cli/chunks/adapter-A62ETL5C.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.10.4");process.exit(0)}
-import{a,b,c}from"./chunk-ZM4QGYGK.js";import"./chunk-LYKSIOOT.js";import"./chunk-USB7GCIC.js";import"./chunk-IYFMDIYZ.js";import"./chunk-2B6ETC7C.js";import"./chunk-SVILIQQQ.js";export{a as AgentBoosterAdapter,b as createAgentBoosterAdapter,c as createAgentBoosterAdapterSync};

package/dist/cli/chunks/aqe-learning-engine-MTCRAV6N.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.10.4");process.exit(0)}
-import{a,b,c,d,e,f}from"./chunk-2TYO4VZH.js";import"./chunk-5Q3L4QEE.js";import"./chunk-AMW27FSS.js";import"./chunk-GLMDRGJD.js";import"./chunk-OKKTDHHF.js";import"./chunk-SC6UFGJ6.js";import"./chunk-VDKMBOUK.js";import"./chunk-KGPAWNNR.js";import"./chunk-OIFJH7TF.js";import"./chunk-MQIAN57O.js";import"./chunk-YSLE6NNG.js";import"./chunk-XBFEHVBO.js";import"./chunk-TCV5DASI.js";import"./chunk-5T2HDET6.js";import"./chunk-NZGLDOU4.js";import"./chunk-K72J52JO.js";import"./chunk-U27GVYXA.js";import"./chunk-IYFMDIYZ.js";import"./chunk-KWZEBHAP.js";import"./chunk-HPYGMKZF.js";import"./chunk-VRE2EBFI.js";import"./chunk-UFKVKNAA.js";import"./chunk-2B6ETC7C.js";import"./chunk-PISW5HUX.js";import"./chunk-RJKYPWFD.js";import"./chunk-2G2PVVQG.js";import"./chunk-UWAUYDW4.js";import"./chunk-N3MM4Z33.js";import"./chunk-6OLHPWSN.js";import"./chunk-WI5WXYIS.js";import"./chunk-EMZ3DXMG.js";import"./chunk-MFWWPRBV.js";import"./chunk-D7IWGQTW.js";import"./chunk-SVILIQQQ.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/audit-42XG5JFB.js

@@ -1,3 +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.10.4");process.exit(0)}
-import{d as c,e as u,f as h,g as m}from"./chunk-UW3ZSFFB.js";import{m as p}from"./chunk-NZGLDOU4.js";import"./chunk-K72J52JO.js";import{b as s}from"./chunk-U27GVYXA.js";import"./chunk-IYFMDIYZ.js";import"./chunk-HPYGMKZF.js";import"./chunk-VRE2EBFI.js";import"./chunk-2B6ETC7C.js";import"./chunk-RJKYPWFD.js";import{p as l,q as d}from"./chunk-2G2PVVQG.js";import"./chunk-UWAUYDW4.js";import"./chunk-N3MM4Z33.js";import"./chunk-6OLHPWSN.js";import"./chunk-WI5WXYIS.js";import"./chunk-EMZ3DXMG.js";import"./chunk-MFWWPRBV.js";import"./chunk-D7IWGQTW.js";import{g as f}from"./chunk-SVILIQQQ.js";import{Command as g}from"commander";import a from"chalk";p();import{existsSync as y}from"node:fs";import b from"node:path";function C(n,i){let t=[];t.push(a.bold("Witness Chain Audit Verification")),t.push("");let e=i?a.green("ENABLED"):a.yellow("DISABLED");t.push(`  Feature Flag: ${e}`),t.push(`  Chain Length:  ${n.length} receipts`);let r=n.valid?a.green("VALID"):a.red("BROKEN");return t.push(`  Integrity:    ${r}`),n.length>0&&t.push(`  Last Hash:    ${n.lastHash.slice(0,16)}...`),!n.valid&&n.brokenAt>=0&&(t.push(""),t.push(a.red(`  Break detected at index ${n.brokenAt}`)),t.push(a.red(`  ${n.message}`))),t.push(""),t.join(`
-`)}function x(){try{let n=s(),i=b.join(n,".agentic-qe","memory.db");if(!y(i))return null;let t=(d(),f(l)),e=new t(i),r=c(e),o=h(r);return e.close(),o}catch{return null}}async function A(n){let i=m(),e=(x()??u()).verifyChain(),r={featureEnabled:i,chainLength:e.length,integrity:e.valid,brokenAt:e.brokenAt,lastHash:e.lastHash,message:e.message};return n.format==="json"?console.log(JSON.stringify(r,null,2)):console.log(C(e,i)),r}function v(n,i,t){let e=new g("audit").description("Witness chain audit trail management");return e.command("verify").description("Verify witness chain integrity").option("-F, --format <format>","Output format (json|text)","text").action(async r=>{try{await A({format:r.format}),await i(0)}catch(o){console.error("Failed to verify witness chain:",o),await i(1)}}),e}export{v as createAuditCommand,C as formatVerificationText,A as handleAuditVerify};

package/dist/cli/chunks/base-KKEBUHZC.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.10.4");process.exit(0)}
-import{a,b,c,d,e,f,g,h,i,j}from"./chunk-F77X5DAF.js";import"./chunk-TBJ566KV.js";import"./chunk-NZGLDOU4.js";import"./chunk-K72J52JO.js";import"./chunk-U27GVYXA.js";import"./chunk-IYFMDIYZ.js";import"./chunk-HPYGMKZF.js";import"./chunk-VRE2EBFI.js";import"./chunk-2B6ETC7C.js";import"./chunk-PISW5HUX.js";import"./chunk-RJKYPWFD.js";import"./chunk-2G2PVVQG.js";import"./chunk-UWAUYDW4.js";import"./chunk-N3MM4Z33.js";import"./chunk-6OLHPWSN.js";import"./chunk-WI5WXYIS.js";import"./chunk-EMZ3DXMG.js";import"./chunk-MFWWPRBV.js";import"./chunk-D7IWGQTW.js";import"./chunk-SVILIQQQ.js";export{j as MCPToolBase,i as defaultToolLogger,h as getLLMRouter,d as getMemoryBackend,f as getSharedLLMRouter,b as getSharedMemoryBackend,a as registerRvfResetFn,g as resetSharedLLMRouter,c as resetSharedMemoryBackend,e as setSharedLLMRouter};

package/dist/cli/chunks/browser-workflow-XHYAJUB6.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.10.4");process.exit(0)}
-import{a}from"./chunk-UXJVR323.js";import"./chunk-F77X5DAF.js";import"./chunk-TBJ566KV.js";import"./chunk-NZGLDOU4.js";import"./chunk-K72J52JO.js";import"./chunk-U27GVYXA.js";import"./chunk-IYFMDIYZ.js";import"./chunk-HPYGMKZF.js";import"./chunk-VRE2EBFI.js";import"./chunk-2B6ETC7C.js";import"./chunk-PISW5HUX.js";import"./chunk-RJKYPWFD.js";import"./chunk-2G2PVVQG.js";import"./chunk-UWAUYDW4.js";import"./chunk-N3MM4Z33.js";import"./chunk-6OLHPWSN.js";import"./chunk-WI5WXYIS.js";import"./chunk-EMZ3DXMG.js";import"./chunk-MFWWPRBV.js";import"./chunk-D7IWGQTW.js";import"./chunk-SVILIQQQ.js";export{a as BrowserWorkflowTool};