@oriro/orirocli 0.1.11 → 0.1.12

package/skills/craft/vercel-optimize/lib/gates/platform-fluid-compute.mjs

@@ -1,94 +1,94 @@
-// Second branch (slow p95 + traffic floor) keeps the gate useful on teams where
-// cold-start isn't directly observable — common on CLI v53 — trading specificity for coverage.
-export const metadata = {
-  id: "platform_fluid_compute",
-  threshold: "fluid=false AND (any cold_start signal OR any route with p95>1000ms AND inv>1000)",
-  billingDimension: "function-duration",
-  scope: "account",
-  sourceCitation: "vercel-optimize gate threshold",
-  description:
-    "When Fluid Compute is disabled on a project that shows cold-start pressure (high cold-start rate) or sustained slow function p95 on hot routes. Fluid Compute reduces cold starts via instance reuse — recommend turning it on at the project level rather than per-route.",
-};
-
-export function gate(signals) {
-  // If project config failed to load we can't tell if Fluid is on; recommending it when already-on
-  // erodes trust badly, so stay silent and let Strengths note the gap.
-  if (signals.project?.error) return [];
-
-  const fluidEnabled =
-    signals.project?.resourceConfig?.fluid === true ||
-    signals.project?.defaultResourceConfig?.fluid === true;
-  if (fluidEnabled) return [];
-
-  const cold = extractHighColdRoutes(signals);
-  const slow = extractSlowHotRoutes(signals);
-  if (cold.length === 0 && slow.length === 0) return [];
-
-  return [
-    {
-      kind: metadata.id,
-      scope: "account",
-      files: [],
-      priority: 50,
-      confidence: cold.length > 0 ? 0.85 : 0.65,
-      o11ySignal:
-        cold.length > 0
-          ? `${cold.length} route(s) with high cold-start rate`
-          : `${slow.length} hot route(s) with p95>1s; cold-start not directly observable`,
-      reason:
-        cold.length > 0
-          ? "cold starts observed and Fluid Compute is disabled"
-          : "slow hot routes and Fluid Compute is disabled",
-      question:
-        "Would enabling Fluid Compute reduce cold-start and warm-instance reuse overhead for the observed hot routes?",
-      evidence: { fluidEnabled, highColdRoutes: cold.slice(0, 5), slowHotRoutes: slow.slice(0, 5) },
-    },
-  ];
-}
-
-function extractHighColdRoutes(signals) {
-  const live = signals.metrics?.fnStartTypeByRoute?.rows;
-  if (Array.isArray(live) && live.some((r) => "coldCount" in r || "coldPct" in r)) {
-    return live.filter((r) => r.route && (r.coldPct ?? 0) > 0.3 && (r.total ?? 0) > 100);
-  }
-  // Legacy pre-derived fixture shape.
-  const direct = signals.metrics?.coldStartByRoute?.rows;
-  if (Array.isArray(direct)) {
-    return direct.filter((r) => r.route && (r.coldPct ?? 0) > 0.3 && (r.total ?? 0) > 100);
-  }
-  const legacy = signals.metrics?.coldStarts?.series;
-  if (Array.isArray(legacy)) {
-    return legacy
-      .map((s) => {
-        const total = s.summary?.count ?? 0;
-        const coldCount = s.summary?.coldCount ?? s.summary?.sum ?? 0;
-        return { route: s.groupValues?.route, total, coldPct: total > 0 ? coldCount / total : 0 };
-      })
-      .filter((r) => r.route && r.coldPct > 0.3 && r.total > 100);
-  }
-  return [];
-}
-
-function extractSlowHotRoutes(signals) {
-  const dur = signals.metrics?.fnDurationP95ByRoute?.rows;
-  const cache = signals.metrics?.requestsByRouteCache?.rows;
-  if (!Array.isArray(dur)) return [];
-
-  // Sum requests per route across cache_result.
-  const inv = new Map();
-  for (const r of cache ?? []) {
-    if (!r.route) continue;
-    inv.set(r.route, (inv.get(r.route) ?? 0) + (r.value ?? 0));
-  }
-  return (
-    dur
-      .filter((r) => r.route)
-      .map((r) => ({
-        route: r.route,
-        p95Ms: Math.round(r.value ?? 0),
-        invocations: inv.get(r.route) ?? 0,
-      }))
-      // inv>500 floor is the 14d-window equivalent of the old 1000/30d.
-      .filter((r) => r.p95Ms > 1000 && r.invocations > 500)
-  );
-}
+// Second branch (slow p95 + traffic floor) keeps the gate useful on teams where
+// cold-start isn't directly observable — common on CLI v53 — trading specificity for coverage.
+export const metadata = {
+  id: "platform_fluid_compute",
+  threshold: "fluid=false AND (any cold_start signal OR any route with p95>1000ms AND inv>1000)",
+  billingDimension: "function-duration",
+  scope: "account",
+  sourceCitation: "vercel-optimize gate threshold",
+  description:
+    "When Fluid Compute is disabled on a project that shows cold-start pressure (high cold-start rate) or sustained slow function p95 on hot routes. Fluid Compute reduces cold starts via instance reuse — recommend turning it on at the project level rather than per-route.",
+};
+
+export function gate(signals) {
+  // If project config failed to load we can't tell if Fluid is on; recommending it when already-on
+  // erodes trust badly, so stay silent and let Strengths note the gap.
+  if (signals.project?.error) return [];
+
+  const fluidEnabled =
+    signals.project?.resourceConfig?.fluid === true ||
+    signals.project?.defaultResourceConfig?.fluid === true;
+  if (fluidEnabled) return [];
+
+  const cold = extractHighColdRoutes(signals);
+  const slow = extractSlowHotRoutes(signals);
+  if (cold.length === 0 && slow.length === 0) return [];
+
+  return [
+    {
+      kind: metadata.id,
+      scope: "account",
+      files: [],
+      priority: 50,
+      confidence: cold.length > 0 ? 0.85 : 0.65,
+      o11ySignal:
+        cold.length > 0
+          ? `${cold.length} route(s) with high cold-start rate`
+          : `${slow.length} hot route(s) with p95>1s; cold-start not directly observable`,
+      reason:
+        cold.length > 0
+          ? "cold starts observed and Fluid Compute is disabled"
+          : "slow hot routes and Fluid Compute is disabled",
+      question:
+        "Would enabling Fluid Compute reduce cold-start and warm-instance reuse overhead for the observed hot routes?",
+      evidence: { fluidEnabled, highColdRoutes: cold.slice(0, 5), slowHotRoutes: slow.slice(0, 5) },
+    },
+  ];
+}
+
+function extractHighColdRoutes(signals) {
+  const live = signals.metrics?.fnStartTypeByRoute?.rows;
+  if (Array.isArray(live) && live.some((r) => "coldCount" in r || "coldPct" in r)) {
+    return live.filter((r) => r.route && (r.coldPct ?? 0) > 0.3 && (r.total ?? 0) > 100);
+  }
+  // Legacy pre-derived fixture shape.
+  const direct = signals.metrics?.coldStartByRoute?.rows;
+  if (Array.isArray(direct)) {
+    return direct.filter((r) => r.route && (r.coldPct ?? 0) > 0.3 && (r.total ?? 0) > 100);
+  }
+  const legacy = signals.metrics?.coldStarts?.series;
+  if (Array.isArray(legacy)) {
+    return legacy
+      .map((s) => {
+        const total = s.summary?.count ?? 0;
+        const coldCount = s.summary?.coldCount ?? s.summary?.sum ?? 0;
+        return { route: s.groupValues?.route, total, coldPct: total > 0 ? coldCount / total : 0 };
+      })
+      .filter((r) => r.route && r.coldPct > 0.3 && r.total > 100);
+  }
+  return [];
+}
+
+function extractSlowHotRoutes(signals) {
+  const dur = signals.metrics?.fnDurationP95ByRoute?.rows;
+  const cache = signals.metrics?.requestsByRouteCache?.rows;
+  if (!Array.isArray(dur)) return [];
+
+  // Sum requests per route across cache_result.
+  const inv = new Map();
+  for (const r of cache ?? []) {
+    if (!r.route) continue;
+    inv.set(r.route, (inv.get(r.route) ?? 0) + (r.value ?? 0));
+  }
+  return (
+    dur
+      .filter((r) => r.route)
+      .map((r) => ({
+        route: r.route,
+        p95Ms: Math.round(r.value ?? 0),
+        invocations: inv.get(r.route) ?? 0,
+      }))
+      // inv>500 floor is the 14d-window equivalent of the old 1000/30d.
+      .filter((r) => r.p95Ms > 1000 && r.invocations > 500)
+  );
+}

