agentic-qe 3.6.0 → 3.6.2

package/v3/assets/agents/v3/qe-devils-advocate.md

@@ -0,0 +1,218 @@
+---
+name: qe-devils-advocate
+version: "3.6.0"
+updated: "2026-02-09"
+description: Meta-agent that challenges other agents' outputs by finding gaps, questioning assumptions, and critiquing completeness
+v2_compat: null
+domain: quality-assessment
+---
+
+<qe_agent_definition>
+<identity>
+You are the V3 QE Devil's Advocate, the adversarial reviewer in Agentic QE v3.
+Mission: Challenge other agents' outputs to surface gaps, blind spots, false positives, and unquestioned assumptions before results reach users.
+Domain: quality-assessment (ADR-064)
+V2 Compatibility: New in v3 -- no v2 equivalent.
+</identity>
+
+<implementation_status>
+Working:
+- Missing edge case detection (boundary values, null/undefined, concurrency)
+- False positive detection in security scans and coverage reports
+- Coverage gap critique (structural vs semantic coverage gaps)
+- Security blind spot identification (missing threat vectors)
+- Assumption questioning (implicit preconditions, happy-path bias)
+- Boundary value gap analysis (off-by-one, overflow, empty collections)
+- Error handling gap detection (missing catch blocks, swallowed errors)
+- Configurable severity thresholds and confidence filters
+- Per-review and cumulative statistics tracking
+
+Partial:
+- Integration with Queen Coordinator task pipeline
+- Cross-domain challenge coordination
+
+Planned:
+- Learning from past challenge outcomes (which challenges were acted on)
+- Auto-escalation for repeated unchallenged gaps
+</implementation_status>
+
+<default_to_action>
+Review outputs immediately when a ChallengeTarget is provided.
+Apply all applicable strategies without confirmation.
+Filter results by configured minConfidence and minSeverity.
+Report challenges in descending severity order.
+Always produce a summary even when no challenges are found.
+</default_to_action>
+
+<parallel_execution>
+Run all applicable challenge strategies concurrently against the target.
+Strategies are independent -- missing-edge-case, false-positive, coverage-gap, etc. run in parallel.
+Aggregate and sort results by severity after all strategies complete.
+Use up to 7 concurrent strategies per review.
+</parallel_execution>
+
+<capabilities>
+- **Missing Edge Case Detection**: Identify untested boundary values, null handling, concurrency, and error paths in test generation outputs
+- **False Positive Detection**: Flag likely false positives in security scans and coverage reports by checking for vague descriptions, low confidence, and known false-positive patterns
+- **Coverage Gap Critique**: Challenge coverage claims by checking for missing negative tests, missing integration paths, and semantic gaps not visible in line coverage
+- **Security Blind Spot Identification**: Find missing threat vectors (injection, auth bypass, SSRF, deserialization) not covered by security scan results
+- **Assumption Questioning**: Surface implicit assumptions in quality assessments, requirements validations, and defect predictions
+- **Boundary Value Gap Analysis**: Detect missing tests for off-by-one errors, integer overflow, empty/max-size collections, and Unicode edge cases
+- **Error Handling Gap Detection**: Find missing error handling for network failures, timeouts, malformed input, and resource exhaustion
+</capabilities>
+
+<memory_namespace>
+Reads:
+- aqe/v3/domains/test-generation/results/* - Test generation outputs to challenge
+- aqe/v3/domains/coverage-analysis/results/* - Coverage reports to critique
+- aqe/v3/domains/security-compliance/scans/* - Security scans to review
+- aqe/v3/domains/quality-assessment/reports/* - Quality reports to question
+
+Writes:
+- aqe/v3/devils-advocate/reviews/* - Challenge review results
+- aqe/v3/devils-advocate/stats/* - Cumulative challenge statistics
+- aqe/v3/devils-advocate/patterns/* - Learned gap patterns
+
+Coordination:
+- aqe/v3/queen/tasks/* - Task status updates
+- aqe/v3/domains/*/results/* - Cross-domain output access
+</memory_namespace>
+
+<learning_protocol>
+**MANDATORY**: When executed via Claude Code Task tool, you MUST call learning MCP tools.
+
+### Query Past Challenge Patterns BEFORE Review
+
+```typescript
+mcp__agentic-qe__memory_retrieve({
+  key: "devils-advocate/patterns",
+  namespace: "learning"
+})
+```
+
+### Required Learning Actions (Call AFTER Review)
+
+**1. Store Challenge Review Experience:**
+```typescript
+mcp__agentic-qe__memory_store({
+  key: "devils-advocate/outcome-{timestamp}",
+  namespace: "learning",
+  value: {
+    agentId: "qe-devils-advocate",
+    taskType: "challenge-review",
+    reward: <calculated_reward>,
+    outcome: {
+      targetType: "<test-generation|coverage-analysis|security-scan|...>",
+      targetAgentId: "<agent that produced the output>",
+      challengeCount: <number>,
+      highSeverityCount: <number>,
+      overallScore: <0-1>,
+      verdict: "PASSED|CHALLENGED"
+    },
+    patterns: {
+      gapsFound: ["<types of gaps found>"],
+      strategiesUsed: ["<strategies that produced findings>"]
+    }
+  }
+})
+```
+
+**2. Submit Review Result to Queen:**
+```typescript
+mcp__agentic-qe__task_submit({
+  type: "challenge-review-complete",
+  priority: "p1",
+  payload: {
+    targetAgentId: "...",
+    targetType: "...",
+    challengeCount: <number>,
+    highSeverityCount: <number>,
+    summary: "...",
+    challenges: [...]
+  }
+})
+```
+
+### Reward Calculation Criteria (0-1 scale)
+| Reward | Criteria |
+|--------|----------|
+| 1.0 | Actionable critical findings confirmed by follow-up |
+| 0.9 | High-severity gaps found with clear evidence |
+| 0.7 | Medium gaps found, strategies well-targeted |
+| 0.5 | Review completed, minor findings only |
+| 0.3 | Review completed, no significant findings (clean output) |
+| 0.0 | Review failed or produced only noise/false challenges |
+</learning_protocol>
+
+<output_format>
+- JSON for structured challenge results (challenges array, scores, summary)
+- Markdown for human-readable challenge reports
+- Challenges sorted by severity (critical > high > medium > low > informational)
+- Include challenge count, overall confidence score, and per-strategy breakdown
+</output_format>
+
+<examples>
+Example 1: Challenge test generation output
+```
+Input: Review test-generation output from agent test-gen-001
+  - 5 tests generated for UserService.createUser()
+  - All tests check happy path with valid data
+
+Output: CHALLENGED (Score: 0.38, 4 challenges)
+  [HIGH] Missing edge case: No test for duplicate email
+  [HIGH] Missing edge case: No test for empty/null username
+  [MEDIUM] Boundary value gap: No max-length validation test
+  [LOW] Error handling gap: No test for database connection failure
+  Summary: 5 tests cover only the happy path. No negative tests,
+  no boundary tests, no error handling tests. Test suite has
+  significant gaps in edge case coverage.
+```
+
+Example 2: Challenge security scan output
+```
+Input: Review security-scan output from agent sec-scan-001
+  - 0 vulnerabilities found
+  - Scanned: SQL injection, XSS
+
+Output: CHALLENGED (Score: 0.52, 2 challenges)
+  [HIGH] Security blind spot: No SSRF testing performed
+  [MEDIUM] Security blind spot: No deserialization checks
+  Summary: Scan covers injection and XSS but misses SSRF,
+  deserialization, and authentication bypass vectors.
+```
+</examples>
+
+<v3_integration>
+### Code Implementation
+The Devil's Advocate agent is implemented in `v3/src/agents/devils-advocate/`:
+- `agent.ts` - Core `DevilsAdvocate` class with `review()` method
+- `strategies.ts` - 7 pluggable challenge strategies
+- `types.ts` - Type definitions for targets, challenges, results
+
+### Usage
+```typescript
+import { DevilsAdvocate } from '@agentic-qe/v3';
+
+const da = DevilsAdvocate.createDevilsAdvocate({ minConfidence: 0.5 });
+
+const result = da.review({
+  type: 'test-generation',
+  agentId: 'test-gen-001',
+  domain: 'test-generation',
+  output: { testCount: 3, tests: [] },
+  timestamp: Date.now(),
+});
+```
+
+### Strategies
+| Strategy | Applies To | Detects |
+|----------|-----------|---------|
+| MissingEdgeCaseStrategy | test-generation | Untested edge cases, null handling |
+| FalsePositiveDetectionStrategy | security-scan, coverage-analysis | Likely false positives |
+| CoverageGapCritiqueStrategy | coverage-analysis | Semantic gaps in coverage |
+| SecurityBlindSpotStrategy | security-scan | Missing threat vectors |
+| AssumptionQuestioningStrategy | quality-assessment, defect-prediction, requirements | Implicit assumptions |
+| BoundaryValueGapStrategy | test-generation | Off-by-one, overflow, empty collections |
+| ErrorHandlingGapStrategy | test-generation, contract-validation | Missing error handling |
+</v3_integration>
+</qe_agent_definition>

package/v3/assets/agents/v3/qe-quality-criteria-recommender.md

@@ -245,7 +245,7 @@ interface QualityCriteriaAnalysis {
 ```
 
 ## Template Location
-Helper files installed to `.claude/agents/v3/helpers/quality-criteria/`:
+Helper files installed to `.claude/helpers/v3/quality-criteria/`:
 - `quality-criteria-reference-template.html` - HTML output template (MUST read before generating)
 - `htsm-categories.md` - Detailed category definitions
 - `evidence-classification.md` - Evidence type guidelines
@@ -404,7 +404,7 @@ if (!valid) {
 ### Output Validation
 If HTML output requested, always read template first:
 ```
-.claude/agents/v3/helpers/quality-criteria/quality-criteria-reference-template.html
+.claude/helpers/v3/quality-criteria/quality-criteria-reference-template.html
 ```
 </final_validation>
 </qe_agent_definition>

package/v3/assets/skills/qe-iterative-loop/SKILL.md

@@ -441,5 +441,5 @@ When ALL phases complete -> <promise>DEPLOYMENT_READY</promise>
 ---
 
 **Origin**: Adapted from Ralph Wiggum plugin (anthropics/claude-code)
-**Specialized for**: Agentic QE v3 Fleet with 59 QE agents
+**Specialized for**: Agentic QE v3 Fleet with 60 QE agents
 **Domains**: test-generation, test-execution, coverage-analysis, quality-assessment

package/v3/dist/agents/devils-advocate/agent.d.ts

@@ -0,0 +1,103 @@
+/**
+ * Agentic QE v3 - Devil's Advocate Agent
+ * ADR-064, Phase 2C: Core agent class that orchestrates challenge reviews
+ *
+ * The Devil's Advocate reviews outputs from other agents and challenges them
+ * using pluggable strategies. It does not create tests or fix code -- it finds
+ * what was missed, questions assumptions, and argues why gaps matter.
+ *
+ * @module agents/devils-advocate
+ */
+import type { ChallengeTarget, ChallengeTargetType, ChallengeResult, ChallengeStrategy, DevilsAdvocateConfig, DevilsAdvocateStats } from './types.js';
+/**
+ * The Devil's Advocate agent reviews other agents' outputs and produces
+ * structured challenges identifying gaps, weaknesses, and questionable results.
+ *
+ * @example
+ * ```typescript
+ * const da = new DevilsAdvocate();
+ *
+ * const result = da.review({
+ *   type: 'test-generation',
+ *   agentId: 'test-gen-001',
+ *   domain: 'test-generation',
+ *   output: { testCount: 5, tests: [...] },
+ *   timestamp: Date.now(),
+ * });
+ *
+ * console.log(result.summary);
+ * for (const challenge of result.challenges) {
+ *   console.log(`[${challenge.severity}] ${challenge.title}`);
+ * }
+ * ```
+ */
+export declare class DevilsAdvocate {
+    private readonly config;
+    private readonly strategies;
+    private reviewCount;
+    private totalChallengeCount;
+    private scoreAccumulator;
+    private readonly severityCounts;
+    private readonly categoryCounts;
+    /**
+     * Create a new Devil's Advocate agent.
+     *
+     * @param config - Optional partial configuration (merged with defaults)
+     */
+    constructor(config?: Partial<DevilsAdvocateConfig>);
+    /**
+     * Review an agent's output and produce challenges.
+     *
+     * The review process:
+     * 1. Gets all applicable strategies for the target type
+     * 2. Filters to enabled strategies
+     * 3. Runs each strategy against the target
+     * 4. Collects all challenges
+     * 5. Filters by minConfidence and minSeverity
+     * 6. Sorts by severity (critical first)
+     * 7. Limits to maxChallengesPerReview
+     * 8. Computes overall score
+     * 9. Generates summary
+     *
+     * @param target - The output to challenge
+     * @returns A ChallengeResult with all findings
+     */
+    review(target: ChallengeTarget): ChallengeResult;
+    /**
+     * Get applicable and enabled strategies for a target type.
+     *
+     * @param targetType - The type of output to find strategies for
+     * @returns Array of strategies that can review this target type
+     */
+    getStrategiesFor(targetType: ChallengeTargetType): ChallengeStrategy[];
+    /**
+     * Get accumulated review statistics.
+     *
+     * @returns Current statistics snapshot
+     */
+    getStats(): DevilsAdvocateStats;
+    /**
+     * Reset all accumulated statistics.
+     */
+    resetStats(): void;
+    /**
+     * Compute the overall score based on challenges found.
+     * Score is 1.0 minus the weighted impact of all challenges.
+     * A score of 1.0 means no challenges were found.
+     * A score of 0.0 means maximum challenge impact.
+     */
+    private computeScore;
+    /**
+     * Generate a human-readable summary of the review.
+     */
+    private generateSummary;
+    /**
+     * Count challenges grouped by severity.
+     */
+    private countBySeverity;
+    /**
+     * Update internal statistics after a review.
+     */
+    private updateStats;
+}
+//# sourceMappingURL=agent.d.ts.map

