just-vibe 0.7.0

package/plugins/just-vibe/skills/vercel-runtime/SKILL.md

@@ -0,0 +1,61 @@
+---
+name: vercel-runtime
+description: "Investigate function errors, timeouts, and runtime differences Use for failures after a successful build; vercel-build-fix handles build-time errors."
+---
+
+# vercel-runtime
+
+Investigate function errors, timeouts, and runtime differences
+
+## Choose this workflow
+
+Use for failures after a successful build; vercel-build-fix handles build-time errors.
+
+Read [shared execution](../../references/execution.md) for context/mode/authority handling and [Vercel methods](../../references/packs/vercel.md) for tool selection and operational details. Resolve these paths from this skill file; all runtime assets ship inside the plugin.
+
+## Input and mode
+
+Use the complete request appended to this invocation, preserving all constraints and references. Default mode: **inspect**. Inspect; deployment, route/function, error window, and correlation IDs.
+
+exact team/project/environment and deployment/revision when applicable; read access to relevant configuration/logs. Verify installed CLI/API support and framework behavior during implementation. Never print environment values or infer promotion authorization from a preview request.
+
+Declared evidence requirements: `vercel.context`. Use actual host discovery or adequate supplied artifacts; unavailable evidence remains blocked/unknown.
+
+## Scope
+
+Runtime exceptions, timeouts, resource limits, and local/deployed behavior differences.
+
+None by default. Plan artifacts may be saved when requested.
+
+## Execute
+
+- Correlate logs with revision/runtime, inspect request and dependency boundaries, separate cold-start/resource/network causes, and propose a focused reproduction or fix.
+- Correlate deployment/request/time and inspect handler entry, environment presence, dependency waits and runtime-specific API support.
+- Use the matching bundled evidence collector when available; read its result and limitations rather than treating exit zero as readiness. Revalidate identity before a dependent action.
+
+## Read when relevant
+
+- Resolving check, deployment or migration identity: [Delivery evidence](../../references/scenarios/delivery-evidence.md).
+
+## Decision branches
+
+- **When timeout logs contain no downstream completion:** Treat the waiting boundary as evidence, not proof of which dependency caused the delay.
+
+## Deliver and verify
+
+- Supported diagnosis, relevant log references, and repair/verification steps.
+- Request/deployment identity, causal hypotheses, discriminating probe and recovery limits.
+
+Verify these observable conditions when applicable to the actual task; do not claim they were exercised from merely reading this file:
+
+- Build success is not mistaken for runtime health; a timeout has evidence identifying the waiting boundary.
+
+## Stop and recover
+
+- Do not trigger billable/high-volume traffic or expose request data. Apply changes only when remediation is requested.
+
+## Example requests
+
+- **Normal (inspect):** Investigate function timeouts for this deployment and time window.
+- **edge (inspect):** Diagnose a function that builds but times out awaiting a database connection.
+- **blocked (inspect):** Analyze redacted runtime logs without generating live traffic.

package/plugins/just-vibe/skills/verify/SKILL.md

