@oriro/orirocli 0.1.0

package/skills/craft/vercel-optimize/references/support-topics/external-api-critical-path-platform.md

@@ -0,0 +1,31 @@
+---
+id: external-api-critical-path-platform
+title: Cross-framework external API critical path
+status: active
+candidateKinds: ["external_api_slow"]
+frameworks: ["*"]
+priority: 86
+citations:
+  [
+    "https://vercel.com/docs/functions/debug-slow-functions",
+    "https://vercel.com/docs/caching/runtime-cache",
+    "https://vercel.com/docs/functions/functions-api-reference/vercel-functions-package",
+  ]
+maxBriefChars: 850
+---
+
+## Investigation Brief
+
+External API candidates are actionable only when the slow hostname is on a customer route's critical path. Prove the route waits on it before suggesting a cache, payload, or post-response change.
+
+## Evidence To Check
+
+Use hostname latency, caller routes, transfer bytes, and source awaits. Check sequential calls, overbroad payloads, repeated shared data, and side effects that can move after the response.
+
+## Do Not Recommend When
+
+Do not cache mutations, secrets, per-user responses, or unknown freshness contracts. Do not blame Vercel runtime when the upstream owns the latency.
+
+## Verification
+
+Name the hostname, caller route, observed p75/p95 or bytes, and exact await or fetch line that blocks the response.

package/skills/craft/vercel-optimize/references/support-topics/external-api-critical-path.md

@@ -0,0 +1,31 @@
+---
+id: external-api-critical-path
+title: External API critical path
+status: active
+candidateKinds: ["external_api_slow"]
+frameworks: ["next@>=13.0.0"]
+priority: 90
+citations:
+  [
+    "vercel-react-best-practices:async-parallel",
+    "vercel-react-best-practices:server-parallel-fetching",
+    "vercel-react-best-practices:server-cache-react",
+  ]
+maxBriefChars: 850
+---
+
+## Investigation Brief
+
+For external API candidates, identify the customer route that waits on the slow hostname and whether the call is on the critical path.
+
+## Evidence To Check
+
+Use callers-by-route evidence, transfer size, and source awaits. Check whether the upstream call can run in parallel, be cached safely, be reduced in payload size, or move after response.
+
+## Do Not Recommend When
+
+Do not cache mutations, secrets, per-user responses, or upstream calls whose freshness requirement is unknown.
+
+## Verification
+
+Name the hostname, caller route, p75 or p95 latency, and the exact source line that waits on the call.

package/skills/craft/vercel-optimize/references/support-topics/fast-data-transfer-payloads.md

@@ -0,0 +1,26 @@
+---
+id: fast-data-transfer-payloads
+title: Fast Data Transfer payloads
+status: active
+candidateKinds: ["uncached_route"]
+frameworks: ["*"]
+priority: 65
+citations: ["https://vercel.com/docs/manage-cdn-usage", "https://vercel.com/docs/caching/cdn-cache"]
+maxBriefChars: 900
+---
+
+## Investigation Brief
+
+When uncached routes carry high bandwidth, check payload shape before recommending only cache headers. Fast Data Transfer includes the bytes transferred by requests and responses; compare compressed response sizes to the signal, not raw JSON.
+
+## Evidence To Check
+
+Use `bandwidthByCache`, response size, and source serialization. Look for unbounded JSON, large embedded objects, static files through functions, missing pagination.
+
+## Do Not Recommend When
+
+Do not shrink payloads without identifying fields or assets that are unnecessary for the route’s response.
+
+## Verification
+
+Tie the finding to observed bytes, cache result mix, and the exact response line. A "large payload" claim must reflect post-compression bytes — the unit FDT meters.

package/skills/craft/vercel-optimize/references/support-topics/fluid-compute-caveats.md

