@bilalimamoglu/sift 0.3.2 → 0.4.0

package/dist/cli.js

@@ -1262,7 +1262,8 @@ function renderInstructionBody() {
     "- After making or planning a fix, refresh the truth with `sift rerun` so the same full suite runs again at `standard` and shows what is resolved or still remaining.",
     "- The normal stop budget is `standard` first, then at most one zoom step before raw.",
     "- Only if more detail is still needed after `sift rerun`, use `sift rerun --remaining --detail focused`, then `sift rerun --remaining --detail verbose`, then `sift rerun --remaining --detail verbose --show-raw`.",
-    "- `sift rerun --remaining` currently supports only argv-mode `pytest ...` or `python -m pytest ...` runs; otherwise rerun a narrowed command manually with `sift exec --preset test-status -- <narrowed pytest command>`.",
+    "- `sift rerun --remaining` narrows automatically for `pytest` and reruns the full original command for `vitest` and `jest` while keeping the diagnosis focused on what still fails.",
+    "- For other runners, rerun a narrowed command manually with `sift exec --preset test-status -- <narrowed test command>` if you need a smaller surface.",
     "- Start with `standard` text. Use diagnose JSON only when automation or machine branching truly needs it.",
     "- If `standard` already shows bucket-level root cause, anchor, and fix lines, trust it and report from it directly.",
     "- In that case, do not re-verify the same bucket with raw pytest; at most do one targeted source read before you edit.",
@@ -1876,7 +1877,7 @@ function showPreset(config, name, includeInternal = false) {
 }
 
 // src/core/escalate.ts
-import pc3 from "picocolors";
+import pc4 from "picocolors";
 
 // src/core/insufficient.ts
 function isInsufficientSignalOutput(output) {
@@ -1897,8 +1898,8 @@ function buildInsufficientSignalOutput(input) {
   } else {
     hint = "Hint: the captured output did not contain a clear answer for this preset.";
   }
-  return `${INSUFFICIENT_SIGNAL_TEXT}
-${hint}`;
+  const presetSuggestion = input.recognizedRunner && input.recognizedRunner !== "unknown" && input.presetName !== "test-status" ? `Hint: captured output looks like ${input.recognizedRunner} test output; try --preset test-status.` : null;
+  return [INSUFFICIENT_SIGNAL_TEXT, hint, presetSuggestion].filter((value) => Boolean(value)).join("\n");
 }
 
 // src/core/run.ts
@@ -2124,7 +2125,125 @@ function createProvider(config) {
 
 // src/core/testStatusDecision.ts
 import { z as z2 } 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[]}';
+
+// src/core/testStatusTargets.ts
+function unique(values) {
+  return [...new Set(values)];
+}
+function normalizeTestId(value) {
+  return value.replace(/\\/g, "/").replace(/\s+/g, " ").trim();
+}
+function stripMatcherProse(value) {
+  return value.replace(/\s+-\s+.*$/, "").trim();
+}
+function extractJsFile(value) {
+  const match = value.match(/([A-Za-z0-9_./-]+\.(?:test|spec)\.[cm]?[jt]sx?)/i);
+  return match ? normalizeTestId(match[1]) : null;
+}
+function normalizeFailingTarget(label, runner) {
+  const normalized = normalizeTestId(label).replace(/^['"]|['"]$/g, "");
+  if (runner === "pytest") {
+    return stripMatcherProse(normalized);
+  }
+  if (runner === "vitest" || runner === "jest") {
+    const compact = normalized.replace(/^FAIL\s+/i, "").replace(/^[❯×]\s*/, "").replace(/\s+\[[^\]]+\]\s*$/, "").trim();
+    const file = extractJsFile(compact);
+    if (!file) {
+      return stripMatcherProse(compact);
+    }
+    const fileIndex = compact.indexOf(file);
+    const suffix = compact.slice(fileIndex + file.length).trim();
+    if (!suffix) {
+      return file;
+    }
+    if (suffix.startsWith(">")) {
+      const testName = stripMatcherProse(suffix.replace(/^>\s*/, ""));
+      return testName.length > 0 ? `${file} > ${testName}` : file;
+    }
+    return file;
+  }
+  return normalized;
+}
+function extractFamilyPrefix(value) {
+  const normalized = normalizeTestId(value);
+  const filePart = normalized.split("::")[0]?.split(" > ")[0]?.trim() ?? normalized;
+  const workflowMatch = filePart.match(/^(\.github\/workflows\/)/);
+  if (workflowMatch) {
+    return workflowMatch[1];
+  }
+  const testsMatch = filePart.match(/^((?:test|tests)\/[^/]+\/)/);
+  if (testsMatch) {
+    return testsMatch[1];
+  }
+  const srcMatch = filePart.match(/^(src\/[^/]+\/)/);
+  if (srcMatch) {
+    return srcMatch[1];
+  }
+  const configMatch = filePart.match(
+    /^((?:[^/]+\/)*(?:package\.json|pytest\.ini|pyproject\.toml|tox\.ini|conftest\.py|(?:vitest|jest)\.config\.[^/]+|tsconfig(?:\.[^/]+)?\.json|[^/]*config[^/]*\.(?:json|ya?ml)))$/i
+  );
+  if (configMatch) {
+    return configMatch[1];
+  }
+  const segments = filePart.replace(/^\/+/, "").split("/").filter(Boolean);
+  if (segments.length >= 2) {
+    return `${segments[0]}/${segments[1]}/`;
+  }
+  if (segments.length === 1) {
+    return segments[0];
+  }
+  return "other";
+}
+function buildTestTargetSummary(values) {
+  const uniqueValues = unique(values);
+  const counts = /* @__PURE__ */ new Map();
+  for (const value of uniqueValues) {
+    const prefix = extractFamilyPrefix(value);
+    counts.set(prefix, (counts.get(prefix) ?? 0) + 1);
+  }
+  const families = [...counts.entries()].map(([prefix, count]) => ({
+    prefix,
+    count
+  })).sort((left, right) => {
+    if (right.count !== left.count) {
+      return right.count - left.count;
+    }
+    return left.prefix.localeCompare(right.prefix);
+  }).slice(0, 5);
+  return {
+    count: uniqueValues.length,
+    families
+  };
+}
+function formatTargetSummary(summary) {
+  if (summary.count === 0) {
+    return "count=0";
+  }
+  const families = summary.families.length > 0 ? summary.families.map((family) => `${family.prefix}${family.count}`).join(", ") : "none";
+  return `count=${summary.count}; families=${families}`;
+}
+function joinFamilies(families) {
+  if (families.length === 0) {
+    return "";
+  }
+  if (families.length === 1) {
+    return families[0];
+  }
+  if (families.length === 2) {
+    return `${families[0]} and ${families[1]}`;
+  }
+  return `${families.slice(0, -1).join(", ")}, and ${families.at(-1)}`;
+}
+function describeTargetSummary(summary) {
+  if (summary.count === 0 || summary.families.length === 0) {
+    return null;
+  }
+  const families = summary.families.map((family) => `${family.prefix} (${family.count})`);
+  return `across ${joinFamilies(families)}`;
+}
+
+// src/core/testStatusDecision.ts
+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","remaining_mode":"none|subset_rerun|full_rerun_diff","primary_suspect_kind":"test|app_code|config|environment|tooling|unknown","confidence_reason":string,"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,"suspect_kind":"test|app_code|config|environment|tooling|unknown","fix_hint":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,"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 = z2.object({
   code: z2.enum([
@@ -2166,6 +2285,16 @@ var testStatusDiagnoseContractSchema = z2.object({
   additional_source_read_likely_low_value: z2.boolean(),
   read_raw_only_if: z2.string().nullable(),
   decision: z2.enum(["stop", "zoom", "read_source", "read_raw"]),
+  remaining_mode: z2.enum(["none", "subset_rerun", "full_rerun_diff"]),
+  primary_suspect_kind: z2.enum([
+    "test",
+    "app_code",
+    "config",
+    "environment",
+    "tooling",
+    "unknown"
+  ]),
+  confidence_reason: z2.string().min(1),
   dominant_blocker_bucket_index: z2.number().int().nullable(),
   provider_used: z2.boolean(),
   provider_confidence: z2.number().min(0).max(1).nullable(),
@@ -2180,6 +2309,15 @@ var testStatusDiagnoseContractSchema = z2.object({
       label: z2.string(),
       count: z2.number().int(),
       root_cause: z2.string(),
+      suspect_kind: z2.enum([
+        "test",
+        "app_code",
+        "config",
+        "environment",
+        "tooling",
+        "unknown"
+      ]),
+      fix_hint: z2.string().min(1),
       evidence: z2.array(z2.string()).max(2),
       bucket_confidence: z2.number(),
       root_cause_confidence: z2.number(),
@@ -2230,6 +2368,42 @@ function parseTestStatusProviderSupplement(input) {
   return testStatusProviderSupplementSchema.parse(JSON.parse(input));
 }
 var extendedBucketSpecs = [
+  {
+    prefix: "service unavailable:",
+    type: "service_unavailable",
+    label: "service unavailable",
+    genericTitle: "Service unavailable failures",
+    defaultCoverage: "error",
+    rootCauseConfidence: 0.9,
+    dominantPriority: 2,
+    dominantBlocker: true,
+    why: "it contains the dependency service or API path that is unavailable in the test environment",
+    fix: "Restore the dependency service or test double before rerunning the full suite."
+  },
+  {
+    prefix: "db refused:",
+    type: "db_connection_failure",
+    label: "database connection",
+    genericTitle: "Database connection failures",
+    defaultCoverage: "error",
+    rootCauseConfidence: 0.9,
+    dominantPriority: 2,
+    dominantBlocker: true,
+    why: "it contains the database host, DSN, or startup path that is refusing connections",
+    fix: "Restore the test database connectivity before rerunning the full suite."
+  },
+  {
+    prefix: "auth bypass absent:",
+    type: "auth_bypass_absent",
+    label: "auth bypass missing",
+    genericTitle: "Auth bypass setup failures",
+    defaultCoverage: "error",
+    rootCauseConfidence: 0.86,
+    dominantPriority: 2,
+    dominantBlocker: true,
+    why: "it contains the auth bypass fixture or setup path that tests expected to be active",
+    fix: "Restore the test auth bypass fixture or mock before rerunning the full suite."
+  },
   {
     prefix: "snapshot mismatch:",
     type: "snapshot_mismatch",
@@ -2414,6 +2588,16 @@ var extendedBucketSpecs = [
     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: "assertion failed:",
+    type: "assertion_failure",
+    label: "assertion failure",
+    genericTitle: "Assertion failures",
+    defaultCoverage: "failed",
+    rootCauseConfidence: 0.76,
+    why: "it contains the expected-versus-actual assertion that failed inside the visible test",
+    fix: "Read the assertion diff or expectation and fix the code or expected value before rerunning."
+  },
   {
     prefix: "xfail strict:",
     type: "xfail_strict_unexpected_pass",
@@ -2435,54 +2619,127 @@ function extractReasonDetail(reason, prefix) {
 function formatCount(count, singular, plural = `${singular}s`) {
   return `${count} ${count === 1 ? singular : plural}`;
 }
-function unique(values) {
+function unique2(values) {
   return [...new Set(values)];
 }
-function normalizeTestId(value) {
+function normalizeTestId2(value) {
   return value.replace(/\\/g, "/").trim();
 }
-function extractTestFamilyPrefix(value) {
-  const normalized = normalizeTestId(value);
-  const testsMatch = normalized.match(/^(tests\/[^/]+\/)/);
-  if (testsMatch) {
-    return testsMatch[1];
+function normalizePathCandidate(value) {
+  if (!value) {
+    return null;
   }
-  const filePart = normalized.split("::")[0]?.trim() ?? "";
-  if (!filePart.includes("/")) {
-    return "other";
+  let normalized = value.replace(/\\/g, "/").trim();
+  normalized = normalized.replace(/^[("'`<\[]+/, "").replace(/[>"'`\]),:;]+$/, "");
+  normalized = normalized.replace(/^<repo>\//, "").replace(/^\.\//, "");
+  if (normalized.includes("::")) {
+    normalized = normalized.split("::")[0]?.trim() ?? normalized;
   }
-  const segments = filePart.replace(/^\/+/, "").split("/").filter(Boolean);
-  if (segments.length === 0) {
-    return "other";
+  if (normalized.startsWith("/") && !normalized.startsWith("/tmp/") && !normalized.startsWith("/var/tmp/")) {
+    return null;
+  }
+  if (/^\.github\/workflows\/.+\.(?:yml|yaml)$/i.test(normalized)) {
+    return normalized;
+  }
+  if (/^(?:src|test|tests)\/.+\.[A-Za-z0-9._-]+$/i.test(normalized)) {
+    return normalized;
   }
-  return `${segments[0]}/`;
+  if (/^(?:package\.json|pytest\.ini|pyproject\.toml|tox\.ini|(?:[A-Za-z0-9._/-]+\/)?conftest\.py)$/i.test(
+    normalized
+  )) {
+    return normalized;
+  }
+  if (/^(?:[A-Za-z0-9._/-]+\/)?(?:vitest|jest)\.config\.[A-Za-z0-9._-]+$/i.test(normalized)) {
+    return normalized;
+  }
+  if (/^(?:[A-Za-z0-9._/-]+\/)?tsconfig(?:\.[A-Za-z0-9_-]+)?\.json$/i.test(normalized)) {
+    return normalized;
+  }
+  if (/^[A-Za-z0-9._/-]*config[A-Za-z0-9._/-]*\.(?:json|yml|yaml)$/i.test(normalized)) {
+    return normalized;
+  }
+  return null;
 }
-function buildTestTargetSummary(values) {
-  const counts = /* @__PURE__ */ new Map();
-  for (const value of values) {
-    const prefix = extractTestFamilyPrefix(value);
-    counts.set(prefix, (counts.get(prefix) ?? 0) + 1);
+function addPathCandidatesFromText(target, text) {
+  if (!text) {
+    return;
   }
-  const families = [...counts.entries()].map(([prefix, count]) => ({
-    prefix,
-    count
-  })).sort((left, right) => {
-    if (right.count !== left.count) {
-      return right.count - left.count;
+  const pattern = /(?:^|[\s("'`])((?:\.github\/workflows\/[A-Za-z0-9._/-]+\.(?:yml|yaml)|(?:src|test|tests)\/[A-Za-z0-9._/-]+\.[A-Za-z0-9._-]+|package\.json|pytest\.ini|pyproject\.toml|tox\.ini|(?:[A-Za-z0-9._/-]+\/)?conftest\.py|(?:[A-Za-z0-9._/-]+\/)?(?:vitest|jest)\.config\.[A-Za-z0-9._-]+|(?:[A-Za-z0-9._/-]+\/)?tsconfig(?:\.[A-Za-z0-9_-]+)?\.json|[A-Za-z0-9._/-]*config[A-Za-z0-9._/-]*\.(?:json|yml|yaml)))/g;
+  for (const match of text.matchAll(pattern)) {
+    const normalized = normalizePathCandidate(match[1] ?? null);
+    if (normalized) {
+      target.add(normalized);
+    }
+  }
+}
+function extractBucketPathCandidates(args) {
+  const candidates = /* @__PURE__ */ new Set();
+  const push = (value) => {
+    const normalized = normalizePathCandidate(value);
+    if (normalized) {
+      candidates.add(normalized);
     }
-    return left.prefix.localeCompare(right.prefix);
-  }).slice(0, 5);
-  return {
-    count: values.length,
-    families
   };
+  push(args.readTarget?.file);
+  for (const item of args.bucket.representativeItems) {
+    push(item.file);
+    addPathCandidatesFromText(candidates, item.label);
+    addPathCandidatesFromText(candidates, item.reason);
+  }
+  addPathCandidatesFromText(candidates, args.bucket.reason);
+  addPathCandidatesFromText(candidates, args.bucket.headline);
+  for (const line of args.bucket.summaryLines) {
+    addPathCandidatesFromText(candidates, line);
+  }
+  return [...candidates];
 }
-function formatTargetSummary(summary) {
-  if (summary.count === 0) {
-    return "count=0";
+function isConfigPathCandidate(path8) {
+  return /^\.github\/workflows\/.+\.(?:yml|yaml)$/i.test(path8) || /^(?:package\.json|pytest\.ini|pyproject\.toml|tox\.ini|(?:[A-Za-z0-9._/-]+\/)?conftest\.py)$/i.test(
+    path8
+  ) || /^(?:[A-Za-z0-9._/-]+\/)?(?:vitest|jest)\.config\.[A-Za-z0-9._-]+$/i.test(path8) || /^(?:[A-Za-z0-9._/-]+\/)?tsconfig(?:\.[A-Za-z0-9_-]+)?\.json$/i.test(path8) || /^[A-Za-z0-9._/-]*config[A-Za-z0-9._/-]*\.(?:json|yml|yaml)$/i.test(path8);
+}
+function isAppPathCandidate(path8) {
+  return path8.startsWith("src/");
+}
+function isTestPathCandidate(path8) {
+  return path8.startsWith("test/") || path8.startsWith("tests/");
+}
+function looksLikeMatcherLiteralComparison(detail) {
+  return /\bexpected\b[\s\S]*\bto (?:be|contain)\b/i.test(detail);
+}
+function looksLikeGoldenLiteralDrift(detail) {
+  return /\\n/.test(detail) || /-\s+(?:Tests|Decision|Likely owner|Next|Stop signal)\b/.test(detail) || /\b(?:node-version|workflow_dispatch|run-name|matrix|registry-url)\b/i.test(detail);
+}
+function isGoldenOutputDriftBucket(bucket) {
+  if (bucket.type !== "assertion_failure") {
+    return false;
   }
-  const families = summary.families.length > 0 ? summary.families.map((family) => `${family.prefix}${family.count}`).join(", ") : "none";
-  return `count=${summary.count}; families=${families}`;
+  const detail = extractReasonDetail(bucket.reason, "assertion failed:") ?? bucket.reason;
+  if (!looksLikeMatcherLiteralComparison(detail)) {
+    return false;
+  }
+  if (bucket.reason.startsWith("snapshot mismatch:")) {
+    return false;
+  }
+  if (!looksLikeGoldenLiteralDrift(detail)) {
+    return false;
+  }
+  const candidates = extractBucketPathCandidates({
+    bucket
+  });
+  return candidates.some((candidate) => isConfigPathCandidate(candidate) || isTestPathCandidate(candidate));
+}
+function specializeBucket(bucket) {
+  if (!isGoldenOutputDriftBucket(bucket)) {
+    return bucket;
+  }
+  return {
+    ...bucket,
+    type: "golden_output_drift",
+    reason: "golden output drift: expected literal or golden output no longer matches current output",
+    labelOverride: "golden output drift",
+    hint: "Update the expected literal or golden output if the new output is intentional; otherwise fix the generated output and rerun."
+  };
 }
 function classifyGenericBucketType(reason) {
   const extended = findExtendedBucketSpec(reason);
@@ -2507,6 +2764,9 @@ function classifyGenericBucketType(reason) {
   if (reason.startsWith("missing module:")) {
     return "import_dependency_failure";
   }
+  if (reason.startsWith("golden output drift:")) {
+    return "golden_output_drift";
+  }
   if (reason.startsWith("assertion failed:")) {
     return "assertion_failure";
   }
@@ -2659,7 +2919,7 @@ function mergeBucketDetails(existing, incoming) {
     count,
     confidence: Math.max(existing.confidence, incoming.confidence),
     representativeItems,
-    entities: unique([...existing.entities, ...incoming.entities]),
+    entities: unique2([...existing.entities, ...incoming.entities]),
     hint: existing.hint ?? incoming.hint,
     overflowCount: Math.max(
       existing.overflowCount,
@@ -2851,6 +3111,9 @@ function labelForBucket(bucket) {
   if (bucket.type === "import_dependency_failure") {
     return "import dependency failure";
   }
+  if (bucket.type === "golden_output_drift") {
+    return "golden output drift";
+  }
   if (bucket.type === "assertion_failure") {
     return "assertion failure";
   }
@@ -2885,6 +3148,9 @@ function rootCauseConfidenceFor(bucket) {
   if (bucket.type === "contract_snapshot_drift") {
     return bucket.entities.length > 0 ? 0.92 : 0.76;
   }
+  if (bucket.type === "golden_output_drift") {
+    return 0.78;
+  }
   if (bucket.source === "provider") {
     return Math.max(0.6, Math.min(bucket.confidence, 0.82));
   }
@@ -2959,6 +3225,9 @@ function buildReadTargetWhy(args) {
   if (args.bucket.type === "import_dependency_failure") {
     return "it is the first visible failing module in this missing dependency bucket";
   }
+  if (args.bucket.type === "golden_output_drift") {
+    return "it is the first visible golden or literal drift anchor for this bucket";
+  }
   if (args.bucket.type === "assertion_failure") {
     return "it is the first visible failing test in this bucket";
   }
@@ -3036,6 +3305,9 @@ function buildReadTargetSearchHint(bucket, anchor) {
   if (assertionText) {
     return assertionText;
   }
+  if (bucket.type === "golden_output_drift") {
+    return bucket.representativeItems.map((item) => item.reason.match(/^assertion failed:\s+(.+)$/)?.[1] ?? item.reason).find(Boolean) ?? anchor.label.split("::")[1]?.trim() ?? null;
+  }
   if (bucket.reason.startsWith("unknown ")) {
     return anchor.reason;
   }
@@ -3090,18 +3362,36 @@ function buildConcreteNextNote(args) {
   }
   const lead = primaryTarget.context_hint.start_line !== null && primaryTarget.context_hint.end_line !== null ? `Read ${primaryTarget.file} lines ${primaryTarget.context_hint.start_line}-${primaryTarget.context_hint.end_line} first; ${primaryTarget.why}.` : primaryTarget.context_hint.search_hint ? `Search for ${primaryTarget.context_hint.search_hint} in ${primaryTarget.file} first; ${primaryTarget.why}.` : `Read ${formatReadTargetLocation(primaryTarget)} first; ${primaryTarget.why}.`;
   if (args.nextBestAction.code === "fix_dominant_blocker") {
+    if (args.remainingMode === "subset_rerun") {
+      return "Fix the remaining bucket first, then refresh the full-suite truth with sift rerun.";
+    }
+    if (args.remainingMode === "full_rerun_diff") {
+      return "Fix the remaining bucket first. The cached full-suite baseline is still preserved; use sift rerun when you want to refresh it.";
+    }
     if (args.nextBestAction.bucket_index === 1 && args.hasSecondaryVisibleBucket) {
       return "Fix bucket 1 first, then rerun the full suite at standard. Secondary buckets are already visible behind it.";
     }
     return `Fix bucket ${args.nextBestAction.bucket_index ?? 1} first, then rerun the full suite at standard.`;
   }
   if (args.nextBestAction.code === "read_source_for_bucket") {
+    if (args.remainingMode === "subset_rerun") {
+      return "Fix the remaining bucket first, then refresh the full-suite truth with sift rerun.";
+    }
+    if (args.remainingMode === "full_rerun_diff") {
+      return "Fix the remaining bucket first. The cached full-suite baseline is still preserved; use sift rerun when you want to refresh it.";
+    }
     return lead;
   }
   if (args.nextBestAction.code === "insufficient_signal") {
-    if (args.nextBestAction.note.startsWith("Provider follow-up failed")) {
+    if (args.nextBestAction.note.startsWith("Provider follow-up")) {
       return args.nextBestAction.note;
     }
+    if (args.remainingMode === "subset_rerun") {
+      return "Fix the remaining bucket first, then refresh the full-suite truth with sift rerun.";
+    }
+    if (args.remainingMode === "full_rerun_diff") {
+      return "Fix the remaining bucket first. The cached full-suite baseline is still preserved; use sift rerun when you want to refresh it.";
+    }
     return `${lead} Then take one deeper sift pass before raw traceback.`;
   }
   return args.nextBestAction.note;
@@ -3110,13 +3400,13 @@ function extractMiniDiff(input, bucket) {
   if (bucket.type !== "contract_snapshot_drift") {
     return null;
   }
-  const addedPaths = unique(
+  const addedPaths = unique2(
     [...input.matchAll(/[+-]\s+'(\/api\/[^']+)'/g)].map((match) => match[1])
   ).length;
-  const removedModels = unique(
+  const removedModels = unique2(
     [...input.matchAll(/[+-]\s+'([A-Za-z0-9._/-]+-[A-Za-z0-9._-]+)'/g)].map((match) => match[1])
   ).length;
-  const changedTaskMappings = unique(
+  const changedTaskMappings = unique2(
     [...input.matchAll(/[+-]\s+'([a-z]+(?:_[a-z0-9]+)+)'/g)].map((match) => match[1])
   ).length;
   if (addedPaths === 0 && removedModels === 0 && changedTaskMappings === 0) {
@@ -3203,7 +3493,7 @@ function buildProviderSupplementBuckets(args) {
   });
 }
 function pickUnknownAnchor(args) {
-  const fromStatusItems = args.kind === "error" ? args.analysis.visibleErrorItems[0] : null;
+  const fromStatusItems = args.kind === "error" ? args.analysis.visibleErrorItems[0] : args.analysis.visibleFailedItems[0];
   if (fromStatusItems) {
     return {
       label: fromStatusItems.label,
@@ -3217,7 +3507,7 @@ function pickUnknownAnchor(args) {
   }
   const label = args.kind === "error" ? args.analysis.visibleErrorLabels[0] : args.analysis.visibleFailedLabels[0];
   if (label) {
-    const normalizedLabel = normalizeTestId(label);
+    const normalizedLabel = normalizeTestId2(label);
     const fileMatch = normalizedLabel.match(/^([A-Za-z0-9_./-]+\.[A-Za-z0-9]+)\b/);
     const file = fileMatch?.[1] ?? normalizedLabel.split("::")[0] ?? null;
     return {
@@ -3240,12 +3530,14 @@ function buildUnknownBucket(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";
+  const firstConcreteSignal = anchor && anchor.reason !== reason && anchor.reason !== "setup failures share a repeated but unclassified pattern" && anchor.reason !== "failing tests share a repeated but unclassified pattern" ? `First concrete signal: ${anchor.reason}` : null;
   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.`
-    ],
+      `${label}: ${formatCount(args.count, "visible failure")} share a repeated but unclassified pattern.`,
+      firstConcreteSignal
+    ].filter((value) => Boolean(value)),
     reason,
     count: args.count,
     confidence: 0.45,
@@ -3343,16 +3635,29 @@ function buildDecisionLine(contract) {
   }
   return "- Decision: raw only if exact traceback is required.";
 }
+function buildRemainingPassLine(contract) {
+  if (contract.remaining_mode === "subset_rerun") {
+    return "- Remaining pass: showing only what is still failing from the cached baseline.";
+  }
+  if (contract.remaining_mode === "full_rerun_diff") {
+    return "- Remaining pass: full rerun analyzed against the cached baseline because narrowed rerun is not available for this runner.";
+  }
+  return null;
+}
 function buildComparisonLines(contract) {
   const lines = [];
+  const resolvedSummary = buildTestTargetSummary(contract.resolved_tests);
+  const remainingSummary = buildTestTargetSummary(contract.remaining_tests);
   if (contract.resolved_tests.length > 0) {
+    const summaryText = describeTargetSummary(resolvedSummary);
     lines.push(
-      `- Resolved in this rerun: ${formatCount(contract.resolved_tests.length, "test")} dropped out of the failing set.`
+      `- Resolved in this rerun: ${formatCount(contract.resolved_tests.length, "test")} dropped out of the failing set${summaryText ? ` ${summaryText}` : ""}.`
     );
   }
-  if (contract.resolved_tests.length > 0 && contract.remaining_tests.length > 0) {
+  if (contract.remaining_tests.length > 0 && (contract.resolved_tests.length > 0 || contract.remaining_mode !== "none")) {
+    const summaryText = describeTargetSummary(remainingSummary);
     lines.push(
-      `- Remaining failing targets: ${formatCount(contract.remaining_tests.length, "test/module", "tests/modules")}.`
+      `- Remaining failing targets: ${formatCount(contract.remaining_tests.length, "test/module", "tests/modules")}${summaryText ? ` ${summaryText}` : ""}.`
     );
   }
   return lines;
@@ -3372,7 +3677,7 @@ function buildStandardAnchorText(target) {
   }
   return formatReadTargetLocation(target);
 }
-function buildStandardFixText(args) {
+function resolveBucketFixHint(args) {
   if (args.bucket.hint) {
     return args.bucket.hint;
   }
@@ -3421,13 +3726,96 @@ function buildStandardFixText(args) {
   if (args.bucket.type === "runtime_failure") {
     return `Fix the visible ${args.bucketLabel} and rerun the full suite at standard.`;
   }
-  return null;
+  return "Inspect the first visible anchor for this bucket, apply the smallest fix that explains it, then rerun the full suite at standard.";
+}
+function deriveBucketSuspectKind(args) {
+  const pathCandidates = extractBucketPathCandidates({
+    bucket: args.bucket,
+    readTarget: args.readTarget
+  });
+  const hasConfigCandidate = pathCandidates.some((candidate) => isConfigPathCandidate(candidate));
+  const hasAppCandidate = pathCandidates.some((candidate) => isAppPathCandidate(candidate));
+  const hasTestCandidate = pathCandidates.some((candidate) => isTestPathCandidate(candidate));
+  if (args.bucket.type === "shared_environment_blocker" || args.bucket.type === "fixture_guard_failure" || args.bucket.type === "permission_denied_failure" || args.bucket.type === "django_db_access_denied" || args.bucket.type === "network_failure" || args.bucket.type === "service_unavailable" || args.bucket.type === "db_connection_failure" || args.bucket.type === "auth_bypass_absent" || args.bucket.type === "fixture_teardown_failure") {
+    return "environment";
+  }
+  if (args.bucket.type === "configuration_error" || args.bucket.type === "db_migration_failure" || args.bucket.type === "import_dependency_failure" || args.bucket.type === "collection_failure" || args.bucket.type === "no_tests_collected" || args.bucket.type === "deprecation_warning_as_error" || args.bucket.type === "file_not_found_failure") {
+    return "config";
+  }
+  if (args.bucket.type === "contract_snapshot_drift" || args.bucket.type === "snapshot_mismatch" || args.bucket.type === "flaky_test_detected" || args.bucket.type === "xfail_strict_unexpected_pass") {
+    return "test";
+  }
+  if (args.bucket.type === "golden_output_drift") {
+    if (hasConfigCandidate) {
+      return "config";
+    }
+    if (hasAppCandidate) {
+      return "app_code";
+    }
+    if (hasTestCandidate) {
+      return "test";
+    }
+    return "unknown";
+  }
+  if (args.bucket.type === "xdist_worker_crash" || args.bucket.type === "timeout_failure" || args.bucket.type === "async_event_loop_failure" || args.bucket.type === "subprocess_crash_segfault" || args.bucket.type === "memory_error" || args.bucket.type === "resource_leak_warning" || args.bucket.type === "interrupted_run") {
+    return "tooling";
+  }
+  if (args.bucket.type === "unknown_failure") {
+    return "unknown";
+  }
+  if (args.bucket.type === "assertion_failure" || args.bucket.type === "runtime_failure" || args.bucket.type === "type_error_failure" || args.bucket.type === "serialization_encoding_failure") {
+    if (hasConfigCandidate) {
+      return "config";
+    }
+    if (hasAppCandidate) {
+      return "app_code";
+    }
+    if (hasTestCandidate) {
+      return "test";
+    }
+    return "unknown";
+  }
+  return "unknown";
+}
+function derivePrimarySuspectKind(args) {
+  const primaryBucket = (args.dominantBlockerBucketIndex !== null ? args.mainBuckets.find((bucket) => bucket.bucket_index === args.dominantBlockerBucketIndex) : null) ?? args.mainBuckets[0];
+  return primaryBucket?.suspect_kind ?? "unknown";
+}
+function buildConfidenceReason(args) {
+  const primaryBucket = args.mainBuckets.find((bucket) => bucket.dominant) ?? args.mainBuckets[0];
+  if (args.decision === "stop" && primaryBucket && args.primarySuspectKind !== "unknown") {
+    return `Dominant blocker (${primaryBucket.label}) is anchored and actionable.`;
+  }
+  if (args.decision === "zoom") {
+    return "Unknown or low-confidence buckets remain; one deeper sift pass is justified.";
+  }
+  if (args.decision === "read_source") {
+    return "The bucket is identified, but source context is still needed to make the next fix clear.";
+  }
+  return "Heuristic signal is still insufficient; exact traceback lines are needed.";
+}
+function formatSuspectKindLabel(kind) {
+  switch (kind) {
+    case "test":
+      return "test code";
+    case "app_code":
+      return "application code";
+    case "config":
+      return "test or project configuration";
+    case "environment":
+      return "environment setup";
+    case "tooling":
+      return "test runner or tooling";
+    default:
+      return "unknown";
+  }
 }
 function buildStandardBucketSupport(args) {
   return {
     headline: args.bucket.summaryLines[0] ? `- ${args.bucket.summaryLines[0]}` : renderBucketHeadline(args.contractBucket),
+    firstConcreteSignalText: args.bucket.source === "unknown" ? args.bucket.summaryLines[1] ?? null : null,
     anchorText: buildStandardAnchorText(args.readTarget),
-    fixText: buildStandardFixText({
+    fixText: resolveBucketFixHint({
       bucket: args.bucket,
       bucketLabel: args.contractBucket.label
     })
@@ -3435,6 +3823,10 @@ function buildStandardBucketSupport(args) {
 }
 function renderStandard(args) {
   const lines = [...buildOutcomeLines(args.analysis), ...buildComparisonLines(args.contract)];
+  const remainingPassLine = buildRemainingPassLine(args.contract);
+  if (remainingPassLine) {
+    lines.push(remainingPassLine);
+  }
   if (args.contract.main_buckets.length > 0) {
     for (const bucket of args.contract.main_buckets.slice(0, 3)) {
       const rawBucket = args.buckets[bucket.bucket_index - 1];
@@ -3450,6 +3842,9 @@ function renderStandard(args) {
         )
       });
       lines.push(support.headline);
+      if (support.firstConcreteSignalText) {
+        lines.push(`- ${support.firstConcreteSignalText}`);
+      }
       if (support.anchorText) {
         lines.push(`- Anchor: ${support.anchorText}`);
       }
@@ -3459,12 +3854,19 @@ function renderStandard(args) {
     }
   }
   lines.push(buildDecisionLine(args.contract));
+  if (args.contract.main_buckets.length > 0 && args.contract.primary_suspect_kind !== "unknown") {
+    lines.push(`- Likely owner: ${formatSuspectKindLabel(args.contract.primary_suspect_kind)}`);
+  }
   lines.push(`- Next: ${args.contract.next_best_action.note}`);
   lines.push(buildStopSignal(args.contract));
   return lines.join("\n");
 }
 function renderFocused(args) {
   const lines = [...buildOutcomeLines(args.analysis), ...buildComparisonLines(args.contract)];
+  const remainingPassLine = buildRemainingPassLine(args.contract);
+  if (remainingPassLine) {
+    lines.push(remainingPassLine);
+  }
   for (const bucket of args.contract.main_buckets) {
     const rawBucket = args.buckets[bucket.bucket_index - 1];
     lines.push(
@@ -3484,6 +3886,10 @@ function renderFocused(args) {
 }
 function renderVerbose(args) {
   const lines = [...buildOutcomeLines(args.analysis), ...buildComparisonLines(args.contract)];
+  const remainingPassLine = buildRemainingPassLine(args.contract);
+  if (remainingPassLine) {
+    lines.push(remainingPassLine);
+  }
   for (const bucket of args.contract.main_buckets) {
     const rawBucket = args.buckets[bucket.bucket_index - 1];
     lines.push(
@@ -3533,7 +3939,9 @@ function buildTestStatusDiagnoseContract(args) {
       count: residuals.remainingFailed
     })
   ].filter((bucket) => Boolean(bucket));
-  const buckets = prioritizeBuckets([...combinedBuckets, ...unknownBuckets]).slice(0, 3);
+  const buckets = prioritizeBuckets(
+    [...combinedBuckets, ...unknownBuckets].map((bucket) => specializeBucket(bucket))
+  ).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,
@@ -3546,29 +3954,49 @@ function buildTestStatusDiagnoseContract(args) {
   })[0] ?? null;
   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,
     dominantBucketIndex: dominantBlockerBucketIndex
   });
-  const mainBuckets = buckets.map((bucket, index) => ({
-    bucket_index: index + 1,
-    label: labelForBucket(bucket),
-    count: bucket.count,
-    root_cause: bucket.reason,
-    evidence: buildBucketEvidence(bucket),
-    bucket_confidence: Number(bucket.confidence.toFixed(2)),
-    root_cause_confidence: Number(rootCauseConfidenceFor(bucket).toFixed(2)),
-    dominant: dominantBucket?.index === index,
-    secondary_visible_despite_blocker: dominantBlockerBucketIndex !== null && dominantBlockerBucketIndex !== index + 1,
-    mini_diff: extractMiniDiff(args.input, bucket)
-  }));
-  const resolvedTests = unique(args.resolvedTests ?? []);
-  const remainingTests = unique(
-    args.remainingTests ?? unique([...args.analysis.visibleErrorLabels, ...args.analysis.visibleFailedLabels])
+  const dominantBucketHasConcreteAnchor = dominantBucket !== null && (readTargets.some((target) => target.bucket_index === dominantBucket.index + 1 && target.file.length > 0) || dominantBucket.bucket.representativeItems.some((item) => item.anchor_kind !== "none"));
+  const smallConcreteSuite = args.analysis.failed + args.analysis.errors <= 2 && residuals.remainingErrors === 0 && residuals.remainingFailed === 0 && buckets.length === 1 && !hasUnknownBucket && dominantBucket !== null && dominantBucketHasConcreteAnchor;
+  const dominantConfidenceThreshold = smallConcreteSuite ? 0.55 : 0.6;
+  const diagnosisComplete = args.analysis.failed === 0 && args.analysis.errors === 0 && args.analysis.passed > 0 || simpleCollectionFailure || buckets.length > 0 && hasConcreteCoverage && !hasUnknownBucket && (dominantBucket?.bucket.confidence ?? 0) >= dominantConfidenceThreshold;
+  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 mainBuckets = buckets.map((bucket, index) => {
+    const bucketIndex = index + 1;
+    const label = labelForBucket(bucket);
+    const readTarget = readTargets.find((target) => target.bucket_index === bucketIndex);
+    return {
+      bucket_index: bucketIndex,
+      label,
+      count: bucket.count,
+      root_cause: bucket.reason,
+      suspect_kind: deriveBucketSuspectKind({
+        bucket,
+        readTarget
+      }),
+      fix_hint: resolveBucketFixHint({
+        bucket,
+        bucketLabel: label
+      }),
+      evidence: buildBucketEvidence(bucket),
+      bucket_confidence: Number(bucket.confidence.toFixed(2)),
+      root_cause_confidence: Number(rootCauseConfidenceFor(bucket).toFixed(2)),
+      dominant: dominantBucket?.index === index,
+      secondary_visible_despite_blocker: dominantBlockerBucketIndex !== null && dominantBlockerBucketIndex !== bucketIndex,
+      mini_diff: extractMiniDiff(args.input, bucket)
+    };
+  });
+  const resolvedTests = unique2(args.resolvedTests ?? []);
+  const remainingTests = unique2(
+    args.remainingTests ?? unique2([...args.analysis.visibleErrorLabels, ...args.analysis.visibleFailedLabels])
   );
+  const primarySuspectKind = derivePrimarySuspectKind({
+    mainBuckets,
+    dominantBlockerBucketIndex
+  });
   let nextBestAction;
   if (args.analysis.failed === 0 && args.analysis.errors === 0 && args.analysis.passed > 0) {
     nextBestAction = {
@@ -3613,7 +4041,10 @@ function buildTestStatusDiagnoseContract(args) {
     raw_needed: rawNeeded,
     additional_source_read_likely_low_value: diagnosisComplete && !rawNeeded,
     read_raw_only_if: rawNeeded ? "you still need exact traceback lines after focused or verbose detail" : null,
+    remaining_mode: args.remainingMode ?? "none",
     dominant_blocker_bucket_index: dominantBlockerBucketIndex,
+    primary_suspect_kind: primarySuspectKind,
+    confidence_reason: "Unknown or low-confidence buckets remain; one deeper sift pass is justified.",
     provider_used: false,
     provider_confidence: null,
     provider_failed: false,
@@ -3641,13 +4072,21 @@ function buildTestStatusDiagnoseContract(args) {
         readTargets,
         hasSecondaryVisibleBucket: mainBuckets.some(
           (bucket) => bucket.secondary_visible_despite_blocker
-        )
+        ),
+        remainingMode: args.contractOverrides?.remaining_mode ?? baseContract.remaining_mode
       })
     }
   };
+  const resolvedDecision = effectiveDecision ?? deriveDecision(mergedContractWithoutDecision);
+  const resolvedConfidenceReason = buildConfidenceReason({
+    decision: resolvedDecision,
+    mainBuckets,
+    primarySuspectKind: mergedContractWithoutDecision.primary_suspect_kind
+  });
   const contract = testStatusDiagnoseContractSchema.parse({
     ...mergedContractWithoutDecision,
-    decision: effectiveDecision ?? deriveDecision(mergedContractWithoutDecision)
+    confidence_reason: resolvedConfidenceReason,
+    decision: resolvedDecision
   });
   return {
     contract,
@@ -3699,6 +4138,7 @@ function buildTestStatusAnalysisContext(args) {
     `- diagnosis_complete=${args.contract.diagnosis_complete}`,
     `- raw_needed=${args.contract.raw_needed}`,
     `- decision=${args.contract.decision}`,
+    `- remaining_mode=${args.contract.remaining_mode}`,
     `- provider_used=${args.contract.provider_used}`,
     `- provider_failed=${args.contract.provider_failed}`,
     `- raw_slice_strategy=${args.contract.raw_slice_strategy}`,
@@ -4052,6 +4492,27 @@ function buildFallbackOutput(args) {
 var RISK_LINE_PATTERN = /(destroy|delete|drop|recreate|replace|revoke|deny|downtime|data loss|iam|network exposure)/i;
 var ZERO_DESTRUCTIVE_SUMMARY_PATTERN = /\b0\s+to\s+(destroy|delete|drop|recreate|replace|revoke)\b/i;
 var SAFE_LINE_PATTERN = /(no changes|up-to-date|up to date|no risky changes|safe to apply)/i;
+var RESOURCE_DESTROY_HEADER_PATTERN = /^#\s+.+\bwill be (destroyed|deleted|replaced)\b/i;
+var DESTROY_ERROR_PATTERN = /(instance cannot be destroyed|prevent_destroy|downtime|data loss)/i;
+var ACTION_DESTROY_PATTERN = /^-\s+destroy$/i;
+var TSC_CODE_LABELS = {
+  TS1002: "syntax error",
+  TS1005: "syntax error",
+  TS2304: "cannot find name",
+  TS2307: "cannot find module",
+  TS2322: "type mismatch",
+  TS2339: "missing property on type",
+  TS2345: "argument type mismatch",
+  TS2554: "wrong argument count",
+  TS2741: "missing required property",
+  TS2769: "no matching overload",
+  TS5083: "config file error",
+  TS6133: "declared but unused",
+  TS7006: "implicit any",
+  TS18003: "no inputs were found",
+  TS18046: "unknown type",
+  TS18048: "possibly undefined"
+};
 function collectEvidence(input, matcher, limit = 3) {
   return input.split("\n").map((line) => line.trim()).filter((line) => line.length > 0 && matcher.test(line)).slice(0, limit);
 }
@@ -4065,63 +4526,231 @@ function inferPackage(line) {
 function inferRemediation(pkg2) {
   return `Upgrade ${pkg2} to a patched version.`;
 }
-function getCount(input, label) {
-  const matches = [...input.matchAll(new RegExp(`(\\d+)\\s+${label}`, "gi"))];
-  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";
+function parseCompactAuditVulnerability(line) {
+  if (/^Severity:\s*/i.test(line)) {
+    return null;
   }
-  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";
+  if (!/\b(critical|high)\b/i.test(line)) {
+    return null;
   }
-  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) {
+  const pkg2 = inferPackage(line);
+  if (!pkg2) {
     return null;
   }
-  const metricMatch = line.match(new RegExp(`(\\d+)\\s+${metric}`, "i"));
-  return metricMatch ? Number(metricMatch[1]) : null;
+  return {
+    package: pkg2,
+    severity: inferSeverity(line),
+    remediation: inferRemediation(pkg2)
+  };
 }
-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) {
+function inferAuditPackageHeader(line) {
+  const trimmed = line.trim();
+  if (trimmed.length === 0 || trimmed.startsWith("#") || trimmed.includes(":") || /^node_modules\//i.test(trimmed)) {
     return null;
   }
-  const metricMatch = line.match(new RegExp(`(\\d+)\\s+${metric}`, "i"));
-  return metricMatch ? Number(metricMatch[1]) : null;
+  const match = trimmed.match(/^([@a-z0-9._/-]+)(?:\s{2,}|\s+(?:[<>=~^*]|\d))/i);
+  return match?.[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"),
+function collectAuditCriticalVulnerabilities(input) {
+  const lines = input.split("\n");
+  const vulnerabilities = [];
+  const seen = /* @__PURE__ */ new Set();
+  const pushVulnerability = (pkg2, severity) => {
+    const key = `${pkg2}:${severity}`;
+    if (seen.has(key)) {
+      return;
+    }
+    seen.add(key);
+    vulnerabilities.push({
+      package: pkg2,
+      severity,
+      remediation: inferRemediation(pkg2)
+    });
+  };
+  for (let index = 0; index < lines.length; index += 1) {
+    const line = lines[index].trim();
+    if (!line) {
+      continue;
+    }
+    const compact = parseCompactAuditVulnerability(line);
+    if (compact) {
+      pushVulnerability(compact.package, compact.severity);
+      continue;
+    }
+    const pkg2 = inferAuditPackageHeader(line);
+    if (!pkg2) {
+      continue;
+    }
+    for (let cursor = index + 1; cursor < Math.min(lines.length, index + 5); cursor += 1) {
+      const candidate = lines[cursor].trim();
+      if (!candidate) {
+        continue;
+      }
+      const severityMatch = candidate.match(/^Severity:\s*(critical|high)\b/i);
+      if (severityMatch) {
+        pushVulnerability(pkg2, severityMatch[1].toLowerCase());
+        break;
+      }
+      if (inferAuditPackageHeader(candidate) || parseCompactAuditVulnerability(candidate)) {
+        break;
+      }
+    }
+  }
+  return vulnerabilities;
+}
+function getCount(input, label) {
+  const matches = [...input.matchAll(new RegExp(`(\\d+)\\s+${label}`, "gi"))];
+  const lastMatch = matches.at(-1);
+  return lastMatch ? Number(lastMatch[1]) : 0;
+}
+function collectInfraRiskEvidence(input) {
+  const lines = input.split("\n").map((line) => line.trim()).filter((line) => line.length > 0);
+  const evidence = [];
+  const seen = /* @__PURE__ */ new Set();
+  const pushMatches = (matcher, options) => {
+    let added = 0;
+    for (const line of lines) {
+      if (!matcher.test(line)) {
+        continue;
+      }
+      if (options?.exclude?.test(line)) {
+        continue;
+      }
+      if (seen.has(line)) {
+        continue;
+      }
+      evidence.push(line);
+      seen.add(line);
+      added += 1;
+      if (options?.limit && added >= options.limit) {
+        return;
+      }
+      if (evidence.length >= (options?.maxEvidence ?? 4)) {
+        return;
+      }
+    }
+  };
+  pushMatches(/Plan:/i, {
+    exclude: ZERO_DESTRUCTIVE_SUMMARY_PATTERN,
+    limit: 1
+  });
+  if (evidence.length < 4) {
+    pushMatches(RESOURCE_DESTROY_HEADER_PATTERN, { limit: 2 });
+  }
+  if (evidence.length < 4) {
+    pushMatches(DESTROY_ERROR_PATTERN, { limit: 1 });
+  }
+  if (evidence.length < 4) {
+    pushMatches(ACTION_DESTROY_PATTERN, { limit: 1 });
+  }
+  if (evidence.length < 4) {
+    pushMatches(RISK_LINE_PATTERN, {
+      exclude: /->\s+null$|\b0\s+to\s+(destroy|delete|drop|recreate|replace|revoke)\b/i,
+      maxEvidence: 4
+    });
+  }
+  return evidence.slice(0, 4);
+}
+function collectInfraDestroyTargets(input) {
+  const targets = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const line of input.split("\n").map((entry) => entry.trim())) {
+    const match = line.match(/^#\s+(.+?)\s+will be (destroyed|deleted|replaced)\b/i);
+    const target = match?.[1]?.trim();
+    if (!target || seen.has(target)) {
+      continue;
+    }
+    seen.add(target);
+    targets.push(target);
+  }
+  return targets;
+}
+function inferInfraDestroyCount(input, destroyTargets) {
+  const matches = [
+    ...input.matchAll(/\b(\d+)\s+to\s+(destroy|delete|drop|recreate|replace|revoke)\b/gi)
+  ];
+  const lastMatch = matches.at(-1);
+  return lastMatch ? Number(lastMatch[1]) : destroyTargets.length;
+}
+function collectInfraBlockers(input) {
+  const lines = input.split("\n");
+  const blockers = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (let index = 0; index < lines.length; index += 1) {
+    const trimmed = lines[index]?.trim();
+    const errorMatch = trimmed?.match(/^(?:[│|]\s*)?Error:\s+(.+)$/);
+    if (!errorMatch) {
+      continue;
+    }
+    const message = errorMatch[1].trim();
+    const nearby = lines.slice(index, index + 8).join("\n");
+    const preventDestroyTarget = nearby.match(/Resource\s+([^\s]+)\s+has lifecycle\.prevent_destroy set/i)?.[1] ?? null;
+    const type = preventDestroyTarget ? "prevent_destroy" : "destroy_blocked";
+    const key = `${type}:${preventDestroyTarget ?? ""}:${message}`;
+    if (seen.has(key)) {
+      continue;
+    }
+    seen.add(key);
+    blockers.push({
+      type,
+      target: preventDestroyTarget,
+      message
+    });
+  }
+  return blockers;
+}
+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*(?:FAILED|ERROR)\s+[A-Za-z0-9_./-]+::[^\n]+$/m.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")
@@ -4147,6 +4776,21 @@ function collectUniqueMatches(input, matcher, limit = 6) {
   }
   return values;
 }
+function compactDisplayFile(file) {
+  const normalized = file.replace(/\\/g, "/").trim();
+  if (!normalized) {
+    return file;
+  }
+  const looksAbsolute = normalized.startsWith("/") || /^[A-Za-z]:\//.test(normalized);
+  if (!looksAbsolute && normalized.length <= 60) {
+    return normalized;
+  }
+  const basename = normalized.split("/").at(-1);
+  return basename && basename.length > 0 ? basename : normalized;
+}
+function formatDisplayedFiles(files, limit = 3) {
+  return [...new Set([...files].map((file) => file.trim()).filter(Boolean))].sort((left, right) => left.localeCompare(right)).slice(0, limit).map((file) => compactDisplayFile(file));
+}
 function emptyAnchor() {
   return {
     file: null,
@@ -4426,6 +5070,31 @@ function classifyFailureReason(line, options) {
       group: "permission or locked resource failures"
     };
   }
+  const osDiskFullFailure = normalized.match(
+    /(OSError:\s*\[Errno 28\][^$]*|No space left on device)/i
+  );
+  if (osDiskFullFailure) {
+    return {
+      reason: buildClassifiedReason(
+        "configuration",
+        `disk full (${buildExcerptDetail(
+          osDiskFullFailure[1] ?? normalized,
+          "No space left on device"
+        )})`
+      ),
+      group: "test configuration failures"
+    };
+  }
+  const osPermissionFailure = normalized.match(/OSError:\s*\[Errno 13\][^$]*/i);
+  if (osPermissionFailure) {
+    return {
+      reason: buildClassifiedReason(
+        "permission",
+        buildExcerptDetail(osPermissionFailure[0] ?? normalized, "permission denied")
+      ),
+      group: "permission or locked resource failures"
+    };
+  }
   const xdistWorkerCrash = normalized.match(
     /(worker ['"][^'"]+['"] crashed|node down:\s*[^,;]+|WorkerLost[^,;]*|Worker exited unexpectedly[^,;]*|worker exited unexpectedly[^,;]*)/i
   );
@@ -4451,7 +5120,7 @@ function classifyFailureReason(line, options) {
     };
   }
   const networkFailure = normalized.match(
-    /(Max retries exceeded[^,;]*|gaierror[^,;]*|SSLCertVerificationError[^,;]*|Network is unreachable)/i
+    /(Max retries exceeded[^,;]*|gaierror[^,;]*|SSLCertVerificationError[^,;]*|Network is unreachable|ConnectionResetError[^,;]*|BrokenPipeError[^,;]*|HTTPError:\s*[45]\d\d[^,;]*)/i
   );
   if (networkFailure) {
     return {
@@ -4462,6 +5131,15 @@ function classifyFailureReason(line, options) {
       group: "network dependency failures"
     };
   }
+  const matcherAssertionFailure = normalized.match(
+    /(expect\(received\)\.(?:toBe|toEqual|toStrictEqual|toMatchObject)\(expected\))/i
+  );
+  if (matcherAssertionFailure) {
+    return {
+      reason: `assertion failed: ${matcherAssertionFailure[1]}`.slice(0, 120),
+      group: "assertion failures"
+    };
+  }
   const relationMigration = normalized.match(/relation ["'`]([^"'`]+)["'`] does not exist/i);
   if (relationMigration) {
     return {
@@ -4500,6 +5178,34 @@ function classifyFailureReason(line, options) {
       group: "memory exhaustion failures"
     };
   }
+  const propertySetterOverrideFailure = normalized.match(
+    /AttributeError:\s*(property ['"][^'"]+['"] of ['"][^'"]+['"] object has no setter|can't set attribute|readonly attribute|read-only attribute)/i
+  );
+  if (propertySetterOverrideFailure) {
+    return {
+      reason: buildClassifiedReason(
+        "configuration",
+        `invalid test setup override (${buildExcerptDetail(
+          `AttributeError: ${propertySetterOverrideFailure[1] ?? normalized}`,
+          "AttributeError: can't set attribute"
+        )})`
+      ),
+      group: "test configuration failures"
+    };
+  }
+  const setupOverrideFailure = normalized.match(/\b(AttributeError|TypeError):\s*(.+)$/i);
+  if (setupOverrideFailure && /(monkeypatch|patch|fixture|settings|conftest)/i.test(normalized)) {
+    return {
+      reason: buildClassifiedReason(
+        "configuration",
+        `invalid test setup override (${buildExcerptDetail(
+          `${setupOverrideFailure[1]}: ${setupOverrideFailure[2] ?? ""}`,
+          `${setupOverrideFailure[1]}`
+        )})`
+      ),
+      group: "test configuration failures"
+    };
+  }
   const typeErrorFailure = normalized.match(/TypeError:\s*(.+)$/i);
   if (typeErrorFailure) {
     return {
@@ -5205,6 +5911,9 @@ function classifyBucketTypeFromReason(reason) {
   if (reason.startsWith("missing module:")) {
     return "import_dependency_failure";
   }
+  if (reason.startsWith("golden output drift:")) {
+    return "golden_output_drift";
+  }
   if (reason.startsWith("assertion failed:")) {
     return "assertion_failure";
   }
@@ -5581,13 +6290,17 @@ function analyzeTestStatus(input) {
   const interrupted = /\binterrupted\b/i.test(input) || /\bKeyboardInterrupt\b/i.test(input);
   const collectionItems = chooseStrongestFailureItems(collectCollectionFailureItems(input));
   const inlineItems = chooseStrongestFailureItems(collectInlineFailureItems(input));
+  const statusItems = collectInlineFailureItemsWithStatus(input);
   const visibleErrorItems = chooseStrongestStatusFailureItems([
     ...collectionItems.map((item) => ({
       ...item,
       status: "error"
     })),
-    ...collectInlineFailureItemsWithStatus(input).filter((item) => item.status === "error")
+    ...statusItems.filter((item) => item.status === "error")
   ]);
+  const visibleFailedItems = chooseStrongestStatusFailureItems(
+    statusItems.filter((item) => item.status === "failed")
+  );
   const labels = collectFailureLabels(input);
   const visibleErrorLabels = labels.filter((item) => item.status === "error").map((item) => item.label);
   const visibleFailedLabels = labels.filter((item) => item.status === "failed").map((item) => item.label);
@@ -5646,6 +6359,7 @@ function analyzeTestStatus(input) {
     visibleErrorLabels,
     visibleFailedLabels,
     visibleErrorItems,
+    visibleFailedItems,
     buckets
   };
 }
@@ -5706,20 +6420,18 @@ function testStatusHeuristic(input, detail = "standard") {
   return null;
 }
 function auditCriticalHeuristic(input) {
-  const vulnerabilities = input.split("\n").map((line) => line.trim()).filter(Boolean).map((line) => {
-    if (!/\b(critical|high)\b/i.test(line)) {
-      return null;
-    }
-    const pkg2 = inferPackage(line);
-    if (!pkg2) {
-      return null;
-    }
-    return {
-      package: pkg2,
-      severity: inferSeverity(line),
-      remediation: inferRemediation(pkg2)
-    };
-  }).filter((item) => item !== null);
+  if (/\bfound\s+0\s+vulnerabilities\b/i.test(input) || /\b0\s+vulnerabilities\b/i.test(input)) {
+    return JSON.stringify(
+      {
+        status: "ok",
+        vulnerabilities: [],
+        summary: "No high or critical vulnerabilities found in the provided input."
+      },
+      null,
+      2
+    );
+  }
+  const vulnerabilities = collectAuditCriticalVulnerabilities(input);
   if (vulnerabilities.length === 0) {
     return null;
   }
@@ -5735,16 +6447,19 @@ function auditCriticalHeuristic(input) {
   );
 }
 function infraRiskHeuristic(input) {
+  const destroyTargets = collectInfraDestroyTargets(input);
+  const blockers = collectInfraBlockers(input);
   const zeroDestructiveEvidence = input.split("\n").map((line) => line.trim()).filter((line) => line.length > 0 && ZERO_DESTRUCTIVE_SUMMARY_PATTERN.test(line)).slice(0, 3);
-  const riskEvidence = input.split("\n").map((line) => line.trim()).filter(
-    (line) => line.length > 0 && RISK_LINE_PATTERN.test(line) && !ZERO_DESTRUCTIVE_SUMMARY_PATTERN.test(line)
-  ).slice(0, 3);
+  const riskEvidence = collectInfraRiskEvidence(input);
   if (riskEvidence.length > 0) {
     return JSON.stringify(
       {
         verdict: "fail",
         reason: "Destructive or clearly risky infrastructure change signals are present.",
-        evidence: riskEvidence
+        evidence: riskEvidence,
+        destroy_count: inferInfraDestroyCount(input, destroyTargets),
+        destroy_targets: destroyTargets,
+        blockers
       },
       null,
       2
@@ -5755,7 +6470,10 @@ function infraRiskHeuristic(input) {
       {
         verdict: "pass",
         reason: "The provided input explicitly indicates zero destructive changes.",
-        evidence: zeroDestructiveEvidence
+        evidence: zeroDestructiveEvidence,
+        destroy_count: 0,
+        destroy_targets: [],
+        blockers: []
       },
       null,
       2
@@ -5767,7 +6485,10 @@ function infraRiskHeuristic(input) {
       {
         verdict: "pass",
         reason: "The provided input explicitly indicates no risky infrastructure changes.",
-        evidence: safeEvidence
+        evidence: safeEvidence,
+        destroy_count: 0,
+        destroy_targets: [],
+        blockers: []
       },
       null,
       2
@@ -5775,6 +6496,551 @@ function infraRiskHeuristic(input) {
   }
   return null;
 }
+function parseTscErrors(input) {
+  const diagnostics = [];
+  for (const rawLine of input.split("\n")) {
+    const line = rawLine.replace(/\u001b\[[0-9;]*m/g, "").trimEnd();
+    if (!line.trim()) {
+      continue;
+    }
+    let match = line.match(/^(.+)\((\d+),(\d+)\):\s+error\s+(TS\d+):\s+(.+)$/);
+    if (match) {
+      diagnostics.push({
+        file: match[1].replace(/\\/g, "/").trim(),
+        line: Number(match[2]),
+        column: Number(match[3]),
+        code: match[4],
+        message: match[5].trim()
+      });
+      continue;
+    }
+    match = line.match(/^(.+):(\d+):(\d+)\s+-\s+error\s+(TS\d+):\s+(.+)$/);
+    if (match) {
+      diagnostics.push({
+        file: match[1].replace(/\\/g, "/").trim(),
+        line: Number(match[2]),
+        column: Number(match[3]),
+        code: match[4],
+        message: match[5].trim()
+      });
+      continue;
+    }
+    match = line.match(/^\s*error\s+(TS\d+):\s+(.+)$/);
+    if (match) {
+      diagnostics.push({
+        file: null,
+        line: null,
+        column: null,
+        code: match[1],
+        message: match[2].trim()
+      });
+    }
+  }
+  return diagnostics;
+}
+function extractTscSummary(input) {
+  const matches = [
+    ...input.matchAll(/\bFound\s+(\d+)\s+errors?\b(?:\s+in\s+(\d+)\s+files?)?\.?/gi)
+  ];
+  const summary = matches.at(-1);
+  if (!summary) {
+    return null;
+  }
+  return {
+    errorCount: Number(summary[1]),
+    fileCount: summary[2] ? Number(summary[2]) : null
+  };
+}
+function formatTscGroup(args) {
+  const label = TSC_CODE_LABELS[args.code];
+  const displayFiles = formatDisplayedFiles(args.files);
+  let line = `- ${args.code}`;
+  if (label) {
+    line += ` (${label})`;
+  }
+  line += `: ${formatCount2(args.count, "occurrence")}`;
+  if (displayFiles.length > 0) {
+    line += ` across ${displayFiles.join(", ")}`;
+  }
+  return `${line}.`;
+}
+function typecheckSummaryHeuristic(input) {
+  if (input.trim().length === 0) {
+    return null;
+  }
+  const diagnostics = parseTscErrors(input);
+  const summary = extractTscSummary(input);
+  const hasTscSignal = diagnostics.length > 0 || summary !== null || /\berror\s+TS\d+:/m.test(input);
+  if (!hasTscSignal) {
+    return null;
+  }
+  if (summary?.errorCount === 0) {
+    return "No type errors.";
+  }
+  if (diagnostics.length === 0 && summary === null) {
+    return null;
+  }
+  const errorCount = summary?.errorCount ?? diagnostics.length;
+  const allFiles = new Set(
+    diagnostics.map((diagnostic) => diagnostic.file).filter((file) => Boolean(file))
+  );
+  const fileCount = summary?.fileCount ?? (allFiles.size > 0 ? allFiles.size : null);
+  const groups = /* @__PURE__ */ new Map();
+  for (const diagnostic of diagnostics) {
+    const group = groups.get(diagnostic.code) ?? {
+      count: 0,
+      files: /* @__PURE__ */ new Set()
+    };
+    group.count += 1;
+    if (diagnostic.file) {
+      group.files.add(diagnostic.file);
+    }
+    groups.set(diagnostic.code, group);
+  }
+  const bullets = [
+    `- Typecheck failed: ${formatCount2(errorCount, "error")}${fileCount ? ` in ${formatCount2(fileCount, "file")}` : ""}.`
+  ];
+  const sortedGroups = [...groups.entries()].map(([code, group]) => ({
+    code,
+    count: group.count,
+    files: group.files
+  })).sort((left, right) => right.count - left.count || left.code.localeCompare(right.code));
+  for (const group of sortedGroups.slice(0, 3)) {
+    bullets.push(formatTscGroup(group));
+  }
+  if (sortedGroups.length > 3) {
+    const overflowFiles = /* @__PURE__ */ new Set();
+    for (const group of sortedGroups.slice(3)) {
+      for (const file of group.files) {
+        overflowFiles.add(file);
+      }
+    }
+    let overflow = `- ${formatCount2(sortedGroups.length - 3, "more error code")}`;
+    if (overflowFiles.size > 0) {
+      overflow += ` across ${formatCount2(overflowFiles.size, "file")}`;
+    }
+    bullets.push(`${overflow}.`);
+  }
+  return bullets.join("\n");
+}
+function looksLikeEslintFileHeader(line) {
+  if (line.trim().length === 0 || line.trim() !== line) {
+    return false;
+  }
+  if (/^\s*[✖×x]\s+\d+\s+problems?\b/i.test(line) || /potentially\s+fixable/i.test(line) || /^\d+\s+problems?\b/i.test(line)) {
+    return false;
+  }
+  const normalized = line.replace(/\\/g, "/");
+  const pathLike = normalized.startsWith("/") || normalized.startsWith("./") || normalized.startsWith("../") || /^[A-Za-z]:\//.test(normalized) || /^[A-Za-z0-9_.-]+\//.test(normalized);
+  return pathLike && /\.[A-Za-z0-9]+$/.test(normalized);
+}
+function normalizeEslintRule(rule, message) {
+  if (rule && rule.trim().length > 0) {
+    return rule.trim();
+  }
+  if (/parsing error/i.test(message)) {
+    return "parsing error";
+  }
+  if (/fatal/i.test(message)) {
+    return "fatal error";
+  }
+  return "unclassified lint error";
+}
+function parseEslintStylish(input) {
+  const violations = [];
+  let currentFile = null;
+  for (const rawLine of input.split("\n")) {
+    const line = rawLine.replace(/\u001b\[[0-9;]*m/g, "").replace(/\r$/, "");
+    if (looksLikeEslintFileHeader(line.trim())) {
+      currentFile = line.trim().replace(/\\/g, "/");
+      continue;
+    }
+    let match = line.match(/^\s*(\d+):(\d+)\s+(error|warning)\s+(.+?)\s{2,}(\S+)\s*$/);
+    if (match) {
+      violations.push({
+        file: currentFile ?? "(unknown file)",
+        line: Number(match[1]),
+        column: Number(match[2]),
+        severity: match[3],
+        message: match[4].trim(),
+        rule: normalizeEslintRule(match[5], match[4])
+      });
+      continue;
+    }
+    match = line.match(/^\s*(\d+):(\d+)\s+(error|warning)\s+(.+?)\s*$/);
+    if (match) {
+      violations.push({
+        file: currentFile ?? "(unknown file)",
+        line: Number(match[1]),
+        column: Number(match[2]),
+        severity: match[3],
+        message: match[4].trim(),
+        rule: normalizeEslintRule(null, match[4])
+      });
+    }
+  }
+  return violations;
+}
+function extractEslintSummary(input) {
+  const summaryMatches = [
+    ...input.matchAll(
+      /^\s*[✖×x]?\s*(\d+)\s+problems?\s+\((\d+)\s+errors?,\s+(\d+)\s+warnings?\)/gim
+    )
+  ];
+  const summary = summaryMatches.at(-1);
+  if (!summary) {
+    return null;
+  }
+  const fixableMatch = input.match(
+    /(\d+)\s+errors?\s+and\s+(\d+)\s+warnings?\s+(?:are|is)\s+potentially\s+fixable/i
+  );
+  return {
+    problems: Number(summary[1]),
+    errors: Number(summary[2]),
+    warnings: Number(summary[3]),
+    fixableProblems: fixableMatch ? Number(fixableMatch[1]) + Number(fixableMatch[2]) : null
+  };
+}
+function formatLintGroup(args) {
+  const totalErrors = args.errors;
+  const totalWarnings = args.warnings;
+  const displayFiles = formatDisplayedFiles(args.files);
+  let detail = "";
+  if (totalErrors > 0 && totalWarnings > 0) {
+    detail = `${formatCount2(totalErrors, "error")}, ${formatCount2(totalWarnings, "warning")}`;
+  } else if (totalErrors > 0) {
+    detail = formatCount2(totalErrors, "error");
+  } else {
+    detail = formatCount2(totalWarnings, "warning");
+  }
+  let line = `- ${args.rule}: ${detail}`;
+  if (displayFiles.length > 0) {
+    line += ` across ${displayFiles.join(", ")}`;
+  }
+  return `${line}.`;
+}
+function lintFailuresHeuristic(input) {
+  const trimmed = input.trim();
+  if (trimmed.length === 0 || trimmed.startsWith("[") || trimmed.startsWith("{")) {
+    return null;
+  }
+  const summary = extractEslintSummary(input);
+  const violations = parseEslintStylish(input);
+  if (summary === null && violations.length === 0) {
+    return null;
+  }
+  if (summary?.problems === 0) {
+    return "No lint failures.";
+  }
+  const problems = summary?.problems ?? violations.length;
+  const errors = summary?.errors ?? countPattern(input, /^\s*\d+:\d+\s+error\b/gm);
+  const warnings = summary?.warnings ?? countPattern(input, /^\s*\d+:\d+\s+warning\b/gm);
+  const bullets = [];
+  if (errors > 0) {
+    let headline = `- Lint failed: ${formatCount2(problems, "problem")} (${formatCount2(errors, "error")}, ${formatCount2(warnings, "warning")}).`;
+    if ((summary?.fixableProblems ?? 0) > 0) {
+      headline += ` ${formatCount2(summary.fixableProblems, "problem")} potentially fixable with --fix.`;
+    }
+    bullets.push(headline);
+  } else {
+    bullets.push(`- No lint errors visible: ${formatCount2(warnings, "warning")}.`);
+  }
+  const groups = /* @__PURE__ */ new Map();
+  for (const violation of violations) {
+    const group = groups.get(violation.rule) ?? {
+      errors: 0,
+      warnings: 0,
+      files: /* @__PURE__ */ new Set()
+    };
+    if (violation.severity === "error") {
+      group.errors += 1;
+    } else {
+      group.warnings += 1;
+    }
+    group.files.add(violation.file);
+    groups.set(violation.rule, group);
+  }
+  const sortedGroups = [...groups.entries()].map(([rule, group]) => ({
+    rule,
+    errors: group.errors,
+    warnings: group.warnings,
+    total: group.errors + group.warnings,
+    files: group.files
+  })).sort((left, right) => {
+    const leftHasErrors = left.errors > 0 ? 1 : 0;
+    const rightHasErrors = right.errors > 0 ? 1 : 0;
+    return rightHasErrors - leftHasErrors || right.total - left.total || left.rule.localeCompare(right.rule);
+  });
+  for (const group of sortedGroups.slice(0, 3)) {
+    bullets.push(formatLintGroup(group));
+  }
+  if (sortedGroups.length > 3) {
+    const overflowFiles = /* @__PURE__ */ new Set();
+    for (const group of sortedGroups.slice(3)) {
+      for (const file of group.files) {
+        overflowFiles.add(file);
+      }
+    }
+    let overflow = `- ${formatCount2(sortedGroups.length - 3, "more rule")}`;
+    if (overflowFiles.size > 0) {
+      overflow += ` across ${formatCount2(overflowFiles.size, "file")}`;
+    }
+    bullets.push(`${overflow}.`);
+  }
+  return bullets.join("\n");
+}
+function stripAnsiText(input) {
+  return input.replace(/\u001b\[[0-9;]*m/g, "");
+}
+function normalizeBuildPath(file) {
+  return file.replace(/\\/g, "/").replace(/^\.\//, "").trim();
+}
+function trimTrailingSentencePunctuation(input) {
+  return input.replace(/[.:]+$/, "").trim();
+}
+function containsKnownBuildFailureSignal(input) {
+  return /^ERROR in /m.test(input) || /^(?:[✘✗]\s*)?\[ERROR\]\s+/m.test(input) || /^error(?:\[E\d+\])?:\s+/m.test(input) || /^.+?\.go:\d+:\d+:\s+\S+/m.test(input) || /^.+?\.(?:c|cc|cpp|cxx|h|hpp|m|mm):\d+:\d+:\s*error:\s+/m.test(input) || /\berror\s+TS\d+:/m.test(input) || /^\s*npm ERR!/m.test(input) || /\bERR_PNPM_/m.test(input) || /^\s*error Command failed/m.test(input);
+}
+function detectExplicitBuildSuccess(input) {
+  if (containsKnownBuildFailureSignal(input)) {
+    return false;
+  }
+  return /\bcompiled successfully\b/i.test(input) || /^\s*Build succeeded\.?\s*$/im.test(input) || /\bcompiled with 0 errors?\b/i.test(input);
+}
+function inferBuildFailureCategory(message) {
+  if (/module not found|can't resolve|could not resolve|cannot find module|no required module provides package/i.test(
+    message
+  )) {
+    return "module-resolution";
+  }
+  if (/no matching export|does not provide an export named|missing export/i.test(message)) {
+    return "missing-export";
+  }
+  if (/cannot find name|cannot find value|not found in this scope|undefined:|undeclared identifier/i.test(
+    message
+  )) {
+    return "undefined-identifier";
+  }
+  if (/syntax error|unexpected token|expected ['"`;)]|expected .* after expression/i.test(message)) {
+    return "syntax";
+  }
+  if (/\bTS\d+\b/.test(message) || /type .* is not assignable|type error|no matching overload/i.test(message)) {
+    return "type";
+  }
+  return "generic";
+}
+function buildFailureSuggestion(category) {
+  switch (category) {
+    case "module-resolution":
+      return "Install the missing package or fix the import path.";
+    case "missing-export":
+      return "Check the export name in the source module.";
+    case "undefined-identifier":
+      return "Define or import the missing identifier.";
+    case "syntax":
+      return "Fix the syntax error at the indicated location.";
+    case "type":
+      return "Fix the type error at the indicated location.";
+    case "wrapper":
+      return "Check the underlying build tool output above.";
+    default:
+      return "Fix the first reported error and rebuild.";
+  }
+}
+function formatBuildFailureOutput(match) {
+  const message = trimTrailingSentencePunctuation(match.message);
+  const suggestion = buildFailureSuggestion(match.category);
+  const displayFile = match.file ? compactDisplayFile(match.file) : null;
+  if (displayFile && match.line !== null) {
+    return `Build failed: ${message} in ${displayFile}:${match.line}. Fix: ${suggestion}`;
+  }
+  if (displayFile) {
+    return `Build failed: ${message} in ${displayFile}. Fix: ${suggestion}`;
+  }
+  return `Build failed: ${message}. Fix: ${suggestion}`;
+}
+function extractWebpackBuildFailure(input) {
+  const lines = stripAnsiText(input).split("\n").map((line) => line.trimEnd());
+  for (let index = 0; index < lines.length; index += 1) {
+    const match = lines[index]?.match(/^ERROR in (.+?)(?:\s+(\d+):(\d+))?$/);
+    if (!match) {
+      continue;
+    }
+    const candidates = [];
+    for (let cursor = index + 1; cursor < Math.min(lines.length, index + 6); cursor += 1) {
+      const candidate = lines[cursor]?.trim();
+      if (!candidate) {
+        continue;
+      }
+      if (/^ERROR in /.test(candidate) || /compiled with \d+ errors?/i.test(candidate)) {
+        break;
+      }
+      if (/^(?:>|\|)|^\d+\s+\|/.test(candidate)) {
+        continue;
+      }
+      candidates.push(candidate);
+    }
+    let message = "Compilation error";
+    if (candidates.length > 0) {
+      const preferred = candidates.find(
+        (candidate) => !/^Module build failed\b/i.test(candidate) && !/^Error:\s+TypeScript compilation failed\b/i.test(candidate) && inferBuildFailureCategory(candidate) !== "generic"
+      ) ?? candidates.find(
+        (candidate) => !/^Module build failed\b/i.test(candidate) && !/^Error:\s+TypeScript compilation failed\b/i.test(candidate)
+      ) ?? candidates[0];
+      message = preferred ?? message;
+    }
+    return {
+      message,
+      file: normalizeBuildPath(match[1]),
+      line: match[2] ? Number(match[2]) : null,
+      column: match[3] ? Number(match[3]) : null,
+      category: inferBuildFailureCategory(message)
+    };
+  }
+  return null;
+}
+function extractViteImportAnalysisBuildFailure(input) {
+  const lines = stripAnsiText(input).split("\n").map((line) => line.trim());
+  for (const line of lines) {
+    const match = line.match(
+      /^\[plugin:vite:import-analysis\]\s+Failed to resolve import\s+"([^"]+)"\s+from\s+"([^"]+)"/i
+    );
+    if (!match) {
+      continue;
+    }
+    return {
+      message: `Failed to resolve import "${match[1]}"`,
+      file: normalizeBuildPath(match[2]),
+      line: null,
+      column: null,
+      category: "module-resolution"
+    };
+  }
+  return null;
+}
+function extractEsbuildBuildFailure(input) {
+  const lines = stripAnsiText(input).split("\n").map((line) => line.trimEnd());
+  for (let index = 0; index < lines.length; index += 1) {
+    const match = lines[index]?.match(/^(?:[✘✗]\s*)?\[ERROR\]\s*(.+)$/);
+    if (!match) {
+      continue;
+    }
+    const message = match[1].replace(/^\[vite\]\s*/i, "").trim();
+    let file = null;
+    let line = null;
+    let column = null;
+    for (let cursor = index + 1; cursor < Math.min(lines.length, index + 6); cursor += 1) {
+      const locationMatch = lines[cursor]?.trim().match(/^(.+?):(\d+):(\d+):$/);
+      if (!locationMatch) {
+        continue;
+      }
+      file = normalizeBuildPath(locationMatch[1]);
+      line = Number(locationMatch[2]);
+      column = Number(locationMatch[3]);
+      break;
+    }
+    return {
+      message,
+      file,
+      line,
+      column,
+      category: inferBuildFailureCategory(message)
+    };
+  }
+  return null;
+}
+function extractCargoBuildFailure(input) {
+  if (!/^error(?:\[E\d+\])?:\s+/m.test(input) || !(/^\s*-->\s+/m.test(input) || /could not compile/i.test(input))) {
+    return null;
+  }
+  const lines = stripAnsiText(input).split("\n").map((line) => line.trimEnd());
+  for (let index = 0; index < lines.length; index += 1) {
+    const match = lines[index]?.match(/^error(?:\[(E\d+)\])?:\s+(.+)$/);
+    if (!match) {
+      continue;
+    }
+    const code = match[1];
+    const locationMatch = lines.slice(index + 1, index + 7).join("\n").match(/^\s*-->\s+(.+?):(\d+):(\d+)/m);
+    return {
+      message: code ? `${code}: ${match[2].trim()}` : match[2].trim(),
+      file: locationMatch ? normalizeBuildPath(locationMatch[1]) : null,
+      line: locationMatch ? Number(locationMatch[2]) : null,
+      column: locationMatch ? Number(locationMatch[3]) : null,
+      category: inferBuildFailureCategory(match[2])
+    };
+  }
+  return null;
+}
+function extractCompilerStyleBuildFailure(input) {
+  const lines = stripAnsiText(input).split("\n").map((line) => line.trimEnd());
+  for (const rawLine of lines) {
+    let match = rawLine.match(
+      /^(.+?\.(?:c|cc|cpp|cxx|h|hpp|m|mm)):([0-9]+):([0-9]+):\s*error:\s+(.+)$/
+    );
+    if (match) {
+      return {
+        message: match[4].trim(),
+        file: normalizeBuildPath(match[1]),
+        line: Number(match[2]),
+        column: Number(match[3]),
+        category: inferBuildFailureCategory(match[4])
+      };
+    }
+    match = rawLine.match(/^(.+?\.go):([0-9]+):([0-9]+):\s+(.+)$/);
+    if (match && !/^\s*warning:/i.test(match[4])) {
+      return {
+        message: match[4].trim(),
+        file: normalizeBuildPath(match[1]),
+        line: Number(match[2]),
+        column: Number(match[3]),
+        category: inferBuildFailureCategory(match[4])
+      };
+    }
+  }
+  return null;
+}
+function extractTscBuildFailure(input) {
+  const diagnostics = parseTscErrors(input);
+  const first = diagnostics[0];
+  if (!first) {
+    return null;
+  }
+  return {
+    message: `${first.code}: ${first.message}`,
+    file: first.file,
+    line: first.line,
+    column: first.column,
+    category: inferBuildFailureCategory(`${first.code}: ${first.message}`)
+  };
+}
+function extractWrapperBuildFailure(input) {
+  if (!/^\s*npm ERR!|\bERR_PNPM_|^\s*error Command failed/m.test(input)) {
+    return null;
+  }
+  const npmCommandMatch = input.match(/^\s*npm ERR!\s+.*?\bbuild:\s+`([^`]+)`/m);
+  const genericCommandMatch = input.match(/^\s*.+?\s+build:\s+`([^`]+)`/m);
+  const command = npmCommandMatch?.[1] ?? genericCommandMatch?.[1] ?? null;
+  return {
+    message: command ? `build script \`${command}\` failed` : "the build script failed",
+    file: null,
+    line: null,
+    column: null,
+    category: "wrapper"
+  };
+}
+function buildFailureHeuristic(input) {
+  if (input.trim().length === 0) {
+    return null;
+  }
+  if (detectExplicitBuildSuccess(input)) {
+    return "Build succeeded.";
+  }
+  const match = extractViteImportAnalysisBuildFailure(input) ?? extractWebpackBuildFailure(input) ?? extractEsbuildBuildFailure(input) ?? extractCargoBuildFailure(input) ?? extractCompilerStyleBuildFailure(input) ?? extractTscBuildFailure(input) ?? extractWrapperBuildFailure(input);
+  if (!match) {
+    return null;
+  }
+  return formatBuildFailureOutput(match);
+}
 function applyHeuristicPolicy(policyName, input, detail) {
   if (!policyName) {
     return null;
@@ -5788,6 +7054,15 @@ function applyHeuristicPolicy(policyName, input, detail) {
   if (policyName === "test-status") {
     return testStatusHeuristic(input, detail);
   }
+  if (policyName === "typecheck-summary") {
+    return typecheckSummaryHeuristic(input);
+  }
+  if (policyName === "lint-failures") {
+    return lintFailuresHeuristic(input);
+  }
+  if (policyName === "build-failure") {
+    return buildFailureHeuristic(input);
+  }
   return null;
 }
 
@@ -5867,36 +7142,168 @@ function truncateInput(input, options) {
     truncatedApplied: true
   };
 }
-
-// src/core/pipeline.ts
-function prepareInput(raw, config) {
-  const sanitized = sanitizeInput(raw, config.stripAnsi);
-  const redacted = config.redact || config.redactStrict ? redactInput(sanitized, { strict: config.redactStrict }) : sanitized;
-  const truncated = truncateInput(redacted, {
-    maxInputChars: config.maxInputChars,
-    headChars: config.headChars,
-    tailChars: config.tailChars
+
+// src/core/pipeline.ts
+function prepareInput(raw, config) {
+  const sanitized = sanitizeInput(raw, config.stripAnsi);
+  const redacted = config.redact || config.redactStrict ? redactInput(sanitized, { strict: config.redactStrict }) : sanitized;
+  const truncated = truncateInput(redacted, {
+    maxInputChars: config.maxInputChars,
+    headChars: config.headChars,
+    tailChars: config.tailChars
+  });
+  return {
+    raw,
+    sanitized,
+    redacted,
+    truncated: truncated.text,
+    meta: {
+      originalLength: raw.length,
+      finalLength: truncated.text.length,
+      redactionApplied: config.redact || config.redactStrict,
+      truncatedApplied: truncated.truncatedApplied
+    }
+  };
+}
+
+// src/core/rawSlice.ts
+function escapeRegExp2(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function unique3(values) {
+  return [...new Set(values)];
+}
+var genericBucketSearchTerms = /* @__PURE__ */ new Set([
+  "runtimeerror",
+  "typeerror",
+  "error",
+  "exception",
+  "failed",
+  "failure",
+  "visible failure",
+  "failing tests",
+  "setup failures",
+  "runtime failure",
+  "assertion failed",
+  "network",
+  "permission",
+  "configuration"
+]);
+function normalizeSearchTerm(value) {
+  return value.replace(/^['"`]+|['"`]+$/g, "").trim();
+}
+function isHighSignalSearchTerm(term) {
+  const normalized = normalizeSearchTerm(term);
+  if (normalized.length < 4) {
+    return false;
+  }
+  const lower = normalized.toLowerCase();
+  if (genericBucketSearchTerms.has(lower)) {
+    return false;
+  }
+  if (/^(runtime|type|assertion|network|permission|configuration)\b/i.test(normalized)) {
+    return false;
+  }
+  return true;
+}
+function scoreSearchTerm(term) {
+  const normalized = normalizeSearchTerm(term);
+  let score = normalized.length;
+  if (/^[A-Z][A-Z0-9_]{2,}$/.test(normalized)) {
+    score += 80;
+  }
+  if (/^TS\d+$/.test(normalized)) {
+    score += 70;
+  }
+  if (/^[45]\d\d\b/.test(normalized) || /\bHTTPError:\s*[45]\d\d\b/i.test(normalized)) {
+    score += 60;
+  }
+  if (normalized.includes("/") || normalized.includes("\\")) {
+    score += 50;
+  }
+  if (/\b[A-Za-z0-9_.-]+\.[A-Za-z0-9_.-]+\b/.test(normalized)) {
+    score += 40;
+  }
+  if (/['"`]/.test(term)) {
+    score += 30;
+  }
+  if (normalized.includes("::")) {
+    score += 25;
+  }
+  return score;
+}
+function collectCandidateSearchTerms(value) {
+  const candidates = [];
+  const normalized = value.trim();
+  if (!normalized) {
+    return candidates;
+  }
+  for (const match of normalized.matchAll(/['"`]([^'"`]{4,})['"`]/g)) {
+    candidates.push(match[1]);
+  }
+  for (const match of normalized.matchAll(/\b[A-Z][A-Z0-9_]{2,}\b/g)) {
+    candidates.push(match[0]);
+  }
+  for (const match of normalized.matchAll(/\bTS\d+\b/g)) {
+    candidates.push(match[0]);
+  }
+  for (const match of normalized.matchAll(/\bHTTPError:\s*[45]\d\d\b/gi)) {
+    candidates.push(match[0]);
+  }
+  for (const match of normalized.matchAll(/\/[A-Za-z0-9_./:{}-]{4,}/g)) {
+    candidates.push(match[0]);
+  }
+  for (const match of normalized.matchAll(/\b(?:[A-Za-z0-9_.-]+\/)+[A-Za-z0-9_.-]+\b/g)) {
+    candidates.push(match[0]);
+  }
+  for (const match of normalized.matchAll(/\b[A-Za-z0-9_.-]+\.[A-Za-z0-9_.-]+\b/g)) {
+    candidates.push(match[0]);
+  }
+  const detail = normalized.split(":").slice(1).join(":").trim();
+  if (detail.length >= 8) {
+    candidates.push(detail);
+  }
+  return candidates;
+}
+function extractBucketSearchTerms(args) {
+  const sources = [
+    args.bucket.root_cause,
+    ...args.bucket.evidence,
+    ...args.readTargets.filter((target) => target.bucket_index === args.bucket.bucket_index).flatMap((target) => [target.context_hint.search_hint ?? "", target.file])
+  ];
+  const prioritized = unique3(
+    sources.flatMap((value) => collectCandidateSearchTerms(value)).filter(isHighSignalSearchTerm)
+  ).sort((left, right) => {
+    const delta = scoreSearchTerm(right) - scoreSearchTerm(left);
+    if (delta !== 0) {
+      return delta;
+    }
+    return left.localeCompare(right);
   });
-  return {
-    raw,
-    sanitized,
-    redacted,
-    truncated: truncated.text,
-    meta: {
-      originalLength: raw.length,
-      finalLength: truncated.text.length,
-      redactionApplied: config.redact || config.redactStrict,
-      truncatedApplied: truncated.truncatedApplied
-    }
-  };
-}
-
-// src/core/rawSlice.ts
-function escapeRegExp2(value) {
-  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  if (prioritized.length > 0) {
+    return prioritized.slice(0, 6);
+  }
+  const fallbackTerms = unique3(
+    [...args.bucket.evidence, args.bucket.root_cause].flatMap((value) => value.split(/->|:/).map((part) => normalizeSearchTerm(part))).filter(isHighSignalSearchTerm)
+  );
+  return fallbackTerms.slice(0, 4);
 }
-function unique2(values) {
-  return [...new Set(values)];
+function clusterIndexes(indexes, maxGap = 12) {
+  if (indexes.length === 0) {
+    return [];
+  }
+  const clusters = [];
+  let currentCluster = [indexes[0]];
+  for (const index of indexes.slice(1)) {
+    if (index - currentCluster[currentCluster.length - 1] <= maxGap) {
+      currentCluster.push(index);
+      continue;
+    }
+    clusters.push(currentCluster);
+    currentCluster = [index];
+  }
+  clusters.push(currentCluster);
+  return clusters;
 }
 function buildLineWindows(args) {
   const selected = /* @__PURE__ */ new Set();
@@ -5913,11 +7320,17 @@ function buildLineWindows(args) {
   }
   return [...selected].sort((left, right) => left - right).map((index) => args.lines[index]);
 }
+function buildPriorityLineGroup(args) {
+  return unique3([
+    ...args.indexes.map((index) => args.lines[index]).filter(Boolean),
+    ...buildLineWindows(args)
+  ]);
+}
 function collapseSelectedLines(args) {
   if (args.lines.length === 0) {
     return args.fallback();
   }
-  const joined = unique2(args.lines).join("\n").trim();
+  const joined = unique3(args.lines).join("\n").trim();
   if (joined.length === 0) {
     return args.fallback();
   }
@@ -6061,15 +7474,16 @@ function buildTestStatusRawSlice(args) {
     ) ? index : -1
   ).filter((index) => index >= 0);
   const bucketGroups = args.contract.main_buckets.map((bucket) => {
-    const bucketTerms = unique2(
-      [bucket.root_cause, ...bucket.evidence].map((value) => value.split(":").at(-1)?.trim() ?? value.trim()).filter((value) => value.length >= 4)
-    );
+    const bucketTerms = extractBucketSearchTerms({
+      bucket,
+      readTargets: args.contract.read_targets
+    });
     const indexes = lines.map(
       (line, index) => bucketTerms.some((term) => new RegExp(escapeRegExp2(term), "i").test(line)) ? index : -1
     ).filter((index) => index >= 0);
-    return unique2([
+    return unique3([
       ...indexes.map((index) => lines[index]).filter(Boolean),
-      ...buildLineWindows({
+      ...buildPriorityLineGroup({
         lines,
         indexes,
         radius: 2,
@@ -6077,30 +7491,59 @@ function buildTestStatusRawSlice(args) {
       })
     ]);
   });
-  const targetGroups = args.contract.read_targets.map(
-    (target) => buildLineWindows({
+  const targetGroups = args.contract.read_targets.flatMap((target) => {
+    const searchHintIndexes = findSearchHintIndexes({
       lines,
-      indexes: unique2([
-        ...findReadTargetIndexes({
-          lines,
-          file: target.file,
-          line: target.line,
-          contextHint: target.context_hint
-        }),
-        ...findSearchHintIndexes({
-          lines,
-          searchHint: target.context_hint.search_hint
-        })
-      ]),
-      radius: target.line === null ? 1 : 2,
-      maxLines: target.line === null ? 6 : 8
+      searchHint: target.context_hint.search_hint
+    });
+    const fileIndexes = findReadTargetIndexes({
+      lines,
+      file: target.file,
+      line: target.line,
+      contextHint: target.context_hint
+    });
+    const radius = target.line === null ? 1 : 2;
+    const maxLines = target.line === null ? 6 : 8;
+    const groups = [
+      searchHintIndexes.length > 0 ? buildPriorityLineGroup({
+        lines,
+        indexes: searchHintIndexes,
+        radius,
+        maxLines
+      }) : null,
+      fileIndexes.length > 0 ? buildPriorityLineGroup({
+        lines,
+        indexes: fileIndexes,
+        radius,
+        maxLines
+      }) : null
+    ].filter((group) => group !== null && group.length > 0);
+    if (groups.length > 0) {
+      return groups;
+    }
+    return [
+      buildPriorityLineGroup({
+        lines,
+        indexes: unique3([...searchHintIndexes, ...fileIndexes]),
+        radius,
+        maxLines
+      })
+    ];
+  });
+  const failureHeaderIndexes = lines.map((line, index) => /\b(FAILED|ERROR)\b/.test(line) ? index : -1).filter((index) => index >= 0);
+  const failureIndexes = (failureHeaderIndexes.length > 0 ? failureHeaderIndexes : lines.map((line, index) => /^E\s/.test(line) ? index : -1).filter((index) => index >= 0)).filter((index) => index >= 0);
+  const failureHeaderGroups = clusterIndexes(failureIndexes).slice(0, 8).map(
+    (cluster) => buildPriorityLineGroup({
+      lines,
+      indexes: cluster,
+      radius: 1,
+      maxLines: 8
     })
-  );
-  const failureIndexes = lines.map((line, index) => /\b(FAILED|ERROR)\b/.test(line) || /^E\s/.test(line) ? index : -1).filter((index) => index >= 0);
+  ).filter((group) => group.length > 0);
   const selected = collapseSelectedLineGroups({
     groups: [
       ...targetGroups,
-      unique2([
+      unique3([
         ...summaryIndexes.map((index) => lines[index]).filter(Boolean),
         ...buildLineWindows({
           lines,
@@ -6110,12 +7553,14 @@ function buildTestStatusRawSlice(args) {
         })
       ]),
       ...bucketGroups,
-      buildLineWindows({
-        lines,
-        indexes: failureIndexes,
-        radius: 1,
-        maxLines: 24
-      })
+      ...failureHeaderGroups.length > 0 ? failureHeaderGroups : [
+        buildLineWindows({
+          lines,
+          indexes: failureIndexes,
+          radius: 1,
+          maxLines: 24
+        })
+      ]
     ],
     maxInputChars: args.config.maxInputChars,
     fallback: () => truncateInput(args.input, {
@@ -6256,7 +7701,8 @@ function withInsufficientHint(args) {
   return buildInsufficientSignalOutput({
     presetName: args.request.presetName,
     originalLength: args.prepared.meta.originalLength,
-    truncatedApplied: args.prepared.meta.truncatedApplied
+    truncatedApplied: args.prepared.meta.truncatedApplied,
+    recognizedRunner: detectTestRunner(args.prepared.redacted)
   });
 }
 async function generateWithRetry(args) {
@@ -6295,6 +7741,34 @@ function hasRecognizableTestStatusSignal(input) {
   const analysis = analyzeTestStatus(input);
   return analysis.collectionErrorCount !== void 0 || analysis.noTestsCollected || analysis.interrupted || analysis.failed > 0 || analysis.errors > 0 || analysis.passed > 0 || analysis.inlineItems.length > 0 || analysis.buckets.length > 0;
 }
+function shouldUseCompactTestStatusBypass(args) {
+  if (args.request.policyName !== "test-status") {
+    return false;
+  }
+  if (args.request.detail && args.request.detail !== "standard") {
+    return false;
+  }
+  if (args.request.goal === "diagnose" && args.request.format === "json") {
+    return false;
+  }
+  if (args.request.testStatusContext?.resolvedTests?.length || args.request.testStatusContext?.remainingTests?.length || args.request.testStatusContext?.remainingSubsetAvailable || args.request.testStatusContext?.remainingMode && args.request.testStatusContext.remainingMode !== "none") {
+    return false;
+  }
+  return args.analysis.failed === 0 && args.analysis.errors === 0 && args.analysis.passed > 0 || args.analysis.collectionErrorCount !== void 0 && args.analysis.collectionItems.length === 0 && args.analysis.inlineItems.length === 0 && args.analysis.buckets.length === 0 || args.analysis.noTestsCollected || args.analysis.interrupted && args.analysis.failed === 0 && args.analysis.errors === 0;
+}
+function sanitizeProviderFailureReason(reason) {
+  const normalized = reason.trim();
+  const httpStatus = normalized.match(/\bHTTP\s+(\d{3})\b/i)?.[1];
+  if (httpStatus) {
+    return `provider follow-up unavailable (HTTP ${httpStatus})`;
+  }
+  if (/unterminated string|invalid json|unexpected token|json at position|schema|zod|parse/i.test(
+    normalized
+  )) {
+    return "provider follow-up returned unusable structured output";
+  }
+  return "provider follow-up failed";
+}
 function renderTestStatusDecisionOutput(args) {
   if (args.request.goal === "diagnose" && args.request.format === "json") {
     return JSON.stringify(
@@ -6316,12 +7790,49 @@ function renderTestStatusDecisionOutput(args) {
   return args.decision.standardText;
 }
 function buildTestStatusProviderFailureDecision(args) {
+  const sanitizedReason = sanitizeProviderFailureReason(args.reason);
+  const concreteReadTarget = args.baseDecision.contract.read_targets.find(
+    (target) => Boolean(target.file)
+  );
+  const hasUnknownBucket = args.baseDecision.contract.main_buckets.some(
+    (bucket) => bucket.root_cause.startsWith("unknown ")
+  );
+  if (concreteReadTarget && !hasUnknownBucket) {
+    return buildTestStatusDiagnoseContract({
+      input: args.input,
+      analysis: args.analysis,
+      resolvedTests: args.baseDecision.contract.resolved_tests,
+      remainingTests: args.baseDecision.contract.remaining_tests,
+      remainingMode: args.request.testStatusContext?.remainingMode,
+      contractOverrides: {
+        ...args.baseDecision.contract,
+        diagnosis_complete: false,
+        raw_needed: false,
+        additional_source_read_likely_low_value: false,
+        read_raw_only_if: null,
+        decision: "read_source",
+        provider_used: true,
+        provider_confidence: null,
+        provider_failed: true,
+        raw_slice_used: args.rawSliceUsed,
+        raw_slice_strategy: args.rawSliceStrategy,
+        next_best_action: {
+          code: "read_source_for_bucket",
+          bucket_index: args.baseDecision.contract.dominant_blocker_bucket_index ?? concreteReadTarget.bucket_index,
+          note: `${sanitizedReason[0].toUpperCase()}${sanitizedReason.slice(
+            1
+          )}. The heuristic anchor is concrete enough to inspect source for the current bucket before reading raw traceback.`
+        }
+      }
+    });
+  }
   const shouldZoomFirst = args.request.detail !== "verbose";
   return buildTestStatusDiagnoseContract({
     input: args.input,
     analysis: args.analysis,
     resolvedTests: args.baseDecision.contract.resolved_tests,
     remainingTests: args.baseDecision.contract.remaining_tests,
+    remainingMode: args.request.testStatusContext?.remainingMode,
     contractOverrides: {
       ...args.baseDecision.contract,
       diagnosis_complete: false,
@@ -6337,12 +7848,16 @@ function buildTestStatusProviderFailureDecision(args) {
       next_best_action: {
         code: shouldZoomFirst ? "insufficient_signal" : "read_raw_for_exact_traceback",
         bucket_index: args.baseDecision.contract.dominant_blocker_bucket_index ?? args.baseDecision.contract.main_buckets[0]?.bucket_index ?? null,
-        note: shouldZoomFirst ? `Provider follow-up failed (${args.reason}). Use one deeper sift pass on the same cached output before reading raw traceback lines.` : `Provider follow-up failed (${args.reason}). Read raw traceback only if exact stack lines are still needed.`
+        note: shouldZoomFirst ? `${sanitizedReason[0].toUpperCase()}${sanitizedReason.slice(
+          1
+        )}. Use one deeper sift pass on the same cached output before reading raw traceback lines.` : `${sanitizedReason[0].toUpperCase()}${sanitizedReason.slice(
+          1
+        )}. Read raw traceback only if exact stack lines are still needed.`
       }
     }
   });
 }
-async function runSift(request) {
+async function runSiftCore(request, recorder) {
   const prepared = prepareInput(request.stdin, request.config.input);
   const heuristicInput = prepared.redacted;
   const heuristicInputTruncated = false;
@@ -6358,23 +7873,28 @@ async function runSift(request) {
   const provider = createProvider(request.config);
   const hasTestStatusSignal = request.policyName === "test-status" && hasRecognizableTestStatusSignal(heuristicInput);
   const testStatusAnalysis = hasTestStatusSignal ? analyzeTestStatus(heuristicInput) : null;
-  const testStatusDecision = hasTestStatusSignal && testStatusAnalysis ? buildTestStatusDiagnoseContract({
+  const useCompactTestStatusOutput = hasTestStatusSignal && testStatusAnalysis ? shouldUseCompactTestStatusBypass({
+    request,
+    analysis: testStatusAnalysis
+  }) : false;
+  const testStatusDecision = hasTestStatusSignal && testStatusAnalysis && !useCompactTestStatusOutput ? buildTestStatusDiagnoseContract({
     input: heuristicInput,
     analysis: testStatusAnalysis,
     resolvedTests: request.testStatusContext?.resolvedTests,
-    remainingTests: request.testStatusContext?.remainingTests
+    remainingTests: request.testStatusContext?.remainingTests,
+    remainingMode: request.testStatusContext?.remainingMode
   }) : null;
   const testStatusHeuristicOutput = testStatusDecision ? renderTestStatusDecisionOutput({
     request,
     decision: testStatusDecision
-  }) : null;
+  }) : useCompactTestStatusOutput ? applyHeuristicPolicy("test-status", heuristicInput, "standard") : null;
   if (request.config.runtime.verbose) {
     process.stderr.write(
       `${pc2.dim("sift")} provider=${provider.name} model=${request.config.provider.model} base_url=${request.config.provider.baseUrl} input_chars=${prepared.meta.finalLength}
 `
     );
   }
-  const heuristicOutput = request.policyName === "test-status" ? testStatusDecision?.contract.diagnosis_complete ? testStatusHeuristicOutput : null : applyHeuristicPolicy(request.policyName, heuristicInput, request.detail);
+  const heuristicOutput = request.policyName === "test-status" ? useCompactTestStatusOutput ? testStatusHeuristicOutput : testStatusDecision?.contract.diagnosis_complete ? testStatusHeuristicOutput : null : applyHeuristicPolicy(request.policyName, heuristicInput, request.detail);
   if (heuristicOutput) {
     if (request.config.runtime.verbose) {
       process.stderr.write(`${pc2.dim("sift")} heuristic=${request.policyName}
@@ -6428,6 +7948,7 @@ async function runSift(request) {
         finalOutput
       });
     }
+    recorder?.heuristic();
     return finalOutput;
   }
   if (testStatusDecision && testStatusAnalysis) {
@@ -6497,6 +8018,7 @@ async function runSift(request) {
         analysis: testStatusAnalysis,
         resolvedTests: request.testStatusContext?.resolvedTests,
         remainingTests: request.testStatusContext?.remainingTests,
+        remainingMode: request.testStatusContext?.remainingMode,
         providerBucketSupplements: supplement.bucket_supplements,
         contractOverrides: {
           diagnosis_complete: supplement.diagnosis_complete,
@@ -6527,6 +8049,7 @@ async function runSift(request) {
         providerInputChars: providerPrepared2.truncated.length,
         providerOutputChars: result.text.length
       });
+      recorder?.provider(result.usage);
       return finalOutput;
     } catch (error) {
       const reason = error instanceof Error ? error.message : "unknown_error";
@@ -6561,6 +8084,7 @@ async function runSift(request) {
         rawSliceChars: rawSlice.text.length,
         providerInputChars: providerPrepared2.truncated.length
       });
+      recorder?.fallback();
       return finalOutput;
     }
   }
@@ -6617,6 +8141,7 @@ async function runSift(request) {
     })) {
       throw new Error("Model output rejected by quality gate");
     }
+    recorder?.provider(result.usage);
     return withInsufficientHint({
       output: normalizeOutput(result.text, providerPrompt.responseMode),
       request,
@@ -6624,6 +8149,7 @@ async function runSift(request) {
     });
   } catch (error) {
     const reason = error instanceof Error ? error.message : "unknown_error";
+    recorder?.fallback();
     return withInsufficientHint({
       output: buildFallbackOutput({
         format: request.format,
@@ -6637,6 +8163,72 @@ async function runSift(request) {
     });
   }
 }
+async function runSift(request) {
+  return runSiftCore(request);
+}
+async function runSiftWithStats(request) {
+  if (request.dryRun) {
+    return {
+      output: await runSiftCore(request),
+      stats: null
+    };
+  }
+  const startedAt = Date.now();
+  let layer = "fallback";
+  let providerCalled = false;
+  let totalTokens = null;
+  const output = await runSiftCore(request, {
+    heuristic() {
+      layer = "heuristic";
+      providerCalled = false;
+      totalTokens = null;
+    },
+    provider(usage) {
+      layer = "provider";
+      providerCalled = true;
+      totalTokens = usage?.totalTokens ?? null;
+    },
+    fallback() {
+      layer = "fallback";
+      providerCalled = true;
+      totalTokens = null;
+    }
+  });
+  return {
+    output,
+    stats: {
+      layer,
+      providerCalled,
+      totalTokens,
+      durationMs: Date.now() - startedAt,
+      presetName: request.presetName
+    }
+  };
+}
+
+// src/core/stats.ts
+import pc3 from "picocolors";
+function formatDuration(durationMs) {
+  return durationMs >= 1e3 ? `${(durationMs / 1e3).toFixed(1)}s` : `${durationMs}ms`;
+}
+function formatStatsFooter(stats) {
+  const duration = formatDuration(stats.durationMs);
+  if (stats.layer === "heuristic") {
+    return `[sift: heuristic \u2022 LLM skipped \u2022 summary ${duration}]`;
+  }
+  if (stats.layer === "provider") {
+    const tokenSegment = stats.totalTokens !== null ? ` \u2022 ${stats.totalTokens} tokens` : "";
+    return `[sift: provider \u2022 LLM used${tokenSegment} \u2022 summary ${duration}]`;
+  }
+  return `[sift: fallback \u2022 provider failed \u2022 summary ${duration}]`;
+}
+function emitStatsFooter(args) {
+  if (args.quiet || !args.stats || !process.stderr.isTTY) {
+    return;
+  }
+  process.stderr.write(`${pc3.dim(formatStatsFooter(args.stats))}
+`);
+}
 
 // src/core/testStatusState.ts
 import fs5 from "fs";
@@ -6672,6 +8264,7 @@ var failureBucketTypeSchema = z3.enum([
   "import_dependency_failure",
   "collection_failure",
   "assertion_failure",
+  "golden_output_drift",
   "runtime_failure",
   "interrupted_run",
   "no_tests_collected",
@@ -6712,7 +8305,19 @@ var cachedPytestStateSchema = z3.object({
   failingNodeIds: z3.array(z3.string()),
   remainingNodeIds: z3.array(z3.string()).optional()
 }).optional();
-var cachedRunSchema = z3.object({
+var testRunnerSchema = z3.enum(["pytest", "vitest", "jest", "unknown"]);
+var cachedRunnerSubsetSchema = z3.object({
+  available: z3.boolean(),
+  strategy: z3.enum(["pytest-node-ids", "none"]),
+  baseArgv: z3.array(z3.string()).min(1).optional()
+});
+var cachedRunnerStateSchema = z3.object({
+  name: testRunnerSchema,
+  failingTargets: z3.array(z3.string()),
+  baselineCommand: cachedCommandSchema,
+  subset: cachedRunnerSubsetSchema
+});
+var cachedRunV1Schema = z3.object({
   version: z3.literal(1),
   timestamp: z3.string(),
   presetName: z3.literal("test-status"),
@@ -6730,6 +8335,25 @@ var cachedRunSchema = z3.object({
   analysis: cachedAnalysisSchema,
   pytest: cachedPytestStateSchema
 });
+var cachedRunV2Schema = z3.object({
+  version: z3.literal(2),
+  timestamp: z3.string(),
+  presetName: z3.literal("test-status"),
+  cwd: z3.string(),
+  commandKey: z3.string(),
+  commandPreview: z3.string(),
+  command: cachedCommandSchema,
+  detail: detailSchema,
+  exitCode: z3.number().int(),
+  rawOutput: z3.string(),
+  capture: z3.object({
+    originalChars: countSchema,
+    truncatedApplied: z3.boolean()
+  }),
+  analysis: cachedAnalysisSchema,
+  runner: cachedRunnerStateSchema
+});
+var cachedRunSchema = z3.discriminatedUnion("version", [cachedRunV1Schema, cachedRunV2Schema]);
 var MissingCachedTestStatusRunError = class extends Error {
   constructor() {
     super(
@@ -6778,6 +8402,37 @@ function isPytestExecutable(value) {
 function isPythonExecutable(value) {
   return basenameMatches(value, /^python(?:\d+(?:\.\d+)*)?(?:\.exe)?$/i);
 }
+function detectRunnerFromCommand(command) {
+  if (!command) {
+    return "unknown";
+  }
+  if (command.mode === "argv") {
+    const [first, second, third] = command.argv;
+    if (first && isPytestExecutable(first)) {
+      return "pytest";
+    }
+    if (first && isPythonExecutable(first) && second === "-m" && third === "pytest") {
+      return "pytest";
+    }
+    if (first && basenameMatches(first, /^vitest(?:\.exe)?$/i)) {
+      return "vitest";
+    }
+    if (first && basenameMatches(first, /^jest(?:\.exe)?$/i)) {
+      return "jest";
+    }
+    return "unknown";
+  }
+  if (/\bpython(?:\d+(?:\.\d+)*)?\s+-m\s+pytest\b|\bpytest\b/i.test(command.shellCommand)) {
+    return "pytest";
+  }
+  if (/\bvitest\b/i.test(command.shellCommand)) {
+    return "vitest";
+  }
+  if (/\bjest\b/i.test(command.shellCommand)) {
+    return "jest";
+  }
+  return "unknown";
+}
 var shortPytestOptionsWithValue = /* @__PURE__ */ new Set([
   "-c",
   "-k",
@@ -6872,26 +8527,52 @@ function buildCachedCommand(args) {
   }
   return void 0;
 }
-function buildFailingNodeIds(analysis) {
+function buildFailingTargets(analysis) {
+  const runner = analysis.runner;
   const values = [];
   for (const value of [...analysis.visibleErrorLabels, ...analysis.visibleFailedLabels]) {
-    if (value.length > 0 && !values.includes(value)) {
-      values.push(value);
+    const normalized = normalizeFailingTarget(value, runner);
+    if (normalized.length > 0 && !values.includes(normalized)) {
+      values.push(normalized);
     }
   }
   return values;
 }
-function buildCachedPytestState(args) {
+function buildCachedRunnerState(args) {
   const baseArgv = args.command?.mode === "argv" && isSubsetCapablePytestArgv(args.command.argv) ? [...args.command.argv] : void 0;
+  const runnerName = args.analysis.runner !== "unknown" ? args.analysis.runner : detectRunnerFromCommand(args.command);
   return {
-    subsetCapable: Boolean(baseArgv),
-    baseArgv,
-    failingNodeIds: buildFailingNodeIds(args.analysis),
-    remainingNodeIds: args.remainingNodeIds
+    name: runnerName,
+    failingTargets: buildFailingTargets(args.analysis),
+    baselineCommand: args.command,
+    subset: {
+      available: runnerName === "pytest" && Boolean(baseArgv),
+      strategy: runnerName === "pytest" && baseArgv ? "pytest-node-ids" : "none",
+      ...runnerName === "pytest" && baseArgv ? { baseArgv } : {}
+    }
   };
 }
+function normalizeCwd(value) {
+  return path7.resolve(value).replace(/\\/g, "/");
+}
+function buildTestStatusBaselineIdentity(args) {
+  const cwd = normalizeCwd(args.cwd);
+  const command = args.command ?? buildCachedCommand({
+    shellCommand: args.shellCommand,
+    command: args.shellCommand ? void 0 : args.commandPreview?.split(" ")
+  });
+  const mode = command?.mode ?? (args.shellCommand ? "shell" : "argv");
+  const normalizedCommand = command?.mode === "argv" ? command.argv.join("") : command?.mode === "shell" ? command.shellCommand.trim().replace(/\s+/g, " ") : (args.commandPreview ?? "").trim().replace(/\s+/g, " ");
+  return [cwd, args.runner, mode, normalizedCommand].join("");
+}
 function buildTestStatusCommandKey(args) {
-  return `${args.shellCommand ? "shell" : "argv"}:${args.commandPreview}`;
+  return buildTestStatusBaselineIdentity({
+    cwd: args.cwd ?? process.cwd(),
+    runner: args.runner ?? "unknown",
+    command: args.command,
+    commandPreview: args.commandPreview,
+    shellCommand: args.shellCommand
+  });
 }
 function snapshotTestStatusAnalysis(analysis) {
   return {
@@ -6917,13 +8598,22 @@ function createCachedTestStatusRun(args) {
     command: args.command,
     shellCommand: args.shellCommand
   });
+  const runnerName = args.analysis.runner !== "unknown" ? args.analysis.runner : detectRunnerFromCommand(command);
+  const commandPreview = args.commandPreview ?? args.shellCommand ?? (args.command ?? []).join(" ");
+  const commandKey = args.commandKey ?? buildTestStatusBaselineIdentity({
+    cwd: args.cwd,
+    runner: runnerName,
+    command,
+    commandPreview,
+    shellCommand: args.shellCommand
+  });
   return {
-    version: 1,
+    version: 2,
     timestamp: args.timestamp ?? (/* @__PURE__ */ new Date()).toISOString(),
     presetName: "test-status",
     cwd: args.cwd,
-    commandKey: args.commandKey,
-    commandPreview: args.commandPreview,
+    commandKey,
+    commandPreview,
     command,
     detail: args.detail,
     exitCode: args.exitCode,
@@ -6933,13 +8623,61 @@ function createCachedTestStatusRun(args) {
       truncatedApplied: args.truncatedApplied
     },
     analysis: snapshotTestStatusAnalysis(args.analysis),
-    pytest: buildCachedPytestState({
+    runner: buildCachedRunnerState({
       command,
-      analysis: args.analysis,
-      remainingNodeIds: args.remainingNodeIds
+      analysis: args.analysis
     })
   };
 }
+function migrateCachedTestStatusRun(state) {
+  if (state.version === 2) {
+    return state;
+  }
+  const runnerFromOutput = detectTestRunner(state.rawOutput);
+  const runner = runnerFromOutput !== "unknown" ? runnerFromOutput : detectRunnerFromCommand(state.command);
+  const storedCommand = state.command;
+  const fallbackBaseArgv = !storedCommand && state.pytest?.baseArgv ? {
+    mode: "argv",
+    argv: [...state.pytest.baseArgv]
+  } : void 0;
+  const baselineCommand = storedCommand ?? fallbackBaseArgv;
+  const commandPreview = state.commandPreview ?? (baselineCommand?.mode === "argv" ? baselineCommand.argv.join(" ") : baselineCommand?.mode === "shell" ? baselineCommand.shellCommand : "");
+  const commandKey = buildTestStatusBaselineIdentity({
+    cwd: state.cwd,
+    runner,
+    command: baselineCommand,
+    commandPreview
+  });
+  return {
+    version: 2,
+    timestamp: state.timestamp,
+    presetName: state.presetName,
+    cwd: state.cwd,
+    commandKey,
+    commandPreview,
+    command: state.command,
+    detail: state.detail,
+    exitCode: state.exitCode,
+    rawOutput: state.rawOutput,
+    capture: state.capture,
+    analysis: state.analysis,
+    runner: {
+      name: runner,
+      failingTargets: [...new Set((state.pytest?.failingNodeIds ?? []).map(
+        (target) => normalizeFailingTarget(target, runner)
+      ))],
+      baselineCommand,
+      subset: {
+        available: runner === "pytest" && Boolean(state.pytest?.baseArgv),
+        strategy: runner === "pytest" && state.pytest?.baseArgv ? "pytest-node-ids" : "none",
+        ...runner === "pytest" && state.pytest?.baseArgv ? {
+          baseArgv: [...state.pytest.baseArgv]
+        } : {}
+      }
+    },
+    ...fallbackBaseArgv ? { runnerMigrationFallbackUsed: true } : {}
+  };
+}
 function readCachedTestStatusRun(statePath = getDefaultTestStatusStatePath()) {
   let raw = "";
   try {
@@ -6951,7 +8689,7 @@ function readCachedTestStatusRun(statePath = getDefaultTestStatusStatePath()) {
     throw new InvalidCachedTestStatusRunError();
   }
   try {
-    return cachedRunSchema.parse(JSON.parse(raw));
+    return migrateCachedTestStatusRun(cachedRunSchema.parse(JSON.parse(raw)));
   } catch {
     throw new InvalidCachedTestStatusRunError();
   }
@@ -6980,15 +8718,7 @@ function getNextEscalationDetail(detail) {
   return null;
 }
 function buildTargetDelta(args) {
-  if (args.previous.presetName !== "test-status" || args.current.presetName !== "test-status" || args.previous.cwd !== args.current.cwd || args.previous.commandKey !== args.current.commandKey) {
-    return {
-      comparable: false,
-      resolved: [],
-      remaining: [],
-      introduced: []
-    };
-  }
-  if (!args.previous.pytest || !args.current.pytest) {
+  if (args.previous.presetName !== "test-status" || args.current.presetName !== "test-status" || args.previous.cwd !== args.current.cwd || args.previous.commandKey !== args.current.commandKey || args.previous.runner.name !== args.current.runner.name || args.previous.runner.name === "unknown") {
     return {
       comparable: false,
       resolved: [],
@@ -6996,8 +8726,8 @@ function buildTargetDelta(args) {
       introduced: []
     };
   }
-  const previousTargets = args.previous.pytest.failingNodeIds;
-  const currentTargets = args.current.pytest.failingNodeIds;
+  const previousTargets = args.previous.runner.failingTargets;
+  const currentTargets = args.current.runner.failingTargets;
   const currentTargetSet = new Set(currentTargets);
   const previousTargetSet = new Set(previousTargets);
   return {
@@ -7010,8 +8740,11 @@ function buildTargetDelta(args) {
 function diffTestStatusTargets(args) {
   return buildTargetDelta(args);
 }
+function isRemainingSubsetAvailable(state) {
+  return state.runner.name === "pytest" && state.runner.subset.available;
+}
 function getRemainingPytestNodeIds(state) {
-  return state.pytest?.remainingNodeIds ?? state.pytest?.failingNodeIds ?? [];
+  return state.runner.name === "pytest" ? state.runner.failingTargets : [];
 }
 function diffTestStatusRuns(args) {
   const targetDelta = buildTargetDelta(args);
@@ -7022,21 +8755,45 @@ function diffTestStatusRuns(args) {
     args.current.analysis.buckets.map((bucket) => [buildBucketSignature(bucket), bucket])
   );
   const lines = [];
-  if (targetDelta.resolved.length > 0) {
-    lines.push(
-      `- Resolved: ${formatCount3(targetDelta.resolved.length, "failing test/module", "failing tests/modules")} no longer appear${appendPreview(targetDelta.resolved)}.`
-    );
-  }
-  if (targetDelta.remaining.length > 0) {
-    lines.push(
-      `- Remaining: ${formatCount3(targetDelta.remaining.length, "failing test/module", "failing tests/modules")} still appear${appendPreview(targetDelta.remaining)}.`
-    );
-  }
-  if (targetDelta.introduced.length > 0) {
+  const resolvedSummary = buildTestTargetSummary(targetDelta.resolved);
+  const remainingSummary = buildTestTargetSummary(targetDelta.remaining);
+  const introducedSummary = buildTestTargetSummary(targetDelta.introduced);
+  const pushTargetLine = (args2) => {
+    if (args2.summary.count === 0) {
+      return;
+    }
+    const summaryText = describeTargetSummary(args2.summary);
+    if (summaryText) {
+      lines.push(
+        `- ${args2.kind}: ${formatCount3(args2.summary.count, args2.countLabel, `${args2.countLabel}s`)} ${args2.verb} ${summaryText}.`
+      );
+      return;
+    }
     lines.push(
-      `- New: ${formatCount3(targetDelta.introduced.length, "failing test/module", "failing tests/modules")} appeared${appendPreview(targetDelta.introduced)}.`
+      `- ${args2.kind}: ${formatCount3(args2.summary.count, args2.countLabel, `${args2.countLabel}s`)} ${args2.verb}${appendPreview(args2.fallbackValues)}.`
     );
-  }
+  };
+  pushTargetLine({
+    kind: "Resolved",
+    summary: resolvedSummary,
+    countLabel: "failing target",
+    fallbackValues: targetDelta.resolved,
+    verb: "no longer appear"
+  });
+  pushTargetLine({
+    kind: "Remaining",
+    summary: remainingSummary,
+    countLabel: "failing target",
+    fallbackValues: targetDelta.remaining,
+    verb: "still appear"
+  });
+  pushTargetLine({
+    kind: "New",
+    summary: introducedSummary,
+    countLabel: "failing target",
+    fallbackValues: targetDelta.introduced,
+    verb: "appeared"
+  });
   for (const bucket of args.current.analysis.buckets) {
     const signature = buildBucketSignature(bucket);
     const previous = previousBuckets.get(signature);
@@ -7064,19 +8821,19 @@ function diffTestStatusRuns(args) {
     }
   }
   return {
-    lines: lines.slice(0, 4),
-    remainingNodeIds: targetDelta.comparable ? targetDelta.remaining : void 0
+    lines: lines.slice(0, 4)
   };
 }
 function getCachedRerunCommand(state) {
-  if (state.command?.mode === "argv") {
+  const baselineCommand = state.runner.baselineCommand ?? state.command;
+  if (baselineCommand?.mode === "argv") {
     return {
-      command: [...state.command.argv]
+      command: [...baselineCommand.argv]
     };
   }
-  if (state.command?.mode === "shell") {
+  if (baselineCommand?.mode === "shell") {
     return {
-      shellCommand: state.command.shellCommand
+      shellCommand: baselineCommand.shellCommand
     };
   }
   throw new Error(
@@ -7084,13 +8841,13 @@ function getCachedRerunCommand(state) {
   );
 }
 function getRemainingPytestRerunCommand(state) {
-  if (!state.pytest?.subsetCapable || !state.pytest.baseArgv) {
+  if (!isRemainingSubsetAvailable(state) || !state.runner.subset.baseArgv) {
     throw new Error(
       "Cached test-status run cannot use `sift rerun --remaining`. Automatic remaining-subset reruns currently support only argv-mode `pytest ...` or `python -m pytest ...` commands. Run a narrowed command manually with `sift exec --preset test-status -- <narrowed pytest command>`."
     );
   }
   const remainingNodeIds = getRemainingPytestNodeIds(state);
-  return [...state.pytest.baseArgv, ...remainingNodeIds];
+  return [...state.runner.subset.baseArgv, ...remainingNodeIds];
 }
 
 // src/core/escalate.ts
@@ -7114,7 +8871,7 @@ async function runEscalate(request) {
   const detail = resolveEscalationDetail(state, request.detail, request.showRaw);
   if (request.verbose) {
     process.stderr.write(
-      `${pc3.dim("sift")} escalate detail=${detail} cached_detail=${state.detail} command=${state.commandPreview}
+      `${pc4.dim("sift")} escalate detail=${detail} cached_detail=${state.detail} command=${state.commandPreview}
 `
     );
   }
@@ -7124,7 +8881,7 @@ async function runEscalate(request) {
       process.stderr.write("\n");
     }
   }
-  let output = await runSift({
+  const result = await runSiftWithStats({
     question: request.question,
     format: request.format,
     goal: request.goal,
@@ -7138,9 +8895,11 @@ async function runEscalate(request) {
     outputContract: request.outputContract,
     fallbackJson: request.fallbackJson,
     testStatusContext: {
-      remainingSubsetAvailable: Boolean(state.pytest?.subsetCapable) && (state.pytest?.failingNodeIds.length ?? 0) > 0
+      remainingSubsetAvailable: isRemainingSubsetAvailable(state) && state.runner.failingTargets.length > 0,
+      remainingMode: "none"
     }
   });
+  let output = result.output;
   if (isInsufficientSignalOutput(output)) {
     output = buildInsufficientSignalOutput({
       presetName: "test-status",
@@ -7151,6 +8910,10 @@ async function runEscalate(request) {
   }
   process.stdout.write(`${output}
 `);
+  emitStatsFooter({
+    stats: result.stats,
+    quiet: Boolean(request.quiet)
+  });
   try {
     writeCachedTestStatusRun({
       ...state,
@@ -7159,7 +8922,7 @@ async function runEscalate(request) {
   } catch (error) {
     if (request.verbose) {
       const reason = error instanceof Error ? error.message : "unknown_error";
-      process.stderr.write(`${pc3.dim("sift")} cache_write=failed reason=${reason}
+      process.stderr.write(`${pc4.dim("sift")} cache_write=failed reason=${reason}
 `);
     }
   }
@@ -7169,7 +8932,7 @@ async function runEscalate(request) {
 // src/core/exec.ts
 import { spawn } from "child_process";
 import { constants as osConstants } from "os";
-import pc4 from "picocolors";
+import pc5 from "picocolors";
 
 // src/core/gate.ts
 var FAIL_ON_SUPPORTED_PRESETS = /* @__PURE__ */ new Set(["infra-risk", "audit-critical"]);
@@ -7347,8 +9110,9 @@ async function runTestStatusWatch(request, cycles) {
       testStatusContext: {
         ...request.testStatusContext,
         resolvedTests: targetDelta?.resolved ?? request.testStatusContext?.resolvedTests,
-        remainingTests: targetDelta?.remaining ?? currentRun.pytest?.failingNodeIds ?? request.testStatusContext?.remainingTests,
-        remainingSubsetAvailable: request.testStatusContext?.remainingSubsetAvailable ?? (Boolean(currentRun.pytest?.subsetCapable) && (currentRun.pytest?.failingNodeIds.length ?? 0) > 0)
+        remainingTests: targetDelta?.remaining ?? currentRun.runner.failingTargets ?? request.testStatusContext?.remainingTests,
+        remainingSubsetAvailable: request.testStatusContext?.remainingSubsetAvailable ?? (isRemainingSubsetAvailable(currentRun) && currentRun.runner.failingTargets.length > 0),
+        remainingMode: request.testStatusContext?.remainingMode ?? "none"
       }
     });
     if (request.goal === "diagnose" && request.format === "json") {
@@ -7495,11 +9259,13 @@ async function runExec(request) {
   const shellPath = process.env.SHELL || "/bin/bash";
   const commandPreview = buildCommandPreview(request);
   const commandCwd = request.cwd ?? process.cwd();
-  const shouldCacheTestStatusBase = request.presetName === "test-status" && !request.skipCacheWrite;
-  const previousCachedRun = shouldCacheTestStatusBase ? tryReadCachedTestStatusRun() : null;
+  const isTestStatusPreset = request.presetName === "test-status";
+  const readCachedBaseline = isTestStatusPreset && (request.readCachedBaseline ?? true);
+  const writeCachedBaselineRequested = isTestStatusPreset && (request.writeCachedBaseline ?? (request.skipCacheWrite ? false : true));
+  const previousCachedRun = readCachedBaseline ? tryReadCachedTestStatusRun() : null;
   if (request.config.runtime.verbose) {
     process.stderr.write(
-      `${pc4.dim("sift")} exec mode=${hasShellCommand ? "shell" : "argv"} command=${commandPreview}
+      `${pc5.dim("sift")} exec mode=${hasShellCommand ? "shell" : "argv"} command=${commandPreview}
 `
     );
   }
@@ -7528,7 +9294,7 @@ async function runExec(request) {
     }
     bypassed = true;
     if (request.config.runtime.verbose) {
-      process.stderr.write(`${pc4.dim("sift")} bypass=interactive-prompt
+      process.stderr.write(`${pc5.dim("sift")} bypass=interactive-prompt
 `);
     }
     process.stderr.write(capture.render());
@@ -7554,18 +9320,20 @@ async function runExec(request) {
   const capturedOutput = capture.render();
   const autoWatchDetected = !request.watch && looksLikeWatchStream(capturedOutput);
   const useWatchFlow = Boolean(request.watch) || autoWatchDetected;
-  const shouldCacheTestStatus = shouldCacheTestStatusBase && !useWatchFlow;
+  const shouldBuildTestStatusState = isTestStatusPreset && !useWatchFlow;
+  const shouldWriteCachedBaseline = writeCachedBaselineRequested && !useWatchFlow;
   if (request.config.runtime.verbose) {
     process.stderr.write(
-      `${pc4.dim("sift")} child_exit=${exitCode} captured_chars=${capture.getTotalChars()} capture_truncated=${capture.wasTruncated()}
+      `${pc5.dim("sift")} child_exit=${exitCode} captured_chars=${capture.getTotalChars()} capture_truncated=${capture.wasTruncated()}
 `
     );
   }
   if (autoWatchDetected) {
-    process.stderr.write(`${pc4.dim("sift")} auto-watch=detected
+    process.stderr.write(`${pc5.dim("sift")} auto-watch=detected
 `);
   }
   if (!bypassed) {
+    const reductionStartedAt = Date.now();
     if (request.showRaw && capturedOutput.length > 0) {
       process.stderr.write(capturedOutput);
       if (!capturedOutput.endsWith("\n")) {
@@ -7580,12 +9348,22 @@ async function runExec(request) {
     if (execSuccessShortcut && !request.dryRun) {
       if (request.config.runtime.verbose) {
         process.stderr.write(
-          `${pc4.dim("sift")} exec_shortcut=${request.presetName}
+          `${pc5.dim("sift")} exec_shortcut=${request.presetName}
 `
         );
       }
       process.stdout.write(`${execSuccessShortcut}
 `);
+      emitStatsFooter({
+        stats: {
+          layer: "heuristic",
+          providerCalled: false,
+          totalTokens: null,
+          durationMs: Date.now() - reductionStartedAt,
+          presetName: request.presetName
+        },
+        quiet: Boolean(request.quiet)
+      });
       return exitCode;
     }
     if (useWatchFlow) {
@@ -7598,17 +9376,27 @@ async function runExec(request) {
           presetName: request.presetName,
           originalLength: capture.getTotalChars(),
           truncatedApplied: capture.wasTruncated(),
-          exitCode
+          exitCode,
+          recognizedRunner: detectTestRunner(capturedOutput)
         });
       }
       process.stdout.write(`${output2}
 `);
       return exitCode;
     }
-    const analysis = shouldCacheTestStatus ? analyzeTestStatus(capturedOutput) : null;
-    let currentCachedRun = shouldCacheTestStatus && analysis ? createCachedTestStatusRun({
+    const analysis = shouldBuildTestStatusState ? analyzeTestStatus(capturedOutput) : null;
+    let currentCachedRun = shouldBuildTestStatusState && analysis ? createCachedTestStatusRun({
       cwd: commandCwd,
       commandKey: buildTestStatusCommandKey({
+        cwd: commandCwd,
+        runner: analysis.runner,
+        command: Array.isArray(request.command) && request.command.length > 0 ? {
+          mode: "argv",
+          argv: [...request.command]
+        } : request.shellCommand ? {
+          mode: "shell",
+          shellCommand: request.shellCommand
+        } : void 0,
         commandPreview,
         shellCommand: request.shellCommand
       }),
@@ -7622,36 +9410,39 @@ async function runExec(request) {
       truncatedApplied: capture.wasTruncated(),
       analysis
     }) : null;
-    const targetDelta = request.diff && !request.dryRun && previousCachedRun && currentCachedRun ? diffTestStatusTargets({
+    const targetDelta = (request.diff || request.testStatusContext?.remainingMode === "subset_rerun" || request.testStatusContext?.remainingMode === "full_rerun_diff") && !request.dryRun && previousCachedRun && currentCachedRun ? diffTestStatusTargets({
       previous: previousCachedRun,
       current: currentCachedRun
     }) : null;
-    let output = await runSift({
+    const result = await runSiftWithStats({
       ...request,
       stdin: capturedOutput,
-      analysisContext: request.skipCacheWrite && request.presetName === "test-status" ? [
+      analysisContext: request.testStatusContext?.remainingMode && request.testStatusContext.remainingMode !== "none" && request.presetName === "test-status" ? [
         request.analysisContext,
         "Zoom context:",
         "- This pass is remaining-only.",
         "- The full-suite truth already exists from the cached full run.",
         "- Do not reintroduce resolved tests into the diagnosis."
       ].filter((value) => Boolean(value)).join("\n") : request.analysisContext,
-      testStatusContext: shouldCacheTestStatus && analysis ? {
+      testStatusContext: shouldBuildTestStatusState && analysis ? {
         ...request.testStatusContext,
         resolvedTests: targetDelta?.resolved ?? request.testStatusContext?.resolvedTests,
-        remainingTests: targetDelta?.remaining ?? currentCachedRun?.pytest?.failingNodeIds ?? request.testStatusContext?.remainingTests,
+        remainingTests: targetDelta?.remaining ?? currentCachedRun?.runner.failingTargets ?? request.testStatusContext?.remainingTests,
         remainingSubsetAvailable: request.testStatusContext?.remainingSubsetAvailable ?? Boolean(
-          currentCachedRun?.pytest?.subsetCapable && (targetDelta?.remaining ?? currentCachedRun?.pytest?.failingNodeIds ?? []).length > 0
-        )
+          currentCachedRun && isRemainingSubsetAvailable(currentCachedRun) && (targetDelta?.remaining ?? currentCachedRun?.runner.failingTargets ?? []).length > 0
+        ),
+        remainingMode: request.testStatusContext?.remainingMode ?? "none"
       } : request.testStatusContext
     });
-    if (shouldCacheTestStatus) {
+    let output = result.output;
+    if (shouldBuildTestStatusState) {
       if (isInsufficientSignalOutput(output)) {
         output = buildInsufficientSignalOutput({
           presetName: request.presetName,
           originalLength: capture.getTotalChars(),
           truncatedApplied: capture.wasTruncated(),
-          exitCode
+          exitCode,
+          recognizedRunner: detectTestRunner(capturedOutput)
         });
       }
       if (request.diff && !request.dryRun && previousCachedRun && currentCachedRun) {
@@ -7659,32 +9450,18 @@ async function runExec(request) {
           previous: previousCachedRun,
           current: currentCachedRun
         });
-        currentCachedRun = createCachedTestStatusRun({
-          cwd: commandCwd,
-          commandKey: currentCachedRun.commandKey,
-          commandPreview,
-          command: request.command,
-          shellCommand: request.shellCommand,
-          detail: request.detail ?? "standard",
-          exitCode,
-          rawOutput: capturedOutput,
-          originalChars: capture.getTotalChars(),
-          truncatedApplied: capture.wasTruncated(),
-          analysis,
-          remainingNodeIds: delta.remainingNodeIds
-        });
         if (delta.lines.length > 0) {
           output = `${delta.lines.join("\n")}
 ${output}`;
         }
       }
-      if (currentCachedRun) {
+      if (currentCachedRun && shouldWriteCachedBaseline) {
         try {
           writeCachedTestStatusRun(currentCachedRun);
         } catch (error) {
           if (request.config.runtime.verbose) {
             const reason = error instanceof Error ? error.message : "unknown_error";
-            process.stderr.write(`${pc4.dim("sift")} cache_write=failed reason=${reason}
+            process.stderr.write(`${pc5.dim("sift")} cache_write=failed reason=${reason}
 `);
           }
         }
@@ -7694,11 +9471,16 @@ ${output}`;
         presetName: request.presetName,
         originalLength: capture.getTotalChars(),
         truncatedApplied: capture.wasTruncated(),
-        exitCode
+        exitCode,
+        recognizedRunner: detectTestRunner(capturedOutput)
       });
     }
     process.stdout.write(`${output}
 `);
+    emitStatsFooter({
+      stats: result.stats,
+      quiet: Boolean(request.quiet)
+    });
     if (request.failOn && !request.dryRun && exitCode === 0 && supportsFailOnPreset(request.presetName) && evaluateGate({
       presetName: request.presetName,
       output
@@ -7720,25 +9502,60 @@ async function runRerun(request) {
       diff: true,
       presetName: "test-status",
       detail: "standard",
-      showRaw: false
+      showRaw: false,
+      readCachedBaseline: true,
+      writeCachedBaseline: true,
+      testStatusContext: {
+        ...request.testStatusContext,
+        remainingMode: "none"
+      }
     });
   }
-  const remainingNodeIds = getRemainingPytestNodeIds(state);
-  if (remainingNodeIds.length === 0) {
-    process.stdout.write("No remaining failing pytest targets.\n");
-    return 0;
+  if (state.runner.name === "pytest") {
+    const remainingNodeIds = getRemainingPytestNodeIds(state);
+    if (remainingNodeIds.length === 0) {
+      process.stdout.write("No remaining failing pytest targets.\n");
+      return 0;
+    }
+    return runExec({
+      ...request,
+      command: getRemainingPytestRerunCommand(state),
+      cwd: state.cwd,
+      diff: false,
+      presetName: "test-status",
+      readCachedBaseline: true,
+      writeCachedBaseline: false,
+      testStatusContext: {
+        ...request.testStatusContext,
+        remainingSubsetAvailable: isRemainingSubsetAvailable(state),
+        remainingMode: "subset_rerun"
+      }
+    });
   }
-  return runExec({
-    ...request,
-    command: getRemainingPytestRerunCommand(state),
-    cwd: state.cwd,
-    diff: false,
-    presetName: "test-status",
-    skipCacheWrite: true,
-    testStatusContext: {
-      remainingSubsetAvailable: true
+  if (state.runner.name === "vitest" || state.runner.name === "jest") {
+    if (!state.runner.baselineCommand || state.runnerMigrationFallbackUsed) {
+      throw new Error(
+        "Cached test-status run cannot use `sift rerun --remaining` yet because the original full command is unavailable from cache. Refresh the baseline with `sift exec --preset test-status -- <test command>` and retry."
+      );
     }
-  });
+    return runExec({
+      ...request,
+      ...getCachedRerunCommand(state),
+      cwd: state.cwd,
+      diff: false,
+      presetName: "test-status",
+      readCachedBaseline: true,
+      writeCachedBaseline: false,
+      testStatusContext: {
+        ...request.testStatusContext,
+        remainingSubsetAvailable: false,
+        remainingMode: "full_rerun_diff"
+      }
+    });
+  }
+  throw new Error(
+    "Cached test-status run cannot use `sift rerun --remaining` for this runner. Refresh with `sift exec --preset test-status -- <test command>` or rerun a narrowed command manually."
+  );
 }
 
 // src/core/stdin.ts
@@ -7788,6 +9605,7 @@ var defaultCliDeps = {
   evaluateGate,
   readStdin,
   runSift,
+  runSiftWithStats,
   runWatch,
   looksLikeWatchStream,
   getPreset
@@ -7896,7 +9714,7 @@ function applySharedOptions(command) {
   ).option(
     "--fail-on",
     "Fail with exit code 1 when a supported built-in preset produces a blocking result"
-  ).option("--config <path>", "Path to config file").option("--verbose", "Enable verbose stderr logging");
+  ).option("--config <path>", "Path to config file").option("--quiet", "Suppress the stats footer on stderr").option("--verbose", "Enable verbose stderr logging");
 }
 function normalizeDetail(value) {
   if (value === void 0 || value === null || value === "") {
@@ -7995,21 +9813,25 @@ function createCliApp(args = {}) {
         stderr.write("\n");
       }
     }
-    const output = deps.looksLikeWatchStream(stdin) ? await deps.runWatch({
-      question: input.question,
-      format: input.format,
-      goal: input.goal,
-      stdin,
-      config,
-      dryRun: Boolean(input.options.dryRun),
-      showRaw: Boolean(input.options.showRaw),
-      includeTestIds: Boolean(input.options.includeTestIds),
-      detail: input.detail,
-      presetName: input.presetName,
-      policyName: input.policyName,
-      outputContract: input.outputContract,
-      fallbackJson: input.fallbackJson
-    }) : await deps.runSift({
+    const isWatchStream = deps.looksLikeWatchStream(stdin);
+    const result = isWatchStream ? {
+      output: await deps.runWatch({
+        question: input.question,
+        format: input.format,
+        goal: input.goal,
+        stdin,
+        config,
+        dryRun: Boolean(input.options.dryRun),
+        showRaw: Boolean(input.options.showRaw),
+        includeTestIds: Boolean(input.options.includeTestIds),
+        detail: input.detail,
+        presetName: input.presetName,
+        policyName: input.policyName,
+        outputContract: input.outputContract,
+        fallbackJson: input.fallbackJson
+      }),
+      stats: null
+    } : await deps.runSiftWithStats({
       question: input.question,
       format: input.format,
       goal: input.goal,
@@ -8024,8 +9846,13 @@ function createCliApp(args = {}) {
       outputContract: input.outputContract,
       fallbackJson: input.fallbackJson
     });
+    const output = result.output;
     stdout.write(`${output}
 `);
+    emitStatsFooter({
+      stats: result.stats,
+      quiet: Boolean(input.options.quiet)
+    });
     if (Boolean(input.options.failOn) && !Boolean(input.options.dryRun) && input.presetName && deps.evaluateGate({
       presetName: input.presetName,
       output
@@ -8055,6 +9882,7 @@ function createCliApp(args = {}) {
       dryRun: Boolean(input.options.dryRun),
       diff: input.diff,
       failOn: Boolean(input.options.failOn),
+      quiet: Boolean(input.options.quiet),
       showRaw: Boolean(input.options.showRaw),
       includeTestIds: Boolean(input.options.includeTestIds),
       watch: Boolean(input.options.watch),
@@ -8234,13 +10062,20 @@ function createCliApp(args = {}) {
       outputContract: preset.outputContract,
       fallbackJson: preset.fallbackJson,
       detail: normalizeEscalateDetail(options.detail),
+      quiet: Boolean(options.quiet),
       showRaw: Boolean(options.showRaw),
       verbose: Boolean(options.verbose)
     });
   });
   applySharedOptions(
-    cli.command("rerun", "Rerun the cached test-status command or only the remaining pytest subset")
-  ).usage("rerun [options]").example("rerun").example("rerun --remaining").example("rerun --remaining --detail focused").example("rerun --remaining --detail verbose --show-raw").option("--remaining", "Rerun only the remaining failing pytest node IDs from the cached full run").action(async (options) => {
+    cli.command(
+      "rerun",
+      "Rerun the cached test-status command or focus on what still fails from the cached baseline"
+    )
+  ).usage("rerun [options]").example("rerun").example("rerun --remaining").example("rerun --remaining --detail focused").example("rerun --remaining --detail verbose --show-raw").option(
+    "--remaining",
+    "Focus on what still fails from the cached baseline; narrows automatically for pytest and diffs a full rerun for vitest/jest"
+  ).action(async (options) => {
     const remaining = Boolean(options.remaining);
     if (!remaining && Boolean(options.showRaw)) {
       throw new Error("--show-raw is supported only with `sift rerun --remaining`.");