@@ -0,0 +1,59 @@
+---
+name: verify
+description: "Run relevant checks and report supporting evidence Use to establish evidence for explicit completion criteria; test authors missing checks."
+---
+
+# verify
+
+Run relevant checks and report supporting evidence
+
+## Choose this workflow
+
+Use to establish evidence for explicit completion criteria; test authors missing checks.
+
+Read [shared execution](../../references/execution.md) for context/mode/authority handling and [General methods](../../references/packs/general.md) for tool selection and operational details. Resolve these paths from this skill file; all runtime assets ship inside the plugin.
+
+## Input and mode
+
+Use the complete request appended to this invocation, preserving all constraints and references. Default mode: **apply**. Apply because checks may create artifacts; target change and claimed success criteria. Inspect mode reads existing evidence only.
+
+Resolve the user brief and inspect the relevant project or supplied evidence. External capabilities are optional unless the selected action actually needs them.
+
+Declared evidence requirements: `project.read`. Use actual host discovery or adequate supplied artifacts; unavailable evidence remains blocked/unknown.
+
+## Scope
+
+Relevant tests, builds, type checks, and runtime validation; no automatic repairs.
+
+Only the requested local changes; external actions require their exact action and target in session authorization.
+
+## Execute
+
+1. Read the relevant package scripts and changed behavior before choosing checks. Identify scripts that install, deploy, seed shared databases or make external calls before running them.
+2. Execute the relevant bounded checks with the active host tool and capture actual exit code, revision, output summary and any generated artifacts. Use read-only existing evidence in inspect mode.
+3. Do not repair failures unless the user also requested repair. Keep failed, blocked and unrun checks separate from passes; identify pre-existing failures only with evidence.
+
+Task-specific method: Select checks from project scripts and changed behavior, inspect commands for side effects, run bounded checks, and associate results with the tested revision. Map every criterion to an existing check, inspected artifact or bounded interaction; inspect script side effects and record the revision and environment.
+
+## Decision branches
+
+- **When a required check is unavailable or fails before exercising behavior:** Mark that criterion unverified and report the prerequisite separately from product failure.
+
+## Deliver and verify
+
+- Check results, exit statuses, covered criteria, and blocked/unverified areas.
+- Criterion/check/result matrix with commands, exit statuses, revision and gaps.
+
+Verify these observable conditions when applicable to the actual task; do not claim they were exercised from merely reading this file:
+
+- A failing command produces a failed result; unavailable dependencies remain blocked rather than skipped into an overall pass.
+
+## Stop and recover
+
+- Do not run deployment scripts as verification. Separate pre-existing failures from introduced failures using evidence.
+
+## Example requests
+
+- **Normal (apply):** Verify this checkout change using the project checks; report blocked checks.
+- **edge (apply):** Verify a fix where unit tests pass but the browser build fails.
+- **blocked (inspect):** Review existing CI artifacts without running commands or treating stale results as current.

package/plugins/just-vibe/skills/vite-assets/SKILL.md

@@ -0,0 +1,57 @@
+---
+name: vite-assets
+description: "Fix asset paths, public files, base paths, and deployment paths Use for missing assets or wrong emitted URLs; vercel-routing handles platform rewrites."
+---
+
+# vite-assets
+
+Fix asset paths, public files, base paths, and deployment paths
+
+## Choose this workflow
+
+Use for missing assets or wrong emitted URLs; vercel-routing handles platform rewrites.
+
+Read [shared execution](../../references/execution.md) for context/mode/authority handling and [Vite methods](../../references/packs/vite.md) for tool selection and operational details. Resolve these paths from this skill file; all runtime assets ship inside the plugin.
+
+## Input and mode
+
+Use the complete request appended to this invocation, preserving all constraints and references. Default mode: **apply**. Apply; broken asset URLs, deployment base path, source assets, and target routes.
+
+project manifests, lockfile, Vite/framework/plugin versions, and existing build scripts. Verify current version-specific documentation when changing configuration. Apply-mode checks may generate build/cache artifacts; inspect mode uses existing evidence.
+
+Declared evidence requirements: `project.read`. Use actual host discovery or adequate supplied artifacts; unavailable evidence remains blocked/unknown.
+
+## Scope
+
+Imported/public assets, URL construction, and base-path handling; no asset redesign.
+
+Only the requested local changes; external actions require their exact action and target in session authorization.
+
+## Execute
+
+- Resolve the actual mode, root, base path and deployment routing. Trace each failing URL from an imported asset, public file, CSS reference or runtime string to emitted output; compare dev and production behavior.
+- Repair the owning URL construction using supported installed-version semantics. Keep case-sensitive paths, hashed output and assets consumed by lazy routes distinct; do not fix every route with an unconditional root-relative path.
+- Verify root navigation, direct nested navigation, configured subpath base and refresh in a production preview. Check response status and content type: a fallback HTML page with status 200 is still a broken image or module.
+
+## Decision branches
+
+- **When runtime concatenation prevents static asset discovery:** Use an explicit asset map or supported URL/import pattern appropriate to the installed version.
+
+## Deliver and verify
+
+- Asset-path patch and production-build/browser verification.
+- Source-to-output mapping and root/subpath/nested-route results.
+
+Verify these observable conditions when applicable to the actual task; do not claim they were exercised from merely reading this file:
+
+- Emitted asset URLs resolve under the requested base and nested routes, with correct content types and no reliance on navigation from the root.
+
+## Stop and recover
+
+- Do not hard-code a development origin or copy secret files into public output. Missing deployment evidence is stated separately.
+
+## Example requests
+
+- **Normal (apply):** Fix images that work locally but fail when hosted under a subpath.
+- **edge (apply):** Fix images that work in dev but fail under a deployed subdirectory.
+- **blocked (inspect):** Inspect source paths without deployment access; separate build evidence from live serving.