@@ -0,0 +1,26 @@
+---
+id: fluid-compute-caveats
+title: Fluid compute caveats
+status: active
+candidateKinds: ["platform_fluid_compute", "cold_start"]
+frameworks: ["*"]
+priority: 80
+citations: ["https://vercel.com/docs/fluid-compute"]
+maxBriefChars: 900
+---
+
+## Investigation Brief
+
+Fluid compute is a project-level lever. Use it when the setting is off and metrics show cold-start or warm-instance reuse pressure. Fluid can handle multiple invocations in one function instance; avoid per-request state in module scope.
+
+## Evidence To Check
+
+Check project facts, `startTypeSplit`, cold-vs-warm latency, and routes carrying the cold-start share. When enabling Fluid, audit module-state hazards Fluid surfaces (not creates): module-scoped mutable state, lazy singletons holding per-user data, globals keyed on per-request inputs.
+
+## Do Not Recommend When
+
+Do not recommend enabling fluid compute when project facts say it is already on. Do not frame as a file-level code fix.
+
+## Verification
+
+State project setting, cold-start rate or fallback slow-route signal, affected route concentration. If enabling, call out module-state audit as follow-up.

package/skills/craft/vercel-optimize/references/support-topics/function-duration-io-and-after.md

@@ -0,0 +1,31 @@
+---
+id: function-duration-io-and-after
+title: Function duration, I/O, and post-response work
+status: active
+candidateKinds: ["slow_route"]
+frameworks: ["next@>=15.0.0"]
+priority: 75
+citations:
+  [
+    "https://nextjs.org/docs/app/api-reference/functions/after",
+    "vercel-react-best-practices:async-parallel",
+    "vercel-react-best-practices:server-after-nonblocking",
+  ]
+maxBriefChars: 850
+---
+
+## Investigation Brief
+
+When wall-clock latency is much higher than CPU time, check critical-path awaits before blaming rendering or compute.
+
+## Evidence To Check
+
+Compare `cpu.p95`, `ttfb.p95`, and `latency.p95`. In source, separate dependent awaits from independent awaits, and identify analytics, logging, or notification work that can run after the response.
+
+## Do Not Recommend When
+
+Do not wrap dependent operations in `Promise.all`. Do not replace `Promise.allSettled` when partial failure handling is intentional.
+
+## Verification
+
+Name the awaits that can move, the work that can run post-response, and the observed CPU-vs-wall-clock gap.

package/skills/craft/vercel-optimize/references/support-topics/function-invocation-reduction.md

@@ -0,0 +1,31 @@
+---
+id: function-invocation-reduction
+title: Function invocation reduction
+status: active
+candidateKinds: ["slow_route"]
+frameworks: ["next@>=13.0.0"]
+priority: 70
+citations:
+  [
+    "https://react.dev/reference/react/cache",
+    "vercel-react-best-practices:server-parallel-fetching",
+    "vercel-react-best-practices:server-cache-react",
+  ]
+maxBriefChars: 850
+---
+
+## Investigation Brief
+
+For slow routes, prove duplicated in-request work in the listed files before recommending consolidation or memoization.
+
+## Evidence To Check
+
+Look for repeated awaits, duplicate fetches, same-app route handler calls, and helpers that run more than once per request.
+
+## Do Not Recommend When
+
+Do not collapse endpoints called independently by different clients. Do not persistently cache user-specific data. Do not recommend `Promise.all` for CPU-bound or compile-bound work unless trace/span evidence shows wait time to overlap. High `cpu.p95` near `latency.p95` is a warning sign, not proof of a latency win.
+
+## Verification
+
+Quote duplicated call sites with `latency.p95`, `cpu.p95`, or request-count evidence. If the fix overlaps awaits, cite measured helper/span timing or state the impact is unmeasured.

package/skills/craft/vercel-optimize/references/support-topics/function-region-misconfiguration-ttfb.md

