showdar-skills 0.2.0

package/skills/showdar-ship/stacks/node-backend.md

@@ -0,0 +1,37 @@
+# Node backend delivery verification
+
+Verify the artifact and release-like local runtime by default. Deployment,
+traffic changes, and production data operations require an explicit task.
+
+## Artifact and runtime
+
+Record Node version/engine, package-manager lockfile, start command, process model, image/base runtime, port, and environment names. Verify the production artifact contains the intended source/generated files and no development-only dependency or secret. Test with the same module mode, CPU architecture, TLS/CA setup, and resource limits as the target; a passing local dev server is not runtime parity.
+
+## Data compatibility assessment
+
+Classify migrations as additive, backfill, lock-heavy, destructive, or
+irreversible. Assess an expand/contract sequence: compatible readers/writers,
+observable backfill, then removal after old consumers are gone. Confirm old and
+new versions can coexist and that queues, caches, and retries do not duplicate
+side effects. Read `references/migrations.md` and `references/rollback.md`
+without applying production changes.
+
+## Health and operations
+
+Separate liveness from readiness: readiness must fail when required dependencies are unavailable, while liveness must not restart a process for a temporary downstream outage. Verify graceful shutdown drains requests, stops consumers, closes pools, and respects the termination window. Check structured logs, request IDs, metrics, traces, alert thresholds, secret references by name, and startup config validation.
+
+## Wrong turns and rollback
+
+Do not use a health endpoint that returns 200 while the application cannot
+serve its critical path, hide config errors with defaults, or claim rollback
+safety without checking schema compatibility. Record prior artifact/config,
+feature-flag state, rollback trigger, queued-message handling, and any
+execution-only checks as unverified.
+
+## Verification
+
+Run tests, static checks, production build, migration dry-run/validation where
+supported, and a release-like local start. Smoke readiness, authentication, one
+critical read/write, dependency outage, timeout, and graceful termination.
+Observe a deployed version only when explicit deployment verification was
+requested.

package/skills/showdar-ship/stacks/orchestration.md

@@ -0,0 +1,12 @@
+# Container orchestration delivery verification
+
+Use this only when the task explicitly concerns orchestration execution or
+review of an existing orchestration configuration. In ordinary Ship mode,
+inspect the files read-only; do not create manifests, modify deployment config,
+change traffic, or operate a cluster.
+
+For explicit scope, verify image digest, resource limits, readiness/liveness
+behavior, secret references, rollout strategy, replica availability, and
+rollback target. A rollout is not healthy until new replicas serve the critical
+smoke path and old replicas drain as intended. Keep migration compatibility and
+previous image/config available before changing traffic.

package/skills/showdar-ship/stacks/tauri.md

@@ -0,0 +1,35 @@
+# Tauri/desktop delivery verification
+
+Verify bundles, signing inputs, and local install/update behavior by default.
+Notarization submission, updater publication, and release-channel changes are
+explicit execution scopes.
+
+## Artifact and identity
+
+Record Tauri/Rust/frontend versions, target triples, bundle identifier, product name, marketing/build version, updater channel, and artifact formats (`.app`/DMG/PKG, MSI/NSIS, or other configured targets). Verify the packaged frontend assets, Rust release binary, resources, capabilities, icons, and platform-specific paths; a dev-server launch does not validate the bundle.
+
+## Signing and updater
+
+For macOS verify Developer ID signing, entitlements, hardened runtime, notarization, stapling, and Gatekeeper launch on a clean machine. For Windows verify the configured code-signing identity, timestamping, installer metadata, and SmartScreen-relevant artifact. Check updater endpoint/channel, public key/signature, version ordering, delta/full artifact availability, and failure behavior. Never put signing or updater private keys in the repository or logs.
+
+## Artifact and local recovery verification
+
+Build each intended target in release mode, inspect artifact names/checksums,
+install without the development checkout, and smoke startup, IPC commands,
+filesystem/network capabilities, deep links, restart, upgrade, and failed-update
+recovery locally. Notarization, updater publication, and release-channel
+verification require explicit execution intent. Keep previous signed artifacts
+and define whether recovery means reinstalling an older version, disabling a
+channel, or shipping a forward fix; already-updated clients and incompatible
+local data can limit rollback.
+
+## Wrong turns and caveats
+
+Do not grant all capabilities, use absolute developer paths, or call packaging/upload success a release. WebView/WebView2/WebKit, Rust/Tauri APIs, target architectures, OS signing rules, and updater schemas are version-sensitive; verify the current toolchain's supported targets.
+
+## Verification
+
+Run frontend tests, `cargo test`, the configured release bundle command,
+signature verification, and clean-machine install/update smoke for every
+affected platform. Run notarization or external updater verification only when
+explicitly requested.