package/plugins/just-vibe/skills/vite-bundle/SKILL.md

@@ -0,0 +1,58 @@
+---
+name: vite-bundle
+description: "Analyze bundle composition and measured size reductions Use for bundle composition and size; vite-chunks focuses on loading boundaries."
+---
+
+# vite-bundle
+
+Analyze bundle composition and measured size reductions
+
+## Choose this workflow
+
+Use for bundle composition and size; vite-chunks focuses on loading boundaries.
+
+Read [shared execution](../../references/execution.md) for context/mode/authority handling and [Vite methods](../../references/packs/vite.md) for tool selection and operational details. Resolve these paths from this skill file; all runtime assets ship inside the plugin.
+
+## Input and mode
+
+Use the complete request appended to this invocation, preserving all constraints and references. Default mode: **inspect**. Inspect; saved build stats/artifacts and size/performance goal; generating a build selects authorized execution.
+
+project manifests, lockfile, Vite/framework/plugin versions, and existing build scripts. Verify current version-specific documentation when changing configuration. Apply-mode checks may generate build/cache artifacts; inspect mode uses existing evidence.
+
+Declared evidence requirements: `project.read`. Use actual host discovery or adequate supplied artifacts; unavailable evidence remains blocked/unknown.
+
+## Scope
+
+Bundle composition and measured reductions, not arbitrary dependency removal.
+
+None by default. Plan artifacts may be saved when requested.
+
+## Execute
+
+- Record the installed versions, command, mode, route and baseline artifact. Separate raw output, compressed size and actual transferred bytes; compare equivalent build and cache conditions.
+- Trace a large or duplicate module to imports and the user journey that loads it. Distinguish startup cost from total application cost and verify whether an existing lazy boundary is defeated by an eager import.
+- Choose a focused change based on the observed cost. Splitting a module can add a waterfall or alter side-effect order; avoid generic manual-chunk rules or removing dependencies solely because they are large.
+- Build and exercise affected entry/lazy routes, direct navigation and failure recovery. Report comparable before/after measurements plus functional checks; a smaller output file alone does not prove faster interaction.
+
+## Decision branches
+
+- **When a dependency is large but loaded only after an optional interaction:** Measure its contribution to that interaction rather than attributing it to initial load.
+
+## Deliver and verify
+
+- Size breakdown, cause, changes if authorized, and comparable before/after results.
+- Import path, size metric, loaded route and before/after build conditions.
+
+Verify these observable conditions when applicable to the actual task; do not claim they were exercised from merely reading this file:
+
+- Measurements share build/mode/version assumptions, and affected initial and lazy routes still load correctly. Raw bytes are not mislabeled as transfer size or user-perceived performance.
+
+## Stop and recover
+
+- Do not equate smaller bytes with faster UX without timing evidence. Missing stats limit numerical conclusions.
+
+## Example requests
+
+- **Normal (inspect):** Analyze the supplied production bundle statistics and prioritize size reductions.
+- **edge (inspect):** Reduce initial bytes without breaking a lazily loaded editor.
+- **blocked (inspect):** Review available bundle stats without installing an analyzer or inventing timing gains.

