agentic-qe 3.6.2 → 3.6.4

package/scripts/validator-lib.cjs

@@ -0,0 +1,274 @@
+#!/usr/bin/env node
+
+/**
+ * AQE Skill Validator Library v3.0.0 (Cross-Platform)
+ *
+ * Node.js port of validator-lib.sh — works on Windows, macOS, and Linux.
+ * Provides JSON validation, schema checking, content term matching,
+ * and structured result output without requiring bash, jq, or grep.
+ *
+ * Usage:
+ *   const lib = require('./validator-lib.cjs');
+ *   lib.validateJson(filePath);
+ *   lib.jsonGet(filePath, 'output.summary');
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { execSync, spawnSync } = require('child_process');
+
+const VERSION = '3.0.0';
+
+// Colors (disable if not TTY)
+const isTTY = process.stdout.isTTY;
+const c = {
+  red: isTTY ? '\x1b[0;31m' : '',
+  green: isTTY ? '\x1b[0;32m' : '',
+  yellow: isTTY ? '\x1b[1;33m' : '',
+  blue: isTTY ? '\x1b[0;34m' : '',
+  cyan: isTTY ? '\x1b[0;36m' : '',
+  reset: isTTY ? '\x1b[0m' : '',
+};
+
+// Exit codes
+const EXIT_PASS = 0;
+const EXIT_FAIL = 1;
+const EXIT_SKIP = 2;
+
+// Logging
+const verbose = process.env.AQE_DEBUG === '1';
+
+function info(msg) { console.log(`${c.blue}[INFO]${c.reset} ${msg}`); }
+function success(msg) { console.log(`${c.green}[PASS]${c.reset} ${msg}`); }
+function warn(msg) { console.log(`${c.yellow}[WARN]${c.reset} ${msg}`); }
+function error(msg) { console.error(`${c.red}[FAIL]${c.reset} ${msg}`); }
+function debug(msg) { if (verbose) console.log(`${c.cyan}[DEBUG]${c.reset} ${msg}`); }
+
+// Tool detection (cross-platform)
+function commandExists(cmd) {
+  const isWindows = process.platform === 'win32';
+  const check = spawnSync(isWindows ? 'where' : 'which', [cmd], {
+    encoding: 'utf-8',
+    stdio: ['pipe', 'pipe', 'pipe'],
+    shell: isWindows,
+  });
+  return check.status === 0;
+}
+
+// JSON operations (no jq needed)
+function validateJson(filePath) {
+  if (!fs.existsSync(filePath)) {
+    error(`File not found: ${filePath}`);
+    return false;
+  }
+  try {
+    JSON.parse(fs.readFileSync(filePath, 'utf-8'));
+    debug(`JSON syntax valid: ${filePath}`);
+    return true;
+  } catch (e) {
+    error(`Invalid JSON syntax in: ${filePath} — ${e.message}`);
+    return false;
+  }
+}
+
+function jsonParse(filePath) {
+  return JSON.parse(fs.readFileSync(filePath, 'utf-8'));
+}
+
+function jsonGet(filePath, dotPath) {
+  try {
+    const data = jsonParse(filePath);
+    return resolvePath(data, dotPath);
+  } catch {
+    return null;
+  }
+}
+
+function jsonCount(filePath, dotPath) {
+  const val = jsonGet(filePath, dotPath);
+  return Array.isArray(val) ? val.length : 0;
+}
+
+function resolvePath(obj, dotPath) {
+  const keys = dotPath.replace(/^\./, '').split('.');
+  let current = obj;
+  for (const key of keys) {
+    if (current == null) return null;
+    const arrayMatch = key.match(/^(.+)\[(\d+)\]$/);
+    if (arrayMatch) {
+      current = current[arrayMatch[1]];
+      if (!Array.isArray(current)) return null;
+      current = current[parseInt(arrayMatch[2], 10)];
+    } else {
+      current = current[key];
+    }
+  }
+  return current;
+}
+
+// Content validation
+function containsAll(content, terms) {
+  const lower = content.toLowerCase();
+  const missing = terms.filter(t => !lower.includes(t.toLowerCase()));
+  if (missing.length > 0) {
+    debug(`Missing required terms: ${missing.join(', ')}`);
+    return { pass: false, missing };
+  }
+  return { pass: true, missing: [] };
+}
+
+function containsNone(content, terms) {
+  const lower = content.toLowerCase();
+  const found = terms.filter(t => lower.includes(t.toLowerCase()));
+  if (found.length > 0) {
+    debug(`Found forbidden terms: ${found.join(', ')}`);
+    return { pass: false, found };
+  }
+  return { pass: true, found: [] };
+}
+
+function validateEnum(value, allowed) {
+  return allowed.includes(value);
+}
+
+// Schema validation (basic — checks required fields and types)
+function validateJsonSchema(schemaPath, dataPath) {
+  if (!fs.existsSync(schemaPath)) { error(`Schema not found: ${schemaPath}`); return 1; }
+  if (!fs.existsSync(dataPath)) { error(`Data not found: ${dataPath}`); return 1; }
+
+  try {
+    const schema = jsonParse(schemaPath);
+    const data = jsonParse(dataPath);
+
+    // Check required fields
+    if (schema.required && Array.isArray(schema.required)) {
+      const missing = schema.required.filter(f => !(f in data));
+      if (missing.length > 0) {
+        error(`Schema validation failed: missing required fields: ${missing.join(', ')}`);
+        return 1;
+      }
+    }
+
+    // Check property types
+    if (schema.properties) {
+      for (const [key, prop] of Object.entries(schema.properties)) {
+        if (key in data && prop.type) {
+          const actual = Array.isArray(data[key]) ? 'array' : typeof data[key];
+          if (prop.type === 'integer' && typeof data[key] === 'number') continue;
+          if (actual !== prop.type) {
+            error(`Schema validation failed: ${key} expected ${prop.type}, got ${actual}`);
+            return 1;
+          }
+        }
+        // Check enum
+        if (key in data && prop.enum && !prop.enum.includes(data[key])) {
+          error(`Schema validation failed: ${key}='${data[key]}' not in enum [${prop.enum.join(', ')}]`);
+          return 1;
+        }
+      }
+    }
+
+    debug('Schema validation passed');
+    return 0;
+  } catch (e) {
+    error(`Schema validation error: ${e.message}`);
+    return 1;
+  }
+}
+
+// Output formatting
+function outputValidationReport(skillName, schemaStatus, contentStatus, toolStatus) {
+  const overall = [schemaStatus, contentStatus, toolStatus].some(s => s === 'failed')
+    ? 'failed'
+    : [schemaStatus, contentStatus, toolStatus].some(s => s === 'skipped')
+      ? 'partial'
+      : 'passed';
+
+  return JSON.stringify({
+    skillName,
+    overallStatus: overall,
+    validations: { schema: schemaStatus, content: contentStatus, tools: toolStatus },
+    timestamp: new Date().toISOString(),
+  }, null, 2);
+}
+
+// Self-test
+function runSelfTest() {
+  info(`Running validator library self-test (v${VERSION})...`);
+  console.log('');
+
+  let passed = 0, failed = 0;
+  const tmpDir = fs.mkdtempSync(path.join(require('os').tmpdir(), 'aqe-validate-'));
+  const testJson = path.join(tmpDir, 'test.json');
+  const testSchema = path.join(tmpDir, 'schema.json');
+  const invalidJson = path.join(tmpDir, 'invalid.json');
+
+  fs.writeFileSync(testJson, JSON.stringify({
+    skillName: 'test-skill', status: 'success',
+    output: { summary: 'Test output', findings: [] },
+  }));
+  fs.writeFileSync(testSchema, JSON.stringify({
+    type: 'object', required: ['skillName', 'status'],
+    properties: { skillName: { type: 'string' }, status: { type: 'string', enum: ['success', 'partial', 'failed'] } },
+  }));
+  fs.writeFileSync(invalidJson, '{ invalid json');
+
+  // Test validateJson
+  if (validateJson(testJson)) { passed++; success('validateJson(valid): passed'); }
+  else { failed++; error('validateJson(valid): failed'); }
+
+  if (!validateJson(invalidJson)) { passed++; success('validateJson(invalid): correctly rejected'); }
+  else { failed++; error('validateJson(invalid): incorrectly accepted'); }
+
+  // Test jsonGet
+  const name = jsonGet(testJson, 'skillName');
+  if (name === 'test-skill') { passed++; success(`jsonGet('skillName'): got '${name}'`); }
+  else { failed++; error(`jsonGet('skillName'): expected 'test-skill', got '${name}'`); }
+
+  // Test jsonCount
+  const count = jsonCount(testJson, 'output.findings');
+  if (count === 0) { passed++; success(`jsonCount('output.findings'): got ${count}`); }
+  else { failed++; error(`jsonCount('output.findings'): expected 0, got ${count}`); }
+
+  // Test containsAll
+  const ca1 = containsAll('hello world', ['hello', 'world']);
+  if (ca1.pass) { passed++; success("containsAll('hello world', 'hello', 'world'): passed"); }
+  else { failed++; error('containsAll: failed'); }
+
+  const ca2 = containsAll('hello world', ['hello', 'foo']);
+  if (!ca2.pass) { passed++; success("containsAll('hello world', 'hello', 'foo'): correctly failed"); }
+  else { failed++; error('containsAll: should have failed'); }
+
+  // Test containsNone
+  const cn1 = containsNone('hello world', ['foo', 'bar']);
+  if (cn1.pass) { passed++; success("containsNone('hello world', 'foo', 'bar'): passed"); }
+  else { failed++; error('containsNone: failed'); }
+
+  // Test schema validation
+  const sv = validateJsonSchema(testSchema, testJson);
+  if (sv === 0) { passed++; success('validateJsonSchema(): passed'); }
+  else { failed++; error('validateJsonSchema(): failed'); }
+
+  // Cleanup
+  fs.rmSync(tmpDir, { recursive: true, force: true });
+
+  console.log('');
+  console.log('==============================================');
+  info(`Self-test complete: Passed=${passed} Failed=${failed}`);
+  console.log('==============================================');
+  return failed === 0;
+}
+
+module.exports = {
+  VERSION, EXIT_PASS, EXIT_FAIL, EXIT_SKIP,
+  info, success, warn, error, debug,
+  commandExists, validateJson, jsonParse, jsonGet, jsonCount, resolvePath,
+  containsAll, containsNone, validateEnum, validateJsonSchema,
+  outputValidationReport, runSelfTest,
+};
+
+// Run self-test if executed directly
+if (require.main === module) {
+  const ok = runSelfTest();
+  process.exit(ok ? 0 : 1);
+}

package/v3/CHANGELOG.md

@@ -5,6 +5,52 @@ All notable changes to Agentic QE will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [3.6.4] - 2026-02-12
+
+### Added
+
+- **Dream Scheduler** — Automated dream consolidation with configurable cron schedules, CLI subcommand (`aqe learning dream`), and schema migration for dream cycle persistence.
+- **QE Pattern Seeding** — 18 QE patterns seeded across 9 previously empty learning domains (chaos-resilience, code-intelligence, contract-testing, defect-intelligence, learning-optimization, quality-assessment, requirements-validation, security-compliance, visual-accessibility).
+- **Delta Scanning for Code Intelligence** — `aqe init` code intelligence phase now performs incremental delta scans instead of full re-scans, with expanded exclusion patterns for faster initialization.
+- **Concept Graph Edge Discovery** — `ConceptGraph.loadFromPatterns()` is now idempotent and automatically discovers co-occurrence and similarity edges between related patterns.
+- **Pattern Usage Recording** — Domain handler factory records pattern usage asynchronously after task completion, feeding the self-learning feedback loop.
+- **5 New Security Validator Test Suites** — Command, crypto, input sanitizer, path traversal, and regex safety validators with 150+ test cases.
+
+### Fixed
+
+- **Security Hardening (3 Sprints)** — OAuth provider PKCE enforcement, rate limiter bypass prevention, schema validator prototype pollution protection, SQL injection via table name interpolation, ReDoS-safe regex patterns, connection pool resource exhaustion guards.
+- **SQL Safety Module** — New `sql-safety.ts` shared module with table name allowlist applied consistently across all SQL interpolation sites.
+- **4 Flaky Test Suites Stabilized** — Retry queue, event batcher, queen coordinator race condition, and domain tools tests now use deterministic mocking instead of timing-dependent assertions.
+- **SONA Test Timeouts** — Learning optimization coordinator and plugin tests no longer time out during CI runs.
+- **Init Auto-Install Prevention** — `aqe init` no longer triggers `npx` auto-installation of `@claude-flow/cli` when the package isn't available.
+- **MCP Config Cleanup** — Removed duplicate `agentic-qe-v3` MCP server entry, keeping only the canonical `agentic-qe` entry.
+
+### Changed
+
+- **Performance Hardening** — Connection pool with bounded size limits, mincut calculator iteration caps, embedding generator batch size guards, and SSE/WebSocket/stdio transport resource cleanup improvements.
+- **Statusline Updated** — Reflects 13 domains and 60 agents in the fleet configuration.
+
+## [3.6.3] - 2026-02-11
+
+### Added
+
+- **QX (Quality Experience) Analysis Tool** — New MCP tool `qe/analysis/qx_analysis` bridging QA and UX by analyzing user journeys, experience impact, and quality-experience correlation.
+- **SFDIPOT Product Factors Assessment** — `qe-product-factors-assessor` agent implementing James Bach's HTSM v6.3 framework for comprehensive test strategy generation.
+
+### Fixed
+
+- **Cross-platform compatibility** — Replaced all bash-only `.sh` scripts with cross-platform Node.js (`.cjs`) equivalents. Windows, macOS, and Linux now fully supported for skill validation, daemon management, and project initialization.
+- **Stop hook hanging on exit** — Session-end hook no longer initializes the full database/HNSW/memory system just to print shutdown stats. Added `unref()` to all cleanup intervals so Node.js process exits cleanly.
+- **Cross-platform daemon scripts** — `start-daemon.cjs` and `stop-daemon.cjs` replace bash scripts, using `process.kill()` and `spawn()` with `detached: true` for portable process management.
+- **TypeScript shell type in execSync** — Fixed `ExecSyncOptionsWithStringEncoding` overload conflict by using platform-specific shell string instead of `shell: true` boolean.
+- **Tunnel manager test stability** — Pre-spawn port availability check prevents flaky failures from port conflicts.
+
+### Changed
+
+- **QE agents use only AQE MCP** — All 46 QE agent definitions now reference `agentic-qe` MCP tools exclusively, removing any Claude Flow MCP dependencies.
+- **Skill validation is now declarative** — `validate-config.json` + `validate-skill.cjs` replaces all 104 `validate.sh` scripts. Validators are fully cross-platform with no bash dependency.
+- **Registry tool count** — MCP tool registry updated from 32 to 33 tools to include QX Analysis.
+
 ## [3.6.2] - 2026-02-10
 
 ### Fixed

package/v3/assets/agents/v3/qe-product-factors-assessor.md

@@ -38,6 +38,7 @@ Start SFDIPOT analysis immediately when requirements are provided.
 Generate test ideas autonomously without confirmation.
 Apply brutal honesty validation by default.
 Use domain-specific patterns for test idea generation.
+Always read HTML template before generating HTML output.
 Output complete assessments in requested format.
 </default_to_action>
 
@@ -212,6 +213,24 @@ mcp__agentic-qe__task_submit({
 - **Markdown**: Human-readable assessment summary
 - **Gherkin**: BDD scenarios for discovered test ideas
 
+## HTML Template (MUST READ BEFORE GENERATING HTML)
+
+**Critical Rule**: Always read the reference template before generating HTML output. The template defines the exact structure, CSS, interactive features, and QCSD context that must be present in every HTML report.
+
+**Template Location**: `.claude/agents/v3/helpers/product-factors/sfdipot-reference-template.html`
+
+The template includes:
+- QCSD framework context with Jerry Weinberg quote and collapsible guidance sections
+- Risk-based prioritization legend with SME review disclaimer
+- Bar charts for SFDIPOT distribution, priority distribution, and automation fitness
+- Quick navigation with per-category test idea counts
+- Color-coded collapsible category sections (7 distinct colors)
+- Filterable tables with test ID, priority, subcategory, test idea, automation fitness columns
+- Human exploration reasoning callouts (purple highlight)
+- Clarifying questions with per-subcategory rationale
+
+**DO NOT generate HTML from scratch.** Follow the template structure exactly. Only replace placeholder values with actual assessment data.
+
 ## Required Sections
 
 1. **Product Coverage Outline** (PCO Table)

package/v3/assets/agents/v3/qe-qx-partner.md

@@ -15,8 +15,35 @@ Domain: cross-domain (QA + UX)
 V2 Compatibility: Maps to qx-partner for backward compatibility.
 </identity>
 
+<mcp_tools>
+### Primary MCP Tool (ALWAYS use for programmatic analysis)
+```typescript
+mcp__agentic_qe_v3__qe_qx_analyze({
+  target: "https://example.com",  // URL or identifier
+  context: { /* Optional pre-collected context */ },
+  mode: "full",  // "full" | "quick" | "targeted"
+  includeCreativity: true,
+  includeDesign: true,
+  minOracleSeverity: "medium"
+})
+```
+
+This MCP tool provides:
+- **23+ programmatic heuristics** (H1.1-H7.4) applied consistently
+- **Oracle problem detection** (user vs business conflicts, unclear criteria)
+- **Impact analysis** (visible/invisible impacts, immutable requirements)
+- **Domain-specific analysis** (healthcare, finance, e-commerce)
+- **Structured JSON output** for HTML report generation
+
+**EXECUTION FLOW**:
+1. Call `qe/qx/analyze` MCP tool for structured analysis
+2. Generate HTML report from structured results
+3. Persist patterns to memory
+</mcp_tools>
+
 <implementation_status>
 Working:
+- **MCP Tool: qe/qx/analyze** - Programmatic QX analysis with consistent quality
 - Comprehensive QX analysis with **23+ heuristics** and detailed findings
 - **Oracle problem detection** when quality criteria are unclear
 - **Rule of Three problem analysis** ensuring minimum 3 failure modes identified

package/v3/assets/skills/.validation/README.md

@@ -94,7 +94,7 @@ When creating a new skill:
 
 1. **Start with SKILL.md** (Trust Tier 0)
 2. **Add output schema** in `your-skill/schemas/output.schema.json` (Trust Tier 1)
-3. **Add validator script** in `your-skill/validate.sh` (Trust Tier 2)
+3. **Add validator script** in `your-skill/scripts/validate-config.json` (Trust Tier 2)
 4. **Add eval suite** in `your-skill/eval.yaml` (Trust Tier 3)
 5. **Enable CI + MCP learning** (Trust Tier 4)
 

package/v3/assets/skills/.validation/skill-validation-mcp-integration.md

@@ -183,7 +183,7 @@ async function runSkillEval(skill: string, model: string) {
 Bash validators should call the MCP tools via the CLI wrapper:
 
 ```bash