package/v3/dist/agents/devils-advocate/agent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"agent.d.ts","sourceRoot":"","sources":["../../../src/agents/devils-advocate/agent.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,KAAK,EACV,eAAe,EACf,mBAAmB,EACnB,eAAe,EAGf,iBAAiB,EAEjB,oBAAoB,EACpB,mBAAmB,EACpB,MAAM,YAAY,CAAC;AAYpB;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,qBAAa,cAAc;IACzB,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAuB;IAC9C,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAsB;IACjD,OAAO,CAAC,WAAW,CAAK;IACxB,OAAO,CAAC,mBAAmB,CAAK;IAChC,OAAO,CAAC,gBAAgB,CAAK;IAC7B,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAoC;IACnE,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAyB;IAExD;;;;OAIG;gBACS,MAAM,CAAC,EAAE,OAAO,CAAC,oBAAoB,CAAC;IAmBlD;;;;;;;;;;;;;;;;OAgBG;IACH,MAAM,CAAC,MAAM,EAAE,eAAe,GAAG,eAAe;IA0DhD;;;;;OAKG;IACH,gBAAgB,CAAC,UAAU,EAAE,mBAAmB,GAAG,iBAAiB,EAAE;IAMtE;;;;OAIG;IACH,QAAQ,IAAI,mBAAmB;IAa/B;;OAEG;IACH,UAAU,IAAI,IAAI;IAYlB;;;;;OAKG;IACH,OAAO,CAAC,YAAY;IAapB;;OAEG;IACH,OAAO,CAAC,eAAe;IA4BvB;;OAEG;IACH,OAAO,CAAC,eAAe;IAgBvB;;OAEG;IACH,OAAO,CAAC,WAAW;CAUpB"}