package/plugins/just-vibe/skills/vite-chunks/SKILL.md

@@ -0,0 +1,56 @@
+---
+name: vite-chunks
+description: "Investigate loading boundaries, duplicated modules, and chunks Use to change lazy-loading/cache boundaries; vite-bundle first identifies heavy contributors."
+---
+
+# vite-chunks
+
+Investigate loading boundaries, duplicated modules, and chunks
+
+## Choose this workflow
+
+Use to change lazy-loading/cache boundaries; vite-bundle first identifies heavy contributors.
+
+Read [shared execution](../../references/execution.md) for context/mode/authority handling and [Vite methods](../../references/packs/vite.md) for tool selection and operational details. Resolve these paths from this skill file; all runtime assets ship inside the plugin.
+
+## Input and mode
+
+Use the complete request appended to this invocation, preserving all constraints and references. Default mode: **inspect**. Inspect; route/loading behavior, build artifacts, and chunk configuration.
+
+project manifests, lockfile, Vite/framework/plugin versions, and existing build scripts. Verify current version-specific documentation when changing configuration. Apply-mode checks may generate build/cache artifacts; inspect mode uses existing evidence.
+
+Declared evidence requirements: `project.read`. Use actual host discovery or adequate supplied artifacts; unavailable evidence remains blocked/unknown.
+
+## Scope
+
+Dynamic imports, shared chunks, duplicate modules, and loading boundaries.
+
+None by default. Plan artifacts may be saved when requested.
+
+## Execute
+
+- Map entry/chunk relationships, inspect waterfalls and dependency duplication, evaluate cache/initial-load tradeoffs, and propose focused splitting changes.
+- Map dynamic imports and shared chunks to representative navigation waterfalls; examine duplication, circular dependencies and cache invalidation costs.
+
+## Decision branches
+
+- **When manual splitting changes execution order or creates a waterfall:** Verify module side effects and route transitions before accepting byte reductions.
+
+## Deliver and verify
+
+- Chunk graph explanation and optimization plan or authorized patch with loading evidence.
+- Chunk/dependency map, request waterfall and relevant navigation checks.
+
+Verify these observable conditions when applicable to the actual task; do not claim they were exercised from merely reading this file:
+
+- A split reduces the intended initial work; deep-link and lazy-load paths still resolve all required modules.
+
+## Stop and recover
+
+- Avoid arbitrary manual chunk rules without evidence. Report missing network traces rather than inventing loading improvements.
+
+## Example requests
+
+- **Normal (inspect):** Find duplicated dependencies and loading-boundary issues in these build artifacts.
+- **edge (inspect):** Split a heavy dashboard while preserving direct deep links and shared vendor initialization.
+- **blocked (inspect):** Plan chunks without network traces; report loading benefits as hypotheses.

package/plugins/just-vibe/skills/vite-config/SKILL.md