package/skills/showdar-ship/stacks/web.md

@@ -0,0 +1,35 @@
+# Web/static web delivery verification
+
+Use this as a local readiness checklist by default. Do not publish the artifact
+or change hosting/CDN configuration unless the request explicitly asks for that
+execution.
+
+## Choose the delivery model
+
+Identify whether the artifact is static HTML/assets, a Node server, or an edge runtime. A static export cannot read a new server environment variable after build and has no server health endpoint; a Node/edge deployment has startup, runtime API, and scaling constraints. Record framework version, build command, output directory, hosting target, public base path, and the exact artifact or commit being promoted. Use `stacks/nextjs.md` for Next-specific rendering/cache behavior.
+
+## Build and configuration
+
+Run the production build from a clean dependency install and inspect the output for source maps, routes, asset URLs, redirects, headers, and accidental secret values. Classify every environment variable as build-time public configuration or runtime private configuration. Verify base URL, trailing-slash, locale, image/font handling, CSP, and cache headers against the target CDN; a successful local preview does not prove the deployed path works.
+
+## Artifact and local smoke
+
+Inspect the immutable artifact and record its digest/version for handoff; do
+not publish it by default. Smoke a local production preview or equivalent:
+homepage, authenticated/critical route, 404/error path, assets,
+redirect/HTTPS behavior, and API origin if present. Check CDN invalidation or
+cache freshness only when the task explicitly concerns delivery execution. Use
+`references/release-readiness.md` for local evidence; use
+`references/post-deploy.md` only for explicit external verification.
+
+## Wrong turns and edge cases
+
+Do not call a static upload “healthy” because files exist, bake secrets into client bundles, or rely on a dev server to validate production routing. Watch for SPA fallback differences, stale service workers, immutable asset naming, edge-incompatible Node APIs, preview/prod environment drift, and rollback that requires restoring both HTML and referenced assets.
+
+## Verification
+
+Run the repository's test/typecheck/build commands, inspect the actual artifact,
+and smoke the local production preview from a clean browser/session. A
+deployed URL is not required for ordinary readiness. Record provider, DNS, CDN,
+analytics, and monitoring checks as external/unverified unless explicitly
+requested.

package/skills/showdar-test/SKILL.md

