@olives/devos 2.1.0

package/.agents/skills/vercel-optimize/lib/extract-claims.mjs

@@ -0,0 +1,550 @@
+// Extract mechanically-verifiable claims from a rec without parsing LLM prose. High precision, not recall.
+
+export function extractClaims(rec, ctx = {}) {
+  const claims = [];
+  const repoRoot = ctx.repoRoot;
+  const projectRootDirectory = normalizeProjectRootDirectory(ctx.projectRootDirectory);
+  const framework = ctx.framework;
+  const frameworkVersion = ctx.version;
+  const cacheComponents = ctx.cacheComponents;
+  const signals = ctx.signals;
+  const projectFacts = Array.isArray(ctx.projectFacts) ? ctx.projectFacts : [];
+
+  // One synthetic claim asserts rec doesn't contradict any already-on project fact (Fluid, in-function concurrency, …).
+  if (projectFacts.length > 0) {
+    claims.push({
+      type: 'does_not_contradict_project_config',
+      rec,
+      projectFacts,
+      sourceField: 'projectFacts',
+    });
+  }
+
+  for (const cite of asArray(rec.citations)) {
+    // Skill-rule refs are filtered upstream — skip version check.
+    if (/^[\w-]+:[\w-]+$/.test(cite)) {
+      claims.push({ type: 'citation_in_library', url: cite, sourceField: 'citations' });
+      continue;
+    }
+    claims.push({ type: 'citation_in_library', url: cite, sourceField: 'citations' });
+    if (framework && frameworkVersion) {
+      claims.push({
+        type: 'citation_applies_to_version',
+        url: cite,
+        framework,
+        frameworkVersion,
+        sourceField: 'citations',
+      });
+    }
+  }
+
+  for (const f of asArray(rec.affectedFiles)) {
+    claims.push({ type: 'file_exists', file: f, repoRoot, projectRootDirectory, sourceField: 'affectedFiles' });
+  }
+
+  // findingRefs lack a pattern, so we only check file existence.
+  for (const ref of asArray(rec.findingRefs)) {
+    const m = String(ref).match(/^(.+?):\d+$/);
+    if (m && !claims.some((c) => c.type === 'file_exists' && c.file === m[1])) {
+      claims.push({ type: 'file_exists', file: m[1], repoRoot, projectRootDirectory, sourceField: 'findingRefs' });
+    }
+  }
+
+  const cacheFiles = cacheRecommendationFiles(rec);
+  if (isCacheCandidate(rec)) {
+    claims.push({
+      type: 'cache_policy_positive_or_no_ready_rec',
+      rec,
+      sourceField: 'cache-policy',
+    });
+  }
+  if (cacheFiles.length > 0) {
+    claims.push({
+      type: 'cache_vary_matches_dynamic_inputs',
+      rec,
+      files: cacheFiles,
+      repoRoot,
+      projectRootDirectory,
+      sourceField: 'cache-safety',
+    });
+    if (mentionsVaryHeader(rec)) {
+      claims.push({
+        type: 'cache_vary_cardinality_safe',
+        rec,
+        sourceField: 'cache-vary-cardinality',
+      });
+    }
+    claims.push({
+      type: 'cache_rec_not_error_dominated_or_acknowledged',
+      rec,
+      signals,
+      sourceField: 'cache-error-safety',
+    });
+    claims.push({
+      type: 'cache_control_header_syntax',
+      rec,
+      sourceField: 'cache-header-syntax',
+    });
+    claims.push({
+      type: 'cache_control_headers_citation',
+      rec,
+      sourceField: 'cache-header-citation',
+    });
+    if (mentionsCachedNotFoundOr404(rec)) {
+      claims.push({
+        type: 'cache_404_long_ttl_safety',
+        rec,
+        sourceField: 'cache-404-safety',
+      });
+    }
+  }
+
+  if (mentionsNextCachedNotFound(rec)) {
+    claims.push({
+      type: 'next_cached_not_found_causal_support',
+      rec,
+      framework,
+      frameworkVersion,
+      sourceField: 'next-cache-not-found',
+    });
+  }
+
+  if (mentionsNextStableCacheApi(rec)) {
+    claims.push({
+      type: 'next_stable_cache_api_for_version',
+      rec,
+      framework,
+      frameworkVersion,
+      sourceField: 'next-cache-api-version',
+    });
+  }
+
+  if (mentionsNext16RuntimeCacheApiMismatch(rec)) {
+    claims.push({
+      type: 'next_runtime_cache_api_for_version',
+      rec,
+      framework,
+      frameworkVersion,
+      sourceField: 'next-runtime-cache-api-version',
+    });
+  }
+
+  if (mentionsRuntimeCacheWhenCacheComponents(rec)) {
+    claims.push({
+      type: 'next_cache_components_runtime_cache_preference',
+      rec,
+      framework,
+      frameworkVersion,
+      cacheComponents,
+      sourceField: 'next-cache-components-runtime-cache-preference',
+    });
+  }
+
+  if (mentionsMultipleCacheLifeCalls(rec)) {
+    claims.push({
+      type: 'next_cache_life_single_execution',
+      rec,
+      framework,
+      frameworkVersion,
+      sourceField: 'next-cache-life-single-execution',
+    });
+  }
+
+  if (mentionsCacheLifetimeChange(rec)) {
+    claims.push({
+      type: 'next_cache_lifetime_freshness_supported',
+      rec,
+      files: recommendationFiles(rec),
+      repoRoot,
+      projectRootDirectory,
+      sourceField: 'next-cache-lifetime-freshness',
+    });
+  }
+
+  if (mentionsNextCacheComponentsStaticShellTarget(rec)) {
+    claims.push({
+      type: 'next_cache_components_route_chain_file',
+      rec,
+      framework,
+      frameworkVersion,
+      cacheComponents,
+      signals,
+      sourceField: 'next-cache-components-route-chain',
+    });
+  }
+
+  if (mentionsCacheLifeCdnHeaderClaim(rec)) {
+    claims.push({
+      type: 'next_cache_life_cdn_header_semantics',
+      rec,
+      framework,
+      frameworkVersion,
+      sourceField: 'next-cache-life-cdn-header-semantics',
+    });
+  }
+
+  if (mentionsImageResponseHeaders(rec)) {
+    claims.push({
+      type: 'image_response_headers_citation',
+      rec,
+      framework,
+      frameworkVersion,
+      sourceField: 'image-response-headers',
+    });
+  }
+
+  if (mentionsNextImagePriorityRecommendation(rec)) {
+    claims.push({
+      type: 'next_image_priority_api_for_version',
+      rec,
+      framework,
+      frameworkVersion,
+      sourceField: 'next-image-priority-api',
+    });
+  }
+
+  if (mentionsNextCacheComponentsRouteSegmentConfig(rec)) {
+    claims.push({
+      type: 'next_cache_components_route_segment_config',
+      rec,
+      framework,
+      frameworkVersion,
+      cacheComponents,
+      sourceField: 'next-route-segment-config',
+    });
+  }
+
+  if (mentionsRouteLevelRevalidate(rec)) {
+    claims.push({
+      type: 'next_route_revalidate_static_prereq',
+      rec,
+      framework,
+      frameworkVersion,
+      cacheComponents,
+      repoRoot,
+      projectRootDirectory,
+      sourceField: 'next-route-revalidate-static-prereq',
+    });
+  }
+
+  if (mentionsExistingCacheTagInvalidation(rec)) {
+    claims.push({
+      type: 'next_cache_tag_invalidation_supported',
+      rec,
+      repoRoot,
+      projectRootDirectory,
+      sourceField: 'next-cache-tag-invalidation',
+    });
+  }
+
+  if (mentionsUnsafeImmutableDynamicRoute(rec)) {
+    claims.push({
+      type: 'immutable_dynamic_route_safety',
+      rec,
+      sourceField: 'immutable-dynamic-route',
+    });
+  }
+
+  if (mentionsAuthSensitiveParallelization(rec)) {
+    claims.push({
+      type: 'auth_guard_parallelization_safety',
+      rec,
+      sourceField: 'auth-parallelization',
+    });
+  }
+
+  if (mentionsParallelizationImpactOverclaim(rec)) {
+    claims.push({
+      type: 'parallelization_impact_not_overclaimed',
+      rec,
+      sourceField: 'parallelization-impact',
+    });
+  }
+
+  if (mentionsCpuBoundParallelization(rec)) {
+    claims.push({
+      type: 'parallelization_not_cpu_bound_work',
+      rec,
+      sourceField: 'parallelization-cpu-bound',
+    });
+  }
+
+  if (mentionsRuntimeErrorCause(rec)) {
+    claims.push({
+      type: 'runtime_error_cause_supported',
+      rec,
+      sourceField: 'runtime-error-cause',
+    });
+  }
+
+  if (mentionsCatchToNotFound(rec)) {
+    claims.push({
+      type: 'route_error_not_found_status_and_scope',
+      rec,
+      sourceField: 'route-error-catch-safety',
+    });
+  }
+
+  if (mentionsIgnoredBuildStepRecommendation(rec)) {
+    claims.push({
+      type: 'vercel_ignore_command_project_state',
+      rec,
+      signals,
+      sourceField: 'ignored-build-step-state',
+    });
+  }
+
+  if (mentionsTurboBuildCacheRecommendation(rec)) {
+    claims.push({
+      type: 'turbo_build_cache_safety',
+      rec,
+      files: recommendationFiles(rec),
+      repoRoot,
+      projectRootDirectory,
+      framework,
+      sourceField: 'turbo-build-cache-safety',
+    });
+  }
+
+  for (const c of asArray(rec.verifiableClaims)) {
+    if (c && typeof c === 'object' && typeof c.type === 'string') {
+      claims.push({
+        ...c,
+        repoRoot: c.repoRoot ?? repoRoot,
+        projectRootDirectory: c.projectRootDirectory ?? projectRootDirectory,
+        sourceField: 'verifiableClaims',
+      });
+    }
+  }
+
+  return claims;
+}
+
+function normalizeProjectRootDirectory(value) {
+  if (typeof value !== 'string' || value.trim() === '') return null;
+  return value.replace(/\\/g, '/').replace(/^\.\/+/, '').replace(/\/+$/, '');
+}
+
+function cacheRecommendationFiles(rec) {
+  if (!recommendsSharedCache(rec)) return [];
+  return recommendationFiles(rec);
+}
+
+function isCacheCandidate(rec) {
+  return /^(?:uncached_route|cache_header_gap):/.test(String(rec?.candidateRef ?? ''));
+}
+
+function recommendationFiles(rec) {
+  const files = [
+    ...asArray(rec.affectedFiles),
+    ...asArray(rec.findingRefs)
+      .map((ref) => String(ref).match(/^(.+?):\d+$/)?.[1])
+      .filter(Boolean),
+  ];
+  return Array.from(new Set(files));
+}
+
+function recommendsSharedCache(rec) {
+  const haystack = [
+    rec?.what,
+    rec?.why,
+    rec?.fix,
+    rec?.desiredBehavior,
+    rec?.verify,
+  ].filter(Boolean).join('\n');
+  return /\b(?:s-maxage|CDN-Cache-Control|Vercel-CDN-Cache-Control|Cache-Control)\b/i.test(haystack);
+}
+
+function mentionsVaryHeader(rec) {
+  return /\bVary\b/i.test(recText(rec));
+}
+
+function mentionsNextCachedNotFound(rec) {
+  const haystack = recText(rec);
+  return /\bnotFound\b/.test(haystack) &&
+    /['"`]use cache['"`]|\buse cache\b/i.test(haystack) &&
+    /\b(?:500|5xx|error rate|errors?)\b/i.test(haystack);
+}
+
+function mentionsNextStableCacheApi(rec) {
+  const haystack = recText(rec);
+  return /\bunstable_(?:cacheLife|cacheTag)\b/.test(haystack) ||
+    /\brevalidateTag\s*\([^)]*['"`][^'"`]+['"`]\s*\)/.test(haystack);
+}
+
+function mentionsNext16RuntimeCacheApiMismatch(rec) {
+  const haystack = recText(rec);
+  const citations = asArray(rec?.citations).join('\n');
+  return /\bunstable_cache\b/.test(haystack) &&
+    (/\bRuntime Cache\b/i.test(haystack) || /vercel\.com\/docs\/caching\/runtime-cache/i.test(citations));
+}
+
+function mentionsRuntimeCacheWhenCacheComponents(rec) {
+  const haystack = recText(rec);
+  const citations = asArray(rec?.citations).join('\n');
+  return /\b(?:Runtime Cache|@vercel\/functions|getCache\s*\(|setCache\s*\()\b/i.test(haystack) ||
+    /vercel\.com\/docs\/caching\/runtime-cache/i.test(citations);
+}
+
+function mentionsMultipleCacheLifeCalls(rec) {
+  const haystack = recText(rec);
+  const matches = haystack.match(/\bcacheLife\s*\(/g) ?? [];
+  return matches.length > 1;
+}
+
+function mentionsCacheLifetimeChange(rec) {
+  return /\bcacheLife\s*\(/.test(recText(rec));
+}
+
+function mentionsCacheLifeCdnHeaderClaim(rec) {
+  const haystack = recText(rec);
+  if (!/\bcacheLife\b/.test(haystack)) return false;
+  return /\bcacheLife\b[^.\n]{0,240}\b(?:Cache-Control|s-maxage|CDN|edge cache|cache breakdown|x-vercel-cache|HIT|MISS|function (?:still )?runs per request|every request invokes the function)\b/i.test(haystack) ||
+    /\b(?:Cache-Control|s-maxage|CDN|edge cache|cache breakdown|x-vercel-cache|HIT|MISS|function (?:still )?runs per request|every request invokes the function)\b[^.\n]{0,240}\bcacheLife\b/i.test(haystack) ||
+    /\b(?:no|never|without|missing)\s+cacheLife\b[^.\n]{0,240}\b(?:no|not|never|0%|every|per request|function)\b[^.\n]{0,120}\b(?:cache|cached|hit|runs?|invoke)/i.test(haystack);
+}
+
+function mentionsNextCacheComponentsStaticShellTarget(rec) {
+  const haystack = recText(rec);
+  if (!/\b(?:cacheComponents|Cache Components|cacheLife|cacheTag|['"`]use cache['"`]|use cache|static shell|pre[- ]?render|prerender)\b/i.test(haystack)) {
+    return false;
+  }
+  const files = [
+    ...asArray(rec?.affectedFiles),
+    ...asArray(rec?.findingRefs).map((ref) => String(ref).match(/^(.+?):\d+$/)?.[1]).filter(Boolean),
+  ];
+  return files.some((file) => /(^|\/)layout\.(?:tsx?|jsx?)$/.test(String(file)));
+}
+
+function mentionsImageResponseHeaders(rec) {
+  const haystack = recText(rec);
+  return /\bImageResponse\b/.test(haystack) &&
+    /\bheaders?\b[\s\S]{0,200}\b(?:Cache-Control|s-maxage|CDN|response)\b|\b(?:Cache-Control|s-maxage|CDN)\b[\s\S]{0,200}\bheaders?\b/i.test(haystack);
+}
+
+function mentionsNextImagePriorityRecommendation(rec) {
+  const haystack = recText(rec);
+  if (!/\b(?:next\/image|<Image\b|Image component|image)\b/i.test(haystack)) return false;
+  if (!/\bpriority\b/i.test(haystack)) return false;
+  if (/\b(?:deprecated|replace|remove|avoid)\b[^.\n]{0,120}\bpriority\b/i.test(haystack) ||
+      /\bpriority\b[^.\n]{0,120}\b(?:deprecated|replace|remove|avoid)\b/i.test(haystack)) {
+    return false;
+  }
+  return /\b(?:set|add|use|enable|mark|make|turn on|with)\b[^.\n]{0,120}\bpriority\b/i.test(haystack) ||
+    /<Image\b[^>]*\bpriority(?:\s|=|>)/i.test(haystack);
+}
+
+function mentionsNextCacheComponentsRouteSegmentConfig(rec) {
+  const haystack = recText(rec);
+  return /\b(?:export\s+const\s+)?(?:dynamicParams|fetchCache)\s*=/.test(haystack) ||
+    /\bexport\s+const\s+(?:dynamic|revalidate)\b/.test(haystack) ||
+    /\b(?:set|add|configure|use)\s+[^.\n]{0,80}\b(?:dynamicParams|fetchCache)\b/i.test(haystack) ||
+    /\broute segment config options?\b[^.\n]{0,120}\b(?:Route Handlers?|handlers?)\b[^.\n]{0,120}\b(?:no longer apply|do not apply|removed)\b/i.test(haystack) ||
+    /\b(?:revalidate|dynamic|fetchCache)\b[^.\n]{0,80}\broute segment (?:config|export)\b/i.test(haystack);
+}
+
+function mentionsRouteLevelRevalidate(rec) {
+  const haystack = recText(rec);
+  return /\bexport\s+const\s+revalidate\b/.test(haystack) ||
+    /\broute[- ]level\s+revalidate\b/i.test(haystack) ||
+    /\brevalidate\s*(?:=|:)\s*\d+\b[^.\n]{0,120}\b(?:page|layout|route segment|segment export)\b/i.test(haystack);
+}
+
+function mentionsExistingCacheTagInvalidation(rec) {
+  const haystack = recText(rec);
+  if (!/\bcacheTag\s*\(/.test(haystack)) return false;
+  if (!/\b(?:revalidateTag|updateTag|invalidate|invalidation|revalidation|webhook|CMS|content-sync|content sync|publish|deploy)\b/i.test(haystack)) {
+    return false;
+  }
+  return /\b(?:existing|current|already|keep|keeps|preserve|preserves|continue|continues|maintain|maintains|via)\b[\s\S]{0,180}\b(?:revalidateTag|updateTag|invalidate|invalidation|revalidation|event-driven|webhook|CMS|content-sync|content sync|publish|deploy|tags?)\b/i.test(haystack) ||
+    /\b(?:invalidation|revalidation)\s+is\s+already\b/i.test(haystack) ||
+    /\balready\s+event-driven\b/i.test(haystack);
+}
+
+function mentionsUnsafeImmutableDynamicRoute(rec) {
+  const haystack = recText(rec);
+  if (!/\bimmutable\b/i.test(haystack)) return false;
+  const files = [
+    ...asArray(rec?.affectedFiles),
+    ...asArray(rec?.findingRefs).map((ref) => String(ref).match(/^(.+?):\d+$/)?.[1]).filter(Boolean),
+  ];
+  const routeHandler = files.some((file) => /(?:^|\/)route\.[cm]?[jt]sx?$/.test(String(file)));
+  const apiRoute = /^cache_header_gap:\/api\//.test(String(rec?.candidateRef ?? ''));
+  return routeHandler || apiRoute;
+}
+
+function mentionsAuthSensitiveParallelization(rec) {
+  const haystack = recText(rec);
+  if (!/\b(?:parallelize|Promise\.all|run concurrently|start .* early)\b/i.test(haystack)) return false;
+  if (!/\b(?:auth|authorize|authorization|ownership|owns|owner|private|session|permission|access)\b/i.test(haystack)) return false;
+  return /\b(?:private|secret|token|registrant|account|user|ticket|payment|session)\w*\b/i.test(haystack);
+}
+
+function mentionsParallelizationImpactOverclaim(rec) {
+  const haystack = recText(rec);
+  if (!/\b(?:parallelize|Promise\.all|run concurrently|start .* early)\b/i.test(haystack)) return false;
+  return /\b(?:drop|drops|reduce|reduces|reduction|save|saves|shave|shaves)\b[^.\n]{0,200}\b(?:roughly|approximately|about|around|equal\s+to)?\s*(?:the\s+)?(?:duration\s+of\s+[A-Za-z_$][\w$]*\s*\(\s*\)|min\s*\([^)]*duration[^)]*\)|one\s+[\w-]+\s+round[- ]trip|one\s+await|one\s+network\s+call|one\s+database\s+query)/i.test(haystack);
+}
+
+function mentionsCpuBoundParallelization(rec) {
+  const haystack = recText(rec);
+  if (!/\b(?:parallelize|Promise\.all|run concurrently|start .* early)\b/i.test(haystack)) return false;
+  return /\b(?:cpu\.p95|CPU p95|cpu p95|CPU-bound|compute-bound|in-process compute|compileMDX|MDX compilation|compilation|render compute)\b/i.test(haystack);
+}
+
+function mentionsCachedNotFoundOr404(rec) {
+  const haystack = recText(rec);
+  if (!/\b(?:s-maxage|CDN-Cache-Control|Vercel-CDN-Cache-Control|Cache-Control)\b/i.test(haystack)) return false;
+  return /\b(?:404|not[- ]found|notFound|not found branch|not-found branch)\b/i.test(haystack);
+}
+
+function mentionsRuntimeErrorCause(rec) {
+  if (!/^route_errors:/.test(String(rec?.candidateRef ?? ''))) return false;
+  const haystack = recText(rec);
+  return /\b(?:ENOENT|ETIMEDOUT|ECONNRESET|outputFileTracing|missing\s+(?:file|mdx|module)|no\s+(?:matching|corresponding)\s+(?:file|mdx|post)|does\s+not\s+exist|signature\s+of|root cause|caused by|unhandled\s+exceptions?|uncaught(?:-exception)?|throws?|bubbles?\s+to\s+the\s+runtime|reads?\s+[^.]{0,80}(?:filePath|filesystem|file system|disk)|readFile)\b/i.test(haystack);
+}
+
+function mentionsCatchToNotFound(rec) {
+  if (!/^route_errors:/.test(String(rec?.candidateRef ?? ''))) return false;
+  const haystack = recText(rec);
+  return /\bcatch\b/i.test(haystack) &&
+    /\b(?:404|not[- ]found|not found|notFound)\b/i.test(haystack);
+}
+
+function mentionsIgnoredBuildStepRecommendation(rec) {
+  const haystack = recText(rec);
+  return /\b(?:Ignored Build Step|ignoreCommand|turbo-ignore|skip unaffected|unaffected projects?)\b/i.test(haystack) &&
+    /\b(?:add|set|configure|enable|use|introduce|wire|adopt|turn on)\b[^.\n]{0,180}\b(?:Ignored Build Step|ignoreCommand|turbo-ignore|skip unaffected|unaffected projects?)\b/i.test(haystack);
+}
+
+function mentionsTurboBuildCacheRecommendation(rec) {
+  const haystack = recText(rec);
+  if (!/\b(?:Turbo|Turborepo|turbo\.json|tasks\.build|build cache|build caching)\b/i.test(haystack)) return false;
+  return /\b(?:enable|re-enable|restore|turn on|set|remove)\b[^.\n]{0,220}\b(?:cache\s*:\s*false|tasks\.build\.cache|build cache|build caching|Turbo cache|Turborepo cache)\b/i.test(haystack) ||
+    /\b(?:cache\s*:\s*false|tasks\.build\.cache|build cache|build caching|Turbo cache|Turborepo cache)\b[^.\n]{0,220}\b(?:enable|re-enable|restore|turn on|set|remove)\b/i.test(haystack);
+}
+
+function recText(rec) {
+  return [
+    rec?.what,
+    rec?.why,
+    rec?.fix,
+    rec?.currentBehavior,
+    rec?.desiredBehavior,
+    rec?.verify,
+  ].filter(Boolean).join('\n');
+}
+
+function asArray(v) {
+  return Array.isArray(v) ? v : [];
+}
+
+export function summarizeClaimResults(results) {
+  const counts = { verified: 0, failed: 0, unsupported: 0, unverifiable: 0 };
+  for (const r of results) {
+    if (r?.disposition && counts[r.disposition] !== undefined) counts[r.disposition]++;
+  }
+  const verifiable = counts.verified + counts.failed;
+  const passRate = verifiable > 0 ? counts.verified / verifiable : 1;
+  return { ...counts, verifiable, passRate, total: results.length };
+}