@@ -0,0 +1,31 @@
+---
+id: function-region-misconfiguration-ttfb
+title: Function region misconfiguration (TTFB)
+status: active
+candidateKinds: ["region_misconfig"]
+frameworks: ["*"]
+scannerPatterns: ["region-pin-in-config"]
+priority: 85
+citations:
+  [
+    "https://vercel.com/docs/functions/configuring-functions/region",
+    "https://vercel.com/docs/regions",
+  ]
+maxBriefChars: 950
+---
+
+## Investigation Brief
+
+A single function region is pinned. Per-region TTFB data is unavailable today (`evidence.dataGap`); treat as an audit prompt — validate the pinned region against user geo and data-source location before recommending changes.
+
+## Evidence To Check
+
+Scanner subtype (`vercel-json-single`, `segment-preferred`) and pinned regions. Cross-check Speed Insights TTFB and country analytics for traffic geo. Locate the data source — proximity to it often wins on cache-miss paths.
+
+## Do Not Recommend When
+
+Skip if TTFB is healthy across countries. Skip if pinned intentionally for data proximity. Skip on small projects (<20 routes). Do not propose multi-region without confirming the data layer is reachable without cross-region egress.
+
+## Verification
+
+Name pinned region(s), traffic geo, data-source location, and a specific call: relocate, expand, or keep with a TTFB monitor.

package/skills/craft/vercel-optimize/references/support-topics/image-optimization-cost-control.md

@@ -0,0 +1,31 @@
+---
+id: image-optimization-cost-control
+title: Image optimization cost control
+status: active
+candidateKinds: ["image_optimization"]
+frameworks: ["*"]
+priority: 90
+citations:
+  [
+    "https://vercel.com/docs/image-optimization",
+    "https://vercel.com/docs/image-optimization/managing-image-optimization-costs",
+    "https://vercel.com/docs/image-optimization/limits-and-pricing",
+  ]
+maxBriefChars: 850
+---
+
+## Investigation Brief
+
+Image recommendations should distinguish real user-facing image work from wasteful transformations.
+
+## Evidence To Check
+
+Inspect the sampled files for raw image tags, dimensions, remote sources, repeated transforms, source image limits, icons, SVGs, GIFs, and existing framework image components.
+
+## Do Not Recommend When
+
+Do not route tiny icons, SVG UI assets, or animated GIFs through image optimization just because they are images. Do not change remote-source policy without checking the existing config.
+
+## Verification
+
+Name the image files or components, current rendering path, and the metric or scanner evidence that makes optimization material.

package/skills/craft/vercel-optimize/references/support-topics/isr-revalidation-static-generation.md

@@ -0,0 +1,31 @@
+---
+id: isr-revalidation-static-generation
+title: ISR revalidation and static generation
+status: active
+candidateKinds: ["isr_overrevalidation"]
+frameworks: ["next@>=13.4.0"]
+priority: 95
+citations:
+  [
+    "https://vercel.com/docs/incremental-static-regeneration",
+    "https://nextjs.org/docs/app/api-reference/functions/revalidateTag",
+    "https://nextjs.org/docs/app/api-reference/functions/revalidatePath",
+  ]
+maxBriefChars: 1000
+---
+
+## Investigation Brief
+
+For ISR over-revalidation, the goal is to reduce unnecessary regeneration work without making content stale beyond the product’s tolerance.
+
+## Evidence To Check
+
+Compare ISR writes to reads, then inspect the route’s `revalidate`, `cacheLife()`, tag invalidation, and content update path. Look for very short timer revalidation on routes where updates are event-driven. If recommending `cacheLife()` or `cacheTag()` for tagged content, prove the exact tags are invalidated by `revalidateTag()` or `updateTag()`; near-matches do not count.
+
+## Do Not Recommend When
+
+Do not lengthen revalidation for inventory, pricing, auth, or other user-critical freshness without source evidence that stale content is acceptable. Do not claim existing CMS or webhook invalidation unless the matching invalidation call or config is in the allowed files.
+
+## Verification
+
+Tie the fix to the observed ISR writes per read and the line that controls revalidation or on-demand invalidation.