@@ -0,0 +1,164 @@
+---
+name: showdar-test
+description: Use when choosing or implementing automated tests for behavior, regressions, integration, E2E, or coverage.
+---
+
+# Showdar Test
+
+## Purpose
+
+- Match test level to the boundary/risk being proven.
+- Produce tests that fail for real regressions rather than implementation rearrangement.
+- Use unit, integration, component/widget, E2E, and regression tests deliberately.
+- Keep coverage fast and deterministic while preserving realistic contracts where they matter.
+- Read `references/test-smells.md` before expanding an already-fragile test suite.
+
+## When to use
+
+- Designing test strategy for a feature or migration.
+- Adding regression coverage for a confirmed bug.
+- Reviewing whether existing tests prove changed behavior.
+- Choosing between unit, integration, widget/component, and E2E levels.
+- Stabilizing flaky tests when the test itself obscures the invariant.
+
+## When not to use
+
+- Root cause is unknown; debug first so the regression test targets the real defect.
+- The user only wants code review without test implementation.
+- Do not create E2E coverage for every branch already proven cheaply at lower levels.
+- Do not redesign production architecture solely to make mocks easier.
+
+## Inputs and assumptions
+
+- Behavior/invariant to prove and the boundary where it can fail.
+- Existing test framework and project commands; detect with `scripts/detect-test-tools.mjs` when useful.
+- Existing fixtures/helpers should be reused when they improve clarity, not because they are available.
+- External systems should be real/ephemeral at the level where their semantics are under test.
+
+## Non-negotiable rules
+
+- A test must name the production behavior that would make it fail.
+- Prefer observable output/state/side effect over private implementation calls.
+- Avoid mocks unless the dependency is external, nondeterministic, expensive, or not the contract under test.
+- No arbitrary sleeps for async synchronization.
+- Regression tests must reproduce the defect before the fix when feasible.
+- Tests must be independently repeatable and not depend on execution order.
+- Keep test-only shortcuts out of production APIs.
+- Do not use snapshot-only assertions for critical behavior.
+
+## Workflow
+
+### Phase 1 — state the invariant
+- Write one sentence describing what must remain true from the user/system perspective.
+- Identify inputs, state, side effects, errors, and concurrency/time boundaries.
+
+### Phase 2 — choose the lowest effective level
+- Query `data/test-strategy.csv` for similar risk. Use indexed categories for unit, component, integration, contract, E2E, regression, property, snapshot, mocking, flaky, concurrency, and performance decisions.
+- Pure policy/parser -> unit.
+- Persistence/HTTP/service boundary -> integration.
+- UI state/interaction -> component/widget.
+- Critical cross-system user journey -> E2E.
+- Production defect -> lowest reliable regression level, plus higher smoke only when additional integration risk exists.
+
+### Phase 3 — design the test
+- Use realistic inputs and explicit setup.
+- Control clock/network/process only at the true nondeterministic boundary.
+- Assert behavior and important side effects/errors.
+- Include the smallest meaningful edge cases.
+
+### Phase 4 — red proof
+- Run the new regression/behavior test before production change when possible.
+- Confirm it fails for the intended missing behavior, not syntax/fixture error.
+
+### Phase 5 — green and refactor
+- Apply/verify implementation until the test passes.
+- Refactor test helpers only after behavior is proven.
+
+### Phase 6 — broaden verification
+- Run affected suite and static/build checks relevant to the boundary.
+- Check runtime and flake characteristics for integration/E2E tests.
+
+## Decision points
+
+- Can unit test fully prove external contract? If persistence/protocol semantics matter, use integration.
+- Does UI issue depend on navigation/native/keyboard? Component test may be insufficient; add targeted integration/E2E.
+- Is timing the bug? Use deterministic barriers/fake clock/event control, not sleep.
+- Is dependency behavior the risk? Do not mock it away.
+- Large matrix? Prefer table/property tests when it improves clarity and failure localization.
+
+## Stack detection
+
+- Vitest: read `stacks/vitest.md`.
+- Jest: read `stacks/jest.md`.
+- React Testing Library: read `stacks/react-testing-library.md`.
+- React Native testing: read `stacks/react-native-testing.md`.
+- Flutter: read `stacks/flutter-test.md`.
+- Flutter `integration_test`: read `stacks/integration-test.md`.
+- Playwright: read `stacks/playwright.md`.
+- Detox: read `stacks/detox.md`.
+- XCTest: read `stacks/xctest.md`.
+- Android testing: read `stacks/android-testing.md`.
+- Unsupported tools follow the same behavior-first rules and repository-specific commands.
+
+## Failure modes
+
+- Test asserts that a mock was called but never proves user/system behavior.
+- Flake hidden by retries or longer timeouts.
+- Huge fixture makes failure cause unclear.
+- E2E test duplicates dozens of unit branches and becomes slow/brittle.
+- Snapshot changes are accepted without understanding behavior difference.
+- Regression test passes before the fix because it never reproduces the defect.
+- Test relies on private method/implementation structure.
+
+## Stop conditions
+
+- Stop when the requested outcome is outside this skill and hand off to the more appropriate workflow.
+- Stop before destructive, irreversible, production, credential, publishing, or deployment actions unless the user explicitly approved them.
+- Stop when required evidence is unavailable and proceeding would require guessing about behavior, ownership, or safety.
+- Stop when a repository instruction conflicts with this playbook; repository/user instructions win.
+- Stop when the targeted invariant is proven at the lowest effective level and affected broader verification is green.
+
+## Escalation conditions
+
+- Ask when the required external dependency cannot be reproduced locally and mocking it would remove the semantics under test.
+- Escalate flaky infrastructure separately from product regressions.
+- If the bug needs unavailable device/service behavior, define the exact manual/CI scenario instead of inventing a passing local test.
+- Split massive test matrices by invariant/boundary.
+
+## Verification
+
+- Confirm new test fails for the missing/buggy behavior when possible.
+- Confirm it passes after the correct implementation.
+- For regression proof, revert/disable the causal fix and ensure the test fails when practical.
+- Run affected suite and check zero unexpected warnings/errors.
+- Ensure no arbitrary timing sleeps or leaked resources remain.
+- Report levels/environments not run.
+
+## Output contract
+
+- **Invariant** being proven.
+- **Chosen test level** and reason.
+- **Cases** including important edge/error behavior.
+- **Test files/fixtures** changed.
+- **Red/green evidence** where applicable.
+- **Broader verification** commands/results.
+- **Known gaps** requiring device/CI/external environment.
+
+## Anti-patterns
+
+- “100% coverage” as a quality goal detached from behavior.
+- Mocking the database/network/parser when its actual semantics are the risk.
+- One giant E2E test for all product behavior.
+- Sleeping to wait for async work.
+- Snapshot-only regression proof.
+- Testing implementation details to make refactors painful.
+- Adding tests after code only to mirror current implementation without proving intent.
+
+## Example
+
+Bug: duplicate payment submission after rapid retry.
+- Invariant: same idempotency key cannot create two payment effects.
+- Preferred proof: integration test around request/service/persistence boundary.
+- Add UI/E2E only if client retry/navigation behavior also caused duplicate requests.
+- Verify regression test fails when idempotency enforcement is disabled.
+- See `examples/regression.md`.

