showdar-skills 0.2.0

package/skills/showdar-upgrade/data/compatibility-checklist.csv

@@ -0,0 +1,24 @@
+id,category,surface,inspect,common_breakage,mitigation,verification,rollback,tags,reference,stack
+runtime-node,runtime,Node runtime,engine range; native addons; ESM/CJS; OpenSSL,unsupported syntax or binary ABI,match supported runtime and rebuild native modules,version command plus clean install and tests,restore runtime and lockfile,runtime upgrade,references/compatibility.md,node
+runtime-dart,runtime,Dart and Flutter SDK,sdk constraints; analyzer; channel,language or framework API mismatch,choose supported SDK pair before package edits,flutter analyze and test,restore SDK constraint and lockfile,flutter sdk,references/compatibility.md,dart
+runtime-swift,runtime,Swift and Xcode,Swift language mode; Xcode; deployment target,compiler or SDK API mismatch,stage compiler and source migration,build and test affected schemes,restore Xcode and project settings,swift toolchain,references/compatibility.md,swift
+runtime-kotlin,runtime,Kotlin and JDK,Kotlin plugin; JDK; Gradle; language level,compile plugin or bytecode mismatch,upgrade compatible toolchain tuple,release assemble and tests,restore Gradle and plugin versions,kotlin toolchain,references/compatibility.md,kotlin
+dependency-direct,dependencies,direct dependency,manifest range; import usage; peer range,install resolves but runtime API changed,read release notes and search usage,install lock resolution plus tests,restore manifest and lockfile,dependency usage,references/dependency-resolution.md,*
+dependency-peer,dependencies,peer dependency,peerDependencies and package manager resolver,duplicate framework or incompatible peer,upgrade owning framework and package together only when matrix supports it,clean install and peer report,restore prior compatible tuple,peer dependency,references/dependency-resolution.md,package-manager
+dependency-transitive,dependencies,transitive dependency,package tree; duplicate versions; overrides,security or behavior differs through nested package,identify owner and use narrow override only with evidence,lockfile diff and affected tests,remove override and restore lockfile,transitive graph,references/dependency-resolution.md,package-manager
+lockfile-integrity,lockfile,lockfile,lock format; importer or package sections; integrity metadata,unreviewable churn or nonreproducible install,upgrade with owning package manager and inspect diff,clean install from lockfile,restore previous lockfile,lockfile,references/dependency-resolution.md,package-manager
+framework-react,framework,React migration,removed lifecycle or API; JSX types; compiler behavior,source compile or effect semantics change,search deprecated usage and migrate by invariant,typecheck plus component tests,restore React and types lockfile,react migration,references/breaking-changes.md,react
+framework-next,framework,Next.js migration,Node minimum; routing; server/client; cache; config,build or rendering/cache behavior changes,migrate config and route boundaries separately,production build plus route smoke,restore framework config and lockfile,next migration,references/breaking-changes.md,nextjs
+framework-rn,framework,React Native migration,React pairing; Metro/Babel; Hermes; architecture; native template,native build or runtime module mismatch,compare template and migrate native files selectively,Android release build and iOS archive where available,restore source native and lockfile,rn migration,references/breaking-changes.md,react-native
+framework-expo,framework,Expo migration,SDK and React Native pairing; config plugins; native projects,prebuild or runtime module incompatibility,follow supported SDK pair and inspect generated diff,expo diagnostics and platform builds,restore SDK config and generated ownership,expo migration,references/breaking-changes.md,expo
+framework-flutter,framework,Flutter framework migration,Dart SDK; deprecated widgets; plugin platform support,analyzer errors or layout/runtime changes,migrate deprecated APIs and pin plugins,analyze test and release builds,restore pubspec and generated files,flutter migration,references/breaking-changes.md,flutter
+native-ios,native,CocoaPods and SPM,Podfile lock; Package.swift; deployment target; signing,link failure or missing capability,upgrade native dependency with minimum OS matrix,archive or scheme build and dependency resolution,restore Podfile.lock and SPM pins,native ios,references/compatibility.md,cocoapods
+native-android,native,Android Gradle stack,Gradle; AGP; JDK; compile target min SDK namespace,task resource or signing failure,upgrade supported tuple before app code,release bundle and mapping artifact,restore Gradle files and pins,android gradle,references/compatibility.md,gradle
+native-tauri,native,Tauri and Rust,Rust toolchain; Tauri crates; frontend API; permissions,compile or capability policy failure,follow crate/API migration and review capabilities,release bundle plus clean install smoke,restore Cargo lock and config,tauri rust,references/breaking-changes.md,tauri
+codegen,generated,code generation,source schema; generator version; generated ownership,generated API drift or stale artifacts,regenerate from source and inspect only owned diff,clean regeneration and compile,restore generated output and generator,codegen,references/migration-strategy.md,*
+codemod,source migration,codemod output,matched files; skipped patterns; formatting,partial automated migration,review every changed callsite and keep codemod log,search old API plus tests,restore source checkpoint,codemod,references/migration-strategy.md,*
+database-schema,data migration,migration compatibility,old app readers; new schema; rollback reader,old app cannot read new schema or rollback loses data,expand migrate contract with compatibility window,old and new fixtures plus migration dry run,restore app before contract and use backup,db migration,references/rollback.md,node
+minimum-platform,platform,minimum OS or SDK,iOS deployment; Android min target; browser runtime support,users excluded or build policy changes,make support change explicit product decision,build matrix and supported-device check,restore minimum and release config,minimum platform,references/compatibility.md,*
+staged-upgrade,rollout,staged upgrade,intermediate compatibility and rollout gates,large jump hides causal failure,split runtime framework native and source steps,verify each checkpoint before next,stop at last proven checkpoint,staged migration,references/migration-strategy.md,*
+rollback-lock,rollback,rollback boundary,previous manifest lockfile artifact and schema compatibility,rollback command cannot reproduce prior build,preserve artifact and document irreversible steps,build from restored state,restore previous version and compatible config,rollback,references/rollback.md,*
+security-patch,security,security patch,advisory; affected range; runtime exposure,patch absent or forced incompatible version,choose supported patched version and test narrow path,dependency audit plus regression suite,backport prior safe version if patch path fails,security update,references/breaking-changes.md,*

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

