@debugbundle/mcp 1.8.0 → 1.8.2

package/dist/main.cjs

@@ -39659,17 +39659,17 @@ var require_dns = __commonJS({
         const timestamp = Date.now();
         const records = { records: { 4: null, 6: null } };
         let minTTL = this.#maxTTL;
-        for (const record of addresses) {
-          record.timestamp = timestamp;
-          if (typeof record.ttl === "number") {
-            record.ttl = Math.min(record.ttl, this.#maxTTL);
-            minTTL = Math.min(minTTL, record.ttl);
+        for (const record2 of addresses) {
+          record2.timestamp = timestamp;
+          if (typeof record2.ttl === "number") {
+            record2.ttl = Math.min(record2.ttl, this.#maxTTL);
+            minTTL = Math.min(minTTL, record2.ttl);
           } else {
-            record.ttl = this.#maxTTL;
+            record2.ttl = this.#maxTTL;
           }
-          const familyRecords = records.records[record.family] ?? { ips: [] };
-          familyRecords.ips.push(record);
-          records.records[record.family] = familyRecords;
+          const familyRecords = records.records[record2.family] ?? { ips: [] };
+          familyRecords.ips.push(record2);
+          records.records[record2.family] = familyRecords;
         }
         this.storage.set(origin.hostname, records, { ttl: minTTL });
       }
@@ -55119,15 +55119,15 @@ var require_util7 = __commonJS({
     exports2.getUniqueHostnamesFromOptions = getUniqueHostnamesFromOptions;
     function groupSrvRecords(records) {
       const recordsByPriority = {};
-      for (const record of records) {
-        if (!recordsByPriority.hasOwnProperty(record.priority)) {
-          recordsByPriority[record.priority] = {
-            totalWeight: record.weight,
-            records: [record]
+      for (const record2 of records) {
+        if (!recordsByPriority.hasOwnProperty(record2.priority)) {
+          recordsByPriority[record2.priority] = {
+            totalWeight: record2.weight,
+            records: [record2]
           };
         } else {
-          recordsByPriority[record.priority].totalWeight += record.weight;
-          recordsByPriority[record.priority].records.push(record);
+          recordsByPriority[record2.priority].totalWeight += record2.weight;
+          recordsByPriority[record2.priority].records.push(record2);
         }
       }
       return recordsByPriority;
@@ -55140,12 +55140,12 @@ var require_util7 = __commonJS({
       }
       const random = Math.floor(Math.random() * (recordsGroup.totalWeight + recordsGroup.records.length));
       let total = 0;
-      for (const [i, record] of recordsGroup.records.entries()) {
-        total += 1 + record.weight;
+      for (const [i, record2] of recordsGroup.records.entries()) {
+        total += 1 + record2.weight;
         if (total > random) {
-          recordsGroup.totalWeight -= record.weight;
+          recordsGroup.totalWeight -= record2.weight;
           recordsGroup.records.splice(i, 1);
-          return record;
+          return record2;
         }
       }
     }
@@ -57067,13 +57067,13 @@ var require_cluster = __commonJS({
               if (!sortedKeys.length) {
                 return reject(err2);
               }
-              const key = sortedKeys[0], group = groupedRecords[key], record = (0, util_1.weightSrvRecords)(group);
+              const key = sortedKeys[0], group = groupedRecords[key], record2 = (0, util_1.weightSrvRecords)(group);
               if (!group.records.length) {
                 sortedKeys.shift();
               }
-              self.dnsLookup(record.name).then((host) => resolve2({
+              self.dnsLookup(record2.name).then((host) => resolve2({
                 host,
-                port: record.port
+                port: record2.port
               }), tryFirstOne);
             }
             tryFirstOne();
@@ -64420,6 +64420,73 @@ function createEventEnvelope(input2) {
   return EventEnvelopeSchema.parse(candidate);
 }
 
+// ../../packages/shared-types/src/browser-resource-routes.ts
+var BrowserResourceRoutesSchema = external_exports.object({
+  items: external_exports.array(external_exports.object({ route: external_exports.string().max(1024), occurrences: external_exports.number().int().positive() })).max(20),
+  recorded_occurrences: external_exports.number().int().nonnegative(),
+  unattributed_occurrences: external_exports.number().int().nonnegative(),
+  omitted_routes: external_exports.number().int().nonnegative(),
+  coverage: external_exports.enum(["occurrence_metadata", "retained_samples"])
+});
+function normalizeResourceRoute(value) {
+  if (typeof value !== "string" || !value.startsWith("/") || value.startsWith("//") || value.length > 4096)
+    return null;
+  const path = value.split(/[?#]/, 1)[0];
+  if (/[\u0000-\u0020\u007f\\]/.test(path)) return null;
+  const segments = path.split("/").filter(Boolean).map((segment) => {
+    let decoded;
+    try {
+      decoded = decodeURIComponent(segment);
+    } catch {
+      return "{param}";
+    }
+    if (decoded === "{param}" || /^:[A-Za-z_][A-Za-z_0-9]*$/.test(decoded)) return "{param}";
+    return /^\d+$/.test(decoded) || /^[a-f0-9-]{16,}$/i.test(decoded) || /^[A-Za-z0-9_-]{24,}$/.test(decoded) || decoded.length >= 16 && /[A-Za-z]/.test(decoded) && /\d/.test(decoded) || /[@/\\\u0000-\u0020\u007f]/.test(decoded) ? "{param}" : segment;
+  });
+  const route = `/${segments.join("/")}`;
+  return route.length <= 1024 ? route : null;
+}
+function summarizeResourceRoutes(routes, occurrenceCount) {
+  const counts = /* @__PURE__ */ new Map();
+  for (const raw of routes) {
+    const route = normalizeResourceRoute(raw);
+    if (route !== null) counts.set(route, (counts.get(route) ?? 0) + 1);
+  }
+  const items = [...counts].map(([route, occurrences]) => ({ route, occurrences })).sort(
+    (a, b) => b.occurrences - a.occurrences || (a.route < b.route ? -1 : a.route > b.route ? 1 : 0)
+  );
+  const recorded = items.reduce((total, item) => total + item.occurrences, 0);
+  return {
+    items: items.slice(0, 20),
+    recorded_occurrences: recorded,
+    unattributed_occurrences: Math.max(0, occurrenceCount - recorded),
+    omitted_routes: Math.max(0, items.length - 20),
+    coverage: "retained_samples"
+  };
+}
+
+// ../../packages/shared-types/src/browser-resource-context.ts
+var BrowserResourceContextSchema = external_exports.object({
+  version: external_exports.literal(1),
+  host: external_exports.string().max(255).nullable(),
+  path: external_exports.string().max(1024),
+  type: external_exports.string().nullable(),
+  first_party: external_exports.boolean().nullable(),
+  role: external_exports.enum([
+    "analytics",
+    "advertising",
+    "tag_manager",
+    "authentication",
+    "application_asset",
+    "unknown"
+  ]),
+  provider: external_exports.string().nullable(),
+  title: external_exports.string(),
+  optional_candidate: external_exports.boolean(),
+  diagnosis: external_exports.string(),
+  routes: BrowserResourceRoutesSchema
+});
+
 // ../../packages/shared-types/src/tier-capabilities.ts
 var TIER_CAPABILITIES = {
   free: {
@@ -65254,6 +65321,93 @@ var CaptureRulesFileSchema = external_exports.object({
   rules: external_exports.array(CaptureRuleSchema)
 });
 
+// ../../packages/shared-types/src/browser-resource.ts
+function record(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+function httpUrl(value, base2) {
+  if (typeof value !== "string" || value.length === 0 || value.length > 4096 || /[\u0000-\u0020\u007f]/.test(value))
+    return null;
+  try {
+    const url = base2 === void 0 ? new URL(value) : new URL(value, base2);
+    return url.protocol === "http:" || url.protocol === "https:" ? url : null;
+  } catch {
+    return null;
+  }
+}
+function browserResourceLocation(source, page) {
+  if (typeof source !== "string") return null;
+  const pageUrl = httpUrl(page);
+  const url = httpUrl(source, pageUrl ?? void 0);
+  if (url !== null) {
+    if (url.pathname.length > 1024 || url.hostname.length > 255) return null;
+    return {
+      host: url.hostname.toLowerCase(),
+      path: url.pathname || "/",
+      first_party: pageUrl === null ? null : url.origin === pageUrl.origin
+    };
+  }
+  if (source.startsWith("/") && !source.startsWith("//") && !source.includes("\\") && !/[\u0000-\u0020\u007f]/.test(source)) {
+    const path = source.split(/[?#]/, 1)[0];
+    if (path.length <= 1024) return { host: null, path, first_party: true };
+  }
+  return null;
+}
+function describeBrowserResource(value) {
+  const event = record(value);
+  if (event?.["kind"] !== "resource_error") return null;
+  const target = record(event["target"]);
+  const page = record(event["page"]);
+  const location = browserResourceLocation(
+    target?.["source_url"] ?? event["file_name"],
+    page?.["url"]
+  );
+  if (location === null) return null;
+  const tag2 = typeof target?.["tag_name"] === "string" ? target["tag_name"].toLowerCase() : null;
+  const type = tag2 !== null && [
+    "script",
+    "link",
+    "img",
+    "audio",
+    "video",
+    "source",
+    "iframe",
+    "object",
+    "embed",
+    "input"
+  ].includes(tag2) ? tag2 : null;
+  let role = location.first_party === true ? "application_asset" : "unknown";
+  let provider = null;
+  if (type === "script") {
+    if (location.host === "www.googletagmanager.com" && location.path === "/gtm.js") {
+      provider = "Google Tag Manager";
+      role = "tag_manager";
+    } else if (location.host === "connect.facebook.net" && /^\/[a-z]{2}_[A-Z]{2}\/fbevents\.js$/.test(location.path)) {
+      provider = "Meta Pixel";
+      role = "advertising";
+    } else if (location.host === "www.clarity.ms" && /^\/tag\/[A-Za-z0-9]+$/.test(location.path)) {
+      provider = "Microsoft Clarity";
+      role = "analytics";
+    } else if (location.host === "accounts.google.com" && location.path === "/gsi/client") {
+      provider = "Google sign-in";
+      role = "authentication";
+    }
+  }
+  const file = location.path.split("/").filter(Boolean).at(-1) ?? location.path;
+  const kind = type === "img" ? "Image" : type === "script" || /\.m?js$/i.test(file) ? "JavaScript asset" : "Resource";
+  return {
+    ...location,
+    type,
+    role,
+    provider,
+    title: provider !== null ? `${provider} script failed to load` : `${kind} failed to load: ${file}${location.host === null ? "" : ` (${location.host})`}`,
+    optional_candidate: event["opaque"] === true && location.first_party !== true && ["analytics", "advertising", "tag_manager"].includes(role)
+  };
+}
+function browserResourceDiagnosis(resource) {
+  return resource?.optional_candidate === true ? "The browser reported that this script failed to load. Possibly blocked by privacy tools; network, CSP or provider failures are also possible. The captured event does not identify the cause." : "The browser reported that this resource failed to load. The captured event does not identify the cause or establish whether application functionality was affected.";
+}
+
 // ../../packages/shared-types/src/capture-rule-evaluation.ts
 var CaptureRuleEvaluationUrlSchema = external_exports.object({
   host: external_exports.string().min(1).transform((value) => value.toLowerCase()).optional(),
@@ -65276,7 +65430,9 @@ var CaptureRuleEvaluationContextSchema = external_exports.object({
   resource_url: CaptureRuleEvaluationUrlSchema.optional(),
   request_url: CaptureRuleEvaluationUrlSchema.optional(),
   status_code: external_exports.number().int().min(0).max(599).optional(),
-  fingerprint: CaptureRuleFingerprintSchema.optional()
+  fingerprint: CaptureRuleFingerprintSchema.optional(),
+  // Server-derived prior versions keep installed exact-match rules effective.
+  fingerprint_aliases: external_exports.array(CaptureRuleFingerprintSchema).max(2).optional()
 });
 function classifyCaptureRuleClientFromUserAgent(userAgent) {
   if (userAgent === null || userAgent === void 0) {
@@ -65319,6 +65475,7 @@ var CaptureRuleSuggestionSchema = external_exports.object({
   rule: CaptureRuleCreateSchema
 });
 var CaptureRuleSuggestionsResponseSchema = external_exports.object({
+  access_mode: external_exports.enum(["manage", "preview"]).optional(),
   suggestions: external_exports.array(CaptureRuleSuggestionSchema),
   bundle_status: external_exports.enum(["ready", "pending", "failed"]).optional(),
   bundle_reason: external_exports.string().nullable().optional()
@@ -65814,6 +65971,14 @@ function looksSensitiveCustomDimensionValue(value) {
   return /https?:\/\//i.test(value) || /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(value) || /\bBearer\s+[A-Za-z0-9._~+/=-]+/i.test(value) || /\b(?:token|password|secret|api_key)=/i.test(value);
 }
 
+// ../../packages/shared-types/src/frontend-severity.ts
+function inferFrontendExceptionSeverity(event) {
+  const browserEvent = event.payload.browser_event;
+  if (browserEvent?.opaque === true)
+    return browserEvent.kind === "resource_error" ? "medium" : "low";
+  return "high";
+}
+
 // ../../packages/shared-types/src/analytics-product.ts
 var AnalyticsOpportunityStatusValues = ["open", "resolved", "snoozed"];
 var AnalyticsOpportunityStatusSchema = external_exports.enum(AnalyticsOpportunityStatusValues);
@@ -66388,6 +66553,7 @@ var ContextDeviceSchema = external_exports.object({
   color_scheme_preference: external_exports.enum(["light", "dark", "no-preference"]).nullable()
 });
 var BundleContextSchema = external_exports.object({
+  resource_failure: BrowserResourceContextSchema.optional(),
   error: ContextErrorSchema.nullable().optional(),
   request: ContextRequestSchema.nullable().optional(),
   response: ContextResponseSchema.nullable().optional(),
@@ -68070,6 +68236,15 @@ function buildSkill() {
     "- Scope frontend noise by structured evidence such as service, environment, `browser_event_kind`, `browser_event_opaque`, `client_kind`, `bot_family`, and message fields. Do not broadly demote generic `Unhandled promise rejection` incidents without bot-scoped or otherwise narrow evidence.",
     "- For expected or intentionally promoted 4xx responses on known routes, use capture-policy client-error path rules instead of promoting all client errors: `debugbundle capture-policy set --client-error-path-rule <status=/path/*@GET>`.",
     "",
+    "### Browser resource failures",
+    "",
+    "- Inspect the primary failure and routes: one resource can span pages, route coverage may be incomplete, and historical incidents stay separate. Related tracker evidence does not explain an application exception.",
+    '- If the cause is unknown, say "possibly blocked by privacy tools." Network/CSP/provider failures remain possible; provider recognition proves neither Pi-hole blocking nor optionality.',
+    "- Review exact host/path, service, environment and opaque resource-error scope; never widen to a whole host. Google sign-in, app assets and unknown dependencies have no automatic resource noise recommendation.",
+    "- For confirmed optional dependencies, context (demote) retains diagnostics without new incidents/alerts/automation and may remain billable. Drop discards future matches; choose it only when evidence has no diagnostic value. Explain the tradeoff; neither deletes history. Use the returned suggestion ID.",
+    "- Check existing/disabled rules. Empty suggestions or pending/failed bundles do not justify broader rules. Applying requires user authorization and owner/admin access; preview is read-only. Verify subsequent matching and protected captures before claiming improvement; live tests need authorization.",
+    "- The official OpenAI connection cannot suggest or apply rules. When it is the only connection, review returned evidence and hand off through a returned safe dashboard URL; never invent tools or switch credentials.",
+    "",
     "## Notification Delivery",
     "",
     "When notification or automation delivery is the reported failure, inspect configuration and delivery records before changing incident logic.",
@@ -68177,6 +68352,7 @@ function buildCliReference() {
     "- `debugbundle capture-policy set [--project <id>] --client-error-path-rule <404=/path/*@GET,POST> [--json]`",
     "",
     "Use capture-rule suggestions for repeated operational noise after inspecting an incident bundle. Use capture-policy client-error path rules for route-scoped 4xx incidents instead of promoting all client errors.",
+    "For browser resource failures, follow the skill's Browser resource failures guidance. Use the current response's suggestion ID, inspect `bundle_status`, `access_mode` and existing-rule state, and review the complete matcher before applying.",
     "",
     "## Probes",
     "",
@@ -68325,6 +68501,7 @@ function buildMcpReference() {
     "- `get_capture_policy`, `update_capture_policy` \u2014 review or update capture policy, including path-scoped client-error incident rules.",
     "",
     "Use these tools for repeated low-value operational noise only after inspecting incident evidence. Keep frontend suppression scoped by structured browser and client signals, and use path-scoped capture policy for known 4xx routes.",
+    "For browser resource failures, follow the skill's Browser resource failures guidance and use the suggestion ID returned by the server. These management tools belong to the member-authenticated MCP surface; the official OpenAI connection is read-only and cannot suggest or apply capture rules.",
     "",
     "## Product Analytics Tools",
     "",
@@ -68520,6 +68697,43 @@ function buildSkillEvals() {
             "Use capture-policy path rules for known route-scoped 4xx incidents."
           ]
         },
+        {
+          name: "browser_resource_noise_review",
+          prompt: "GTM failed on four routes. The owner says analytics is optional and asks to keep useful diagnostics without repeated alerts. The suggestion response offers resource_context and resource_drop with exact host/path/service/environment matchers. Explain and apply the appropriate authorized choice.",
+          expected_behavior: [
+            "Inspect the primary failure and bounded route coverage; do not count each route as a separate application defect.",
+            "Describe privacy blocking as possible, not proven; do not diagnose Pi-hole.",
+            "Review the exact matcher and use the returned context suggestion ID; explain retained evidence and possible paid usage.",
+            "Verify the returned rule without claiming historical incidents were removed or live noise reduction was already observed."
+          ]
+        },
+        {
+          name: "protected_resource_noise_review",
+          prompt: "A checkout TypeError has related GTM evidence. Separate incidents show Google sign-in and an unknown script failing. The user asks whether ignoring all Google or third-party hosts would clean this up.",
+          expected_behavior: [
+            "Keep the primary checkout exception separate from related tracker evidence.",
+            "Do not broaden rules to whole hosts or infer that sign-in, app assets or unknown dependencies are optional.",
+            "Inspect evidence and available suggestions before proposing any narrowly scoped change."
+          ]
+        },
+        {
+          name: "unavailable_resource_noise_suggestions",
+          prompt: "Resource suggestions are pending or empty, the current member has preview access, and a matching rule is disabled. The user asks why the resource still opens incidents.",
+          expected_behavior: [
+            "Explain the missing evidence and access limits without inventing a rule or bypassing authorization.",
+            "Inspect the disabled rule; do not assume it is active, create a duplicate or silently enable it.",
+            "Do not claim noise was reduced or resolve historical incidents based solely on a policy proposal."
+          ]
+        },
+        {
+          name: "readonly_resource_noise_handoff",
+          prompt: "Only the official read-only OpenAI connection is available. The user asks to ignore recurring tracker failures.",
+          expected_behavior: [
+            "Inspect only available incident evidence; distinguish possible privacy blocking from a proven cause.",
+            "Explain that this connection cannot fetch capture-rule suggestions or apply rules; do not invent a management tool or switch credentials.",
+            "Use a returned safe dashboard URL for a reviewed handoff when available, and never claim a rule was applied."
+          ]
+        },
         {
           name: "operational_controls_guidance",
           prompt: "The user reports missing webhook deliveries and asks whether probes or alerts are available. Confirm the skill points the agent to the relevant operational controls and docs.",
@@ -70060,8 +70274,57 @@ function createHealthCheckApi(httpClient) {
 var import_promises4 = require("node:fs/promises");
 var import_node_path4 = require("node:path");
 
-// ../../packages/event-normalizer/src/index.ts
-var import_node_crypto2 = require("node:crypto");
+// ../../packages/event-normalizer/src/fingerprints.ts
+var import_node_crypto = require("node:crypto");
+var FINGERPRINT_VERSION = "v2";
+var RESOURCE_FINGERPRINT_VERSION = "v3";
+function fingerprintVersion(event) {
+  return event.resource_type != null ? RESOURCE_FINGERPRINT_VERSION : FINGERPRINT_VERSION;
+}
+function stableJson(value) {
+  if (value === null || typeof value !== "object") return JSON.stringify(value);
+  if (Array.isArray(value)) return `[${value.map(stableJson).join(",")}]`;
+  const object = value;
+  return `{${Object.keys(object).sort().map((key) => `${JSON.stringify(key)}:${stableJson(object[key])}`).join(",")}}`;
+}
+function fingerprint(event) {
+  const canonical = event.resource_type != null ? {
+    // A concrete resource is the grouping unit, not proof of a common underlying cause.
+    browser_event_kind: "resource_error",
+    resource_host: event.resource_host,
+    resource_path: event.resource_path,
+    resource_type: event.resource_type,
+    environment: event.environment,
+    fingerprint_version: RESOURCE_FINGERPRINT_VERSION
+  } : {
+    // Preserve exact historical bytes for every non-resource event and explicit legacy normalization.
+    error_type: event.error_type,
+    normalized_message: event.normalized_message,
+    top_frames: event.top_frames,
+    route_template: event.route_template,
+    browser_event_kind: event.browser_event_kind,
+    resource_host: event.resource_host,
+    resource_path: event.resource_path,
+    http_method: event.http_method,
+    http_status: event.http_status,
+    environment: event.environment
+  };
+  return (0, import_node_crypto.createHash)("sha256").update(stableJson(canonical)).digest("hex");
+}
+function inferMatchedFields(event) {
+  if (event.resource_type != null)
+    return ["environment", "browser_event_kind", "resource_host", "resource_path", "resource_type"];
+  const fields = ["environment", "normalized_message"];
+  if (event.error_type !== null) fields.push("error_type");
+  if (event.route_template !== null) fields.push("route_template");
+  if (event.top_frames.length > 0) fields.push("top_frames");
+  if (event.browser_event_kind != null) fields.push("browser_event_kind");
+  if (event.resource_host != null) fields.push("resource_host");
+  if (event.resource_path != null) fields.push("resource_path");
+  if (event.http_method !== null) fields.push("http_method");
+  if (event.http_status !== null) fields.push("http_status");
+  return fields;
+}
 
 // ../../packages/redaction/src/index.ts
 var DEFAULT_SENSITIVE_KEYS = [
@@ -70160,7 +70423,7 @@ function redact(payload2, options) {
 }
 
 // ../../packages/event-normalizer/src/mobile-event-compatibility.ts
-var import_node_crypto = require("node:crypto");
+var import_node_crypto2 = require("node:crypto");
 var MOBILE_SDKS = /* @__PURE__ */ new Set(["@debugbundle/sdk-android", "@debugbundle/sdk-swift"]);
 function isRecord(candidate) {
   return typeof candidate === "object" && candidate !== null && !Array.isArray(candidate);
@@ -70187,8 +70450,8 @@ function readInteger(candidate) {
 function readBoolean(candidate) {
   return typeof candidate === "boolean" ? candidate : null;
 }
-function readField(record, snakeCase, camelCase) {
-  return record[snakeCase] ?? record[camelCase];
+function readField(record2, snakeCase, camelCase) {
+  return record2[snakeCase] ?? record2[camelCase];
 }
 function stableValue(candidate) {
   if (Array.isArray(candidate)) {
@@ -70202,7 +70465,7 @@ function stableValue(candidate) {
   );
 }
 function deterministicEventId(candidate) {
-  const digest2 = (0, import_node_crypto.createHash)("sha256").update(JSON.stringify(stableValue(candidate))).digest("hex");
+  const digest2 = (0, import_node_crypto2.createHash)("sha256").update(JSON.stringify(stableValue(candidate))).digest("hex");
   const chars = digest2.slice(0, 32).split("");
   chars[12] = "5";
   chars[16] = ["8", "9", "a", "b"][Number.parseInt(chars[16] ?? "0", 16) % 4] ?? "8";
@@ -70560,8 +70823,14 @@ function normalizeInstalledJavaEvent(candidate) {
   };
 }
 
+// ../../packages/event-normalizer/src/java-timer-message.ts
+var TIMER_DIAGNOSTIC = /^WFLYEJB002(?:0|2):[^\n]*\[id=[^\]\n]*\btimedObjectId=/;
+var JAVA_TIMER_DATE = /\b(previousRun|initialExpiration|nextExpiration)=((?:Mon|Tue|Wed|Thu|Fri|Sat|Sun)\s+(?:Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec)\s+\d{1,2}\s+\d{2}:\d{2}:\d{2}\s+[A-Za-z][A-Za-z0-9:+-]{0,15}\s+\d{4})\b/g;
+function normalizeJavaTimerMessage(message3) {
+  return TIMER_DIAGNOSTIC.test(message3) ? message3.replace(JAVA_TIMER_DATE, "$1={dynamic}") : message3;
+}
+
 // ../../packages/event-normalizer/src/index.ts
-var FINGERPRINT_VERSION = "v1";
 var PAYLOAD_ALLOWED_KEYS = {
   backend_exception: /* @__PURE__ */ new Set([
     "name",
@@ -70744,34 +71013,6 @@ function normalizeCompatibleEventCandidate(candidate) {
   }
   return event;
 }
-function inferMatchedFields(event) {
-  const matchedFields = ["environment", "normalized_message"];
-  if (event.error_type !== null) {
-    matchedFields.push("error_type");
-  }
-  if (event.route_template !== null) {
-    matchedFields.push("route_template");
-  }
-  if (event.top_frames.length > 0) {
-    matchedFields.push("top_frames");
-  }
-  if (event.browser_event_kind != null) {
-    matchedFields.push("browser_event_kind");
-  }
-  if (event.resource_host != null) {
-    matchedFields.push("resource_host");
-  }
-  if (event.resource_path != null) {
-    matchedFields.push("resource_path");
-  }
-  if (event.http_method !== null) {
-    matchedFields.push("http_method");
-  }
-  if (event.http_status !== null) {
-    matchedFields.push("http_status");
-  }
-  return matchedFields;
-}
 var UUID_PATTERN = /\b[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}\b/gi;
 var EMAIL_PATTERN = /\b[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,}\b/gi;
 var ISO_TIMESTAMP_PATTERN = /\b\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?Z\b/g;
@@ -70895,12 +71136,12 @@ function normalizeKnownDatabaseMessage(message3) {
   }
   return null;
 }
-function normalizeMessage(message3) {
+function normalizeMessage(message3, version2) {
   const knownDatabaseMessage = normalizeKnownDatabaseMessage(message3);
   if (knownDatabaseMessage !== null) {
     return knownDatabaseMessage;
   }
-  return collapseWhitespace(normalizeScalarTokens(message3));
+  return collapseWhitespace(normalizeScalarTokens(version2 === "v1" ? message3 : normalizeJavaTimerMessage(message3)));
 }
 function normalizeRoute(path) {
   if (path === null || path.length === 0) {
@@ -70975,29 +71216,17 @@ function normalizeResourceIdentity(value) {
     };
   }
 }
-function stableJson(value) {
-  if (value === null || typeof value !== "object") {
-    return JSON.stringify(value);
-  }
-  if (Array.isArray(value)) {
-    return `[${value.map((entry) => stableJson(entry)).join(",")}]`;
-  }
-  const record = value;
-  const keys2 = Object.keys(record).sort();
-  const pairs = keys2.map((key) => `${JSON.stringify(key)}:${stableJson(record[key])}`);
-  return `{${pairs.join(",")}}`;
-}
 function validateEvent(candidate) {
   return EventEnvelopeSchema.safeParse(normalizeCompatibleEventCandidate(candidate));
 }
-function normalizeEvent(event) {
+function normalizeEvent(event, version2 = RESOURCE_FINGERPRINT_VERSION) {
   const redactedPayload = redact(event.payload).redacted;
   if (event.event_type === "backend_exception") {
     return {
       event_type: event.event_type,
       environment: event.service.environment,
       error_type: event.payload.name,
-      normalized_message: normalizeMessage(event.payload.message),
+      normalized_message: normalizeMessage(event.payload.message, version2),
       route_template: normalizeRoute(event.payload.request.path),
       http_method: event.payload.request.method,
       http_status: event.payload.response.status_code,
@@ -71029,7 +71258,7 @@ function normalizeEvent(event) {
       event_type: event.event_type,
       environment: event.service.environment,
       error_type: null,
-      normalized_message: normalizeMessage(event.payload.message),
+      normalized_message: normalizeMessage(event.payload.message, version2),
       route_template: null,
       http_method: null,
       http_status: null,
@@ -71044,18 +71273,22 @@ function normalizeEvent(event) {
     const browserEvent = event.payload.browser_event;
     const resourceIdentity = browserEvent?.kind === "resource_error" ? normalizeResourceIdentity(browserEvent.target?.source_url ?? browserEvent.file_name) : { host: null, path: null };
     const topFrames = browserEvent?.opaque === true ? [] : selectTopFrames(event.payload.stack);
+    const resource = describeBrowserResource(browserEvent);
+    const concreteResource = version2 === RESOURCE_FINGERPRINT_VERSION && browserEvent?.opaque === true && resource?.host != null && resource.type !== null;
     return {
       event_type: event.event_type,
       environment: event.service.environment,
       error_type: event.payload.name,
-      normalized_message: normalizeMessage(event.payload.message),
+      normalized_message: normalizeMessage(event.payload.message, version2),
       route_template: normalizeRoute(event.payload.route ?? null),
       http_method: null,
       http_status: null,
       top_frames: topFrames,
       browser_event_kind: browserEvent?.kind ?? null,
-      resource_host: resourceIdentity.host,
-      resource_path: resourceIdentity.path,
+      resource_host: concreteResource ? resource.host : resourceIdentity.host,
+      resource_path: concreteResource ? resource.path : resourceIdentity.path,
+      ...concreteResource ? { resource_type: resource.type } : {},
+      ...resource === null ? {} : { incident_title: resource.title },
       payload: redactedPayload
     };
   }
@@ -71074,21 +71307,6 @@ function normalizeEvent(event) {
     payload: redactedPayload
   };
 }
-function fingerprint(event) {
-  const canonical = {
-    error_type: event.error_type,
-    normalized_message: event.normalized_message,
-    top_frames: event.top_frames,
-    route_template: event.route_template,
-    browser_event_kind: event.browser_event_kind,
-    resource_host: event.resource_host,
-    resource_path: event.resource_path,
-    http_method: event.http_method,
-    http_status: event.http_status,
-    environment: event.environment
-  };
-  return (0, import_node_crypto2.createHash)("sha256").update(stableJson(canonical)).digest("hex");
-}
 var INCIDENT_LOG_LEVELS = /* @__PURE__ */ new Set(["error", "fatal", "critical"]);
 function getRequestResponseStatus(payload2) {
   const status = payload2?.["response_status"];
@@ -89169,6 +89387,54 @@ var ANALYTICS_BOOTSTRAP_STATEMENTS = [
   `
 ];
 
+// ../../packages/storage/src/schema-migration-definition.ts
+var import_node_crypto7 = require("node:crypto");
+function defineStorageSchemaMigration(input2) {
+  return {
+    ...input2,
+    checksum: (0, import_node_crypto7.createHash)("sha256").update(JSON.stringify(input2)).digest("hex")
+  };
+}
+
+// ../../packages/storage/src/worker-job-schema.ts
+var WORKER_JOB_SCHEMA_STATEMENTS = [
+  `CREATE TABLE IF NOT EXISTS worker_jobs (
+    id text PRIMARY KEY,
+    job_name text NOT NULL,
+    project_id uuid REFERENCES projects(id) ON DELETE CASCADE,
+    payload jsonb,
+    depends_on text REFERENCES worker_jobs(id) ON DELETE RESTRICT,
+    status text NOT NULL DEFAULT 'pending' CHECK (status IN ('pending', 'running', 'completed', 'failed', 'skipped')),
+    attempts integer NOT NULL DEFAULT 0 CHECK (attempts >= 0),
+    operator_retries integer NOT NULL DEFAULT 0 CHECK (operator_retries >= 0),
+    available_at timestamptz NOT NULL DEFAULT now(),
+    lease_token uuid,
+    lease_expires_at timestamptz,
+    last_error_code text,
+    created_at timestamptz NOT NULL DEFAULT now(),
+    updated_at timestamptz NOT NULL DEFAULT now(),
+    expires_at timestamptz NOT NULL DEFAULT now() + interval '7 days',
+    CHECK ((status = 'running') = (lease_token IS NOT NULL AND lease_expires_at IS NOT NULL)),
+    CHECK (payload IS NULL OR jsonb_typeof(payload) = 'object')
+  )`,
+  `CREATE INDEX IF NOT EXISTS worker_jobs_pending_idx ON worker_jobs(job_name, available_at, created_at, id) WHERE status = 'pending'`,
+  `CREATE INDEX IF NOT EXISTS worker_jobs_running_idx ON worker_jobs(lease_expires_at) WHERE status = 'running'`,
+  `CREATE INDEX IF NOT EXISTS worker_jobs_expiry_idx ON worker_jobs(expires_at)`,
+  `CREATE INDEX IF NOT EXISTS worker_jobs_project_idx ON worker_jobs(project_id)`,
+  `CREATE INDEX IF NOT EXISTS worker_jobs_dependency_idx ON worker_jobs(depends_on) WHERE depends_on IS NOT NULL`,
+  `CREATE INDEX IF NOT EXISTS worker_jobs_status_idx ON worker_jobs(status, created_at) WHERE status IN ('pending', 'running', 'failed')`
+];
+var WORKER_JOB_SCHEMA_MIGRATIONS = [
+  defineStorageSchemaMigration({
+    id: "202609130001_add_durable_worker_jobs",
+    description: "Persist worker handoffs, bounded retries, and fenced processing leases",
+    statements: WORKER_JOB_SCHEMA_STATEMENTS
+  })
+];
+var WORKER_JOB_BOOTSTRAP_STATEMENTS = WORKER_JOB_SCHEMA_STATEMENTS.map(
+  (statement) => statement.replaceAll(" IF NOT EXISTS", "")
+);
+
 // ../../packages/storage/src/openai-oauth-bootstrap-statements.ts
 var OPENAI_OAUTH_BOOTSTRAP_STATEMENTS = [
   `
@@ -89255,6 +89521,192 @@ var OPENAI_OAUTH_BOOTSTRAP_STATEMENTS = [
   `CREATE INDEX oauth_provider_artifacts_expires_idx ON oauth_provider_artifacts (expires_at, model, provider_id_hash)`
 ];
 
+// ../../packages/storage/src/storage-bootstrap-incident-statements.ts
+var STORAGE_BOOTSTRAP_INCIDENT_STATEMENTS = [
+  `
+    CREATE TABLE incidents (
+      id uuid PRIMARY KEY,
+      project_id uuid NOT NULL REFERENCES projects(id) ON DELETE CASCADE,
+      service_id uuid REFERENCES services(id) ON DELETE SET NULL,
+      environment text NOT NULL DEFAULT 'production',
+      fingerprint text NOT NULL,
+      fingerprint_version text NOT NULL DEFAULT 'v1',
+      title text NOT NULL,
+      severity text NOT NULL,
+      status text NOT NULL DEFAULT 'open',
+      first_seen_at timestamptz NOT NULL,
+      last_seen_at timestamptz NOT NULL,
+      occurrence_count integer NOT NULL DEFAULT 1,
+      matched_fields text[],
+      created_at timestamptz NOT NULL DEFAULT now(),
+      updated_at timestamptz NOT NULL DEFAULT now(),
+      regressed_at timestamptz,
+      spike_detected_at timestamptz,
+      frequency_occurrences_1m integer,
+      frequency_occurrences_5m integer,
+      frequency_occurrences_1h integer,
+      frequency_occurrences_24h integer,
+      frequency_baseline_1h_per_5m double precision,
+      frequency_spike_ratio_5m_to_1h double precision,
+      frequency_has_sufficient_baseline boolean,
+      frequency_is_spiking boolean,
+      frequency_snapshot_at timestamptz,
+      latest_deployment_id uuid REFERENCES deployments(id) ON DELETE SET NULL,
+      bundle_generation_number integer NOT NULL DEFAULT 0,
+      bundle_created_at timestamptz,
+      bundle_updated_at timestamptz,
+      bundle_source_event_id uuid,
+      bundle_source_occurred_at timestamptz,
+      bundle_trigger text,
+      bundle_failure_reason text,
+      resolved_at timestamptz,
+      resolved_by_member_id uuid REFERENCES users(id) ON DELETE SET NULL,
+      UNIQUE (project_id, environment, service_id, fingerprint)
+    )
+  `,
+  `
+    CREATE TABLE processed_events (
+      event_id uuid PRIMARY KEY,
+      project_id uuid NOT NULL REFERENCES projects(id) ON DELETE CASCADE,
+      event_type text NOT NULL,
+      fingerprint text NOT NULL,
+      normalized_message text NOT NULL,
+      processed_at timestamptz NOT NULL DEFAULT now()
+    )
+  `,
+  `
+    CREATE TABLE improvement_opportunities (
+      id uuid PRIMARY KEY,
+      project_id uuid NOT NULL REFERENCES projects(id) ON DELETE CASCADE,
+      service_id uuid REFERENCES services(id) ON DELETE SET NULL,
+      service_name text NOT NULL,
+      environment text NOT NULL DEFAULT 'production',
+      kind text NOT NULL,
+      status text NOT NULL DEFAULT 'open',
+      severity text NOT NULL,
+      confidence numeric NOT NULL,
+      fingerprint text NOT NULL,
+      title text NOT NULL,
+      summary text NOT NULL,
+      occurrence_count integer NOT NULL DEFAULT 1,
+      evidence jsonb NOT NULL,
+      first_detected_at timestamptz NOT NULL,
+      last_detected_at timestamptz NOT NULL,
+      last_source_event_id uuid,
+      related_incident_ids uuid[] NOT NULL DEFAULT '{}',
+      bundle_generation_number integer NOT NULL DEFAULT 0,
+      bundle_created_at timestamptz,
+      bundle_updated_at timestamptz,
+      bundle_source_event_id uuid,
+      bundle_failure_reason text,
+      resolved_at timestamptz,
+      resolved_by_user_id uuid REFERENCES users(id) ON DELETE SET NULL,
+      snoozed_until timestamptz,
+      created_at timestamptz NOT NULL DEFAULT now(),
+      updated_at timestamptz NOT NULL DEFAULT now(),
+      UNIQUE (project_id, fingerprint)
+    )
+  `,
+  `
+    CREATE INDEX improvement_opportunities_project_status_detected_idx
+    ON improvement_opportunities (project_id, status, last_detected_at DESC)
+  `,
+  `
+    CREATE INDEX improvement_opportunities_project_kind_detected_idx
+    ON improvement_opportunities (project_id, kind, last_detected_at DESC)
+  `,
+  `
+    CREATE INDEX improvement_opportunities_project_service_env_idx
+    ON improvement_opportunities (project_id, service_id, environment)
+  `,
+  `
+    CREATE TABLE improvement_opportunity_events (
+      improvement_opportunity_id uuid NOT NULL REFERENCES improvement_opportunities(id) ON DELETE CASCADE,
+      event_id uuid NOT NULL,
+      event_type text NOT NULL,
+      occurred_at timestamptz NOT NULL,
+      PRIMARY KEY (improvement_opportunity_id, event_id)
+    )
+  `,
+  `
+    CREATE INDEX improvement_opportunity_events_detected_idx
+    ON improvement_opportunity_events (improvement_opportunity_id, occurred_at DESC, event_id DESC)
+  `,
+  `
+    CREATE TABLE bundle_generations (
+      id uuid PRIMARY KEY,
+      project_id uuid NOT NULL REFERENCES projects(id) ON DELETE CASCADE,
+      incident_id uuid REFERENCES incidents(id) ON DELETE CASCADE,
+      improvement_opportunity_id uuid REFERENCES improvement_opportunities(id) ON DELETE CASCADE,
+      bundle_type text NOT NULL,
+      generation_number integer NOT NULL,
+      source_event_id uuid NOT NULL,
+      source_occurred_at timestamptz NOT NULL,
+      trigger text NOT NULL,
+      created_at timestamptz NOT NULL,
+      updated_at timestamptz NOT NULL,
+      CHECK (
+        (incident_id IS NOT NULL AND improvement_opportunity_id IS NULL AND bundle_type = 'failure')
+        OR (incident_id IS NULL AND improvement_opportunity_id IS NOT NULL AND bundle_type = 'improvement')
+      )
+    )
+  `,
+  `
+    CREATE UNIQUE INDEX bundle_generations_incident_source_idx
+    ON bundle_generations (incident_id, source_event_id)
+    WHERE incident_id IS NOT NULL
+  `,
+  `
+    CREATE UNIQUE INDEX bundle_generations_improvement_source_idx
+    ON bundle_generations (improvement_opportunity_id, source_event_id)
+    WHERE improvement_opportunity_id IS NOT NULL
+  `,
+  `
+    CREATE INDEX bundle_generations_project_created_idx
+    ON bundle_generations (project_id, created_at DESC, bundle_type)
+  `,
+  `
+    CREATE INDEX bundle_generations_incident_generation_idx
+    ON bundle_generations (incident_id, generation_number DESC)
+  `,
+  `
+    CREATE INDEX bundle_generations_improvement_generation_idx
+    ON bundle_generations (improvement_opportunity_id, generation_number DESC)
+    WHERE improvement_opportunity_id IS NOT NULL
+  `,
+  `
+    CREATE TABLE incident_events (
+      incident_id uuid NOT NULL REFERENCES incidents(id) ON DELETE CASCADE,
+      event_id uuid NOT NULL,
+      event_type text NOT NULL,
+      event_class text NOT NULL DEFAULT 'context_signal',
+      occurred_at timestamptz NOT NULL,
+      is_sampled boolean NOT NULL DEFAULT false,
+      level text,
+      resource_route text,
+      retain_first boolean NOT NULL DEFAULT false,
+      retain_latest boolean NOT NULL DEFAULT false,
+      retain_after_deploy boolean NOT NULL DEFAULT false,
+      retain_highest_severity boolean NOT NULL DEFAULT false,
+      retain_deploy_metadata boolean NOT NULL DEFAULT false,
+      severity_rank integer NOT NULL DEFAULT 0,
+      PRIMARY KEY (incident_id, event_id)
+    )
+  `,
+  `
+    CREATE INDEX incident_events_incident_occurred_event_idx
+    ON incident_events (incident_id, occurred_at DESC, event_id DESC)
+  `,
+  `
+    CREATE INDEX incident_events_incident_level_occurred_event_idx
+    ON incident_events (incident_id, level, occurred_at DESC, event_id DESC)
+  `,
+  `
+    CREATE INDEX incident_events_incident_sampled_idx
+    ON incident_events (incident_id, is_sampled, occurred_at ASC, event_id ASC)
+  `
+];
+
 // ../../packages/storage/src/storage-bootstrap-account-analytics-statements.ts
 var STORAGE_BOOTSTRAP_ACCOUNT_ANALYTICS_STATEMENTS = [
   `
@@ -89775,187 +90227,7 @@ var STORAGE_BOOTSTRAP_STATEMENTS = [
     CREATE INDEX deployments_project_service_env_deployed_idx
     ON deployments (project_id, service_id, environment, deployed_at DESC)
   `,
-  `
-    CREATE TABLE incidents (
-      id uuid PRIMARY KEY,
-      project_id uuid NOT NULL REFERENCES projects(id) ON DELETE CASCADE,
-      service_id uuid REFERENCES services(id) ON DELETE SET NULL,
-      environment text NOT NULL DEFAULT 'production',
-      fingerprint text NOT NULL,
-      fingerprint_version text NOT NULL DEFAULT 'v1',
-      title text NOT NULL,
-      severity text NOT NULL,
-      status text NOT NULL DEFAULT 'open',
-      first_seen_at timestamptz NOT NULL,
-      last_seen_at timestamptz NOT NULL,
-      occurrence_count integer NOT NULL DEFAULT 1,
-      matched_fields text[],
-      created_at timestamptz NOT NULL DEFAULT now(),
-      updated_at timestamptz NOT NULL DEFAULT now(),
-      regressed_at timestamptz,
-      spike_detected_at timestamptz,
-      frequency_occurrences_1m integer,
-      frequency_occurrences_5m integer,
-      frequency_occurrences_1h integer,
-      frequency_occurrences_24h integer,
-      frequency_baseline_1h_per_5m double precision,
-      frequency_spike_ratio_5m_to_1h double precision,
-      frequency_has_sufficient_baseline boolean,
-      frequency_is_spiking boolean,
-      frequency_snapshot_at timestamptz,
-      latest_deployment_id uuid REFERENCES deployments(id) ON DELETE SET NULL,
-      bundle_generation_number integer NOT NULL DEFAULT 0,
-      bundle_created_at timestamptz,
-      bundle_updated_at timestamptz,
-      bundle_source_event_id uuid,
-      bundle_source_occurred_at timestamptz,
-      bundle_trigger text,
-      bundle_failure_reason text,
-      resolved_at timestamptz,
-      resolved_by_member_id uuid REFERENCES users(id) ON DELETE SET NULL,
-      UNIQUE (project_id, environment, service_id, fingerprint)
-    )
-  `,
-  `
-    CREATE TABLE processed_events (
-      event_id uuid PRIMARY KEY,
-      project_id uuid NOT NULL REFERENCES projects(id) ON DELETE CASCADE,
-      event_type text NOT NULL,
-      fingerprint text NOT NULL,
-      normalized_message text NOT NULL,
-      processed_at timestamptz NOT NULL DEFAULT now()
-    )
-  `,
-  `
-    CREATE TABLE improvement_opportunities (
-      id uuid PRIMARY KEY,
-      project_id uuid NOT NULL REFERENCES projects(id) ON DELETE CASCADE,
-      service_id uuid REFERENCES services(id) ON DELETE SET NULL,
-      service_name text NOT NULL,
-      environment text NOT NULL DEFAULT 'production',
-      kind text NOT NULL,
-      status text NOT NULL DEFAULT 'open',
-      severity text NOT NULL,
-      confidence numeric NOT NULL,
-      fingerprint text NOT NULL,
-      title text NOT NULL,
-      summary text NOT NULL,
-      occurrence_count integer NOT NULL DEFAULT 1,
-      evidence jsonb NOT NULL,
-      first_detected_at timestamptz NOT NULL,
-      last_detected_at timestamptz NOT NULL,
-      last_source_event_id uuid,
-      related_incident_ids uuid[] NOT NULL DEFAULT '{}',
-      bundle_generation_number integer NOT NULL DEFAULT 0,
-      bundle_created_at timestamptz,
-      bundle_updated_at timestamptz,
-      bundle_source_event_id uuid,
-      bundle_failure_reason text,
-      resolved_at timestamptz,
-      resolved_by_user_id uuid REFERENCES users(id) ON DELETE SET NULL,
-      snoozed_until timestamptz,
-      created_at timestamptz NOT NULL DEFAULT now(),
-      updated_at timestamptz NOT NULL DEFAULT now(),
-      UNIQUE (project_id, fingerprint)
-    )
-  `,
-  `
-    CREATE INDEX improvement_opportunities_project_status_detected_idx
-    ON improvement_opportunities (project_id, status, last_detected_at DESC)
-  `,
-  `
-    CREATE INDEX improvement_opportunities_project_kind_detected_idx
-    ON improvement_opportunities (project_id, kind, last_detected_at DESC)
-  `,
-  `
-    CREATE INDEX improvement_opportunities_project_service_env_idx
-    ON improvement_opportunities (project_id, service_id, environment)
-  `,
-  `
-    CREATE TABLE improvement_opportunity_events (
-      improvement_opportunity_id uuid NOT NULL REFERENCES improvement_opportunities(id) ON DELETE CASCADE,
-      event_id uuid NOT NULL,
-      event_type text NOT NULL,
-      occurred_at timestamptz NOT NULL,
-      PRIMARY KEY (improvement_opportunity_id, event_id)
-    )
-  `,
-  `
-    CREATE INDEX improvement_opportunity_events_detected_idx
-    ON improvement_opportunity_events (improvement_opportunity_id, occurred_at DESC, event_id DESC)
-  `,
-  `
-    CREATE TABLE bundle_generations (
-      id uuid PRIMARY KEY,
-      project_id uuid NOT NULL REFERENCES projects(id) ON DELETE CASCADE,
-      incident_id uuid REFERENCES incidents(id) ON DELETE CASCADE,
-      improvement_opportunity_id uuid REFERENCES improvement_opportunities(id) ON DELETE CASCADE,
-      bundle_type text NOT NULL,
-      generation_number integer NOT NULL,
-      source_event_id uuid NOT NULL,
-      source_occurred_at timestamptz NOT NULL,
-      trigger text NOT NULL,
-      created_at timestamptz NOT NULL,
-      updated_at timestamptz NOT NULL,
-      CHECK (
-        (incident_id IS NOT NULL AND improvement_opportunity_id IS NULL AND bundle_type = 'failure')
-        OR (incident_id IS NULL AND improvement_opportunity_id IS NOT NULL AND bundle_type = 'improvement')
-      )
-    )
-  `,
-  `
-    CREATE UNIQUE INDEX bundle_generations_incident_source_idx
-    ON bundle_generations (incident_id, source_event_id)
-    WHERE incident_id IS NOT NULL
-  `,
-  `
-    CREATE UNIQUE INDEX bundle_generations_improvement_source_idx
-    ON bundle_generations (improvement_opportunity_id, source_event_id)
-    WHERE improvement_opportunity_id IS NOT NULL
-  `,
-  `
-    CREATE INDEX bundle_generations_project_created_idx
-    ON bundle_generations (project_id, created_at DESC, bundle_type)
-  `,
-  `
-    CREATE INDEX bundle_generations_incident_generation_idx
-    ON bundle_generations (incident_id, generation_number DESC)
-  `,
-  `
-    CREATE INDEX bundle_generations_improvement_generation_idx
-    ON bundle_generations (improvement_opportunity_id, generation_number DESC)
-    WHERE improvement_opportunity_id IS NOT NULL
-  `,
-  `
-    CREATE TABLE incident_events (
-      incident_id uuid NOT NULL REFERENCES incidents(id) ON DELETE CASCADE,
-      event_id uuid NOT NULL,
-      event_type text NOT NULL,
-      event_class text NOT NULL DEFAULT 'context_signal',
-      occurred_at timestamptz NOT NULL,
-      is_sampled boolean NOT NULL DEFAULT false,
-      level text,
-      retain_first boolean NOT NULL DEFAULT false,
-      retain_latest boolean NOT NULL DEFAULT false,
-      retain_after_deploy boolean NOT NULL DEFAULT false,
-      retain_highest_severity boolean NOT NULL DEFAULT false,
-      retain_deploy_metadata boolean NOT NULL DEFAULT false,
-      severity_rank integer NOT NULL DEFAULT 0,
-      PRIMARY KEY (incident_id, event_id)
-    )
-  `,
-  `
-    CREATE INDEX incident_events_incident_occurred_event_idx
-    ON incident_events (incident_id, occurred_at DESC, event_id DESC)
-  `,
-  `
-    CREATE INDEX incident_events_incident_level_occurred_event_idx
-    ON incident_events (incident_id, level, occurred_at DESC, event_id DESC)
-  `,
-  `
-    CREATE INDEX incident_events_incident_sampled_idx
-    ON incident_events (incident_id, is_sampled, occurred_at ASC, event_id ASC)
-  `,
+  ...STORAGE_BOOTSTRAP_INCIDENT_STATEMENTS,
   `
     CREATE TABLE weekly_report_channels (
       id uuid PRIMARY KEY,
@@ -90409,18 +90681,19 @@ var STORAGE_BOOTSTRAP_STATEMENTS2 = [
   ...STORAGE_BOOTSTRAP_STATEMENTS,
   ...OPENAI_OAUTH_BOOTSTRAP_STATEMENTS,
   ...AVAILABILITY_CHECK_BOOTSTRAP_STATEMENTS,
-  ...ANALYTICS_BOOTSTRAP_STATEMENTS
+  ...ANALYTICS_BOOTSTRAP_STATEMENTS,
+  ...WORKER_JOB_BOOTSTRAP_STATEMENTS
 ];
 
 // ../../packages/storage/src/migrations.ts
 var STORAGE_BOOTSTRAP_SQL = STORAGE_BOOTSTRAP_STATEMENTS2.join(";\n\n");
 
 // ../../packages/storage/src/availability-check-schema-migrations.ts
-var import_node_crypto7 = require("node:crypto");
+var import_node_crypto8 = require("node:crypto");
 function defineAvailabilityCheckStorageSchemaMigration(input2) {
   return {
     ...input2,
-    checksum: (0, import_node_crypto7.createHash)("sha256").update(JSON.stringify(input2)).digest("hex")
+    checksum: (0, import_node_crypto8.createHash)("sha256").update(JSON.stringify(input2)).digest("hex")
   };
 }
 var AVAILABILITY_CHECK_STORAGE_SCHEMA_MIGRATIONS = [
@@ -90664,11 +90937,11 @@ var AVAILABILITY_CHECK_STORAGE_SCHEMA_MIGRATIONS = [
 ];
 
 // ../../packages/storage/src/analytics-schema-migrations.ts
-var import_node_crypto8 = require("node:crypto");
+var import_node_crypto9 = require("node:crypto");
 function defineAnalyticsStorageSchemaMigration(input2) {
   return {
     ...input2,
-    checksum: (0, import_node_crypto8.createHash)("sha256").update(JSON.stringify(input2)).digest("hex")
+    checksum: (0, import_node_crypto9.createHash)("sha256").update(JSON.stringify(input2)).digest("hex")
   };
 }
 var analyticsAnalysisKindCheck2 = "('usage_summary', 'route_health', 'funnel_dropoff', 'journey_friction', 'feature_usage', 'incident_impact', 'deploy_comparison', 'conversion_path')";
@@ -91456,15 +91729,6 @@ var ANALYTICS_STORAGE_SCHEMA_MIGRATIONS = [
   })
 ];
 
-// ../../packages/storage/src/schema-migration-definition.ts
-var import_node_crypto9 = require("node:crypto");
-function defineStorageSchemaMigration(input2) {
-  return {
-    ...input2,
-    checksum: (0, import_node_crypto9.createHash)("sha256").update(JSON.stringify(input2)).digest("hex")
-  };
-}
-
 // ../../packages/storage/src/openai-oauth-schema-migrations.ts
 var OPENAI_OAUTH_STORAGE_SCHEMA_MIGRATIONS = [
   defineStorageSchemaMigration({
@@ -92552,7 +92816,12 @@ var LATE_STORAGE_SCHEMA_MIGRATIONS = [
 // ../../packages/storage/src/schema-migrations-catalog.ts
 var STORAGE_SCHEMA_MIGRATIONS = [
   ...EARLY_STORAGE_SCHEMA_MIGRATIONS,
-  ...LATE_STORAGE_SCHEMA_MIGRATIONS
+  ...LATE_STORAGE_SCHEMA_MIGRATIONS,
+  defineStorageSchemaMigration({
+    id: "202609160001_add_browser_resource_routes",
+    description: "Retain sanitized browser resource routes independently of raw event sampling.",
+    statements: ["ALTER TABLE incident_events ADD COLUMN IF NOT EXISTS resource_route text"]
+  })
 ];
 
 // ../../packages/storage/src/schema-migrations.ts
@@ -92560,7 +92829,8 @@ var STORAGE_SCHEMA_MIGRATIONS2 = [
   ...STORAGE_SCHEMA_MIGRATIONS,
   ...AVAILABILITY_CHECK_STORAGE_SCHEMA_MIGRATIONS,
   ...ANALYTICS_STORAGE_SCHEMA_MIGRATIONS,
-  ...OPENAI_OAUTH_STORAGE_SCHEMA_MIGRATIONS
+  ...OPENAI_OAUTH_STORAGE_SCHEMA_MIGRATIONS,
+  ...WORKER_JOB_SCHEMA_MIGRATIONS
 ].sort((left, right) => left.id.localeCompare(right.id));
 
 // ../cli/src/ingest-command.ts
@@ -92572,6 +92842,39 @@ var import_node_crypto10 = require("node:crypto");
 var import_promises5 = require("node:fs/promises");
 var import_node_path6 = require("node:path");
 
+// ../../packages/bundle-engine/src/browser-resource-context.ts
+function buildBrowserResourceContext(browserEvent, incident, events2) {
+  const resource = describeBrowserResource(browserEvent);
+  if (resource === null) return void 0;
+  const routes = [];
+  for (const event of events2) {
+    if (event.event_type !== "frontend_exception" || event.service.name !== incident.service_name || event.service.environment !== incident.environment)
+      continue;
+    const candidate = describeBrowserResource(event.payload.browser_event);
+    if (candidate !== null && candidate.host === resource.host && candidate.path === resource.path && candidate.type === resource.type) {
+      routes.push(event.payload.route ?? null);
+    }
+  }
+  return {
+    version: 1,
+    ...resource,
+    diagnosis: browserResourceDiagnosis(resource),
+    routes: incident.resource_routes ?? summarizeResourceRoutes(routes, incident.occurrence_count)
+  };
+}
+
+// ../../packages/bundle-engine/src/deployment-context.ts
+function selectScopedDeployments(input2) {
+  const cutoff = Date.parse(input2.occurredAt);
+  const configuredAt = Date.parse(input2.configuredDeployedAt ?? "");
+  return input2.envelopes.filter(
+    (event) => event.event_type === "deploy_metadata" && event.service.name === input2.service && event.service.environment === input2.environment && event.payload.environment === input2.environment && Date.parse(event.payload.deployed_at) <= cutoff && // A caller-provided workload history row can be newer than the raw window.
+    (!(configuredAt <= cutoff) || Date.parse(event.payload.deployed_at) >= configuredAt)
+  ).sort(
+    (left, right) => Date.parse(left.payload.deployed_at) - Date.parse(right.payload.deployed_at) || left.event_id.localeCompare(right.event_id)
+  );
+}
+
 // ../../packages/bundle-engine/src/frontend-context.ts
 function toIsoTimestamp(value) {
   return new Date(value).toISOString();
@@ -92645,9 +92948,9 @@ function stableJson2(value) {
   if (Array.isArray(value)) {
     return `[${value.map((entry) => stableJson2(entry)).join(",")}]`;
   }
-  const record = value;
-  const keys2 = Object.keys(record).sort();
-  return `{${keys2.map((key) => `${JSON.stringify(key)}:${stableJson2(record[key])}`).join(",")}}`;
+  const record2 = value;
+  const keys2 = Object.keys(record2).sort();
+  return `{${keys2.map((key) => `${JSON.stringify(key)}:${stableJson2(record2[key])}`).join(",")}}`;
 }
 function buildFrontendBreadcrumbKey(input2) {
   return `${input2.breadcrumb_type}:${input2.ts}:${input2.route ?? ""}:${stableJson2(input2.data)}`;
@@ -92957,6 +93260,7 @@ function buildRequestContext(envelopes) {
   if (exceptionEvent === null) {
     return null;
   }
+  if (exceptionEvent.payload.request.method.toUpperCase() === "UNKNOWN") return null;
   return {
     version: 1,
     method: exceptionEvent.payload.request.method,
@@ -93020,10 +93324,11 @@ function buildSummaryGuidance(input2) {
   }
   if (input2.opaqueBrowserError) {
     if (input2.browserEvent?.kind === "resource_error") {
+      const resource = describeBrowserResource(input2.browserEvent);
       return {
-        likely_cause: "The browser reported a resource load error without a usable application stack.",
+        likely_cause: browserResourceDiagnosis(resource),
         confidence: 0.35,
-        recommended_action: "Inspect the captured resource target, browser network failures, CSP rules, and cross-origin asset configuration."
+        recommended_action: "Check the affected resource and routes, browser network failures, CSP and provider availability." + (resource?.optional_candidate === true ? " If the dependency is optional for your app, review a resource-scoped noise rule." : " Verify whether application functionality is affected.")
       };
     }
     return {
@@ -93277,21 +93582,30 @@ function buildBundle(input2) {
   const responseContext = buildResponseContext(sourceEnvelopes);
   const logsContext = buildLogsContext(sourceEnvelopes);
   const frontendContext = buildFrontendContext(sourceEnvelopes);
+  const deploymentEnvelopes = selectScopedDeployments({
+    envelopes: sourceEnvelopes,
+    service: input2.incident.service_name,
+    environment: input2.incident.environment,
+    occurredAt: input2.bundleMetadata.source_occurred_at,
+    configuredDeployedAt: input2.configuredDeploy?.deployed_at ?? null
+  });
   const deployContext = buildDeployContext(
-    sourceEnvelopes,
+    deploymentEnvelopes,
     input2.job.trigger,
     input2.configuredDeploy
   );
   const runtimeContext = buildRuntimeContext(sourceEnvelopes);
-  const gitContext = buildGitContext(sourceEnvelopes, input2.configuredDeploy);
+  const gitContext = buildGitContext(deploymentEnvelopes, input2.configuredDeploy);
   const deviceContext = buildDeviceContext(sourceEnvelopes);
   const dependenciesContext = buildDependenciesContext(
     input2.incident,
     errorContext,
     requestContext
   );
-  const browserEvent = getPrimaryBrowserExceptionEvent(sourceEnvelopes, primarySignalEnvelope);
+  const browserEventCandidate = getPrimaryBrowserExceptionEvent(sourceEnvelopes, primarySignalEnvelope);
+  const browserEvent = browserEventCandidate?.kind === "resource_error" && primarySignalEnvelope !== null && !isFrontendExceptionEnvelope(primarySignalEnvelope) ? null : browserEventCandidate;
   const opaqueBrowserError = isOpaqueBrowserError(errorContext, browserEvent);
+  const resourceContext = buildBrowserResourceContext(browserEvent, input2.incident, sourceEnvelopes);
   const primarySignalType = primarySignalEnvelope !== null ? mapSignalType(primarySignalEnvelope.event_type) : inferSignalTypeFromSourceEventTypes(sourceEventTypes);
   const primarySourceEvent = errorContext?.name ?? sourceEventTypes[0] ?? "backend_exception";
   const firstSeenAt = new Date(input2.incident.first_seen_at).toISOString();
@@ -93365,6 +93679,7 @@ function buildBundle(input2) {
       regression_suspected: input2.job.trigger === "regression_reopen"
     },
     context: {
+      ...resourceContext === void 0 ? {} : { resource_failure: resourceContext },
       error: errorContext,
       request: requestContext,
       response: responseContext,
@@ -93418,7 +93733,9 @@ function stableStringify(value) {
     return `[${value.map((item) => stableStringify(item)).join(",")}]`;
   }
   if (value !== null && typeof value === "object") {
-    const entries = Object.entries(value).sort(([left], [right]) => left.localeCompare(right));
+    const entries = Object.entries(value).sort(
+      ([left], [right]) => left.localeCompare(right)
+    );
     return `{${entries.map(([key, entryValue]) => `${JSON.stringify(key)}:${stableStringify(entryValue)}`).join(",")}}`;
   }
   return JSON.stringify(value);
@@ -93426,8 +93743,8 @@ function stableStringify(value) {
 function shellQuote(value) {
   return `'${value.replaceAll("'", `'\\''`)}'`;
 }
-function sortRecordEntries(record) {
-  return Object.entries(record).sort(([left], [right]) => left.localeCompare(right));
+function sortRecordEntries(record2) {
+  return Object.entries(record2).sort(([left], [right]) => left.localeCompare(right));
 }
 var REPLAY_HEADER_PRIORITY = [
   "authorization",
@@ -93497,7 +93814,10 @@ function normalizeReplayJsonValue(value) {
   }
   if (value !== null && typeof value === "object") {
     return Object.fromEntries(
-      Object.entries(value).map(([key, entryValue]) => [key, normalizeReplayJsonValue(entryValue)])
+      Object.entries(value).map(([key, entryValue]) => [
+        key,
+        normalizeReplayJsonValue(entryValue)
+      ])
     );
   }
   return value;
@@ -93518,7 +93838,10 @@ function normalizeReplayQueryValue(value) {
   }
   if (value !== null && typeof value === "object") {
     return Object.fromEntries(
-      sortRecordEntries(value).map(([key, entryValue]) => [key, normalizeReplayQueryValue(entryValue)])
+      sortRecordEntries(value).map(([key, entryValue]) => [
+        key,
+        normalizeReplayQueryValue(entryValue)
+      ])
     );
   }
   return value;
@@ -93534,7 +93857,9 @@ function hasStructuredQueryAmbiguity(value) {
     return value.some((item) => hasStructuredQueryAmbiguity(item));
   }
   if (value !== null && typeof value === "object") {
-    return Object.values(value).some((item) => hasStructuredQueryAmbiguity(item));
+    return Object.values(value).some(
+      (item) => hasStructuredQueryAmbiguity(item)
+    );
   }
   return false;
 }
@@ -93545,7 +93870,9 @@ function buildStructuredReplayQuery(query) {
   return hasStructuredQueryAmbiguity(normalizedQuery) ? normalizedQuery : void 0;
 }
 function buildReplayHeaders(headers) {
-  const entries = sortRecordEntries(headers).filter(([headerName]) => !DROPPED_REPLAY_HEADERS.has(headerName.toLowerCase())).map(([headerName, headerValue]) => [headerName, normalizeHeaderValue(headerValue)]);
+  const entries = sortRecordEntries(headers).filter(([headerName]) => !DROPPED_REPLAY_HEADERS.has(headerName.toLowerCase())).map(
+    ([headerName, headerValue]) => [headerName, normalizeHeaderValue(headerValue)]
+  );
   entries.sort(([left], [right]) => {
     const leftPriority = REPLAY_HEADER_PRIORITY.indexOf(left.toLowerCase());
     const rightPriority = REPLAY_HEADER_PRIORITY.indexOf(right.toLowerCase());
@@ -93571,7 +93898,9 @@ function expandHeaderValues(headers) {
   });
 }
 function getHeaderValues(headers, headerName) {
-  const matchedEntry = sortRecordEntries(headers).find(([candidateName]) => candidateName.toLowerCase() === headerName.toLowerCase());
+  const matchedEntry = sortRecordEntries(headers).find(
+    ([candidateName]) => candidateName.toLowerCase() === headerName.toLowerCase()
+  );
   if (matchedEntry === void 0) {
     return [];
   }
@@ -93633,6 +93962,9 @@ function buildDeterministicRequestUrl(request) {
   const protocol = typeof protoHeader === "string" && protoHeader.length > 0 ? protoHeader : "https";
   const host = typeof forwardedHostHeader === "string" && forwardedHostHeader.length > 0 ? forwardedHostHeader : typeof hostHeader === "string" && hostHeader.length > 0 ? hostHeader : "example.invalid";
   const url = new URL(request.path, `${protocol}://${host}`);
+  if (!["http:", "https:"].includes(url.protocol) || url.username || url.password) {
+    throw new Error("request_url_invalid");
+  }
   for (const [key, rawValue] of sortRecordEntries(request.query)) {
     if (Array.isArray(rawValue)) {
       for (const item of rawValue) {
@@ -93656,22 +93988,52 @@ function buildReproduction(bundle) {
     };
   }
   const method = request.method.toUpperCase();
-  const url = buildDeterministicRequestUrl(request);
+  if (!/^[A-Z][A-Z0-9_-]{0,31}$/.test(method) || method === "UNKNOWN") {
+    return {
+      possible: false,
+      confidence: 0.1,
+      reason: "request_method_unavailable",
+      artifacts: null,
+      feasibility_reference: null
+    };
+  }
+  let url;
+  try {
+    url = buildDeterministicRequestUrl(request);
+  } catch {
+    return {
+      possible: false,
+      confidence: 0.1,
+      reason: "request_url_invalid",
+      artifacts: null,
+      feasibility_reference: null
+    };
+  }
   const replayHeaders = buildReplayHeaders(request.headers);
   const contentType = getPrimaryContentType(replayHeaders);
   const structuredReplayQuery = buildStructuredReplayQuery(request.query);
-  const headerParts = expandHeaderValues(replayHeaders).map(([headerName, headerValue]) => `${headerName}:${headerValue}`);
-  const curlHeaderParts = headerParts.map((header2) => `-H ${shellQuote(header2.replace(":", ": "))}`);
+  const headerParts = expandHeaderValues(replayHeaders).map(
+    ([headerName, headerValue]) => `${headerName}:${headerValue}`
+  );
+  const curlHeaderParts = headerParts.map(
+    (header2) => `-H ${shellQuote(header2.replace(":", ": "))}`
+  );
   const requestBody = buildReplayBody(request.body, replayHeaders);
   const jsonSpecBody = contentType === "application/json" ? request.body === void 0 ? null : normalizeReplayJsonValue(request.body) : typeof request.body === "string" ? requestBody : request.body === null || request.body === void 0 ? null : request.body;
   const curlBodyPart = requestBody === null ? [] : [`--data-raw ${shellQuote(requestBody)}`];
-  const curl = [`curl -X ${method} ${shellQuote(url)}`, ...curlHeaderParts, ...curlBodyPart].join(" ");
-  const httpieBase = [`http ${method} ${shellQuote(url)}`, ...headerParts.map((header2) => shellQuote(header2))].join(" ");
+  const curl = [`curl -X ${method} ${shellQuote(url)}`, ...curlHeaderParts, ...curlBodyPart].join(
+    " "
+  );
+  const httpieBase = [
+    `http ${method} ${shellQuote(url)}`,
+    ...headerParts.map((header2) => shellQuote(header2))
+  ].join(" ");
   const httpie = requestBody === null ? httpieBase : `printf '%s' ${shellQuote(requestBody)} | ${httpieBase}`;
+  const hasRequestTarget = new URL(url).hostname !== "example.invalid";
   return {
-    possible: true,
-    confidence: 0.8,
-    reason: "request_context_available",
+    possible: hasRequestTarget,
+    confidence: hasRequestTarget ? 0.8 : 0.1,
+    reason: hasRequestTarget ? "request_context_available" : "request_target_unavailable",
     artifacts: {
       curl,
       httpie,
@@ -93699,6 +94061,159 @@ function resolveWorkspacePath(rootDirectory, targetPath) {
   return (0, import_node_path5.isAbsolute)(targetPath) ? targetPath : (0, import_node_path5.join)(rootDirectory, targetPath);
 }
 
+// ../cli/src/local-processing-state.ts
+var EVENT_TYPE_SET = new Set(EventTypeValues);
+function isEventType(value) {
+  return typeof value === "string" && EVENT_TYPE_SET.has(value);
+}
+function parseIncidentState(candidate) {
+  if (!isRecord5(candidate)) {
+    return null;
+  }
+  if (candidate["source"] !== "local" || candidate["status"] !== "open" && candidate["status"] !== "resolved") {
+    return null;
+  }
+  const sourceEvents = candidate["source_events"];
+  if (!Array.isArray(sourceEvents)) {
+    return null;
+  }
+  const validatedSourceEvents = [];
+  for (const sourceEvent of sourceEvents) {
+    const validated = validateEvent(sourceEvent);
+    if (!validated.success) {
+      return null;
+    }
+    validatedSourceEvents.push(validated.data);
+  }
+  const matchedFields = candidate["matched_fields"];
+  const sourceEventTypes = candidate["source_event_types"];
+  if (!Array.isArray(matchedFields) || !matchedFields.every((value) => typeof value === "string")) {
+    return null;
+  }
+  if (!Array.isArray(sourceEventTypes) || !sourceEventTypes.every(isEventType)) {
+    return null;
+  }
+  const severity = candidate["severity"];
+  if (severity !== "low" && severity !== "medium" && severity !== "high" && severity !== "critical") {
+    return null;
+  }
+  const status = candidate["status"];
+  if (status !== "open" && status !== "resolved") {
+    return null;
+  }
+  const requiredStringKeys = [
+    "incident_id",
+    "project_id",
+    "service_id",
+    "service_name",
+    "environment",
+    "fingerprint",
+    "fingerprint_version",
+    "title",
+    "first_seen_at",
+    "last_seen_at",
+    "source_event_id",
+    "source_occurred_at",
+    "bundle_path",
+    "reproduction_path"
+  ];
+  for (const key of requiredStringKeys) {
+    if (typeof candidate[key] !== "string") {
+      return null;
+    }
+  }
+  if (typeof candidate["occurrence_count"] !== "number" || typeof candidate["generation_number"] !== "number") {
+    return null;
+  }
+  const serviceRuntime = candidate["service_runtime"];
+  const serviceFramework = candidate["service_framework"];
+  if (serviceRuntime !== null && typeof serviceRuntime !== "string") {
+    return null;
+  }
+  if (serviceFramework !== null && typeof serviceFramework !== "string") {
+    return null;
+  }
+  const incidentId = candidate["incident_id"];
+  const projectId = candidate["project_id"];
+  const serviceId = candidate["service_id"];
+  const serviceName = candidate["service_name"];
+  const environment = candidate["environment"];
+  const incidentFingerprint = candidate["fingerprint"];
+  const fingerprintVersion2 = candidate["fingerprint_version"];
+  const title = candidate["title"];
+  const firstSeenAt = candidate["first_seen_at"];
+  const lastSeenAt = candidate["last_seen_at"];
+  const occurrenceCount = candidate["occurrence_count"];
+  const sourceEventId = candidate["source_event_id"];
+  const sourceOccurredAt = candidate["source_occurred_at"];
+  const bundlePath = candidate["bundle_path"];
+  const reproductionPath = candidate["reproduction_path"];
+  const generationNumber = candidate["generation_number"];
+  const normalizedSourceEventTypes = [...sourceEventTypes].sort();
+  return {
+    incident_id: incidentId,
+    source: "local",
+    project_id: projectId,
+    service_id: serviceId,
+    service_name: serviceName,
+    service_runtime: serviceRuntime,
+    service_framework: serviceFramework,
+    environment,
+    fingerprint: incidentFingerprint,
+    fingerprint_version: fingerprintVersion2,
+    title,
+    severity,
+    status,
+    first_seen_at: firstSeenAt,
+    last_seen_at: lastSeenAt,
+    occurrence_count: occurrenceCount,
+    source_event_id: sourceEventId,
+    source_occurred_at: sourceOccurredAt,
+    source_event_types: normalizedSourceEventTypes,
+    matched_fields: [...matchedFields].sort(),
+    bundle_path: bundlePath,
+    reproduction_path: reproductionPath,
+    generation_number: generationNumber,
+    source_events: validatedSourceEvents.sort(compareEventEnvelopes)
+  };
+}
+function parseState(rawState) {
+  const parsed = JSON.parse(rawState);
+  if (!isRecord5(parsed) || parsed["version"] !== 1) {
+    return null;
+  }
+  const lastProcessedEventFile = parsed["last_processed_event_file"];
+  if (lastProcessedEventFile !== null && typeof lastProcessedEventFile !== "string") {
+    return null;
+  }
+  const incidents = parsed["incidents"];
+  if (!isRecord5(incidents)) {
+    return null;
+  }
+  const parsedIncidents = {};
+  for (const [incidentId, incidentValue] of Object.entries(incidents).sort(
+    ([left], [right]) => left.localeCompare(right)
+  )) {
+    const incident = parseIncidentState(incidentValue);
+    if (incident === null || incident.incident_id !== incidentId) {
+      return null;
+    }
+    parsedIncidents[incidentId] = incident;
+  }
+  return {
+    version: 1,
+    last_processed_event_file: lastProcessedEventFile,
+    incidents: parsedIncidents
+  };
+}
+function compareEventEnvelopes(left, right) {
+  const occurredAtComparison = left.occurred_at.localeCompare(right.occurred_at);
+  if (occurredAtComparison !== 0) {
+    return occurredAtComparison;
+  }
+  return left.event_id.localeCompare(right.event_id);
+}
+
 // ../cli/src/process-command.ts
 var LOCAL_EVENTS_DIRECTORY_PATH = ".debugbundle/local/events";
 var LOCAL_STATE_FILE_PATH = ".debugbundle/local/state.json";
@@ -93709,10 +94224,6 @@ var CLI_SDK = {
   name: "debugbundle-cli",
   version: "0.1.0"
 };
-var EVENT_TYPE_SET = new Set(EventTypeValues);
-function isEventType(value) {
-  return typeof value === "string" && EVENT_TYPE_SET.has(value);
-}
 function inferSeverity2(event, capturePreset, incidentKind = "immediate") {
   if (incidentKind === "request_anomaly") {
     return "medium";
@@ -93720,7 +94231,8 @@ function inferSeverity2(event, capturePreset, incidentKind = "immediate") {
   if (event.event_type === "request_event") {
     return classifyRequestStatus({ responseStatus: event.payload.response_status, capturePreset }) === "incident_signal" ? "high" : "low";
   }
-  if (event.event_type === "backend_exception" || event.event_type === "frontend_exception") {
+  if (event.event_type === "frontend_exception") return inferFrontendExceptionSeverity(event);
+  if (event.event_type === "backend_exception") {
     return "high";
   }
   if (event.event_type === "error_suppressed") {
@@ -93740,13 +94252,6 @@ function severityRank(severity) {
       return 1;
   }
 }
-function compareEventEnvelopes(left, right) {
-  const occurredAtComparison = left.occurred_at.localeCompare(right.occurred_at);
-  if (occurredAtComparison !== 0) {
-    return occurredAtComparison;
-  }
-  return left.event_id.localeCompare(right.event_id);
-}
 function classifyEnvelope(envelope, capturePreset) {
   return classifyEvent(
     envelope.event_type,
@@ -93838,9 +94343,9 @@ function stableJson3(value) {
   if (Array.isArray(value)) {
     return `[${value.map((entry) => stableJson3(entry)).join(",")}]`;
   }
-  const record = value;
-  const keys2 = Object.keys(record).sort();
-  return `{${keys2.map((key) => `${JSON.stringify(key)}:${stableJson3(record[key])}`).join(",")}}`;
+  const record2 = value;
+  const keys2 = Object.keys(record2).sort();
+  return `{${keys2.map((key) => `${JSON.stringify(key)}:${stableJson3(record2[key])}`).join(",")}}`;
 }
 function buildRequestAnomalyFingerprint(input2) {
   return (0, import_node_crypto10.createHash)("sha256").update(
@@ -93993,144 +94498,6 @@ async function pathExists4(path, stat) {
     throw error;
   }
 }
-function parseIncidentState(candidate) {
-  if (!isRecord5(candidate)) {
-    return null;
-  }
-  if (candidate["source"] !== "local" || candidate["status"] !== "open" && candidate["status"] !== "resolved") {
-    return null;
-  }
-  const sourceEvents = candidate["source_events"];
-  if (!Array.isArray(sourceEvents)) {
-    return null;
-  }
-  const validatedSourceEvents = [];
-  for (const sourceEvent of sourceEvents) {
-    const validated = validateEvent(sourceEvent);
-    if (!validated.success) {
-      return null;
-    }
-    validatedSourceEvents.push(validated.data);
-  }
-  const matchedFields = candidate["matched_fields"];
-  const sourceEventTypes = candidate["source_event_types"];
-  if (!Array.isArray(matchedFields) || !matchedFields.every((value) => typeof value === "string")) {
-    return null;
-  }
-  if (!Array.isArray(sourceEventTypes) || !sourceEventTypes.every(isEventType)) {
-    return null;
-  }
-  const severity = candidate["severity"];
-  if (severity !== "low" && severity !== "medium" && severity !== "high" && severity !== "critical") {
-    return null;
-  }
-  const status = candidate["status"];
-  if (status !== "open" && status !== "resolved") {
-    return null;
-  }
-  const requiredStringKeys = [
-    "incident_id",
-    "project_id",
-    "service_id",
-    "service_name",
-    "environment",
-    "fingerprint",
-    "fingerprint_version",
-    "title",
-    "first_seen_at",
-    "last_seen_at",
-    "source_event_id",
-    "source_occurred_at",
-    "bundle_path",
-    "reproduction_path"
-  ];
-  for (const key of requiredStringKeys) {
-    if (typeof candidate[key] !== "string") {
-      return null;
-    }
-  }
-  if (typeof candidate["occurrence_count"] !== "number" || typeof candidate["generation_number"] !== "number") {
-    return null;
-  }
-  const serviceRuntime = candidate["service_runtime"];
-  const serviceFramework = candidate["service_framework"];
-  if (serviceRuntime !== null && typeof serviceRuntime !== "string") {
-    return null;
-  }
-  if (serviceFramework !== null && typeof serviceFramework !== "string") {
-    return null;
-  }
-  const incidentId = candidate["incident_id"];
-  const projectId = candidate["project_id"];
-  const serviceId = candidate["service_id"];
-  const serviceName = candidate["service_name"];
-  const environment = candidate["environment"];
-  const incidentFingerprint = candidate["fingerprint"];
-  const fingerprintVersion = candidate["fingerprint_version"];
-  const title = candidate["title"];
-  const firstSeenAt = candidate["first_seen_at"];
-  const lastSeenAt = candidate["last_seen_at"];
-  const occurrenceCount = candidate["occurrence_count"];
-  const sourceEventId = candidate["source_event_id"];
-  const sourceOccurredAt = candidate["source_occurred_at"];
-  const bundlePath = candidate["bundle_path"];
-  const reproductionPath = candidate["reproduction_path"];
-  const generationNumber = candidate["generation_number"];
-  const normalizedSourceEventTypes = [...sourceEventTypes].sort();
-  return {
-    incident_id: incidentId,
-    source: "local",
-    project_id: projectId,
-    service_id: serviceId,
-    service_name: serviceName,
-    service_runtime: serviceRuntime,
-    service_framework: serviceFramework,
-    environment,
-    fingerprint: incidentFingerprint,
-    fingerprint_version: fingerprintVersion,
-    title,
-    severity,
-    status,
-    first_seen_at: firstSeenAt,
-    last_seen_at: lastSeenAt,
-    occurrence_count: occurrenceCount,
-    source_event_id: sourceEventId,
-    source_occurred_at: sourceOccurredAt,
-    source_event_types: normalizedSourceEventTypes,
-    matched_fields: [...matchedFields].sort(),
-    bundle_path: bundlePath,
-    reproduction_path: reproductionPath,
-    generation_number: generationNumber,
-    source_events: validatedSourceEvents.sort(compareEventEnvelopes)
-  };
-}
-function parseState(rawState) {
-  const parsed = JSON.parse(rawState);
-  if (!isRecord5(parsed) || parsed["version"] !== 1) {
-    return null;
-  }
-  const lastProcessedEventFile = parsed["last_processed_event_file"];
-  if (lastProcessedEventFile !== null && typeof lastProcessedEventFile !== "string") {
-    return null;
-  }
-  const incidents = parsed["incidents"];
-  if (!isRecord5(incidents)) {
-    return null;
-  }
-  const parsedIncidents = {};
-  for (const [incidentId, incidentValue] of Object.entries(incidents).sort(([left], [right]) => left.localeCompare(right))) {
-    const incident = parseIncidentState(incidentValue);
-    if (incident === null || incident.incident_id !== incidentId) {
-      return null;
-    }
-    parsedIncidents[incidentId] = incident;
-  }
-  return {
-    version: 1,
-    last_processed_event_file: lastProcessedEventFile,
-    incidents: parsedIncidents
-  };
-}
 async function readState(statePath, readFile, stat) {
   if (!await pathExists4(statePath, stat)) {
     return null;
@@ -94264,7 +94631,7 @@ async function processCommand(input2, dependencies = {}) {
         mergedIncidentIds: /* @__PURE__ */ new Set([incidentId]),
         signalEventTypes: /* @__PURE__ */ new Set(),
         traceIds: /* @__PURE__ */ new Set(),
-        title: normalizedEvent.normalized_message,
+        title: normalizedEvent.incident_title ?? normalizedEvent.normalized_message,
         kind: "immediate",
         severity: inferSeverity2(event, capturePreset)
       };
@@ -94274,7 +94641,7 @@ async function processCommand(input2, dependencies = {}) {
       aggregate.newEvents.push(event);
       aggregate.signalEventTypes.add(event.event_type);
       const traceId = getTraceId(event);
-      if (traceId !== null) {
+      if (traceId !== null && normalizedEvent.resource_type === void 0) {
         aggregate.traceIds.add(traceId);
         const traceCorrelationGroup = traceCorrelationGroups.get(traceId) ?? {
           incidentIds: /* @__PURE__ */ new Set(),
@@ -94366,7 +94733,7 @@ async function processCommand(input2, dependencies = {}) {
       service_framework: latestSignalEvent.service.framework ?? existing?.service_framework ?? null,
       environment: aggregate.environment,
       fingerprint: aggregate.fingerprint,
-      fingerprint_version: FINGERPRINT_VERSION,
+      fingerprint_version: aggregate.kind === "request_anomaly" ? FINGERPRINT_VERSION : fingerprintVersion(normalizeEvent(latestSignalEvent)),
       title: aggregate.title,
       severity,
       status: existingIncidents.some((incidentState) => incidentState.status === "resolved") ? "open" : existing?.status ?? "open",
@@ -99915,7 +100282,7 @@ var zodToJsonSchema = (schema, options) => {
 var package_default = {
   name: "@debugbundle/mcp",
   mcpName: "com.debugbundle/mcp",
-  version: "1.8.0",
+  version: "1.8.2",
   private: false,
   description: "MCP server for runtime error reporting, incident response, health checks, debug bundles, and product analytics",
   license: "Apache-2.0",