@@ -0,0 +1,56 @@
+---
+name: vite-config
+description: "Audit aliases, plugins, build options, and environment handling Use to inspect effective configuration; vite-hmr or vite-assets handles a known failure surface."
+---
+
+# vite-config
+
+Audit aliases, plugins, build options, and environment handling
+
+## Choose this workflow
+
+Use to inspect effective configuration; vite-hmr or vite-assets handles a known failure surface.
+
+Read [shared execution](../../references/execution.md) for context/mode/authority handling and [Vite methods](../../references/packs/vite.md) for tool selection and operational details. Resolve these paths from this skill file; all runtime assets ship inside the plugin.
+
+## Input and mode
+
+Use the complete request appended to this invocation, preserving all constraints and references. Default mode: **inspect**. Inspect; configuration files, intended behavior, and observed issue.
+
+project manifests, lockfile, Vite/framework/plugin versions, and existing build scripts. Verify current version-specific documentation when changing configuration. Apply-mode checks may generate build/cache artifacts; inspect mode uses existing evidence.
+
+Declared evidence requirements: `project.read`. Use actual host discovery or adequate supplied artifacts; unavailable evidence remains blocked/unknown.
+
+## Scope
+
+Aliases, plugins/order, build targets, server options, and environment handling.
+
+None by default. Plan artifacts may be saved when requested.
+
+## Execute
+
+- Read effective configuration sources and version compatibility, trace conflicting options, compare development/production behavior, and propose focused corrections.
+- Resolve command, mode, root, envDir, aliases and plugin order from the actual invoked script; compare TypeScript resolution with bundler resolution.
+
+## Decision branches
+
+- **When a config function branches on command or mode:** Assess each relevant branch statically before executing potentially side-effecting configuration.
+
+## Deliver and verify
+
+- Configuration findings, reasoning, and optional authorized patch.
+- Effective configuration by invocation and unsupported/conflicting settings.
+
+Verify these observable conditions when applicable to the actual task; do not claim they were exercised from merely reading this file:
+
+- A TypeScript-only alias missing at runtime is identified; a version-unsupported option is not recommended.
+
+## Stop and recover
+
+- Do not execute arbitrary config code during read-only inspection without considering its side effects. Missing build evidence remains unknown.
+
+## Example requests
+
+- **Normal (inspect):** Audit aliases and plugin order for the installed Vite version.
+- **edge (inspect):** Diagnose an alias that typechecks but fails in the production bundle.
+- **blocked (inspect):** Inspect config source with no build permission; do not execute arbitrary imports.

package/plugins/just-vibe/skills/vite-env/SKILL.md

@@ -0,0 +1,56 @@
+---
+name: vite-env
+description: "Check environment loading and exposure of server-only values Use for build mode, environment loading and client exposure; vercel-env checks deployment scope metadata."
+---
+
+# vite-env
+
+Check environment loading and exposure of server-only values
+
+## Choose this workflow
+
+Use for build mode, environment loading and client exposure; vercel-env checks deployment scope metadata.
+
+Read [shared execution](../../references/execution.md) for context/mode/authority handling and [Vite methods](../../references/packs/vite.md) for tool selection and operational details. Resolve these paths from this skill file; all runtime assets ship inside the plugin.
+
+## Input and mode
+
+Use the complete request appended to this invocation, preserving all constraints and references. Default mode: **inspect**. Inspect; build mode, expected variable names, environment files, and exposure policy.
+
+project manifests, lockfile, Vite/framework/plugin versions, and existing build scripts. Verify current version-specific documentation when changing configuration. Apply-mode checks may generate build/cache artifacts; inspect mode uses existing evidence.
+
+Declared evidence requirements: `project.read`. Use actual host discovery or adequate supplied artifacts; unavailable evidence remains blocked/unknown.
+
+## Scope
+
+Load precedence, prefixes, build-time replacement, and client/server separation.
+
+None by default. Plan artifacts may be saved when requested.
+
+## Execute
+
+- Inspect variable references and configuration names, trace which mode supplies them, inspect existing generated bundles for exposure when available, and recommend narrow corrections.
+- Trace import.meta.env usage and configured envPrefix, inspect mode-specific files by names only, and separate build mode from NODE_ENV.
+
+## Decision branches
+
+- **When a required secret is referenced by client code:** Move the privileged operation behind a server boundary instead of adding a client-exposed prefix.
+
+## Deliver and verify
+
+- Redacted environment map and exposure/missing-value findings.
+- Name/consumer/mode/exposure table and evidence from a controlled built artifact.
+
+Verify these observable conditions when applicable to the actual task; do not claim they were exercised from merely reading this file:
+
+- Server-only credentials are not moved into client-exposed prefixes; development and production modes resolve the intended public configuration.
+
+## Stop and recover
+
+- Never print secret values. Secret rotation is a separate authorized action; configuration edits follow an explicit repair request.
+
+## Example requests
+
+- **Normal (inspect):** Check whether server-only configuration is exposed in the client bundle.
+- **edge (inspect):** Diagnose a staging build made with a production NODE_ENV and a custom mode.
+- **blocked (inspect):** Inspect environment references without reading secret values or building output.