@@ -0,0 +1,14 @@
+{
+  "version": 1,
+  "skill": "showdar-upgrade",
+  "datasets": [
+    {
+      "file": "data/compatibility-checklist.csv",
+      "idField": "id",
+      "requiredColumns": ["id", "category", "surface", "inspect", "common_breakage", "mitigation", "verification", "rollback", "tags", "reference", "stack"],
+      "searchableFields": ["category", "surface", "inspect", "common_breakage", "mitigation", "verification", "rollback", "tags"],
+      "filterFields": ["category", "stack"],
+      "reference": "references/compatibility.md"
+    }
+  ]
+}

package/skills/showdar-upgrade/examples/upgrade-report.md

@@ -0,0 +1,18 @@
+# Example upgrade report
+
+Target: React Native `0.74` -> `0.76` with the repository's pinned Node and
+Android/iOS toolchains retained until compatibility is proven.
+
+Inventory: direct and peer dependencies, lockfile, Metro/Babel config, Hermes,
+native Podfile/Gradle plugins, minimum OS versions, CI images, and generated code.
+
+Compatibility findings: the framework upgrade changes the native template and
+may change peer ranges; the repository must prove every native module before
+enabling the new architecture. Do not infer compatibility from install success.
+
+Migration order: update direct constraints, resolve lockfile, apply codemods,
+regenerate native/codegen artifacts, run JS tests, then build and test iOS and
+Android. Keep the old build available and gate risky runtime behavior.
+
+Report each command by platform, mark TestFlight/store processing as unverified
+when it was not observed, and define the first safe rollback boundary.

package/skills/showdar-upgrade/references/breaking-changes.md

@@ -0,0 +1,3 @@
+# Breaking changes
+
+Read official migration and release notes for every crossed boundary that can alter API or tooling. Search the repository for removed, deprecated, renamed APIs, config keys, and behavior assumptions before changing versions. Separate source migration from generated, native, build, and deployment migration. Record each changed usage, required edit, and proof; do not infer that a successful install means the migration is complete.

package/skills/showdar-upgrade/references/compatibility.md

@@ -0,0 +1,3 @@
+# Compatibility analysis
+
+Build a matrix across runtime/framework, language/toolchain, native platform minimums, peer dependencies, build plugins, generated/codegen versions, and deployment environment. Record current, target, supported range, evidence source, and verification. Treat undocumented combinations as risk, not automatic incompatibility. A manifest constraint is weaker evidence than a resolved lockfile plus target build.

package/skills/showdar-upgrade/references/dependency-resolution.md

@@ -0,0 +1,3 @@
+# Dependency resolution
+
+Record current version, requested target, direct/peer/platform constraints, lockfile owner, package manager, and duplicated/transitive versions that affect runtime. Inspect why a resolver selected each critical version and whether overrides hide an incompatible peer. Preserve lockfile integrity and review churn. Do not assume latest is compatible with the current framework, toolchain, native target, or deployment runtime.

package/skills/showdar-upgrade/references/migration-strategy.md

@@ -0,0 +1,3 @@
+# Migration strategy
+
+Prefer one controlled version step when changes are coupled and testable; use staged upgrades when intermediate compatibility is required or blast radius is large. Define ordering across runtime, framework, native, source, codegen, and lockfile changes. Regenerate only owned artifacts, inspect template diffs, and verify each checkpoint before the next. Stop at the last proven checkpoint when a later layer fails.