package/skills/craft/vercel-optimize/lib/gates/region-misconfig.mjs

@@ -1,71 +1,71 @@
-// Region-misconfig gate. Branch 2 (scanner-only) — per-region TTFB data gap.
-//
-// The intended Branch 1 (region-grouped TTFB metric) was preflight-tested but the
-// CLI returned INTERNAL_ERROR for the `--group-by route --group-by function_region`
-// combination, and SAML re-auth blocked single-dim verification (see Phase 0 in
-// plans/wild-splashing-flamingo.md). Ship scanner-only with `evidence.dataGap` and
-// add the query later when verifiable.
-//
-// Fires when a single-region pin is found AND the project has meaningful surface area
-// (routes.length > 20). Skips multi-region configs (informational only).
-export const metadata = {
-  id: "region_misconfig",
-  threshold: "single-region pin found AND routes.length > 20 (scanner-only branch)",
-  billingDimension: "function-duration",
-  scope: "account",
-  sourceCitation: "vercel-optimize gate threshold",
-  description:
-    "A single function region is pinned in `vercel.json` or per-route `preferredRegion`. Without per-region TTFB data (data gap), the gate can't quantify the geographic latency cost — but a single-region pin on a project with 20+ routes is worth auditing against Speed Insights traffic geo.",
-};
-
-const ROUTE_FLOOR = 20;
-const SCANNER_PATTERN = "region-pin-in-config";
-
-export function gate(signals) {
-  const findings = (signals?.codebase?.findings ?? []).filter((f) => f.pattern === SCANNER_PATTERN);
-  if (findings.length === 0) return [];
-
-  const routes = signals?.codebase?.routes ?? [];
-  if (routes.length < ROUTE_FLOOR) return [];
-
-  const singleRegionFindings = findings.filter(
-    (f) => Array.isArray(f.regions) && f.regions.length === 1,
-  );
-  if (singleRegionFindings.length === 0) return [];
-
-  const allPinned = new Set();
-  for (const f of singleRegionFindings) {
-    for (const r of f.regions ?? []) allPinned.add(r);
-  }
-  const regionList = [...allPinned];
-
-  // If multiple distinct single-region pins exist across files, the surface is partly
-  // multi-region by accident; that's noteworthy but lower priority.
-  const homogeneous = regionList.length === 1;
-
-  return [
-    {
-      kind: metadata.id,
-      scope: "account",
-      files: singleRegionFindings.map((f) => f.file).slice(0, 6),
-      priority: homogeneous ? 42 : 38,
-      confidence: 0.6, // low — no per-region TTFB data
-      o11ySignal: `pinned_regions=${regionList.join(",")} routes=${routes.length}`,
-      reason: homogeneous
-        ? `all functions pinned to a single region (${regionList[0]}) on a project with ${routes.length} routes`
-        : `${regionList.length} different single-region pins across files`,
-      question:
-        "Are the pinned function regions aligned with the dominant user geography and the data source location? Speed Insights TTFB-by-country can ground the comparison.",
-      evidence: {
-        metric: "codebase.findings",
-        pinnedRegions: regionList,
-        findingsCount: singleRegionFindings.length,
-        routeCount: routes.length,
-        sampleFiles: singleRegionFindings
-          .slice(0, 3)
-          .map((f) => ({ file: f.file, regions: f.regions, subtype: f.subtype })),
-        dataGap: "region-grouped-TTFB-unavailable",
-      },
-    },
-  ];
-}
+// Region-misconfig gate. Branch 2 (scanner-only) — per-region TTFB data gap.
+//
+// The intended Branch 1 (region-grouped TTFB metric) was preflight-tested but the
+// CLI returned INTERNAL_ERROR for the `--group-by route --group-by function_region`
+// combination, and SAML re-auth blocked single-dim verification (see Phase 0 in
+// plans/wild-splashing-flamingo.md). Ship scanner-only with `evidence.dataGap` and
+// add the query later when verifiable.
+//
+// Fires when a single-region pin is found AND the project has meaningful surface area
+// (routes.length > 20). Skips multi-region configs (informational only).
+export const metadata = {
+  id: "region_misconfig",
+  threshold: "single-region pin found AND routes.length > 20 (scanner-only branch)",
+  billingDimension: "function-duration",
+  scope: "account",
+  sourceCitation: "vercel-optimize gate threshold",
+  description:
+    "A single function region is pinned in `vercel.json` or per-route `preferredRegion`. Without per-region TTFB data (data gap), the gate can't quantify the geographic latency cost — but a single-region pin on a project with 20+ routes is worth auditing against Speed Insights traffic geo.",
+};
+
+const ROUTE_FLOOR = 20;
+const SCANNER_PATTERN = "region-pin-in-config";
+
+export function gate(signals) {
+  const findings = (signals?.codebase?.findings ?? []).filter((f) => f.pattern === SCANNER_PATTERN);
+  if (findings.length === 0) return [];
+
+  const routes = signals?.codebase?.routes ?? [];
+  if (routes.length < ROUTE_FLOOR) return [];
+
+  const singleRegionFindings = findings.filter(
+    (f) => Array.isArray(f.regions) && f.regions.length === 1,
+  );
+  if (singleRegionFindings.length === 0) return [];
+
+  const allPinned = new Set();
+  for (const f of singleRegionFindings) {
+    for (const r of f.regions ?? []) allPinned.add(r);
+  }
+  const regionList = [...allPinned];
+
+  // If multiple distinct single-region pins exist across files, the surface is partly
+  // multi-region by accident; that's noteworthy but lower priority.
+  const homogeneous = regionList.length === 1;
+
+  return [
+    {
+      kind: metadata.id,
+      scope: "account",
+      files: singleRegionFindings.map((f) => f.file).slice(0, 6),
+      priority: homogeneous ? 42 : 38,
+      confidence: 0.6, // low — no per-region TTFB data
+      o11ySignal: `pinned_regions=${regionList.join(",")} routes=${routes.length}`,
+      reason: homogeneous
+        ? `all functions pinned to a single region (${regionList[0]}) on a project with ${routes.length} routes`
+        : `${regionList.length} different single-region pins across files`,
+      question:
+        "Are the pinned function regions aligned with the dominant user geography and the data source location? Speed Insights TTFB-by-country can ground the comparison.",
+      evidence: {
+        metric: "codebase.findings",
+        pinnedRegions: regionList,
+        findingsCount: singleRegionFindings.length,
+        routeCount: routes.length,
+        sampleFiles: singleRegionFindings
+          .slice(0, 3)
+          .map((f) => ({ file: f.file, regions: f.regions, subtype: f.subtype })),
+        dataGap: "region-grouped-TTFB-unavailable",
+      },
+    },
+  ];
+}