package/plugins/just-vibe/skills/vite-hmr/SKILL.md

@@ -0,0 +1,56 @@
+---
+name: vite-hmr
+description: "Diagnose broken, slow, or inconsistent hot-module updates Use for broken development updates; react-effects handles lifecycle bugs visible during refresh."
+---
+
+# vite-hmr
+
+Diagnose broken, slow, or inconsistent hot-module updates
+
+## Choose this workflow
+
+Use for broken development updates; react-effects handles lifecycle bugs visible during refresh.
+
+Read [shared execution](../../references/execution.md) for context/mode/authority handling and [Vite methods](../../references/packs/vite.md) for tool selection and operational details. Resolve these paths from this skill file; all runtime assets ship inside the plugin.
+
+## Input and mode
+
+Use the complete request appended to this invocation, preserving all constraints and references. Default mode: **inspect**. Inspect; affected file/component, development environment, and HMR logs or reproduction.
+
+project manifests, lockfile, Vite/framework/plugin versions, and existing build scripts. Verify current version-specific documentation when changing configuration. Apply-mode checks may generate build/cache artifacts; inspect mode uses existing evidence.
+
+Declared evidence requirements: `project.read`. Use actual host discovery or adequate supplied artifacts; unavailable evidence remains blocked/unknown.
+
+## Scope
+
+Watcher events, module invalidation, framework refresh, and proxy/network transport.
+
+None by default. Plan artifacts may be saved when requested.
+
+## Execute
+
+- Trace file change to browser update, inspect plugin boundaries and duplicate modules, distinguish full reload from hot replacement, and localize the failure.
+- Follow file watcher to module graph to HMR connection and framework boundary; distinguish transport loss from invalidation and deliberate full reload.
+
+## Decision branches
+
+- **When updates fail only through a proxy or container:** Inspect websocket origin/port and mounted-path watching before relaxing host/filesystem protections.
+
+## Deliver and verify
+
+- Diagnosis and focused fix proposal; apply and validate when requested.
+- Reproduction steps, failing HMR boundary and update/state-preservation checks.
+
+Verify these observable conditions when applicable to the actual task; do not claim they were exercised from merely reading this file:
+
+- A changed module updates correctly after remediation; unrelated state is preserved when the framework supports it.
+
+## Stop and recover
+
+- Running a dev server requires execution authorization. Do not disable host protections or broadly relax filesystem access as a default fix.
+
+## Example requests
+
+- **Normal (inspect):** Investigate why changes trigger full reloads and lose form state.
+- **edge (inspect):** Diagnose refresh failing behind a reverse proxy while direct localhost works.
+- **blocked (inspect):** Inspect HMR configuration without starting a dev server; identify needed browser evidence.

package/plugins/just-vibe/skills/vite-setup/SKILL.md