package/skills/showdar-upgrade/references/rollback.md

@@ -0,0 +1,3 @@
+# Upgrade rollback
+
+Preserve previous manifest, lockfile, toolchain, artifact, and configuration where practical. Identify irreversible steps such as database migrations, Xcode/Gradle project transforms, codegen format changes, capability changes, or minimum OS changes. A rollback plan must name what can actually be restored, schema compatibility, and the trigger for stopping. “Reinstall” is not a rollback if it changes the resolved graph.

package/skills/showdar-upgrade/scripts/inspect-dependencies.mjs

@@ -0,0 +1,6 @@
+#!/usr/bin/env node
+import { access, readFile } from 'node:fs/promises'; import path from 'node:path'; import { detectStacks } from './lib/detect-stack.mjs';
+const root=path.resolve(process.argv[2]??process.cwd()); const out={root,stacks:await detectStacks(root)};
+try{const p=JSON.parse(await readFile(path.join(root,'package.json'),'utf8'));out.node={engines:p.engines??{},dependencies:p.dependencies??{},devDependencies:p.devDependencies??{},peerDependencies:p.peerDependencies??{}}}catch{}
+try{await access(path.join(root,'pubspec.yaml'));out.pubspec=(await readFile(path.join(root,'pubspec.yaml'),'utf8')).slice(0,20000)}catch{}
+console.log(JSON.stringify(out,null,2));

package/skills/showdar-upgrade/scripts/lib/detect-stack.mjs

@@ -0,0 +1,48 @@
+import { access, readdir, readFile } from 'node:fs/promises';
+import path from 'node:path';
+
+async function exists(target) { try { await access(target); return true; } catch { return false; } }
+
+export async function detectStacks(projectRoot) {
+  const found = new Set();
+  try {
+    const names = await readdir(projectRoot);
+    if (names.some((name) => ['package-lock.json', 'yarn.lock', 'pnpm-lock.yaml', 'bun.lockb'].includes(name))) found.add('package-manager');
+    if (names.some((name) => ['pnpm-workspace.yaml', 'lerna.json', 'turbo.json', 'nx.json'].includes(name))) found.add('workspace');
+    if (names.some((name) => name.endsWith('.xcodeproj') || name.endsWith('.xcworkspace'))) found.add('ios');
+  } catch { /* inaccessible repository is reported by the caller */ }
+  const packageFile = path.join(projectRoot, 'package.json');
+  if (await exists(packageFile)) {
+    try {
+      const pkg = JSON.parse(await readFile(packageFile, 'utf8'));
+      const deps = { ...(pkg.dependencies ?? {}), ...(pkg.devDependencies ?? {}), ...(pkg.peerDependencies ?? {}) };
+      if (pkg.packageManager) found.add('package-manager');
+      if (pkg.workspaces) found.add('workspace');
+      if (deps.next) found.add('nextjs');
+      if (deps.react) found.add('react');
+      if (deps['react-native']) found.add('react-native');
+      if (deps.vue) found.add('vue');
+      if (deps.svelte) found.add('svelte');
+      if (deps.tailwindcss) found.add('html-tailwind');
+      if (deps.fastify || deps['@fastify/core']) found.add('fastify');
+      if (deps['@nestjs/core']) found.add('nestjs');
+      if (deps['@tauri-apps/api']) found.add('tauri');
+      if (deps.electron) found.add('electron');
+      if (deps.expo || deps['expo-router']) found.add('expo');
+      found.add('node');
+    } catch { /* malformed package is reported by higher-level skills */ }
+  }
+  if (await exists(path.join(projectRoot, 'pubspec.yaml'))) {
+    const pubspec = await readFile(path.join(projectRoot, 'pubspec.yaml'), 'utf8');
+    if (/\bflutter\s*:/m.test(pubspec)) found.add('flutter');
+    found.add('dart');
+  }
+  if (await exists(path.join(projectRoot, 'ios'))) found.add('ios');
+  if (await exists(path.join(projectRoot, 'android'))) found.add('android');
+  if (await exists(path.join(projectRoot, 'Package.swift'))) { found.add('swift'); found.add('spm'); }
+  if (await exists(path.join(projectRoot, 'Cargo.toml'))) found.add('rust');
+  if (await exists(path.join(projectRoot, 'go.mod'))) found.add('go');
+  if (await exists(path.join(projectRoot, 'pyproject.toml')) || await exists(path.join(projectRoot, 'requirements.txt'))) found.add('python');
+  if (await exists(path.join(projectRoot, '.github', 'workflows')) || await exists(path.join(projectRoot, '.gitlab-ci.yml')) || await exists(path.join(projectRoot, 'Jenkinsfile'))) found.add('ci');
+  return [...found].sort();
+}