package/skills/showdar-test/data/index.json

@@ -0,0 +1,14 @@
+{
+  "version": 1,
+  "skill": "showdar-test",
+  "datasets": [
+    {
+      "file": "data/test-strategy.csv",
+      "idField": "id",
+      "requiredColumns": ["id", "category", "preferred_level", "when", "reason", "example", "anti_pattern", "verification", "tags", "reference", "stack"],
+      "searchableFields": ["category", "preferred_level", "when", "reason", "example", "anti_pattern", "verification", "tags"],
+      "filterFields": ["category", "preferred_level", "stack"],
+      "reference": "references/unit.md"
+    }
+  ]
+}

package/skills/showdar-test/data/test-strategy.csv

@@ -0,0 +1,22 @@
+id,category,preferred_level,when,reason,example,anti_pattern,verification,tags,reference,stack
+unit-policy,unit,unit,pure deterministic policy,rule has no external semantics,fee calculation or reducer transition,mocking the function under test,assert inputs outputs and boundary cases,unit invariant,references/unit.md,*
+unit-parser,unit,unit,parser or serializer,format and error cases are local; enumerable boundary behavior,date token or config parser,snapshot only for parser output,malformed and representative fixtures,parser boundary,references/unit.md,*
+unit-property,property-based,property-based,large input domain or algebraic invariant,examples alone leave broad cases; find counterexamples automatically,parser round trip or idempotent normalization,random uncontrolled generator,seeded generators and minimal counterexample,property invariant,references/unit.md,vitest
+component-state,component,component,UI state and interaction,rendering plus local event ownership is the risk,form validation or selector rebuild,mock every child and assert calls,assert role text state and user action,component behavior,references/integration.md,react-testing-library
+component-accessibility,component,component,semantic UI contract,accessible name role focus and error are behavior,keyboard form flow or custom control,assert only class names,query by role or name and inspect focus,error semantics,references/integration.md,react-testing-library
+integration-http,integration,integration,HTTP route and service,validation auth mapping and persistence cross boundary,POST creates resource or returns typed error,mock service and assert handler call,real request plus response and durable effect,http contract,references/integration.md,node
+integration-database,integration,integration,persistence semantics,transaction constraints isolation or query behavior matters,unique constraint and rollback,in-memory object fake for DB semantics,ephemeral DB or repository integration test,database semantics,references/integration.md,node
+integration-cache,integration,integration,cache and source interaction,invalidation freshness and key ownership matter,mutation then query returns fresh result,clear cache in setup after every action,assert targeted and unrelated keys,cache consistency,references/integration.md,*
+contract-api,contract,contract,public API compatibility,independent producer and consumer must agree,OpenAPI or JSON response fixture,duplicated type assertion with no wire fixture,consumer/provider contract check,api compatibility,references/integration.md,node
+contract-native,contract,contract,native bridge payload,serialization and platform error mapping matter,MethodChannel or IPC command response,testing only platform mock shape,real bridge fixture or platform test,bridge contract,references/integration.md,ios
+e2e-critical,e2e,e2e,critical user journey,system integration and navigation risk remains,login then purchase then confirmation,all branches duplicated in E2E,deterministic seed and user-visible assertions,critical journey,references/e2e.md,playwright
+e2e-mobile,e2e,e2e,native mobile journey,keyboard permissions lifecycle or deep links cross layers,launch then permission then submit,arbitrary tap sleeps,Detox synchronization and stable semantics,native journey,references/e2e.md,detox
+regression-lowest,regression,regression,known production defect,reported invariant needs permanent proof,duplicate payment submission,write a broad E2E without reproducer,red before fix and green after,regression proof,references/regression.md,*
+regression-revert,regression,regression,causal fix must be guarded,fix could be removed in future,stale cache or race,assert test after implementation only,revert or disable fix and confirm red when practical,regression proof,references/regression.md,*
+mock-boundary,mocking,mocking,unavailable external service,dependency is not the semantics under test,clock provider or payment gateway boundary,mock database for transaction behavior,contract-shaped fake and one real integration path,mocking boundary,references/test-smells.md,*
+mock-restore,mocking,mocking,module or timer replacement,tests mutate global or module state,isolated clock or browser API,leaked mocks affect later tests,restore in teardown and run repeatably,test isolation,references/test-smells.md,jest
+flaky-order,flaky,flaky,order-dependent test,passes alone but fails in suite,shared mutable fixture or leaked server,parallel-safe test data,repeat in random or parallel order without retry,flaky order,references/test-smells.md,*
+flaky-timing,flaky,flaky,timing-dependent async,uses sleep or guessed timeout,eventual UI or queue completion,arbitrary sleep,wait on state barrier or event with bounded timeout,flaky timing,references/test-smells.md,playwright
+concurrency,concurrency,concurrency,race or duplicate effect,ordering and idempotency are the invariant,release two requests in controlled order,run sequentially only,barriers force both interleavings,concurrency invariant,references/integration.md,*
+performance,performance,performance,latency memory or frame budget,scale changes user experience,10000 row query or list scroll,assert duration on noisy shared host,benchmark stable path and regression threshold,performance budget,references/test-smells.md,*
+snapshot,snapshot,snapshot,stable structural output,large static structure is costly to assert manually,accessibility tree or generated config,snapshot is sole proof of behavior,review diff and pair with semantic assertions,snapshot review,references/test-smells.md,*

