@bilalimamoglu/sift 0.3.3 → 0.4.1

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.",
@@ -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","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[]}';
+
+// 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,7 @@ 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",
@@ -2499,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);
@@ -2571,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";
   }
@@ -2723,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,
@@ -2915,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";
   }
@@ -2949,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));
   }
@@ -3023,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";
   }
@@ -3100,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;
   }
@@ -3154,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;
@@ -3174,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) {
@@ -3281,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 {
@@ -3409,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;
@@ -3490,6 +3729,13 @@ function resolveBucketFixHint(args) {
   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";
   }
@@ -3499,6 +3745,18 @@ function deriveBucketSuspectKind(args) {
   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";
   }
@@ -3506,11 +3764,13 @@ function deriveBucketSuspectKind(args) {
     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") {
-    const file = args.readTarget?.file ?? "";
-    if (file.startsWith("src/")) {
+    if (hasConfigCandidate) {
+      return "config";
+    }
+    if (hasAppCandidate) {
       return "app_code";
     }
-    if (file.startsWith("test/") || file.startsWith("tests/")) {
+    if (hasTestCandidate) {
       return "test";
     }
     return "unknown";
@@ -3563,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];
@@ -3590,13 +3854,19 @@ function renderStandard(args) {
     }
   }
   lines.push(buildDecisionLine(args.contract));
-  lines.push(`- Likely owner: ${formatSuspectKindLabel(args.contract.primary_suspect_kind)}`);
+  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(
@@ -3616,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(
@@ -3665,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,
@@ -3713,9 +3989,9 @@ function buildTestStatusDiagnoseContract(args) {
       mini_diff: extractMiniDiff(args.input, bucket)
     };
   });
-  const resolvedTests = unique(args.resolvedTests ?? []);
-  const remainingTests = unique(
-    args.remainingTests ?? unique([...args.analysis.visibleErrorLabels, ...args.analysis.visibleFailedLabels])
+  const resolvedTests = unique2(args.resolvedTests ?? []);
+  const remainingTests = unique2(
+    args.remainingTests ?? unique2([...args.analysis.visibleErrorLabels, ...args.analysis.visibleFailedLabels])
   );
   const primarySuspectKind = derivePrimarySuspectKind({
     mainBuckets,
@@ -3765,6 +4041,7 @@ 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.",
@@ -3795,7 +4072,8 @@ function buildTestStatusDiagnoseContract(args) {
         readTargets,
         hasSecondaryVisibleBucket: mainBuckets.some(
           (bucket) => bucket.secondary_visible_despite_blocker
-        )
+        ),
+        remainingMode: args.contractOverrides?.remaining_mode ?? baseContract.remaining_mode
       })
     }
   };
@@ -3860,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}`,
@@ -4427,7 +4706,7 @@ function detectTestRunner(input) {
   if (/^\s*Test Suites:\s+\d+\s+failed,\s+\d+\s+passed(?:,\s+\d+\s+total)?/m.test(input) || /^\s*Tests:\s+\d+\s+failed,\s+\d+\s+passed(?:,\s+\d+\s+total)?/m.test(input)) {
     return "jest";
   }
-  if (/\bpytest\b/i.test(input) || /^\s*=+.*\b\d+\s+failed\b.*=+\s*$/m.test(input) || /\bcollected\s+\d+\s+items\b/i.test(input)) {
+  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";
@@ -5632,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";
   }
@@ -6888,7 +7170,7 @@ function prepareInput(raw, config) {
 function escapeRegExp2(value) {
   return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
-function unique2(values) {
+function unique3(values) {
   return [...new Set(values)];
 }
 var genericBucketSearchTerms = /* @__PURE__ */ new Set([
@@ -6989,7 +7271,7 @@ function extractBucketSearchTerms(args) {
     ...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 = unique2(
+  const prioritized = unique3(
     sources.flatMap((value) => collectCandidateSearchTerms(value)).filter(isHighSignalSearchTerm)
   ).sort((left, right) => {
     const delta = scoreSearchTerm(right) - scoreSearchTerm(left);
@@ -7001,7 +7283,7 @@ function extractBucketSearchTerms(args) {
   if (prioritized.length > 0) {
     return prioritized.slice(0, 6);
   }
-  const fallbackTerms = unique2(
+  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);
@@ -7039,7 +7321,7 @@ function buildLineWindows(args) {
   return [...selected].sort((left, right) => left - right).map((index) => args.lines[index]);
 }
 function buildPriorityLineGroup(args) {
-  return unique2([
+  return unique3([
     ...args.indexes.map((index) => args.lines[index]).filter(Boolean),
     ...buildLineWindows(args)
   ]);
@@ -7048,7 +7330,7 @@ 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();
   }
@@ -7199,7 +7481,7 @@ function buildTestStatusRawSlice(args) {
     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),
       ...buildPriorityLineGroup({
         lines,
@@ -7242,7 +7524,7 @@ function buildTestStatusRawSlice(args) {
     return [
       buildPriorityLineGroup({
         lines,
-        indexes: unique2([...searchHintIndexes, ...fileIndexes]),
+        indexes: unique3([...searchHintIndexes, ...fileIndexes]),
         radius,
         maxLines
       })
@@ -7261,7 +7543,7 @@ function buildTestStatusRawSlice(args) {
   const selected = collapseSelectedLineGroups({
     groups: [
       ...targetGroups,
-      unique2([
+      unique3([
         ...summaryIndexes.map((index) => lines[index]).filter(Boolean),
         ...buildLineWindows({
           lines,
@@ -7312,7 +7594,7 @@ function buildGenericRawSlice(args) {
 
 // src/core/run.ts
 var RETRY_DELAY_MS = 300;
-var PROVIDER_PENDING_NOTICE_DELAY_MS = 150;
+var PENDING_NOTICE_DELAY_MS = 150;
 function estimateTokenCount(text) {
   return Math.max(1, Math.ceil(text.length / 4));
 }
@@ -7393,17 +7675,16 @@ function buildDryRunOutput(args) {
 async function delay(ms) {
   await new Promise((resolve) => setTimeout(resolve, ms));
 }
-function startProviderPendingNotice() {
-  if (!process.stderr.isTTY) {
+function startPendingNotice(message, enabled) {
+  if (!enabled) {
     return () => {
     };
   }
-  const message = "sift waiting for provider...";
   let shown = false;
   const timer = setTimeout(() => {
     shown = true;
     process.stderr.write(`${message}\r`);
-  }, PROVIDER_PENDING_NOTICE_DELAY_MS);
+  }, PENDING_NOTICE_DELAY_MS);
   return () => {
     clearTimeout(timer);
     if (!shown) {
@@ -7433,7 +7714,10 @@ async function generateWithRetry(args) {
     responseMode: args.responseMode,
     jsonResponseFormat: args.request.config.provider.jsonResponseFormat
   });
-  const stopPendingNotice = startProviderPendingNotice();
+  const stopPendingNotice = startPendingNotice(
+    "sift waiting for provider...",
+    Boolean(process.stderr.isTTY)
+  );
   try {
     try {
       return await generate();
@@ -7459,6 +7743,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(
@@ -7480,6 +7792,7 @@ 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)
   );
@@ -7492,6 +7805,7 @@ function buildTestStatusProviderFailureDecision(args) {
       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,
@@ -7507,7 +7821,9 @@ function buildTestStatusProviderFailureDecision(args) {
         next_best_action: {
           code: "read_source_for_bucket",
           bucket_index: args.baseDecision.contract.dominant_blocker_bucket_index ?? concreteReadTarget.bucket_index,
-          note: `Provider follow-up failed (${args.reason}). The heuristic anchor is concrete enough to inspect source for the current bucket before reading raw traceback.`
+          note: `${sanitizedReason[0].toUpperCase()}${sanitizedReason.slice(
+            1
+          )}. The heuristic anchor is concrete enough to inspect source for the current bucket before reading raw traceback.`
         }
       }
     });
@@ -7518,6 +7834,7 @@ function buildTestStatusProviderFailureDecision(args) {
     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,
@@ -7533,7 +7850,11 @@ 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.`
       }
     }
   });