package/skills/craft/vercel-optimize/lib/gates/route-errors.mjs

@@ -1,95 +1,95 @@
-// Errored function invocations still bill at full duration, so high-volume 5xx is a cost issue, not just reliability.
-import { withRouteShapeWarnings } from "../route-normalize.mjs";
-
-const MIN_VOLUME_FOR_RATE_EMISSION = 1000;
-
-export const metadata = {
-  id: "route_errors",
-  threshold: `count > 250 OR (totalRequests >= ${MIN_VOLUME_FOR_RATE_EMISSION} AND errorRate > 0.01)`,
-  billingDimension: "function-duration",
-  scope: "route",
-  sourceCitation: "vercel-optimize gate threshold",
-  description:
-    "Routes producing > 250 5xx errors over the window, or with > 1% error rate on at least 1,000 total requests. Errored function invocations still bill at full duration; high error rates also poison user experience.",
-};
-
-export function gate(signals) {
-  const errors = extractErrors(signals);
-  return errors
-    .filter(
-      (e) =>
-        e.count > 250 || (e.total >= MIN_VOLUME_FOR_RATE_EMISSION && (e.errorRate ?? 0) > 0.01),
-    )
-    .map((e) =>
-      withRouteShapeWarnings(
-        {
-          kind: metadata.id,
-          scope: "route",
-          route: e.route,
-          files: [],
-          priority: e.count,
-          confidence: 0.93,
-          o11ySignal:
-            e.errorRate != null
-              ? `errs=${e.count},rate=${(e.errorRate * 100).toFixed(1)}%`
-              : `errs=${e.count}`,
-          reason: "concentrated 5xx errors",
-          question: `Why does ${e.route} produce ${e.count} 5xx errors over the window, and what code path is failing?`,
-          evidence: {
-            metric: e.metric,
-            route: e.route,
-            count: e.count,
-            totalRequests: e.total,
-            errorRate: e.errorRate,
-          },
-        },
-        signals,
-      ),
-    );
-}
-
-function extractErrors(signals) {
-  const fnStatus = signals.metrics?.fnStatusByRoute;
-  if (Array.isArray(fnStatus?.rows)) return extractFromStatusRows(fnStatus.rows, "fnStatusByRoute");
-
-  const m = signals.metrics?.requestsByRouteStatus;
-  const cache = signals.metrics?.requestsByRouteCache;
-  if (!m?.ok && !Array.isArray(m?.rows)) return [];
-
-  const errors = extractFromStatusRows(m?.rows ?? [], "requestsByRouteStatus");
-
-  // cache rollup is summed across cache_result, giving per-route total request count.
-  const totalByRoute = new Map();
-  for (const row of cache?.rows ?? []) {
-    if (!row.route) continue;
-    totalByRoute.set(row.route, (totalByRoute.get(row.route) ?? 0) + (row.value ?? 0));
-  }
-
-  return errors.map((e) => {
-    const total = totalByRoute.get(e.route) ?? 0;
-    return {
-      ...e,
-      total,
-      errorRate: total > 0 ? e.count / total : null,
-    };
-  });
-}
-
-function extractFromStatusRows(rows, metric) {
-  const errByRoute = new Map();
-  const totalByRoute = new Map();
-  for (const row of rows) {
-    const route = row.route;
-    if (!route) continue;
-    const v = row.value ?? 0;
-    const status = String(row.http_status ?? "");
-    if (/^5\d\d$/.test(status)) errByRoute.set(route, (errByRoute.get(route) ?? 0) + v);
-    totalByRoute.set(route, (totalByRoute.get(route) ?? 0) + v);
-  }
-
-  return [...errByRoute.entries()].map(([route, count]) => {
-    const total = totalByRoute.get(route) ?? 0;
-    const errorRate = total > 0 ? count / total : null;
-    return { route, count, total, errorRate, metric };
-  });
-}
+// Errored function invocations still bill at full duration, so high-volume 5xx is a cost issue, not just reliability.
+import { withRouteShapeWarnings } from "../route-normalize.mjs";
+
+const MIN_VOLUME_FOR_RATE_EMISSION = 1000;
+
+export const metadata = {
+  id: "route_errors",
+  threshold: `count > 250 OR (totalRequests >= ${MIN_VOLUME_FOR_RATE_EMISSION} AND errorRate > 0.01)`,
+  billingDimension: "function-duration",
+  scope: "route",
+  sourceCitation: "vercel-optimize gate threshold",
+  description:
+    "Routes producing > 250 5xx errors over the window, or with > 1% error rate on at least 1,000 total requests. Errored function invocations still bill at full duration; high error rates also poison user experience.",
+};
+
+export function gate(signals) {
+  const errors = extractErrors(signals);
+  return errors
+    .filter(
+      (e) =>
+        e.count > 250 || (e.total >= MIN_VOLUME_FOR_RATE_EMISSION && (e.errorRate ?? 0) > 0.01),
+    )
+    .map((e) =>
+      withRouteShapeWarnings(
+        {
+          kind: metadata.id,
+          scope: "route",
+          route: e.route,
+          files: [],
+          priority: e.count,
+          confidence: 0.93,
+          o11ySignal:
+            e.errorRate != null
+              ? `errs=${e.count},rate=${(e.errorRate * 100).toFixed(1)}%`
+              : `errs=${e.count}`,
+          reason: "concentrated 5xx errors",
+          question: `Why does ${e.route} produce ${e.count} 5xx errors over the window, and what code path is failing?`,
+          evidence: {
+            metric: e.metric,
+            route: e.route,
+            count: e.count,
+            totalRequests: e.total,
+            errorRate: e.errorRate,
+          },
+        },
+        signals,
+      ),
+    );
+}
+
+function extractErrors(signals) {
+  const fnStatus = signals.metrics?.fnStatusByRoute;
+  if (Array.isArray(fnStatus?.rows)) return extractFromStatusRows(fnStatus.rows, "fnStatusByRoute");
+
+  const m = signals.metrics?.requestsByRouteStatus;
+  const cache = signals.metrics?.requestsByRouteCache;
+  if (!m?.ok && !Array.isArray(m?.rows)) return [];
+
+  const errors = extractFromStatusRows(m?.rows ?? [], "requestsByRouteStatus");
+
+  // cache rollup is summed across cache_result, giving per-route total request count.
+  const totalByRoute = new Map();
+  for (const row of cache?.rows ?? []) {
+    if (!row.route) continue;
+    totalByRoute.set(row.route, (totalByRoute.get(row.route) ?? 0) + (row.value ?? 0));
+  }
+
+  return errors.map((e) => {
+    const total = totalByRoute.get(e.route) ?? 0;
+    return {
+      ...e,
+      total,
+      errorRate: total > 0 ? e.count / total : null,
+    };
+  });
+}
+
+function extractFromStatusRows(rows, metric) {
+  const errByRoute = new Map();
+  const totalByRoute = new Map();
+  for (const row of rows) {
+    const route = row.route;
+    if (!route) continue;
+    const v = row.value ?? 0;
+    const status = String(row.http_status ?? "");
+    if (/^5\d\d$/.test(status)) errByRoute.set(route, (errByRoute.get(route) ?? 0) + v);
+    totalByRoute.set(route, (totalByRoute.get(route) ?? 0) + v);
+  }
+
+  return [...errByRoute.entries()].map(([route, count]) => {
+    const total = totalByRoute.get(route) ?? 0;
+    const errorRate = total > 0 ? count / total : null;
+    return { route, count, total, errorRate, metric };
+  });
+}