package/skills/showdar-test/examples/regression.md

@@ -0,0 +1,14 @@
+# Example regression choice
+
+Bug: rapid retry creates two payment records.
+
+Observed contract: one logical checkout has one idempotency key, and the server
+must return the original result for repeated requests even when requests overlap.
+
+Lowest reliable proof: an integration test sends two concurrent requests with the
+same key, asserts one persisted payment, and asserts both responses identify the
+same result. Include the database uniqueness constraint in the test environment.
+
+Avoid making tap timing the only proof; an E2E test is appropriate only if the
+client retry/navigation behavior is also part of the defect. Add the E2E smoke
+after the deterministic server regression is green.

package/skills/showdar-test/references/e2e.md

@@ -0,0 +1,3 @@
+# End-to-end tests
+
+Reserve E2E for critical user journeys and integration risk that lower levels cannot prove. Keep flows deterministic, seed state deliberately, use role/label semantics, and assert user-visible outcomes plus recovery. Cover one happy path and the highest-risk failure/permission/navigation path. Do not duplicate every unit case through E2E, hide flakes with retries, or use arbitrary sleeps.

package/skills/showdar-test/references/integration.md

@@ -0,0 +1,3 @@
+# Integration tests
+
+Use when correctness depends on boundaries working together: HTTP plus validation plus service, persistence adapter plus real database semantics, component plus state provider, cache invalidation, or native bridge wrapper. Prefer realistic or ephemeral dependencies for the contract under risk. Control time and concurrency with barriers, seed isolated data, assert response plus durable side effect, and clean resources at their owner. Do not mock away the boundary being proven.

package/skills/showdar-test/references/regression.md

@@ -0,0 +1,3 @@
+# Regression tests
+
+First reproduce the reported symptom with a focused test or executable scenario. Verify it fails for the original defect rather than a fixture error, passes with the causal fix, and ideally fails again when the fix is disabled or reverted. Encode the user/system invariant, including negative and ordering cases, not the implementation accident. Keep one higher-level smoke only when an additional boundary is part of the defect.

package/skills/showdar-test/references/test-smells.md

@@ -0,0 +1,3 @@
+# Test smells
+
+Warning signs: mocks that assert mocks, sleeps for timing, snapshot-only behavior proof, huge shared fixtures, tests coupled to private methods, duplicate E2E coverage, environment-dependent order, leaked resources, blanket retries, and tests that can pass while the user-visible bug remains. Replace sleeps with state/barrier/event synchronization; replace mock choreography with observable behavior; retain snapshots only as reviewed structural evidence paired with semantic assertions.

package/skills/showdar-test/references/unit.md

@@ -0,0 +1,3 @@
+# Unit tests
+
+Use for deterministic policy, parsing, calculations, reducers/state transitions, and small components/functions where dependencies are not the behavior under test. State the invariant first, use table/property cases for meaningful boundaries, and assert observable output/state or error—not internal call choreography. Keep fixtures local and deterministic. Move upward to integration when persistence, protocol, cache, lifecycle, or native semantics are the risk.

package/skills/showdar-test/scripts/detect-test-tools.mjs

@@ -0,0 +1,6 @@
+#!/usr/bin/env node
+import { access, readFile } from 'node:fs/promises'; import path from 'node:path';
+const root=path.resolve(process.argv[2]??process.cwd()); const out=[];
+try{const p=JSON.parse(await readFile(path.join(root,'package.json'),'utf8'));const d={...(p.dependencies??{}),...(p.devDependencies??{})};for(const [pkg,name] of [['vitest','vitest'],['jest','jest'],['@playwright/test','playwright'],['detox','detox']])if(d[pkg])out.push(name)}catch{}
+try{await access(path.join(root,'pubspec.yaml'));const s=await readFile(path.join(root,'pubspec.yaml'),'utf8');if(/flutter_test/.test(s))out.push('flutter-test');if(/integration_test/.test(s))out.push('flutter-integration-test')}catch{}
+console.log(JSON.stringify({root,tools:[...new Set(out)]},null,2));