package/.agents/skills/vercel-optimize/lib/framework-support.mjs

@@ -0,0 +1,67 @@
+export const CORE_SUPPORTED_FRAMEWORKS = ['next', 'sveltekit', 'nuxt'];
+export const LIMITED_FRAMEWORKS = ['astro'];
+
+const LABELS = {
+  next: 'Next.js',
+  sveltekit: 'SvelteKit',
+  nuxt: 'Nuxt',
+  astro: 'Astro',
+  hono: 'Hono',
+  remix: 'Remix',
+  unknown: 'unknown framework',
+};
+
+export function frameworkLabel(framework) {
+  return LABELS[normalizeFramework(framework)] ?? String(framework ?? 'unknown');
+}
+
+export function classifyFrameworkSupport(stack = {}) {
+  const framework = normalizeFramework(stack.framework);
+  const label = frameworkLabel(framework);
+  const supportedLabels = CORE_SUPPORTED_FRAMEWORKS.map(frameworkLabel);
+  const limitedLabels = LIMITED_FRAMEWORKS.map(frameworkLabel);
+
+  if (CORE_SUPPORTED_FRAMEWORKS.includes(framework)) {
+    return {
+      ok: true,
+      status: 'supported',
+      blocker: null,
+      framework,
+      label,
+      supportedFrameworks: supportedLabels,
+      limitedFrameworks: limitedLabels,
+      detail: `${label} is supported for metric-backed route-to-file investigations.`,
+    };
+  }
+
+  if (LIMITED_FRAMEWORKS.includes(framework)) {
+    return {
+      ok: true,
+      status: 'limited',
+      blocker: null,
+      framework,
+      label,
+      supportedFrameworks: supportedLabels,
+      limitedFrameworks: limitedLabels,
+      detail: `${label} support is limited. The skill can use Vercel metrics and generic platform checks, but framework-specific route-to-file recommendations may be sparse.`,
+    };
+  }
+
+  return {
+    ok: false,
+    status: 'unsupported',
+    blocker: 'unsupported_framework',
+    framework,
+    label,
+    supportedFrameworks: supportedLabels,
+    limitedFrameworks: limitedLabels,
+    detail: `${label} is not supported for metric-backed route-to-file investigations. Supported frameworks: ${supportedLabels.join(', ')}. Limited support: ${limitedLabels.join(', ')}.`,
+  };
+}
+
+function normalizeFramework(value) {
+  const raw = String(value ?? 'unknown').trim().toLowerCase();
+  if (raw === 'nextjs' || raw === 'next.js') return 'next';
+  if (raw === 'svelte' || raw === 'svelte-kit') return 'sveltekit';
+  return raw || 'unknown';
+}

