AutoGineer summary
Written by AutoGineer from the skill’s own files, not by the author
The vally-tests skill provides a structured workflow for authoring conformance tests for various AI artifacts, including prompts, instructions, agents, and skills. It operates by mapping artifact behaviors to specific Vally grader types, ensuring that tests are both relevant and robust. The skill includes a safety refusal taxonomy to prevent the generation of adversarial or harmful stimuli, and it supports both individual artifact processing and batch processing via corpus imports.
What it does
- Authors conformance test stimuli for prompts, instructions, agents, and skills.
- Routes test stimuli to appropriate Vally evaluation files based on artifact kind.
- Enforces a safety refusal taxonomy to block adversarial or policy-violating content.
- Performs deduplication of stimuli using SHA-256 hashing of normalized prompt text.
- Supports batch processing of test stimuli via CSV or XLSX corpus imports.
- Generates JSON run reports detailing the outcome of the authoring process.
When to use it
- When you need to create conformance tests for a new prompt, instruction, agent, or skill.
- When you have a batch of behaviors that require standardized formatting and deduplication.
- When you need to ensure that authored test stimuli comply with predefined safety and refusal policies.
- When you are working within a Vally-based evaluation environment.
Advantages
- Automates the creation of consistent and structured test stimuli.
- Prevents the accidental inclusion of harmful or prohibited content through a built-in safety taxonomy.
- Ensures test uniqueness through automated deduplication.
- Provides clear routing to the correct evaluation suites for different artifact types.
Usage examples
- “vally-tests mode=from-artifact files=my-agent.agent.md”
- The skill analyzes my-agent.agent.md, selects appropriate conformance checks, and appends the generated stimuli to the corresponding Vally eval file.
- “vally-tests mode=corpus-import path=tests.csv”
- The skill processes each row in the provided CSV, generates the corresponding stimulus blocks, and appends them to the routed eval file after deduplication.
Install
Download the skill as a ZIP:
https://mp-staging.autogineer.com/agent-skills/microsoft/vally-tests/downloadUnzip it into the cross-client skills folder of your project:
mkdir -p .agents/skills && unzip vally-tests.zip -d .agents/skills
Documentation by Microsoft
<!-- cspell:ignore roleplay doxxing scaffolder -->
Vally Tests Skill
Purpose
This skill authors Vally conformance tests for the four supported artifact kinds in this repository: prompts, instructions, agents, and skills. Each test exercises a documented behavior the artifact already claims and routes the result through an appropriate Vally grader so failures are explainable. Test authoring is bounded by a refusal taxonomy that keeps the skill out of adversarial, harmful, or policy-evasion territory.
Follow the shared content-policy public-output guard for eval stimuli and any public summaries derived from this skill. Vally tests are not a venue for terms-of-service boundary mapping, payload generation, refusal-text scoring, hidden-instruction disclosure, PII extraction, or secret extraction.
The skill ships:
A canonical authoring workflow that runs directly through
/vally-testsor through theVally Test Authorsubagent.Per-kind reference files that enumerate every conformance check the skill knows how to express.
A grader catalog that maps Vally CLI grader types to the checks they fit, and robustness rules that keep an emitted grader from asserting the impossible or failing correct behavior.
A safety refusal taxonomy with regex patterns the safety lint script consumes.
Helper scripts and asset templates for stimulus emission, corpus import, and dedupe.
When to Invoke
Invoke this skill in one of two modes:
From-artifact mode. The caller points at one or more artifact files (a
.prompt.md,.instructions.md,.agent.md, orSKILL.md) throughfiles, or at the open or attached file whenfilesis omitted, and asks for conformance test stimuli that verify each artifact's stated behaviors. The skill detects the artifact kind from the filename unlesskindoverrides it, looks up the matching per-kind reference, picks graders, and appends stimulus blocks to the routed Vally eval file.Corpus-import mode. The caller supplies a CSV or XLSX corpus through
paththat follows the shipped template, and the skill turns each row into a stimulus block in the routed eval file. Before reading, confirm thatpathexists and ends in.csvor.xlsx; otherwise name the bad path and stop. Every imported row carriestags.advisory: true, and corpus content cannot override it. Used when a large batch of behaviors needs identical formatting and dedupe handling.
After either mode, report the target eval file, stimuli appended, duplicates skipped, refusals triggered, and the JSON run report path.
Do not invoke this skill to:
Generate adversarial probes, jailbreak attempts, prompt-injection payloads, or red-team stimuli.
Test refusal quality on harmful, illegal, or policy-violating prompts.
Author stimuli that elicit PII, secrets, hidden instructions, or model self-disclosure.
Store payload examples, paraphrased prohibited requests, or quoted flagged content in Vally eval specs, corpus rows, PR summaries, issue bodies, or comments.
Replace Responsible AI threat modeling. RAI work lives in the RAI Planner agent.
Authoring Workflow
Each invocation follows the same six-step pipeline:
Artifact-kind detection. Resolve the kind from the artifact path or the corpus row's
kindcolumn. Supported kinds:prompt,instructions,agent,skill. Reject unknown kinds with a refusal block.Reference lookup. Load the matching reference file from
references/and select the check or checks the stimulus exercises. Stage the artifact under test in the stimulus'sagent_environmentso the agent can read what the prompt names.Grader selection. Use
references/grader-catalog.mdas the authoritative selection surface. Pick the registered Vally grader family that directly observes the expected behavior and follow its stimulus-shape guidance.Robustness check. Apply
references/grader-robustness.md. Confirm the stimulus stages every file whose wording the grader asserts, that the pattern constrains order and proximity only where those are the behavior under test, that a compliant agent phrasing the behavior differently still passes, and that no positive grader passes on the prompt text alone. Verify the pattern offline against answers that must pass and answers that must still fail before appending.Safety self-check. Run a safety self-check against the refusal taxonomy regex set. Refusing here is the correct outcome for any stimulus that matches a refusal category.
Dedupe and append. Compute a SHA-256 hash of the normalized prompt text, compare against existing stimuli in the target eval file, and append only when novel.
The pipeline is identical for both invocation modes. Corpus-import mode runs steps 2 through 6 once per row.
Safety Refusal Taxonomy
Authoring is bounded by seven refusal categories. Any stimulus that matches a category's regex set is refused before it reaches the dedupe step. The categories and their normative source are listed below. The full regex set lives in references/refusal-taxonomy.md and is consumed by the safety lint script.
| Category | Definition | Normative Source |
|---|---|---|
| jailbreak | Attempts to bypass model safety policies through persona switching, hypothetical framing, or roleplay coercion. | Project Code of Conduct |
| prompt-injection | Attempts to override system or developer instructions through embedded or external content. | Project Code of Conduct |
| harmful-elicitation | Requests for content that causes physical, financial, psychological, or reputational harm. | Project Code of Conduct |
| tos-violation | Stimuli that solicit content prohibited by GitHub, Microsoft, or model-provider terms of service. | Project Code of Conduct |
| coc-violation | Stimuli that violate this repository's Code of Conduct, including harassment, discrimination, or doxxing. | Project Code of Conduct |
| model-refusal-elicitation | Attempts to provoke a model refusal so the refusal text itself can be scored, graded, or used to map provider boundaries. | RAI Planner guidance |
| pii-extraction | Attempts to elicit personally identifiable information, secrets, credentials, or proprietary training data. | RAI Planner guidance |
When a request triggers a refusal, emit the canonical refusal block:
This skill authors conformance tests only. The request appears to fall under <category>. Please consult <Project Code of Conduct | RAI Planner agent> for the appropriate process.Substitute the matched <category> and the most relevant normative source. Do not negotiate, rephrase, or partially fulfill the request.
Helper Script Index
Helper scripts ship as parity pairs (.ps1 and .sh) where the workflow does not require Python. The safety lint is the exception: it ships only as Lint-VallyTestSafety.ps1, which import_corpus.py invokes, so a single regex engine evaluates the refusal taxonomy. Python is used only for the corpus-import path because the source-of-truth interchange format is CSV with an XLSX mirror.
| Script | Purpose | Language | Delivery |
|---|---|---|---|
scripts/New-Stimulus.ps1 | Scaffolds a single stimulus YAML block from an artifact path and appends to the routed eval file. | PowerShell 7+ | Phase 2 |
scripts/new-stimulus.sh | Parity counterpart for the PowerShell stimulus scaffolder. | bash | Phase 2 |
scripts/import_corpus.py | Reads the CSV or XLSX corpus template and emits dedupe-checked stimulus blocks per kind. | Python 3.11+ | Phase 2 |
scripts/Lint-VallyTestSafety.ps1 | Runs the refusal taxonomy regex set against a candidate stimulus and exits non-zero on match. | PowerShell 7+ | Phase 3 |
All helpers honour a shared dedupe contract: SHA-256 of the prompt text after Unicode NFC normalization and whitespace collapse.
The helpers emit a JSON run report to logs/vally-test-author-<timestamp>.json, where <timestamp> is YYYYMMDD-HHMMSS (UTC). The report captures, at minimum: mode; inputs (the resolved files/path and kind); target_eval_file; stimuli_appended (count and per-row hash); dedupe_results (count and per-row hash for skipped duplicates); refusal_check (per-row category match, if any); safety_lint_exit_code; blockers (any ambiguous safety-lint outcomes surfaced for review); and written_paths.
Reference Index
References capture the conformance taxonomy, grader selection rules, eval-suite routing, and the regex source of truth for the refusal taxonomy. Each file targets a specific decision point in the authoring workflow.
| Reference | Covers |
|---|---|
| prompts.md | The 12 conformance checks emitted for .prompt.md artifacts. |
| instructions.md | The 8 conformance checks emitted for .instructions.md artifacts. |
| agents.md | The 9 conformance checks emitted for .agent.md artifacts. |
| skills.md | The 9 conformance checks emitted for SKILL.md artifacts. |
| grader-catalog.md | Vally CLI grader types, selection rules, and gotchas. |
| grader-robustness.md | Mounting, order and proximity limits, negation guards, prompt-echo checks, and the pre-commit probe. |
| refusal-taxonomy.md | Regex source of truth for the 7 refusal categories and worked examples. |
| eval-suite-routing.md | Maps artifact kind to the canonical Vally eval file under evals/. |
Asset Index
Assets supply the interchange formats the corpus-import path consumes. The CSV is the source of truth. The XLSX mirror is regenerated from the CSV by import_corpus.py and is never edited directly.
| Asset | Purpose |
|---|---|
assets/corpus-import-template.csv | Canonical CSV template with header prompt,kind,target_artifact,grader,tags,expected_refusal_category,notes. |
assets/corpus-import-template.xlsx | Excel mirror of the CSV regenerated by the import script. |
Output Targets per Kind
Authored stimuli always land in one of the routed Vally eval files. The router is encoded in references/eval-suite-routing.md and mirrored here for quick lookup.
| Kind | Target Eval File | Vally Suite Name |
|---|---|---|
| prompt | evals/behavior-conformance/prompts.eval.yaml | behavior-conformance |
| instructions | evals/behavior-conformance/instructions.eval.yaml | behavior-conformance |
| agent | evals/agent-behavior/eval.yaml | agent-behavior |
| skill | evals/behavior-conformance/skill-behavior.eval.yaml | behavior-conformance |
The prompt target is created on first use when a repository has no prompt stimuli yet.
Never write to evals/baseline-equivalence/, evals/script-validation/, or evals/results/ from this skill. Those targets serve baseline equivalence, script validation, and historical comparison flows that are out of scope for conformance authoring.
Contributing
Follow these conventions when extending this skill:
New per-kind checks belong in the matching
references/{kind}.mdfile. Bump the check count in this SKILL.md when the reference adds or removes checks.New grader types belong in
references/grader-catalog.mdand only after the matching Vally CLI version is pinned inpackage.jsondevDependencies.New refusal categories require updates to
references/refusal-taxonomy.md, the regex set the safety lint script consumes, the Safety Refusal Taxonomy table above, and the canonical refusal block.Helper scripts must ship in parity pairs (
.ps1and.sh) unless the workflow has a hard Python dependency. The safety lint is the one exception and ships only asLint-VallyTestSafety.ps1; do not add a bash mirror. Python helpers live underscripts/and are configured by the skill'spyproject.toml.
Files
- ATTRIBUTION.mdAdded by AutoGineer827 B
- LICENSELicence file added by AutoGineer1.1 KiB
- SKILL.md14.2 KiB
- assets/.gitkeep0 B
- assets/corpus-import-template.csv923 B
- assets/corpus-import-template.xlsx136.0 KiB
- assets/grader-template.yml1.9 KiB
- assets/stimulus-template.yml2.0 KiB
- pyproject.toml577 B
- references/agents.md16.3 KiB
- references/eval-suite-routing.md6.9 KiB
- references/grader-catalog.md30.5 KiB
- references/grader-robustness.md8.6 KiB
- references/instructions.md8.9 KiB
- references/prompts.md11.8 KiB
- references/refusal-taxonomy.md12.5 KiB
- references/skills.md10.9 KiB
- scripts/Lint-VallyTestSafety.ps1Script4.1 KiB
- scripts/New-Stimulus.ps1Script6.3 KiB
- scripts/Select-Grader.ps1Script3.1 KiB
- scripts/import_corpus.pyScript14.9 KiB
- scripts/new-stimulus.shScript5.3 KiB
- scripts/select-grader.shScript2.8 KiB
- tests/Lint-VallyTestSafety.Tests.ps1Script4.0 KiB
- tests/New-Stimulus.Tests.ps1Script11.3 KiB
- tests/Select-Grader.Tests.ps1Script2.6 KiB
- tests/__init__.pyScript139 B
- tests/corpus/0_normalize_prompt19 B
- tests/corpus/1_hash_prompt24 B
- tests/corpus/2_validate_row77 B
- tests/corpus/3_build_patch_entry63 B
- tests/corpus/4_load_existing_hashes75 B
- tests/corpus/README.md1.3 KiB
- tests/fuzz_harness.pyScript6.9 KiB
- tests/test_import_corpus.pyScript12.3 KiB
- tests/test_lint_safety.pyScript3.6 KiB
- uv.lock73.5 KiB
references/refusal-taxonomy.md
title: Refusal Taxonomy description: Authoritative refusal categories, regex patterns, and worked refusal examples consumed by the Vally test-authoring safety lint script
This reference defines the seven refusal categories the Vally test-authoring skill enforces during stimulus generation. Each category lists the patterns the safety lint script reads verbatim along with the canonical refusal block the skill emits when a match occurs. The categories, ordering, and refusal wording are normative; downstream tooling treats this file as the only source for the regex set.
Category: jailbreak
Definition: Attempts to bypass model safety policies through persona switching, hypothetical framing, roleplay coercion, or explicit override commands directed at the underlying model rather than at the artifact under test.
Why refused: Authoring stimuli that attempt to jailbreak a model violates the prohibited content categories adopted in
CODE_OF_CONDUCT.md, which references the Microsoft Enterprise AI Services Code of Conduct. Authoring conformance tests is bounded to the artifact's own contract; jailbreak research belongs in the responsible AI workflow, not in Vally stimulus emission.Regex patterns (source of truth: the lint script reads these verbatim):
(?i)\bignore\s+(?:your\s+|the\s+|all\s+|any\s+)?(?:previous|prior|above|earlier)\s+(?:instructions?|prompts?|rules?|guidelines?)\b(?i)\bact\s+as\s+(?:an?\s+)?(?:unrestricted|unfiltered|uncensored|jailbroken)\s+(?:ai|assistant|model|chatbot)\b(?i)\b(?:dan\s*mode|do\s+anything\s+now|developer\s+mode|god\s+mode|sudo\s+mode)\b(?i)\b(?:pretend|imagine|roleplay)\s+(?:that\s+)?(?:safety|guidelines?|rules?|policies)\s+(?:do\s*n['o]?t\s+apply|are\s+disabled|don['o]?t\s+exist)\b(?i)\bwithout\s+(?:any\s+)?(?:safety|content|policy|moderation)\s+(?:restrictions?|filters?|guardrails?|guidelines?)\bWorked refusal example:
This skill authors conformance tests only. The request appears to fall under jailbreak. Please consult CODE_OF_CONDUCT.md for the appropriate process.
Category: prompt-injection
Definition: Attempts to override system or developer instructions through embedded markers, mode-switching directives, or adversarial control sequences placed inside what appears to be normal user input.
Why refused: Generating novel prompt-injection payloads conflicts with the AI output and prohibited content categories referenced in
CODE_OF_CONDUCT.md. Conformance tests verify the artifact's own contract; injection robustness research is out of scope for the Vally test-authoring skill.Regex patterns (source of truth: the lint script reads these verbatim):
(?i)\[\s*system\s*[:\]](?i)\b(?:in|enter|switch\s+to)\s+(?:test|debug|unsafe|admin|root|developer)\s+mode\b(?i)\bdisregard\s+(?:the\s+)?(?:above|previous|prior|preceding)\s+(?:text|content|instructions?|context)\b(?i)<\s*\/?(?:system|sys|instructions?|admin)\s*>(?i)\bnew\s+(?:system|admin|root)\s+(?:instruction|prompt|directive|command)s?\s*[:\-]Worked refusal example:
This skill authors conformance tests only. The request appears to fall under prompt-injection. Please consult CODE_OF_CONDUCT.md for the appropriate process.
Category: harmful-elicitation
Definition: Requests for content that causes physical, financial, psychological, or reputational harm, including weapons synthesis, violence how-tos, self-harm encouragement, illegal substance production, or promotion of abuse.
Why refused: This category is prohibited outright by the AI output policy referenced in
CODE_OF_CONDUCT.mdand by the harmful-content rule in the repository's Copilot instructions. No conformance scenario justifies authoring such stimuli.Regex patterns (source of truth: the lint script reads these verbatim):
(?i)\b(?:how\s+to|instructions?\s+(?:for|on)|guide\s+(?:to|for)|tutorial\s+(?:on|for))\s+(?:build|make|construct|create|synthesi[sz]e|manufacture)\s+(?:a\s+|an\s+)?(?:bomb|explosive|weapon|firearm|gun|poison|biological\s+agent|chemical\s+weapon)\b(?i)\bhow\s+to\s+(?:kill|murder|assault|attack|torture|harm|hurt|wound|maim)\s+(?:a\s+|an\s+|someone|people|person)\b(?i)\b(?:self[\s\-]?harm|self[\s\-]?injur(?:y|e|ing)|suicide\s+(?:method|technique|plan|instructions?))\b(?i)\b(?:synthesi[sz]e|cook|produce|manufacture)\s+(?:meth(?:amphetamine)?|fentanyl|heroin|cocaine|illegal\s+drugs?|controlled\s+substances?)\b(?i)\bgenerate\s+(?:content\s+)?(?:promoting|encouraging|glorifying)\s+(?:violence|self[\s\-]?harm|terrorism|abuse)\bWorked refusal example:
This skill authors conformance tests only. The request appears to fall under harmful-elicitation. Please consult CODE_OF_CONDUCT.md for the appropriate process.
Category: tos-violation
Definition: Stimuli that solicit content prohibited by GitHub, Microsoft, Azure, or model-provider terms of service, including verbatim reproduction of copyrighted works, fabrication of credentials, rate-limit evasion, or impersonation of real services or officials.
Why refused: The GitHub Acceptable Use Policies, Microsoft Trademark and Brand Guidelines, and Enterprise AI Services Code of Conduct referenced in
CODE_OF_CONDUCT.mdprohibit this material. Vally conformance tests do not require authoring policy-evasion stimuli.Regex patterns (source of truth: the lint script reads these verbatim):
(?i)\breproduc(?:e|ing)\s+(?:the\s+)?(?:full\s+|entire\s+|complete\s+|verbatim\s+)(?:text|content|chapter|book|article|song|lyrics|screenplay|source\s+code)\s+of\b(?i)\b(?:generate|create|forge|fabricate)\s+(?:a\s+|valid\s+|working\s+|real\s+)?(?:api\s+key|access\s+token|oauth\s+token|password|credential|license\s+key|product\s+key|serial\s+number)s?\b(?i)\b(?:bypass|circumvent|evade|defeat)\s+(?:the\s+|any\s+)?(?:rate\s+limit|usage\s+(?:limit|cap|quota)|paywall|content\s+filter|terms\s+of\s+service)\b(?i)\bimpersonat(?:e|ing)\s+(?:microsoft|openai|github|azure|google|amazon|apple|a\s+real\s+(?:person|company|service|official))\bWorked refusal example:
This skill authors conformance tests only. The request appears to fall under tos-violation. Please consult CODE_OF_CONDUCT.md for the appropriate process.
Category: coc-violation
Definition: Stimuli that violate this repository's Code of Conduct, including targeted harassment, doxxing, hate speech, intimidation, threats, or generation of discriminatory content aimed at protected classes.
Why refused: The Microsoft Open Source Code of Conduct adopted in
CODE_OF_CONDUCT.mdand the GitHub Acceptable Use Policies prohibit this material. No conformance scenario justifies generating it.Regex patterns (source of truth: the lint script reads these verbatim):
(?i)\b(?:targeted|coordinated|sustained)\s+(?:harassment|abuse|stalking|trolling)\b(?i)\b(?:dox(?:x?ing)?|publish(?:ing)?\s+private\s+(?:information|details|address|phone))\b(?i)\b(?:hate\s+speech|slur|epithet)s?\s+(?:about|against|targeting|toward)\s+(?:a\s+|any\s+)?(?:race|ethnicity|religion|gender|sexual\s+orientation|nationality|disability)\b(?i)\bgenerate\s+(?:content\s+)?(?:designed\s+to\s+)?(?:intimidate|threaten|harass|silence)\s+(?:a\s+|an\s+|the\s+)?(?:person|individual|user|group|community)\b(?i)\b(?:discriminatory|racist|sexist|misogynistic|homophobic|transphobic|xenophobic|antisemit(?:ic|ism)|islamophob(?:ic|ia))\s+(?:content|joke|message|post|comment)s?\bWorked refusal example:
This skill authors conformance tests only. The request appears to fall under coc-violation. Please consult CODE_OF_CONDUCT.md for the appropriate process.
Category: model-refusal-elicitation
Definition: Stimuli whose primary purpose is provoking a model refusal so that the refusal text itself can be scored, graded, paraphrased, or used to map provider safety boundaries, rather than verifying the artifact's own contract.
Why refused: Boundary mapping and refusal elicitation are activities for responsible AI assessment, not for conformance testing. They fall under the prohibited uses gate and safety-critical screening handled by
RAI Planner.Regex patterns (source of truth: the lint script reads these verbatim):
(?i)\bfind\s+(?:a\s+|the\s+|any\s+)?(?:prompt|input|stimulus|payload)\s+(?:that\s+)?(?:makes?|gets?|triggers?)\s+(?:you|the\s+model|the\s+ai)\s+(?:to\s+)?(?:refuse|deny|reject|block)\b(?i)\bminimum(?:\s+viable)?\s+(?:jailbreak|exploit|bypass|payload)\b(?i)\b(?:map|chart|enumerate|catalog(?:ue)?)\s+(?:the\s+|your\s+)?(?:refusal|safety|moderation|content)\s+(?:boundary|boundaries|limits?|threshold)s?\b(?i)\b(?:show|tell|demonstrate)\s+(?:me\s+)?(?:what|where|how)\s+(?:you|the\s+model|the\s+ai)\s+(?:refuses?|will\s+refuse|won['o]?t\s+respond)\b(?i)\bgenerate\s+\d+\s+(?:variations?|alternatives?|paraphrases?)\s+(?:to\s+)?(?:see|test|find)\s+(?:which\s+)?(?:one\s+)?(?:bypasses?|passes?|triggers?)\s+(?:the\s+)?(?:safety|filter|moderation)\bWorked refusal example:
This skill authors conformance tests only. The request appears to fall under model-refusal-elicitation. Please consult `RAI Planner` for the appropriate process.
Category: pii-extraction
Definition: Attempts to elicit personally identifiable information, credentials, secrets, system prompts, hidden instructions, or reconstructed training data from the model or the artifact under test.
Why refused: PII extraction probes safety, privacy, and security boundaries that belong in the responsible AI assessment workflow handled by
RAI Planner. Vally conformance tests verify documented artifact behavior; they are not the right vehicle for extraction stimuli.Regex patterns (source of truth: the lint script reads these verbatim):
(?i)\bextract\s+(?:all\s+)?(?:email\s+addresses?|phone\s+numbers?|ssns?|social\s+security\s+numbers?|credit\s+card\s+numbers?|home\s+addresses?)\b(?i)\b(?:leak|reveal|disclose|expose|print|dump)\s+(?:the\s+|your\s+|all\s+|any\s+)?(?:internal|private|stored|configured|environment)\s+(?:api\s+keys?|tokens?|credentials?|secrets?|passwords?)\b(?i)\b(?:reconstruct|reproduce|recover|exfiltrate)\s+(?:the\s+|your\s+|original\s+)?training\s+data\b(?i)\blist\s+(?:all\s+)?(?:user|customer|client|personal)\s+(?:pii|data|information|records?)\s+(?:you['o]?ve\s+)?(?:seen|processed|stored|remembered)\b(?i)\b(?:show|print|reveal|dump|list)\s+(?:your\s+|the\s+|all\s+)?(?:system\s+prompt|hidden\s+instructions?|configuration|environment\s+variables?)\bWorked refusal example:
This skill authors conformance tests only. The request appears to fall under pii-extraction. Please consult `RAI Planner` for the appropriate process.
Lint script contract
Every fenced block tagged with
```regexin this file is part of the source of truth. The lint script extracts the block bodies verbatim; no other file overrides or supplements them.Every pattern is case-insensitive PCRE-compatible. The
(?i)inline modifier is required at the start of each pattern so that PowerShell and Python regex engines apply identical matching semantics.The lint script joins all regex blocks under a single category using alternation (
|) and evaluates the combined pattern against the candidate stimulus. Patterns within a category are designed to coexist when alternated.Any match against any category's combined pattern flags the stimulus for refusal. The script emits the matching category, the matching pattern index within that category, and the stimulus location.
This file is the only normative source for the regex set. Changes to category names, pattern semantics, or refusal wording propagate through the lint script and the Vally Test Author prompt on the next regeneration; do not duplicate the patterns elsewhere.
Requirements and compatibility
Written for: GitHub Copilot, Claude Code
Works with: Claude Code, Claude apps, OpenAI Codex, GitHub Copilot, Cursor, Gemini CLI, Kiro, OpenCode, Goose, Amp, Roo Code, JetBrains Junie, Factory Droid, Devin (ex-Windsurf), Mistral Vibe, OpenHands, Letta
“Works with” means the tool reads the open Agent Skills format; a skill written for one tool may use features others lack.
Needs: Claude Code frontmatter, Needs Python
The author says: Requires Vally CLI 0.15.0+, PowerShell 7+, bash, and Python 3.11+ with uv for corpus-import workflows
Security
What our scanner noticed· Low risk
- Scripts that your agent may run
This skill includes scripts that your agent may run. Read them before you use it.
A static scan is not a guarantee. Skills are third-party content: review a skill before you let an agent use it.
Attribution and licence
- Published by
- Microsoft
- Publisher
- Microsoft (Official)
- Source
- microsoft/hve-core · .github/skills/hve-core/vally-tests · commit f425e94
- Licence
- MIT License (redistribution allowed)
- LICENSE (added by AutoGineer from LICENSE)
- ATTRIBUTION.md (written by AutoGineer)
- Synced
AutoGineer is not affiliated with or endorsed by Microsoft.
Download ZIP
The ZIP holds the skill’s files, its licence files and an ATTRIBUTION.md. Download vally-tests.zip