package/skills/showdar-test/stacks/android-testing.md

@@ -0,0 +1,13 @@
+# Android testing
+
+## Choose the boundary
+
+Use JVM unit tests for pure Kotlin policy, repository/Room or service integration for real persistence/protocol semantics, and instrumented/UI tests for Android lifecycle, permissions, resources, navigation, process restoration, Compose/View rendering, and device APIs. Robolectric can speed framework-adjacent tests but is not proof of device behavior; use an emulator/device for native timing, ABI, or release configuration risk.
+
+## Deterministic lifecycle
+
+Control coroutine dispatchers, virtual time, lifecycle state, and test data explicitly. Assert semantics, visible UI/accessibility, navigation, durable state, and recovery after process death—not only mock calls. Use real Room/serialization/network boundaries when those are the contract; fake external services at a controlled server boundary instead of mocking the repository under test. Reset permissions, files, databases, and app state per test owner.
+
+## Failure modes and verification
+
+Watch for main-thread violations, leaked coroutines, idling-resource gaps, animation/Compose recomposition timing, API/OEM differences, manifest variant drift, and emulator state pollution. Run the focused Gradle test task, then the affected instrumentation/UI task on the supported API/ABI matrix; collect Logcat, screenshots, and test artifacts. Include a release-like/R8 configuration when that is part of the risk. See `references/unit.md`, `references/integration.md`, and `references/e2e.md`.

package/skills/showdar-test/stacks/detox.md

@@ -0,0 +1,13 @@
+# Detox
+
+## Boundary and suitability
+
+Use Detox for React Native journeys whose risk is native lifecycle, navigation, permissions, keyboard, deep links, real networking, or release-like packaging. Keep pure reducer/component behavior in Jest/React Native Testing Library; do not turn every JavaScript branch into a device journey.
+
+## Synchronization and setup
+
+Detox relies on app idling/resource synchronization. Drive the app to a known state with deterministic fixtures, launch arguments, deep links, or a test-only reset boundary. Use stable accessibility labels/test IDs only where semantic queries are unavailable or ambiguous. Wait for visible state/idle conditions and explicit native events; never add `sleep` to mask an unsatisfied synchronization contract. Control permissions, animations, network, and clock at the actual nondeterministic boundary.
+
+## Failure modes and verification
+
+Watch for infinite timers, animations, background tasks, image/network requests, native modules, and dev-server dependencies that keep the app busy or make it look idle too soon. Run the same debug/release-like build and architecture relevant to the issue, capture device logs/artifacts, and distinguish app crash from Detox synchronization failure. Keep failed screenshots/logs and rerun the focused journey before the full device suite; use retries only as diagnostic evidence, never as flake removal. See `references/e2e.md` and `references/test-smells.md`.

package/skills/showdar-test/stacks/flutter-test.md

@@ -0,0 +1,13 @@
+# Flutter test
+
+## Choose the boundary
+
+Use pure Dart tests for deterministic policy/parsing, widget tests for build/layout/interaction and provider/Bloc/Cubit state, and `integration_test` for real platform channels, plugins, navigation, permissions, and device lifecycle. Do not use a widget test to claim native integration works.
+
+## Synchronization and doubles
+
+Pump only the frames required by the invariant: `pump`, `pumpAndSettle`, or an explicit frame/event barrier. `pumpAndSettle` can hang or hide an animation/timer leak, so use a bounded explicit pump when the app intentionally remains busy. Control clocks and async work deterministically; inject repositories/services rather than mocking the widget tree. Assert semantics, visible state, error/recovery, and important side effects rather than private widget fields.
+
+## Failure modes and verification
+
+Watch for `BuildContext` used after disposal, provider scope that differs from production, unconstrained `pumpAndSettle`, golden tests that vary by font/renderer, leaked timers/streams, and platform calls replaced by mocks in a test that claims plugin behavior. Run `flutter test` for focused unit/widget cases and the repository's analyzer; use profile/release-like integration coverage for performance or native risk. Read `references/unit.md`, `references/integration.md`, and `references/test-smells.md`.

package/skills/showdar-test/stacks/integration-test.md

