@bilalimamoglu/sift 0.3.1 → 0.3.2

package/dist/index.js

@@ -166,6 +166,209 @@ var testStatusPublicDiagnoseContractSchema = testStatusDiagnoseContractSchema.om
 function parseTestStatusProviderSupplement(input) {
   return testStatusProviderSupplementSchema.parse(JSON.parse(input));
 }
+var extendedBucketSpecs = [
+  {
+    prefix: "snapshot mismatch:",
+    type: "snapshot_mismatch",
+    label: "snapshot mismatch",
+    genericTitle: "Snapshot mismatches",
+    defaultCoverage: "failed",
+    rootCauseConfidence: 0.84,
+    why: "it contains the failing snapshot expectation behind this bucket",
+    fix: "Update the snapshots if these output changes are intentional, then rerun the suite."
+  },
+  {
+    prefix: "timeout:",
+    type: "timeout_failure",
+    label: "timeout",
+    genericTitle: "Timeout failures",
+    defaultCoverage: "mixed",
+    rootCauseConfidence: 0.9,
+    why: "it contains the test or fixture that exceeded the timeout threshold",
+    fix: "Check for deadlocks, slow setup, or increase the timeout threshold before rerunning."
+  },
+  {
+    prefix: "permission:",
+    type: "permission_denied_failure",
+    label: "permission denied",
+    genericTitle: "Permission failures",
+    defaultCoverage: "error",
+    rootCauseConfidence: 0.85,
+    why: "it contains the file, socket, or port access that was denied",
+    fix: "Check file or port permissions in the CI environment before rerunning."
+  },
+  {
+    prefix: "async loop:",
+    type: "async_event_loop_failure",
+    label: "async event loop",
+    genericTitle: "Async event loop failures",
+    defaultCoverage: "mixed",
+    rootCauseConfidence: 0.88,
+    why: "it contains the async setup or coroutine that caused the event loop error",
+    fix: "Check event loop scope and pytest-asyncio configuration before rerunning."
+  },
+  {
+    prefix: "fixture teardown:",
+    type: "fixture_teardown_failure",
+    label: "fixture teardown",
+    genericTitle: "Fixture teardown failures",
+    defaultCoverage: "error",
+    rootCauseConfidence: 0.85,
+    why: "it contains the fixture teardown path that failed after the test body completed",
+    fix: "Inspect the teardown cleanup path and restore idempotent fixture cleanup before rerunning."
+  },
+  {
+    prefix: "db migration:",
+    type: "db_migration_failure",
+    label: "db migration",
+    genericTitle: "DB migration failures",
+    defaultCoverage: "error",
+    rootCauseConfidence: 0.9,
+    why: "it contains the migration or model definition behind the missing table or relation",
+    fix: "Run pending migrations or fix the expected model schema before rerunning."
+  },
+  {
+    prefix: "configuration:",
+    type: "configuration_error",
+    label: "configuration error",
+    genericTitle: "Configuration errors",
+    defaultCoverage: "error",
+    rootCauseConfidence: 0.95,
+    dominantPriority: 4,
+    dominantBlocker: true,
+    why: "it contains the pytest configuration or conftest setup error that blocks the run",
+    fix: "Fix the pytest configuration, CLI usage, or conftest import error before rerunning."
+  },
+  {
+    prefix: "xdist worker crash:",
+    type: "xdist_worker_crash",
+    label: "xdist worker crash",
+    genericTitle: "xdist worker crashes",
+    defaultCoverage: "error",
+    rootCauseConfidence: 0.92,
+    dominantPriority: 3,
+    why: "it contains the worker startup or shared-state path that crashed an xdist worker",
+    fix: "Check shared state, worker startup hooks, or resource contention between workers before rerunning."
+  },
+  {
+    prefix: "type error:",
+    type: "type_error_failure",
+    label: "type error",
+    genericTitle: "Type errors",
+    defaultCoverage: "mixed",
+    rootCauseConfidence: 0.8,
+    why: "it contains the call site or fixture value that triggered the type error",
+    fix: "Inspect the mismatched argument or object shape and rerun the full suite at standard."
+  },
+  {
+    prefix: "resource leak:",
+    type: "resource_leak_warning",
+    label: "resource leak",
+    genericTitle: "Resource leak warnings",
+    defaultCoverage: "mixed",
+    rootCauseConfidence: 0.74,
+    why: "it contains the warning source behind the leaked file, socket, or coroutine",
+    fix: "Close the leaked resource or suppress the warning only if the cleanup is intentional."
+  },
+  {
+    prefix: "django db access:",
+    type: "django_db_access_denied",
+    label: "django db access",
+    genericTitle: "Django DB access failures",
+    defaultCoverage: "error",
+    rootCauseConfidence: 0.95,
+    why: "it needs the @pytest.mark.django_db decorator or fixture permission to access the database",
+    fix: "Add @pytest.mark.django_db to the test or class before rerunning."
+  },
+  {
+    prefix: "network:",
+    type: "network_failure",
+    label: "network failure",
+    genericTitle: "Network failures",
+    defaultCoverage: "error",
+    rootCauseConfidence: 0.88,
+    dominantPriority: 2,
+    why: "it contains the host, URL, or TLS path behind the network failure",
+    fix: "Check DNS, outbound network access, retries, or TLS trust before rerunning."
+  },
+  {
+    prefix: "segfault:",
+    type: "subprocess_crash_segfault",
+    label: "segfault",
+    genericTitle: "Segfault crashes",
+    defaultCoverage: "mixed",
+    rootCauseConfidence: 0.8,
+    why: "it contains the subprocess or native extension path that crashed with SIGSEGV",
+    fix: "Inspect the native extension, subprocess boundary, or incompatible binary before rerunning."
+  },
+  {
+    prefix: "flaky:",
+    type: "flaky_test_detected",
+    label: "flaky test",
+    genericTitle: "Flaky test detections",
+    defaultCoverage: "mixed",
+    rootCauseConfidence: 0.72,
+    why: "it contains the rerun-prone test that behaved inconsistently across attempts",
+    fix: "Stabilize the nondeterministic test or fixture before relying on reruns."
+  },
+  {
+    prefix: "serialization:",
+    type: "serialization_encoding_failure",
+    label: "serialization or encoding",
+    genericTitle: "Serialization or encoding failures",
+    defaultCoverage: "mixed",
+    rootCauseConfidence: 0.78,
+    why: "it contains the serialization or decoding path behind the malformed payload",
+    fix: "Inspect the encoded payload, serializer, or fixture data before rerunning."
+  },
+  {
+    prefix: "file not found:",
+    type: "file_not_found_failure",
+    label: "file not found",
+    genericTitle: "Missing file failures",
+    defaultCoverage: "mixed",
+    rootCauseConfidence: 0.82,
+    why: "it contains the missing file path or fixture artifact required by the test",
+    fix: "Restore the missing file, fixture artifact, or working-directory assumption before rerunning."
+  },
+  {
+    prefix: "memory:",
+    type: "memory_error",
+    label: "memory error",
+    genericTitle: "Memory failures",
+    defaultCoverage: "mixed",
+    rootCauseConfidence: 0.78,
+    why: "it contains the allocation path that exhausted available memory",
+    fix: "Reduce memory pressure or investigate the large allocation before rerunning."
+  },
+  {
+    prefix: "deprecation as error:",
+    type: "deprecation_warning_as_error",
+    label: "deprecation as error",
+    genericTitle: "Deprecation warnings as errors",
+    defaultCoverage: "mixed",
+    rootCauseConfidence: 0.74,
+    why: "it contains the deprecated API or warning filter that is failing the test run",
+    fix: "Update the deprecated call site or relax the warning policy only if that is intentional."
+  },
+  {
+    prefix: "xfail strict:",
+    type: "xfail_strict_unexpected_pass",
+    label: "strict xfail unexpected pass",
+    genericTitle: "Strict xfail unexpected passes",
+    defaultCoverage: "failed",
+    rootCauseConfidence: 0.78,
+    why: "it contains the strict xfail case that unexpectedly passed",
+    fix: "Remove or update the strict xfail expectation if the test is now passing intentionally."
+  }
+];
+function findExtendedBucketSpec(reason) {
+  return extendedBucketSpecs.find((spec) => reason.startsWith(spec.prefix)) ?? null;
+}
+function extractReasonDetail(reason, prefix) {
+  const detail = reason.slice(prefix.length).trim();
+  return detail.length > 0 ? detail : null;
+}
 function formatCount(count, singular, plural = `${singular}s`) {
   return `${count} ${count === 1 ? singular : plural}`;
 }
