[{"data":1,"prerenderedAt":-1},["ShallowReactive",2],{"skill:01M76YHSVH50F6BTHVM7XA0MGY":3,"skill-same:01M76YHSVH50F6BTHVM7XA0MGY":47},{"skillNo":4,"name":5,"nameZh":6,"description":7,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":16,"categories":17,"keywords":18,"publishedAt":19,"linkOnly":20,"markdownContent":21,"markdownBody":22,"frontMatter":23,"refName":25,"commitSha":26,"skillDirectory":27,"forksCount":28,"repositoryHtmlUrl":29,"repositoryHomepageUrl":6,"ownerHtmlUrl":30,"ownerBlogUrl":31,"ownerDescription":6,"updatedAt":32,"install":33,"resources":46},"01M76YHSVH50F6BTHVM7XA0MGY","test-tagging",null,"Classifies existing tests by standard traits and reports their distribution. USE FOR: tagging all tests with category attributes, categorizing\u002Ftagging\u002F labeling each test, compare happy vs error paths, audit the test mix, describe coverage shape by test type, or tag then verify the project builds. Read bodies when names mislead. Apply canonical attributes; otherwise report only. DO NOT USE FOR: requests owned by test-anti-patterns, coverage-analysis, crap-score, test-gap-analysis, code-testing, or migration skills.","stanfish06\u002Fskillquarium","stanfish06","https:\u002F\u002Favatars.githubusercontent.com\u002Fu\u002F93099613?v=4","01M75F1CK4ZW109ZK3T26VN52F","Zhiyuan","01M75F1CM53VH6F79DZ8GXKKES",12,"MIT","https:\u002F\u002Fgithub.com\u002Fstanfish06\u002Fskillquarium\u002Fblob\u002Fmaster\u002Fskills\u002Ftest-tagging\u002FSKILL.md",[],[],"2026-11-12 13:55:43",false,"---\nname: test-tagging\ndescription: >\n  Classifies existing tests by standard traits and reports their distribution.\n  USE FOR: tagging all tests with category attributes, categorizing\u002Ftagging\u002F\n  labeling each\n  test, compare happy vs error paths, audit the test mix, describe coverage shape\n  by test type, or tag then verify the project builds. Read bodies when names\n  mislead. Apply canonical attributes; otherwise report only. DO NOT USE FOR:\n  requests owned by test-anti-patterns, coverage-analysis, crap-score,\n  test-gap-analysis, code-testing, or migration skills.\nlicense: MIT\n---\n\n# Test Trait Tagging\n\nAnalyze an existing test suite in any supported language and apply a standardized set of trait tags to each test method, giving teams visibility into their test distribution (positive vs. negative, critical-path coverage, smoke tests, etc.).\n\n> **Language-specific guidance**: Read the caller-provided or runtime-listed\n> `test-analysis-extensions` catalog and its matching language file.\n> The helper is reference-only, not an invocable skill. If absent,\n> continue with the built-in framework table below and report the limitation.\n\n## When to Use\n\n- Auditing a test project to understand the mix of test types\n- Adding trait attributes to untagged tests\n- Generating a summary report of trait distribution across a test suite\n- Reviewing whether critical paths have sufficient coverage\n\n## When Not to Use\n\n- Writing new tests from scratch (use `code-testing` for any language, or `writing-mstest-tests` for MSTest)\n- Running or filtering tests (use `run-tests` for .NET; equivalent native runners elsewhere)\n- Migrating between test frameworks\n- General quality, smell, flakiness, or assertion audits (use `test-anti-patterns` or the matching analysis skill)\n- Diagnostic .NET executed line\u002Fbranch\u002FCobertura interpretation or project-wide CRAP risk (use `coverage-analysis`); raw coverage collection (use `run-tests` for .NET, native tooling otherwise)\n- CRAP analysis for a named method, class, or file (use `crap-score`)\n- Behavioral gaps where a test would survive broken production logic (use `test-gap-analysis`)\n\n## Inputs\n\n| Input | Required | Description |\n|-------|----------|-------------|\n| Test project or files | No | Path to the test project, folder, or specific test files. Discover from the current workspace when omitted. |\n| Scope | No | Infer from the verb: `tag`\u002F`apply` edits, `audit`\u002F`classify`\u002F`report` is report-only, and `both` applies only when both are requested. If ambiguous, default to `audit` to avoid unrequested edits. Frameworks declared `report-only` always emit a report; `convention-based` frameworks edit only after the user confirms the convention. |\n| Framework | No | Auto-detected. Override when detection fails. |\n\n## Trait Taxonomy\n\nUse exactly these trait names and values. Do not invent new trait values outside this table.\n\n| Trait Value | Meaning | Heuristics |\n|-------------|---------|------------|\n| `positive` | Verifies expected behavior under normal\u002Fvalid conditions | Asserts success, valid output, expected state, no exceptions for valid input |\n| `negative` | Verifies correct handling of invalid input, errors, or edge cases | Asserts exceptions, error codes, validation failures, rejects bad input |\n| `boundary` | Tests limits, thresholds, empty\u002Fnull\u002FNone\u002Fnil inputs, min\u002Fmax values | Operates on `0`, `-1`, `int.MaxValue` \u002F `sys.maxsize` \u002F `Number.MAX_SAFE_INTEGER` \u002F `math.MaxInt64` \u002F `i32::MAX`, empty string, null\u002FNone\u002Fnil\u002Fundefined, empty collection, boundary of valid range |\n| `critical-path` | Core workflow that must never break; breakage blocks users | Tests the primary success scenario of a key public API or user-facing feature |\n| `smoke` | Quick sanity check that the system is operational | Fast, no complex setup, verifies basic wiring (e.g., service resolves, endpoint returns 200) |\n| `regression` | Reproduces a specific previously-reported bug | References a bug ID, issue number, or describes a fix in its name or comments |\n| `integration` | Crosses process, network, or persistence boundaries | Uses real database, HTTP client, file system, external service, or multi-component setup |\n| `end-to-end` | Full user workflow spanning the entire application stack | Exercises a complete scenario from entry point to final result, distinct from single-boundary `integration` |\n| `performance` | Validates timing, throughput, or resource consumption | Asserts on elapsed time, memory, allocations, or uses benchmark harness (BenchmarkDotNet, pytest-benchmark, benchmark.js, JMH, `go test -bench`, criterion.rs, XCTMetric, kotlinx-benchmark, Google Benchmark) |\n| `security` | Verifies authentication, authorization, input sanitization, or secrets handling | Tests for SQL injection, XSS, CSRF, unauthorized access, token validation, permission checks |\n| `concurrency` | Validates thread safety, parallelism, or async correctness | Uses `Task.WhenAll` \u002F `Parallel.ForEach` \u002F `SemaphoreSlim` (.NET); `asyncio.gather` \u002F `threading.Lock` \u002F `multiprocessing` (Python); `Promise.all` \u002F worker threads (JS\u002FTS); `CompletableFuture` \u002F `ExecutorService` \u002F `synchronized` (Java); `go func` \u002F `sync.WaitGroup` \u002F `sync.Mutex` \u002F `chan` (Go); `Mutex` \u002F `Thread.new` (Ruby); `tokio::spawn` \u002F `Arc\u003CMutex\u003C_>>` \u002F `crossbeam` (Rust); `DispatchQueue` \u002F `actor` (Swift); `coroutineScope` \u002F `Mutex` (Kotlin); `Start-Job` \u002F `RunspacePool` (PowerShell); `std::thread` \u002F `std::mutex` (C++); reproduces race conditions |\n| `resilience` | Tests retry logic, timeouts, circuit breakers, or graceful degradation | Asserts behavior under transient failures, network drops, or service unavailability (e.g., Polly, tenacity, p-retry, resilience4j, hystrix, opossum, retry-go) |\n| `destructive` | Mutates shared or external state that is hard to roll back | Deletes records, drops resources, modifies global config -- useful for CI isolation decisions |\n| `configuration` | Verifies settings loading, defaults, environment behavior | Tests missing config keys, invalid values, environment variable fallbacks, options validation |\n| `flaky` | Known to intermittently fail (meta-tag for test health tracking) | Mark tests the team knows are unreliable; used to quarantine or prioritize stabilization |\n\nA single test may have **multiple traits** (e.g., both `negative` and `boundary`). At minimum, every test should receive one of `positive` or `negative`.\n\n## Workflow\n\n### Step 1: Detect the language, framework, and tagging capability\n\nResolve the requested test scope from the current workspace before asking for a\npath. The skill context's `Base directory` contains these instructions, not the\nuser's repository. Always inspect the current working directory before claiming\nthat repository files are unavailable. If the prompt's relative path is absent,\nsearch the workspace for the named project\u002Ffile and retry the exact result. A\nsuccessful search proves that the target is present; if the normal reader then\nreports that same path missing, treat the contradiction as a reader\npath-normalization or transport failure rather than asking the user for files.\nUse a shell text reader (`sed`\u002F`cat` on Unix,\n`Get-Content` on PowerShell) only for a confirmed reader availability,\ntransport, or path-normalization failure and only after verifying the canonical\npath remains inside the current workspace. Stop on content-exclusion,\npermission\u002Fpolicy, workspace-boundary, or unknown read failures. Never ask the\nuser for a path or file contents after a workspace search found a readable\ntarget.\n\nFor an `auto-edit` framework, a failed patch\u002Feditor call is not a stopping\ncondition only when the failure is confirmed tool availability, transport, or\npath normalization. Do not bypass stale-context, concurrent-change,\npermission\u002Fpolicy, or path-boundary errors. Before a shell fallback, resolve\nthe canonical path inside the current workspace, freshly read the file, and use\nan anchored transformation that aborts unless the expected old text and exact\nmatch count are unchanged. Then re-open the complete file, inspect the diff,\nand run Step 6 validation. Do not report proposed attributes as completion when\nthe user asked to apply them.\n\nIdentify the language and framework. Read the matching bundled reference when\nneeded; use the supplied catalog for the filename,\nchecking only that known directory. If absent, classify capability\nfrom the built-in rules below:\n\n- **`auto-edit`** — framework has canonical tag syntax this skill can safely insert (.NET `[TestCategory]` \u002F `[Trait]` \u002F `[Category]` \u002F `[Property]`, pytest `@pytest.mark.\u003Cname>`, JUnit 5 `@Tag(\"...\")`, TestNG `groups = {\"...\"}`, RSpec metadata `it \"...\" , :tag => true`, Pester `-Tag '...'`, Kotest `@Tags(...)`, Swift Testing `@Tag(.tagName)`, Catch2 `[tag]`, doctest `* doctest::test_suite(\"tag\")` decorator).\n- **`report-only`** — framework has no canonical, agreed-upon tag attribute; report tags in a Markdown table only and do not edit source (Go standard `testing` without build-tag conventions, Jest\u002FVitest without consistent describe-prefix convention, Rust without project-specific cfg conventions, XCTest without a test plan, GoogleTest without test-name prefix conventions, Mocha without describe-prefix conventions).\n- **`convention-based`** — framework uses naming or file conventions for tagging (Go `\u002F\u002Fgo:build integration` build tags, file-name suffixes like `*_integration_test.go`, GoogleTest `INTEGRATION_*` filter prefix). Only emit canonical edits when the user has confirmed the project convention; otherwise treat as `report-only`.\n\nCapture the capability before Step 4.\n\nAlso lock the requested mode before classification. Do not turn an audit into\nsource edits because canonical attributes are available; edit only for an\nexplicit tagging\u002Fapply request.\n\n### Step 2: Scan existing traits\n\nCheck which tests already have trait attributes. Use the extension when loaded;\notherwise use this built-in table as the source of truth:\n\n| Framework | Existing Attribute | Example |\n|-----------|--------------------|---------|\n| MSTest | `[TestCategory(\"...\")]` | `[TestCategory(\"positive\")]` |\n| xUnit | `[Trait(\"Category\", \"...\")]` | `[Trait(\"Category\", \"positive\")]` |\n| NUnit | `[Category(\"...\")]` | `[Category(\"positive\")]` |\n| TUnit | `[Property(\"Category\", \"...\")]` | `[Property(\"Category\", \"positive\")]` |\n| JUnit 5 | `@Tag(\"...\")` | `@Tag(\"positive\")` |\n| TestNG | `@Test(groups = {\"...\"})` | `@Test(groups = {\"positive\"})` |\n| pytest | `@pytest.mark.\u003Cname>` | `@pytest.mark.positive` |\n| RSpec | metadata after `it` | `it \"...\", :positive do` |\n| Pester | `-Tag '...'` | `It '...' -Tag 'positive'` |\n| Kotest | `@Tags(...)` | `@Tags(Positive)` |\n| Swift Testing | `@Tag(.\u003Cname>)` | `@Test(.tags(.positive))` |\n| Catch2 | `[tag]` in name | `TEST_CASE(\"...\", \"[positive]\")` |\n| doctest | `* doctest::test_suite(\"...\")` decorator | `TEST_CASE(\"...\" *doctest::test_suite(\"positive\"))` |\n\nRecord which tests already have tags to avoid duplication.\n\n### Step 3: Classify each test method\n\nBuild one canonical inventory containing each discovered test exactly once.\nRecord the test identifier, behavioral classification, and traits in that\ninventory; use the same rows for source edits, per-test reporting, totals, and\ndistribution counts. Do not hand-count a separate denominator. Before\npublishing, reconcile the reported total with the number of inventory rows and\nverify that every row contributes to each displayed trait count.\n\nFor each test method without traits, analyze:\n\n1. **Method name** -- names containing `Invalid`, `Fail`, `Error`, `Throw`, `Reject`, `BadInput`, `Null`, `None`, `Nil`, `Negative`, `raises_`, `_throws_`, `_returns_error` suggest `negative`\n2. **Assertion type** -- `Assert.ThrowsException` \u002F `Assert.Throws` \u002F `Should().Throw()` \u002F `pytest.raises` \u002F `expect(fn).toThrow` \u002F `assertThrows` \u002F `assert.Error(t, err)` \u002F `expect { ... }.to raise_error` \u002F `#[should_panic]` \u002F `XCTAssertThrowsError` \u002F `Should -Throw` \u002F `EXPECT_THROW` suggest `negative`\n3. **Input values** -- `null` \u002F `None` \u002F `nil` \u002F `undefined`, `\"\"`, `0`, `-1`, `int.MaxValue` \u002F `sys.maxsize` \u002F `Number.MAX_SAFE_INTEGER` \u002F `math.MaxInt64` \u002F `i32::MAX`, empty collections suggest `boundary`\n4. **Setup complexity** -- minimal setup with basic assertions suggests `smoke`; external dependencies (file\u002Fdb\u002Fnet\u002Fenv) suggest `integration`\n5. **Comments and names** -- references to issue numbers or \"regression\" \u002F \"bug\" \u002F \"fix for #...\" suggest `regression`\n6. **Timing assertions** -- `Stopwatch`, `BenchmarkDotNet`, elapsed-time checks; pytest-benchmark fixtures; benchmark.js; JMH `@Benchmark`; `go test -bench`; criterion.rs; XCTMetric; Google Benchmark; kotlinx-benchmark suggest `performance`\n7. **Feature centrality** -- tests on primary public API entry points or critical user workflows suggest `critical-path`\n8. **Security patterns** -- validates auth, checks permissions, sanitizes input, tests for injection, handles tokens\u002Fsecrets suggest `security`\n9. **Parallel\u002Fasync constructs** -- per-language concurrency primitives (see Trait Taxonomy table) suggest `concurrency`\n10. **Fault injection** -- simulates failures, tests retries, timeouts, or circuit breakers suggest `resilience`\n11. **State mutation** -- deletes external records, drops resources, modifies shared\u002Fglobal state suggest `destructive`\n12. **Full-stack flow** -- test spans entry point through data layer to final response, covering a complete user scenario suggest `end-to-end`\n13. **Config\u002Fsettings** -- loads configuration, tests missing keys, validates options, checks environment variables suggest `configuration`\n14. **Known instability** -- test has skip \u002F ignore annotations with comments about flakiness, or names contain \"flaky\" \u002F \"intermittent\" suggest `flaky`\n15. **Default** -- if the test verifies a normal success path, tag `positive`\n\nWhen in doubt between `positive` and `negative`, read the assertion: if it asserts success -> `positive`; if it asserts failure -> `negative`.\n\nFor a requested distribution or coverage-shape audit, use available production\ncode to map each test to the exact outcome it exercises before summarizing.\nCall out duplicated boundary coverage and whether the test inventory represents\nboth sides of named thresholds and the observable collaborator outcomes on\nbusiness-critical paths. Keep these as concise distribution observations, not\nnew trait values. Do not perform mutation reasoning, prescribe new tests, or\nexpand into the behavioral-gap audit owned by `test-gap-analysis`.\n\n### Step 4: Apply trait attributes (or report only)\n\nResolve the mode before applying the capability:\n\n- **Audit mode** (`audit`, `classify`, `report`, or ambiguous intent): emit the\n  per-test mapping and summary without modifying source, regardless of\n  capability.\n- **Edit mode** (`tag`, `apply`, or explicitly requested `both`): continue with\n  the capability branch below.\n\n**In edit mode, if the resolved capability is `auto-edit`**, add the appropriate\nattribute to each test method. Place trait attributes adjacent to the existing\ntest attribute. Examples:\n\nApply traits at the individual test-method\u002Fcase level. Do not substitute one\nclass-level category for method-level classification: different methods usually\nexercise different positive, negative, and boundary behavior.\n\n**MSTest:**\n```csharp\n[TestMethod]\n[TestCategory(\"negative\")]\n[TestCategory(\"boundary\")]\npublic void Parse_NullInput_ThrowsArgumentNullException() { ... }\n```\n\n**xUnit:**\n```csharp\n[Fact]\n[Trait(\"Category\", \"positive\")]\n[Trait(\"Category\", \"critical-path\")]\npublic void CreateOrder_ValidItems_ReturnsConfirmation() { ... }\n```\n\n**NUnit:**\n```csharp\n[Test]\n[Category(\"regression\")]\n[Category(\"negative\")]\npublic void Calculate_OverflowInput_ReturnsError() \u002F\u002F Fix for #1234\n{ ... }\n```\n\n**pytest:**\n```python\n@pytest.mark.negative\n@pytest.mark.boundary\ndef test_parse_none_input_raises_value_error():\n    ...\n```\n\n**JUnit 5:**\n```java\n@Test\n@Tag(\"positive\")\n@Tag(\"critical-path\")\nvoid createOrder_validItems_returnsConfirmation() { ... }\n```\n\n**TestNG:**\n```java\n@Test(groups = {\"negative\", \"boundary\"})\npublic void parse_nullInput_throwsIllegalArgumentException() { ... }\n```\n\n**RSpec:**\n```ruby\nit \"rejects null input\", :negative, :boundary do\n  ...\nend\n```\n\n**Pester:**\n```powershell\nIt 'Rejects null input' -Tag 'negative','boundary' {\n    ...\n}\n```\n\n**Kotest:**\n```kotlin\n@Tags(Negative, Boundary)\nclass ParserSpec : StringSpec({\n    \"rejects null input\" { ... }\n})\n```\n\n**Swift Testing:**\n```swift\n@Test(.tags(.negative, .boundary))\nfunc parseNullInputThrows() throws { ... }\n```\n\n**Catch2:**\n```cpp\nTEST_CASE(\"Parse null input throws\", \"[negative][boundary]\") { ... }\n```\n\n**In any mode, if the resolved capability is `report-only`** (Go standard\n`testing`, plain Jest\u002FVitest without convention, Rust without project-specific\ncfg, plain XCTest, plain GoogleTest, plain Mocha), do NOT modify source files.\nInstead emit a concise mapping from each test to its suggested tags. Recommend a\nproject-wide convention only when the user asks how to persist or filter those\ntags; an analysis-only request should report and stop.\n\n**In edit mode, if the resolved capability is `convention-based`** (e.g., Go\n`\u002F\u002Fgo:build integration`, `*_integration_test.go`, GoogleTest `INTEGRATION_*`\nprefix), only emit canonical edits when the user has confirmed the project's\nconvention. Otherwise treat as `report-only`.\n\n### Step 5: Generate trait summary\n\nAfter tagging, produce a summary table. Include only traits with a non-zero\ncount unless the user asks for the full taxonomy; zero-filled rows obscure the\nsuite's actual shape. For a small report-only suite, keep the per-test mapping\nand non-zero distribution together rather than expanding into a dashboard.\n\n```\n## Trait Distribution\n\n| Trait         | Count | % of Total |\n|---------------|-------|------------|\n| positive      |    50 |      64.1% |\n| negative      |    28 |      35.9% |\n| boundary      |     8 |      10.3% |\n| critical-path |    12 |      15.4% |\n| **Total tests** | **78** | -- |\n\nNote: Percentages exceed 100% because tests can have multiple traits.\n```\n\nInclude observations such as:\n- Ratio of positive to negative tests\n- Whether critical-path tests exist for key public APIs\n- Any tests that could not be confidently classified (list them for manual review)\n\n`boundary` and every other specialized trait are additive. A boundary success\ncase still counts as `positive`; a rejected boundary still counts as `negative`.\nDerive the positive\u002Fnegative distribution after applying this rule.\n\n### Step 6: Verify edits before reporting\n\nFor every `auto-edit` framework, run the narrowest command that compiles the\nedited attributes and confirms test discovery. This is required even when the\nuser asks only to add tags: syntactically plausible attributes are not a\ncompleted edit.\n\n| Framework | Minimum verification |\n|---|---|\n| .NET | Run `dotnet build \u003Ctest-project>`, then confirm discovery with `dotnet test \u003Ctest-project> --list-tests --no-build`. Do not execute the suite unless the user asks; route execution to `run-tests`. |\n| pytest | collect the edited suite with the repository's configured pytest command |\n| JUnit\u002FTestNG | compile tests through the repository's Maven\u002FGradle test task |\n| Other auto-edit frameworks | Use the repository's narrowest compile or test-discovery command |\n\nIf an edit or patch application was uncertain, re-open the complete edited file\nbefore verification and reconcile every inventory row with the actual\nattribute next to that test. Do not report success from a partial diff or from\nthe intended patch. If verification fails, report the exact command and error;\nnever publish a successful distribution handoff for uncompiled edits.\n\n## Validation\n\n- [ ] Every test method has at least one trait classification (`positive` or `negative` at minimum) — in the report for `report-only` frameworks, or as an attribute for `auto-edit` frameworks\n- [ ] The total equals the per-test inventory count, and displayed trait counts were derived from that inventory\n- [ ] No invented trait values outside the taxonomy table\n- [ ] Existing trait attributes were preserved, not duplicated\n- [ ] The trait summary table was generated\n- [ ] For `auto-edit` frameworks, the project still builds \u002F tests still discover without executing unrequested tests (`dotnet build` plus list mode \u002F `pytest --collect-only` \u002F `mvn test-compile` \u002F `go vet .\u002F...` \u002F `cargo check --tests` \u002F `npm run test:list` \u002F equivalent)\n- [ ] The final summary cites successful validation commands and the discovered test count when a discovery command is available\n- [ ] For `report-only` frameworks, no source files were modified\n- [ ] For `convention-based` frameworks, edits were applied ONLY when a project convention was confirmed\n\n## Common Pitfalls\n\n| Pitfall | Solution |\n|---------|----------|\n| Guessing traits without reading the test body | Always read assertions and setup to classify accurately |\n| Tagging a test only as `boundary` without `positive`\u002F`negative` | Every test should also be `positive` or `negative` -- `boundary` is additive |\n| Using the wrong attribute syntax for the detected framework | Match the loaded extension or built-in table (don't put `[TestCategory]` in xUnit or `@pytest.mark.x` in unittest) |\n| Duplicating an existing category attribute | Check for pre-existing traits in Step 2 before adding |\n| Over-tagging as `critical-path` | Reserve for tests on primary public entry points, not every helper |\n| Editing Go \u002F plain Jest \u002F plain Rust \u002F plain XCTest \u002F plain GoogleTest source | These are `report-only` by default — emit a Markdown table instead. Only edit if the user confirms a project-wide convention (build tag, file suffix, describe-prefix, test-plan grouping). |\n| Inventing tag prefixes for convention-based frameworks | Confirm the project's existing convention before adopting one — don't guess between `_integration_test.go`, `\u002F\u002Fgo:build integration`, or `IntegrationTest` prefix |\n| Missing language-specific concurrency \u002F async primitives | Use the loaded extension when available; otherwise use the Trait Taxonomy concurrency row |\n","# Test Trait Tagging\n\nAnalyze an existing test suite in any supported language and apply a standardized set of trait tags to each test method, giving teams visibility into their test distribution (positive vs. negative, critical-path coverage, smoke tests, etc.).\n\n> **Language-specific guidance**: Read the caller-provided or runtime-listed\n> `test-analysis-extensions` catalog and its matching language file.\n> The helper is reference-only, not an invocable skill. If absent,\n> continue with the built-in framework table below and report the limitation.\n\n## When to Use\n\n- Auditing a test project to understand the mix of test types\n- Adding trait attributes to untagged tests\n- Generating a summary report of trait distribution across a test suite\n- Reviewing whether critical paths have sufficient coverage\n\n## When Not to Use\n\n- Writing new tests from scratch (use `code-testing` for any language, or `writing-mstest-tests` for MSTest)\n- Running or filtering tests (use `run-tests` for .NET; equivalent native runners elsewhere)\n- Migrating between test frameworks\n- General quality, smell, flakiness, or assertion audits (use `test-anti-patterns` or the matching analysis skill)\n- Diagnostic .NET executed line\u002Fbranch\u002FCobertura interpretation or project-wide CRAP risk (use `coverage-analysis`); raw coverage collection (use `run-tests` for .NET, native tooling otherwise)\n- CRAP analysis for a named method, class, or file (use `crap-score`)\n- Behavioral gaps where a test would survive broken production logic (use `test-gap-analysis`)\n\n## Inputs\n\n| Input | Required | Description |\n|-------|----------|-------------|\n| Test project or files | No | Path to the test project, folder, or specific test files. Discover from the current workspace when omitted. |\n| Scope | No | Infer from the verb: `tag`\u002F`apply` edits, `audit`\u002F`classify`\u002F`report` is report-only, and `both` applies only when both are requested. If ambiguous, default to `audit` to avoid unrequested edits. Frameworks declared `report-only` always emit a report; `convention-based` frameworks edit only after the user confirms the convention. |\n| Framework | No | Auto-detected. Override when detection fails. |\n\n## Trait Taxonomy\n\nUse exactly these trait names and values. Do not invent new trait values outside this table.\n\n| Trait Value | Meaning | Heuristics |\n|-------------|---------|------------|\n| `positive` | Verifies expected behavior under normal\u002Fvalid conditions | Asserts success, valid output, expected state, no exceptions for valid input |\n| `negative` | Verifies correct handling of invalid input, errors, or edge cases | Asserts exceptions, error codes, validation failures, rejects bad input |\n| `boundary` | Tests limits, thresholds, empty\u002Fnull\u002FNone\u002Fnil inputs, min\u002Fmax values | Operates on `0`, `-1`, `int.MaxValue` \u002F `sys.maxsize` \u002F `Number.MAX_SAFE_INTEGER` \u002F `math.MaxInt64` \u002F `i32::MAX`, empty string, null\u002FNone\u002Fnil\u002Fundefined, empty collection, boundary of valid range |\n| `critical-path` | Core workflow that must never break; breakage blocks users | Tests the primary success scenario of a key public API or user-facing feature |\n| `smoke` | Quick sanity check that the system is operational | Fast, no complex setup, verifies basic wiring (e.g., service resolves, endpoint returns 200) |\n| `regression` | Reproduces a specific previously-reported bug | References a bug ID, issue number, or describes a fix in its name or comments |\n| `integration` | Crosses process, network, or persistence boundaries | Uses real database, HTTP client, file system, external service, or multi-component setup |\n| `end-to-end` | Full user workflow spanning the entire application stack | Exercises a complete scenario from entry point to final result, distinct from single-boundary `integration` |\n| `performance` | Validates timing, throughput, or resource consumption | Asserts on elapsed time, memory, allocations, or uses benchmark harness (BenchmarkDotNet, pytest-benchmark, benchmark.js, JMH, `go test -bench`, criterion.rs, XCTMetric, kotlinx-benchmark, Google Benchmark) |\n| `security` | Verifies authentication, authorization, input sanitization, or secrets handling | Tests for SQL injection, XSS, CSRF, unauthorized access, token validation, permission checks |\n| `concurrency` | Validates thread safety, parallelism, or async correctness | Uses `Task.WhenAll` \u002F `Parallel.ForEach` \u002F `SemaphoreSlim` (.NET); `asyncio.gather` \u002F `threading.Lock` \u002F `multiprocessing` (Python); `Promise.all` \u002F worker threads (JS\u002FTS); `CompletableFuture` \u002F `ExecutorService` \u002F `synchronized` (Java); `go func` \u002F `sync.WaitGroup` \u002F `sync.Mutex` \u002F `chan` (Go); `Mutex` \u002F `Thread.new` (Ruby); `tokio::spawn` \u002F `Arc\u003CMutex\u003C_>>` \u002F `crossbeam` (Rust); `DispatchQueue` \u002F `actor` (Swift); `coroutineScope` \u002F `Mutex` (Kotlin); `Start-Job` \u002F `RunspacePool` (PowerShell); `std::thread` \u002F `std::mutex` (C++); reproduces race conditions |\n| `resilience` | Tests retry logic, timeouts, circuit breakers, or graceful degradation | Asserts behavior under transient failures, network drops, or service unavailability (e.g., Polly, tenacity, p-retry, resilience4j, hystrix, opossum, retry-go) |\n| `destructive` | Mutates shared or external state that is hard to roll back | Deletes records, drops resources, modifies global config -- useful for CI isolation decisions |\n| `configuration` | Verifies settings loading, defaults, environment behavior | Tests missing config keys, invalid values, environment variable fallbacks, options validation |\n| `flaky` | Known to intermittently fail (meta-tag for test health tracking) | Mark tests the team knows are unreliable; used to quarantine or prioritize stabilization |\n\nA single test may have **multiple traits** (e.g., both `negative` and `boundary`). At minimum, every test should receive one of `positive` or `negative`.\n\n## Workflow\n\n### Step 1: Detect the language, framework, and tagging capability\n\nResolve the requested test scope from the current workspace before asking for a\npath. The skill context's `Base directory` contains these instructions, not the\nuser's repository. Always inspect the current working directory before claiming\nthat repository files are unavailable. If the prompt's relative path is absent,\nsearch the workspace for the named project\u002Ffile and retry the exact result. A\nsuccessful search proves that the target is present; if the normal reader then\nreports that same path missing, treat the contradiction as a reader\npath-normalization or transport failure rather than asking the user for files.\nUse a shell text reader (`sed`\u002F`cat` on Unix,\n`Get-Content` on PowerShell) only for a confirmed reader availability,\ntransport, or path-normalization failure and only after verifying the canonical\npath remains inside the current workspace. Stop on content-exclusion,\npermission\u002Fpolicy, workspace-boundary, or unknown read failures. Never ask the\nuser for a path or file contents after a workspace search found a readable\ntarget.\n\nFor an `auto-edit` framework, a failed patch\u002Feditor call is not a stopping\ncondition only when the failure is confirmed tool availability, transport, or\npath normalization. Do not bypass stale-context, concurrent-change,\npermission\u002Fpolicy, or path-boundary errors. Before a shell fallback, resolve\nthe canonical path inside the current workspace, freshly read the file, and use\nan anchored transformation that aborts unless the expected old text and exact\nmatch count are unchanged. Then re-open the complete file, inspect the diff,\nand run Step 6 validation. Do not report proposed attributes as completion when\nthe user asked to apply them.\n\nIdentify the language and framework. Read the matching bundled reference when\nneeded; use the supplied catalog for the filename,\nchecking only that known directory. If absent, classify capability\nfrom the built-in rules below:\n\n- **`auto-edit`** — framework has canonical tag syntax this skill can safely insert (.NET `[TestCategory]` \u002F `[Trait]` \u002F `[Category]` \u002F `[Property]`, pytest `@pytest.mark.\u003Cname>`, JUnit 5 `@Tag(\"...\")`, TestNG `groups = {\"...\"}`, RSpec metadata `it \"...\" , :tag => true`, Pester `-Tag '...'`, Kotest `@Tags(...)`, Swift Testing `@Tag(.tagName)`, Catch2 `[tag]`, doctest `* doctest::test_suite(\"tag\")` decorator).\n- **`report-only`** — framework has no canonical, agreed-upon tag attribute; report tags in a Markdown table only and do not edit source (Go standard `testing` without build-tag conventions, Jest\u002FVitest without consistent describe-prefix convention, Rust without project-specific cfg conventions, XCTest without a test plan, GoogleTest without test-name prefix conventions, Mocha without describe-prefix conventions).\n- **`convention-based`** — framework uses naming or file conventions for tagging (Go `\u002F\u002Fgo:build integration` build tags, file-name suffixes like `*_integration_test.go`, GoogleTest `INTEGRATION_*` filter prefix). Only emit canonical edits when the user has confirmed the project convention; otherwise treat as `report-only`.\n\nCapture the capability before Step 4.\n\nAlso lock the requested mode before classification. Do not turn an audit into\nsource edits because canonical attributes are available; edit only for an\nexplicit tagging\u002Fapply request.\n\n### Step 2: Scan existing traits\n\nCheck which tests already have trait attributes. Use the extension when loaded;\notherwise use this built-in table as the source of truth:\n\n| Framework | Existing Attribute | Example |\n|-----------|--------------------|---------|\n| MSTest | `[TestCategory(\"...\")]` | `[TestCategory(\"positive\")]` |\n| xUnit | `[Trait(\"Category\", \"...\")]` | `[Trait(\"Category\", \"positive\")]` |\n| NUnit | `[Category(\"...\")]` | `[Category(\"positive\")]` |\n| TUnit | `[Property(\"Category\", \"...\")]` | `[Property(\"Category\", \"positive\")]` |\n| JUnit 5 | `@Tag(\"...\")` | `@Tag(\"positive\")` |\n| TestNG | `@Test(groups = {\"...\"})` | `@Test(groups = {\"positive\"})` |\n| pytest | `@pytest.mark.\u003Cname>` | `@pytest.mark.positive` |\n| RSpec | metadata after `it` | `it \"...\", :positive do` |\n| Pester | `-Tag '...'` | `It '...' -Tag 'positive'` |\n| Kotest | `@Tags(...)` | `@Tags(Positive)` |\n| Swift Testing | `@Tag(.\u003Cname>)` | `@Test(.tags(.positive))` |\n| Catch2 | `[tag]` in name | `TEST_CASE(\"...\", \"[positive]\")` |\n| doctest | `* doctest::test_suite(\"...\")` decorator | `TEST_CASE(\"...\" *doctest::test_suite(\"positive\"))` |\n\nRecord which tests already have tags to avoid duplication.\n\n### Step 3: Classify each test method\n\nBuild one canonical inventory containing each discovered test exactly once.\nRecord the test identifier, behavioral classification, and traits in that\ninventory; use the same rows for source edits, per-test reporting, totals, and\ndistribution counts. Do not hand-count a separate denominator. Before\npublishing, reconcile the reported total with the number of inventory rows and\nverify that every row contributes to each displayed trait count.\n\nFor each test method without traits, analyze:\n\n1. **Method name** -- names containing `Invalid`, `Fail`, `Error`, `Throw`, `Reject`, `BadInput`, `Null`, `None`, `Nil`, `Negative`, `raises_`, `_throws_`, `_returns_error` suggest `negative`\n2. **Assertion type** -- `Assert.ThrowsException` \u002F `Assert.Throws` \u002F `Should().Throw()` \u002F `pytest.raises` \u002F `expect(fn).toThrow` \u002F `assertThrows` \u002F `assert.Error(t, err)` \u002F `expect { ... }.to raise_error` \u002F `#[should_panic]` \u002F `XCTAssertThrowsError` \u002F `Should -Throw` \u002F `EXPECT_THROW` suggest `negative`\n3. **Input values** -- `null` \u002F `None` \u002F `nil` \u002F `undefined`, `\"\"`, `0`, `-1`, `int.MaxValue` \u002F `sys.maxsize` \u002F `Number.MAX_SAFE_INTEGER` \u002F `math.MaxInt64` \u002F `i32::MAX`, empty collections suggest `boundary`\n4. **Setup complexity** -- minimal setup with basic assertions suggests `smoke`; external dependencies (file\u002Fdb\u002Fnet\u002Fenv) suggest `integration`\n5. **Comments and names** -- references to issue numbers or \"regression\" \u002F \"bug\" \u002F \"fix for #...\" suggest `regression`\n6. **Timing assertions** -- `Stopwatch`, `BenchmarkDotNet`, elapsed-time checks; pytest-benchmark fixtures; benchmark.js; JMH `@Benchmark`; `go test -bench`; criterion.rs; XCTMetric; Google Benchmark; kotlinx-benchmark suggest `performance`\n7. **Feature centrality** -- tests on primary public API entry points or critical user workflows suggest `critical-path`\n8. **Security patterns** -- validates auth, checks permissions, sanitizes input, tests for injection, handles tokens\u002Fsecrets suggest `security`\n9. **Parallel\u002Fasync constructs** -- per-language concurrency primitives (see Trait Taxonomy table) suggest `concurrency`\n10. **Fault injection** -- simulates failures, tests retries, timeouts, or circuit breakers suggest `resilience`\n11. **State mutation** -- deletes external records, drops resources, modifies shared\u002Fglobal state suggest `destructive`\n12. **Full-stack flow** -- test spans entry point through data layer to final response, covering a complete user scenario suggest `end-to-end`\n13. **Config\u002Fsettings** -- loads configuration, tests missing keys, validates options, checks environment variables suggest `configuration`\n14. **Known instability** -- test has skip \u002F ignore annotations with comments about flakiness, or names contain \"flaky\" \u002F \"intermittent\" suggest `flaky`\n15. **Default** -- if the test verifies a normal success path, tag `positive`\n\nWhen in doubt between `positive` and `negative`, read the assertion: if it asserts success -> `positive`; if it asserts failure -> `negative`.\n\nFor a requested distribution or coverage-shape audit, use available production\ncode to map each test to the exact outcome it exercises before summarizing.\nCall out duplicated boundary coverage and whether the test inventory represents\nboth sides of named thresholds and the observable collaborator outcomes on\nbusiness-critical paths. Keep these as concise distribution observations, not\nnew trait values. Do not perform mutation reasoning, prescribe new tests, or\nexpand into the behavioral-gap audit owned by `test-gap-analysis`.\n\n### Step 4: Apply trait attributes (or report only)\n\nResolve the mode before applying the capability:\n\n- **Audit mode** (`audit`, `classify`, `report`, or ambiguous intent): emit the\n  per-test mapping and summary without modifying source, regardless of\n  capability.\n- **Edit mode** (`tag`, `apply`, or explicitly requested `both`): continue with\n  the capability branch below.\n\n**In edit mode, if the resolved capability is `auto-edit`**, add the appropriate\nattribute to each test method. Place trait attributes adjacent to the existing\ntest attribute. Examples:\n\nApply traits at the individual test-method\u002Fcase level. Do not substitute one\nclass-level category for method-level classification: different methods usually\nexercise different positive, negative, and boundary behavior.\n\n**MSTest:**\n```csharp\n[TestMethod]\n[TestCategory(\"negative\")]\n[TestCategory(\"boundary\")]\npublic void Parse_NullInput_ThrowsArgumentNullException() { ... }\n```\n\n**xUnit:**\n```csharp\n[Fact]\n[Trait(\"Category\", \"positive\")]\n[Trait(\"Category\", \"critical-path\")]\npublic void CreateOrder_ValidItems_ReturnsConfirmation() { ... }\n```\n\n**NUnit:**\n```csharp\n[Test]\n[Category(\"regression\")]\n[Category(\"negative\")]\npublic void Calculate_OverflowInput_ReturnsError() \u002F\u002F Fix for #1234\n{ ... }\n```\n\n**pytest:**\n```python\n@pytest.mark.negative\n@pytest.mark.boundary\ndef test_parse_none_input_raises_value_error():\n    ...\n```\n\n**JUnit 5:**\n```java\n@Test\n@Tag(\"positive\")\n@Tag(\"critical-path\")\nvoid createOrder_validItems_returnsConfirmation() { ... }\n```\n\n**TestNG:**\n```java\n@Test(groups = {\"negative\", \"boundary\"})\npublic void parse_nullInput_throwsIllegalArgumentException() { ... }\n```\n\n**RSpec:**\n```ruby\nit \"rejects null input\", :negative, :boundary do\n  ...\nend\n```\n\n**Pester:**\n```powershell\nIt 'Rejects null input' -Tag 'negative','boundary' {\n    ...\n}\n```\n\n**Kotest:**\n```kotlin\n@Tags(Negative, Boundary)\nclass ParserSpec : StringSpec({\n    \"rejects null input\" { ... }\n})\n```\n\n**Swift Testing:**\n```swift\n@Test(.tags(.negative, .boundary))\nfunc parseNullInputThrows() throws { ... }\n```\n\n**Catch2:**\n```cpp\nTEST_CASE(\"Parse null input throws\", \"[negative][boundary]\") { ... }\n```\n\n**In any mode, if the resolved capability is `report-only`** (Go standard\n`testing`, plain Jest\u002FVitest without convention, Rust without project-specific\ncfg, plain XCTest, plain GoogleTest, plain Mocha), do NOT modify source files.\nInstead emit a concise mapping from each test to its suggested tags. Recommend a\nproject-wide convention only when the user asks how to persist or filter those\ntags; an analysis-only request should report and stop.\n\n**In edit mode, if the resolved capability is `convention-based`** (e.g., Go\n`\u002F\u002Fgo:build integration`, `*_integration_test.go`, GoogleTest `INTEGRATION_*`\nprefix), only emit canonical edits when the user has confirmed the project's\nconvention. Otherwise treat as `report-only`.\n\n### Step 5: Generate trait summary\n\nAfter tagging, produce a summary table. Include only traits with a non-zero\ncount unless the user asks for the full taxonomy; zero-filled rows obscure the\nsuite's actual shape. For a small report-only suite, keep the per-test mapping\nand non-zero distribution together rather than expanding into a dashboard.\n\n```\n## Trait Distribution\n\n| Trait         | Count | % of Total |\n|---------------|-------|------------|\n| positive      |    50 |      64.1% |\n| negative      |    28 |      35.9% |\n| boundary      |     8 |      10.3% |\n| critical-path |    12 |      15.4% |\n| **Total tests** | **78** | -- |\n\nNote: Percentages exceed 100% because tests can have multiple traits.\n```\n\nInclude observations such as:\n- Ratio of positive to negative tests\n- Whether critical-path tests exist for key public APIs\n- Any tests that could not be confidently classified (list them for manual review)\n\n`boundary` and every other specialized trait are additive. A boundary success\ncase still counts as `positive`; a rejected boundary still counts as `negative`.\nDerive the positive\u002Fnegative distribution after applying this rule.\n\n### Step 6: Verify edits before reporting\n\nFor every `auto-edit` framework, run the narrowest command that compiles the\nedited attributes and confirms test discovery. This is required even when the\nuser asks only to add tags: syntactically plausible attributes are not a\ncompleted edit.\n\n| Framework | Minimum verification |\n|---|---|\n| .NET | Run `dotnet build \u003Ctest-project>`, then confirm discovery with `dotnet test \u003Ctest-project> --list-tests --no-build`. Do not execute the suite unless the user asks; route execution to `run-tests`. |\n| pytest | collect the edited suite with the repository's configured pytest command |\n| JUnit\u002FTestNG | compile tests through the repository's Maven\u002FGradle test task |\n| Other auto-edit frameworks | Use the repository's narrowest compile or test-discovery command |\n\nIf an edit or patch application was uncertain, re-open the complete edited file\nbefore verification and reconcile every inventory row with the actual\nattribute next to that test. Do not report success from a partial diff or from\nthe intended patch. If verification fails, report the exact command and error;\nnever publish a successful distribution handoff for uncompiled edits.\n\n## Validation\n\n- [ ] Every test method has at least one trait classification (`positive` or `negative` at minimum) — in the report for `report-only` frameworks, or as an attribute for `auto-edit` frameworks\n- [ ] The total equals the per-test inventory count, and displayed trait counts were derived from that inventory\n- [ ] No invented trait values outside the taxonomy table\n- [ ] Existing trait attributes were preserved, not duplicated\n- [ ] The trait summary table was generated\n- [ ] For `auto-edit` frameworks, the project still builds \u002F tests still discover without executing unrequested tests (`dotnet build` plus list mode \u002F `pytest --collect-only` \u002F `mvn test-compile` \u002F `go vet .\u002F...` \u002F `cargo check --tests` \u002F `npm run test:list` \u002F equivalent)\n- [ ] The final summary cites successful validation commands and the discovered test count when a discovery command is available\n- [ ] For `report-only` frameworks, no source files were modified\n- [ ] For `convention-based` frameworks, edits were applied ONLY when a project convention was confirmed\n\n## Common Pitfalls\n\n| Pitfall | Solution |\n|---------|----------|\n| Guessing traits without reading the test body | Always read assertions and setup to classify accurately |\n| Tagging a test only as `boundary` without `positive`\u002F`negative` | Every test should also be `positive` or `negative` -- `boundary` is additive |\n| Using the wrong attribute syntax for the detected framework | Match the loaded extension or built-in table (don't put `[TestCategory]` in xUnit or `@pytest.mark.x` in unittest) |\n| Duplicating an existing category attribute | Check for pre-existing traits in Step 2 before adding |\n| Over-tagging as `critical-path` | Reserve for tests on primary public entry points, not every helper |\n| Editing Go \u002F plain Jest \u002F plain Rust \u002F plain XCTest \u002F plain GoogleTest source | These are `report-only` by default — emit a Markdown table instead. Only edit if the user confirms a project-wide convention (build tag, file suffix, describe-prefix, test-plan grouping). |\n| Inventing tag prefixes for convention-based frameworks | Confirm the project's existing convention before adopting one — don't guess between `_integration_test.go`, `\u002F\u002Fgo:build integration`, or `IntegrationTest` prefix |\n| Missing language-specific concurrency \u002F async primitives | Use the loaded extension when available; otherwise use the Trait Taxonomy concurrency row |\n",{"name":5,"license":15,"description":24},"Classifies existing tests by standard traits and reports their distribution. USE FOR: tagging all tests with category attributes, categorizing\u002Ftagging\u002F labeling each test, compare happy vs error paths, audit the test mix, describe coverage shape by test type, or tag then verify the project builds. Read bodies when names mislead. Apply canonical attributes; otherwise report only. DO NOT USE FOR: requests owned by test-anti-patterns, coverage-analysis, crap-score, test-gap-analysis, code-testing, or migration skills.\n","master","49e49abf2f670d429e0b7e2c0349739c3fdd5cbe","skills\u002Ftest-tagging",5,"https:\u002F\u002Fgithub.com\u002Fstanfish06\u002Fskillquarium","https:\u002F\u002Fgithub.com\u002Fstanfish06","https:\u002F\u002Fwww.stanfish.dev\u002F","2026-11-14 21:31:37",{"source":8,"skillName":5,"commands":34,"prompt":44,"zipAvailable":45},[35,38,41],{"tool":36,"command":37},"npx","npx skills add stanfish06\u002Fskillquarium --skill test-tagging",{"tool":39,"command":40},"bunx","bunx skills add stanfish06\u002Fskillquarium --skill test-tagging",{"tool":42,"command":43},"pnpm","pnpm dlx skills add stanfish06\u002Fskillquarium --skill test-tagging","安装技能，技能地址：https:\u002F\u002Fgithub.com\u002Fstanfish06\u002Fskillquarium\u002Fblob\u002Fmaster\u002Fskills\u002Ftest-tagging\u002FSKILL.md",true,[],[48,55,64,71,78,85],{"skillNo":49,"name":50,"nameZh":6,"description":51,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":52,"categories":53,"keywords":54,"publishedAt":19},"01M76ZJTRVA456GD7K8Y3EP82H","zarr-python","Stores and queries chunked N-D scientific arrays with Zarr-Python 3, including codecs, sharding, S3\u002FGCS storage, and NumPy\u002FDask\u002FXarray integration. Use for array layout, bounded I\u002FO, format migration, or scientific metadata preservation.","https:\u002F\u002Fgithub.com\u002Fstanfish06\u002Fskillquarium\u002Fblob\u002Fmaster\u002Fskills\u002Fzarr-python\u002FSKILL.md",[],[],{"skillNo":56,"name":57,"nameZh":6,"description":58,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":59,"licenseFileUrl":60,"sourceHtmlUrl":61,"categories":62,"keywords":63,"publishedAt":19},"01M76ZJQZ15Q1HKC5V85NHE325","yeet","Publish local changes to GitHub by confirming scope, committing intentionally, pushing the branch, and opening a draft PR through the GitHub app from this plugin, with `gh` used only as a fallback where connector coverage is insufficient.","Apache-2.0","https:\u002F\u002Fgithub.com\u002Fstanfish06\u002Fskillquarium\u002Fblob\u002Fmaster\u002Fskills\u002Fyeet\u002FLICENSE.txt","https:\u002F\u002Fgithub.com\u002Fstanfish06\u002Fskillquarium\u002Fblob\u002Fmaster\u002Fskills\u002Fyeet\u002FSKILL.md",[],[],{"skillNo":65,"name":66,"nameZh":6,"description":67,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":59,"licenseFileUrl":6,"sourceHtmlUrl":68,"categories":69,"keywords":70,"publishedAt":19},"01M76ZJ8ASZ4QYQ70Y6SBA4Z4S","xarray","N-dimensional labeled arrays and datasets in Python. Built on top of NumPy and Dask. It introduces labels in the form of dimensions, coordinates, and attributes on top of raw NumPy-like arrays, making data analysis in physical sciences more intuitive and less error-prone. Use for working with multi-dimensional scientific data, NetCDF\u002FGRIB\u002FZarr files, climate\u002Fweather\u002Foceanographic datasets, remote sensing, geospatial imaging, large out-of-memory datasets with Dask, and labeled array operations.","https:\u002F\u002Fgithub.com\u002Fstanfish06\u002Fskillquarium\u002Fblob\u002Fmaster\u002Fskills\u002Fxarray\u002FSKILL.md",[],[],{"skillNo":72,"name":73,"nameZh":6,"description":74,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":75,"categories":76,"keywords":77,"publishedAt":19},"01M76ZHFBXD6VXPQ02VCEG202B","writing-mstest-tests","Use when asked to fix, rewrite, update, improve, modernize, show corrected code for, or explain existing MSTest tests or MSTest-specific configuration. Use for \"review\" when corrected code or edits are wanted, even for one pasted assertion or passing tests with bad failure output. Covers expected\u002Factual labels; generic Boolean, collection, string, numeric, null, identity, exception, hard-cast, and object[] checks; TestContext\u002Flifecycle; timeout\u002Fcancellation; OS\u002FCI conditions, retry, cleanup, parallelization, MSTest.Sdk project setup, and MSTESTxxxx. Honor the installed MSTest version. DO NOT USE to design new test cases (code-testing), perform report-only audits, create project files rather than explain MSTest setup, run tests, migrate frameworks, or handle non-MSTest\u002Fnon-.NET code.","https:\u002F\u002Fgithub.com\u002Fstanfish06\u002Fskillquarium\u002Fblob\u002Fmaster\u002Fskills\u002Fwriting-mstest-tests\u002FSKILL.md",[],[],{"skillNo":79,"name":80,"nameZh":6,"description":81,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":82,"categories":83,"keywords":84,"publishedAt":19},"01M76ZDFDF4N88RH6HSYGS7GP2","wgs-prs","End-to-end WGS to polygenic risk score pipeline. Takes paired-end FASTQ files (or a pre-existing VCF) through nf-core\u002Fsarek for variant calling, applies VCF QC (normalisation, hard filtering, Ti\u002FTv and Het\u002FHom checks), then computes polygenic risk scores via the PGS Catalog. Fills the FASTQ to VCF gap upstream of the gwas-prs skill.","https:\u002F\u002Fgithub.com\u002Fstanfish06\u002Fskillquarium\u002Fblob\u002Fmaster\u002Fskills\u002Fwgs-prs\u002FSKILL.md",[],[],{"skillNo":86,"name":87,"nameZh":6,"description":88,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":59,"licenseFileUrl":89,"sourceHtmlUrl":90,"categories":91,"keywords":92,"publishedAt":19},"01M76ZCC1SC68J42QK4MDC8RCG","webapp-testing","Toolkit for interacting with and testing local web applications using Playwright. Supports verifying frontend functionality, debugging UI behavior, capturing browser screenshots, and viewing browser logs.","https:\u002F\u002Fgithub.com\u002Fstanfish06\u002Fskillquarium\u002Fblob\u002Fmaster\u002Fskills\u002Fwebapp-testing\u002FLICENSE.txt","https:\u002F\u002Fgithub.com\u002Fstanfish06\u002Fskillquarium\u002Fblob\u002Fmaster\u002Fskills\u002Fwebapp-testing\u002FSKILL.md",[],[]]