@@ -0,0 +1,13 @@
+# Flutter integration_test
+
+## Boundary and suitability
+
+Use Flutter `integration_test` for a real app process on a simulator, emulator, or device when correctness depends on platform plugins, channels, navigation, permissions, persistence, lifecycle, or rendering beyond widget tests. Keep pure Dart and widget state at lower levels so device tests remain a small risk-focused set.
+
+## Deterministic setup
+
+Seed isolated accounts/files/databases, launch with explicit test configuration, and reset state at the owner boundary. Use real request/repository/cache/bridge semantics when they are under test; fake only external services whose behavior is not the invariant. Synchronize on app state, frame completion, or an explicit event—not arbitrary sleeps—and control network/clock only when that boundary is the source of nondeterminism. Assert visible outcome plus durable side effect or rollback.
+
+## Failure modes and verification
+
+Watch for permissions left from a previous run, process death/background state, animations and pending timers, device locale/timezone, flaky network fixtures, leaked ports/files, and tests that pass on one platform because a plugin has different native behavior. Run `flutter test integration_test`, capture device logs/screenshots, and repeat failed cases on the supported device/API matrix. Report simulator-only or unavailable physical-device coverage. See `references/integration.md`, `references/e2e.md`, and `references/test-smells.md`.

package/skills/showdar-test/stacks/jest.md

@@ -0,0 +1,13 @@
+# Jest
+
+## Choose the boundary
+
+Use Jest for unit/module tests and framework integrations already supported by the repository's preset. Select `node`, `jsdom`, or the React Native preset deliberately; the environment changes globals, timers, module resolution, and native shims. Use integration tests for real persistence/HTTP/cache behavior and Detox or another E2E tool for native lifecycle, permissions, and device rendering.
+
+## Doubles and lifecycle
+
+Avoid webs of `jest.mock`; mock only external or nondeterministic boundaries and keep one real path for the contract under test. Reset/restore spies, mocks, fake timers, module registry, and global state in the owning teardown. Await user/data promises and use `act`/library async helpers for React updates. In React Native assert visible behavior and navigation/state effects, not instance methods or private component fields.
+
+## Failure modes and verification
+
+Watch for hoisted module mocks, stale singleton modules, fake timers that leave promises pending, `jsdom` behavior that differs from native, and tests that depend on file/order or worker state. Do not fix flakes with retries or a larger timeout before finding the leaked resource or missing barrier. Run the focused test, affected Jest project/preset, then the normal parallel suite; rerun the failed file in band when diagnosing isolation, not as the final proof. See `references/unit.md`, `references/integration.md`, and `references/test-smells.md`.

package/skills/showdar-test/stacks/playwright.md

@@ -0,0 +1,13 @@
+# Playwright
+
+## Boundary and suitability
+
+Use Playwright for critical browser journeys, cross-page/session behavior, real routing, browser APIs, and integration risk that lower-level tests cannot prove. Keep business-rule matrices in unit/component tests. Choose the target browsers/projects intentionally and record whether the risk is Chromium-only, cross-browser, mobile viewport, or server/runtime behavior.
+
+## Deterministic flow
+
+Seed isolated data and authenticate through a supported fixture/API boundary rather than clicking a long setup path in every test. Prefer role/label/test-id locators with stable semantics, user-visible assertions, and explicit `expect` retries. Use `waitForResponse`/network assertions only when the protocol is the contract; otherwise wait for the rendered state. Capture trace/video/screenshot on failure and isolate accounts, files, and storage per worker.
+
+## Failure modes and verification
+
+Avoid arbitrary sleeps, CSS selectors tied to styling, shared mutable users, blanket retries, and tests that pass against mocked responses while the real app wiring is broken. Watch for service-worker/cache pollution, missing web-server readiness, timezone/locale drift, popup/download cleanup, and parallel port collisions. Run the focused project with its normal web server, then the affected browser matrix; use trace evidence to classify product failure versus test/environment flake. See `references/e2e.md` and `references/test-smells.md`.

package/skills/showdar-test/stacks/react-native-testing.md

@@ -0,0 +1,17 @@
+# React Native testing
+
+## Choose the boundary
+
+Use React Native Testing Library/Jest for JavaScript behavior, rendered semantics, navigation state, and provider integration. Use Detox for native lifecycle, permissions, deep links, keyboard, real layout, native modules, and release-like packaging. A component test cannot prove Hermes, JSI/TurboModule, Fabric, Android/iOS configuration, or process-death behavior.
+
+## Rendering and async
+
+Render through the smallest realistic provider/navigation boundary and query by role, label, text, or test ID only when semantics are unavailable. Use `act`, `findBy*`, and explicit event/state barriers for updates; do not sleep or call private component methods. Wait for navigation focus/blur, async data, and animations through the library/native synchronization that represents the contract. Test loading, error, cancellation, stale-response, unmount, and retry paths when lifecycle is involved.
+
+## Doubles and native edges
+
+Mock only external services or native APIs whose semantics are outside the current test, and keep a real integration path for caches, serializers, and native bridge wrappers. Watch for fake timers blocking promises, Reanimated/gesture mocks hiding UI-thread behavior, Metro transform differences, leaked subscriptions, and platform-specific accessibility/permission behavior. Keep fixtures deterministic and reset storage/query caches per test.
+
+## Verification
+
+Run the focused Jest/RN Testing Library test, affected JS suite, and Detox journey for native risk. Repeat with the repository's normal Metro/Hermes configuration and capture device logs for native failures; report platform/architecture coverage that was not run. See `references/integration.md`, `references/e2e.md`, and `references/test-smells.md`.

