@bilalimamoglu/sift 0.3.0 → 0.3.1

package/dist/index.js

@@ -62,7 +62,7 @@ function evaluateGate(args) {
 // src/core/testStatusDecision.ts
 import { z } from "zod";
 var TEST_STATUS_DIAGNOSE_JSON_CONTRACT = '{"status":"ok|insufficient","diagnosis_complete":boolean,"raw_needed":boolean,"additional_source_read_likely_low_value":boolean,"read_raw_only_if":string|null,"decision":"stop|zoom|read_source|read_raw","dominant_blocker_bucket_index":number|null,"provider_used":boolean,"provider_confidence":number|null,"provider_failed":boolean,"raw_slice_used":boolean,"raw_slice_strategy":"none|bucket_evidence|traceback_window|head_tail","resolved_summary":{"count":number,"families":[{"prefix":string,"count":number}]},"remaining_summary":{"count":number,"families":[{"prefix":string,"count":number}]},"remaining_subset_available":boolean,"main_buckets":[{"bucket_index":number,"label":string,"count":number,"root_cause":string,"evidence":string[],"bucket_confidence":number,"root_cause_confidence":number,"dominant":boolean,"secondary_visible_despite_blocker":boolean,"mini_diff":{"added_paths"?:number,"removed_models"?:number,"changed_task_mappings"?:number}|null}],"read_targets":[{"file":string,"line":number|null,"why":string,"bucket_index":number,"context_hint":{"start_line":number|null,"end_line":number|null,"search_hint":string|null}}],"next_best_action":{"code":"fix_dominant_blocker|read_source_for_bucket|read_raw_for_exact_traceback|insufficient_signal","bucket_index":number|null,"note":string},"resolved_tests"?:string[],"remaining_tests"?:string[]}';
-var TEST_STATUS_PROVIDER_SUPPLEMENT_JSON_CONTRACT = '{"diagnosis_complete":boolean,"raw_needed":boolean,"additional_source_read_likely_low_value":boolean,"read_raw_only_if":string|null,"decision":"stop|zoom|read_source|read_raw","provider_confidence":number|null,"next_best_action":{"code":"fix_dominant_blocker|read_source_for_bucket|read_raw_for_exact_traceback|insufficient_signal","bucket_index":number|null,"note":string}}';
+var TEST_STATUS_PROVIDER_SUPPLEMENT_JSON_CONTRACT = '{"diagnosis_complete":boolean,"raw_needed":boolean,"additional_source_read_likely_low_value":boolean,"read_raw_only_if":string|null,"decision":"stop|zoom|read_source|read_raw","provider_confidence":number|null,"bucket_supplements":[{"label":string,"count":number,"root_cause":string,"anchor":{"file":string|null,"line":number|null,"search_hint":string|null},"fix_hint":string|null,"confidence":number}],"next_best_action":{"code":"fix_dominant_blocker|read_source_for_bucket|read_raw_for_exact_traceback|insufficient_signal","bucket_index":number|null,"note":string}}';
 var nextBestActionSchema = z.object({
   code: z.enum([
     "fix_dominant_blocker",
@@ -80,6 +80,20 @@ var testStatusProviderSupplementSchema = z.object({
   read_raw_only_if: z.string().nullable(),
   decision: z.enum(["stop", "zoom", "read_source", "read_raw"]),
   provider_confidence: z.number().min(0).max(1).nullable(),
+  bucket_supplements: z.array(
+    z.object({
+      label: z.string().min(1),
+      count: z.number().int().positive(),
+      root_cause: z.string().min(1),
+      anchor: z.object({
+        file: z.string().nullable(),
+        line: z.number().int().nullable(),
+        search_hint: z.string().nullable()
+      }),
+      fix_hint: z.string().nullable(),
+      confidence: z.number().min(0).max(1)
+    })
+  ).max(2),
   next_best_action: nextBestActionSchema
 });
 var testStatusDiagnoseContractSchema = z.object({
@@ -231,14 +245,73 @@ function classifyGenericBucketType(reason) {
   }
   return "unknown_failure";
 }
+function isUnknownBucket(bucket) {
+  return bucket.source === "unknown" || bucket.reason.startsWith("unknown ");
+}
+function classifyVisibleStatusForLabel(args) {
+  const isError = args.errorLabels.has(args.label);
+  const isFailed = args.failedLabels.has(args.label);
+  if (isError && isFailed) {
+    return "mixed";
+  }
+  if (isError) {
+    return "error";
+  }
+  if (isFailed) {
+    return "failed";
+  }
+  return "unknown";
+}
+function inferCoverageFromReason(reason) {
+  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";
+  }
+  if (reason.startsWith("assertion failed:")) {
+    return "failed";
+  }
+  return "mixed";
+}
+function buildCoverageCounts(args) {
+  if (args.coverageKind === "error") {
+    return {
+      error: args.count,
+      failed: 0
+    };
+  }
+  if (args.coverageKind === "failed") {
+    return {
+      error: 0,
+      failed: args.count
+    };
+  }
+  return {
+    error: 0,
+    failed: 0
+  };
+}
 function buildGenericBuckets(analysis) {
   const buckets = [];
   const grouped = /* @__PURE__ */ new Map();
+  const errorLabels = new Set(analysis.visibleErrorLabels);
+  const failedLabels = new Set(analysis.visibleFailedLabels);
   const push = (reason, item) => {
-    const key = `${classifyGenericBucketType(reason)}:${reason}`;
+    const coverageKind = (() => {
+      const status = classifyVisibleStatusForLabel({
+        label: item.label,
+        errorLabels,
+        failedLabels
+      });
+      return status === "unknown" ? inferCoverageFromReason(reason) : status;
+    })();
+    const key = `${classifyGenericBucketType(reason)}:${coverageKind}:${reason}`;
     const existing = grouped.get(key);
     if (existing) {
       existing.count += 1;
+      if (coverageKind === "error") {
+        existing.coverage.error += 1;
+      } else if (coverageKind === "failed") {
+        existing.coverage.failed += 1;
+      }
       if (!existing.representativeItems.some((entry) => entry.label === item.label) && existing.representativeItems.length < 6) {
         existing.representativeItems.push(item);
       }
@@ -255,7 +328,12 @@ function buildGenericBuckets(analysis) {
       entities: [],
       hint: void 0,
       overflowCount: 0,
-      overflowLabel: "failing tests/modules"
+      overflowLabel: "failing tests/modules",
+      coverage: buildCoverageCounts({
+        count: 1,
+        coverageKind
+      }),
+      source: "heuristic"
     });
   };
   for (const item of [...analysis.collectionItems, ...analysis.inlineItems]) {
@@ -308,10 +386,51 @@ function mergeBucketDetails(existing, incoming) {
       incoming.overflowCount,
       count - representativeItems.length
     ),
-    overflowLabel: existing.overflowLabel || incoming.overflowLabel
+    overflowLabel: existing.overflowLabel || incoming.overflowLabel,
+    labelOverride: existing.labelOverride ?? incoming.labelOverride,
+    coverage: {
+      error: Math.max(existing.coverage.error, incoming.coverage.error),
+      failed: Math.max(existing.coverage.failed, incoming.coverage.failed)
+    },
+    source: existing.source
+  };
+}
+function inferFailureBucketCoverage(bucket, analysis) {
+  const errorLabels = new Set(analysis.visibleErrorLabels);
+  const failedLabels = new Set(analysis.visibleFailedLabels);
+  let error = 0;
+  let failed = 0;
+  for (const item of bucket.representativeItems) {
+    const status = classifyVisibleStatusForLabel({
+      label: item.label,
+      errorLabels,
+      failedLabels
+    });
+    if (status === "error") {
+      error += 1;
+    } else if (status === "failed") {
+      failed += 1;
+    }
+  }
+  const claimed = bucket.countClaimed ?? bucket.countVisible;
+  if (bucket.type === "contract_snapshot_drift" || bucket.type === "assertion_failure") {
+    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") {
+    return {
+      error: Math.max(error, claimed),
+      failed
+    };
+  }
+  return {
+    error,
+    failed
   };
 }
-function mergeBuckets(analysis) {
+function mergeBuckets(analysis, extraBuckets = []) {
   const mergedByIdentity = /* @__PURE__ */ new Map();
   const merged = [];
   const pushBucket = (bucket) => {
@@ -340,7 +459,9 @@ function mergeBuckets(analysis) {
     entities: [...bucket2.entities],
     hint: bucket2.hint,
     overflowCount: bucket2.overflowCount,
-    overflowLabel: bucket2.overflowLabel
+    overflowLabel: bucket2.overflowLabel,
+    coverage: inferFailureBucketCoverage(bucket2, analysis),
+    source: "heuristic"
   }))) {
     pushBucket(bucket);
   }
@@ -364,6 +485,9 @@ function mergeBuckets(analysis) {
       coveredLabels.add(item.label);
     }
   }
+  for (const bucket of extraBuckets) {
+    pushBucket(bucket);
+  }
   return merged;
 }
 function dominantBucketPriority(bucket) {
@@ -379,6 +503,9 @@ function dominantBucketPriority(bucket) {
   if (bucket.type === "collection_failure") {
     return 2;
   }
+  if (isUnknownBucket(bucket)) {
+    return 2;
+  }
   if (bucket.type === "contract_snapshot_drift") {
     return 1;
   }
@@ -403,6 +530,9 @@ function isDominantBlockerType(type) {
   return type === "shared_environment_blocker" || type === "import_dependency_failure" || type === "collection_failure";
 }
 function labelForBucket(bucket) {
+  if (bucket.labelOverride) {
+    return bucket.labelOverride;
+  }
   if (bucket.reason.startsWith("missing test env:")) {
     return "missing test env";
   }
@@ -442,15 +572,27 @@ function labelForBucket(bucket) {
   if (bucket.type === "runtime_failure") {
     return "runtime failure";
   }
+  if (bucket.reason.startsWith("unknown setup blocker:")) {
+    return "unknown setup blocker";
+  }
+  if (bucket.reason.startsWith("unknown failure family:")) {
+    return "unknown failure family";
+  }
   return "unknown failure";
 }
 function rootCauseConfidenceFor(bucket) {
+  if (isUnknownBucket(bucket)) {
+    return 0.52;
+  }
   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;
   }
   if (bucket.type === "contract_snapshot_drift") {
     return bucket.entities.length > 0 ? 0.92 : 0.76;
   }
+  if (bucket.source === "provider") {
+    return Math.max(0.6, Math.min(bucket.confidence, 0.82));
+  }
   return Math.max(0.6, Math.min(bucket.confidence, 0.88));
 }
 function buildBucketEvidence(bucket) {
@@ -494,6 +636,12 @@ function buildReadTargetWhy(args) {
   if (args.bucket.reason.startsWith("auth bypass absent:")) {
     return "it contains the auth bypass setup behind this bucket";
   }
+  if (args.bucket.reason.startsWith("unknown setup blocker:")) {
+    return "it is the first anchored setup failure in this unknown bucket";
+  }
+  if (args.bucket.reason.startsWith("unknown failure family:")) {
+    return "it is the first anchored failing test in this unknown bucket";
+  }
   if (args.bucket.type === "contract_snapshot_drift") {
     if (args.bucketLabel === "route drift") {
       return "it maps to the visible route drift bucket";
@@ -543,6 +691,9 @@ function buildReadTargetSearchHint(bucket, anchor) {
   if (assertionText) {
     return assertionText;
   }
+  if (bucket.reason.startsWith("unknown ")) {
+    return anchor.reason;
+  }
   const fallbackLabel = anchor.label.split("::")[1]?.trim();
   return fallbackLabel || null;
 }
@@ -602,6 +753,12 @@ function buildConcreteNextNote(args) {
   if (args.nextBestAction.code === "read_source_for_bucket") {
     return lead;
   }
+  if (args.nextBestAction.code === "insufficient_signal") {
+    if (args.nextBestAction.note.startsWith("Provider follow-up failed")) {
+      return args.nextBestAction.note;
+    }
+    return `${lead} Then take one deeper sift pass before raw traceback.`;
+  }
   return args.nextBestAction.note;
 }
 function extractMiniDiff(input, bucket) {
@@ -626,6 +783,152 @@ function extractMiniDiff(input, bucket) {
     ...changedTaskMappings > 0 ? { changed_task_mappings: changedTaskMappings } : {}
   };
 }
+function inferSupplementCoverageKind(args) {
+  const normalized = `${args.label} ${args.rootCause}`.toLowerCase();
+  if (/env|setup|fixture|import|dependency|service|db|database|auth bypass|collection|connection refused/.test(
+    normalized
+  )) {
+    return "error";
+  }
+  if (/snapshot|contract|drift|assertion|expected|actual|golden/.test(normalized)) {
+    return "failed";
+  }
+  if (args.remainingErrors > 0 && args.remainingFailed === 0) {
+    return "error";
+  }
+  return "failed";
+}
+function buildProviderSupplementBuckets(args) {
+  let remainingErrors = args.remainingErrors;
+  let remainingFailed = args.remainingFailed;
+  return args.supplements.flatMap((supplement) => {
+    const coverageKind = inferSupplementCoverageKind({
+      label: supplement.label,
+      rootCause: supplement.root_cause,
+      remainingErrors,
+      remainingFailed
+    });
+    const budget = coverageKind === "error" ? remainingErrors : remainingFailed;
+    const count = Math.max(0, Math.min(supplement.count, budget));
+    if (count === 0) {
+      return [];
+    }
+    if (coverageKind === "error") {
+      remainingErrors -= count;
+    } else {
+      remainingFailed -= count;
+    }
+    const representativeLabel = supplement.anchor.file ?? `${supplement.label} supplement`;
+    const representativeItem = {
+      label: representativeLabel,
+      reason: supplement.root_cause,
+      group: supplement.label,
+      file: supplement.anchor.file,
+      line: supplement.anchor.line,
+      anchor_kind: supplement.anchor.file && supplement.anchor.line !== null ? "traceback" : supplement.anchor.file ? "test_label" : supplement.anchor.search_hint ? "entity" : "none",
+      anchor_confidence: Math.max(0.4, Math.min(supplement.confidence, 0.82))
+    };
+    return [
+      {
+        type: classifyGenericBucketType(supplement.root_cause),
+        headline: `${supplement.label}: ${formatCount(count, "visible failure")} share ${supplement.root_cause}.`,
+        summaryLines: [
+          `${supplement.label}: ${formatCount(count, "visible failure")} share ${supplement.root_cause}.`
+        ],
+        reason: supplement.root_cause,
+        count,
+        confidence: Math.max(0.4, Math.min(supplement.confidence, 0.82)),
+        representativeItems: [representativeItem],
+        entities: supplement.anchor.search_hint ? [supplement.anchor.search_hint] : [],
+        hint: supplement.fix_hint ?? void 0,
+        overflowCount: Math.max(count - 1, 0),
+        overflowLabel: "failing tests/modules",
+        labelOverride: supplement.label,
+        coverage: buildCoverageCounts({
+          count,
+          coverageKind
+        }),
+        source: "provider"
+      }
+    ];
+  });
+}
+function pickUnknownAnchor(args) {
+  const fromStatusItems = args.kind === "error" ? args.analysis.visibleErrorItems[0] : null;
+  if (fromStatusItems) {
+    return {
+      label: fromStatusItems.label,
+      reason: fromStatusItems.reason,
+      group: fromStatusItems.group,
+      file: fromStatusItems.file,
+      line: fromStatusItems.line,
+      anchor_kind: fromStatusItems.anchor_kind,
+      anchor_confidence: fromStatusItems.anchor_confidence
+    };
+  }
+  const label = args.kind === "error" ? args.analysis.visibleErrorLabels[0] : args.analysis.visibleFailedLabels[0];
+  if (label) {
+    const normalizedLabel = normalizeTestId(label);
+    const fileMatch = normalizedLabel.match(/^([A-Za-z0-9_./-]+\.[A-Za-z0-9]+)\b/);
+    const file = fileMatch?.[1] ?? normalizedLabel.split("::")[0] ?? null;
+    return {
+      label,
+      reason: args.kind === "error" ? "setup failures share a repeated but unclassified pattern" : "failing tests share a repeated but unclassified pattern",
+      group: args.kind === "error" ? "unknown setup blocker" : "unknown failure family",
+      file: file && file !== label ? file : null,
+      line: null,
+      anchor_kind: file && file !== label ? "test_label" : "none",
+      anchor_confidence: file && file !== label ? 0.6 : 0
+    };
+  }
+  return null;
+}
+function buildUnknownBucket(args) {
+  if (args.count <= 0) {
+    return null;
+  }
+  const anchor = pickUnknownAnchor(args);
+  const isError = args.kind === "error";
+  const label = isError ? "unknown setup blocker" : "unknown failure family";
+  const reason = isError ? "unknown setup blocker: setup failures share a repeated but unclassified pattern" : "unknown failure family: failing tests share a repeated but unclassified pattern";
+  return {
+    type: "unknown_failure",
+    headline: `${label}: ${formatCount(args.count, "visible failure")} share a repeated but unclassified pattern.`,
+    summaryLines: [
+      `${label}: ${formatCount(args.count, "visible failure")} share a repeated but unclassified pattern.`
+    ],
+    reason,
+    count: args.count,
+    confidence: 0.45,
+    representativeItems: anchor ? [anchor] : [],
+    entities: [],
+    hint: isError ? "Take one deeper sift pass or inspect the first anchored setup failure." : "Take one deeper sift pass or inspect the first anchored failing test.",
+    overflowCount: Math.max(args.count - (anchor ? 1 : 0), 0),
+    overflowLabel: "failing tests/modules",
+    labelOverride: label,
+    coverage: buildCoverageCounts({
+      count: args.count,
+      coverageKind: isError ? "error" : "failed"
+    }),
+    source: "unknown"
+  };
+}
+function buildCoverageResiduals(args) {
+  const covered = args.buckets.reduce(
+    (totals, bucket) => ({
+      error: totals.error + bucket.coverage.error,
+      failed: totals.failed + bucket.coverage.failed
+    }),
+    {
+      error: 0,
+      failed: 0
+    }
+  );
+  return {
+    remainingErrors: Math.max(args.analysis.errors - Math.min(args.analysis.errors, covered.error), 0),
+    remainingFailed: Math.max(args.analysis.failed - Math.min(args.analysis.failed, covered.failed), 0)
+  };
+}
 function buildOutcomeLines(analysis) {
   if (analysis.noTestsCollected) {
     return ["- Tests did not run.", "- Collected 0 items."];
@@ -744,6 +1047,12 @@ function buildStandardFixText(args) {
   if (args.bucket.reason.startsWith("auth bypass absent:")) {
     return "Restore the test auth bypass setup and rerun the full suite at standard.";
   }
+  if (args.bucket.reason.startsWith("unknown setup blocker:")) {
+    return "Take one deeper sift pass or inspect the first anchored setup failure before rerunning.";
+  }
+  if (args.bucket.reason.startsWith("unknown failure family:")) {
+    return "Take one deeper sift pass or inspect the first anchored failing test before rerunning.";
+  }
   if (args.bucket.type === "contract_snapshot_drift") {
     return "Review the visible drift and regenerate the contract snapshots if the changes are intentional.";
   }
@@ -840,7 +1149,35 @@ function renderVerbose(args) {
   return lines.join("\n");
 }
 function buildTestStatusDiagnoseContract(args) {
-  const buckets = prioritizeBuckets(mergeBuckets(args.analysis)).slice(0, 3);
+  const heuristicBuckets = mergeBuckets(args.analysis);
+  const preUnknownSimpleCollectionFailure = args.analysis.collectionErrorCount !== void 0 && args.analysis.collectionItems.length === 0 && heuristicBuckets.length === 0 && (args.providerBucketSupplements?.length ?? 0) === 0;
+  const heuristicResiduals = buildCoverageResiduals({
+    analysis: args.analysis,
+    buckets: heuristicBuckets
+  });
+  const providerSupplementBuckets = buildProviderSupplementBuckets({
+    supplements: args.providerBucketSupplements ?? [],
+    remainingErrors: heuristicResiduals.remainingErrors,
+    remainingFailed: heuristicResiduals.remainingFailed
+  });
+  const combinedBuckets = mergeBuckets(args.analysis, providerSupplementBuckets);
+  const residuals = buildCoverageResiduals({
+    analysis: args.analysis,
+    buckets: combinedBuckets
+  });
+  const unknownBuckets = preUnknownSimpleCollectionFailure ? [] : [
+    buildUnknownBucket({
+      analysis: args.analysis,
+      kind: "error",
+      count: residuals.remainingErrors
+    }),
+    buildUnknownBucket({
+      analysis: args.analysis,
+      kind: "failed",
+      count: residuals.remainingFailed
+    })
+  ].filter((bucket) => Boolean(bucket));
+  const buckets = prioritizeBuckets([...combinedBuckets, ...unknownBuckets]).slice(0, 3);
   const simpleCollectionFailure = args.analysis.collectionErrorCount !== void 0 && args.analysis.collectionItems.length === 0 && buckets.length === 0;
   const dominantBucket = buckets.map((bucket, index) => ({
     bucket,
@@ -851,8 +1188,10 @@ function buildTestStatusDiagnoseContract(args) {
     }
     return right.bucket.confidence - left.bucket.confidence;
   })[0] ?? null;
-  const diagnosisComplete = args.analysis.failed === 0 && args.analysis.errors === 0 && args.analysis.passed > 0 || simpleCollectionFailure || buckets.length > 0 && (dominantBucket?.bucket.confidence ?? 0) >= 0.7;
-  const rawNeeded = buckets.length > 0 ? buckets.every((bucket) => bucket.confidence < 0.7) : !(args.analysis.failed === 0 && args.analysis.errors === 0 && args.analysis.passed > 0 || simpleCollectionFailure);
+  const hasUnknownBucket = buckets.some((bucket) => isUnknownBucket(bucket));
+  const hasConcreteCoverage = args.analysis.failed === 0 && args.analysis.errors === 0 ? true : residuals.remainingErrors === 0 && residuals.remainingFailed === 0;
+  const diagnosisComplete = args.analysis.failed === 0 && args.analysis.errors === 0 && args.analysis.passed > 0 || simpleCollectionFailure || buckets.length > 0 && hasConcreteCoverage && !hasUnknownBucket && (dominantBucket?.bucket.confidence ?? 0) >= 0.6;
+  const rawNeeded = buckets.length === 0 ? !(args.analysis.failed === 0 && args.analysis.errors === 0 && args.analysis.passed > 0 || simpleCollectionFailure) : !diagnosisComplete && !hasUnknownBucket && buckets.every((bucket) => bucket.confidence < 0.7);
   const dominantBlockerBucketIndex = dominantBucket && isDominantBlockerType(dominantBucket.bucket.type) ? dominantBucket.index + 1 : null;
   const readTargets = buildReadTargets({
     buckets,
@@ -887,6 +1226,12 @@ function buildTestStatusDiagnoseContract(args) {
       bucket_index: null,
       note: "Inspect the collection traceback or setup code next; the run failed before tests executed."
     };
+  } else if (hasUnknownBucket) {
+    nextBestAction = {
+      code: "insufficient_signal",
+      bucket_index: dominantBucket ? dominantBucket.index + 1 : null,
+      note: "Take one deeper sift pass or inspect the first anchored failure before falling back to raw traceback."
+    };
   } else if (!diagnosisComplete) {
     nextBestAction = {
       code: rawNeeded ? "read_raw_for_exact_traceback" : "insufficient_signal",
@@ -924,11 +1269,15 @@ function buildTestStatusDiagnoseContract(args) {
     read_targets: readTargets,
     next_best_action: nextBestAction
   };
+  const effectiveDiagnosisComplete = Boolean(args.contractOverrides?.diagnosis_complete ?? diagnosisComplete) && !hasUnknownBucket;
+  const requestedDecision = args.contractOverrides?.decision;
+  const effectiveDecision = hasUnknownBucket && requestedDecision && (requestedDecision === "stop" || requestedDecision === "read_source") ? "zoom" : requestedDecision;
   const effectiveNextBestAction = args.contractOverrides?.next_best_action ?? baseContract.next_best_action;
   const mergedContractWithoutDecision = {
     ...baseContract,
     ...args.contractOverrides,
-    status: args.contractOverrides?.diagnosis_complete ?? diagnosisComplete ? "ok" : "insufficient",
+    diagnosis_complete: effectiveDiagnosisComplete,
+    status: effectiveDiagnosisComplete ? "ok" : "insufficient",
     next_best_action: {
       ...effectiveNextBestAction,
       note: buildConcreteNextNote({
@@ -942,7 +1291,7 @@ function buildTestStatusDiagnoseContract(args) {
   };
   const contract = testStatusDiagnoseContractSchema.parse({
     ...mergedContractWithoutDecision,
-    decision: args.contractOverrides?.decision ?? deriveDecision(mergedContractWithoutDecision)
+    decision: effectiveDecision ?? deriveDecision(mergedContractWithoutDecision)
   });
   return {
     contract,
@@ -1162,7 +1511,25 @@ function extractEnvBlockerName(normalized) {
   const fallbackMatch = normalized.match(
     /\b([A-Z][A-Z0-9_]{2,})\b(?=[^.\n]*DB-isolated tests)/
   );
-  return fallbackMatch?.[1] ?? null;
+  if (fallbackMatch) {
+    return fallbackMatch[1];
+  }
+  const leadingEnvMatch = normalized.match(
+    /\b([A-Z][A-Z0-9_]{2,})\b(?=[^.\n]{0,80}\b(?:is\s+)?(?:missing|unset|not set|not configured|required)\b)/
+  );
+  if (leadingEnvMatch) {
+    return leadingEnvMatch[1];
+  }
+  const trailingEnvMatch = normalized.match(
+    /\b(?:missing|unset|not set|not configured|required)\b[^.\n]{0,80}\b([A-Z][A-Z0-9_]{2,})\b/
+  );
+  if (trailingEnvMatch) {
+    return trailingEnvMatch[1];
+  }
+  const validationEnvMatch = normalized.match(
+    /\bValidationError\b[^.\n]{0,120}\b([A-Z][A-Z0-9_]{2,})\b/
+  );
+  return validationEnvMatch?.[1] ?? null;
 }
 function classifyFailureReason(line, options) {
   const normalized = line.trim().replace(/^[A-Z]\s+/, "");
@@ -1183,7 +1550,7 @@ function classifyFailureReason(line, options) {
     };
   }
   const missingEnv = normalized.match(
-    /\b(?:environment variable|env(?:ironment)? var(?:iable)?|Missing required env(?:ironment)? variable)\s+([A-Z][A-Z0-9_]{2,})\b/i
+    /\b(?:environment variable|env(?:ironment)? var(?:iable)?|missing required env(?:ironment)? variable)\s+([A-Z][A-Z0-9_]{2,})\b/
   );
   if (missingEnv) {
     return {
@@ -1215,6 +1582,12 @@ function classifyFailureReason(line, options) {
       group: "database connectivity failures"
     };
   }
+  if (/(ECONNREFUSED|ConnectionRefusedError|connection refused)/i.test(normalized)) {
+    return {
+      reason: "service unavailable: dependency connection was refused",
+      group: "service availability failures"
+    };
+  }
   if (/(503\b|service unavailable|temporarily unavailable)/i.test(normalized)) {
     return {
       reason: "service unavailable: dependency service is unavailable",
@@ -1699,7 +2072,7 @@ function synthesizeImportDependencyBucket(args) {
     return null;
   }
   const allVisibleErrorsAreImportRelated = args.visibleErrorItems.length > 0 && args.visibleErrorItems.every((item) => item.reason.startsWith("missing module:"));
-  const countClaimed = allVisibleErrorsAreImportRelated && importItems.length >= 3 && args.errors >= importItems.length ? args.errors : void 0;
+  const countClaimed = allVisibleErrorsAreImportRelated && importItems.length >= 2 && args.errors >= importItems.length ? args.errors : void 0;
   const modules = Array.from(
     new Set(
       importItems.map((item) => item.reason.replace("missing module:", "").trim()).filter(Boolean)
@@ -1735,7 +2108,7 @@ function synthesizeImportDependencyBucket(args) {
   };
 }
 function isContractDriftLabel(label) {
-  return /(freeze|snapshot|contract|manifest|openapi)/i.test(label);
+  return /(freeze|snapshot|contract|manifest|openapi|golden)/i.test(label);
 }
 function looksLikeTaskKey(value) {
   return /^[a-z]+(?:_[a-z0-9]+)+$/i.test(value) && !value.startsWith("/api/");
@@ -2224,10 +2597,11 @@ async function buildOpenAICompatibleError(response) {
   return new Error(detail);
 }
 var OpenAICompatibleProvider = class {
-  name = "openai-compatible";
+  name;
   baseUrl;
   apiKey;
   constructor(options) {
+    this.name = options.name ?? "openai-compatible";
     this.baseUrl = options.baseUrl.replace(/\/$/, "");
     this.apiKey = options.apiKey;
   }
@@ -2303,6 +2677,13 @@ function createProvider(config) {
       apiKey: config.provider.apiKey
     });
   }
+  if (config.provider.provider === "openrouter") {
+    return new OpenAICompatibleProvider({
+      baseUrl: config.provider.baseUrl,
+      apiKey: config.provider.apiKey,
+      name: "openrouter"
+    });
+  }
   throw new Error(`Unsupported provider: ${config.provider.provider}`);
 }
 
@@ -2475,9 +2856,12 @@ function resolvePromptPolicy(args) {
         "Return only valid JSON.",
         `Use this exact contract: ${args.outputContract ?? TEST_STATUS_DIAGNOSE_JSON_CONTRACT}.`,
         "Treat the heuristic context as extraction guidance, but do not invent hidden failures.",
-        "Use the heuristic extract as the bucket truth unless the visible command output clearly disproves it.",
+        "Use the heuristic extract as the base bucket truth unless the visible command output clearly disproves it.",
+        "If some visible failure or error families remain unexplained, add at most 2 bucket_supplements for the residual families only.",
+        "Do not rewrite or delete heuristic buckets; only supplement missing residual coverage.",
+        "Keep bucket_supplement counts within the unexplained residual failures or errors.",
         "Identify the dominant blocker, remaining visible failure buckets, the decision, and the next best action.",
-        "Set diagnosis_complete to true only when the visible output is already sufficient to stop and act.",
+        "Set diagnosis_complete to true only when the visible output is already sufficient to stop and act and no unknown residual family remains.",
         "Set raw_needed to true only when exact traceback lines are still required.",
         "Set provider_confidence to a number between 0 and 1, or null only when confidence cannot be estimated."
       ] : [
@@ -2994,6 +3378,7 @@ function buildGenericRawSlice(args) {
 
 // src/core/run.ts
 var RETRY_DELAY_MS = 300;
+var PROVIDER_PENDING_NOTICE_DELAY_MS = 150;
 function estimateTokenCount(text) {
   return Math.max(1, Math.ceil(text.length / 4));
 }
@@ -3014,6 +3399,8 @@ function logVerboseTestStatusTelemetry(args) {
     `${pc.dim("sift")} diagnosis_complete_at_layer=${getDiagnosisCompleteAtLayer(args.contract)}`,
     `${pc.dim("sift")} heuristic_short_circuit=${!args.contract.provider_used && args.contract.diagnosis_complete && !args.contract.raw_needed && !args.contract.provider_failed}`,
     `${pc.dim("sift")} raw_input_chars=${args.request.stdin.length}`,
+    `${pc.dim("sift")} heuristic_input_chars=${args.heuristicInputChars}`,
+    `${pc.dim("sift")} heuristic_input_truncated=${args.heuristicInputTruncated}`,
     `${pc.dim("sift")} prepared_input_chars=${args.prepared.meta.finalLength}`,
     `${pc.dim("sift")} raw_slice_chars=${args.rawSliceChars ?? 0}`,
     `${pc.dim("sift")} provider_input_chars=${args.providerInputChars ?? 0}`,
@@ -3055,6 +3442,7 @@ function buildDryRunOutput(args) {
       responseMode: args.responseMode,
       policy: args.request.policyName ?? null,
       heuristicOutput: args.heuristicOutput ?? null,
+      heuristicInput: args.heuristicInput,
       input: {
         originalLength: args.prepared.meta.originalLength,
         finalLength: args.prepared.meta.finalLength,
@@ -3071,6 +3459,25 @@ function buildDryRunOutput(args) {
 async function delay(ms) {
   await new Promise((resolve) => setTimeout(resolve, ms));
 }
+function startProviderPendingNotice() {
+  if (!process.stderr.isTTY) {
+    return () => {
+    };
+  }
+  const message = "sift waiting for provider...";
+  let shown = false;
+  const timer = setTimeout(() => {
+    shown = true;
+    process.stderr.write(`${message}\r`);
+  }, PROVIDER_PENDING_NOTICE_DELAY_MS);
+  return () => {
+    clearTimeout(timer);
+    if (!shown) {
+      return;
+    }
+    process.stderr.write(`\r${" ".repeat(message.length)}\r`);
+  };
+}
 function withInsufficientHint(args) {
   if (!isInsufficientSignalOutput(args.output)) {
     return args.output;
@@ -3091,22 +3498,27 @@ async function generateWithRetry(args) {
     responseMode: args.responseMode,
     jsonResponseFormat: args.request.config.provider.jsonResponseFormat
   });
+  const stopPendingNotice = startProviderPendingNotice();
   try {
-    return await generate();
-  } catch (error) {
-    const reason = error instanceof Error ? error.message : "unknown_error";
-    if (!isRetriableReason(reason)) {
-      throw error;
-    }
-    if (args.request.config.runtime.verbose) {
-      process.stderr.write(
-        `${pc.dim("sift")} retry=1 reason=${reason} delay_ms=${RETRY_DELAY_MS}
+    try {
+      return await generate();
+    } catch (error) {
+      const reason = error instanceof Error ? error.message : "unknown_error";
+      if (!isRetriableReason(reason)) {
+        throw error;
+      }
+      if (args.request.config.runtime.verbose) {
+        process.stderr.write(
+          `${pc.dim("sift")} retry=1 reason=${reason} delay_ms=${RETRY_DELAY_MS}
 `
-      );
+        );
+      }
+      await delay(RETRY_DELAY_MS);
     }
-    await delay(RETRY_DELAY_MS);
+    return await generate();
+  } finally {
+    stopPendingNotice();
   }
-  return generate();
 }
 function hasRecognizableTestStatusSignal(input) {
   const analysis = analyzeTestStatus(input);
@@ -3161,11 +3573,22 @@ function buildTestStatusProviderFailureDecision(args) {
 }
 async function runSift(request) {
   const prepared = prepareInput(request.stdin, request.config.input);
+  const heuristicInput = prepared.redacted;
+  const heuristicInputTruncated = false;
+  const heuristicPrepared = {
+    ...prepared,
+    truncated: heuristicInput,
+    meta: {
+      ...prepared.meta,
+      finalLength: heuristicInput.length,
+      truncatedApplied: heuristicInputTruncated
+    }
+  };
   const provider = createProvider(request.config);
-  const hasTestStatusSignal = request.policyName === "test-status" && hasRecognizableTestStatusSignal(prepared.truncated);
-  const testStatusAnalysis = hasTestStatusSignal ? analyzeTestStatus(prepared.truncated) : null;
+  const hasTestStatusSignal = request.policyName === "test-status" && hasRecognizableTestStatusSignal(heuristicInput);
+  const testStatusAnalysis = hasTestStatusSignal ? analyzeTestStatus(heuristicInput) : null;
   const testStatusDecision = hasTestStatusSignal && testStatusAnalysis ? buildTestStatusDiagnoseContract({
-    input: prepared.truncated,
+    input: heuristicInput,
     analysis: testStatusAnalysis,
     resolvedTests: request.testStatusContext?.resolvedTests,
     remainingTests: request.testStatusContext?.remainingTests
@@ -3180,7 +3603,7 @@ async function runSift(request) {
 `
     );
   }
-  const heuristicOutput = request.policyName === "test-status" ? testStatusDecision?.contract.diagnosis_complete ? testStatusHeuristicOutput : null : applyHeuristicPolicy(request.policyName, prepared.truncated, request.detail);
+  const heuristicOutput = request.policyName === "test-status" ? testStatusDecision?.contract.diagnosis_complete ? testStatusHeuristicOutput : null : applyHeuristicPolicy(request.policyName, heuristicInput, request.detail);
   if (heuristicOutput) {
     if (request.config.runtime.verbose) {
       process.stderr.write(`${pc.dim("sift")} heuristic=${request.policyName}
@@ -3190,7 +3613,7 @@ async function runSift(request) {
       question: request.question,
       format: request.format,
       goal: request.goal,
-      input: prepared.truncated,
+      input: heuristicInput,
       detail: request.detail,
       policyName: request.policyName,
       outputContract: request.policyName === "test-status" && request.goal === "diagnose" && request.format === "json" ? request.outputContract ?? TEST_STATUS_DIAGNOSE_JSON_CONTRACT : request.outputContract,
@@ -3210,6 +3633,11 @@ async function runSift(request) {
         prompt: heuristicPrompt.prompt,
         responseMode: heuristicPrompt.responseMode,
         prepared,
+        heuristicInput: {
+          length: heuristicInput.length,
+          truncatedApplied: heuristicInputTruncated,
+          strategy: "full-redacted"
+        },
         heuristicOutput,
         strategy: "heuristic"
       });
@@ -3223,6 +3651,8 @@ async function runSift(request) {
       logVerboseTestStatusTelemetry({
         request,
         prepared,
+        heuristicInputChars: heuristicInput.length,
+        heuristicInputTruncated,
         contract: testStatusDecision.contract,
         finalOutput
       });
@@ -3274,6 +3704,11 @@ async function runSift(request) {
         prompt: prompt.prompt,
         responseMode: prompt.responseMode,
         prepared: providerPrepared2,
+        heuristicInput: {
+          length: heuristicInput.length,
+          truncatedApplied: heuristicInputTruncated,
+          strategy: "full-redacted"
+        },
         heuristicOutput: testStatusHeuristicOutput,
         strategy: "hybrid"
       });
@@ -3287,10 +3722,11 @@ async function runSift(request) {
       });
       const supplement = parseTestStatusProviderSupplement(result.text);
       const mergedDecision = buildTestStatusDiagnoseContract({
-        input: prepared.truncated,
+        input: heuristicInput,
         analysis: testStatusAnalysis,
         resolvedTests: request.testStatusContext?.resolvedTests,
         remainingTests: request.testStatusContext?.remainingTests,
+        providerBucketSupplements: supplement.bucket_supplements,
         contractOverrides: {
           diagnosis_complete: supplement.diagnosis_complete,
           raw_needed: supplement.raw_needed,
@@ -3312,6 +3748,8 @@ async function runSift(request) {
       logVerboseTestStatusTelemetry({
         request,
         prepared,
+        heuristicInputChars: heuristicInput.length,
+        heuristicInputTruncated,
         contract: mergedDecision.contract,
         finalOutput,
         rawSliceChars: rawSlice.text.length,
@@ -3324,7 +3762,7 @@ async function runSift(request) {
       const failureDecision = buildTestStatusProviderFailureDecision({
         request,
         baseDecision: testStatusDecision,
-        input: prepared.truncated,
+        input: heuristicInput,
         analysis: testStatusAnalysis,
         reason,
         rawSliceUsed: rawSlice.used,
@@ -3345,6 +3783,8 @@ async function runSift(request) {
       logVerboseTestStatusTelemetry({
         request,
         prepared,
+        heuristicInputChars: heuristicInput.length,
+        heuristicInputTruncated,
         contract: failureDecision.contract,
         finalOutput,
         rawSliceChars: rawSlice.text.length,
@@ -3383,6 +3823,11 @@ async function runSift(request) {
       prompt: providerPrompt.prompt,
       responseMode: providerPrompt.responseMode,
       prepared: providerPrepared,
+      heuristicInput: {
+        length: heuristicInput.length,
+        truncatedApplied: heuristicInputTruncated,
+        strategy: "full-redacted"
+      },
       heuristicOutput: testStatusDecision ? testStatusHeuristicOutput : null,
       strategy: testStatusDecision ? "hybrid" : "provider"
     });
@@ -4419,13 +4864,16 @@ var OPENAI_COMPATIBLE_BASE_URL_ENV = [
   { prefix: "https://api.together.xyz/", envName: "TOGETHER_API_KEY" },
   { prefix: "https://api.groq.com/openai/", envName: "GROQ_API_KEY" }
 ];
+var NATIVE_PROVIDER_API_KEY_ENV = {
+  openai: "OPENAI_API_KEY",
+  openrouter: "OPENROUTER_API_KEY"
+};
 var PROVIDER_API_KEY_ENV = {
   anthropic: "ANTHROPIC_API_KEY",
   claude: "ANTHROPIC_API_KEY",
   groq: "GROQ_API_KEY",
-  openai: "OPENAI_API_KEY",
-  openrouter: "OPENROUTER_API_KEY",
-  together: "TOGETHER_API_KEY"
+  together: "TOGETHER_API_KEY",
+  ...NATIVE_PROVIDER_API_KEY_ENV
 };
 function normalizeBaseUrl(baseUrl) {
   if (!baseUrl) {
@@ -4463,7 +4911,11 @@ function resolveProviderApiKey(provider, baseUrl, env) {
 
 // src/config/schema.ts
 import { z as z3 } from "zod";
-var providerNameSchema = z3.enum(["openai", "openai-compatible"]);
+var providerNameSchema = z3.enum([
+  "openai",
+  "openai-compatible",
+  "openrouter"
+]);
 var outputFormatSchema = z3.enum([
   "brief",
   "bullets",
@@ -4492,6 +4944,15 @@ var providerConfigSchema = z3.object({
   temperature: z3.number().min(0).max(2),
   maxOutputTokens: z3.number().int().positive()
 });
+var providerProfileSchema = z3.object({
+  model: z3.string().min(1).optional(),
+  baseUrl: z3.string().url().optional(),
+  apiKey: z3.string().optional()
+});
+var providerProfilesSchema = z3.object({
+  openai: providerProfileSchema.optional(),
+  openrouter: providerProfileSchema.optional()
+}).optional();
 var inputConfigSchema = z3.object({
   stripAnsi: z3.boolean(),
   redact: z3.boolean(),
@@ -4516,10 +4977,19 @@ var siftConfigSchema = z3.object({
   provider: providerConfigSchema,
   input: inputConfigSchema,
   runtime: runtimeConfigSchema,
-  presets: z3.record(presetDefinitionSchema)
+  presets: z3.record(presetDefinitionSchema),
+  providerProfiles: providerProfilesSchema
 });
 
 // src/config/resolve.ts
+var PROVIDER_DEFAULT_OVERRIDES = {
+  openrouter: {
+    provider: {
+      model: "openrouter/free",
+      baseUrl: "https://openrouter.ai/api/v1"
+    }
+  }
+};
 function isRecord(value) {
   return Boolean(value) && typeof value === "object" && !Array.isArray(value);
 }
@@ -4582,13 +5052,32 @@ function buildCredentialEnvOverrides(env, context) {
     }
   };
 }
+function getBaseConfigForProvider(provider) {
+  return mergeDefined(defaultConfig, provider ? PROVIDER_DEFAULT_OVERRIDES[provider] : {});
+}
+function resolveProvisionalProvider(args) {
+  const provisional = mergeDefined(
+    mergeDefined(
+      mergeDefined(defaultConfig, args.fileConfig),
+      args.nonCredentialEnvConfig
+    ),
+    stripApiKey(args.cliOverrides) ?? {}
+  );
+  return provisional.provider.provider;
+}
 function resolveConfig(options = {}) {
   const env = options.env ?? process.env;
   const fileConfig = loadRawConfig(options.configPath);
   const nonCredentialEnvConfig = buildNonCredentialEnvOverrides(env);
+  const provisionalProvider = resolveProvisionalProvider({
+    fileConfig,
+    nonCredentialEnvConfig,
+    cliOverrides: options.cliOverrides
+  });
+  const baseConfig = getBaseConfigForProvider(provisionalProvider);
   const contextConfig = mergeDefined(
     mergeDefined(
-      mergeDefined(defaultConfig, fileConfig),
+      mergeDefined(baseConfig, fileConfig),
       nonCredentialEnvConfig
     ),
     stripApiKey(options.cliOverrides) ?? {}
@@ -4600,7 +5089,7 @@ function resolveConfig(options = {}) {
   const merged = mergeDefined(
     mergeDefined(
       mergeDefined(
-        mergeDefined(defaultConfig, fileConfig),
+        mergeDefined(baseConfig, fileConfig),
         nonCredentialEnvConfig
       ),
       credentialEnvConfig