package/skills/craft/vercel-optimize/references/support-topics/middleware-proxy-edge-cost.md

@@ -0,0 +1,30 @@
+---
+id: middleware-proxy-edge-cost
+title: Middleware edge cost
+status: active
+candidateKinds: ["middleware_heavy"]
+frameworks: ["next@>=12.0.0"]
+priority: 90
+citations:
+  [
+    "https://nextjs.org/docs/app/building-your-application/routing/middleware",
+    "https://vercel.com/docs/routing-middleware",
+  ]
+maxBriefChars: 850
+---
+
+## Investigation Brief
+
+Middleware recommendations should reduce unnecessary interception, not remove required request handling.
+
+## Evidence To Check
+
+Use `topMiddlewarePaths` and the matcher config. Confirm which paths need auth, rewrites, headers, or locale handling. Check whether static assets, images, or routes with no middleware need are being matched.
+
+## Do Not Recommend When
+
+Do not narrow the matcher in a way that bypasses required auth or routing behavior. Do not move middleware work into every route if the current matcher is already scoped.
+
+## Verification
+
+State the current middleware share, the dominant matched paths, and the exact matcher line to change.

package/skills/craft/vercel-optimize/references/support-topics/next-fetch-revalidate-floor.md

@@ -0,0 +1,30 @@
+---
+id: next-fetch-revalidate-floor
+title: Next.js fetch revalidation floor
+status: active
+candidateKinds: ["uncached_route", "isr_overrevalidation"]
+frameworks: ["next@>=13.0.0"]
+priority: 88
+citations:
+  [
+    "https://nextjs.org/docs/app/api-reference/functions/fetch",
+    "https://nextjs.org/docs/app/building-your-application/caching",
+  ]
+maxBriefChars: 850
+---
+
+## Investigation Brief
+
+Next.js `fetch` options can set the route's effective cache floor. Low `revalidate`, `revalidate: 0`, or `cache: 'no-store'` can explain uncached traffic and excessive ISR work.
+
+## Evidence To Check
+
+Inspect route-tree `fetch` calls. Compare route revalidation with per-fetch `cache`, `next.revalidate`, tags, dynamic APIs, and duplicated URLs with conflicting options.
+
+## Do Not Recommend When
+
+Do not raise freshness windows for pricing, inventory, auth, draft, or user-specific data unless the source proves stale reads are acceptable.
+
+## Verification
+
+Name the observed cache or ISR signal, the lowest cache setting that controls the route, and the exact fetch line to change.

package/skills/craft/vercel-optimize/references/support-topics/next-font-cls-self-hosting.md

@@ -0,0 +1,31 @@
+---
+id: next-font-cls-self-hosting
+title: Next.js font CLS guardrail
+status: active
+candidateKinds: ["cwv_poor"]
+frameworks: ["next@>=13.2.0"]
+metrics: ["CLS"]
+priority: 86
+citations:
+  [
+    "https://nextjs.org/docs/app/api-reference/components/font",
+    "https://web.dev/articles/optimize-cls",
+  ]
+maxBriefChars: 800
+---
+
+## Investigation Brief
+
+For poor CLS, check fonts only when the route actually loads external font CSS or swaps text after render.
+
+## Evidence To Check
+
+Inspect layouts and global styles for external font links, CSS imports, custom font-face rules, late-loading font classes, and whether `next/font` is already used.
+
+## Do Not Recommend When
+
+Do not migrate fonts when CLS is caused by images, ads, embeds, or injected UI. Do not suggest `next/font` for unsupported Next.js versions.
+
+## Verification
+
+Name the CLS value, font-loading mechanism, and the exact layout or stylesheet line to change.

package/skills/craft/vercel-optimize/references/support-topics/next-heavy-ui-lazy-load-boundaries.md