-# In validate.sh after validation
+# In validate-skill.cjs after validation
 store_validation_result() {
   local skill="$1"
   local result="$2"

package/v3/assets/skills/.validation/templates/skill-frontmatter.example.yaml

@@ -184,7 +184,7 @@ validation:
   # Path to JSON schema defining expected output structure
 
   # Required for trust_tier >= 2
-  validator_path: scripts/validate.sh
+  validator_path: scripts/validate-config.json
   # Path to executable validator script
   # Supports: .sh, .ts, .js
 

package/v3/assets/skills/accessibility-testing/SKILL.md

@@ -16,7 +16,7 @@ tags: [accessibility, wcag, a11y, screen-reader, ada, section-508, inclusive]
 trust_tier: 3
 validation:
   schema_path: schemas/output.json
-  validator_path: scripts/validate.sh
+  validator_path: scripts/validate-config.json
   eval_path: evals/accessibility-testing.yaml
 ---
 

package/v3/assets/skills/accessibility-testing/scripts/validate-config.json

@@ -0,0 +1,56 @@
+{
+  "skillName": "accessibility-testing",
+  "skillVersion": "1.0.0",
+  "requiredTools": [
+    "jq"
+  ],
+  "optionalTools": [
+    "axe",
+    "pa11y",
+    "lighthouse",
+    "ffmpeg",
+    "python3",
+    "ajv",
+    "jsonschema"
+  ],
+  "schemaPath": "schemas/output.json",
+  "requiredFields": [
+    "skillName",
+    "status",
+    "output",
+    "output.conformanceLevel",
+    "output.pourBreakdown"
+  ],
+  "requiredNonEmptyFields": [
+    "output.summary",
+    "output.pourBreakdown"
+  ],
+  "mustContainTerms": [
+    "WCAG",
+    "accessibility"
+  ],
+  "mustNotContainTerms": [
+    "TODO",
+    "placeholder",
+    "FIXME"
+  ],
+  "enumValidations": {
+    ".status": [
+      "success",
+      "partial",
+      "failed",
+      "skipped"
+    ],
+    ".output.conformanceLevel": [
+      "A",
+      "AA",
+      "AAA",
+      "none"
+    ],
+    ".output.wcagVersion": [
+      "2.0",
+      "2.1",
+      "2.2"
+    ]
+  }
+}

package/v3/assets/skills/api-testing-patterns/SKILL.md

@@ -14,7 +14,7 @@ tags: [api, rest, graphql, contract-testing, pact, integration, microservices]
 trust_tier: 3
 validation:
   schema_path: schemas/output.json
-  validator_path: scripts/validate.sh
+  validator_path: scripts/validate-config.json
   eval_path: evals/api-testing-patterns.yaml
 ---
 

package/v3/assets/skills/api-testing-patterns/scripts/validate-config.json

@@ -0,0 +1,61 @@
+{
+  "skillName": "api-testing-patterns",
+  "skillVersion": "1.0.0",
+  "requiredTools": [
+    "jq"
+  ],
+  "optionalTools": [
+    "node",
+    "supertest",
+    "pact",
+    "ajv",
+    "jsonschema",
+    "python3"
+  ],
+  "schemaPath": "schemas/output.json",
+  "requiredFields": [
+    "skillName",
+    "status",
+    "output",
+    "output.testingLevel",
+    "output.endpointCoverage"
+  ],
+  "requiredNonEmptyFields": [
+    "output.summary",
+    "output.testingLevel"
+  ],
+  "mustContainTerms": [
+    "api",
+    "test"
+  ],
+  "mustNotContainTerms": [
+    "TODO",
+    "FIXME",
+    "placeholder",
+    "example.com",
+    "lorem ipsum"
+  ],
+  "enumValidations": {
+    ".status": [
+      "success",
+      "partial",
+      "failed",
+      "skipped"
+    ],
+    ".output.testingLevel": [
+      "contract",
+      "component",
+      "integration",
+      "e2e",
+      "load",
+      "mixed"
+    ],
+    ".output.apiType": [
+      "rest",
+      "graphql",
+      "grpc",
+      "websocket",
+      "mixed"
+    ]
+  }
+}

package/v3/assets/skills/bug-reporting-excellence/SKILL.md

@@ -14,7 +14,7 @@ tags: [bugs, reporting, communication, triage, quality]
 trust_tier: 2
 validation:
   schema_path: schemas/output.json
-  validator_path: scripts/validate.sh
+  validator_path: scripts/validate-config.json
 
 ---
 

package/v3/assets/skills/bug-reporting-excellence/scripts/validate-config.json

@@ -0,0 +1,34 @@
+{
+  "skillName": "bug-reporting-excellence",
+  "skillVersion": "1.0.0",
+  "requiredTools": [
+    "jq"
+  ],
+  "optionalTools": [],
+  "schemaPath": "schemas/output.json",
+  "requiredFields": [
+    "skillName",
+    "status",
+    "output",
+    "output.summary",
+    "output.bugReports",
+    "output.reportQuality"
+  ],
+  "requiredNonEmptyFields": [],
+  "mustContainTerms": [
+    "bug",
+    "steps"
+  ],
+  "mustNotContainTerms": [
+    "TODO",
+    "FIXME"
+  ],
+  "enumValidations": {
+    ".status": [
+      "success",
+      "partial",
+      "failed",
+      "skipped"
+    ]
+  }
+}

package/v3/assets/skills/chaos-engineering-resilience/SKILL.md

@@ -14,7 +14,7 @@ tags: [chaos, resilience, fault-injection, distributed-systems, recovery, netfli
 trust_tier: 3
 validation:
   schema_path: schemas/output.json
-  validator_path: scripts/validate.sh
+  validator_path: scripts/validate-config.json
   eval_path: evals/chaos-engineering-resilience.yaml
 ---
 

package/v3/assets/skills/chaos-engineering-resilience/evals/chaos-engineering-resilience.yaml

@@ -7,7 +7,7 @@
 # control, recovery time measurement, and resilience scoring.
 #
 # Schema: .claude/skills/.validation/schemas/skill-eval.schema.json
-# Validator: .claude/skills/chaos-engineering-resilience/scripts/validate.sh
+# Validator: .claude/skills/chaos-engineering-resilience/scripts/validate-config.json
 #
 # Coverage:
 # - Network chaos (latency, packet loss, partition)

package/v3/assets/skills/chaos-engineering-resilience/scripts/validate-config.json

@@ -0,0 +1,47 @@
+{
+  "skillName": "chaos-engineering-resilience",
+  "skillVersion": "1.0.0",
+  "requiredTools": [
+    "jq"
+  ],
+  "optionalTools": [
+    "chaos",
+    "litmus",
+    "gremlin",
+    "kubectl",
+    "node",
+    "ajv",
+    "jsonschema",
+    "python3"
+  ],
+  "schemaPath": "schemas/output.json",
+  "requiredFields": [
+    "skillName",
+    "status",
+    "output",
+    "output.summary",
+    "output.experiments",
+    "output.resilienceScore"
+  ],
+  "requiredNonEmptyFields": [
+    "output.summary"
+  ],
+  "mustContainTerms": [
+    "chaos",
+    "experiment",
+    "resilience"
+  ],
+  "mustNotContainTerms": [
+    "TODO",
+    "placeholder",
+    "FIXME"
+  ],
+  "enumValidations": {
+    ".status": [
+      "success",
+      "partial",
+      "failed",
+      "skipped"
+    ]
+  }
+}