package/skills/showdar-upgrade/stacks/android.md

@@ -0,0 +1,15 @@
+# Android platform upgrades
+
+## Compatibility surface
+
+Record current/target JDK, Gradle, AGP, Kotlin, compile/target/min SDK, Android Studio, plugins, application ID, ABI, and release signing. Verify the supported tuple and whether min/target SDK or Play policy changes affect the product/device matrix. Inspect direct/peer/transitive resolution and preserve dependency locks where used.
+
+## Breaking and native surfaces
+
+Read AGP/SDK/Kotlin migration notes and search for namespace, manifest merger, exported-component, resource, permission, packaging, and deprecated API changes. Separate source changes from generated build files, version catalogs, manifests/resources, R8/ProGuard rules, native symbols, and signing configuration. Compare variant outputs because Debug can hide shrinker, resource, ABI, or release-only failures.
+
+## Rollback and verification
+
+Keep the previous Gradle/AGP/JDK tuple, lockfiles, mapping/symbol artifacts, signed bundle, and project diff. Rollback may be constrained by target-SDK policy, version codes, schema/data, or already-installed clients; define a forward-fix path. Read `references/compatibility.md`, `references/breaking-changes.md`, and `references/rollback.md`.
+
+Run clean dependency resolution, unit/instrumentation tests, debug and release bundle tasks, R8/mapping checks, and install/update smoke on affected API/ABI classes. Verify manifest/resources, permissions, deep links/push, process restoration, signing, and native crash symbolization.

package/skills/showdar-upgrade/stacks/cocoapods-spm.md

@@ -0,0 +1,17 @@
+# CocoaPods and Swift Package Manager upgrades
+
+## Inventory and ownership
+
+Record Xcode/Swift, deployment target, package/plugin versions, `Podfile.lock`, `Package.resolved`, local/path packages, target membership, build settings, binary frameworks, and generated workspace/project ownership. Check direct and transitive constraints, duplicate products, static versus dynamic linkage, and whether a package requires a newer OS or Swift language mode.
+
+## Controlled migration
+
+Upgrade one native dependency boundary at a time. Read release notes, search API/deprecation usage, resolve Pods/SPM without deleting lockfiles, and inspect the resolved graph and build settings for unexpected churn. Compare generated workspace/project diffs and preserve app-specific build phases, scripts, signing, capabilities, and resources. If a package changes module name, resources, linkage, or concurrency requirements, migrate source separately from resolution.
+
+## Failure modes and rollback
+
+Watch for CDN/cache masking, checksum failure, duplicate symbols, module-map/header changes, transitive minimum-OS increases, simulator/device architecture mismatch, and a package that builds in Debug but fails at archive. Keep previous lockfiles and a buildable archive; reinstalling dependencies is not rollback if it changes the graph. Read `references/dependency-resolution.md`, `references/compatibility.md`, and `references/rollback.md`.
+
+## Verification
+
+Run dependency resolution, focused tests, the affected scheme, and a release/archive build on the required simulator/device architecture. Inspect `Package.resolved`/`Podfile.lock`, link warnings, signing/entitlements, and runtime flows that cross the upgraded framework.

package/skills/showdar-upgrade/stacks/expo.md

@@ -0,0 +1,17 @@
+# Expo upgrades
+
+## Compatibility and ownership
+
+Record current/target Expo SDK, React Native, React, Node, platform SDKs, config plugins, and whether `ios/`/`android/` are generated, committed, or hand-owned. Check Expo's supported React/RN tuple and plugin peer ranges; do not infer compatibility from a successful JavaScript install. Preserve lockfiles and inspect prebuild/template ownership before changing native files.
+
+## Migration sequence
+
+Read the target Expo SDK notes, search deprecated config/API usage, and separate app-config edits, config-plugin behavior, prebuild output, source changes, and native project changes. Compare `expo prebuild` output to the current native diff before regenerating. For a managed project verify config at build time; for a bare/prebuild project verify the generated native files plus app-specific edits. Treat credentials, permissions, entitlements, schemes, and build profiles as release surfaces.
+
+## Wrong turns and rollback
+
+Do not run prebuild with overwrite behavior over hand-owned native changes, mix SDK and unrelated package upgrades, or use a compatibility flag without understanding its boundary. Keep the previous package/native state and build profile so a failed prebuild or plugin migration can be restored. Read `references/compatibility.md`, `references/migration-strategy.md`, and `references/rollback.md`.
+
+## Verification
+
+Run dependency resolution, Expo diagnostics, tests, a clean prebuild diff, Metro bundle, and release-like Android/iOS builds. Smoke permissions, notifications, deep links, updates, and native plugins on each affected platform; record whether testing used a development client, simulator, or store-like artifact.

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