package/v3/dist/agents/devils-advocate/agent.js

@@ -0,0 +1,240 @@
+/**
+ * Agentic QE v3 - Devil's Advocate Agent
+ * ADR-064, Phase 2C: Core agent class that orchestrates challenge reviews
+ *
+ * The Devil's Advocate reviews outputs from other agents and challenges them
+ * using pluggable strategies. It does not create tests or fix code -- it finds
+ * what was missed, questions assumptions, and argues why gaps matter.
+ *
+ * @module agents/devils-advocate
+ */
+import { DEFAULT_DEVILS_ADVOCATE_CONFIG, SEVERITY_ORDER, SEVERITY_WEIGHTS, } from './types.js';
+import { createAllStrategies, getApplicableStrategies } from './strategies.js';
+// ============================================================================
+// DevilsAdvocate Agent
+// ============================================================================
+/**
+ * The Devil's Advocate agent reviews other agents' outputs and produces
+ * structured challenges identifying gaps, weaknesses, and questionable results.
+ *
+ * @example
+ * ```typescript
+ * const da = new DevilsAdvocate();
+ *
+ * const result = da.review({
+ *   type: 'test-generation',
+ *   agentId: 'test-gen-001',
+ *   domain: 'test-generation',
+ *   output: { testCount: 5, tests: [...] },
+ *   timestamp: Date.now(),
+ * });
+ *
+ * console.log(result.summary);
+ * for (const challenge of result.challenges) {
+ *   console.log(`[${challenge.severity}] ${challenge.title}`);
+ * }
+ * ```
+ */
+export class DevilsAdvocate {
+    config;
+    strategies;
+    reviewCount = 0;
+    totalChallengeCount = 0;
+    scoreAccumulator = 0;
+    severityCounts;
+    categoryCounts;
+    /**
+     * Create a new Devil's Advocate agent.
+     *
+     * @param config - Optional partial configuration (merged with defaults)
+     */
+    constructor(config) {
+        this.config = {
+            ...DEFAULT_DEVILS_ADVOCATE_CONFIG,
+            ...config,
+            enabledStrategies: config?.enabledStrategies ?? DEFAULT_DEVILS_ADVOCATE_CONFIG.enabledStrategies,
+        };
+        this.strategies = createAllStrategies();
+        this.severityCounts = {
+            critical: 0,
+            high: 0,
+            medium: 0,
+            low: 0,
+            informational: 0,
+        };
+        this.categoryCounts = {};
+    }
+    /**
+     * Review an agent's output and produce challenges.
+     *
+     * The review process:
+     * 1. Gets all applicable strategies for the target type
+     * 2. Filters to enabled strategies
+     * 3. Runs each strategy against the target
+     * 4. Collects all challenges
+     * 5. Filters by minConfidence and minSeverity
+     * 6. Sorts by severity (critical first)
+     * 7. Limits to maxChallengesPerReview
+     * 8. Computes overall score
+     * 9. Generates summary
+     *
+     * @param target - The output to challenge
+     * @returns A ChallengeResult with all findings
+     */
+    review(target) {
+        const startTime = Date.now();
+        // 1-2: Get applicable + enabled strategies
+        const applicable = this.getStrategiesFor(target.type);
+        // 3: Run each strategy and collect challenges
+        const allChallenges = [];
+        for (const strategy of applicable) {
+            try {
+                const found = strategy.challenge(target);
+                allChallenges.push(...found);
+            }
+            catch {
+                // Strategy failure should not abort the entire review.
+                // Silently skip the failing strategy.
+            }
+        }
+        // 4-5: Filter by confidence and severity
+        const minSeverityIndex = SEVERITY_ORDER.indexOf(this.config.minSeverity);
+        const filtered = allChallenges.filter(c => {
+            if (c.confidence < this.config.minConfidence)
+                return false;
+            const severityIndex = SEVERITY_ORDER.indexOf(c.severity);
+            return severityIndex <= minSeverityIndex;
+        });
+        // 6: Sort by severity (critical first), then by confidence descending
+        const sorted = filtered.sort((a, b) => {
+            const sevDiff = SEVERITY_ORDER.indexOf(a.severity) - SEVERITY_ORDER.indexOf(b.severity);
+            if (sevDiff !== 0)
+                return sevDiff;
+            return b.confidence - a.confidence;
+        });
+        // 7: Limit to max challenges
+        const limited = sorted.slice(0, this.config.maxChallengesPerReview);
+        // 8: Compute overall score
+        const overallScore = this.computeScore(limited);
+        // 9: Generate summary
+        const summary = this.generateSummary(target, limited, overallScore);
+        const reviewDuration = Date.now() - startTime;
+        // Update internal statistics
+        this.updateStats(limited, overallScore);
+        return {
+            targetType: target.type,
+            targetAgentId: target.agentId,
+            challenges: limited,
+            overallScore,
+            summary,
+            timestamp: Date.now(),
+            reviewDuration,
+        };
+    }
+    /**
+     * Get applicable and enabled strategies for a target type.
+     *
+     * @param targetType - The type of output to find strategies for
+     * @returns Array of strategies that can review this target type
+     */
+    getStrategiesFor(targetType) {
+        const applicable = getApplicableStrategies(this.strategies, targetType);
+        const enabledSet = new Set(this.config.enabledStrategies);
+        return applicable.filter(s => enabledSet.has(s.type));
+    }
+    /**
+     * Get accumulated review statistics.
+     *
+     * @returns Current statistics snapshot
+     */
+    getStats() {
+        return {
+            totalReviews: this.reviewCount,
+            totalChallenges: this.totalChallengeCount,
+            challengesBySeverity: { ...this.severityCounts },
+            challengesByCategory: { ...this.categoryCounts },
+            averageChallengesPerReview: this.reviewCount > 0 ? this.totalChallengeCount / this.reviewCount : 0,
+            averageScore: this.reviewCount > 0 ? this.scoreAccumulator / this.reviewCount : 1,
+        };
+    }
+    /**
+     * Reset all accumulated statistics.
+     */
+    resetStats() {
+        this.reviewCount = 0;
+        this.totalChallengeCount = 0;
+        this.scoreAccumulator = 0;
+        for (const key of SEVERITY_ORDER) {
+            this.severityCounts[key] = 0;
+        }
+        for (const key of Object.keys(this.categoryCounts)) {
+            delete this.categoryCounts[key];
+        }
+    }
+    /**
+     * Compute the overall score based on challenges found.
+     * Score is 1.0 minus the weighted impact of all challenges.
+     * A score of 1.0 means no challenges were found.
+     * A score of 0.0 means maximum challenge impact.
+     */
+    computeScore(challenges) {
+        if (challenges.length === 0)
+            return 1.0;
+        let totalImpact = 0;
+        for (const challenge of challenges) {
+            const weight = SEVERITY_WEIGHTS[challenge.severity] ?? 0.01;
+            totalImpact += weight * challenge.confidence;
+        }
+        // Clamp to [0, 1]
+        return Math.max(0, Math.min(1, 1 - totalImpact));
+    }
+    /**
+     * Generate a human-readable summary of the review.
+     */
+    generateSummary(target, challenges, score) {
+        if (challenges.length === 0) {
+            return (`Review of ${target.type} output from agent "${target.agentId}" ` +
+                `found no significant challenges. Score: ${score.toFixed(2)}.`);
+        }
+        const bySeverity = this.countBySeverity(challenges);
+        const severityParts = [];
+        for (const sev of SEVERITY_ORDER) {
+            const count = bySeverity[sev];
+            if (count > 0) {
+                severityParts.push(`${count} ${sev}`);
+            }
+        }
+        return (`Review of ${target.type} output from agent "${target.agentId}" ` +
+            `raised ${challenges.length} challenge(s): ${severityParts.join(', ')}. ` +
+            `Overall score: ${score.toFixed(2)}.`);
+    }
+    /**
+     * Count challenges grouped by severity.
+     */
+    countBySeverity(challenges) {
+        const counts = {
+            critical: 0,
+            high: 0,
+            medium: 0,
+            low: 0,
+            informational: 0,
+        };
+        for (const c of challenges) {
+            counts[c.severity]++;
+        }
+        return counts;
+    }
+    /**
+     * Update internal statistics after a review.
+     */
+    updateStats(challenges, score) {
+        this.reviewCount++;
+        this.totalChallengeCount += challenges.length;
+        this.scoreAccumulator += score;
+        for (const c of challenges) {
+            this.severityCounts[c.severity]++;
+            this.categoryCounts[c.category] = (this.categoryCounts[c.category] ?? 0) + 1;
+        }
+    }
+}
+//# sourceMappingURL=agent.js.map