package/skills/showdar-test/stacks/react-testing-library.md

@@ -0,0 +1,13 @@
+# React Testing Library
+
+## Boundary and setup
+
+Use React Testing Library for component behavior, accessibility, state transitions, and provider integration that can run in a deterministic DOM environment. Render through the smallest realistic provider boundary: include router/query/auth providers when their behavior is part of the invariant, but do not mount the entire application for every unit case. Use `screen` queries by role, label, or visible text and drive user events, not component instances.
+
+## Async and assertions
+
+Await user interactions and use `findBy*`/`waitFor` for observable state transitions. Assert loading, success, error, focus, accessible name, navigation, and important side effects; also assert that stale/aborted data does not overwrite current UI when that is the risk. Mock only network or external services when their semantics are outside the test, and keep a real cache/data-provider integration path. Do not use arbitrary sleeps or snapshots as the only behavior proof.
+
+## Failure modes and verification
+
+Watch for missing `act`, over-broad providers, leaked query caches, ambiguous queries, fake timers that block transitions, and tests that pass because a mock bypassed validation/cache behavior. Use a deterministic server/fixture boundary, clear state per test, and run the focused component test followed by the affected suite. Read `references/integration.md`, `references/e2e.md`, and `references/test-smells.md` when deciding whether the browser boundary belongs elsewhere.

package/skills/showdar-test/stacks/vitest.md

@@ -0,0 +1,13 @@
+# Vitest
+
+## Choose the boundary
+
+Use Vitest for fast deterministic unit tests, pure utilities, and module-level integration when the Vite/ESM transform is part of the contract. Move to a browser/component or E2E tool when DOM layout, real navigation, browser APIs, or cross-process behavior is the risk. Keep one test focused on the invariant rather than mirroring every implementation branch.
+
+## Doubles and async
+
+Prefer real modules and in-memory deterministic inputs. Mock only external, nondeterministic, expensive, or unavailable boundaries; do not mock the parser, cache, or adapter whose semantics the test claims to prove. Use `await` on the real promise, fake timers only when time is the boundary, and flush the specific event/barrier rather than sleeping. Reset modules/globals/timers in teardown so environment-dependent imports do not leak across tests.
+
+## Failure modes and verification
+
+Watch for ESM/CJS transform differences, shared singleton state, tests that pass in isolation but fail in parallel, unhandled promise rejections, and fake timers that prevent promise/microtask progress. Run the focused file first, then the affected project command; repeat with the repository's normal worker/concurrency setting when isolation or flake is suspected. Read `references/unit.md`, `references/integration.md`, and `references/test-smells.md` for boundary decisions.

package/skills/showdar-test/stacks/xctest.md

@@ -0,0 +1,13 @@
+# XCTest
+
+## Choose the boundary
+
+Use XCTest unit tests for pure Swift policy and async transformations, target/integration tests for persistence, networking, dependency injection, and native framework boundaries, and XCUITest for critical user journeys, permissions, deep links, and lifecycle. Keep UI tests small; they are not a substitute for deterministic model tests.
+
+## Async and platform setup
+
+Use structured concurrency, async test methods, expectations, or notification/predicate waits tied to a real event. Do not sleep to wait for a network, animation, or actor. Assert user-visible/accessibility outcomes and durable effects, not private view hierarchy details. Select the affected scheme/target, deployment target, simulator/device, locale, and permissions explicitly; reset keychain/files/database state at the owner boundary.
+
+## Failure modes and verification
+
+Watch for expectations fulfilled twice, main-actor violations, unstructured tasks outliving the test, shared simulator state, animation timing, network dependence, and tests that pass on simulator but fail with device entitlements or hardware. Run the focused XCTest/XCUITest scheme, then the normal test plan; collect diagnostics/screenshots and record simulator/device, OS, and signing limitations. Read `references/integration.md`, `references/e2e.md`, and `references/test-smells.md`.