Multi-tier framework for evaluating AI agent skills and plugins with quality gates, security scanning, harness compatibility checks, semantic overlap detection, synthetic evaluation dataset generation, and live agent evaluation that measures how skills affect agent behavior. Ships reusable CI templates that bring every check to any repository.
Python agent-evaluationagent-pluginsagent-securityagent-skillsagentic-aibenchmarkci-templatesclaude-codecodexevaluateevaluationharnesspluginplugin-evaluationsecurity-scannerskill-evalskill-evaluationskill-evaluatorskill-gap-analysisskills
Recognize Node scripts in Tier 1 skill type and script checks (#474)
Christopher Kevinfa8e7b56ce33
diff --git a/CHANGELOG.md b/CHANGELOG.mdindex 4eea8f23..f11fef3e 100644--- a/CHANGELOG.md+++ b/CHANGELOG.md@@ -715,6 +715,15 @@ All notable changes to SkillEvaluator are documented in this file.`metrics.estimated_tokens` and `metrics.estimate_method` to the quality JSON.`metrics.total_tokens` keeps the same value and scoring is unchanged.+- Tier 1 skill-type detection and the script-based checks recognise Node scripts+ (`.mjs`, `.cjs`, `.js`) under `scripts/` and `tools/`, so a Node-script skill+ is no longer typed guide-only. A skill whose scripts are all Node scripts is not+ asked for a `run_script` call; one that also bundles Python or shell scripts+ keeps the check. Script lint still parses Python only and reports how many Node+ scripts it did not lint. The rubric judge also receives Node scripts and files+ from `tools/`. Scores of Node-script skills can change because they now get the+ script-based checks.+- Name Skill Lift as the headline comparison and label pass@k differences assupporting reliability across reports and terminal output.diff --git a/docs/tier1-validation.mdx b/docs/tier1-validation.mdxindex 6406974e..3543a9f0 100644--- a/docs/tier1-validation.mdx+++ b/docs/tier1-validation.mdx@@ -436,7 +436,9 @@ For `validate`, the default set is `schema`, `version`, `security`, `pii`, `liceCorrectness reports XML-style tags in any frontmatter value as a HIGH finding (potential prompt injection). A string `argument-hint`, or an unquoted hint such as `[<file>]` that YAML reads as a list of strings, may use command-line placeholders such as `<file> [--strict]`, `<plan|apply|verify>`, or `<codec e.g. av1|h264>`. A placeholder has at most four words, and `|` separates choices that are each one word or a quoted literal, after an optional label such as `stage:` or `codec e.g.`. Longer free text, shell command syntax (`;`, `&`, a backtick, `$(`, `${`, or a pipeline such as `<curl x | sh>`), closing tags, attributes, self-closing tags, and role or control tags such as `<system>`, `<tool_call>`, or `<script>` are still reported there. A role word (`system`, `developer`, `assistant`, `user`, `tool`, `context`, `instructions`, `prompt`, `override`, `rules`, or `policy`) followed by `prompt`, `message`, `call`, `use`, `result`, or `instruction` counts as a role tag (`<system_prompt>`, `<toolCall>`, `<user_message>`), while other names such as `<tool_name>`, `<user_id>`, `<prompt_file>`, or `<toolchain>` are ordinary placeholders. A hint with a redirect, that is a `>` that closes no group (`<cmd > file>`, `<cmd>file>`, `<cmd 2>file>`, `<curl x> /tmp/y>`), or a group with anything after a nested placeholder other than its own closing `>` (`<<curl x>/tmp/<y>>`, `<<x><y>>`) or anything other than a plain name before it (`<curl;sh<x>>`, `<$(curl x|sh)<x>>`), is not masked at all, so it is still reported. A placeholder nested directly after a plain name, such as `<R<NNN>>`, is masked. For a list value, each item and the space-joined hint are checked separately. An arrow or comparison between groups, such as `<old> -> <new>`, `<n> >= 1`, or `<count> (>0)`, is not a redirect. Every other field keeps the strict check.- The checker detects five skill shapes and applies relevant checks: **script-based** (Python or shell files under `scripts/`), **lib-based** (a Python module containing `__init__.py`), **resource-based** (assets, templates, design-system content, or resources), **guide-only** (documentation without executable or resource content), and **hybrid** (scripts plus library or resource content).+ The checker detects five skill shapes and applies relevant checks: **script-based** (Python, shell or Node `.mjs`, `.cjs` and `.js` files under `scripts/` or `tools/`), **lib-based** (a Python module containing `__init__.py`), **resource-based** (assets, templates, design-system content, or resources), **guide-only** (documentation without executable or resource content), and **hybrid** (scripts plus library or resource content).++ A script-based or hybrid skill is expected to document its scripts in an `## Available Scripts` table and to show how to run them. The check looks for a `run_script` call. A skill whose scripts are all Node scripts is not asked for it, because that call names a runner such a skill does not use; a skill that also bundles Python or shell scripts keeps the check. Node scripts are not read by the error-handling reliability check, which looks at Python scripts only. A Node-script skill that was typed guide-only before can therefore score differently after upgrading.Quality signals use boundary-aware lexical matching for unambiguous terms and CommonMark parsing for structural link evidence. Links inside code, images, or comments do not count, and external URLs do not satisfy local-reference checks. Deterministic Tier 1 checks do not infer author intent from ambiguous prose such as MCP negation, temporal language, README guidance, or exclusivity claims. Use `rubric-eval` for semantic judgments about the documentation and Tier 3 for observed agent behavior.@@ -535,7 +537,7 @@ For `validate`, the default set is `schema`, `version`, `security`, `pii`, `lice</Accordion><Accordion title="lint — script linting (advisory)">- `lint-scripts`, and the `lint` check inside `validate`, parse Python scripts under `scripts/` and report advisory findings. These findings do not make the Tier 1 gate fail.+ `lint-scripts`, and the `lint` check inside `validate`, parse Python scripts under `scripts/` and report advisory findings. Node scripts count as scripts for skill-type detection and the script-based checks but are not linted; the result says how many Node scripts were not linted. These findings do not make the Tier 1 gate fail.| Check | Severity | Detects || --- | --- | --- |diff --git a/src/skillevaluator/constants.py b/src/skillevaluator/constants.pyindex 4826586b..1df0b2cf 100644--- a/src/skillevaluator/constants.py+++ b/src/skillevaluator/constants.py@@ -50,6 +50,13 @@ DEFAULT_ALLOWED_SKILL_DIRS = frozenset(# SkillEvaluator name; ``tools/`` is the agentskills.io name.EXECUTABLE_SKILL_DIRS = ("scripts", "tools")+# File patterns that count as skill scripts under ``EXECUTABLE_SKILL_DIRS``.+# Script lint parses Python only; Node scripts are recognised for skill-type+# detection and the script-based checks but are reported as not linted.+PYTHON_SCRIPT_PATTERNS = ("*.py",)+NODE_SCRIPT_PATTERNS = ("*.mjs", "*.cjs", "*.js")+EXECUTABLE_SCRIPT_PATTERNS = (*PYTHON_SCRIPT_PATTERNS, "*.sh", *NODE_SCRIPT_PATTERNS)+# Env var that lets consumers EXTEND the allowed skill-root directory set per# repo (comma- or whitespace-separated) without editing bundled config — e.g.# ``SKILLEVALUATOR_SCHEMA_ALLOWED_DIRS="data,fixtures"``. Names are added to,diff --git a/src/skillevaluator/validators/quality_score.py b/src/skillevaluator/validators/quality_score.pyindex 77596cd9..09896e98 100644--- a/src/skillevaluator/validators/quality_score.py+++ b/src/skillevaluator/validators/quality_score.py@@ -27,7 +27,10 @@ from urllib.parse import unquote, urlsplitimport yamlfrom skillevaluator.constants import (+ EXECUTABLE_SCRIPT_PATTERNS,EXECUTABLE_SKILL_DIRS,+ NODE_SCRIPT_PATTERNS,+ PYTHON_SCRIPT_PATTERNS,QUALITY_CHARS_PER_TOKEN,QUALITY_DEFAULT_MIN_SCORE,QUALITY_EXCLUDED_DIRS,@@ -270,7 +273,7 @@ class QualityScoreValidator(ValidatorBase):# -----------------------------------------------------------------@staticmethod- def _executable_files(skill_path: Path, patterns: tuple[str, ...] = ("*.py", "*.sh")) -> list[Path]:+ def _executable_files(skill_path: Path, patterns: tuple[str, ...] = EXECUTABLE_SCRIPT_PATTERNS) -> list[Path]:files: list[Path] = []for dirname in EXECUTABLE_SKILL_DIRS:directory = skill_path / dirname@@ -279,6 +282,18 @@ class QualityScoreValidator(ValidatorBase):files.extend(sorted(directory.glob(pattern)))return files+ @staticmethod+ def _runs_only_node_scripts(script_files: list[Path]) -> bool:+ """Whether every bundled script is a Node script.++ ``run_script`` is the call the script checks look for in the instructions. It names a+ runner this skill does not use when all its scripts are Node scripts, so such a skill is+ not asked for it. Skills that also bundle Python or shell scripts keep the check.+ """+ return bool(script_files) and all(+ any(script.match(pattern) for pattern in NODE_SCRIPT_PATTERNS) for script in script_files+ )+@staticmethoddef _has_executable_directory(skill_path: Path) -> bool:return any((skill_path / dirname).is_dir() for dirname in EXECUTABLE_SKILL_DIRS)@@ -605,7 +620,9 @@ class QualityScoreValidator(ValidatorBase):qs.has_scripts = Trueqs.script_count = len(script_files)if qs.script_count == 0:- dim.deduct(10, "warning", "scripts/ or tools/ exists but contains no .py or .sh files")+ dim.deduct(+ 10, "warning", "scripts/ or tools/ exists but contains no .py, .sh, .mjs, .cjs or .js files"+ )else:dim.deduct(25,@@ -621,7 +638,7 @@ class QualityScoreValidator(ValidatorBase):"No documented scripts in table format","Add '## Available Scripts' with table: | Script | Purpose | Arguments |",)- if "run_script" not in content:+ if "run_script" not in content and not self._runs_only_node_scripts(script_files):dim.deduct(10,"warning",@@ -795,7 +812,7 @@ class QualityScoreValidator(ValidatorBase):# Type-aware code qualityif qs.skill_type in ("script-based", "hybrid"):- scripts = self._executable_files(skill_path, patterns=("*.py",))+ scripts = self._executable_files(skill_path, patterns=PYTHON_SCRIPT_PATTERNS)self._check_code_error_handling(dim, scripts, error_handling["scripts"])elif qs.skill_type == "lib-based":lib_dir = QualityScoreValidator.find_lib_module(skill_path)diff --git a/src/skillevaluator/validators/rubric_eval.py b/src/skillevaluator/validators/rubric_eval.pyindex 37a2c1ac..fb040899 100644--- a/src/skillevaluator/validators/rubric_eval.py+++ b/src/skillevaluator/validators/rubric_eval.py@@ -27,6 +27,7 @@ from typing import Anyfrom urllib.parse import unquote, urlsplitfrom skillevaluator.constants import (+ EXECUTABLE_SCRIPT_PATTERNS,RUBRIC_CRITERIA,RUBRIC_MAX_TOKENS,RUBRIC_MIN_SCORE,@@ -329,7 +330,7 @@ class RubricJudge(LLMClient):for name, content in linked_markdown.items():extra += f"--- {name} ---\n{content}\n\n"if scripts:- extra += "\nScripts (from scripts/ directory):\n"+ extra += "\nScripts (from scripts/ and tools/ directories):\n"for name, content in scripts.items():extra += f"--- {name} ---\n{content}\n\n"if references:@@ -567,7 +568,13 @@ def _collect_supplementary_content(if linked:result["linked_markdown"] = linked- for subdir, exts in [("scripts", ("*.py", "*.sh")), ("references", ("*.md",))]:+ # ``tools/`` is the agentskills.io name for ``scripts/``; its files are listed+ # under their directory so they cannot collide with a script of the same name.+ for subdir, bucket, exts in [+ ("scripts", "scripts", EXECUTABLE_SCRIPT_PATTERNS),+ ("tools", "scripts", EXECUTABLE_SCRIPT_PATTERNS),+ ("references", "references", ("*.md",)),+ ]:d = skill_path / subdirif not os.path.lexists(d):continue@@ -595,7 +602,7 @@ def _collect_supplementary_content(max_bytes=read_limit,truncate=True,)- result[subdir][f.name] = text+ result[bucket][f.name if subdir != "tools" else f"tools/{f.name}"] = texttotal += bytes_readreturn resultdiff --git a/src/skillevaluator/validators/script_lint.py b/src/skillevaluator/validators/script_lint.pyindex faa844d6..6e86b06c 100644--- a/src/skillevaluator/validators/script_lint.py+++ b/src/skillevaluator/validators/script_lint.py@@ -20,7 +20,13 @@ from __future__ import annotationsimport astfrom pathlib import Path-from skillevaluator.constants import EXECUTABLE_SKILL_DIRS, SCRIPT_LINT_MAX_NESTING, SCRIPT_LINT_SAFE_CONSTANTS+from skillevaluator.constants import (+ EXECUTABLE_SKILL_DIRS,+ NODE_SCRIPT_PATTERNS,+ PYTHON_SCRIPT_PATTERNS,+ SCRIPT_LINT_MAX_NESTING,+ SCRIPT_LINT_SAFE_CONSTANTS,+)from skillevaluator.logging_config import get_loggerfrom skillevaluator.models.result import Finding, Severity, ValidationResultfrom skillevaluator.validators.base import ValidatorBase@@ -129,24 +135,40 @@ class ScriptLintValidator(ValidatorBase):validator_description=self.description,)py_files: list[Path] = []+ node_files: list[Path] = []for dirname in EXECUTABLE_SKILL_DIRS:directory = skill_path / dirnameif directory.is_dir():- py_files.extend(sorted(directory.glob("*.py")))+ for pattern in PYTHON_SCRIPT_PATTERNS:+ py_files.extend(sorted(directory.glob(pattern)))+ for pattern in NODE_SCRIPT_PATTERNS:+ node_files.extend(sorted(directory.glob(pattern)))+ not_linted = f"{len(node_files)} Node script(s) not linted (script lint parses Python only)"+ suffix = f"; {not_linted}" if node_files else ""if not py_files:if not any((skill_path / dirname).is_dir() for dirname in EXECUTABLE_SKILL_DIRS):result.add_success(check_name="lint", message="No scripts/ or tools/ directory found")else:- result.add_success(check_name="lint", message="No Python scripts found in scripts/ or tools/")+ result.add_success(check_name="lint", message=f"No Python scripts found in scripts/ or tools/{suffix}")return resultfor script in py_files:self._lint_script(script, result)if not result.findings:- result.add_success(- check_name="lint",- message=f"All {len(py_files)} script(s) passed lint checks",+ result.add_success(check_name="lint", message=f"All {len(py_files)} script(s) passed lint checks{suffix}")+ elif node_files:+ # The findings carry the verdict. Keep the Node note as an informational finding:+ # unlike a message it survives folder aggregation and the JSON report, and it does+ # not count as another completed check.+ result.add_finding(+ Finding(+ category="SCRIPT_LINT",+ severity=Severity.INFO,+ check_name="node_scripts_not_linted",+ message=not_linted,+ file_path=node_files[0].parent.name,+ ))return resultdiff --git a/tests/validators/test_quality_score.py b/tests/validators/test_quality_score.pyindex dac657f6..98933590 100644--- a/tests/validators/test_quality_score.py+++ b/tests/validators/test_quality_score.py@@ -1563,7 +1563,9 @@ class TestReliabilityErrorHandlingConfig:silent_skill = _write_issue_skill(tmp_path, name="probe-a", troubleshooting="Check the output directory.")mentioning_skill = _write_issue_skill(tmp_path, name="probe-b", troubleshooting="Report the error.")- silent = _validate_with(silent_skill, tmp_path, "expected_headers: []\nerror_handling: {mentioned: {points: 0}}\n")+ silent = _validate_with(+ silent_skill, tmp_path, "expected_headers: []\nerror_handling: {mentioned: {points: 0}}\n"+ )mentioning = _validate_with(mentioning_skill, tmp_path, "expected_headers: []\n")assert MENTION_MESSAGE not in [message for message, _ in _reliability_issues(silent)]@@ -1619,7 +1621,9 @@ class TestReliabilityErrorHandlingConfig:result = _validate_with(skill_dir, tmp_path)- lib_issues = [(m, d) for m, d in _reliability_issues(result) if m.startswith("Lib modules may lack error handling: ")]+ lib_issues = [+ (m, d) for m, d in _reliability_issues(result) if m.startswith("Lib modules may lack error handling: ")+ ]assert len(lib_issues) == 1 and lib_issues[0][1] == 5names = lib_issues[0][0].removeprefix("Lib modules may lack error handling: ").split(", ")assert len(names) == 3 and set(names) < {"a.py", "b.py", "c.py", "d.py"}@@ -1647,7 +1651,9 @@ class TestReliabilityErrorHandlingConfig:assert result.metadata["quality_scores"]["metrics"]["has_error_handling"] is True- @pytest.mark.parametrize("text", ["Check the exit\ncode first.", "Check the exit code first.", "Check the exit\r\n code."])+ @pytest.mark.parametrize(+ "text", ["Check the exit\ncode first.", "Check the exit code first.", "Check the exit\r\n code."]+ )def test_multi_word_custom_terms_match_across_wrapped_or_repeated_whitespace(self, tmp_path: Path, text: str):skill_dir = _write_issue_skill(tmp_path, troubleshooting=text)config = 'expected_headers: []\nerror_handling:\n mentioned:\n terms: ["exit code"]\n'@@ -1752,3 +1758,50 @@ def test_html_report_labels_the_token_count_as_an_estimate(tmp_path):html = HTMLReporter(include_timestamp=False, explicit_skill_name="estimate-skill").render(result)assert "Est. tokens (characters/4):" in html+++def _script_skill(tmp_path, script_name, instructions):+ skill = tmp_path / "scripted-skill"+ (skill / "scripts").mkdir(parents=True)+ (skill / "scripts" / script_name).write_text(+ "console.log('hi')\n" if script_name.endswith(("js", "mjs")) else "print('hi')\n"+ )+ (skill / "SKILL.md").write_text(+ "---\nname: scripted-skill\ndescription: Runs a bundled script. Use when the user asks for it.\n---\n\n"+ "# Scripted skill\n\n## Available Scripts\n\n| Script | Purpose | Arguments |\n| --- | --- | --- |\n"+ f"| {script_name} | Does the work | input |\n\n## Instructions\n\n{instructions}\n"+ )+ return skill+++def _messages(skill):+ return [finding.message for finding in QualityScoreValidator().validate(skill).findings]+++def test_node_only_skill_is_not_asked_for_run_script(tmp_path):+ skill = _script_skill(tmp_path, "run.mjs", "Use the bundled script to process the file.")++ assert not any("run_script" in message for message in _messages(skill))+++def test_node_only_skill_still_needs_its_scripts_documented_in_a_table(tmp_path):+ skill = _script_skill(tmp_path, "run.mjs", "Use the bundled script to process the file.")+ (skill / "SKILL.md").write_text(+ "---\nname: scripted-skill\ndescription: Runs a bundled script. Use when the user asks for it.\n---\n\n"+ "# Scripted skill\n\n## Instructions\n\nRun `node scripts/run.mjs input.txt`.\n"+ )++ assert any("No documented scripts in table format" in message for message in _messages(skill))+++def test_skill_with_python_and_node_scripts_still_needs_run_script(tmp_path):+ skill = _script_skill(tmp_path, "run.mjs", "Use the bundled scripts to process the file.")+ (skill / "scripts" / "helper.py").write_text("print('hi')\n")++ assert any("Instructions don't mention 'run_script'" in message for message in _messages(skill))+++def test_python_script_skill_still_needs_run_script(tmp_path):+ skill = _script_skill(tmp_path, "run.py", "Run `node scripts/run.py` and show the output.")++ assert any("Instructions don't mention 'run_script'" in message for message in _messages(skill))diff --git a/tests/validators/test_rubric_eval.py b/tests/validators/test_rubric_eval.pyindex 4b73e472..09b4c555 100644--- a/tests/validators/test_rubric_eval.py+++ b/tests/validators/test_rubric_eval.py@@ -257,6 +257,17 @@ class TestCollectSupplementaryContent:result = _collect_supplementary_content(skill_dir)assert "main.py" in result["scripts"]+ def test_collects_node_scripts_for_the_judge(self, tmp_path):+ skill_dir = tmp_path / "my-skill"+ skill_dir.mkdir()+ scripts = skill_dir / "scripts"+ scripts.mkdir()+ for name in ("run.mjs", "run.cjs", "run.js"):+ (scripts / name).write_text("console.log('hello')")+ (scripts / "notes.txt").write_text("not a script")+ result = _collect_supplementary_content(skill_dir)+ assert set(result["scripts"]) == {"run.mjs", "run.cjs", "run.js"}+def test_collects_references(self, tmp_path):skill_dir = tmp_path / "my-skill"skill_dir.mkdir()@@ -1735,3 +1746,19 @@ class TestInvalidReplyRetry:rubric = result.metadata["rubric_eval"]assert rubric["execution_status"] == "succeeded"assert rubric["judge_attempts"] == 1+++class TestCollectToolsScripts:+ def test_tools_directory_scripts_reach_the_judge_without_colliding_with_scripts(self, tmp_path):+ skill_dir = tmp_path / "my-skill"+ (skill_dir / "scripts").mkdir(parents=True)+ (skill_dir / "tools").mkdir()+ (skill_dir / "scripts" / "run.mjs").write_text("console.log('scripts')")+ (skill_dir / "tools" / "run.mjs").write_text("console.log('tools')")+ (skill_dir / "tools" / "helper.py").write_text("print('tools')")++ result = _collect_supplementary_content(skill_dir)++ assert set(result["scripts"]) == {"run.mjs", "tools/run.mjs", "tools/helper.py"}+ assert "scripts" in result["scripts"]["run.mjs"]+ assert "tools" in result["scripts"]["tools/run.mjs"]diff --git a/tests/validators/test_script_lint.py b/tests/validators/test_script_lint.pyindex 9daa5869..e6d29628 100644--- a/tests/validators/test_script_lint.py+++ b/tests/validators/test_script_lint.py@@ -7,6 +7,7 @@ from pathlib import Pathimport pytest+from skillevaluator.models.result import Severity, ValidationResultfrom skillevaluator.validators.script_lint import ScriptLintValidator@@ -31,6 +32,70 @@ class TestScriptLintValidator:assert result.passedassert not result.findings+ def test_node_scripts_reported_as_not_linted(self, skill_with_scripts):+ scripts = skill_with_scripts / "scripts"+ (scripts / "a.mjs").write_text("console.log('a')\n")+ (scripts / "b.js").write_text("console.log('b')\n")+ result = ScriptLintValidator().validate(skill_with_scripts)+ assert result.passed+ assert not result.findings+ messages = [d.message for d in result.success_details]+ assert any("2 Node script(s) not linted" in m for m in messages), messages++ def test_node_scripts_reported_alongside_python_lint_findings(self, skill_with_scripts):+ scripts = skill_with_scripts / "scripts"+ (scripts / "flat.py").write_text("#!/usr/bin/env python3\nimport sys\nprint(sys.argv)\n")+ (scripts / "a.js").write_text("console.log('a')\n")+ result = ScriptLintValidator().validate(skill_with_scripts)+ checks = [f.check_name for f in result.findings]+ assert "flat_script" in checks+ (note,) = [f for f in result.findings if f.check_name == "node_scripts_not_linted"]+ assert note.severity == Severity.INFO+ assert "1 Node script(s) not linted" in note.message++ def test_node_note_survives_folder_aggregation(self, skill_with_scripts):+ scripts = skill_with_scripts / "scripts"+ (scripts / "flat.py").write_text("#!/usr/bin/env python3\nimport sys\nprint(sys.argv)\n")+ (scripts / "a.js").write_text("console.log('a')\n")+ single = ScriptLintValidator().validate(skill_with_scripts)+ folder = ValidationResult()+ folder.merge_with_prefix(single, "skill-a")+ assert any(+ f.check_name == "node_scripts_not_linted" and f.file_path.startswith("[skill-a]") for f in folder.findings+ )++ def test_node_scripts_do_not_add_a_second_completed_check(self, skill_with_scripts):+ scripts = skill_with_scripts / "scripts"+ (scripts / "a.mjs").write_text("console.log('a')\n")+ with_node = ScriptLintValidator().validate(skill_with_scripts)+ (scripts / "a.mjs").unlink()+ without_node = ScriptLintValidator().validate(skill_with_scripts)+ assert with_node.summary.checks_performed == without_node.summary.checks_performed+ assert len(with_node.success_details) == len(without_node.success_details)++ def test_node_scripts_in_tools_dir_and_clean_python_are_both_reported(self, tmp_path):+ skill_dir = tmp_path / "tools-skill"+ tools = skill_dir / "tools"+ tools.mkdir(parents=True)+ (skill_dir / "SKILL.md").write_text("---\nname: tools-skill\ndescription: test\n---\n\n# Test\n")+ (tools / "ok.py").write_text(+ "#!/usr/bin/env python3\n"+ "import argparse\n\n"+ "def main():\n"+ " parser = argparse.ArgumentParser()\n"+ " parser.add_argument('input')\n"+ " args = parser.parse_args()\n"+ " print(args.input)\n\n"+ "if __name__ == '__main__':\n"+ " main()\n"+ )+ (tools / "a.mjs").write_text("export {}\n")+ (tools / "b.cjs").write_text("module.exports = {}\n")+ result = ScriptLintValidator().validate(skill_dir)+ messages = [d.message for d in result.success_details]+ assert any("passed lint checks" in m for m in messages), messages+ assert any("2 Node script(s) not linted" in m for m in messages), messages+def test_flat_script_finding(self, skill_with_scripts):scripts = skill_with_scripts / "scripts"(scripts / "flat.py").write_text("#!/usr/bin/env python3\nimport sys\nprint(sys.argv)\n")