package/v3/dist/agents/devils-advocate/agent.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"agent.js","sourceRoot":"","sources":["../../../src/agents/devils-advocate/agent.ts"],"names":[],"mappings":"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"}

package/v3/dist/agents/devils-advocate/index.d.ts

@@ -0,0 +1,60 @@
+/**
+ * Agentic QE v3 - Devil's Advocate Agent
+ * ADR-064, Phase 2C: Barrel exports and factory
+ *
+ * The Devil's Advocate agent challenges other agents' outputs by reviewing
+ * test completeness, questioning security scan results, and identifying
+ * coverage gaps in claimed results.
+ *
+ * @module agents/devils-advocate
+ *
+ * @example
+ * ```typescript
+ * import {
+ *   createDevilsAdvocate,
+ *   type ChallengeTarget,
+ *   type ChallengeResult,
+ * } from './agents/devils-advocate';
+ *
+ * const da = createDevilsAdvocate({ minConfidence: 0.5 });
+ *
+ * const target: ChallengeTarget = {
+ *   type: 'test-generation',
+ *   agentId: 'test-gen-001',
+ *   domain: 'test-generation',
+ *   output: { testCount: 3, tests: [] },
+ *   timestamp: Date.now(),
+ * };
+ *
+ * const result: ChallengeResult = da.review(target);
+ * console.log(result.summary);
+ * ```
+ */
+export type { ChallengeTargetType, ChallengeTarget, ChallengeSeverity, Challenge, ChallengeResult, ChallengeStrategyType, ChallengeStrategy, DevilsAdvocateConfig, DevilsAdvocateStats, } from './types.js';
+export { ALL_CHALLENGE_TARGET_TYPES, ALL_CHALLENGE_STRATEGY_TYPES, SEVERITY_ORDER, SEVERITY_WEIGHTS, DEFAULT_DEVILS_ADVOCATE_CONFIG, } from './types.js';
+export { isChallengeTargetType, isChallengeStrategyType, isChallengeSeverity, } from './types.js';
+export { MissingEdgeCaseStrategy, FalsePositiveDetectionStrategy, CoverageGapCritiqueStrategy, SecurityBlindSpotStrategy, AssumptionQuestioningStrategy, BoundaryValueGapStrategy, ErrorHandlingGapStrategy, createAllStrategies, getApplicableStrategies, } from './strategies.js';
+export { DevilsAdvocate } from './agent.js';
+import type { DevilsAdvocateConfig } from './types.js';
+import { DevilsAdvocate } from './agent.js';
+/**
+ * Factory function to create a Devil's Advocate agent instance.
+ *
+ * @param config - Optional partial configuration (merged with defaults)
+ * @returns A configured DevilsAdvocate instance
+ *
+ * @example
+ * ```typescript
+ * // With defaults
+ * const da = createDevilsAdvocate();
+ *
+ * // With custom config
+ * const strict = createDevilsAdvocate({
+ *   minConfidence: 0.7,
+ *   minSeverity: 'medium',
+ *   maxChallengesPerReview: 10,
+ * });
+ * ```
+ */
+export declare function createDevilsAdvocate(config?: Partial<DevilsAdvocateConfig>): DevilsAdvocate;
+//# sourceMappingURL=index.d.ts.map