@@ -0,0 +1,28 @@
+---
+id: next-heavy-ui-lazy-load-boundaries
+title: Next.js heavy UI lazy-load boundaries
+status: active
+candidateKinds: ["cwv_poor"]
+frameworks: ["next@*"]
+metrics: ["LCP", "INP"]
+priority: 82
+citations:
+  ["https://nextjs.org/docs/app/guides/lazy-loading", "https://web.dev/articles/optimize-inp"]
+maxBriefChars: 850
+---
+
+## Investigation Brief
+
+Heavy above-the-fold or rarely used UI can hurt LCP and INP when it ships too much JavaScript on first load. Look for concrete route-local UI, not generic bundle advice.
+
+## Evidence To Check
+
+Inspect client components, menus, search overlays, personalization widgets, maps, editors, and large imported libraries. Check whether they can load on interaction, viewport, or route entry with `next/dynamic` or dynamic import.
+
+## Do Not Recommend When
+
+Do not lazy-load essential above-the-fold content needed for initial meaning or accessibility. Do not use `ssr: false` from a Server Component.
+
+## Verification
+
+Name the poor metric, heavy UI boundary, imported library or component, and exact line to split.

package/skills/craft/vercel-optimize/references/support-topics/next-image-lcp-preload-sizes.md

@@ -0,0 +1,31 @@
+---
+id: next-image-lcp-preload-sizes
+title: Next.js image LCP preload and sizes
+status: active
+candidateKinds: ["cwv_poor"]
+frameworks: ["next@*"]
+metrics: ["LCP"]
+priority: 86
+citations:
+  [
+    "https://nextjs.org/docs/app/api-reference/components/image",
+    "https://web.dev/articles/optimize-lcp",
+  ]
+maxBriefChars: 850
+---
+
+## Investigation Brief
+
+For poor LCP, identify whether the LCP element is an image before touching unrelated JavaScript. Hero images need correct sizing, priority behavior, and source-cache hygiene.
+
+## Evidence To Check
+
+Inspect above-the-fold media for `next/image`, `fill` without `sizes`, deprecated `priority` on Next.js 16, missing `preload` or `fetchPriority`, oversized dimensions, and remote-image TTL/source behavior.
+
+## Do Not Recommend When
+
+Do not preload multiple possible LCP images or route tiny icons/SVG UI assets through image optimization. Do not change quality or TTL without checking source-update semantics.
+
+## Verification
+
+Name the LCP value, image element or component, current props/config, and the exact line to change.

package/skills/craft/vercel-optimize/references/support-topics/next-route-handler-get-cache-defaults.md

@@ -0,0 +1,30 @@
+---
+id: next-route-handler-get-cache-defaults
+title: Next.js Route Handler GET cache defaults
+status: active
+candidateKinds: ["uncached_route", "cache_header_gap"]
+frameworks: ["next@>=15.0.0"]
+priority: 91
+citations:
+  [
+    "https://nextjs.org/docs/app/api-reference/file-conventions/route",
+    "https://vercel.com/docs/caching/cdn-cache",
+  ]
+maxBriefChars: 850
+---
+
+## Investigation Brief
+
+On Next.js 15+, GET Route Handlers are dynamic by default. For hot public GET handlers, verify whether uncached behavior is intentional before recommending cache headers or route config.
+
+## Evidence To Check
+
+Use method share, cache result, and source. Check `GET`, `revalidate`, `dynamic`, request headers, cookies, auth, query params, and response `Cache-Control`.
+
+## Do Not Recommend When
+
+Do not cache POST-style handlers, webhooks, per-user APIs, streaming responses, search requests with user-specific params, or handlers that read auth/cookies.
+
+## Verification
+
+Name the Next.js version, GET share, cache result mix, and the exact handler or header line that makes public caching safe.

package/skills/craft/vercel-optimize/references/support-topics/next-script-third-party-strategy.md