@@ -0,0 +1,17 @@
+# Flutter upgrades
+
+## Compatibility surface
+
+Record Flutter channel/version, Dart SDK, package manager lockfile, Android Gradle/AGP/Kotlin/JDK, Xcode/Swift/CocoaPods, minimum iOS/Android versions, renderer, and plugin versions. Check each plugin's platform support and transitive constraints; Flutter SDK and Dart constraints must resolve together.
+
+## Breaking and generated work
+
+Read the target Flutter/Dart migration notes and search for deprecated APIs, changed nullability/lifecycle behavior, rendering assumptions, plugin registration, and platform-channel payloads. Separate Dart source migration from `android/`, `ios/`, CocoaPods/Gradle, and generated platform files. Compare generated files to their source-of-truth and do not overwrite app-specific runner settings blindly. Inspect analyzer/lint changes as migration signals, not merely cleanup.
+
+## Sequence and rollback
+
+Prefer Flutter/Dart first, then source API migration, plugin updates, and native toolchain changes when the supported matrix allows; split the steps if Gradle/Xcode failures would otherwise be ambiguous. Preserve `pubspec.lock`, native lockfiles, generated files, and the previous SDK/toolchain. Read `references/compatibility.md`, `references/breaking-changes.md`, and `references/rollback.md`.
+
+## Verification
+
+Run `flutter pub get`, `flutter analyze`, focused/unit/widget tests, integration tests, and profile/release Android/iOS builds. Smoke platform channels, permissions, background/foreground, deep links, images/fonts, and plugin behavior on each target; verify generated artifacts are reproducible from the migrated sources.

package/skills/showdar-upgrade/stacks/gradle.md

@@ -0,0 +1,13 @@
+# Gradle and Android upgrades
+
+## Upgrade the tuple
+
+Treat JDK, Gradle, AGP, Kotlin, compile/target SDK, Android Studio, and build plugins as a supported tuple. Record current/target versions and the package-manager/lock policy before changing one. Check plugin and convention-build peer constraints, repositories, dependency substitution, version catalogs, and duplicated transitive versions; do not use `--refresh-dependencies` or force flags as the final compatibility strategy.
+
+## Inspect generated and variant changes
+
+Read AGP/Gradle/Kotlin migration notes, then search for removed DSLs, namespace requirements, manifest/resource behavior, task wiring, configuration-cache assumptions, and deprecated APIs. Compare generated sources, manifests, resource merges, variant graphs, R8/ProGuard rules, signing, and native ABI outputs. Keep source, build-script, generated, and lockfile edits separable so the first failing task remains attributable.
+
+## Rollback and verification
+
+Preserve the previous wrapper, JDK/toolchain, lockfiles, mapping/native symbols, signed artifact, and project diff. Upgrade in the smallest diagnosable step, then run `./gradlew` dependency/report checks, unit tests, lint, debug APK, and release AAB tasks. Install the resulting artifacts with `adb`, exercise process/lifecycle/permission paths, and verify R8 mapping and signing for the exact release. Read `references/dependency-resolution.md`, `references/migration-strategy.md`, and `references/rollback.md`.

package/skills/showdar-upgrade/stacks/ios.md

@@ -0,0 +1,15 @@
+# iOS platform upgrades
+
+## Compatibility surface
+
+Record current/target Xcode, Swift, SDK, deployment target, architecture, CocoaPods/SPM versions, lockfiles, build settings, signing configuration, and every native framework/plugin. Check whether the target raises minimum OS requirements or changes device/simulator availability; that is a product/release decision, not a silent build fix.
+
+## Migration surfaces
+
+Read Xcode/Swift/platform release notes and search for deprecated APIs, concurrency/actor annotations, linker/build-setting changes, privacy manifests, permission usage descriptions, entitlements, capabilities, and SDK-required declarations. Separate source migration from Pods/SPM resolution, generated project files, signing/export configuration, and archive changes. Compare project/template diffs and preserve app-specific targets/settings.
+
+## Rollback and verification
+
+Keep the previous Xcode/toolchain, Podfile.lock/Package.resolved, project diff, archive, and dSYM. Rollback may be limited by minimum OS, local data, entitlements, or store distribution state; define the last buildable checkpoint. Read `references/compatibility.md`, `references/breaking-changes.md`, and `references/rollback.md`.
+
+Run focused XCTest, `xcodebuild` build/archive for affected schemes, signing/entitlement validation, and device/simulator smoke. Verify permissions, push/deep links, background behavior, native frameworks, symbol artifacts, and release configuration on the supported OS matrix.

package/skills/showdar-upgrade/stacks/nextjs.md