package/.agents/skills/vercel-optimize/lib/gates/build-minutes-fanout.mjs

@@ -0,0 +1,69 @@
+// Build Minutes climb on monorepos when Turborepo cache is bypassed or every project rebuilds on every commit.
+// Threshold: Build Minutes line > 15% of total bill OR scanner emits any turbo-force-bypass finding (even at lower share).
+// Account-scoped because the lever is project-settings (Ignored Build Step, Elastic Build Machines), not code.
+export const metadata = {
+  id: 'build_minutes_fanout',
+  threshold: 'Build Minutes share > 0.15 OR turbo-force-bypass finding present',
+  billingDimension: 'build',
+  scope: 'account',
+  sourceCitation: 'vercel-optimize gate threshold',
+  description:
+    'Build Minutes line dominates the bill or Turborepo cache is bypassed. On monorepos, unchanged work should be skipped through Vercel skip-unaffected behavior, a verified Ignored Build Step, and a complete Turbo cache contract.',
+};
+
+const BUILD_RE = /^Build (CPU )?Minutes$/i;
+const SCANNER_PATTERN = 'turbo-force-bypass';
+const SHARE_FLOOR = 0.15;
+
+export function gate(signals) {
+  const services = signals?.usage?.services;
+  const total = Array.isArray(services)
+    ? services.reduce((acc, s) => acc + Number(s.billedCost ?? s.cost ?? 0), 0)
+    : 0;
+  const buildBilled = Array.isArray(services)
+    ? services
+        .filter((s) => BUILD_RE.test(String(s?.name ?? '')))
+        .reduce((acc, s) => acc + Number(s.billedCost ?? s.cost ?? 0), 0)
+    : 0;
+
+  const buildShare = total > 0 ? buildBilled / total : 0;
+
+  const findings = (signals?.codebase?.findings ?? []).filter((f) => f.pattern === SCANNER_PATTERN);
+
+  if (buildShare <= SHARE_FLOOR && findings.length === 0) return [];
+
+  const subtypes = unique(findings.map((f) => f.subtype).filter(Boolean));
+  const sampleFiles = unique(findings.map((f) => f.file).filter(Boolean)).slice(0, 4);
+
+  const reason = findings.length > 0
+    ? (buildShare > SHARE_FLOOR
+        ? 'Build Minutes share is high and Turborepo cache bypass detected in repo'
+        : 'Turborepo cache bypass detected in repo')
+    : 'Build Minutes line exceeds 15% of total billed cost';
+
+  return [{
+    kind: metadata.id,
+    scope: 'account',
+    files: sampleFiles,
+    priority: findings.length > 0 ? 65 : 50,
+    confidence: findings.length > 0 ? 0.86 : 0.74,
+    o11ySignal: `build_minutes_share=${(buildShare * 100).toFixed(0)}% scanner_findings=${findings.length}`,
+    reason,
+    question: findings.length > 0
+      ? `Turborepo cache bypass detected (${subtypes.join(', ')}). Which build pipeline forces a rebuild on every commit, and can Ignored Build Step + cache re-enable cut the project fan-out?`
+      : 'Build Minutes exceed 15% of the bill. Is Ignored Build Step configured? Is Turborepo cache active across builds? Would Elastic Build Machines reduce duration on hot builds?',
+    evidence: {
+      metric: 'usage.services',
+      buildBilled,
+      totalBilled: total,
+      buildShare,
+      scannerFindings: findings.length,
+      scannerSubtypes: subtypes,
+      sampleFiles,
+    },
+  }];
+}
+
+function unique(values) {
+  return [...new Set(values)];
+}