package/v3/dist/agents/devils-advocate/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/agents/devils-advocate/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AAMH,YAAY,EACV,mBAAmB,EACnB,eAAe,EACf,iBAAiB,EACjB,SAAS,EACT,eAAe,EACf,qBAAqB,EACrB,iBAAiB,EACjB,oBAAoB,EACpB,mBAAmB,GACpB,MAAM,YAAY,CAAC;AAMpB,OAAO,EACL,0BAA0B,EAC1B,4BAA4B,EAC5B,cAAc,EACd,gBAAgB,EAChB,8BAA8B,GAC/B,MAAM,YAAY,CAAC;AAMpB,OAAO,EACL,qBAAqB,EACrB,uBAAuB,EACvB,mBAAmB,GACpB,MAAM,YAAY,CAAC;AAMpB,OAAO,EACL,uBAAuB,EACvB,8BAA8B,EAC9B,2BAA2B,EAC3B,yBAAyB,EACzB,6BAA6B,EAC7B,wBAAwB,EACxB,wBAAwB,EACxB,mBAAmB,EACnB,uBAAuB,GACxB,MAAM,iBAAiB,CAAC;AAMzB,OAAO,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAM5C,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,YAAY,CAAC;AACvD,OAAO,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAE5C;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,oBAAoB,CAClC,MAAM,CAAC,EAAE,OAAO,CAAC,oBAAoB,CAAC,GACrC,cAAc,CAEhB"}