@@ -0,0 +1,17 @@
+# Next.js upgrades
+
+## Compatibility surface
+
+Record current and target Next.js, React/React DOM, Node, package manager, router, output mode, bundler, and deployment runtime. Check peer ranges and provider support as one tuple; a package install does not prove that App Router/Pages Router, Node, serverless, or edge behavior remains supported. Preserve the lockfile and inspect direct/transitive framework packages.
+
+## Breaking and generated surfaces
+
+Read the target release/migration notes, then search for changed routing/data APIs, server/client boundaries, middleware/runtime config, image/font handling, cache/revalidation semantics, server actions, and deprecated config keys. Separate source edits from codemods, generated route/build output, and deployment configuration. For App Router, audit client components and cache invalidation; for Pages Router, audit data functions and fallback/rewrites.
+
+## Migration and rollback
+
+Upgrade React pairing and Next.js in a controlled step when supported; split the change if the target requires a Node/toolchain change or a large template diff. Keep the previous manifest/lockfile and deployable artifact. Do not overwrite custom config or native/provider settings with a template blindly. Read `references/compatibility.md`, `references/breaking-changes.md`, and `references/migration-strategy.md`.
+
+## Verification
+
+Run install/lockfile validation, typecheck/lint/tests, `next build`, and `next start` or the provider-equivalent output. Smoke direct load/client navigation, auth, route handlers/server actions, static assets, cache invalidation, error paths, and the supported Node/edge deployment target.

package/skills/showdar-upgrade/stacks/node.md

@@ -0,0 +1,17 @@
+# Node upgrades
+
+## Compatibility surface
+
+Record current/target Node, package manager, lockfile owner, engine ranges, module mode, native addons, container base image, OS/architecture, and deployment runtime. Check direct/peer dependencies and duplicated transitive packages that depend on Node internals. Resolve the target graph without deleting the lockfile; explain overrides and native rebuilds.
+
+## Breaking surfaces
+
+Read Node release notes for ESM/CJS loader, built-in APIs, permissions, OpenSSL/TLS, Web APIs, diagnostics, and default error behavior. Search the repository for deprecated APIs, conditional exports, dynamic `require`, native addon ABI assumptions, test/build tool compatibility, and environment parsing. Separate source changes from generated lockfile, container, and process-manager changes.
+
+## Sequence and rollback
+
+Upgrade the runtime in a reproducible dev/container environment, then migrate source/tooling and native addons; do not combine unrelated dependency churn. Preserve the previous Node image, lockfile, artifact, and process configuration. A rollback must account for data written by the new runtime and any changed TLS/protocol behavior. Read `references/dependency-resolution.md`, `references/breaking-changes.md`, and `references/rollback.md`.
+
+## Verification
+
+Run clean install, typecheck/lint/tests, build, native-addon load checks, production-equivalent start, timeout/shutdown/error paths, and container smoke. Verify ESM/CJS entry points, OpenSSL/TLS connections, worker/process behavior, and runtime version parity in the deployed artifact.

package/skills/showdar-upgrade/stacks/react-native.md

@@ -0,0 +1,17 @@
+# React Native upgrades
+
+## Compatibility tuple
+
+Record current/target RN core, React, Node, Metro, Babel, Hermes, New Architecture setting, Android Gradle/AGP/Kotlin/JDK, CocoaPods/Xcode, deployment targets, and every native module peer range. Treat Expo SDK as an additional owner when present. Resolve the graph from the repository lockfiles and verify the target's supported tuple before editing versions.
+
+## Migration surfaces
+
+Read official RN release/template notes and search for removed APIs, changed event/layout semantics, Metro/Babel config, codegen, TurboModule/Fabric assumptions, and native project diffs. Inspect `android/` and `ios/` ownership before applying template changes; generated files, Podfile.lock, Gradle lockfiles, codegen output, and native module registration are separate migration surfaces. Check Hermes bytecode/source-map behavior and New Architecture compatibility for each native dependency.
+
+## Sequencing and rollback
+
+Upgrade one layer at a time when it keeps failures diagnosable: RN/React, JS toolchain, Android tuple, iOS tuple, then native modules and generated artifacts. Preserve manifests, lockfiles, native project diff, and a buildable previous commit. Do not disable Hermes/New Architecture or use force-resolution as the migration strategy. Read `references/compatibility.md`, `references/breaking-changes.md`, and `references/rollback.md`.
+
+## Verification
+
+Run clean dependency resolution, lint/typecheck/tests, Metro bundle, Android debug and release-like builds, iOS build/archive, and native-module smoke. Verify navigation, permissions, deep links, background/restore, Hermes/architecture mode, and both platform artifacts; report any platform not available.

package/skills/showdar-upgrade/stacks/react.md