@@ -0,0 +1,56 @@
+---
+name: vite-setup
+description: "Configure Vite for the framework and project requirements Use to add or repair Vite project wiring; vite-upgrade changes an existing version."
+---
+
+# vite-setup
+
+Configure Vite for the framework and project requirements
+
+## Choose this workflow
+
+Use to add or repair Vite project wiring; vite-upgrade changes an existing version.
+
+Read [shared execution](../../references/execution.md) for context/mode/authority handling and [Vite methods](../../references/packs/vite.md) for tool selection and operational details. Resolve these paths from this skill file; all runtime assets ship inside the plugin.
+
+## Input and mode
+
+Use the complete request appended to this invocation, preserving all constraints and references. Default mode: **apply**. Apply; framework, language, project location, deployment shape, and dependency constraints.
+
+project manifests, lockfile, Vite/framework/plugin versions, and existing build scripts. Verify current version-specific documentation when changing configuration. Apply-mode checks may generate build/cache artifacts; inspect mode uses existing evidence.
+
+Declared evidence requirements: `project.read`. Use actual host discovery or adequate supplied artifacts; unavailable evidence remains blocked/unknown.
+
+## Scope
+
+Vite configuration and required scripts/integration; no app redesign or unrelated toolchain replacement.
+
+Only the requested local changes; external actions require their exact action and target in session authorization.
+
+## Execute
+
+- Inspect existing setup, choose compatible plugins, configure development/build/preview scripts, preserve existing source, and validate basic development and production paths.
+- Inspect package manager, workspace root, framework plugin and Node support; preserve existing entry files and establish dev/build/preview paths using project conventions.
+
+## Decision branches
+
+- **When an existing app already has a bundler or non-root deployment path:** Plan an explicit transition and base-path handling rather than copying a new template over it.
+
+## Deliver and verify
+
+- Working setup, dependency/config changes, usage, and check results.
+- Configuration/script changes and dev/production/subpath verification.
+
+Verify these observable conditions when applicable to the actual task; do not claim they were exercised from merely reading this file:
+
+- The existing app builds; deploying under the requested base path resolves assets correctly.
+
+## Stop and recover
+
+- Do not overwrite an existing project with a template. Respect no-new-dependency constraints and unsupported framework combinations.
+
+## Example requests
+
+- **Normal (apply):** Set up Vite for this existing React app without replacing source files.
+- **edge (apply):** Configure Vite in an existing React workspace served under /dashboard/.
+- **blocked (inspect):** Inspect setup requirements without installing dependencies or overwriting source.

package/plugins/just-vibe/skills/vite-upgrade/SKILL.md

@@ -0,0 +1,56 @@
+---
+name: vite-upgrade
+description: "Upgrade Vite and plugins with compatibility and build checks Use for a requested Vite version transition; deps handles general dependency selection."
+---
+
+# vite-upgrade
+
+Upgrade Vite and plugins with compatibility and build checks
+
+## Choose this workflow
+
+Use for a requested Vite version transition; deps handles general dependency selection.
+
+Read [shared execution](../../references/execution.md) for context/mode/authority handling and [Vite methods](../../references/packs/vite.md) for tool selection and operational details. Resolve these paths from this skill file; all runtime assets ship inside the plugin.
+
+## Input and mode
+
+Use the complete request appended to this invocation, preserving all constraints and references. Default mode: **apply**. Apply for a requested upgrade; source/target version, framework/plugins, and runtime constraints.
+
+project manifests, lockfile, Vite/framework/plugin versions, and existing build scripts. Verify current version-specific documentation when changing configuration. Apply-mode checks may generate build/cache artifacts; inspect mode uses existing evidence.
+
+Declared evidence requirements: `project.read`. Use actual host discovery or adequate supplied artifacts; unavailable evidence remains blocked/unknown.
+
+## Scope
+
+Compatible Vite/toolchain upgrade and necessary config changes.
+
+Only the requested local changes; external actions require their exact action and target in session authorization.
+
+## Execute
+
+- Read relevant migration notes, inspect plugin and Node compatibility, update controlled dependencies/lockfile, adjust deprecated behavior, and test development plus production build.
+- Check target migration notes and framework-plugin/Node compatibility, update only the required graph and compare dev refresh, production output and preview behavior.
+
+## Decision branches
+
+- **When a required plugin has no compatible version:** Stop at that compatibility boundary and propose a supported intermediate target.
+
+## Deliver and verify
+
+- Upgrade patch, compatibility rationale, checks, and rollback steps.
+- Version/peer matrix, configuration changes and dev/build/runtime checks.
+
+Verify these observable conditions when applicable to the actual task; do not claim they were exercised from merely reading this file:
+
+- Framework refresh and build both work; incompatible plugins are resolved or explicitly block the target version.
+
+## Stop and recover
+
+- No unrelated major upgrades. If a required peer is unsupported, stop before presenting a broken combination as complete.
+
+## Example requests
+
+- **Normal (apply):** Upgrade to the specified Vite version and verify framework-plugin compatibility.
+- **edge (apply):** Upgrade Vite while retaining an older framework plugin until a supported replacement exists.
+- **blocked (inspect):** Plan an upgrade with unavailable release-note access; do not guess removed options.