@@ -0,0 +1,31 @@
+---
+id: next-script-third-party-strategy
+title: Next.js third-party script strategy
+status: active
+candidateKinds: ["cwv_poor"]
+frameworks: ["next@*"]
+metrics: ["LCP", "INP"]
+priority: 85
+citations:
+  [
+    "https://nextjs.org/docs/app/api-reference/components/script",
+    "https://web.dev/articles/optimize-inp",
+  ]
+maxBriefChars: 850
+---
+
+## Investigation Brief
+
+Third-party scripts are only actionable when they line up with the poor metric and route. For LCP or INP, prove a specific script blocks critical rendering, hydration, or interaction.
+
+## Evidence To Check
+
+Inspect `next/script`, raw `<script>`, tag managers, chat widgets, analytics, and consent code. Check `beforeInteractive`, `afterInteractive`, `lazyOnload`, and whether the script is route-local or global.
+
+## Do Not Recommend When
+
+Do not move required bot detection, consent, auth, or payment scripts later without product evidence. Do not recommend `worker` for App Router.
+
+## Verification
+
+Name the poor metric, script source, current strategy, and the exact route or layout line to change.

package/skills/craft/vercel-optimize/references/support-topics/nextjs-version-cache-semantics.md

@@ -0,0 +1,31 @@
+---
+id: nextjs-version-cache-semantics
+title: Next.js cache semantics by version
+status: active
+candidateKinds: ["uncached_route"]
+frameworks: ["next@>=15.0.0"]
+priority: 85
+citations:
+  [
+    "https://nextjs.org/docs/app/api-reference/directives/use-cache",
+    "https://nextjs.org/docs/app/api-reference/functions/cacheLife",
+    "https://nextjs.org/docs/app/building-your-application/caching",
+  ]
+maxBriefChars: 800
+---
+
+## Investigation Brief
+
+On Next.js 15+, match the fix to the cache primitive already in use.
+
+## Evidence To Check
+
+Check `'use cache'`, `cacheLife`, `cacheTag`, `fetch` cache options, route handlers, and dynamic APIs.
+
+## Do Not Recommend When
+
+Do not suggest APIs outside the detected Next.js version. Do not claim `cacheLife()` emits CDN `Cache-Control` headers or that missing `cacheLife()` alone makes a `'use cache'` route run per request. Omitted `cacheLife()` calls use the default profile.
+
+## Verification
+
+Name the detected Next.js version and exact cache primitive or route header.

package/skills/craft/vercel-optimize/references/support-topics/not-found-catchall-request-waste.md

@@ -0,0 +1,33 @@
+---
+id: not-found-catchall-request-waste
+title: Not-found and catch-all request waste
+status: active
+candidateKinds: ["uncached_route"]
+frameworks: ["*"]
+routePatterns: ["(^|/)404$", "not-found", "\\[\\.\\.\\."]
+priority: 92
+citations:
+  [
+    "https://vercel.com/docs/routing/",
+    "https://vercel.com/docs/redirects/bulk-redirects/",
+    "https://vercel.com/docs/vercel-firewall/vercel-waf/custom-rules",
+    "https://vercel.com/docs/vercel-firewall/vercel-waf/managed-rulesets",
+  ]
+maxBriefChars: 850
+---
+
+## Investigation Brief
+
+High-volume 404 or catch-all traffic is often request waste. First determine whether the traffic is legacy URLs, bots, broken links, or a real product route.
+
+## Evidence To Check
+
+Use route volume, method share, cache result, bot share, and top request paths. Inspect redirects, rewrites, catch-all routes, sitemap/robots output, and any WAF rules already logging or blocking the pattern.
+
+## Do Not Recommend When
+
+Do not block or redirect legitimate product routes, search crawlers, or unknown traffic without a log-mode validation path. Do not replace a useful 404 page with a blanket rewrite.
+
+## Verification
+
+Name the dominant bad path pattern, observed request or bot volume, and the redirect, routing, or WAF rule that would stop the wasted function path.