@@ -0,0 +1,17 @@
+# React upgrades
+
+## Compatibility surface
+
+Record current/target React and React DOM, renderer/test packages, Node, bundler/framework, TypeScript types, peer dependencies, and lockfile. Keep React/React DOM/types paired according to the target release and check libraries that depend on renderer internals or legacy context. A successful resolver does not prove that concurrent rendering, server components, or the chosen framework remains supported.
+
+## Breaking and migration work
+
+Read the target React release/migration notes, then search for deprecated lifecycle APIs, string refs, legacy context, unsafe effects, `findDOMNode`, event assumptions, hydration behavior, and library-specific peer warnings. Separate codemods from manual state/effect changes and from framework/server-client migration. Test Strict Mode and production behavior when development-only double invocation or scheduling exposes a lifecycle defect.
+
+## Sequence and rollback
+
+Upgrade React pairing and types first when supported, apply codemods only to owned code, then update renderer/framework integrations and remove deprecated usage. Keep the previous manifest/lockfile and buildable artifact; do not silence peer warnings or force resolution without identifying the owner. Read `references/compatibility.md`, `references/breaking-changes.md`, and `references/rollback.md`.
+
+## Verification
+
+Run clean install, typecheck/lint, component/integration tests, production build, and browser smoke. Verify render/state/effect behavior, hydration if applicable, accessibility, error boundaries, Suspense/async paths, and the supported browser/runtime matrix.

package/skills/showdar-upgrade/stacks/tauri-rust.md

@@ -0,0 +1,15 @@
+# Tauri and Rust upgrades
+
+## Compatibility surface
+
+Record Tauri/core/plugin crate versions, Rust toolchain/target triples, frontend framework/bundler, WebView runtime, capability schema, bundle targets, signing, and updater format. Check crate feature flags, frontend API pairing, OS minimums, architecture-specific native dependencies, and lockfiles (`Cargo.lock` plus frontend lockfile). Treat generated config and platform bundles as separate ownership boundaries.
+
+## Migration surfaces
+
+Read Tauri/Rust migration notes and search command names, IPC payload types, plugin APIs, capability permissions, window/config keys, updater metadata, and frontend assumptions. Migrate Rust commands/permissions and frontend callers together, then compare generated/platform files rather than overwriting app-specific settings. Inspect `cargo tree` and target-specific feature resolution for hidden native changes.
+
+## Rollback and verification
+
+Preserve previous manifests, lockfiles, Rust toolchain, capability config, signed artifacts, updater keys/endpoints, and a clean install path. A capability/schema or local-data change may require a forward fix rather than downgrade. Read `references/compatibility.md`, `references/breaking-changes.md`, and `references/rollback.md`.
+
+Run `cargo test`, frontend tests, target release bundle, signature/notarization verification, and clean-machine install/update smoke. Verify IPC errors, filesystem/network permissions, startup, restart, updater failure/recovery, and every affected target triple.

package/src/adapters.js

@@ -0,0 +1,44 @@
+import path from 'node:path';
+import { homedir } from 'node:os';
+
+export const NATIVE_TARGETS = ['codex', 'opencode', 'claude', 'universal'];
+
+const ROOTS = {
+  codex: ['.agents', 'skills'],
+  opencode: ['.opencode', 'skills'],
+  claude: ['.claude', 'skills'],
+  universal: ['.agents', 'skills'],
+};
+
+const GLOBAL_ROOTS = {
+  codex: ({ homeRoot }) => path.join(homeRoot, '.agents', 'skills'),
+  opencode: ({ homeRoot }) => path.join(homeRoot, '.config', 'opencode', 'skills'),
+  claude: ({ homeRoot }) => path.join(homeRoot, '.claude', 'skills'),
+  universal: ({ homeRoot }) => path.join(homeRoot, '.agents', 'skills'),
+};
+
+export function resolveTargets(ai) {
+  if (ai === 'all') return [...NATIVE_TARGETS];
+  if (!NATIVE_TARGETS.includes(ai)) throw new Error(`Unknown AI target "${ai}". Expected codex, opencode, claude, universal, or all.`);
+  return [ai];
+}
+
+export function skillRootFor(target, projectRoot) {
+  const parts = ROOTS[target];
+  if (!parts) throw new Error(`Unknown AI target "${target}".`);
+  return path.join(projectRoot, ...parts);
+}
+
+export function globalSkillRootFor(target, { homeRoot = homedir() } = {}) {
+  const resolve = GLOBAL_ROOTS[target];
+  if (!resolve) throw new Error(`Unknown AI target "${target}".`);
+  return resolve({ homeRoot });
+}
+
+export function opencodeCommandRoot(projectRoot) {
+  return path.join(projectRoot, '.opencode', 'commands', 'showdar');
+}
+
+export function globalCommandRootFor({ homeRoot = homedir() } = {}) {
+  return path.join(homeRoot, '.config', 'opencode', 'commands', 'showdar');
+}

package/src/catalog.js