@@ -7554,23 +7875,28 @@ async function runSiftCore(request, recorder) {
   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}
@@ -7694,6 +8020,7 @@ async function runSiftCore(request, recorder) {
         analysis: testStatusAnalysis,
         resolvedTests: request.testStatusContext?.resolvedTests,
         remainingTests: request.testStatusContext?.remainingTests,
+        remainingMode: request.testStatusContext?.remainingMode,
         providerBucketSupplements: supplement.bucket_supplements,
         contractOverrides: {
           diagnosis_complete: supplement.diagnosis_complete,
@@ -7939,6 +8266,7 @@ var failureBucketTypeSchema = z3.enum([
   "import_dependency_failure",
   "collection_failure",
   "assertion_failure",
+  "golden_output_drift",
   "runtime_failure",
   "interrupted_run",
   "no_tests_collected",
@@ -7979,7 +8307,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"),
@@ -7997,6 +8337,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(
@@ -8045,6 +8404,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",
@@ -8139,26 +8529,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 {
@@ -8184,13 +8600,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,
@@ -8200,13 +8625,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 {
@@ -8218,7 +8691,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();
   }
@@ -8247,7 +8720,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) {
+  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: [],
@@ -8255,16 +8728,8 @@ function buildTargetDelta(args) {
       introduced: []
     };
   }
-  if (!args.previous.pytest || !args.current.pytest) {
-    return {
-      comparable: false,
-      resolved: [],
-      remaining: [],
-      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 {
@@ -8277,8 +8742,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);
@@ -8289,21 +8757,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);
@@ -8331,19 +8823,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(
@@ -8351,13 +8843,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
@@ -8405,7 +8897,8 @@ 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;
@@ -8619,8 +9112,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") {
@@ -8767,8 +9261,10 @@ 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(
       `${pc5.dim("sift")} exec mode=${hasShellCommand ? "shell" : "argv"} command=${commandPreview}
@@ -8787,6 +9283,10 @@ async function runExec(request) {
     cwd: commandCwd,
     stdio: ["inherit", "pipe", "pipe"]
   });
+  const stopChildPendingNotice = startPendingNotice(
+    "sift waiting for child command...",
+    Boolean(process.stderr.isTTY) && !request.quiet
+  );
   const handleChunk = (chunk) => {
     const text = Buffer.isBuffer(chunk) ? chunk.toString("utf8") : String(chunk);
     if (bypassed) {
@@ -8807,26 +9307,31 @@ async function runExec(request) {
   };
   child.stdout.on("data", handleChunk);
   child.stderr.on("data", handleChunk);
-  await new Promise((resolve, reject) => {
-    child.on("error", (error) => {
-      reject(error);
-    });
-    child.on("close", (status, signal) => {
-      childStatus = status;
-      childSignal = signal;
-      resolve();
+  try {
+    await new Promise((resolve, reject) => {
+      child.on("error", (error) => {
+        reject(error);
+      });
+      child.on("close", (status, signal) => {
+        childStatus = status;
+        childSignal = signal;
+        resolve();
+      });
     });
-  }).catch((error) => {
+  } catch (error) {
     if (error instanceof Error) {
       throw error;
     }
     throw new Error("Failed to start child process.");
-  });
+  } finally {
+    stopChildPendingNotice();
+  }
   const exitCode = normalizeChildExitCode(childStatus, childSignal);
   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(
       `${pc5.dim("sift")} child_exit=${exitCode} captured_chars=${capture.getTotalChars()} capture_truncated=${capture.wasTruncated()}
@@ -8889,10 +9394,19 @@ async function runExec(request) {
 `);
       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
       }),
@@ -8906,31 +9420,32 @@ 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;
     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
     });
     let output = result.output;
-    if (shouldCacheTestStatus) {
+    if (shouldBuildTestStatusState) {
       if (isInsufficientSignalOutput(output)) {
         output = buildInsufficientSignalOutput({
           presetName: request.presetName,
@@ -8945,26 +9460,12 @@ 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) {
@@ -9011,25 +9512,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
@@ -9542,8 +10078,14 @@ function createCliApp(args = {}) {
     });
   });
   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`.");