package/skills/craft/vercel-optimize/references/support-topics/nuxt-route-rules-cache-isr.md

@@ -0,0 +1,31 @@
+---
+id: nuxt-route-rules-cache-isr
+title: Nuxt routeRules cache and ISR
+status: active
+candidateKinds: ["uncached_route", "isr_overrevalidation", "rendering_candidate"]
+frameworks: ["nuxt@>=3.0.0"]
+priority: 90
+citations:
+  [
+    "https://vercel.com/docs/frameworks/full-stack/nuxt",
+    "https://nuxt.com/docs/4.x/api/utils/define-route-rules",
+    "https://nuxt.com/docs/4.x/guide/concepts/rendering",
+  ]
+maxBriefChars: 850
+---
+
+## Investigation Brief
+
+For Nuxt on Vercel, route-level caching usually belongs in `routeRules`. Match the lever to the route: prerender for static pages, ISR for shared content, and SSR for request-specific views.
+
+## Evidence To Check
+
+Inspect `nuxt.config`, inline route rules, server routes, pages, auth/session reads, and observed cache or ISR read/write patterns. Verify whether the route should be Vercel cache-backed ISR rather than generic SWR.
+
+## Do Not Recommend When
+
+Do not cache authenticated, cart, checkout, preview, or per-user routes. Do not add routeRules without proving the route is public and the freshness window is acceptable.
+
+## Verification
+
+Name the observed route signal, current routeRule or missing rule, chosen cache mode, and exact config line.

package/skills/craft/vercel-optimize/references/support-topics/observability-events-cost-attribution.md

@@ -0,0 +1,27 @@
+---
+id: observability-events-cost-attribution
+title: Observability Events cost attribution
+status: active
+candidateKinds: ["observability_events_attribution"]
+frameworks: ["*"]
+priority: 92
+citations:
+  ["https://vercel.com/docs/observability/observability-plus", "https://vercel.com/docs/alerts"]
+maxBriefChars: 900
+---
+
+## Investigation Brief
+
+Observability Events is the metered SKU under Observability Plus. When the current bill shows a large Observability Events share, event volume is the lever. Reduce upstream: lift cache hit rate, narrow middleware matchers, and reduce unnecessary custom-span cardinality.
+
+## Evidence To Check
+
+Verify the share from `usage.services`. Cross-reference `requestsByRouteCache`, `middlewareCount`, external API span counts, and third-party tracing (`tracesSampleRate=1`).
+
+## Do Not Recommend When
+
+Skip below 15% share. Skip when cache hit rate is already >90% across hot routes — the lever is elsewhere. Do not propose sampling unless the specific metered signal has a documented sampling control.
+
+## Verification
+
+Name the share, upstream drivers, and concrete remediation per driver, not generic "reduce events".

package/skills/craft/vercel-optimize/references/support-topics/post-response-work-waituntil.md

@@ -0,0 +1,26 @@
+---
+id: post-response-work-waituntil
+title: Post-response work with waitUntil
+status: active
+candidateKinds: ["slow_route", "external_api_slow"]
+frameworks: ["next@<15.0.0", "sveltekit@*", "astro@*", "nuxt@*", "unknown@*"]
+priority: 78
+citations: ["https://vercel.com/docs/functions/functions-api-reference/vercel-functions-package"]
+maxBriefChars: 800
+---
+
+## Investigation Brief
+
+For stacks without Next.js `after()`, check whether non-critical work can run after the response instead of extending user-visible latency.
+
+## Evidence To Check
+
+Inspect the listed route for analytics, logging, notifications, cache warming, metrics, or webhook side effects that happen after the response data is ready.
+
+## Do Not Recommend When
+
+Do not move work that decides the response, must fail the request, changes visible state synchronously, or needs a durable retry guarantee.
+
+## Verification
+
+Name the blocking side effect, the observed latency or upstream signal, and the exact line that can move behind `waitUntil`.