@@ -0,0 +1,57 @@
+export const SKILLS = [
+  { id: 'showdar-understand', domain: 'understand', description: 'Use when mapping an unfamiliar repository, architecture, dependencies, or impact before deciding what to change.' },
+  { id: 'showdar-plan', domain: 'plan', description: 'Use when agreed behavior needs a bounded implementation plan, change surface, task order, risks, or verification steps.' },
+  { id: 'showdar-design', domain: 'design', description: 'Use when product UI needs design direction, UX decisions, responsive layout, accessibility, or visual polish.' },
+  { id: 'showdar-build', domain: 'build', description: 'Use when implementing or refactoring an agreed application change within existing architecture and contracts.' },
+  { id: 'showdar-debug', domain: 'debug', description: 'Use when observed behavior fails through crashes, regressions, build failures, races, networking, memory, or performance issues.' },
+  { id: 'showdar-test', domain: 'test', description: 'Use when choosing or implementing automated tests for behavior, regressions, integration, E2E, or coverage.' },
+  { id: 'showdar-review', domain: 'review', description: 'Use when reviewing code or diffs for general correctness, architecture, performance, maintainability, or tests.' },
+  { id: 'showdar-upgrade', domain: 'upgrade', description: 'Use when upgrading dependencies, frameworks, runtimes, or native platforms and compatibility or rollback risk matters.' },
+  { id: 'showdar-ship', domain: 'ship', description: 'Use when checking whether a change, artifact, or release is ready for handoff or external release.' },
+  { id: 'showdar-recover', domain: 'recover', description: 'Use when interrupted or partial engineering work must be reconstructed from repository evidence before continuing.' },
+  { id: 'showdar-git', domain: 'git', description: 'Use when performing local Git inspection, staging, commits, branch integration, conflicts, cleanup, or explicitly requested remote Git actions.' },
+  { id: 'showdar-requirements', domain: 'requirements', description: 'Use when product or business input needs explicit behavior, rules, acceptance criteria, assumptions, or open decisions.' },
+  { id: 'showdar-quality', domain: 'quality', description: 'Use when planning QA/QC scenarios, risk coverage, regression scope, compatibility checks, or bug-report evidence.' },
+  { id: 'showdar-security', domain: 'security', description: 'Use when assessing threat models, attack surfaces, trust boundaries, auth/authz, secrets, exposure, or exploitability.' },
+  { id: 'showdar-ops', domain: 'ops', description: 'Use when inspecting or changing CI/CD, containers, environments, deployment, observability, rollback, or runtime operations.' },
+];
+
+export const AI_TARGETS = ['codex', 'opencode', 'claude', 'universal', 'all'];
+
+const ids = (...values) => values;
+
+export const PROFILES = {
+  minimal: ids('showdar-understand', 'showdar-plan', 'showdar-build', 'showdar-debug', 'showdar-test', 'showdar-review', 'showdar-recover', 'showdar-git'),
+  developer: ids('showdar-understand', 'showdar-plan', 'showdar-design', 'showdar-build', 'showdar-debug', 'showdar-test', 'showdar-review', 'showdar-upgrade', 'showdar-ship', 'showdar-recover', 'showdar-git', 'showdar-security'),
+  backend: ids('showdar-understand', 'showdar-plan', 'showdar-build', 'showdar-debug', 'showdar-test', 'showdar-review', 'showdar-upgrade', 'showdar-ship', 'showdar-recover', 'showdar-git', 'showdar-requirements', 'showdar-quality', 'showdar-security', 'showdar-ops'),
+  qa: ids('showdar-understand', 'showdar-requirements', 'showdar-quality', 'showdar-test', 'showdar-debug', 'showdar-review', 'showdar-ship', 'showdar-recover', 'showdar-git'),
+  product: ids('showdar-understand', 'showdar-requirements', 'showdar-plan', 'showdar-design', 'showdar-quality', 'showdar-review'),
+  full: SKILLS.map((skill) => skill.id),
+};
+
+export const PROFILE_ALIASES = {
+  mobile: 'developer',
+  web: 'developer',
+};
+
+function profileName(profile) {
+  return PROFILE_ALIASES[profile] ?? profile;
+}
+
+export function canonicalProfile(profile) {
+  const canonical = profileName(profile);
+  if (!PROFILES[canonical]) throw new Error(`Unknown profile "${profile}". Expected one of: ${[...Object.keys(PROFILES), ...Object.keys(PROFILE_ALIASES)].join(', ')}`);
+  return canonical;
+}
+
+export function isDeprecatedProfile(profile) {
+  return Object.hasOwn(PROFILE_ALIASES, profile);
+}
+
+export function resolveProfile(profile) {
+  return [...PROFILES[canonicalProfile(profile)]];
+}
+
+export function getSkill(id) {
+  return SKILLS.find((skill) => skill.id === id) ?? null;
+}