@@ -219,6 +422,10 @@ function formatTargetSummary(summary) {
   return `count=${summary.count}; families=${families}`;
 }
 function classifyGenericBucketType(reason) {
+  const extended = findExtendedBucketSpec(reason);
+  if (extended) {
+    return extended.type;
+  }
   if (reason.startsWith("missing test env:")) {
     return "shared_environment_blocker";
   }
@@ -263,6 +470,10 @@ function classifyVisibleStatusForLabel(args) {
   return "unknown";
 }
 function inferCoverageFromReason(reason) {
+  const extended = findExtendedBucketSpec(reason);
+  if (extended) {
+    return extended.defaultCoverage;
+  }
   if (reason.startsWith("missing test env:") || reason.startsWith("fixture guard:") || reason.startsWith("service unavailable:") || reason.startsWith("db refused:") || reason.startsWith("auth bypass absent:") || reason.startsWith("missing module:")) {
     return "error";
   }
@@ -323,7 +534,13 @@ function buildGenericBuckets(analysis) {
       summaryLines: [],
       reason,
       count: 1,
-      confidence: reason.startsWith("assertion failed:") || /^[A-Z][A-Za-z]+(?:Error|Exception):/.test(reason) ? 0.74 : 0.62,
+      confidence: (() => {
+        const extended = findExtendedBucketSpec(reason);
+        if (extended) {
+          return Math.max(0.72, Math.min(extended.rootCauseConfidence, 0.82));
+        }
+        return reason.startsWith("assertion failed:") || /^[A-Z][A-Za-z]+(?:Error|Exception):/.test(reason) ? 0.74 : 0.62;
+      })(),
       representativeItems: [item],
       entities: [],
       hint: void 0,
@@ -340,7 +557,7 @@ function buildGenericBuckets(analysis) {
     push(item.reason, item);
   }
   for (const bucket of grouped.values()) {
-    const title = bucket.type === "assertion_failure" ? "Assertion failures" : bucket.type === "import_dependency_failure" ? "Import/dependency failures" : bucket.type === "collection_failure" ? "Collection or fixture failures" : "Runtime failures";
+    const title = findExtendedBucketSpec(bucket.reason)?.genericTitle ?? (bucket.type === "assertion_failure" || bucket.type === "snapshot_mismatch" ? "Assertion failures" : bucket.type === "import_dependency_failure" ? "Import/dependency failures" : bucket.type === "collection_failure" ? "Collection or fixture failures" : "Runtime failures");
     bucket.headline = `${title}: ${formatCount(bucket.count, "visible failure")} share ${bucket.reason}.`;
     bucket.summaryLines = [bucket.headline];
     bucket.overflowCount = Math.max(bucket.count - bucket.representativeItems.length, 0);
@@ -413,13 +630,13 @@ function inferFailureBucketCoverage(bucket, analysis) {
     }
   }
   const claimed = bucket.countClaimed ?? bucket.countVisible;
-  if (bucket.type === "contract_snapshot_drift" || bucket.type === "assertion_failure") {
+  if (bucket.type === "contract_snapshot_drift" || bucket.type === "assertion_failure" || bucket.type === "snapshot_mismatch") {
     return {
       error,
       failed: Math.max(failed, claimed)
     };
   }
-  if (bucket.type === "shared_environment_blocker" || bucket.type === "import_dependency_failure" || bucket.type === "collection_failure" || bucket.type === "fixture_guard_failure" || bucket.type === "service_unavailable" || bucket.type === "db_connection_failure" || bucket.type === "auth_bypass_absent") {
+  if (bucket.type === "shared_environment_blocker" || bucket.type === "import_dependency_failure" || bucket.type === "collection_failure" || bucket.type === "fixture_guard_failure" || bucket.type === "permission_denied_failure" || bucket.type === "fixture_teardown_failure" || bucket.type === "db_migration_failure" || bucket.type === "configuration_error" || bucket.type === "xdist_worker_crash" || bucket.type === "django_db_access_denied" || bucket.type === "network_failure" || bucket.type === "service_unavailable" || bucket.type === "db_connection_failure" || bucket.type === "auth_bypass_absent") {
     return {
       error: Math.max(error, claimed),
       failed
@@ -494,6 +711,10 @@ function dominantBucketPriority(bucket) {
   if (bucket.reason.startsWith("missing test env:")) {
     return 5;
   }
+  const extended = findExtendedBucketSpec(bucket.reason);
+  if (extended?.dominantPriority !== void 0) {
+    return extended.dominantPriority;
+  }
   if (bucket.type === "shared_environment_blocker") {
     return 4;
   }
@@ -527,12 +748,16 @@ function prioritizeBuckets(buckets) {
   });
 }
 function isDominantBlockerType(type) {
-  return type === "shared_environment_blocker" || type === "import_dependency_failure" || type === "collection_failure";
+  return type === "shared_environment_blocker" || type === "configuration_error" || type === "import_dependency_failure" || type === "collection_failure";
 }
 function labelForBucket(bucket) {
   if (bucket.labelOverride) {
     return bucket.labelOverride;
   }
+  const extended = findExtendedBucketSpec(bucket.reason);
+  if (extended) {
+    return extended.label;
+  }
   if (bucket.reason.startsWith("missing test env:")) {
     return "missing test env";
   }
@@ -566,6 +791,9 @@ function labelForBucket(bucket) {
   if (bucket.type === "assertion_failure") {
     return "assertion failure";
   }
+  if (bucket.type === "snapshot_mismatch") {
+    return "snapshot mismatch";
+  }
   if (bucket.type === "collection_failure") {
     return "collection failure";
   }
@@ -584,6 +812,10 @@ function rootCauseConfidenceFor(bucket) {
   if (isUnknownBucket(bucket)) {
     return 0.52;
   }
+  const extended = findExtendedBucketSpec(bucket.reason);
+  if (extended) {
+    return extended.rootCauseConfidence;
+  }
   if (bucket.reason.startsWith("missing test env:") || bucket.reason.startsWith("missing module:") || bucket.reason.startsWith("db refused:") || bucket.reason.startsWith("service unavailable:") || bucket.reason.startsWith("auth bypass absent:")) {
     return 0.95;
   }
@@ -624,6 +856,10 @@ function buildReadTargetWhy(args) {
   if (envVar) {
     return `it contains the ${envVar} setup guard`;
   }
+  const extended = findExtendedBucketSpec(args.bucket.reason);
+  if (extended) {
+    return extended.why;
+  }
   if (args.bucket.reason.startsWith("fixture guard:")) {
     return "it contains the fixture/setup guard behind this bucket";
   }
@@ -654,6 +890,9 @@ function buildReadTargetWhy(args) {
     }
     return "it maps to the visible stale snapshot expectation";
   }
+  if (args.bucket.type === "snapshot_mismatch") {
+    return "it maps to the visible snapshot mismatch bucket";
+  }
   if (args.bucket.type === "import_dependency_failure") {
     return "it is the first visible failing module in this missing dependency bucket";
   }
@@ -665,11 +904,54 @@ function buildReadTargetWhy(args) {
   }
   return `it maps to the visible ${args.bucketLabel} bucket`;
 }
+function buildExtendedBucketSearchHint(bucket, anchor) {
+  const extended = findExtendedBucketSpec(bucket.reason);
+  if (!extended) {
+    return null;
+  }
+  const detail = extractReasonDetail(bucket.reason, extended.prefix);
+  if (!detail) {
+    return anchor.label.split("::")[1]?.trim() ?? anchor.label ?? null;
+  }
+  if (extended.type === "timeout_failure") {
+    const duration = detail.match(/>\s*([0-9]+(?:\.[0-9]+)?s?)/i)?.[1];
+    return duration ?? anchor.label.split("::")[1]?.trim() ?? detail;
+  }
+  if (extended.type === "db_migration_failure") {
+    const relation = detail.match(/\b(?:relation|table)\s+([A-Za-z0-9_.-]+)/i)?.[1];
+    return relation ?? detail;
+  }
+  if (extended.type === "network_failure") {
+    const url = detail.match(/\bhttps?:\/\/[^\s)'"`]+/i)?.[0];
+    const host = detail.match(/\b(?:[A-Za-z0-9-]+\.)+[A-Za-z]{2,}\b/)?.[0];
+    return url ?? host ?? detail;
+  }
+  if (extended.type === "xdist_worker_crash") {
+    return detail.match(/\bgw\d+\b/)?.[0] ?? detail;
+  }
+  if (extended.type === "fixture_teardown_failure") {
+    return detail.replace(/^of\s+/i, "") || anchor.label;
+  }
+  if (extended.type === "file_not_found_failure") {
+    const path4 = detail.match(/['"]([^'"]+)['"]/)?.[1];
+    return path4 ?? detail;
+  }
+  if (extended.type === "permission_denied_failure") {
+    const path4 = detail.match(/['"]([^'"]+)['"]/)?.[1];
+    const port = detail.match(/\bport\s+(\d+)\b/i)?.[1];
+    return path4 ?? (port ? `port ${port}` : detail);
+  }
+  return detail;
+}
 function buildReadTargetSearchHint(bucket, anchor) {
   const envVar = bucket.reason.match(/^missing test env:\s+([A-Z][A-Z0-9_]{2,})$/)?.[1];
   if (envVar) {
     return envVar;
   }
+  const extendedHint = buildExtendedBucketSearchHint(bucket, anchor);
+  if (extendedHint) {
+    return extendedHint;
+  }
   if (bucket.type === "contract_snapshot_drift") {
     return bucket.entities.find((value) => value.startsWith("/api/")) ?? bucket.entities[0] ?? null;
   }
@@ -784,6 +1066,10 @@ function extractMiniDiff(input, bucket) {
   };
 }
 function inferSupplementCoverageKind(args) {
+  const extended = findExtendedBucketSpec(args.rootCause);
+  if (extended?.defaultCoverage === "error" || extended?.defaultCoverage === "failed") {
+    return extended.defaultCoverage;
+  }
   const normalized = `${args.label} ${args.rootCause}`.toLowerCase();
   if (/env|setup|fixture|import|dependency|service|db|database|auth bypass|collection|connection refused/.test(
     normalized
@@ -1027,6 +1313,10 @@ function buildStandardFixText(args) {
   if (args.bucket.hint) {
     return args.bucket.hint;
   }
+  const extended = findExtendedBucketSpec(args.bucket.reason);
+  if (extended) {
+    return extended.fix;
+  }
   const envVar = args.bucket.reason.match(/^missing test env:\s+([A-Z][A-Z0-9_]{2,})$/)?.[1];
   if (envVar) {
     return `Set ${envVar} before rerunning the affected tests.`;
@@ -1056,6 +1346,9 @@ function buildStandardFixText(args) {
   if (args.bucket.type === "contract_snapshot_drift") {
     return "Review the visible drift and regenerate the contract snapshots if the changes are intentional.";
   }
+  if (args.bucket.type === "snapshot_mismatch") {
+    return "Update the snapshots if these output changes are intentional, then rerun the full suite at standard.";
+  }
   if (args.bucket.type === "assertion_failure") {
     return "Inspect the failing assertion and rerun the full suite at standard.";
   }
@@ -1381,6 +1674,63 @@ function getCount(input, label) {
   const lastMatch = matches.at(-1);
   return lastMatch ? Number(lastMatch[1]) : 0;
 }
+function detectTestRunner(input) {
+  if (/^\s*Test Files?\s+(?:\d+\s+failed\s*\|\s*)?\d+\s+passed/m.test(input) || /^\s*Tests?\s+(?:\d+\s+failed\s*\|\s*)?\d+\s+passed/m.test(input) || /^\s*Snapshots?\s+(?:\d+\s+failed\s*\|\s*)?\d+\s+passed/m.test(input) || /⎯{2,}\s+Failed Tests?\s+\d+\s+⎯{2,}/.test(input)) {
+    return "vitest";
+  }
+  if (/^\s*Test Suites:\s+\d+\s+failed,\s+\d+\s+passed(?:,\s+\d+\s+total)?/m.test(input) || /^\s*Tests:\s+\d+\s+failed,\s+\d+\s+passed(?:,\s+\d+\s+total)?/m.test(input)) {
+    return "jest";
+  }
+  if (/\bpytest\b/i.test(input) || /^\s*=+.*\b\d+\s+failed\b.*=+\s*$/m.test(input) || /\bcollected\s+\d+\s+items\b/i.test(input)) {
+    return "pytest";
+  }
+  return "unknown";
+}
+function extractVitestLineCount(input, label, metric) {
+  const matcher = new RegExp(`^\\s*${label}\\s+(.+)$`, "gmi");
+  const lines = [...input.matchAll(matcher)];
+  const line = lines.at(-1)?.[1];
+  if (!line) {
+    return null;
+  }
+  const metricMatch = line.match(new RegExp(`(\\d+)\\s+${metric}`, "i"));
+  return metricMatch ? Number(metricMatch[1]) : null;
+}
+function extractJestLineCount(input, label, metric) {
+  const matcher = new RegExp(`^\\s*${label}:\\s+(.+)$`, "gmi");
+  const lines = [...input.matchAll(matcher)];
+  const line = lines.at(-1)?.[1];
+  if (!line) {
+    return null;
+  }
+  const metricMatch = line.match(new RegExp(`(\\d+)\\s+${metric}`, "i"));
+  return metricMatch ? Number(metricMatch[1]) : null;
+}
+function extractTestStatusCounts(input, runner) {
+  if (runner === "vitest") {
+    return {
+      passed: extractVitestLineCount(input, "Tests?", "passed") ?? getCount(input, "passed"),
+      failed: extractVitestLineCount(input, "Tests?", "failed") ?? getCount(input, "failed"),
+      errors: extractVitestLineCount(input, "Errors?", "error") ?? extractVitestLineCount(input, "Errors?", "errors") ?? Math.max(getCount(input, "errors"), getCount(input, "error")),
+      skipped: extractVitestLineCount(input, "Tests?", "skipped") ?? getCount(input, "skipped"),
+      snapshotFailures: extractVitestLineCount(input, "Snapshots?", "failed") ?? void 0
+    };
+  }
+  if (runner === "jest") {
+    return {
+      passed: extractJestLineCount(input, "Tests", "passed") ?? getCount(input, "passed"),
+      failed: extractJestLineCount(input, "Tests", "failed") ?? getCount(input, "failed"),
+      errors: Math.max(getCount(input, "errors"), getCount(input, "error")),
+      skipped: extractJestLineCount(input, "Tests", "skipped") ?? getCount(input, "skipped")
+    };
+  }
+  return {
+    passed: getCount(input, "passed"),
+    failed: getCount(input, "failed"),
+    errors: Math.max(getCount(input, "errors"), getCount(input, "error")),
+    skipped: getCount(input, "skipped")
+  };
+}
 function formatCount2(count, singular, plural = `${singular}s`) {
   return `${count} ${count === 1 ? singular : plural}`;
 }
@@ -1413,7 +1763,8 @@ function normalizeAnchorFile(value) {
   return value.replace(/\\/g, "/").trim();
 }
 function inferFileFromLabel(label) {
-  const candidate = cleanFailureLabel(label).split("::")[0]?.trim();
+  const cleaned = cleanFailureLabel(label);
+  const candidate = cleaned.split("::")[0]?.split(" > ")[0]?.trim();
   if (!candidate) {
     return null;
   }
@@ -1468,6 +1819,15 @@ function parseObservedAnchor(line) {
       anchor_confidence: 0.92
     };
   }
+  const vitestTraceback = normalized.match(/^\s*❯\s+([^:\s][^:]*\.[A-Za-z0-9]+):(\d+)(?::\d+)?/);
+  if (vitestTraceback) {
+    return {
+      file: normalizeAnchorFile(vitestTraceback[1]),
+      line: Number(vitestTraceback[2]),
+      anchor_kind: "traceback",
+      anchor_confidence: 1
+    };
+  }
   return null;
 }
 function resolveAnchorForLabel(args) {
@@ -1484,15 +1844,27 @@ function isLowValueInternalReason(normalized) {
   ) || /\bpython\.py:\d+:\s+in\s+importtestmodule\b/i.test(normalized) || /\bpython\.py:\d+:\s+in\s+import_path\b/i.test(normalized);
 }
 function scoreFailureReason(reason) {
+  if (reason.startsWith("configuration:")) {
+    return 6;
+  }
   if (reason.startsWith("missing test env:")) {
     return 6;
   }
   if (reason.startsWith("missing module:")) {
     return 5;
   }
+  if (reason.startsWith("snapshot mismatch:")) {
+    return 4;
+  }
   if (reason.startsWith("assertion failed:")) {
     return 4;
   }
+  if (reason.startsWith("timeout:") || reason.startsWith("async loop:") || reason.startsWith("django db access:") || reason.startsWith("db migration:")) {
+    return 3;
+  }
+  if (reason.startsWith("permission:") || reason.startsWith("xdist worker crash:") || reason.startsWith("network:") || reason.startsWith("segfault:") || reason.startsWith("memory:") || reason.startsWith("type error:") || reason.startsWith("serialization:") || reason.startsWith("file not found:") || reason.startsWith("deprecation as error:") || reason.startsWith("xfail strict:") || reason.startsWith("resource leak:") || reason.startsWith("flaky:") || reason.startsWith("fixture teardown:")) {
+    return 2;
+  }
   if (/^[A-Z][A-Za-z]+(?:Error|Exception):/.test(reason)) {
     return 3;
   }
@@ -1501,6 +1873,16 @@ function scoreFailureReason(reason) {
   }
   return 1;
 }
+function buildClassifiedReason(prefix, detail) {
+  return `${prefix}: ${detail}`.slice(0, 120);
+}
+function buildExcerptDetail(value, fallback) {
+  const trimmed = value.trim().replace(/\s+/g, " ");
+  return trimmed.length > 0 ? trimmed : fallback;
+}
+function sharedBlockerThreshold(reason) {
+  return reason.startsWith("configuration:") ? 1 : 3;
+}
 function extractEnvBlockerName(normalized) {
   const directMatch = normalized.match(
     /\bDB-isolated tests require\s+([A-Z][A-Z0-9_]{2,})\b/
@@ -1600,6 +1982,226 @@ function classifyFailureReason(line, options) {
       group: "authentication test setup failures"
     };
   }
+  const snapshotMismatch = normalized.match(
+    /((?:Error:\s*)?Snapshot\b.+\bmismatched\b[^$]*|Snapshot comparison failed[^$]*)/i
+  );
+  if (snapshotMismatch) {
+    return {
+      reason: buildClassifiedReason(
+        "snapshot mismatch",
+        buildExcerptDetail(snapshotMismatch[1] ?? normalized, "snapshot output changed")
+      ),
+      group: "snapshot mismatches"
+    };
+  }
+  const timeoutFailure = normalized.match(
+    /(Failed:\s*Timeout\s*>[^,;]+|asyncio\.exceptions\.TimeoutError:\s*.+|TimeoutError:\s*.+|(?:Test|Hook)\s+timed out in\s+\d+(?:\.\d+)?m?s[^$]*|(?:\[vitest-(?:worker|pool)\]:\s*)?Timeout[^$]*)$/i
+  );
+  if (timeoutFailure) {
+    return {
+      reason: buildClassifiedReason(
+        "timeout",
+        buildExcerptDetail(timeoutFailure[1] ?? normalized, "test exceeded timeout threshold")
+      ),
+      group: "timeout failures"
+    };
+  }
+  const asyncLoopFailure = normalized.match(
+    /(Event loop is closed|no current event loop|coroutine .* was never awaited|coroutine was never awaited)/i
+  );
+  if (asyncLoopFailure) {
+    return {
+      reason: buildClassifiedReason(
+        "async loop",
+        buildExcerptDetail(asyncLoopFailure[1] ?? normalized, "async event loop failure")
+      ),
+      group: "async event loop failures"
+    };
+  }
+  const permissionFailure = normalized.match(
+    /(PermissionError:\s*\[Errno 13\][^$]*|Address already in use)/i
+  );
+  if (permissionFailure) {
+    return {
+      reason: buildClassifiedReason(
+        "permission",
+        buildExcerptDetail(permissionFailure[1] ?? normalized, "permission denied or resource locked")
+      ),
+      group: "permission or locked resource failures"
+    };
+  }
+  const xdistWorkerCrash = normalized.match(
+    /(worker ['"][^'"]+['"] crashed|node down:\s*[^,;]+|WorkerLost[^,;]*|Worker exited unexpectedly[^,;]*|worker exited unexpectedly[^,;]*)/i
+  );
+  if (xdistWorkerCrash) {
+    return {
+      reason: buildClassifiedReason(
+        "xdist worker crash",
+        buildExcerptDetail(xdistWorkerCrash[1] ?? normalized, "pytest-xdist worker crashed")
+      ),
+      group: "xdist worker crashes"
+    };
+  }
+  if (/Worker terminated due to reaching memory limit/i.test(normalized)) {
+    return {
+      reason: "memory: Worker terminated due to reaching memory limit",
+      group: "memory exhaustion failures"
+    };
+  }
+  if (/Database access not allowed, use the ["']django_db["'] mark/i.test(normalized)) {
+    return {
+      reason: 'django db access: Database access not allowed, use the "django_db" mark',
+      group: "django database marker failures"
+    };
+  }
+  const networkFailure = normalized.match(
+    /(Max retries exceeded[^,;]*|gaierror[^,;]*|SSLCertVerificationError[^,;]*|Network is unreachable)/i
+  );
+  if (networkFailure) {
+    return {
+      reason: buildClassifiedReason(
+        "network",
+        buildExcerptDetail(networkFailure[1] ?? normalized, "network dependency failure")
+      ),
+      group: "network dependency failures"
+    };
+  }
+  const relationMigration = normalized.match(/relation ["'`]([^"'`]+)["'`] does not exist/i);
+  if (relationMigration) {
+    return {
+      reason: buildClassifiedReason("db migration", `relation ${relationMigration[1]} does not exist`),
+      group: "database migration or schema failures"
+    };
+  }
+  const noSuchTable = normalized.match(/no such table(?::)?\s*([A-Za-z0-9_.-]+)/i);
+  if (noSuchTable) {
+    return {
+      reason: buildClassifiedReason("db migration", `no such table ${noSuchTable[1]}`),
+      group: "database migration or schema failures"
+    };
+  }
+  if (/InconsistentMigrationHistory/i.test(normalized)) {
+    return {
+      reason: "db migration: InconsistentMigrationHistory",
+      group: "database migration or schema failures"
+    };
+  }
+  if (/(Segmentation fault|SIGSEGV|\bexit 139\b)/i.test(normalized)) {
+    return {
+      reason: buildClassifiedReason(
+        "segfault",
+        buildExcerptDetail(normalized, "subprocess crashed with SIGSEGV")
+      ),
+      group: "subprocess crash failures"
+    };
+  }
+  if (/(MemoryError\b|\bexit 137\b|OOMKilled|OutOfMemory)/i.test(normalized)) {
+    return {
+      reason: buildClassifiedReason(
+        "memory",
+        buildExcerptDetail(normalized, "process exhausted available memory")
+      ),
+      group: "memory exhaustion failures"
+    };
+  }
+  const typeErrorFailure = normalized.match(/TypeError:\s*(.+)$/i);
+  if (typeErrorFailure) {
+    return {
+      reason: buildClassifiedReason(
+        "type error",
+        buildExcerptDetail(typeErrorFailure[1] ?? normalized, "TypeError")
+      ),
+      group: "type errors"
+    };
+  }
+  const serializationFailure = normalized.match(
+    /\b(UnicodeDecodeError|JSONDecodeError|PicklingError):\s*(.+)$/i
+  );
+  if (serializationFailure) {
+    return {
+      reason: buildClassifiedReason(
+        "serialization",
+        `${serializationFailure[1]}: ${buildExcerptDetail(serializationFailure[2] ?? "", serializationFailure[1] ?? "serialization failure")}`
+      ),
+      group: "serialization and encoding failures"
+    };
+  }
+  const fileNotFoundFailure = normalized.match(/FileNotFoundError:\s*(.+)$/i);
+  if (fileNotFoundFailure) {
+    return {
+      reason: buildClassifiedReason(
+        "file not found",
+        buildExcerptDetail(fileNotFoundFailure[1] ?? normalized, "missing file during test execution")
+      ),
+      group: "missing file failures"
+    };
+  }
+  const deprecationFailure = normalized.match(
+    /\b(DeprecationWarning|FutureWarning|PytestRemovedIn9Warning):\s*(.+)$/i
+  );
+  if (deprecationFailure) {
+    return {
+      reason: buildClassifiedReason(
+        "deprecation as error",
+        `${deprecationFailure[1]}: ${buildExcerptDetail(deprecationFailure[2] ?? "", deprecationFailure[1] ?? "warning treated as error")}`
+      ),
+      group: "warnings treated as errors"
+    };
+  }
+  const strictXfail = normalized.match(/XPASS\(strict\)\s*:?\s*(.+)?$/i);
+  if (strictXfail) {
+    return {
+      reason: buildClassifiedReason(
+        "xfail strict",
+        buildExcerptDetail(strictXfail[1] ?? normalized, "strict xfail unexpectedly passed")
+      ),
+      group: "strict xfail expectation failures"
+    };
+  }
+  const resourceLeak = normalized.match(
+    /(PytestUnraisableExceptionWarning[^,;]*|ResourceWarning:\s*unclosed[^,;]*)/i
+  );
+  if (resourceLeak) {
+    return {
+      reason: buildClassifiedReason(
+        "resource leak",
+        buildExcerptDetail(resourceLeak[1] ?? normalized, "resource leak warning promoted to failure")
+      ),
+      group: "resource leak warnings"
+    };
+  }
+  const flakyFailure = normalized.match(/\b(RERUN|[0-9]+\s+rerun|Flaky test passed)\b[^$]*/i);
+  if (flakyFailure) {
+    return {
+      reason: buildClassifiedReason(
+        "flaky",
+        buildExcerptDetail(flakyFailure[0] ?? normalized, "test required reruns before passing")
+      ),
+      group: "flaky test detections"
+    };
+  }
+  const teardownFailure = normalized.match(/ERROR at teardown of\s+(.+)$/i);
+  if (teardownFailure) {
+    return {
+      reason: buildClassifiedReason(
+        "fixture teardown",
+        buildExcerptDetail(teardownFailure[1] ?? normalized, "fixture teardown failed")
+      ),
+      group: "fixture teardown failures"
+    };
+  }
+  const configurationFailure = normalized.match(
+    /(INTERNALERROR>.+|ConftestImportFailure[^,;]*|UsageError:\s*.+|ERROR:\s*usage:\s*.+|pytest:\s*error:\s*.+|Cannot use import statement outside a module[^$]*|Named export.+not found.+CommonJS[^$]*|failed to load config from.+|localStorage is not available[^$]*|No test suite found in file.+|No test found in suite.+)$/i
+  );
+  if (configurationFailure) {
+    return {
+      reason: buildClassifiedReason(
+        "configuration",
+        buildExcerptDetail(configurationFailure[1] ?? normalized, "test configuration error")
+      ),
+      group: "test configuration failures"
+    };
+  }
   const pythonMissingModule = normalized.match(
     /ModuleNotFoundError:\s+No module named ['"]([^'"]+)['"]/i
   );
@@ -1616,6 +2218,20 @@ function classifyFailureReason(line, options) {
       group: options.duringCollection ? "import/dependency errors during collection" : "missing dependency/module errors"
     };
   }
+  const importResolutionFailure = normalized.match(/Failed to resolve import ['"]([^'"]+)['"]/i);
+  if (importResolutionFailure) {
+    return {
+      reason: `missing module: ${importResolutionFailure[1]}`,
+      group: options.duringCollection ? "import/dependency errors during collection" : "missing dependency/module errors"
+    };
+  }
+  const esmModuleFailure = normalized.match(/ERR_MODULE_NOT_FOUND[^'"`]*['"`]([^'"`]+)['"`]/i) ?? normalized.match(/Cannot find package ['"`]([^'"`]+)['"`]/i);
+  if (esmModuleFailure) {
+    return {
+      reason: `missing module: ${esmModuleFailure[1]}`,
+      group: options.duringCollection ? "import/dependency errors during collection" : "missing dependency/module errors"
+    };
+  }
   const assertionFailure = normalized.match(/AssertionError:\s*(.+)$/i);
   if (assertionFailure) {
     return {
@@ -1623,6 +2239,16 @@ function classifyFailureReason(line, options) {
       group: "assertion failures"
     };
   }
+  const vitestUnhandled = normalized.match(/Vitest caught\s+\d+\s+unhandled errors?/i);
+  if (vitestUnhandled) {
+    return {
+      reason: `RuntimeError: ${buildExcerptDetail(vitestUnhandled[0] ?? normalized, "Vitest caught unhandled errors")}`.slice(
+        0,
+        120
+      ),
+      group: "runtime failures"
+    };
+  }
   const genericError = normalized.match(/\b([A-Z][A-Za-z]+(?:Error|Exception)):\s*(.+)$/);
   if (genericError) {
     const errorType = genericError[1];
@@ -1667,6 +2293,125 @@ function chooseStrongestFailureItems(items) {
   }
   return order.map((label) => strongest.get(label));
 }
+function extractJsTestFile(value) {
+  const match = value.match(/([A-Za-z0-9_./-]+\.(?:test|spec)\.[cm]?[jt]sx?)/i);
+  return match ? normalizeAnchorFile(match[1]) : null;
+}
+function normalizeJsFailureLabel(label) {
+  return cleanFailureLabel(label).replace(/^[❯×]\s*/, "").replace(/\s+\[[^\]]+\]\s*$/, "").replace(/\s+/g, " ").trim();
+}
+function classifyFailureLines(args) {
+  let observedAnchor = null;
+  let strongest = null;
+  for (const line of args.lines) {
+    observedAnchor = parseObservedAnchor(line) ?? observedAnchor;
+    const classification = classifyFailureReason(line, {
+      duringCollection: args.duringCollection
+    });
+    if (!classification) {
+      continue;
+    }
+    const score = scoreFailureReason(classification.reason);
+    if (!strongest || score > strongest.score) {
+      strongest = {
+        classification,
+        score,
+        observedAnchor: parseObservedAnchor(line) ?? observedAnchor
+      };
+    }
+  }
+  if (!strongest) {
+    return null;
+  }
+  return {
+    classification: strongest.classification,
+    observedAnchor: strongest.observedAnchor ?? observedAnchor
+  };
+}
+function collectJsFailureBlocks(input) {
+  const blocks = [];
+  let current = null;
+  let section = null;
+  let currentFile = null;
+  const flushCurrent = () => {
+    if (!current) {
+      return;
+    }
+    blocks.push(current);
+    current = null;
+  };
+  for (const rawLine of input.split("\n")) {
+    const line = rawLine.trimEnd();
+    const trimmed = line.trim();
+    if (/⎯{2,}\s+Failed Tests?\s+\d+\s+⎯{2,}/.test(line)) {
+      flushCurrent();
+      section = "failed_tests";
+      continue;
+    }
+    if (/⎯{2,}\s+Failed Suites?\s+\d+\s+⎯{2,}/.test(line)) {
+      flushCurrent();
+      section = "failed_suites";
+      continue;
+    }
+    if (section && /^⎯{2,}.+⎯{2,}\s*$/.test(line)) {
+      flushCurrent();
+      section = null;
+      continue;
+    }
+    const progress = line.match(
+      /^(.+?\.(?:test|spec)\.[cm]?[jt]sx?(?:\s+>.+?)?)\s+(FAILED|ERROR)\s+\[[^\]]+\]\s*$/
+    );
+    if (progress) {
+      flushCurrent();
+      const label = normalizeJsFailureLabel(progress[1]);
+      current = {
+        label,
+        status: progress[2] === "ERROR" ? "error" : "failed",
+        detailLines: []
+      };
+      currentFile = extractJsTestFile(label);
+      continue;
+    }
+    const failHeader = line.match(/^\s*FAIL\s+(.+)$/);
+    if (failHeader) {
+      const label = normalizeJsFailureLabel(failHeader[1]);
+      if (extractJsTestFile(label)) {
+        flushCurrent();
+        current = {
+          label,
+          status: section === "failed_suites" || !label.includes(" > ") ? "error" : "failed",
+          detailLines: []
+        };
+        currentFile = extractJsTestFile(label);
+        continue;
+      }
+    }
+    const failedTest = line.match(/^\s*×\s+(.+)$/);
+    if (failedTest && (section === "failed_tests" || extractJsTestFile(failedTest[1]))) {
+      flushCurrent();
+      const candidate = normalizeJsFailureLabel(failedTest[1]);
+      const file = extractJsTestFile(candidate) ?? currentFile;
+      const label = file && !extractJsTestFile(candidate) ? `${file} > ${candidate}` : candidate;
+      current = {
+        label,
+        status: "failed",
+        detailLines: []
+      };
+      currentFile = extractJsTestFile(label) ?? currentFile;
+      continue;
+    }
+    if (/^\s*(?:Tests?|Snapshots?|Test Files?|Test Suites?)\b/.test(line)) {
+      flushCurrent();
+      section = null;
+      continue;
+    }
+    if (current && trimmed.length > 0) {
+      current.detailLines.push(line);
+    }
+  }
+  flushCurrent();
+  return blocks;
+}
 function collectCollectionFailureItems(input) {
   const items = [];
   const lines = input.split("\n");
@@ -1674,6 +2419,24 @@ function collectCollectionFailureItems(input) {
   let pendingGenericReason = null;
   let currentAnchor = null;
   for (const line of lines) {
+    const standaloneCollectionLabel = line.match(/No test suite found in file\s+(.+)$/i)?.[1] ?? line.match(/No test found in suite\s+(.+)$/i)?.[1] ?? line.match(/failed to load config from\s+(.+)$/i)?.[1];
+    if (standaloneCollectionLabel) {
+      const classification2 = classifyFailureReason(line, {
+        duringCollection: true
+      });
+      if (classification2) {
+        pushFocusedFailureItem(items, {
+          label: cleanFailureLabel(standaloneCollectionLabel),
+          reason: classification2.reason,
+          group: classification2.group,
+          ...resolveAnchorForLabel({
+            label: cleanFailureLabel(standaloneCollectionLabel),
+            observedAnchor: parseObservedAnchor(line)
+          })
+        });
+      }
+      continue;
+    }
     const collecting = line.match(/^_+\s+ERROR collecting\s+(.+?)\s+_+\s*$/);
     if (collecting) {
       if (currentLabel && pendingGenericReason) {
@@ -1762,6 +2525,24 @@ function collectInlineFailureItems(input) {
       })
     });
   }
+  for (const block of collectJsFailureBlocks(input)) {
+    const resolved = classifyFailureLines({
+      lines: block.detailLines,
+      duringCollection: block.status === "error"
+    });
+    if (!resolved) {
+      continue;
+    }
+    pushFocusedFailureItem(items, {
+      label: block.label,
+      reason: resolved.classification.reason,
+      group: resolved.classification.group,
+      ...resolveAnchorForLabel({
+        label: block.label,
+        observedAnchor: resolved.observedAnchor
+      })
+    });
+  }
   return items;
 }
 function collectInlineFailureItemsWithStatus(input) {
@@ -1796,16 +2577,42 @@ function collectInlineFailureItemsWithStatus(input) {
       })
     });
   }
+  for (const block of collectJsFailureBlocks(input)) {
+    const resolved = classifyFailureLines({
+      lines: block.detailLines,
+      duringCollection: block.status === "error"
+    });
+    if (!resolved) {
+      continue;
+    }
+    items.push({
+      label: block.label,
+      reason: resolved.classification.reason,
+      group: resolved.classification.group,
+      status: block.status,
+      ...resolveAnchorForLabel({
+        label: block.label,
+        observedAnchor: resolved.observedAnchor
+      })
+    });
+  }
   return items;
 }
 function collectStandaloneErrorClassifications(input) {
   const classifications = [];
   for (const line of input.split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed) {
+      continue;
+    }
     const standalone = line.match(/^\s*E\s+(.+)$/);
-    if (!standalone) {
+    const candidate = standalone?.[1] ?? (/^(INTERNALERROR>|ConftestImportFailure\b|UsageError:|ERROR:\s*usage:|pytest:\s*error:)/i.test(
+      trimmed
+    ) ? trimmed : null);
+    if (!candidate) {
       continue;
     }
-    const classification = classifyFailureReason(standalone[1], {
+    const classification = classifyFailureReason(candidate, {
       duringCollection: false
     });
     if (!classification || classification.reason === "import error during collection") {
@@ -1921,6 +2728,9 @@ function collectFailureLabels(input) {
       pushLabel(summary[2], summary[1] === "FAILED" ? "failed" : "error");
     }
   }
+  for (const block of collectJsFailureBlocks(input)) {
+    pushLabel(block.label, block.status);
+  }
   return labels;
 }
 function classifyBucketTypeFromReason(reason) {
@@ -1930,6 +2740,60 @@ function classifyBucketTypeFromReason(reason) {
   if (reason.startsWith("fixture guard:")) {
     return "fixture_guard_failure";
   }
+  if (reason.startsWith("timeout:")) {
+    return "timeout_failure";
+  }
+  if (reason.startsWith("permission:")) {
+    return "permission_denied_failure";
+  }
+  if (reason.startsWith("async loop:")) {
+    return "async_event_loop_failure";
+  }
+  if (reason.startsWith("fixture teardown:")) {
+    return "fixture_teardown_failure";
+  }
+  if (reason.startsWith("db migration:")) {
+    return "db_migration_failure";
+  }
+  if (reason.startsWith("configuration:")) {
+    return "configuration_error";
+  }
+  if (reason.startsWith("xdist worker crash:")) {
+    return "xdist_worker_crash";
+  }
+  if (reason.startsWith("type error:")) {
+    return "type_error_failure";
+  }
+  if (reason.startsWith("resource leak:")) {
+    return "resource_leak_warning";
+  }
+  if (reason.startsWith("django db access:")) {
+    return "django_db_access_denied";
+  }
+  if (reason.startsWith("network:")) {
+    return "network_failure";
+  }
+  if (reason.startsWith("segfault:")) {
+    return "subprocess_crash_segfault";
+  }
+  if (reason.startsWith("flaky:")) {
+    return "flaky_test_detected";
+  }
+  if (reason.startsWith("serialization:")) {
+    return "serialization_encoding_failure";
+  }
+  if (reason.startsWith("file not found:")) {
+    return "file_not_found_failure";
+  }
+  if (reason.startsWith("memory:")) {
+    return "memory_error";
+  }
+  if (reason.startsWith("deprecation as error:")) {
+    return "deprecation_warning_as_error";
+  }
+  if (reason.startsWith("xfail strict:")) {
+    return "xfail_strict_unexpected_pass";
+  }
   if (reason.startsWith("service unavailable:")) {
     return "service_unavailable";
   }
@@ -1939,6 +2803,9 @@ function classifyBucketTypeFromReason(reason) {
   if (reason.startsWith("auth bypass absent:")) {
     return "auth_bypass_absent";
   }
+  if (reason.startsWith("snapshot mismatch:")) {
+    return "snapshot_mismatch";
+  }
   if (reason.startsWith("missing module:")) {
     return "import_dependency_failure";
   }
@@ -1951,9 +2818,6 @@ function classifyBucketTypeFromReason(reason) {
   return "unknown_failure";
 }
 function synthesizeSharedBlockerBucket(args) {
-  if (args.errors === 0) {
-    return null;
-  }
   const visibleReasonGroups = /* @__PURE__ */ new Map();
   for (const item of args.visibleErrorItems) {
     const entry = visibleReasonGroups.get(item.reason);
@@ -1968,7 +2832,7 @@ function synthesizeSharedBlockerBucket(args) {
       items: [item]
     });
   }
-  const top = [...visibleReasonGroups.entries()].filter(([, entry]) => entry.count >= 3).sort((left, right) => right[1].count - left[1].count)[0];
+  const top = [...visibleReasonGroups.entries()].filter(([reason, entry]) => entry.count >= sharedBlockerThreshold(reason)).sort((left, right) => right[1].count - left[1].count)[0];
   const standaloneReasonGroups = /* @__PURE__ */ new Map();
   for (const classification of collectStandaloneErrorClassifications(args.input)) {
     const entry = standaloneReasonGroups.get(classification.reason);
@@ -1981,7 +2845,7 @@ function synthesizeSharedBlockerBucket(args) {
       group: classification.group
     });
   }
-  const standaloneTop = [...standaloneReasonGroups.entries()].filter(([, entry]) => entry.count >= 3).sort((left, right) => right[1].count - left[1].count)[0];
+  const standaloneTop = [...standaloneReasonGroups.entries()].filter(([reason, entry]) => entry.count >= sharedBlockerThreshold(reason)).sort((left, right) => right[1].count - left[1].count)[0];
   const visibleTopReason = top?.[0];
   const visibleTopStats = top?.[1];
   const standaloneTopReason = standaloneTop?.[0];
@@ -2020,6 +2884,12 @@ function synthesizeSharedBlockerBucket(args) {
   let hint;
   if (envVar) {
     hint = `Set ${envVar} (or pass --pgtest-dsn) before rerunning DB-isolated tests.`;
+  } else if (effectiveReason.startsWith("configuration:")) {
+    hint = "Fix the pytest configuration or conftest import error before rerunning the suite.";
+  } else if (effectiveReason.startsWith("xdist worker crash:")) {
+    hint = "Check shared state, worker startup, or resource contention between xdist workers before rerunning.";
+  } else if (effectiveReason.startsWith("network:")) {
+    hint = "Restore DNS, TLS, or outbound network access for the affected dependency before rerunning.";
   } else if (effectiveReason.startsWith("fixture guard:")) {
     hint = "Unblock the required fixture or setup guard before rerunning the affected tests.";
   } else if (effectiveReason.startsWith("db refused:")) {
@@ -2034,6 +2904,12 @@ function synthesizeSharedBlockerBucket(args) {
   let headline;
   if (envVar) {
     headline = `Shared blocker: ${atLeastPrefix}${countText} errors require ${envVar} for DB-isolated tests.`;
+  } else if (effectiveReason.startsWith("configuration:")) {
+    headline = `Shared blocker: ${atLeastPrefix}${countText} visible failure${countText === 1 ? "" : "s"} are caused by a pytest configuration error.`;
+  } else if (effectiveReason.startsWith("xdist worker crash:")) {
+    headline = `Shared blocker: ${atLeastPrefix}${countText} errors are caused by xdist worker crashes.`;
+  } else if (effectiveReason.startsWith("network:")) {
+    headline = `Shared blocker: ${atLeastPrefix}${countText} errors are caused by a network dependency failure.`;
   } else if (effectiveReason.startsWith("fixture guard:")) {
     headline = `Shared blocker: ${atLeastPrefix}${countText} errors are gated by the same fixture/setup guard.`;
   } else if (effectiveReason.startsWith("db refused:")) {
@@ -2064,11 +2940,17 @@ function synthesizeSharedBlockerBucket(args) {
   };
 }
 function synthesizeImportDependencyBucket(args) {
-  if (args.errors === 0) {
-    return null;
-  }
-  const importItems = args.visibleErrorItems.filter((item) => item.reason.startsWith("missing module:"));
-  if (importItems.length < 2) {
+  const visibleImportItems = args.visibleErrorItems.filter(
+    (item) => item.reason.startsWith("missing module:")
+  );
+  const inlineImportItems = chooseStrongestFailureItems(
+    args.inlineItems.filter((item) => item.reason.startsWith("missing module:"))
+  );
+  const importItems = visibleImportItems.length > 0 ? visibleImportItems : inlineImportItems.map((item) => ({
+    ...item,
+    status: "failed"
+  }));
+  if (importItems.length === 0) {
     return null;
   }
   const allVisibleErrorsAreImportRelated = args.visibleErrorItems.length > 0 && args.visibleErrorItems.every((item) => item.reason.startsWith("missing module:"));
@@ -2079,7 +2961,7 @@ function synthesizeImportDependencyBucket(args) {
     )
   ).slice(0, 6);
   const headlineCount = countClaimed ?? importItems.length;
-  const headline = countClaimed ? `Import/dependency blocker: ${headlineCount} errors are caused by missing dependencies during test collection.` : `Import/dependency blocker: at least ${headlineCount} visible errors are caused by missing dependencies during test collection.`;
+  const headline = countClaimed ? `Import/dependency blocker: ${headlineCount} errors are caused by missing dependencies during test collection.` : `Import/dependency blocker: at least ${headlineCount} visible failure${headlineCount === 1 ? "" : "s"} are caused by missing dependencies during test collection.`;
   const summaryLines = [headline];
   if (modules.length > 0) {
     summaryLines.push(`Missing modules include ${modules.join(", ")}.`);
@@ -2089,7 +2971,7 @@ function synthesizeImportDependencyBucket(args) {
     headline,
     countVisible: importItems.length,
     countClaimed,
-    reason: "missing dependencies during test collection",
+    reason: modules.length === 1 ? `missing module: ${modules[0]}` : "missing dependencies during test collection",
     representativeItems: importItems.slice(0, 4).map((item) => ({
       label: item.label,
       reason: item.reason,
@@ -2108,7 +2990,7 @@ function synthesizeImportDependencyBucket(args) {
   };
 }
 function isContractDriftLabel(label) {
-  return /(freeze|snapshot|contract|manifest|openapi|golden)/i.test(label);
+  return /(freeze|contract|manifest|openapi|golden)/i.test(label);
 }
 function looksLikeTaskKey(value) {
   return /^[a-z]+(?:_[a-z0-9]+)+$/i.test(value) && !value.startsWith("/api/");
@@ -2239,13 +3121,67 @@ function synthesizeContractDriftBucket(args) {
     overflowLabel: "changed entities"
   };
 }
+function synthesizeSnapshotMismatchBucket(args) {
+  const snapshotItems = chooseStrongestFailureItems(
+    args.inlineItems.filter((item) => item.reason.startsWith("snapshot mismatch:"))
+  );
+  if (snapshotItems.length === 0) {
+    return null;
+  }
+  const countClaimed = args.snapshotFailures && args.snapshotFailures >= snapshotItems.length ? args.snapshotFailures : void 0;
+  const countText = countClaimed ?? snapshotItems.length;
+  const summaryLines = [
+    `Snapshot mismatches: ${formatCount2(countText, "snapshot expectation")} ${countText === 1 ? "is" : "are"} out of date with current output.`
+  ];
+  return {
+    type: "snapshot_mismatch",
+    headline: summaryLines[0],
+    countVisible: snapshotItems.length,
+    countClaimed,
+    reason: "snapshot mismatch: snapshot expectations differ from current output",
+    representativeItems: snapshotItems.slice(0, 4),
+    entities: snapshotItems.map((item) => item.label.split(" > ").slice(1).join(" > ").trim() || item.label).slice(0, 6),
+    hint: "Update the snapshots if these output changes are intentional.",
+    confidence: countClaimed ? 0.92 : 0.8,
+    summaryLines,
+    overflowCount: Math.max((countClaimed ?? snapshotItems.length) - Math.min(snapshotItems.length, 4), 0),
+    overflowLabel: "snapshot failures"
+  };
+}
+function synthesizeTimeoutBucket(args) {
+  const timeoutItems = chooseStrongestFailureItems(
+    args.inlineItems.filter((item) => item.reason.startsWith("timeout:"))
+  );
+  if (timeoutItems.length === 0) {
+    return null;
+  }
+  const summaryLines = [
+    `Timeout failures: ${formatCount2(timeoutItems.length, "test")} exceeded the configured timeout threshold.`
+  ];
+  return {
+    type: "timeout_failure",
+    headline: summaryLines[0],
+    countVisible: timeoutItems.length,
+    countClaimed: timeoutItems.length,
+    reason: timeoutItems.length === 1 ? timeoutItems[0].reason : "timeout: tests exceeded the configured timeout threshold",
+    representativeItems: timeoutItems.slice(0, 4),
+    entities: timeoutItems.map((item) => item.label.split(" > ").slice(1).join(" > ").trim() || item.label).slice(0, 6),
+    hint: "Check for deadlocks, slow setup, or increase the timeout threshold before rerunning.",
+    confidence: 0.84,
+    summaryLines,
+    overflowCount: Math.max(timeoutItems.length - Math.min(timeoutItems.length, 4), 0),
+    overflowLabel: "timeout failures"
+  };
+}
 function analyzeTestStatus(input) {
-  const passed = getCount(input, "passed");
-  const failed = getCount(input, "failed");
-  const errors = Math.max(getCount(input, "errors"), getCount(input, "error"));
-  const skipped = getCount(input, "skipped");
+  const runner = detectTestRunner(input);
+  const counts = extractTestStatusCounts(input, runner);
+  const passed = counts.passed;
+  const failed = counts.failed;
+  const errors = counts.errors;
+  const skipped = counts.skipped;
   const collectionErrors = input.match(/(\d+)\s+errors?\s+during collection/i);
-  const noTestsCollected = /\bcollected\s+0\s+items\b/i.test(input) || /\bno tests ran\b/i.test(input);
+  const noTestsCollected = /\bcollected\s+0\s+items\b/i.test(input) || /\bno tests ran\b/i.test(input) || /No test suite found in file/i.test(input) || /No test found in suite/i.test(input);
   const interrupted = /\binterrupted\b/i.test(input) || /\bKeyboardInterrupt\b/i.test(input);
   const collectionItems = chooseStrongestFailureItems(collectCollectionFailureItems(input));
   const inlineItems = chooseStrongestFailureItems(collectInlineFailureItems(input));
@@ -2272,7 +3208,8 @@ function analyzeTestStatus(input) {
   if (!sharedBlocker) {
     const importDependencyBucket = synthesizeImportDependencyBucket({
       errors,
-      visibleErrorItems
+      visibleErrorItems,
+      inlineItems
     });
     if (importDependencyBucket) {
       buckets.push(importDependencyBucket);
@@ -2285,11 +3222,26 @@ function analyzeTestStatus(input) {
   if (contractDrift) {
     buckets.push(contractDrift);
   }
+  const snapshotMismatch = synthesizeSnapshotMismatchBucket({
+    inlineItems,
+    snapshotFailures: counts.snapshotFailures
+  });
+  if (snapshotMismatch) {
+    buckets.push(snapshotMismatch);
+  }
+  const timeoutBucket = synthesizeTimeoutBucket({
+    inlineItems
+  });
+  if (timeoutBucket) {
+    buckets.push(timeoutBucket);
+  }
   return {
+    runner,
     passed,
     failed,
     errors,
     skipped,
+    snapshotFailures: counts.snapshotFailures,
     noTestsCollected,
     interrupted,
     collectionErrorCount: collectionErrors ? Number(collectionErrors[1]) : void 0,
@@ -3875,10 +4827,29 @@ var detailSchema = z2.enum(["standard", "focused", "verbose"]);
 var failureBucketTypeSchema = z2.enum([
   "shared_environment_blocker",
   "fixture_guard_failure",
+  "timeout_failure",
+  "permission_denied_failure",
+  "async_event_loop_failure",
+  "fixture_teardown_failure",
+  "db_migration_failure",
+  "configuration_error",
+  "xdist_worker_crash",
+  "type_error_failure",
+  "resource_leak_warning",
+  "django_db_access_denied",
+  "network_failure",
+  "subprocess_crash_segfault",
+  "flaky_test_detected",
+  "serialization_encoding_failure",
+  "file_not_found_failure",
+  "memory_error",
+  "deprecation_warning_as_error",
+  "xfail_strict_unexpected_pass",
   "service_unavailable",
   "db_connection_failure",
   "auth_bypass_absent",
   "contract_snapshot_drift",
+  "snapshot_mismatch",
   "import_dependency_failure",
   "collection_failure",
   "assertion_failure",