@bilalimamoglu/sift 0.2.2 → 0.3.0

package/dist/index.js

@@ -6,8 +6,14 @@ import pc2 from "picocolors";
 // src/constants.ts
 import os from "os";
 import path from "path";
-function getDefaultGlobalConfigPath() {
-  return path.join(os.homedir(), ".config", "sift", "config.yaml");
+function getDefaultGlobalConfigPath(homeDir = os.homedir()) {
+  return path.join(homeDir, ".config", "sift", "config.yaml");
+}
+function getDefaultGlobalStateDir(homeDir = os.homedir()) {
+  return path.join(homeDir, ".config", "sift", "state");
+}
+function getDefaultTestStatusStatePath(homeDir = os.homedir()) {
+  return path.join(getDefaultGlobalStateDir(homeDir), "last-test-status.json");
 }
 function getDefaultConfigSearchPaths() {
   return [
@@ -17,40 +23,2074 @@ function getDefaultConfigSearchPaths() {
     path.join(os.homedir(), ".config", "sift", "config.yml")
   ];
 }
-var INSUFFICIENT_SIGNAL_TEXT = "Insufficient signal in the provided input.";
-var GENERIC_JSON_CONTRACT = '{"answer":string,"evidence":string[],"risks":string[]}';
-var CAPTURE_OMITTED_MARKER = "\n...[captured output omitted]...\n";
-
-// src/core/gate.ts
-var FAIL_ON_SUPPORTED_PRESETS = /* @__PURE__ */ new Set(["infra-risk", "audit-critical"]);
-function parseJson(output) {
-  try {
-    return JSON.parse(output);
-  } catch {
+var INSUFFICIENT_SIGNAL_TEXT = "Insufficient signal in the provided input.";
+var GENERIC_JSON_CONTRACT = '{"answer":string,"evidence":string[],"risks":string[]}';
+var CAPTURE_OMITTED_MARKER = "\n...[captured output omitted]...\n";
+
+// src/core/gate.ts
+var FAIL_ON_SUPPORTED_PRESETS = /* @__PURE__ */ new Set(["infra-risk", "audit-critical"]);
+function parseJson(output) {
+  try {
+    return JSON.parse(output);
+  } catch {
+    return null;
+  }
+}
+function supportsFailOnPreset(presetName) {
+  return typeof presetName === "string" && FAIL_ON_SUPPORTED_PRESETS.has(presetName);
+}
+function evaluateGate(args) {
+  const parsed = parseJson(args.output);
+  if (!parsed || typeof parsed !== "object") {
+    return { shouldFail: false };
+  }
+  if (args.presetName === "infra-risk") {
+    return {
+      shouldFail: parsed["verdict"] === "fail"
+    };
+  }
+  if (args.presetName === "audit-critical") {
+    const status = parsed["status"];
+    const vulnerabilities = parsed["vulnerabilities"];
+    return {
+      shouldFail: status === "ok" && Array.isArray(vulnerabilities) && vulnerabilities.length > 0
+    };
+  }
+  return { shouldFail: false };
+}
+
+// src/core/testStatusDecision.ts
+import { z } from "zod";
+var TEST_STATUS_DIAGNOSE_JSON_CONTRACT = '{"status":"ok|insufficient","diagnosis_complete":boolean,"raw_needed":boolean,"additional_source_read_likely_low_value":boolean,"read_raw_only_if":string|null,"decision":"stop|zoom|read_source|read_raw","dominant_blocker_bucket_index":number|null,"provider_used":boolean,"provider_confidence":number|null,"provider_failed":boolean,"raw_slice_used":boolean,"raw_slice_strategy":"none|bucket_evidence|traceback_window|head_tail","resolved_summary":{"count":number,"families":[{"prefix":string,"count":number}]},"remaining_summary":{"count":number,"families":[{"prefix":string,"count":number}]},"remaining_subset_available":boolean,"main_buckets":[{"bucket_index":number,"label":string,"count":number,"root_cause":string,"evidence":string[],"bucket_confidence":number,"root_cause_confidence":number,"dominant":boolean,"secondary_visible_despite_blocker":boolean,"mini_diff":{"added_paths"?:number,"removed_models"?:number,"changed_task_mappings"?:number}|null}],"read_targets":[{"file":string,"line":number|null,"why":string,"bucket_index":number,"context_hint":{"start_line":number|null,"end_line":number|null,"search_hint":string|null}}],"next_best_action":{"code":"fix_dominant_blocker|read_source_for_bucket|read_raw_for_exact_traceback|insufficient_signal","bucket_index":number|null,"note":string},"resolved_tests"?:string[],"remaining_tests"?:string[]}';
+var TEST_STATUS_PROVIDER_SUPPLEMENT_JSON_CONTRACT = '{"diagnosis_complete":boolean,"raw_needed":boolean,"additional_source_read_likely_low_value":boolean,"read_raw_only_if":string|null,"decision":"stop|zoom|read_source|read_raw","provider_confidence":number|null,"next_best_action":{"code":"fix_dominant_blocker|read_source_for_bucket|read_raw_for_exact_traceback|insufficient_signal","bucket_index":number|null,"note":string}}';
+var nextBestActionSchema = z.object({
+  code: z.enum([
+    "fix_dominant_blocker",
+    "read_source_for_bucket",
+    "read_raw_for_exact_traceback",
+    "insufficient_signal"
+  ]),
+  bucket_index: z.number().int().nullable(),
+  note: z.string().min(1)
+});
+var testStatusProviderSupplementSchema = z.object({
+  diagnosis_complete: z.boolean(),
+  raw_needed: z.boolean(),
+  additional_source_read_likely_low_value: z.boolean(),
+  read_raw_only_if: z.string().nullable(),
+  decision: z.enum(["stop", "zoom", "read_source", "read_raw"]),
+  provider_confidence: z.number().min(0).max(1).nullable(),
+  next_best_action: nextBestActionSchema
+});
+var testStatusDiagnoseContractSchema = z.object({
+  status: z.enum(["ok", "insufficient"]),
+  diagnosis_complete: z.boolean(),
+  raw_needed: z.boolean(),
+  additional_source_read_likely_low_value: z.boolean(),
+  read_raw_only_if: z.string().nullable(),
+  decision: z.enum(["stop", "zoom", "read_source", "read_raw"]),
+  dominant_blocker_bucket_index: z.number().int().nullable(),
+  provider_used: z.boolean(),
+  provider_confidence: z.number().min(0).max(1).nullable(),
+  provider_failed: z.boolean(),
+  raw_slice_used: z.boolean(),
+  raw_slice_strategy: z.enum(["none", "bucket_evidence", "traceback_window", "head_tail"]),
+  resolved_tests: z.array(z.string()),
+  remaining_tests: z.array(z.string()),
+  main_buckets: z.array(
+    z.object({
+      bucket_index: z.number().int(),
+      label: z.string(),
+      count: z.number().int(),
+      root_cause: z.string(),
+      evidence: z.array(z.string()).max(2),
+      bucket_confidence: z.number(),
+      root_cause_confidence: z.number(),
+      dominant: z.boolean(),
+      secondary_visible_despite_blocker: z.boolean(),
+      mini_diff: z.object({
+        added_paths: z.number().int().optional(),
+        removed_models: z.number().int().optional(),
+        changed_task_mappings: z.number().int().optional()
+      }).nullable()
+    })
+  ),
+  read_targets: z.array(
+    z.object({
+      file: z.string().min(1),
+      line: z.number().int().nullable(),
+      why: z.string().min(1),
+      bucket_index: z.number().int(),
+      context_hint: z.object({
+        start_line: z.number().int().nullable(),
+        end_line: z.number().int().nullable(),
+        search_hint: z.string().nullable()
+      })
+    })
+  ).max(5),
+  next_best_action: nextBestActionSchema
+});
+var testStatusTargetSummarySchema = z.object({
+  count: z.number().int().nonnegative(),
+  families: z.array(
+    z.object({
+      prefix: z.string().min(1),
+      count: z.number().int().nonnegative()
+    })
+  ).max(5)
+});
+var testStatusPublicDiagnoseContractSchema = testStatusDiagnoseContractSchema.omit({
+  resolved_tests: true,
+  remaining_tests: true
+}).extend({
+  resolved_summary: testStatusTargetSummarySchema,
+  remaining_summary: testStatusTargetSummarySchema,
+  remaining_subset_available: z.boolean(),
+  resolved_tests: z.array(z.string()).optional(),
+  remaining_tests: z.array(z.string()).optional()
+});
+function parseTestStatusProviderSupplement(input) {
+  return testStatusProviderSupplementSchema.parse(JSON.parse(input));
+}
+function formatCount(count, singular, plural = `${singular}s`) {
+  return `${count} ${count === 1 ? singular : plural}`;
+}
+function unique(values) {
+  return [...new Set(values)];
+}
+function normalizeTestId(value) {
+  return value.replace(/\\/g, "/").trim();
+}
+function extractTestFamilyPrefix(value) {
+  const normalized = normalizeTestId(value);
+  const testsMatch = normalized.match(/^(tests\/[^/]+\/)/);
+  if (testsMatch) {
+    return testsMatch[1];
+  }
+  const filePart = normalized.split("::")[0]?.trim() ?? "";
+  if (!filePart.includes("/")) {
+    return "other";
+  }
+  const segments = filePart.replace(/^\/+/, "").split("/").filter(Boolean);
+  if (segments.length === 0) {
+    return "other";
+  }
+  return `${segments[0]}/`;
+}
+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);
+  }
+  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: values.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 classifyGenericBucketType(reason) {
+  if (reason.startsWith("missing test env:")) {
+    return "shared_environment_blocker";
+  }
+  if (reason.startsWith("fixture guard:")) {
+    return "collection_failure";
+  }
+  if (reason.startsWith("service unavailable:")) {
+    return "runtime_failure";
+  }
+  if (reason.startsWith("db refused:")) {
+    return "runtime_failure";
+  }
+  if (reason.startsWith("auth bypass absent:")) {
+    return "runtime_failure";
+  }
+  if (reason.startsWith("missing module:")) {
+    return "import_dependency_failure";
+  }
+  if (reason.startsWith("assertion failed:")) {
+    return "assertion_failure";
+  }
+  if (/^[A-Z][A-Za-z]+(?:Error|Exception):/.test(reason)) {
+    return "runtime_failure";
+  }
+  return "unknown_failure";
+}
+function buildGenericBuckets(analysis) {
+  const buckets = [];
+  const grouped = /* @__PURE__ */ new Map();
+  const push = (reason, item) => {
+    const key = `${classifyGenericBucketType(reason)}:${reason}`;
+    const existing = grouped.get(key);
+    if (existing) {
+      existing.count += 1;
+      if (!existing.representativeItems.some((entry) => entry.label === item.label) && existing.representativeItems.length < 6) {
+        existing.representativeItems.push(item);
+      }
+      return;
+    }
+    grouped.set(key, {
+      type: classifyGenericBucketType(reason),
+      headline: "",
+      summaryLines: [],
+      reason,
+      count: 1,
+      confidence: reason.startsWith("assertion failed:") || /^[A-Z][A-Za-z]+(?:Error|Exception):/.test(reason) ? 0.74 : 0.62,
+      representativeItems: [item],
+      entities: [],
+      hint: void 0,
+      overflowCount: 0,
+      overflowLabel: "failing tests/modules"
+    });
+  };
+  for (const item of [...analysis.collectionItems, ...analysis.inlineItems]) {
+    push(item.reason, item);
+  }
+  for (const bucket of grouped.values()) {
+    const title = bucket.type === "assertion_failure" ? "Assertion failures" : bucket.type === "import_dependency_failure" ? "Import/dependency failures" : bucket.type === "collection_failure" ? "Collection or fixture failures" : "Runtime failures";
+    bucket.headline = `${title}: ${formatCount(bucket.count, "visible failure")} share ${bucket.reason}.`;
+    bucket.summaryLines = [bucket.headline];
+    bucket.overflowCount = Math.max(bucket.count - bucket.representativeItems.length, 0);
+    buckets.push(bucket);
+  }
+  return buckets.sort((left, right) => right.count - left.count);
+}
+function normalizeBucketIdentity(bucket) {
+  return `${bucket.type}:${bucket.reason.toLowerCase().replace(/\s+/g, " ").trim()}`;
+}
+function mergeRepresentativeItems(left, right) {
+  const merged = [...left];
+  for (const item of right) {
+    if (merged.some(
+      (existing) => existing.label === item.label && existing.reason === item.reason
+    )) {
+      continue;
+    }
+    if (merged.length >= 6) {
+      break;
+    }
+    merged.push(item);
+  }
+  return merged;
+}
+function mergeBucketDetails(existing, incoming) {
+  const representativeItems = mergeRepresentativeItems(
+    existing.representativeItems,
+    incoming.representativeItems
+  );
+  const count = Math.max(existing.count, incoming.count);
+  return {
+    ...existing,
+    headline: existing.summaryLines.length >= incoming.summaryLines.length && existing.headline.length >= incoming.headline.length ? existing.headline : incoming.headline,
+    summaryLines: existing.summaryLines.length >= incoming.summaryLines.length ? existing.summaryLines : incoming.summaryLines,
+    count,
+    confidence: Math.max(existing.confidence, incoming.confidence),
+    representativeItems,
+    entities: unique([...existing.entities, ...incoming.entities]),
+    hint: existing.hint ?? incoming.hint,
+    overflowCount: Math.max(
+      existing.overflowCount,
+      incoming.overflowCount,
+      count - representativeItems.length
+    ),
+    overflowLabel: existing.overflowLabel || incoming.overflowLabel
+  };
+}
+function mergeBuckets(analysis) {
+  const mergedByIdentity = /* @__PURE__ */ new Map();
+  const merged = [];
+  const pushBucket = (bucket) => {
+    const identity = normalizeBucketIdentity(bucket);
+    const existing = mergedByIdentity.get(identity);
+    if (existing) {
+      const replacement = mergeBucketDetails(existing, bucket);
+      const index = merged.indexOf(existing);
+      if (index >= 0) {
+        merged[index] = replacement;
+      }
+      mergedByIdentity.set(identity, replacement);
+      return;
+    }
+    merged.push(bucket);
+    mergedByIdentity.set(identity, bucket);
+  };
+  for (const bucket of analysis.buckets.map((bucket2) => ({
+    type: bucket2.type,
+    headline: bucket2.headline,
+    summaryLines: [...bucket2.summaryLines],
+    reason: bucket2.reason,
+    count: bucket2.countClaimed ?? bucket2.countVisible,
+    confidence: bucket2.confidence,
+    representativeItems: [...bucket2.representativeItems],
+    entities: [...bucket2.entities],
+    hint: bucket2.hint,
+    overflowCount: bucket2.overflowCount,
+    overflowLabel: bucket2.overflowLabel
+  }))) {
+    pushBucket(bucket);
+  }
+  const coveredLabels = new Set(
+    merged.flatMap((bucket) => bucket.representativeItems.map((item) => item.label))
+  );
+  for (const bucket of buildGenericBuckets(analysis)) {
+    const identity = normalizeBucketIdentity(bucket);
+    const unseenItems = bucket.representativeItems.filter(
+      (item) => !coveredLabels.has(item.label)
+    );
+    if (!mergedByIdentity.has(identity) && unseenItems.length === 0) {
+      continue;
+    }
+    pushBucket({
+      ...bucket,
+      count: Math.max(bucket.count, unseenItems.length),
+      representativeItems: mergedByIdentity.has(identity) || unseenItems.length === 0 ? bucket.representativeItems : unseenItems
+    });
+    for (const item of bucket.representativeItems) {
+      coveredLabels.add(item.label);
+    }
+  }
+  return merged;
+}
+function dominantBucketPriority(bucket) {
+  if (bucket.reason.startsWith("missing test env:")) {
+    return 5;
+  }
+  if (bucket.type === "shared_environment_blocker") {
+    return 4;
+  }
+  if (bucket.type === "import_dependency_failure") {
+    return 3;
+  }
+  if (bucket.type === "collection_failure") {
+    return 2;
+  }
+  if (bucket.type === "contract_snapshot_drift") {
+    return 1;
+  }
+  return 0;
+}
+function prioritizeBuckets(buckets) {
+  return [...buckets].sort((left, right) => {
+    const priorityDelta = dominantBucketPriority(right) - dominantBucketPriority(left);
+    if (priorityDelta !== 0) {
+      return priorityDelta;
+    }
+    if (right.count !== left.count) {
+      return right.count - left.count;
+    }
+    if (right.confidence !== left.confidence) {
+      return right.confidence - left.confidence;
+    }
+    return left.reason.localeCompare(right.reason);
+  });
+}
+function isDominantBlockerType(type) {
+  return type === "shared_environment_blocker" || type === "import_dependency_failure" || type === "collection_failure";
+}
+function labelForBucket(bucket) {
+  if (bucket.reason.startsWith("missing test env:")) {
+    return "missing test env";
+  }
+  if (bucket.reason.startsWith("fixture guard:")) {
+    return "fixture guard";
+  }
+  if (bucket.reason.startsWith("service unavailable:")) {
+    return "service unavailable";
+  }
+  if (bucket.reason.startsWith("db refused:")) {
+    return "db refused";
+  }
+  if (bucket.reason.startsWith("auth bypass absent:")) {
+    return "auth bypass absent";
+  }
+  if (bucket.type === "contract_snapshot_drift") {
+    if (/openapi/i.test(bucket.headline) || bucket.entities.some((value) => value.startsWith("/api/"))) {
+      return "route drift";
+    }
+    if (/schema/i.test(bucket.headline)) {
+      return "schema freeze mismatch";
+    }
+    if (/model/i.test(bucket.headline)) {
+      return "model catalog drift";
+    }
+    return "stale snapshot";
+  }
+  if (bucket.type === "import_dependency_failure") {
+    return "import dependency failure";
+  }
+  if (bucket.type === "assertion_failure") {
+    return "assertion failure";
+  }
+  if (bucket.type === "collection_failure") {
+    return "collection failure";
+  }
+  if (bucket.type === "runtime_failure") {
+    return "runtime failure";
+  }
+  return "unknown failure";
+}
+function rootCauseConfidenceFor(bucket) {
+  if (bucket.reason.startsWith("missing test env:") || bucket.reason.startsWith("missing module:") || bucket.reason.startsWith("db refused:") || bucket.reason.startsWith("service unavailable:") || bucket.reason.startsWith("auth bypass absent:")) {
+    return 0.95;
+  }
+  if (bucket.type === "contract_snapshot_drift") {
+    return bucket.entities.length > 0 ? 0.92 : 0.76;
+  }
+  return Math.max(0.6, Math.min(bucket.confidence, 0.88));
+}
+function buildBucketEvidence(bucket) {
+  const evidence = bucket.representativeItems.slice(0, 2).map((item) => `${item.label} -> ${item.reason}`);
+  if (evidence.length > 0) {
+    return evidence;
+  }
+  return bucket.entities.slice(0, 2);
+}
+function formatReadTargetLocation(target) {
+  return target.line === null ? target.file : `${target.file}:${target.line}`;
+}
+function buildReadTargetContextHint(args) {
+  if (args.anchor.line !== null) {
+    return {
+      start_line: Math.max(1, args.anchor.line - 5),
+      end_line: args.anchor.line + 5,
+      search_hint: null
+    };
+  }
+  return {
+    start_line: null,
+    end_line: null,
+    search_hint: buildReadTargetSearchHint(args.bucket, args.anchor)
+  };
+}
+function buildReadTargetWhy(args) {
+  const envVar = args.bucket.reason.match(/^missing test env:\s+([A-Z][A-Z0-9_]{2,})$/)?.[1];
+  if (envVar) {
+    return `it contains the ${envVar} setup guard`;
+  }
+  if (args.bucket.reason.startsWith("fixture guard:")) {
+    return "it contains the fixture/setup guard behind this bucket";
+  }
+  if (args.bucket.reason.startsWith("db refused:")) {
+    return "it contains the database connection setup behind this bucket";
+  }
+  if (args.bucket.reason.startsWith("service unavailable:")) {
+    return "it contains the dependency service call or setup behind this bucket";
+  }
+  if (args.bucket.reason.startsWith("auth bypass absent:")) {
+    return "it contains the auth bypass setup behind this bucket";
+  }
+  if (args.bucket.type === "contract_snapshot_drift") {
+    if (args.bucketLabel === "route drift") {
+      return "it maps to the visible route drift bucket";
+    }
+    if (args.bucketLabel === "model catalog drift") {
+      return "it maps to the visible model drift bucket";
+    }
+    if (args.bucketLabel === "schema freeze mismatch") {
+      return "it maps to the visible schema freeze mismatch";
+    }
+    return "it maps to the visible stale snapshot expectation";
+  }
+  if (args.bucket.type === "import_dependency_failure") {
+    return "it is the first visible failing module in this missing dependency bucket";
+  }
+  if (args.bucket.type === "assertion_failure") {
+    return "it is the first visible failing test in this bucket";
+  }
+  if (args.bucket.type === "collection_failure") {
+    return "it is the first visible collection/setup anchor for this bucket";
+  }
+  return `it maps to the visible ${args.bucketLabel} bucket`;
+}
+function buildReadTargetSearchHint(bucket, anchor) {
+  const envVar = bucket.reason.match(/^missing test env:\s+([A-Z][A-Z0-9_]{2,})$/)?.[1];
+  if (envVar) {
+    return envVar;
+  }
+  if (bucket.type === "contract_snapshot_drift") {
+    return bucket.entities.find((value) => value.startsWith("/api/")) ?? bucket.entities[0] ?? null;
+  }
+  const missingModule = bucket.reason.match(/^missing module:\s+(.+)$/)?.[1];
+  if (missingModule) {
+    return missingModule;
+  }
+  const fixtureGuard = bucket.reason.match(/^fixture guard:\s+(.+)$/)?.[1];
+  if (fixtureGuard) {
+    return fixtureGuard;
+  }
+  const serviceMarker = bucket.reason.match(
+    /^(?:service unavailable|db refused|auth bypass absent):\s+(.+)$/
+  )?.[1];
+  if (serviceMarker) {
+    return serviceMarker;
+  }
+  const assertionText = bucket.reason.match(/^assertion failed:\s+(.+)$/)?.[1];
+  if (assertionText) {
+    return assertionText;
+  }
+  const fallbackLabel = anchor.label.split("::")[1]?.trim();
+  return fallbackLabel || null;
+}
+function buildReadTargets(args) {
+  return args.buckets.map((bucket, index) => ({
+    bucket,
+    bucketIndex: index + 1,
+    bucketLabel: labelForBucket(bucket),
+    dominant: args.dominantBucketIndex === index + 1
+  })).sort((left, right) => {
+    if (left.dominant !== right.dominant) {
+      return left.dominant ? -1 : 1;
+    }
+    return left.bucketIndex - right.bucketIndex;
+  }).flatMap(({ bucket, bucketIndex, bucketLabel }) => {
+    const anchor = [...bucket.representativeItems].filter((item) => item.file).sort((left, right) => {
+      if (left.line !== null !== (right.line !== null)) {
+        return left.line !== null ? -1 : 1;
+      }
+      if (right.anchor_confidence !== left.anchor_confidence) {
+        return right.anchor_confidence - left.anchor_confidence;
+      }
+      return left.label.localeCompare(right.label);
+    })[0];
+    if (!anchor?.file) {
+      return [];
+    }
+    return [
+      {
+        file: anchor.file,
+        line: anchor.line,
+        why: buildReadTargetWhy({
+          bucket,
+          bucketLabel
+        }),
+        bucket_index: bucketIndex,
+        context_hint: buildReadTargetContextHint({
+          bucket,
+          anchor
+        })
+      }
+    ];
+  }).slice(0, 5);
+}
+function buildConcreteNextNote(args) {
+  const primaryTarget = args.readTargets.find((target) => target.bucket_index === args.nextBestAction.bucket_index) ?? args.readTargets[0];
+  if (!primaryTarget) {
+    return args.nextBestAction.note;
+  }
+  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.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") {
+    return lead;
+  }
+  return args.nextBestAction.note;
+}
+function extractMiniDiff(input, bucket) {
+  if (bucket.type !== "contract_snapshot_drift") {
+    return null;
+  }
+  const addedPaths = unique(
+    [...input.matchAll(/[+-]\s+'(\/api\/[^']+)'/g)].map((match) => match[1])
+  ).length;
+  const removedModels = unique(
+    [...input.matchAll(/[+-]\s+'([A-Za-z0-9._/-]+-[A-Za-z0-9._-]+)'/g)].map((match) => match[1])
+  ).length;
+  const changedTaskMappings = unique(
+    [...input.matchAll(/[+-]\s+'([a-z]+(?:_[a-z0-9]+)+)'/g)].map((match) => match[1])
+  ).length;
+  if (addedPaths === 0 && removedModels === 0 && changedTaskMappings === 0) {
+    return null;
+  }
+  return {
+    ...addedPaths > 0 ? { added_paths: addedPaths } : {},
+    ...removedModels > 0 ? { removed_models: removedModels } : {},
+    ...changedTaskMappings > 0 ? { changed_task_mappings: changedTaskMappings } : {}
+  };
+}
+function buildOutcomeLines(analysis) {
+  if (analysis.noTestsCollected) {
+    return ["- Tests did not run.", "- Collected 0 items."];
+  }
+  if (analysis.failed === 0 && analysis.errors === 0 && analysis.passed > 0) {
+    const parts = [formatCount(analysis.passed, "test")];
+    if (analysis.skipped > 0) {
+      parts.push(formatCount(analysis.skipped, "skip"));
+    }
+    return ["- Tests passed.", `- ${parts.join(", ")}.`];
+  }
+  if (analysis.collectionErrorCount && analysis.failed === 0) {
+    return [
+      "- Tests did not complete.",
+      `- ${formatCount(analysis.collectionErrorCount, "error")} occurred during collection.`
+    ];
+  }
+  const counts = [];
+  if (analysis.failed > 0) {
+    counts.push(formatCount(analysis.failed, "test failed", "tests failed"));
+  }
+  if (analysis.errors > 0) {
+    counts.push(formatCount(analysis.errors, "error occurred", "errors occurred"));
+  }
+  if (counts.length === 0) {
+    return ["- Tests did not pass."];
+  }
+  return ["- Tests did not pass.", `- ${counts.join(". ")}.`];
+}
+function buildStopSignal(contract) {
+  if (contract.diagnosis_complete && !contract.raw_needed) {
+    return "- Stop signal: diagnosis complete; raw not needed.";
+  }
+  if (contract.raw_needed && contract.read_raw_only_if) {
+    return `- Stop signal: diagnosis incomplete; raw only if ${contract.read_raw_only_if}.`;
+  }
+  return "- Stop signal: diagnosis incomplete; provider or raw traceback may still help.";
+}
+function deriveDecision(contract) {
+  if (contract.raw_needed || contract.provider_failed) {
+    return "read_raw";
+  }
+  if (!contract.diagnosis_complete) {
+    return "zoom";
+  }
+  if (contract.main_buckets.length === 0 && contract.next_best_action.note === "No failing buckets remain.") {
+    return "stop";
+  }
+  if (contract.next_best_action.code === "read_source_for_bucket") {
+    return "read_source";
+  }
+  return "stop";
+}
+function buildDecisionLine(contract) {
+  if (contract.decision === "stop") {
+    return "- Decision: stop and act. Do not escalate unless you need exact traceback lines.";
+  }
+  if (contract.decision === "read_source") {
+    return "- Decision: read source next. Do not escalate unless exact traceback lines are still needed.";
+  }
+  if (contract.decision === "zoom") {
+    return "- Decision: zoom. One deeper sift pass is justified before raw.";
+  }
+  return "- Decision: raw only if exact traceback is required.";
+}
+function buildComparisonLines(contract) {
+  const lines = [];
+  if (contract.resolved_tests.length > 0) {
+    lines.push(
+      `- Resolved in this rerun: ${formatCount(contract.resolved_tests.length, "test")} dropped out of the failing set.`
+    );
+  }
+  if (contract.resolved_tests.length > 0 && contract.remaining_tests.length > 0) {
+    lines.push(
+      `- Remaining failing targets: ${formatCount(contract.remaining_tests.length, "test/module", "tests/modules")}.`
+    );
+  }
+  return lines;
+}
+function renderBucketHeadline(bucket) {
+  return `- Bucket ${bucket.bucket_index}: ${bucket.label} (${bucket.count}) -> ${bucket.root_cause}`;
+}
+function buildStandardAnchorText(target) {
+  if (!target) {
+    return null;
+  }
+  if (target.context_hint.start_line !== null && target.context_hint.end_line !== null) {
+    return `${target.file} lines ${target.context_hint.start_line}-${target.context_hint.end_line}`;
+  }
+  if (target.context_hint.search_hint) {
+    return `search ${target.context_hint.search_hint} in ${target.file}`;
+  }
+  return formatReadTargetLocation(target);
+}
+function buildStandardFixText(args) {
+  if (args.bucket.hint) {
+    return args.bucket.hint;
+  }
+  const envVar = args.bucket.reason.match(/^missing test env:\s+([A-Z][A-Z0-9_]{2,})$/)?.[1];
+  if (envVar) {
+    return `Set ${envVar} before rerunning the affected tests.`;
+  }
+  const missingModule = args.bucket.reason.match(/^missing module:\s+(.+)$/)?.[1];
+  if (missingModule) {
+    return `Install ${missingModule} and rerun the affected tests.`;
+  }
+  if (args.bucket.reason.startsWith("fixture guard:")) {
+    return "Restore the missing fixture/setup guard and rerun the full suite at standard.";
+  }
+  if (args.bucket.reason.startsWith("db refused:")) {
+    return "Fix the test database connectivity and rerun the full suite at standard.";
+  }
+  if (args.bucket.reason.startsWith("service unavailable:")) {
+    return "Restore the dependency service or test double and rerun the full suite at standard.";
+  }
+  if (args.bucket.reason.startsWith("auth bypass absent:")) {
+    return "Restore the test auth bypass setup and rerun the full suite at standard.";
+  }
+  if (args.bucket.type === "contract_snapshot_drift") {
+    return "Review the visible drift and regenerate the contract snapshots if the changes are intentional.";
+  }
+  if (args.bucket.type === "assertion_failure") {
+    return "Inspect the failing assertion and rerun the full suite at standard.";
+  }
+  if (args.bucket.type === "collection_failure") {
+    return "Fix the collection/setup failure and rerun the full suite at standard.";
+  }
+  if (args.bucket.type === "runtime_failure") {
+    return `Fix the visible ${args.bucketLabel} and rerun the full suite at standard.`;
+  }
+  return null;
+}
+function buildStandardBucketSupport(args) {
+  return {
+    headline: args.bucket.summaryLines[0] ? `- ${args.bucket.summaryLines[0]}` : renderBucketHeadline(args.contractBucket),
+    anchorText: buildStandardAnchorText(args.readTarget),
+    fixText: buildStandardFixText({
+      bucket: args.bucket,
+      bucketLabel: args.contractBucket.label
+    })
+  };
+}
+function renderStandard(args) {
+  const lines = [...buildOutcomeLines(args.analysis), ...buildComparisonLines(args.contract)];
+  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];
+      if (!rawBucket) {
+        lines.push(renderBucketHeadline(bucket));
+        continue;
+      }
+      const support = buildStandardBucketSupport({
+        bucket: rawBucket,
+        contractBucket: bucket,
+        readTarget: args.contract.read_targets.find(
+          (target) => target.bucket_index === bucket.bucket_index
+        )
+      });
+      lines.push(support.headline);
+      if (support.anchorText) {
+        lines.push(`- Anchor: ${support.anchorText}`);
+      }
+      if (support.fixText) {
+        lines.push(`- Fix: ${support.fixText}`);
+      }
+    }
+  }
+  lines.push(buildDecisionLine(args.contract));
+  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)];
+  for (const bucket of args.contract.main_buckets) {
+    const rawBucket = args.buckets[bucket.bucket_index - 1];
+    lines.push(
+      ...rawBucket?.summaryLines.length ? rawBucket.summaryLines.map((line) => `- ${line}`) : [renderBucketHeadline(bucket)]
+    );
+    for (const evidence of bucket.evidence) {
+      lines.push(`  - ${evidence}`);
+    }
+    if (rawBucket?.hint) {
+      lines.push(`  - Hint: ${rawBucket.hint}`);
+    }
+  }
+  lines.push(buildDecisionLine(args.contract));
+  lines.push(`- Next: ${args.contract.next_best_action.note}`);
+  lines.push(buildStopSignal(args.contract));
+  return lines.join("\n");
+}
+function renderVerbose(args) {
+  const lines = [...buildOutcomeLines(args.analysis), ...buildComparisonLines(args.contract)];
+  for (const bucket of args.contract.main_buckets) {
+    const rawBucket = args.buckets[bucket.bucket_index - 1];
+    lines.push(
+      ...rawBucket?.summaryLines.length ? rawBucket.summaryLines.map((line) => `- ${line}`) : [renderBucketHeadline(bucket)]
+    );
+    for (const item of rawBucket?.representativeItems ?? []) {
+      lines.push(`  - ${item.label} -> ${item.reason}`);
+    }
+    if (bucket.mini_diff) {
+      lines.push(`  - mini-diff: ${JSON.stringify(bucket.mini_diff)}`);
+    }
+    if (rawBucket?.hint) {
+      lines.push(`  - Hint: ${rawBucket.hint}`);
+    }
+  }
+  lines.push(buildDecisionLine(args.contract));
+  lines.push(`- Next: ${args.contract.next_best_action.note}`);
+  lines.push(buildStopSignal(args.contract));
+  return lines.join("\n");
+}
+function buildTestStatusDiagnoseContract(args) {
+  const buckets = prioritizeBuckets(mergeBuckets(args.analysis)).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,
+    index
+  })).sort((left, right) => {
+    if (right.bucket.count !== left.bucket.count) {
+      return right.bucket.count - left.bucket.count;
+    }
+    return right.bucket.confidence - left.bucket.confidence;
+  })[0] ?? null;
+  const diagnosisComplete = args.analysis.failed === 0 && args.analysis.errors === 0 && args.analysis.passed > 0 || simpleCollectionFailure || buckets.length > 0 && (dominantBucket?.bucket.confidence ?? 0) >= 0.7;
+  const rawNeeded = buckets.length > 0 ? buckets.every((bucket) => bucket.confidence < 0.7) : !(args.analysis.failed === 0 && args.analysis.errors === 0 && args.analysis.passed > 0 || simpleCollectionFailure);
+  const 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])
+  );
+  let nextBestAction;
+  if (args.analysis.failed === 0 && args.analysis.errors === 0 && args.analysis.passed > 0) {
+    nextBestAction = {
+      code: "read_source_for_bucket",
+      bucket_index: null,
+      note: "No failing buckets remain."
+    };
+  } else if (simpleCollectionFailure) {
+    nextBestAction = {
+      code: "read_source_for_bucket",
+      bucket_index: null,
+      note: "Inspect the collection traceback or setup code next; the run failed before tests executed."
+    };
+  } else if (!diagnosisComplete) {
+    nextBestAction = {
+      code: rawNeeded ? "read_raw_for_exact_traceback" : "insufficient_signal",
+      bucket_index: dominantBucket ? dominantBucket.index + 1 : null,
+      note: rawNeeded ? "Use focused or verbose detail, and read raw traceback only if exact stack lines are still needed." : "The visible output is not yet specific enough to diagnose reliably."
+    };
+  } else if (dominantBlockerBucketIndex !== null) {
+    nextBestAction = {
+      code: "fix_dominant_blocker",
+      bucket_index: dominantBlockerBucketIndex,
+      note: dominantBlockerBucketIndex === 1 && mainBuckets.some((bucket) => bucket.secondary_visible_despite_blocker) ? "Fix bucket 1 first, then rerun the full suite at standard. Secondary buckets are already visible behind it." : `Fix bucket ${dominantBlockerBucketIndex} first, then rerun the full suite at standard.`
+    };
+  } else {
+    nextBestAction = {
+      code: rawNeeded ? "read_raw_for_exact_traceback" : "read_source_for_bucket",
+      bucket_index: mainBuckets[0]?.bucket_index ?? null,
+      note: rawNeeded ? "Read raw traceback only if exact stack lines are required after the current diagnosis." : `Read the source or test code for bucket ${mainBuckets[0]?.bucket_index ?? 1} next.`
+    };
+  }
+  const baseContract = {
+    status: diagnosisComplete ? "ok" : "insufficient",
+    diagnosis_complete: diagnosisComplete,
+    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,
+    dominant_blocker_bucket_index: dominantBlockerBucketIndex,
+    provider_used: false,
+    provider_confidence: null,
+    provider_failed: false,
+    raw_slice_used: false,
+    raw_slice_strategy: "none",
+    resolved_tests: resolvedTests,
+    remaining_tests: remainingTests,
+    main_buckets: mainBuckets,
+    read_targets: readTargets,
+    next_best_action: nextBestAction
+  };
+  const effectiveNextBestAction = args.contractOverrides?.next_best_action ?? baseContract.next_best_action;
+  const mergedContractWithoutDecision = {
+    ...baseContract,
+    ...args.contractOverrides,
+    status: args.contractOverrides?.diagnosis_complete ?? diagnosisComplete ? "ok" : "insufficient",
+    next_best_action: {
+      ...effectiveNextBestAction,
+      note: buildConcreteNextNote({
+        nextBestAction: effectiveNextBestAction,
+        readTargets,
+        hasSecondaryVisibleBucket: mainBuckets.some(
+          (bucket) => bucket.secondary_visible_despite_blocker
+        )
+      })
+    }
+  };
+  const contract = testStatusDiagnoseContractSchema.parse({
+    ...mergedContractWithoutDecision,
+    decision: args.contractOverrides?.decision ?? deriveDecision(mergedContractWithoutDecision)
+  });
+  return {
+    contract,
+    standardText: renderStandard({
+      analysis: args.analysis,
+      contract,
+      buckets
+    }),
+    focusedText: renderFocused({
+      analysis: args.analysis,
+      contract,
+      buckets
+    }),
+    verboseText: renderVerbose({
+      analysis: args.analysis,
+      contract,
+      buckets
+    })
+  };
+}
+function buildTestStatusPublicDiagnoseContract(args) {
+  const {
+    resolved_tests,
+    remaining_tests,
+    ...rest
+  } = args.contract;
+  return testStatusPublicDiagnoseContractSchema.parse({
+    ...rest,
+    resolved_summary: buildTestTargetSummary(resolved_tests),
+    remaining_summary: buildTestTargetSummary(remaining_tests),
+    remaining_subset_available: Boolean(args.remainingSubsetAvailable) && remaining_tests.length > 0,
+    ...args.includeTestIds ? {
+      resolved_tests,
+      remaining_tests
+    } : {}
+  });
+}
+function buildTestStatusAnalysisContext(args) {
+  const publicContract = buildTestStatusPublicDiagnoseContract({
+    contract: args.contract,
+    includeTestIds: args.includeTestIds,
+    remainingSubsetAvailable: args.remainingSubsetAvailable
+  });
+  const bucketLines = args.contract.main_buckets.length === 0 ? ["- No failing buckets visible."] : args.contract.main_buckets.map(
+    (bucket) => `- Bucket ${bucket.bucket_index}: ${bucket.label}; count=${bucket.count}; root_cause=${bucket.root_cause}; dominant=${bucket.dominant}`
+  );
+  return [
+    "Heuristic extract:",
+    `- diagnosis_complete=${args.contract.diagnosis_complete}`,
+    `- raw_needed=${args.contract.raw_needed}`,
+    `- decision=${args.contract.decision}`,
+    `- provider_used=${args.contract.provider_used}`,
+    `- provider_failed=${args.contract.provider_failed}`,
+    `- raw_slice_strategy=${args.contract.raw_slice_strategy}`,
+    `- resolved_summary=${formatTargetSummary(publicContract.resolved_summary)}`,
+    `- remaining_summary=${formatTargetSummary(publicContract.remaining_summary)}`,
+    `- remaining_subset_available=${publicContract.remaining_subset_available}`,
+    ...args.includeTestIds && args.contract.resolved_tests.length > 0 ? [`- resolved_tests=${args.contract.resolved_tests.join(", ")}`] : [],
+    ...args.includeTestIds && args.contract.remaining_tests.length > 0 ? [`- remaining_tests=${args.contract.remaining_tests.join(", ")}`] : [],
+    ...args.contract.read_targets.length > 0 ? args.contract.read_targets.map(
+      (target) => `- read_target[bucket=${target.bucket_index}]=${formatReadTargetLocation(target)} -> ${target.why}${target.context_hint.start_line !== null && target.context_hint.end_line !== null ? `; lines=${target.context_hint.start_line}-${target.context_hint.end_line}` : target.context_hint.search_hint ? `; search=${target.context_hint.search_hint}` : ""}`
+    ) : [],
+    ...bucketLines,
+    `- next_best_action=${args.contract.next_best_action.code}`
+  ].join("\n");
+}
+
+// src/core/heuristics.ts
+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;
+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);
+}
+function inferSeverity(token) {
+  return token.toLowerCase().includes("critical") ? "critical" : "high";
+}
+function inferPackage(line) {
+  const match = line.match(/^\s*([@a-z0-9._/-]+)\s*:/i);
+  return match?.[1] ?? null;
+}
+function inferRemediation(pkg) {
+  return `Upgrade ${pkg} 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 formatCount2(count, singular, plural = `${singular}s`) {
+  return `${count} ${count === 1 ? singular : plural}`;
+}
+function countPattern(input, matcher) {
+  return [...input.matchAll(matcher)].length;
+}
+function collectUniqueMatches(input, matcher, limit = 6) {
+  const values = [];
+  for (const match of input.matchAll(matcher)) {
+    const candidate = match[1]?.trim();
+    if (!candidate || values.includes(candidate)) {
+      continue;
+    }
+    values.push(candidate);
+    if (values.length >= limit) {
+      break;
+    }
+  }
+  return values;
+}
+function emptyAnchor() {
+  return {
+    file: null,
+    line: null,
+    anchor_kind: "none",
+    anchor_confidence: 0
+  };
+}
+function normalizeAnchorFile(value) {
+  return value.replace(/\\/g, "/").trim();
+}
+function inferFileFromLabel(label) {
+  const candidate = cleanFailureLabel(label).split("::")[0]?.trim();
+  if (!candidate) {
+    return null;
+  }
+  if (!/[./\\]/.test(candidate) || !/\.[A-Za-z0-9]+$/.test(candidate)) {
+    return null;
+  }
+  return normalizeAnchorFile(candidate);
+}
+function buildLabelAnchor(label) {
+  const file = inferFileFromLabel(label);
+  if (!file) {
+    return emptyAnchor();
+  }
+  return {
+    file,
+    line: null,
+    anchor_kind: "test_label",
+    anchor_confidence: 0.72
+  };
+}
+function parseObservedAnchor(line) {
+  const normalized = line.trim();
+  if (normalized.length === 0) {
+    return null;
+  }
+  const fileWithLine = normalized.match(/^([A-Za-z0-9_./-]+\.[A-Za-z0-9]+):(\d+)(?::\d+)?:\s+in\b/) ?? normalized.match(/^([^:\s][^:]*\.[A-Za-z0-9]+):(\d+)(?::\d+)?:\s+in\b/);
+  if (fileWithLine) {
+    return {
+      file: normalizeAnchorFile(fileWithLine[1]),
+      line: Number(fileWithLine[2]),
+      anchor_kind: "traceback",
+      anchor_confidence: 1
+    };
+  }
+  const pythonTraceback = normalized.match(/^File\s+"([^"]+)",\s+line\s+(\d+)/);
+  if (pythonTraceback) {
+    return {
+      file: normalizeAnchorFile(pythonTraceback[1]),
+      line: Number(pythonTraceback[2]),
+      anchor_kind: "traceback",
+      anchor_confidence: 1
+    };
+  }
+  const importModule = normalized.match(
+    /ImportError while importing test module ['"]([^'"]+\.[A-Za-z0-9]+)['"]/i
+  );
+  if (importModule) {
+    return {
+      file: normalizeAnchorFile(importModule[1]),
+      line: null,
+      anchor_kind: "traceback",
+      anchor_confidence: 0.92
+    };
+  }
+  return null;
+}
+function resolveAnchorForLabel(args) {
+  return args.observedAnchor ?? buildLabelAnchor(args.label);
+}
+function cleanFailureLabel(label) {
+  return label.trim().replace(/^['"]|['"]$/g, "");
+}
+function isLowValueInternalReason(normalized) {
+  return /^Hint:\s+make sure your test modules\/packages have valid Python names\.?$/i.test(
+    normalized
+  ) || /^Traceback\b/i.test(normalized) || /^return _bootstrap\._gcd_import/i.test(normalized) || /(?:^|[/\\])(?:site-packages[/\\])?_pytest(?:[/\\]|$)/i.test(normalized) || /(?:^|[/\\])importlib[/\\]__init__\.py:\d+:\s+in\s+import_module\b/i.test(
+    normalized
+  ) || /\bpython\.py:\d+:\s+in\s+importtestmodule\b/i.test(normalized) || /\bpython\.py:\d+:\s+in\s+import_path\b/i.test(normalized);
+}
+function scoreFailureReason(reason) {
+  if (reason.startsWith("missing test env:")) {
+    return 6;
+  }
+  if (reason.startsWith("missing module:")) {
+    return 5;
+  }
+  if (reason.startsWith("assertion failed:")) {
+    return 4;
+  }
+  if (/^[A-Z][A-Za-z]+(?:Error|Exception):/.test(reason)) {
+    return 3;
+  }
+  if (reason === "import error during collection") {
+    return 2;
+  }
+  return 1;
+}
+function extractEnvBlockerName(normalized) {
+  const directMatch = normalized.match(
+    /\bDB-isolated tests require\s+([A-Z][A-Z0-9_]{2,})\b/
+  );
+  if (directMatch) {
+    return directMatch[1];
+  }
+  const fallbackMatch = normalized.match(
+    /\b([A-Z][A-Z0-9_]{2,})\b(?=[^.\n]*DB-isolated tests)/
+  );
+  return fallbackMatch?.[1] ?? null;
+}
+function classifyFailureReason(line, options) {
+  const normalized = line.trim().replace(/^[A-Z]\s+/, "");
+  if (normalized.length === 0) {
+    return null;
+  }
+  if (isLowValueInternalReason(normalized)) {
+    return null;
+  }
+  if (/^([A-Za-z0-9_./-]+\.[A-Za-z0-9]+):\d+(?::\d+)?:\s+in\b/.test(normalized) || /^([^:\s][^:]*\.[A-Za-z0-9]+):\d+(?::\d+)?:\s+in\b/.test(normalized) || /^File\s+"[^"]+",\s+line\s+\d+/.test(normalized)) {
+    return null;
+  }
+  const envBlocker = extractEnvBlockerName(normalized);
+  if (envBlocker) {
+    return {
+      reason: `missing test env: ${envBlocker}`,
+      group: "DB-backed tests are blocked by missing test environment configuration"
+    };
+  }
+  const missingEnv = normalized.match(
+    /\b(?:environment variable|env(?:ironment)? var(?:iable)?|Missing required env(?:ironment)? variable)\s+([A-Z][A-Z0-9_]{2,})\b/i
+  );
+  if (missingEnv) {
+    return {
+      reason: `missing test env: ${missingEnv[1]}`,
+      group: "tests are blocked by missing environment configuration"
+    };
+  }
+  const keyErrorEnv = normalized.match(/KeyError:\s*['"]([A-Z][A-Z0-9_]{2,})['"]/);
+  if (keyErrorEnv) {
+    return {
+      reason: `missing test env: ${keyErrorEnv[1]}`,
+      group: "tests are blocked by missing environment configuration"
+    };
+  }
+  const fixtureGuard = normalized.match(
+    /(?:FixtureLookupError|fixture guard|requires fixture)\b[^A-Za-z0-9_'-]*([a-z_][a-z0-9_]*)?/i
+  );
+  if (fixtureGuard) {
+    return {
+      reason: `fixture guard: ${fixtureGuard[1] ?? "required fixture unavailable"}`.trim(),
+      group: "fixture guards or setup gates"
+    };
+  }
+  if (/(ECONNREFUSED|ConnectionRefusedError|connection refused|could not connect to server)/i.test(
+    normalized
+  ) && /(postgres|database|db|5432)/i.test(normalized)) {
+    return {
+      reason: "db refused: database connection was refused",
+      group: "database connectivity failures"
+    };
+  }
+  if (/(503\b|service unavailable|temporarily unavailable)/i.test(normalized)) {
+    return {
+      reason: "service unavailable: dependency service is unavailable",
+      group: "service availability failures"
+    };
+  }
+  if (/(auth bypass|test auth|bypass token)/i.test(normalized) && /(missing|absent|not configured|not set|unavailable)/i.test(normalized)) {
+    return {
+      reason: "auth bypass absent: test auth bypass is missing",
+      group: "authentication test setup failures"
+    };
+  }
+  const pythonMissingModule = normalized.match(
+    /ModuleNotFoundError:\s+No module named ['"]([^'"]+)['"]/i
+  );
+  if (pythonMissingModule) {
+    return {
+      reason: `missing module: ${pythonMissingModule[1]}`,
+      group: options.duringCollection ? "import/dependency errors during collection" : "missing dependency/module errors"
+    };
+  }
+  const nodeMissingModule = normalized.match(/Cannot find module ['"]([^'"]+)['"]/i);
+  if (nodeMissingModule) {
+    return {
+      reason: `missing module: ${nodeMissingModule[1]}`,
+      group: options.duringCollection ? "import/dependency errors during collection" : "missing dependency/module errors"
+    };
+  }
+  const assertionFailure = normalized.match(/AssertionError:\s*(.+)$/i);
+  if (assertionFailure) {
+    return {
+      reason: `assertion failed: ${assertionFailure[1]}`.slice(0, 120),
+      group: "assertion failures"
+    };
+  }
+  const genericError = normalized.match(/\b([A-Z][A-Za-z]+(?:Error|Exception)):\s*(.+)$/);
+  if (genericError) {
+    const errorType = genericError[1];
+    return {
+      reason: `${errorType}: ${genericError[2]}`.slice(0, 120),
+      group: options.duringCollection && errorType === "ImportError" ? "import/dependency errors during collection" : `${errorType} failures`
+    };
+  }
+  if (/ImportError while importing test module/i.test(normalized)) {
+    return {
+      reason: "import error during collection",
+      group: "import/dependency errors during collection"
+    };
+  }
+  if (!/[A-Za-z]/.test(normalized)) {
+    return null;
+  }
+  return {
+    reason: normalized.slice(0, 120),
+    group: options.duringCollection ? "collection/import errors" : "other failures"
+  };
+}
+function pushFocusedFailureItem(items, candidate) {
+  if (items.some((item) => item.label === candidate.label && item.reason === candidate.reason)) {
+    return;
+  }
+  items.push(candidate);
+}
+function chooseStrongestFailureItems(items) {
+  const strongest = /* @__PURE__ */ new Map();
+  const order = [];
+  for (const item of items) {
+    const existing = strongest.get(item.label);
+    if (!existing) {
+      strongest.set(item.label, item);
+      order.push(item.label);
+      continue;
+    }
+    if (scoreFailureReason(item.reason) > scoreFailureReason(existing.reason)) {
+      strongest.set(item.label, item);
+    }
+  }
+  return order.map((label) => strongest.get(label));
+}
+function collectCollectionFailureItems(input) {
+  const items = [];
+  const lines = input.split("\n");
+  let currentLabel = null;
+  let pendingGenericReason = null;
+  let currentAnchor = null;
+  for (const line of lines) {
+    const collecting = line.match(/^_+\s+ERROR collecting\s+(.+?)\s+_+\s*$/);
+    if (collecting) {
+      if (currentLabel && pendingGenericReason) {
+        const anchor2 = resolveAnchorForLabel({
+          label: currentLabel,
+          observedAnchor: currentAnchor
+        });
+        pushFocusedFailureItem(items, {
+          label: currentLabel,
+          reason: pendingGenericReason.reason,
+          group: pendingGenericReason.group,
+          ...anchor2
+        });
+      }
+      currentLabel = cleanFailureLabel(collecting[1]);
+      pendingGenericReason = null;
+      currentAnchor = null;
+      continue;
+    }
+    if (!currentLabel) {
+      continue;
+    }
+    currentAnchor = parseObservedAnchor(line) ?? currentAnchor;
+    const classification = classifyFailureReason(line, {
+      duringCollection: true
+    });
+    if (!classification) {
+      continue;
+    }
+    if (classification.reason === "import error during collection") {
+      pendingGenericReason = classification;
+      continue;
+    }
+    const anchor = resolveAnchorForLabel({
+      label: currentLabel,
+      observedAnchor: currentAnchor
+    });
+    pushFocusedFailureItem(items, {
+      label: currentLabel,
+      reason: classification.reason,
+      group: classification.group,
+      ...anchor
+    });
+    currentLabel = null;
+    pendingGenericReason = null;
+    currentAnchor = null;
+  }
+  if (currentLabel && pendingGenericReason) {
+    const anchor = resolveAnchorForLabel({
+      label: currentLabel,
+      observedAnchor: currentAnchor
+    });
+    pushFocusedFailureItem(items, {
+      label: currentLabel,
+      reason: pendingGenericReason.reason,
+      group: pendingGenericReason.group,
+      ...anchor
+    });
+  }
+  return items;
+}
+function collectInlineFailureItems(input) {
+  const items = [];
+  for (const line of input.split("\n")) {
+    const inlineFailure = line.match(/^(FAILED|ERROR)\s+(.+?)\s+-\s+(.+)$/);
+    if (!inlineFailure) {
+      continue;
+    }
+    const cleanedLabel = cleanFailureLabel(inlineFailure[2]);
+    if (!cleanedLabel) {
+      continue;
+    }
+    const classification = classifyFailureReason(inlineFailure[3], {
+      duringCollection: false
+    });
+    if (!classification) {
+      continue;
+    }
+    pushFocusedFailureItem(items, {
+      label: cleanedLabel,
+      reason: classification.reason,
+      group: classification.group,
+      ...resolveAnchorForLabel({
+        label: cleanedLabel,
+        observedAnchor: parseObservedAnchor(inlineFailure[3])
+      })
+    });
+  }
+  return items;
+}
+function collectInlineFailureItemsWithStatus(input) {
+  const items = [];
+  for (const line of input.split("\n")) {
+    const inlineFailure = line.match(/^(FAILED|ERROR)\s+(.+?)(?:\s+-\s+(.+))?$/);
+    if (!inlineFailure) {
+      continue;
+    }
+    const cleanedLabel = cleanFailureLabel(inlineFailure[2]);
+    if (!cleanedLabel) {
+      continue;
+    }
+    const details = inlineFailure[3]?.trim();
+    if (!details) {
+      continue;
+    }
+    const classification = classifyFailureReason(details, {
+      duringCollection: false
+    });
+    if (!classification) {
+      continue;
+    }
+    items.push({
+      label: cleanedLabel,
+      reason: classification.reason,
+      group: classification.group,
+      status: inlineFailure[1] === "FAILED" ? "failed" : "error",
+      ...resolveAnchorForLabel({
+        label: cleanedLabel,
+        observedAnchor: parseObservedAnchor(details)
+      })
+    });
+  }
+  return items;
+}
+function collectStandaloneErrorClassifications(input) {
+  const classifications = [];
+  for (const line of input.split("\n")) {
+    const standalone = line.match(/^\s*E\s+(.+)$/);
+    if (!standalone) {
+      continue;
+    }
+    const classification = classifyFailureReason(standalone[1], {
+      duringCollection: false
+    });
+    if (!classification || classification.reason === "import error during collection") {
+      continue;
+    }
+    classifications.push(classification);
+  }
+  return classifications;
+}
+function chooseStrongestStatusFailureItems(items) {
+  const strongest = /* @__PURE__ */ new Map();
+  const order = [];
+  for (const item of items) {
+    const key = `${item.status}:${item.label}`;
+    const existing = strongest.get(key);
+    if (!existing) {
+      strongest.set(key, item);
+      order.push(key);
+      continue;
+    }
+    if (scoreFailureReason(item.reason) > scoreFailureReason(existing.reason)) {
+      strongest.set(key, item);
+    }
+  }
+  return order.map((key) => strongest.get(key));
+}
+function summarizeRepeatedTestCauses(input, options) {
+  const pythonMissingModules = collectUniqueMatches(
+    input,
+    /ModuleNotFoundError:\s+No module named ['"]([^'"]+)['"]/gi
+  );
+  const nodeMissingModules = collectUniqueMatches(
+    input,
+    /Cannot find module ['"]([^'"]+)['"]/gi
+  );
+  const missingModules = [...pythonMissingModules];
+  for (const moduleName of nodeMissingModules) {
+    if (!missingModules.includes(moduleName)) {
+      missingModules.push(moduleName);
+    }
+  }
+  const missingModuleHits = countPattern(
+    input,
+    /ModuleNotFoundError:\s+No module named ['"]([^'"]+)['"]/gi
+  ) + countPattern(input, /Cannot find module ['"]([^'"]+)['"]/gi);
+  const envBlockers = [];
+  let envBlockerHits = 0;
+  for (const line of input.split("\n")) {
+    const envBlocker = extractEnvBlockerName(line.trim().replace(/^[A-Z]\s+/, ""));
+    if (!envBlocker) {
+      continue;
+    }
+    envBlockerHits += 1;
+    if (!envBlockers.includes(envBlocker) && envBlockers.length < 4) {
+      envBlockers.push(envBlocker);
+    }
+  }
+  const importCollectionHits = countPattern(input, /ImportError while importing test module/gi) + countPattern(input, /^\s*_+\s+ERROR collecting\b/gim);
+  const genericErrorTypes = collectUniqueMatches(
+    input,
+    /\b((?:Assertion|Import|Type|Value|Runtime|Reference|Key|Attribute)[A-Za-z]*Error)\b/gi,
+    4
+  );
+  const bullets = [];
+  if (envBlockers.length > 0 && envBlockerHits >= 2) {
+    bullets.push(`- Shared test environment blocker detected: ${envBlockers.join(", ")}.`);
+  }
+  if (bullets.length < 2 && (options.duringCollection && (importCollectionHits >= 2 || missingModuleHits >= 2) || !options.duringCollection && missingModuleHits >= 2)) {
+    bullets.push(
+      options.duringCollection ? "- Most failures are import/dependency errors during test collection." : "- Most failures are import/dependency errors."
+    );
+  }
+  if (bullets.length < 2) {
+    if (missingModules.length > 1) {
+      bullets.push(`- Missing modules include ${missingModules.join(", ")}.`);
+    } else if (missingModules.length === 1 && missingModuleHits >= 2) {
+      bullets.push(`- Missing module repeated across failures: ${missingModules[0]}.`);
+    }
+  }
+  if (bullets.length < 2 && genericErrorTypes.length >= 2) {
+    bullets.push(`- Repeated error types include ${genericErrorTypes.join(", ")}.`);
+  }
+  return bullets.slice(0, 2);
+}
+function collectFailureLabels(input) {
+  const labels = [];
+  const seen = /* @__PURE__ */ new Set();
+  const pushLabel = (label, status) => {
+    const cleaned = cleanFailureLabel(label);
+    if (!cleaned) {
+      return;
+    }
+    const key = `${status}:${cleaned}`;
+    if (seen.has(key)) {
+      return;
+    }
+    seen.add(key);
+    labels.push({
+      label: cleaned,
+      status
+    });
+  };
+  for (const line of input.split("\n")) {
+    const progress = line.match(
+      /^(tests\/.+?)(?:\s+<-\s+\S+)?\s+(FAILED|ERROR)\s+\[[^\]]+\]\s*$/
+    );
+    if (progress) {
+      pushLabel(progress[1], progress[2] === "FAILED" ? "failed" : "error");
+      continue;
+    }
+    const summary = line.match(/^(FAILED|ERROR)\s+(.+?)(?:\s+-\s+.*)?$/);
+    if (summary) {
+      pushLabel(summary[2], summary[1] === "FAILED" ? "failed" : "error");
+    }
+  }
+  return labels;
+}
+function classifyBucketTypeFromReason(reason) {
+  if (reason.startsWith("missing test env:")) {
+    return "shared_environment_blocker";
+  }
+  if (reason.startsWith("fixture guard:")) {
+    return "fixture_guard_failure";
+  }
+  if (reason.startsWith("service unavailable:")) {
+    return "service_unavailable";
+  }
+  if (reason.startsWith("db refused:")) {
+    return "db_connection_failure";
+  }
+  if (reason.startsWith("auth bypass absent:")) {
+    return "auth_bypass_absent";
+  }
+  if (reason.startsWith("missing module:")) {
+    return "import_dependency_failure";
+  }
+  if (reason.startsWith("assertion failed:")) {
+    return "assertion_failure";
+  }
+  if (/^RuntimeError:|^[A-Z][A-Za-z]+(?:Error|Exception):/.test(reason)) {
+    return "runtime_failure";
+  }
+  return "unknown_failure";
+}
+function synthesizeSharedBlockerBucket(args) {
+  if (args.errors === 0) {
+    return null;
+  }
+  const visibleReasonGroups = /* @__PURE__ */ new Map();
+  for (const item of args.visibleErrorItems) {
+    const entry = visibleReasonGroups.get(item.reason);
+    if (entry) {
+      entry.count += 1;
+      entry.items.push(item);
+      continue;
+    }
+    visibleReasonGroups.set(item.reason, {
+      count: 1,
+      group: item.group,
+      items: [item]
+    });
+  }
+  const top = [...visibleReasonGroups.entries()].filter(([, entry]) => entry.count >= 3).sort((left, right) => right[1].count - left[1].count)[0];
+  const standaloneReasonGroups = /* @__PURE__ */ new Map();
+  for (const classification of collectStandaloneErrorClassifications(args.input)) {
+    const entry = standaloneReasonGroups.get(classification.reason);
+    if (entry) {
+      entry.count += 1;
+      continue;
+    }
+    standaloneReasonGroups.set(classification.reason, {
+      count: 1,
+      group: classification.group
+    });
+  }
+  const standaloneTop = [...standaloneReasonGroups.entries()].filter(([, entry]) => entry.count >= 3).sort((left, right) => right[1].count - left[1].count)[0];
+  const visibleTopReason = top?.[0];
+  const visibleTopStats = top?.[1];
+  const standaloneTopReason = standaloneTop?.[0];
+  const chosenReason = visibleTopReason && standaloneTopReason ? standaloneReasonGroups.get(standaloneTopReason).count > visibleTopStats.count ? standaloneTopReason : visibleTopReason : visibleTopReason ?? standaloneTopReason;
+  const singleEnvBlockerItem = !chosenReason && args.visibleErrorItems.length === 1 && args.visibleErrorItems[0].reason.startsWith("missing test env:") ? args.visibleErrorItems[0] : null;
+  const effectiveReason = chosenReason ?? singleEnvBlockerItem?.reason;
+  if (!effectiveReason || effectiveReason === "import error during collection") {
+    return null;
+  }
+  const visibleStats = visibleReasonGroups.get(effectiveReason);
+  const standaloneStats = standaloneReasonGroups.get(effectiveReason);
+  const resolvedStats = visibleStats ?? standaloneStats;
+  const bucketType = classifyBucketTypeFromReason(effectiveReason);
+  const countVisible = resolvedStats.count;
+  const visibleReasonsAreUniform = args.visibleErrorItems.length === 0 || args.visibleErrorItems.every((item) => item.reason === effectiveReason);
+  const canClaimAllErrors = (args.errorStatusLabels.length >= 3 || Boolean(singleEnvBlockerItem)) && visibleReasonsAreUniform && args.errors >= countVisible;
+  const countClaimed = canClaimAllErrors ? args.errors : void 0;
+  const countText = countClaimed ?? countVisible;
+  const atLeastPrefix = countClaimed ? "" : "At least ";
+  const group = resolvedStats.group;
+  const representativeItems = visibleStats?.items.slice(0, 4).map((item) => ({
+    label: item.label,
+    reason: effectiveReason,
+    group,
+    file: item.file,
+    line: item.line,
+    anchor_kind: item.anchor_kind,
+    anchor_confidence: item.anchor_confidence
+  })) ?? args.errorStatusLabels.slice(0, 4).map((label) => ({
+    label,
+    reason: effectiveReason,
+    group,
+    ...buildLabelAnchor(label)
+  }));
+  const envVar = effectiveReason.match(/^missing test env:\s+([A-Z][A-Z0-9_]{2,})$/)?.[1];
+  let hint;
+  if (envVar) {
+    hint = `Set ${envVar} (or pass --pgtest-dsn) before rerunning DB-isolated tests.`;
+  } else if (effectiveReason.startsWith("fixture guard:")) {
+    hint = "Unblock the required fixture or setup guard before rerunning the affected tests.";
+  } else if (effectiveReason.startsWith("db refused:")) {
+    hint = "Start the expected test database or fix the DSN before rerunning DB-backed tests.";
+  } else if (effectiveReason.startsWith("service unavailable:")) {
+    hint = "Restore the unavailable service dependency before rerunning the affected tests.";
+  } else if (effectiveReason.startsWith("auth bypass absent:")) {
+    hint = "Configure the expected auth bypass or test auth fixture before rerunning the affected tests.";
+  } else if (effectiveReason.startsWith("missing module:")) {
+    hint = "Install the missing dependency and rerun the affected tests.";
+  }
+  let headline;
+  if (envVar) {
+    headline = `Shared blocker: ${atLeastPrefix}${countText} errors require ${envVar} for DB-isolated tests.`;
+  } else if (effectiveReason.startsWith("fixture guard:")) {
+    headline = `Shared blocker: ${atLeastPrefix}${countText} errors are gated by the same fixture/setup guard.`;
+  } else if (effectiveReason.startsWith("db refused:")) {
+    headline = `Shared blocker: ${atLeastPrefix}${countText} errors are caused by refused database connections.`;
+  } else if (effectiveReason.startsWith("service unavailable:")) {
+    headline = `Shared blocker: ${atLeastPrefix}${countText} errors are caused by an unavailable service dependency.`;
+  } else if (effectiveReason.startsWith("auth bypass absent:")) {
+    headline = `Shared blocker: ${atLeastPrefix}${countText} errors are caused by missing auth bypass setup.`;
+  } else if (effectiveReason.startsWith("missing module:")) {
+    const moduleName = effectiveReason.replace("missing module:", "").trim();
+    headline = `Shared blocker: ${atLeastPrefix}${countText} errors are caused by missing module ${moduleName}.`;
+  } else {
+    headline = `Shared blocker: ${atLeastPrefix}${countText} errors share ${effectiveReason}.`;
+  }
+  return {
+    type: bucketType,
+    headline,
+    countVisible,
+    countClaimed,
+    reason: effectiveReason,
+    representativeItems,
+    entities: envVar ? [envVar] : [],
+    hint,
+    confidence: countClaimed ? 0.95 : 0.75,
+    summaryLines: [headline],
+    overflowCount: Math.max((countClaimed ?? countVisible) - representativeItems.length, 0),
+    overflowLabel: "failing tests/modules"
+  };
+}
+function synthesizeImportDependencyBucket(args) {
+  if (args.errors === 0) {
+    return null;
+  }
+  const importItems = args.visibleErrorItems.filter((item) => item.reason.startsWith("missing module:"));
+  if (importItems.length < 2) {
+    return null;
+  }
+  const allVisibleErrorsAreImportRelated = args.visibleErrorItems.length > 0 && args.visibleErrorItems.every((item) => item.reason.startsWith("missing module:"));
+  const countClaimed = allVisibleErrorsAreImportRelated && importItems.length >= 3 && args.errors >= importItems.length ? args.errors : void 0;
+  const modules = Array.from(
+    new Set(
+      importItems.map((item) => item.reason.replace("missing module:", "").trim()).filter(Boolean)
+    )
+  ).slice(0, 6);
+  const headlineCount = countClaimed ?? importItems.length;
+  const headline = countClaimed ? `Import/dependency blocker: ${headlineCount} errors are caused by missing dependencies during test collection.` : `Import/dependency blocker: at least ${headlineCount} visible errors are caused by missing dependencies during test collection.`;
+  const summaryLines = [headline];
+  if (modules.length > 0) {
+    summaryLines.push(`Missing modules include ${modules.join(", ")}.`);
+  }
+  return {
+    type: "import_dependency_failure",
+    headline,
+    countVisible: importItems.length,
+    countClaimed,
+    reason: "missing dependencies during test collection",
+    representativeItems: importItems.slice(0, 4).map((item) => ({
+      label: item.label,
+      reason: item.reason,
+      group: item.group,
+      file: item.file,
+      line: item.line,
+      anchor_kind: item.anchor_kind,
+      anchor_confidence: item.anchor_confidence
+    })),
+    entities: modules,
+    hint: modules.length === 1 ? `Install ${modules[0]} and rerun the affected tests.` : "Install the missing dependencies and rerun the affected tests.",
+    confidence: countClaimed ? 0.95 : 0.8,
+    summaryLines,
+    overflowCount: Math.max((countClaimed ?? importItems.length) - Math.min(importItems.length, 4), 0),
+    overflowLabel: "failing tests/modules"
+  };
+}
+function isContractDriftLabel(label) {
+  return /(freeze|snapshot|contract|manifest|openapi)/i.test(label);
+}
+function looksLikeTaskKey(value) {
+  return /^[a-z]+(?:_[a-z0-9]+)+$/i.test(value) && !value.startsWith("/api/");
+}
+function looksLikeModelId(value) {
+  return !value.startsWith("/api/") && /^[a-z0-9][a-z0-9._/-]*-[a-z0-9._-]+$/i.test(value);
+}
+function extractContractDriftEntities(input) {
+  const apiPaths = [];
+  const taskKeys = [];
+  const modelIds = [];
+  const snapshotKeys = [];
+  for (const line of input.split("\n")) {
+    const diffPathMatch = line.match(/^\s*(?:E\s+)?[+-]\s+'(\/api\/[^']+)'/);
+    if (diffPathMatch) {
+      const candidatePath = diffPathMatch[1].trim();
+      if (candidatePath && !apiPaths.includes(candidatePath) && apiPaths.length < 6) {
+        apiPaths.push(candidatePath);
+      }
+    }
+    const diffMatch = line.match(/^\s*(?:E\s+)?[+-]\s+'([^']+)'[,]?\s*$/);
+    if (!diffMatch) {
+      continue;
+    }
+    const candidate = diffMatch[1].trim();
+    if (!candidate) {
+      continue;
+    }
+    if (candidate.startsWith("/api/")) {
+      continue;
+    }
+    if (looksLikeModelId(candidate)) {
+      if (!modelIds.includes(candidate) && modelIds.length < 6) {
+        modelIds.push(candidate);
+      }
+      continue;
+    }
+    if (looksLikeTaskKey(candidate)) {
+      if (!taskKeys.includes(candidate) && taskKeys.length < 6) {
+        taskKeys.push(candidate);
+      }
+      continue;
+    }
+    if (!snapshotKeys.includes(candidate) && snapshotKeys.length < 6) {
+      snapshotKeys.push(candidate);
+    }
+  }
+  if (apiPaths.length === 0) {
+    apiPaths.push(
+      ...collectUniqueMatches(input, /['"](\/api\/[A-Za-z0-9_./{}:-]+)['"]/g, 6)
+    );
+  }
+  return {
+    apiPaths,
+    modelIds,
+    taskKeys,
+    snapshotKeys
+  };
+}
+function buildContractRepresentativeReason(args) {
+  if (/openapi/i.test(args.label) && args.entities.apiPaths.length > 0) {
+    const nextPath = args.entities.apiPaths.find((path4) => !args.usedPaths.has(path4)) ?? args.entities.apiPaths[0];
+    args.usedPaths.add(nextPath);
+    return `added path: ${nextPath}`;
+  }
+  if (/(feature|task|manifest|snapshot)/i.test(args.label) && args.entities.modelIds.length > 0) {
+    const nextModel = args.entities.modelIds.find((modelId) => !args.usedModels.has(modelId)) ?? args.entities.modelIds[0];
+    args.usedModels.add(nextModel);
+    return `removed model: ${nextModel}`;
+  }
+  if (args.entities.snapshotKeys.length > 0) {
+    return `snapshot content changed: ${args.entities.snapshotKeys[0]}`;
+  }
+  return "snapshot content changed";
+}
+function synthesizeContractDriftBucket(args) {
+  const contractLabels = args.visibleFailedLabels.filter(isContractDriftLabel);
+  if (contractLabels.length === 0) {
+    return null;
+  }
+  const entities = extractContractDriftEntities(args.input);
+  const usedPaths = /* @__PURE__ */ new Set();
+  const usedModels = /* @__PURE__ */ new Set();
+  const representativeItems = contractLabels.slice(0, 4).map((label) => ({
+    label,
+    reason: buildContractRepresentativeReason({
+      label,
+      entities,
+      usedPaths,
+      usedModels
+    }),
+    group: "contract drift",
+    ...buildLabelAnchor(label)
+  }));
+  const summaryLines = [
+    `Contract drift: ${formatCount2(contractLabels.length, "freeze test")} ${contractLabels.length === 1 ? "is" : "are"} out of sync with current API/model state.`
+  ];
+  if (entities.apiPaths.length > 0 && entities.modelIds.length > 0) {
+    summaryLines.push(
+      `Contract drift includes ${formatCount2(entities.apiPaths.length, "added API path")} and removed model ids such as ${entities.modelIds.slice(0, 3).join(", ")}.`
+    );
+  } else if (entities.apiPaths.length > 0) {
+    summaryLines.push(
+      `OpenAPI drift includes ${formatCount2(entities.apiPaths.length, "added API path")}.`
+    );
+  } else if (entities.modelIds.length > 0) {
+    summaryLines.push(
+      `Snapshot drift includes removed model ids such as ${entities.modelIds.slice(0, 3).join(", ")}.`
+    );
+  }
+  const explicitCommand = args.input.match(/python\s+scripts\/update_contract_snapshots\.py/);
+  const hint = explicitCommand ? `If these changes are intentional, run ${explicitCommand[0]} and rerun the freeze tests.` : "If these API/model changes are intentional, regenerate the contract snapshots and rerun the freeze tests.";
+  return {
+    type: "contract_snapshot_drift",
+    headline: summaryLines[0],
+    countVisible: contractLabels.length,
+    countClaimed: contractLabels.length,
+    reason: "freeze snapshots are out of sync with current API/model state",
+    representativeItems,
+    entities: [...entities.apiPaths, ...entities.modelIds, ...entities.taskKeys, ...entities.snapshotKeys].slice(0, 6),
+    hint,
+    confidence: entities.apiPaths.length > 0 || entities.modelIds.length > 0 ? 0.95 : 0.7,
+    summaryLines,
+    overflowCount: Math.max(
+      [...entities.apiPaths, ...entities.modelIds, ...entities.taskKeys, ...entities.snapshotKeys].slice(0, 6).length - representativeItems.length,
+      0
+    ),
+    overflowLabel: "changed entities"
+  };
+}
+function analyzeTestStatus(input) {
+  const passed = getCount(input, "passed");
+  const failed = getCount(input, "failed");
+  const errors = Math.max(getCount(input, "errors"), getCount(input, "error"));
+  const skipped = getCount(input, "skipped");
+  const collectionErrors = input.match(/(\d+)\s+errors?\s+during collection/i);
+  const noTestsCollected = /\bcollected\s+0\s+items\b/i.test(input) || /\bno tests ran\b/i.test(input);
+  const interrupted = /\binterrupted\b/i.test(input) || /\bKeyboardInterrupt\b/i.test(input);
+  const collectionItems = chooseStrongestFailureItems(collectCollectionFailureItems(input));
+  const inlineItems = chooseStrongestFailureItems(collectInlineFailureItems(input));
+  const visibleErrorItems = chooseStrongestStatusFailureItems([
+    ...collectionItems.map((item) => ({
+      ...item,
+      status: "error"
+    })),
+    ...collectInlineFailureItemsWithStatus(input).filter((item) => item.status === "error")
+  ]);
+  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);
+  const buckets = [];
+  const sharedBlocker = synthesizeSharedBlockerBucket({
+    input,
+    errors,
+    visibleErrorItems,
+    errorStatusLabels: visibleErrorLabels
+  });
+  if (sharedBlocker) {
+    buckets.push(sharedBlocker);
+  }
+  if (!sharedBlocker) {
+    const importDependencyBucket = synthesizeImportDependencyBucket({
+      errors,
+      visibleErrorItems
+    });
+    if (importDependencyBucket) {
+      buckets.push(importDependencyBucket);
+    }
+  }
+  const contractDrift = synthesizeContractDriftBucket({
+    input,
+    visibleFailedLabels
+  });
+  if (contractDrift) {
+    buckets.push(contractDrift);
+  }
+  return {
+    passed,
+    failed,
+    errors,
+    skipped,
+    noTestsCollected,
+    interrupted,
+    collectionErrorCount: collectionErrors ? Number(collectionErrors[1]) : void 0,
+    inlineItems,
+    collectionItems,
+    visibleErrorLabels,
+    visibleFailedLabels,
+    visibleErrorItems,
+    buckets
+  };
+}
+function testStatusHeuristic(input, detail = "standard") {
+  const normalized = input.trim();
+  if (normalized === "") {
+    return null;
+  }
+  const analysis = analyzeTestStatus(input);
+  if (analysis.collectionErrorCount) {
+    if (analysis.collectionItems.length > 0 || analysis.buckets.length > 0) {
+      const decision = buildTestStatusDiagnoseContract({
+        input,
+        analysis
+      });
+      if (detail === "verbose") {
+        return decision.verboseText;
+      }
+      if (detail === "focused") {
+        return decision.focusedText;
+      }
+      return decision.standardText;
+    }
+    return [
+      "- Tests did not complete.",
+      `- ${formatCount2(analysis.collectionErrorCount, "error")} occurred during collection.`,
+      ...summarizeRepeatedTestCauses(input, {
+        duringCollection: true
+      })
+    ].join("\n");
+  }
+  if (analysis.noTestsCollected) {
+    return ["- Tests did not run.", "- Collected 0 items."].join("\n");
+  }
+  if (analysis.interrupted && analysis.failed === 0 && analysis.errors === 0) {
+    return "- Test run was interrupted.";
+  }
+  if (analysis.failed === 0 && analysis.errors === 0 && analysis.passed > 0) {
+    const details = [formatCount2(analysis.passed, "test")];
+    if (analysis.skipped > 0) {
+      details.push(formatCount2(analysis.skipped, "skip"));
+    }
+    return ["- Tests passed.", `- ${details.join(", ")}.`].join("\n");
+  }
+  if (analysis.failed > 0 || analysis.errors > 0 || analysis.inlineItems.length > 0 || analysis.buckets.length > 0) {
+    const decision = buildTestStatusDiagnoseContract({
+      input,
+      analysis
+    });
+    if (detail === "verbose") {
+      return decision.verboseText;
+    }
+    if (detail === "focused") {
+      return decision.focusedText;
+    }
+    return decision.standardText;
+  }
+  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 pkg = inferPackage(line);
+    if (!pkg) {
+      return null;
+    }
+    return {
+      package: pkg,
+      severity: inferSeverity(line),
+      remediation: inferRemediation(pkg)
+    };
+  }).filter((item) => item !== null);
+  if (vulnerabilities.length === 0) {
+    return null;
+  }
+  const firstVulnerability = vulnerabilities[0];
+  return JSON.stringify(
+    {
+      status: "ok",
+      vulnerabilities,
+      summary: vulnerabilities.length === 1 ? `One ${firstVulnerability.severity} vulnerability found in ${firstVulnerability.package}.` : `${vulnerabilities.length} high or critical vulnerabilities found in the provided input.`
+    },
+    null,
+    2
+  );
+}
+function infraRiskHeuristic(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);
+  if (riskEvidence.length > 0) {
+    return JSON.stringify(
+      {
+        verdict: "fail",
+        reason: "Destructive or clearly risky infrastructure change signals are present.",
+        evidence: riskEvidence
+      },
+      null,
+      2
+    );
+  }
+  if (zeroDestructiveEvidence.length > 0) {
+    return JSON.stringify(
+      {
+        verdict: "pass",
+        reason: "The provided input explicitly indicates zero destructive changes.",
+        evidence: zeroDestructiveEvidence
+      },
+      null,
+      2
+    );
+  }
+  const safeEvidence = collectEvidence(input, SAFE_LINE_PATTERN);
+  if (safeEvidence.length > 0) {
+    return JSON.stringify(
+      {
+        verdict: "pass",
+        reason: "The provided input explicitly indicates no risky infrastructure changes.",
+        evidence: safeEvidence
+      },
+      null,
+      2
+    );
+  }
+  return null;
+}
+function applyHeuristicPolicy(policyName, input, detail) {
+  if (!policyName) {
     return null;
   }
-}
-function supportsFailOnPreset(presetName) {
-  return typeof presetName === "string" && FAIL_ON_SUPPORTED_PRESETS.has(presetName);
-}
-function evaluateGate(args) {
-  const parsed = parseJson(args.output);
-  if (!parsed || typeof parsed !== "object") {
-    return { shouldFail: false };
+  if (policyName === "audit-critical") {
+    return auditCriticalHeuristic(input);
   }
-  if (args.presetName === "infra-risk") {
-    return {
-      shouldFail: parsed["verdict"] === "fail"
-    };
+  if (policyName === "infra-risk") {
+    return infraRiskHeuristic(input);
   }
-  if (args.presetName === "audit-critical") {
-    const status = parsed["status"];
-    const vulnerabilities = parsed["vulnerabilities"];
-    return {
-      shouldFail: status === "ok" && Array.isArray(vulnerabilities) && vulnerabilities.length > 0
-    };
+  if (policyName === "test-status") {
+    return testStatusHeuristic(input, detail);
   }
-  return { shouldFail: false };
+  return null;
+}
+
+// src/core/insufficient.ts
+function isInsufficientSignalOutput(output) {
+  const trimmed = output.trim();
+  return trimmed === INSUFFICIENT_SIGNAL_TEXT || trimmed.startsWith(`${INSUFFICIENT_SIGNAL_TEXT}
+Hint:`);
+}
+function buildInsufficientSignalOutput(input) {
+  let hint;
+  if (input.originalLength === 0) {
+    hint = "Hint: no command output was captured.";
+  } else if (input.truncatedApplied) {
+    hint = "Hint: captured output was truncated before a clear summary was found.";
+  } else if (input.presetName === "test-status" && input.exitCode === 0) {
+    hint = "Hint: command succeeded, but no recognizable test summary was found.";
+  } else if (input.presetName === "test-status" && typeof input.exitCode === "number") {
+    hint = "Hint: command failed, but the captured output did not include a recognizable test summary.";
+  } else {
+    hint = "Hint: the captured output did not contain a clear answer for this preset.";
+  }
+  return `${INSUFFICIENT_SIGNAL_TEXT}
+${hint}`;
 }
 
 // src/core/run.ts
@@ -130,7 +2170,7 @@ var OpenAIProvider = class {
       if (!text) {
         throw new Error("Provider returned an empty response");
       }
-      return {
+      const result = {
         text,
         usage: data?.usage ? {
           inputTokens: data.usage.input_tokens,
@@ -139,13 +2179,14 @@ var OpenAIProvider = class {
         } : void 0,
         raw: data
       };
+      clearTimeout(timeout);
+      return result;
     } catch (error) {
+      clearTimeout(timeout);
       if (error.name === "AbortError") {
         throw new Error("Provider request timed out");
       }
       throw error;
-    } finally {
-      clearTimeout(timeout);
     }
   }
 };
@@ -227,7 +2268,7 @@ var OpenAICompatibleProvider = class {
       if (!text.trim()) {
         throw new Error("Provider returned an empty response");
       }
-      return {
+      const result = {
         text,
         usage: data?.usage ? {
           inputTokens: data.usage.prompt_tokens,
@@ -236,13 +2277,14 @@ var OpenAICompatibleProvider = class {
         } : void 0,
         raw: data
       };
+      clearTimeout(timeout);
+      return result;
     } catch (error) {
+      clearTimeout(timeout);
       if (error.name === "AbortError") {
         throw new Error("Provider request timed out");
       }
       throw error;
-    } finally {
-      clearTimeout(timeout);
     }
   }
 };
@@ -423,6 +2465,29 @@ var BUILT_IN_POLICIES = {
   }
 };
 function resolvePromptPolicy(args) {
+  if (args.policyName === "test-status" && args.goal === "diagnose") {
+    return {
+      name: "test-status",
+      responseMode: args.format === "json" ? "json" : "text",
+      outputContract: args.format === "json" ? args.outputContract ?? TEST_STATUS_DIAGNOSE_JSON_CONTRACT : void 0,
+      sharedRules: SHARED_RULES,
+      taskRules: args.format === "json" ? [
+        "Return only valid JSON.",
+        `Use this exact contract: ${args.outputContract ?? TEST_STATUS_DIAGNOSE_JSON_CONTRACT}.`,
+        "Treat the heuristic context as extraction guidance, but do not invent hidden failures.",
+        "Use the heuristic extract as the bucket truth unless the visible command output clearly disproves it.",
+        "Identify the dominant blocker, remaining visible failure buckets, the decision, and the next best action.",
+        "Set diagnosis_complete to true only when the visible output is already sufficient to stop and act.",
+        "Set raw_needed to true only when exact traceback lines are still required.",
+        "Set provider_confidence to a number between 0 and 1, or null only when confidence cannot be estimated."
+      ] : [
+        "Produce a decision-complete diagnosis.",
+        "Name the main failure buckets, include counts and dominant root cause, and end with an explicit Decision line plus an explicit stop signal.",
+        "Prefer blocker-first ordering and keep evidence budget small.",
+        "Do not ask for more context."
+      ]
+    };
+  }
   if (args.policyName) {
     const policy = BUILT_IN_POLICIES[args.policyName];
     return {
@@ -444,17 +2509,35 @@ function resolvePromptPolicy(args) {
 function buildPrompt(args) {
   const policy = resolvePromptPolicy({
     format: args.format,
+    goal: args.goal,
     policyName: args.policyName,
     outputContract: args.outputContract
   });
+  const detailRules = args.policyName === "test-status" && args.detail === "focused" ? [
+    "Use a focused failure view.",
+    "When the output clearly maps failures to specific tests or modules, group them by dominant error type first.",
+    "Within each error group, prefer compact bullets in the form '- test-or-module -> dominant reason'.",
+    "Cap focused entries at 6 per error group and end with '- and N more failing modules' if more clear mappings are visible.",
+    "If per-test or per-module mapping is unclear, fall back to grouped root causes instead of guessing."
+  ] : args.policyName === "test-status" && args.detail === "verbose" ? [
+    "Use a verbose failure view.",
+    "When the output clearly maps failures to specific tests or modules, list each visible failing test or module on its own line in the form '- test-or-module -> normalized reason'.",
+    "Preserve the original file or module order when the mapping is visible.",
+    "Prefer concrete normalized reasons such as missing modules or assertion failures over traceback plumbing.",
+    "If per-test or per-module mapping is unclear, fall back to the focused grouped-cause view instead of guessing."
+  ] : [];
   const prompt = [
     "You are Sift, a CLI output reduction assistant for downstream agents and automation.",
     "Hard rules:",
     ...policy.sharedRules.map((rule) => `- ${rule}`),
     "",
+    `Goal: ${args.goal ?? "summarize"}`,
+    "",
     `Task policy: ${policy.name}`,
     ...policy.taskRules.map((rule) => `- ${rule}`),
+    ...detailRules.map((rule) => `- ${rule}`),
     ...policy.outputContract ? ["", `Output contract: ${policy.outputContract}`] : [],
+    ...args.analysisContext ? ["", "Visible heuristic context:", '"""', args.analysisContext, '"""'] : [],
     "",
     `Question: ${args.question}`,
     "",
@@ -523,7 +2606,10 @@ function buildStructuredError(reason) {
   return {
     status: "error",
     reason,
-    retriable: isRetriableReason(reason)
+    retriable: isRetriableReason(reason),
+    provider_failed: true,
+    raw_needed: true,
+    why_raw_needed: "Provider follow-up failed, so the reduced answer may still need exact raw evidence."
   };
 }
 function buildFallbackOutput(args) {
@@ -543,110 +2629,11 @@ function buildFallbackOutput(args) {
     return JSON.stringify(buildStructuredError(args.reason), null, 2);
   }
   const prefix = `Sift fallback triggered (${args.reason}).`;
+  const rawHint = "Raw may still be needed because provider follow-up failed.";
   if (!args.rawFallback) {
-    return prefix;
-  }
-  return [prefix, "", args.rawInput.slice(-RAW_FALLBACK_SLICE)].join("\n");
-}
-
-// src/core/heuristics.ts
-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;
-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);
-}
-function inferSeverity(token) {
-  return token.toLowerCase().includes("critical") ? "critical" : "high";
-}
-function inferPackage(line) {
-  const match = line.match(/^\s*([@a-z0-9._/-]+)\s*:/i);
-  return match?.[1] ?? null;
-}
-function inferRemediation(pkg) {
-  return `Upgrade ${pkg} to a patched version.`;
-}
-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 pkg = inferPackage(line);
-    if (!pkg) {
-      return null;
-    }
-    return {
-      package: pkg,
-      severity: inferSeverity(line),
-      remediation: inferRemediation(pkg)
-    };
-  }).filter((item) => item !== null);
-  if (vulnerabilities.length === 0) {
-    return null;
-  }
-  const firstVulnerability = vulnerabilities[0];
-  return JSON.stringify(
-    {
-      status: "ok",
-      vulnerabilities,
-      summary: vulnerabilities.length === 1 ? `One ${firstVulnerability.severity} vulnerability found in ${firstVulnerability.package}.` : `${vulnerabilities.length} high or critical vulnerabilities found in the provided input.`
-    },
-    null,
-    2
-  );
-}
-function infraRiskHeuristic(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);
-  if (riskEvidence.length > 0) {
-    return JSON.stringify(
-      {
-        verdict: "fail",
-        reason: "Destructive or clearly risky infrastructure change signals are present.",
-        evidence: riskEvidence
-      },
-      null,
-      2
-    );
-  }
-  if (zeroDestructiveEvidence.length > 0) {
-    return JSON.stringify(
-      {
-        verdict: "pass",
-        reason: "The provided input explicitly indicates zero destructive changes.",
-        evidence: zeroDestructiveEvidence
-      },
-      null,
-      2
-    );
-  }
-  const safeEvidence = collectEvidence(input, SAFE_LINE_PATTERN);
-  if (safeEvidence.length > 0) {
-    return JSON.stringify(
-      {
-        verdict: "pass",
-        reason: "The provided input explicitly indicates no risky infrastructure changes.",
-        evidence: safeEvidence
-      },
-      null,
-      2
-    );
-  }
-  return null;
-}
-function applyHeuristicPolicy(policyName, input) {
-  if (!policyName) {
-    return null;
+    return `${prefix} ${rawHint}`;
   }
-  if (policyName === "audit-critical") {
-    return auditCriticalHeuristic(input);
-  }
-  if (policyName === "infra-risk") {
-    return infraRiskHeuristic(input);
-  }
-  return null;
+  return [prefix, rawHint, "", args.rawInput.slice(-RAW_FALLBACK_SLICE)].join("\n");
 }
 
 // src/core/redact.ts
@@ -749,8 +2736,297 @@ function prepareInput(raw, config) {
   };
 }
 
+// src/core/rawSlice.ts
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function unique2(values) {
+  return [...new Set(values)];
+}
+function buildLineWindows(args) {
+  const selected = /* @__PURE__ */ new Set();
+  for (const index of args.indexes) {
+    for (let cursor = Math.max(0, index - args.radius); cursor <= Math.min(args.lines.length - 1, index + args.radius); cursor += 1) {
+      selected.add(cursor);
+      if (selected.size >= args.maxLines) {
+        break;
+      }
+    }
+    if (selected.size >= args.maxLines) {
+      break;
+    }
+  }
+  return [...selected].sort((left, right) => left - right).map((index) => args.lines[index]);
+}
+function collapseSelectedLines(args) {
+  if (args.lines.length === 0) {
+    return args.fallback();
+  }
+  const joined = unique2(args.lines).join("\n").trim();
+  if (joined.length === 0) {
+    return args.fallback();
+  }
+  if (joined.length <= args.maxInputChars) {
+    return joined;
+  }
+  return truncateInput(joined, {
+    maxInputChars: args.maxInputChars,
+    headChars: Math.min(Math.max(200, Math.floor(args.maxInputChars * 0.55)), args.maxInputChars),
+    tailChars: Math.min(Math.max(120, Math.floor(args.maxInputChars * 0.2)), args.maxInputChars)
+  }).text;
+}
+function collapseSelectedLineGroups(args) {
+  const selected = [];
+  const seen = /* @__PURE__ */ new Set();
+  const groups = args.groups.map(
+    (group) => group.map((line) => line.trimEnd()).filter((line) => line.length > 0)
+  );
+  const cursors = groups.map(() => 0);
+  let addedInPass = true;
+  while (addedInPass) {
+    addedInPass = false;
+    for (const [groupIndex, group] of groups.entries()) {
+      while (cursors[groupIndex] < group.length) {
+        const line = group[cursors[groupIndex]];
+        cursors[groupIndex] = cursors[groupIndex] + 1;
+        if (seen.has(line)) {
+          continue;
+        }
+        const candidate = [...selected, line].join("\n");
+        if (candidate.length > args.maxInputChars) {
+          break;
+        }
+        selected.push(line);
+        seen.add(line);
+        addedInPass = true;
+        break;
+      }
+    }
+  }
+  if (selected.length === 0) {
+    return args.fallback();
+  }
+  return selected.join("\n");
+}
+function buildHeadTailFallback(input, config) {
+  const fallback = truncateInput(input, {
+    maxInputChars: config.maxInputChars,
+    headChars: config.headChars,
+    tailChars: config.tailChars
+  });
+  return {
+    text: fallback.text,
+    strategy: "head_tail",
+    used: fallback.truncatedApplied
+  };
+}
+function findReadTargetIndexes(args) {
+  const escapedFile = escapeRegExp(args.file);
+  const exactPatterns = args.line === null ? [new RegExp(escapedFile)] : [
+    new RegExp(`${escapedFile}:${args.line}(?::\\d+)?`),
+    new RegExp(`File\\s+"${escapedFile}",\\s+line\\s+${args.line}\\b`),
+    new RegExp(`['"]${escapedFile}['"].*\\b${args.line}\\b`)
+  ];
+  const matches = args.lines.map(
+    (line, index) => exactPatterns.some((pattern) => pattern.test(line)) ? index : -1
+  ).filter((index) => index >= 0);
+  if (matches.length > 0) {
+    return matches;
+  }
+  if (args.contextHint.start_line !== null && args.contextHint.end_line !== null) {
+    const startLine = args.contextHint.start_line;
+    const endLine = args.contextHint.end_line;
+    const rangeMatches = args.lines.map((line, index) => {
+      const fileWithLine = line.match(/^([A-Za-z0-9_./-]+\.[A-Za-z0-9]+):(\d+)(?::\d+)?:\s+in\b/) ?? line.match(/^([^:\s][^:]*\.[A-Za-z0-9]+):(\d+)(?::\d+)?:\s+in\b/) ?? line.match(/^File\s+"([^"]+)",\s+line\s+(\d+)/);
+      if (!fileWithLine || !fileWithLine[1] || !fileWithLine[2]) {
+        return -1;
+      }
+      if (fileWithLine[1].replace(/\\/g, "/") !== args.file) {
+        return -1;
+      }
+      const lineNumber = Number(fileWithLine[2]);
+      return lineNumber >= startLine && lineNumber <= endLine ? index : -1;
+    }).filter((index) => index >= 0);
+    if (rangeMatches.length > 0) {
+      return rangeMatches;
+    }
+  }
+  if (args.line !== null) {
+    return [];
+  }
+  return args.lines.map((line, index) => line.includes(args.file) ? index : -1).filter((index) => index >= 0);
+}
+function findSearchHintIndexes(args) {
+  if (!args.searchHint) {
+    return [];
+  }
+  const pattern = new RegExp(escapeRegExp(args.searchHint), "i");
+  return args.lines.map((line, index) => pattern.test(line) ? index : -1).filter((index) => index >= 0);
+}
+function buildTracebackSlice(args) {
+  const lines = args.input.split("\n");
+  const indexes = lines.map(
+    (line, index) => /(traceback|^E\s|error\b|failed\b|exception\b|assertionerror\b|runtimeerror\b)/i.test(line) ? index : -1
+  ).filter((index) => index >= 0);
+  if (indexes.length === 0) {
+    return buildHeadTailFallback(args.input, args.config);
+  }
+  const text = collapseSelectedLines({
+    lines: buildLineWindows({
+      lines,
+      indexes,
+      radius: 3,
+      maxLines: 80
+    }),
+    maxInputChars: args.config.maxInputChars,
+    fallback: () => truncateInput(args.input, {
+      maxInputChars: args.config.maxInputChars,
+      headChars: args.config.headChars,
+      tailChars: args.config.tailChars
+    }).text
+  });
+  return {
+    text,
+    strategy: "traceback_window",
+    used: true
+  };
+}
+function buildTestStatusRawSlice(args) {
+  if (args.input.length <= args.config.maxInputChars) {
+    return {
+      text: args.input,
+      strategy: "none",
+      used: false
+    };
+  }
+  const lines = args.input.split("\n");
+  const summaryIndexes = lines.map(
+    (line, index) => /(=+.*(?:failed|errors?|passed|no tests ran|interrupted).*=+|\b\d+\s+failed\b|\b\d+\s+errors?\b)/i.test(
+      line
+    ) ? 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 indexes = lines.map(
+      (line, index) => bucketTerms.some((term) => new RegExp(escapeRegExp(term), "i").test(line)) ? index : -1
+    ).filter((index) => index >= 0);
+    return unique2([
+      ...indexes.map((index) => lines[index]).filter(Boolean),
+      ...buildLineWindows({
+        lines,
+        indexes,
+        radius: 2,
+        maxLines: 16
+      })
+    ]);
+  });
+  const targetGroups = args.contract.read_targets.map(
+    (target) => buildLineWindows({
+      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
+    })
+  );
+  const failureIndexes = lines.map((line, index) => /\b(FAILED|ERROR)\b/.test(line) || /^E\s/.test(line) ? index : -1).filter((index) => index >= 0);
+  const selected = collapseSelectedLineGroups({
+    groups: [
+      ...targetGroups,
+      unique2([
+        ...summaryIndexes.map((index) => lines[index]).filter(Boolean),
+        ...buildLineWindows({
+          lines,
+          indexes: summaryIndexes,
+          radius: 1,
+          maxLines: 12
+        })
+      ]),
+      ...bucketGroups,
+      buildLineWindows({
+        lines,
+        indexes: failureIndexes,
+        radius: 1,
+        maxLines: 24
+      })
+    ],
+    maxInputChars: args.config.maxInputChars,
+    fallback: () => truncateInput(args.input, {
+      maxInputChars: args.config.maxInputChars,
+      headChars: args.config.headChars,
+      tailChars: args.config.tailChars
+    }).text
+  });
+  if (selected.trim().length === 0) {
+    return buildTracebackSlice({
+      input: args.input,
+      config: args.config
+    });
+  }
+  return {
+    text: selected,
+    strategy: "bucket_evidence",
+    used: true
+  };
+}
+function buildGenericRawSlice(args) {
+  if (args.input.length <= args.config.maxInputChars) {
+    return {
+      text: args.input,
+      strategy: "none",
+      used: false
+    };
+  }
+  return buildTracebackSlice(args);
+}
+
 // src/core/run.ts
 var RETRY_DELAY_MS = 300;
+function estimateTokenCount(text) {
+  return Math.max(1, Math.ceil(text.length / 4));
+}
+function getDiagnosisCompleteAtLayer(contract) {
+  if (contract.raw_needed || contract.provider_failed) {
+    return "raw";
+  }
+  if (contract.provider_used) {
+    return "provider";
+  }
+  return "heuristic";
+}
+function logVerboseTestStatusTelemetry(args) {
+  if (!args.request.config.runtime.verbose) {
+    return;
+  }
+  const lines = [
+    `${pc.dim("sift")} diagnosis_complete_at_layer=${getDiagnosisCompleteAtLayer(args.contract)}`,
+    `${pc.dim("sift")} heuristic_short_circuit=${!args.contract.provider_used && args.contract.diagnosis_complete && !args.contract.raw_needed && !args.contract.provider_failed}`,
+    `${pc.dim("sift")} raw_input_chars=${args.request.stdin.length}`,
+    `${pc.dim("sift")} prepared_input_chars=${args.prepared.meta.finalLength}`,
+    `${pc.dim("sift")} raw_slice_chars=${args.rawSliceChars ?? 0}`,
+    `${pc.dim("sift")} provider_input_chars=${args.providerInputChars ?? 0}`,
+    `${pc.dim("sift")} provider_output_chars=${args.providerOutputChars ?? 0}`,
+    `${pc.dim("sift")} final_output_chars=${args.finalOutput.length}`,
+    `${pc.dim("sift")} final_output_tokens_est=${estimateTokenCount(args.finalOutput)}`,
+    `${pc.dim("sift")} read_targets_count=${args.contract.read_targets.length}`,
+    `${pc.dim("sift")} remaining_count=${args.contract.remaining_tests.length}`,
+    `${pc.dim("sift")} remaining_ids_exposed=${Boolean(args.request.includeTestIds)}`
+  ];
+  process.stderr.write(`${lines.join("\n")}
+`);
+}
 function normalizeOutput(text, responseMode) {
   if (responseMode !== "json") {
     return text.trim();
@@ -766,7 +3042,7 @@ function buildDryRunOutput(args) {
   return JSON.stringify(
     {
       status: "dry-run",
-      strategy: args.heuristicOutput ? "heuristic" : "provider",
+      strategy: args.strategy ?? (args.heuristicOutput ? "heuristic" : "provider"),
       provider: {
         name: args.providerName,
         model: args.request.config.provider.model,
@@ -775,6 +3051,7 @@ function buildDryRunOutput(args) {
       },
       question: args.request.question,
       format: args.request.format,
+      detail: args.request.detail ?? null,
       responseMode: args.responseMode,
       policy: args.request.policyName ?? null,
       heuristicOutput: args.heuristicOutput ?? null,
@@ -794,108 +3071,936 @@ function buildDryRunOutput(args) {
 async function delay(ms) {
   await new Promise((resolve) => setTimeout(resolve, ms));
 }
+function withInsufficientHint(args) {
+  if (!isInsufficientSignalOutput(args.output)) {
+    return args.output;
+  }
+  return buildInsufficientSignalOutput({
+    presetName: args.request.presetName,
+    originalLength: args.prepared.meta.originalLength,
+    truncatedApplied: args.prepared.meta.truncatedApplied
+  });
+}
 async function generateWithRetry(args) {
-  let lastError;
-  for (let attempt = 0; attempt < 2; attempt += 1) {
-    try {
-      return await args.provider.generate({
-        model: args.request.config.provider.model,
-        prompt: args.prompt,
-        temperature: args.request.config.provider.temperature,
-        maxOutputTokens: args.request.config.provider.maxOutputTokens,
-        timeoutMs: args.request.config.provider.timeoutMs,
-        responseMode: args.responseMode,
-        jsonResponseFormat: args.request.config.provider.jsonResponseFormat
-      });
-    } catch (error) {
-      lastError = error;
-      const reason = error instanceof Error ? error.message : "unknown_error";
-      if (attempt > 0 || !isRetriableReason(reason)) {
-        throw error;
-      }
-      if (args.request.config.runtime.verbose) {
-        process.stderr.write(
-          `${pc.dim("sift")} retry=1 reason=${reason} delay_ms=${RETRY_DELAY_MS}
+  const generate = () => args.provider.generate({
+    model: args.request.config.provider.model,
+    prompt: args.prompt,
+    temperature: args.request.config.provider.temperature,
+    maxOutputTokens: args.request.config.provider.maxOutputTokens,
+    timeoutMs: args.request.config.provider.timeoutMs,
+    responseMode: args.responseMode,
+    jsonResponseFormat: args.request.config.provider.jsonResponseFormat
+  });
+  try {
+    return await generate();
+  } catch (error) {
+    const reason = error instanceof Error ? error.message : "unknown_error";
+    if (!isRetriableReason(reason)) {
+      throw error;
+    }
+    if (args.request.config.runtime.verbose) {
+      process.stderr.write(
+        `${pc.dim("sift")} retry=1 reason=${reason} delay_ms=${RETRY_DELAY_MS}
 `
-        );
-      }
-      await delay(RETRY_DELAY_MS);
+      );
     }
+    await delay(RETRY_DELAY_MS);
+  }
+  return generate();
+}
+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 renderTestStatusDecisionOutput(args) {
+  if (args.request.goal === "diagnose" && args.request.format === "json") {
+    return JSON.stringify(
+      buildTestStatusPublicDiagnoseContract({
+        contract: args.decision.contract,
+        includeTestIds: args.request.includeTestIds,
+        remainingSubsetAvailable: args.request.testStatusContext?.remainingSubsetAvailable
+      }),
+      null,
+      2
+    );
+  }
+  if (args.request.detail === "verbose") {
+    return args.decision.verboseText;
   }
-  throw lastError instanceof Error ? lastError : new Error("unknown_error");
+  if (args.request.detail === "focused") {
+    return args.decision.focusedText;
+  }
+  return args.decision.standardText;
+}
+function buildTestStatusProviderFailureDecision(args) {
+  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,
+    contractOverrides: {
+      ...args.baseDecision.contract,
+      diagnosis_complete: false,
+      raw_needed: true,
+      additional_source_read_likely_low_value: false,
+      read_raw_only_if: shouldZoomFirst ? "the provider follow-up failed and one deeper sift pass still is not enough" : "the provider follow-up failed and you still need exact traceback lines",
+      decision: shouldZoomFirst ? "zoom" : "read_raw",
+      provider_used: true,
+      provider_confidence: null,
+      provider_failed: true,
+      raw_slice_used: args.rawSliceUsed,
+      raw_slice_strategy: args.rawSliceStrategy,
+      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.`
+      }
+    }
+  });
 }
 async function runSift(request) {
   const prepared = prepareInput(request.stdin, request.config.input);
-  const { prompt, responseMode } = buildPrompt({
-    question: request.question,
-    format: request.format,
-    input: prepared.truncated,
-    policyName: request.policyName,
-    outputContract: request.outputContract
-  });
   const provider = createProvider(request.config);
+  const hasTestStatusSignal = request.policyName === "test-status" && hasRecognizableTestStatusSignal(prepared.truncated);
+  const testStatusAnalysis = hasTestStatusSignal ? analyzeTestStatus(prepared.truncated) : null;
+  const testStatusDecision = hasTestStatusSignal && testStatusAnalysis ? buildTestStatusDiagnoseContract({
+    input: prepared.truncated,
+    analysis: testStatusAnalysis,
+    resolvedTests: request.testStatusContext?.resolvedTests,
+    remainingTests: request.testStatusContext?.remainingTests
+  }) : null;
+  const testStatusHeuristicOutput = testStatusDecision ? renderTestStatusDecisionOutput({
+    request,
+    decision: testStatusDecision
+  }) : null;
   if (request.config.runtime.verbose) {
     process.stderr.write(
       `${pc.dim("sift")} provider=${provider.name} model=${request.config.provider.model} base_url=${request.config.provider.baseUrl} input_chars=${prepared.meta.finalLength}
 `
     );
   }
-  const heuristicOutput = applyHeuristicPolicy(
-    request.policyName,
-    prepared.truncated
-  );
+  const heuristicOutput = request.policyName === "test-status" ? testStatusDecision?.contract.diagnosis_complete ? testStatusHeuristicOutput : null : applyHeuristicPolicy(request.policyName, prepared.truncated, request.detail);
   if (heuristicOutput) {
     if (request.config.runtime.verbose) {
       process.stderr.write(`${pc.dim("sift")} heuristic=${request.policyName}
 `);
     }
+    const heuristicPrompt = buildPrompt({
+      question: request.question,
+      format: request.format,
+      goal: request.goal,
+      input: prepared.truncated,
+      detail: request.detail,
+      policyName: request.policyName,
+      outputContract: request.policyName === "test-status" && request.goal === "diagnose" && request.format === "json" ? request.outputContract ?? TEST_STATUS_DIAGNOSE_JSON_CONTRACT : request.outputContract,
+      analysisContext: [
+        request.analysisContext,
+        testStatusDecision ? buildTestStatusAnalysisContext({
+          contract: testStatusDecision.contract,
+          includeTestIds: request.includeTestIds,
+          remainingSubsetAvailable: request.testStatusContext?.remainingSubsetAvailable
+        }) : void 0
+      ].filter((value) => Boolean(value)).join("\n\n")
+    });
+    if (request.dryRun) {
+      return buildDryRunOutput({
+        request,
+        providerName: provider.name,
+        prompt: heuristicPrompt.prompt,
+        responseMode: heuristicPrompt.responseMode,
+        prepared,
+        heuristicOutput,
+        strategy: "heuristic"
+      });
+    }
+    const finalOutput = withInsufficientHint({
+      output: heuristicOutput,
+      request,
+      prepared
+    });
+    if (testStatusDecision) {
+      logVerboseTestStatusTelemetry({
+        request,
+        prepared,
+        contract: testStatusDecision.contract,
+        finalOutput
+      });
+    }
+    return finalOutput;
+  }
+  if (testStatusDecision && testStatusAnalysis) {
+    const rawSlice = buildTestStatusRawSlice({
+      input: prepared.redacted,
+      config: request.config.input,
+      contract: testStatusDecision.contract
+    });
+    const prompt = buildPrompt({
+      question: "Complete the diagnosis. Use the heuristic extract as the bucket truth and only change the decision when the sliced command output proves it.",
+      format: "json",
+      goal: "diagnose",
+      input: rawSlice.text,
+      detail: request.detail,
+      policyName: "test-status",
+      outputContract: TEST_STATUS_PROVIDER_SUPPLEMENT_JSON_CONTRACT,
+      analysisContext: [
+        request.analysisContext,
+        buildTestStatusAnalysisContext({
+          contract: {
+            ...testStatusDecision.contract,
+            provider_used: true,
+            provider_failed: false,
+            raw_slice_used: rawSlice.used,
+            raw_slice_strategy: rawSlice.strategy
+          },
+          includeTestIds: request.includeTestIds,
+          remainingSubsetAvailable: request.testStatusContext?.remainingSubsetAvailable
+        })
+      ].filter((value) => Boolean(value)).join("\n\n")
+    });
+    const providerPrepared2 = {
+      ...prepared,
+      truncated: rawSlice.text,
+      meta: {
+        ...prepared.meta,
+        finalLength: rawSlice.text.length,
+        truncatedApplied: rawSlice.used || prepared.meta.truncatedApplied
+      }
+    };
     if (request.dryRun) {
       return buildDryRunOutput({
         request,
         providerName: provider.name,
-        prompt,
-        responseMode,
+        prompt: prompt.prompt,
+        responseMode: prompt.responseMode,
+        prepared: providerPrepared2,
+        heuristicOutput: testStatusHeuristicOutput,
+        strategy: "hybrid"
+      });
+    }
+    try {
+      const result = await generateWithRetry({
+        provider,
+        request,
+        prompt: prompt.prompt,
+        responseMode: prompt.responseMode
+      });
+      const supplement = parseTestStatusProviderSupplement(result.text);
+      const mergedDecision = buildTestStatusDiagnoseContract({
+        input: prepared.truncated,
+        analysis: testStatusAnalysis,
+        resolvedTests: request.testStatusContext?.resolvedTests,
+        remainingTests: request.testStatusContext?.remainingTests,
+        contractOverrides: {
+          diagnosis_complete: supplement.diagnosis_complete,
+          raw_needed: supplement.raw_needed,
+          additional_source_read_likely_low_value: supplement.additional_source_read_likely_low_value,
+          read_raw_only_if: supplement.read_raw_only_if,
+          decision: supplement.decision,
+          provider_used: true,
+          provider_confidence: supplement.provider_confidence,
+          provider_failed: false,
+          raw_slice_used: rawSlice.used,
+          raw_slice_strategy: rawSlice.strategy,
+          next_best_action: supplement.next_best_action
+        }
+      });
+      const finalOutput = renderTestStatusDecisionOutput({
+        request,
+        decision: mergedDecision
+      });
+      logVerboseTestStatusTelemetry({
+        request,
+        prepared,
+        contract: mergedDecision.contract,
+        finalOutput,
+        rawSliceChars: rawSlice.text.length,
+        providerInputChars: providerPrepared2.truncated.length,
+        providerOutputChars: result.text.length
+      });
+      return finalOutput;
+    } catch (error) {
+      const reason = error instanceof Error ? error.message : "unknown_error";
+      const failureDecision = buildTestStatusProviderFailureDecision({
+        request,
+        baseDecision: testStatusDecision,
+        input: prepared.truncated,
+        analysis: testStatusAnalysis,
+        reason,
+        rawSliceUsed: rawSlice.used,
+        rawSliceStrategy: rawSlice.strategy
+      });
+      const finalOutput = request.goal === "diagnose" && request.format === "json" ? JSON.stringify(
+        buildTestStatusPublicDiagnoseContract({
+          contract: failureDecision.contract,
+          includeTestIds: request.includeTestIds,
+          remainingSubsetAvailable: request.testStatusContext?.remainingSubsetAvailable
+        }),
+        null,
+        2
+      ) : renderTestStatusDecisionOutput({
+        request,
+        decision: failureDecision
+      });
+      logVerboseTestStatusTelemetry({
+        request,
         prepared,
-        heuristicOutput
+        contract: failureDecision.contract,
+        finalOutput,
+        rawSliceChars: rawSlice.text.length,
+        providerInputChars: providerPrepared2.truncated.length
       });
+      return finalOutput;
     }
-    return heuristicOutput;
   }
+  const genericRawSlice = buildGenericRawSlice({
+    input: prepared.redacted,
+    config: request.config.input
+  });
+  const providerPrompt = buildPrompt({
+    question: request.question,
+    format: request.format,
+    goal: request.goal,
+    input: genericRawSlice.text,
+    detail: request.detail,
+    policyName: request.policyName,
+    outputContract: request.outputContract,
+    analysisContext: request.analysisContext
+  });
+  const providerPrepared = {
+    ...prepared,
+    truncated: genericRawSlice.text,
+    meta: {
+      ...prepared.meta,
+      finalLength: genericRawSlice.text.length,
+      truncatedApplied: genericRawSlice.used || prepared.meta.truncatedApplied
+    }
+  };
   if (request.dryRun) {
     return buildDryRunOutput({
       request,
       providerName: provider.name,
-      prompt,
-      responseMode,
-      prepared,
-      heuristicOutput: null
+      prompt: providerPrompt.prompt,
+      responseMode: providerPrompt.responseMode,
+      prepared: providerPrepared,
+      heuristicOutput: testStatusDecision ? testStatusHeuristicOutput : null,
+      strategy: testStatusDecision ? "hybrid" : "provider"
     });
   }
   try {
     const result = await generateWithRetry({
       provider,
       request,
-      prompt,
-      responseMode
+      prompt: providerPrompt.prompt,
+      responseMode: providerPrompt.responseMode
     });
     if (looksLikeRejectedModelOutput({
-      source: prepared.truncated,
+      source: genericRawSlice.text,
       candidate: result.text,
-      responseMode
+      responseMode: providerPrompt.responseMode
     })) {
       throw new Error("Model output rejected by quality gate");
     }
-    return normalizeOutput(result.text, responseMode);
+    return withInsufficientHint({
+      output: normalizeOutput(result.text, providerPrompt.responseMode),
+      request,
+      prepared: providerPrepared
+    });
   } catch (error) {
     const reason = error instanceof Error ? error.message : "unknown_error";
-    return buildFallbackOutput({
-      format: request.format,
-      reason,
-      rawInput: prepared.truncated,
-      rawFallback: request.config.runtime.rawFallback,
-      jsonFallback: request.fallbackJson
+    return withInsufficientHint({
+      output: buildFallbackOutput({
+        format: request.format,
+        reason,
+        rawInput: providerPrepared.truncated,
+        rawFallback: request.config.runtime.rawFallback,
+        jsonFallback: request.fallbackJson
+      }),
+      request,
+      prepared: providerPrepared
+    });
+  }
+}
+
+// src/core/testStatusState.ts
+import fs from "fs";
+import path2 from "path";
+import { z as z2 } from "zod";
+var detailSchema = z2.enum(["standard", "focused", "verbose"]);
+var failureBucketTypeSchema = z2.enum([
+  "shared_environment_blocker",
+  "fixture_guard_failure",
+  "service_unavailable",
+  "db_connection_failure",
+  "auth_bypass_absent",
+  "contract_snapshot_drift",
+  "import_dependency_failure",
+  "collection_failure",
+  "assertion_failure",
+  "runtime_failure",
+  "interrupted_run",
+  "no_tests_collected",
+  "unknown_failure"
+]);
+var countSchema = z2.number().int().nonnegative();
+var cachedBucketSchema = z2.object({
+  type: failureBucketTypeSchema,
+  headline: z2.string(),
+  countVisible: countSchema,
+  countClaimed: countSchema.optional(),
+  reason: z2.string(),
+  entities: z2.array(z2.string())
+});
+var cachedAnalysisSchema = z2.object({
+  passed: countSchema,
+  failed: countSchema,
+  errors: countSchema,
+  skipped: countSchema,
+  noTestsCollected: z2.boolean(),
+  interrupted: z2.boolean(),
+  collectionErrorCount: countSchema.optional(),
+  buckets: z2.array(cachedBucketSchema)
+});
+var cachedCommandSchema = z2.discriminatedUnion("mode", [
+  z2.object({
+    mode: z2.literal("argv"),
+    argv: z2.array(z2.string()).min(1)
+  }),
+  z2.object({
+    mode: z2.literal("shell"),
+    shellCommand: z2.string().min(1)
+  })
+]).optional();
+var cachedPytestStateSchema = z2.object({
+  subsetCapable: z2.boolean(),
+  baseArgv: z2.array(z2.string()).min(1).optional(),
+  failingNodeIds: z2.array(z2.string()),
+  remainingNodeIds: z2.array(z2.string()).optional()
+}).optional();
+var cachedRunSchema = z2.object({
+  version: z2.literal(1),
+  timestamp: z2.string(),
+  presetName: z2.literal("test-status"),
+  cwd: z2.string(),
+  commandKey: z2.string(),
+  commandPreview: z2.string(),
+  command: cachedCommandSchema,
+  detail: detailSchema,
+  exitCode: z2.number().int(),
+  rawOutput: z2.string(),
+  capture: z2.object({
+    originalChars: countSchema,
+    truncatedApplied: z2.boolean()
+  }),
+  analysis: cachedAnalysisSchema,
+  pytest: cachedPytestStateSchema
+});
+var MissingCachedTestStatusRunError = class extends Error {
+  constructor() {
+    super(
+      "No cached test-status run found. Start with `sift exec --preset test-status -- <test command>`."
+    );
+  }
+};
+var InvalidCachedTestStatusRunError = class extends Error {
+  constructor() {
+    super(
+      "Cached test-status state is invalid. Run `sift exec --preset test-status -- <test command>` again."
+    );
+  }
+};
+function normalizeBucketReason(reason) {
+  return reason.trim().replace(/\s+/g, " ");
+}
+function getBucketCount(bucket) {
+  return bucket.countClaimed ?? bucket.countVisible;
+}
+function formatCount3(count, singular, plural = `${singular}s`) {
+  return `${count} ${count === 1 ? singular : plural}`;
+}
+function appendPreview(values) {
+  if (values.length === 0) {
+    return "";
+  }
+  const preview = values.slice(0, 2);
+  const overflowCount = values.length - preview.length;
+  const suffix = overflowCount > 0 ? `, and ${overflowCount} more` : "";
+  return ` (${preview.join(", ")}${suffix})`;
+}
+function buildBucketSignature(bucket) {
+  return JSON.stringify([
+    bucket.type,
+    [...bucket.entities].sort(),
+    normalizeBucketReason(bucket.reason)
+  ]);
+}
+function basenameMatches(value, matcher) {
+  return matcher.test(path2.basename(value));
+}
+function isPytestExecutable(value) {
+  return basenameMatches(value, /^pytest(?:\.exe)?$/i);
+}
+function isPythonExecutable(value) {
+  return basenameMatches(value, /^python(?:\d+(?:\.\d+)*)?(?:\.exe)?$/i);
+}
+var shortPytestOptionsWithValue = /* @__PURE__ */ new Set([
+  "-c",
+  "-k",
+  "-m",
+  "-n",
+  "-o",
+  "-p",
+  "-W"
+]);
+var longPytestOptionsWithValue = /* @__PURE__ */ new Set([
+  "--asyncio-mode",
+  "--basetemp",
+  "--capture",
+  "--color",
+  "--confcutdir",
+  "--cov",
+  "--cov-config",
+  "--cov-report",
+  "--deselect",
+  "--durations",
+  "--durations-min",
+  "--ignore",
+  "--ignore-glob",
+  "--import-mode",
+  "--junitxml",
+  "--log-cli-level",
+  "--log-date-format",
+  "--log-file",
+  "--log-file-level",
+  "--log-format",
+  "--log-level",
+  "--maxfail",
+  "--override-ini",
+  "--pyargs",
+  "--rootdir",
+  "--tb"
+]);
+function isSubsetCapablePytestArgv(argv) {
+  let offset = -1;
+  if (argv.length > 0 && isPytestExecutable(argv[0])) {
+    offset = 1;
+  } else if (argv.length > 2 && isPythonExecutable(argv[0]) && argv[1] === "-m" && argv[2] === "pytest") {
+    offset = 3;
+  }
+  if (offset === -1) {
+    return false;
+  }
+  for (let index = offset; index < argv.length; index += 1) {
+    const arg = argv[index];
+    if (arg === "--") {
+      return false;
+    }
+    if (!arg.startsWith("-")) {
+      return false;
+    }
+    if (arg.startsWith("--")) {
+      if (arg.includes("=")) {
+        continue;
+      }
+      if (longPytestOptionsWithValue.has(arg)) {
+        index += 1;
+        if (index >= argv.length) {
+          return false;
+        }
+      }
+      continue;
+    }
+    const shortOption = arg.slice(0, 2);
+    if (shortPytestOptionsWithValue.has(shortOption)) {
+      if (arg.length === 2) {
+        index += 1;
+        if (index >= argv.length) {
+          return false;
+        }
+      }
+    }
+  }
+  return true;
+}
+function buildCachedCommand(args) {
+  if (Array.isArray(args.command) && args.command.length > 0) {
+    return {
+      mode: "argv",
+      argv: [...args.command]
+    };
+  }
+  if (typeof args.shellCommand === "string" && args.shellCommand.length > 0) {
+    return {
+      mode: "shell",
+      shellCommand: args.shellCommand
+    };
+  }
+  return void 0;
+}
+function buildFailingNodeIds(analysis) {
+  const values = [];
+  for (const value of [...analysis.visibleErrorLabels, ...analysis.visibleFailedLabels]) {
+    if (value.length > 0 && !values.includes(value)) {
+      values.push(value);
+    }
+  }
+  return values;
+}
+function buildCachedPytestState(args) {
+  const baseArgv = args.command?.mode === "argv" && isSubsetCapablePytestArgv(args.command.argv) ? [...args.command.argv] : void 0;
+  return {
+    subsetCapable: Boolean(baseArgv),
+    baseArgv,
+    failingNodeIds: buildFailingNodeIds(args.analysis),
+    remainingNodeIds: args.remainingNodeIds
+  };
+}
+function buildTestStatusCommandKey(args) {
+  return `${args.shellCommand ? "shell" : "argv"}:${args.commandPreview}`;
+}
+function snapshotTestStatusAnalysis(analysis) {
+  return {
+    passed: analysis.passed,
+    failed: analysis.failed,
+    errors: analysis.errors,
+    skipped: analysis.skipped,
+    noTestsCollected: analysis.noTestsCollected,
+    interrupted: analysis.interrupted,
+    collectionErrorCount: analysis.collectionErrorCount,
+    buckets: analysis.buckets.map((bucket) => ({
+      type: bucket.type,
+      headline: bucket.headline,
+      countVisible: bucket.countVisible,
+      countClaimed: bucket.countClaimed,
+      reason: bucket.reason,
+      entities: [...bucket.entities]
+    }))
+  };
+}
+function createCachedTestStatusRun(args) {
+  const command = buildCachedCommand({
+    command: args.command,
+    shellCommand: args.shellCommand
+  });
+  return {
+    version: 1,
+    timestamp: args.timestamp ?? (/* @__PURE__ */ new Date()).toISOString(),
+    presetName: "test-status",
+    cwd: args.cwd,
+    commandKey: args.commandKey,
+    commandPreview: args.commandPreview,
+    command,
+    detail: args.detail,
+    exitCode: args.exitCode,
+    rawOutput: args.rawOutput,
+    capture: {
+      originalChars: args.originalChars,
+      truncatedApplied: args.truncatedApplied
+    },
+    analysis: snapshotTestStatusAnalysis(args.analysis),
+    pytest: buildCachedPytestState({
+      command,
+      analysis: args.analysis,
+      remainingNodeIds: args.remainingNodeIds
+    })
+  };
+}
+function readCachedTestStatusRun(statePath = getDefaultTestStatusStatePath()) {
+  let raw = "";
+  try {
+    raw = fs.readFileSync(statePath, "utf8");
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      throw new MissingCachedTestStatusRunError();
+    }
+    throw new InvalidCachedTestStatusRunError();
+  }
+  try {
+    return cachedRunSchema.parse(JSON.parse(raw));
+  } catch {
+    throw new InvalidCachedTestStatusRunError();
+  }
+}
+function tryReadCachedTestStatusRun(statePath = getDefaultTestStatusStatePath()) {
+  try {
+    return readCachedTestStatusRun(statePath);
+  } catch {
+    return null;
+  }
+}
+function writeCachedTestStatusRun(state, statePath = getDefaultTestStatusStatePath()) {
+  fs.mkdirSync(path2.dirname(statePath), {
+    recursive: true
+  });
+  fs.writeFileSync(statePath, `${JSON.stringify(state, null, 2)}
+`, "utf8");
+}
+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) {
+    return {
+      comparable: false,
+      resolved: [],
+      remaining: [],
+      introduced: []
+    };
+  }
+  const previousTargets = args.previous.pytest.failingNodeIds;
+  const currentTargets = args.current.pytest.failingNodeIds;
+  const currentTargetSet = new Set(currentTargets);
+  const previousTargetSet = new Set(previousTargets);
+  return {
+    comparable: true,
+    resolved: previousTargets.filter((target) => !currentTargetSet.has(target)),
+    remaining: currentTargets.filter((target) => previousTargetSet.has(target)),
+    introduced: currentTargets.filter((target) => !previousTargetSet.has(target))
+  };
+}
+function diffTestStatusTargets(args) {
+  return buildTargetDelta(args);
+}
+function diffTestStatusRuns(args) {
+  const targetDelta = buildTargetDelta(args);
+  const previousBuckets = new Map(
+    args.previous.analysis.buckets.map((bucket) => [buildBucketSignature(bucket), bucket])
+  );
+  const currentBuckets = new Map(
+    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) {
+    lines.push(
+      `- New: ${formatCount3(targetDelta.introduced.length, "failing test/module", "failing tests/modules")} appeared${appendPreview(targetDelta.introduced)}.`
+    );
+  }
+  for (const bucket of args.current.analysis.buckets) {
+    const signature = buildBucketSignature(bucket);
+    const previous = previousBuckets.get(signature);
+    if (!previous) {
+      continue;
+    }
+    const previousCount = getBucketCount(previous);
+    const currentCount = getBucketCount(bucket);
+    if (previousCount !== currentCount) {
+      lines.push(`- Changed: ${bucket.headline} (${previousCount} -> ${currentCount}).`);
+    }
+  }
+  if (lines.length === 0) {
+    for (const bucket of args.previous.analysis.buckets) {
+      const signature = buildBucketSignature(bucket);
+      if (!currentBuckets.has(signature)) {
+        lines.push(`- Resolved: ${bucket.headline} (${getBucketCount(bucket)}).`);
+      }
+    }
+    for (const bucket of args.current.analysis.buckets) {
+      const signature = buildBucketSignature(bucket);
+      if (!previousBuckets.has(signature)) {
+        lines.push(`- New: ${bucket.headline} (${getBucketCount(bucket)}).`);
+      }
+    }
+  }
+  return {
+    lines: lines.slice(0, 4),
+    remainingNodeIds: targetDelta.comparable ? targetDelta.remaining : void 0
+  };
+}
+
+// src/core/watch.ts
+var CLEAR_SCREEN_PATTERN = /\u001bc|\u001b\[2J(?:\u001b\[H)?/g;
+var SUMMARY_BOUNDARY_PATTERN = /^={5,}.*(?:passed|failed|errors?|no tests ran|interrupted).*={5,}\s*$/i;
+function normalizeWatchInput(input) {
+  return input.replace(/\r\n/g, "\n");
+}
+function hasVisibleContent(input) {
+  return input.split("\n").some((line) => line.trim().length > 0);
+}
+function splitBySummaryBoundaries(input) {
+  const cycles = [];
+  let current = [];
+  for (const line of input.split("\n")) {
+    current.push(line);
+    if (SUMMARY_BOUNDARY_PATTERN.test(line.trim())) {
+      const candidate = current.join("\n").trim();
+      if (candidate.length > 0) {
+        cycles.push(candidate);
+      }
+      current = [];
+    }
+  }
+  const trailing = current.join("\n").trim();
+  if (trailing.length > 0) {
+    cycles.push(trailing);
+  }
+  return cycles;
+}
+function splitWatchCycles(input) {
+  const normalized = normalizeWatchInput(input);
+  const clearScreenChunks = normalized.split(CLEAR_SCREEN_PATTERN).map((chunk) => chunk.trim()).filter((chunk) => chunk.length > 0);
+  if (clearScreenChunks.length > 1) {
+    return clearScreenChunks;
+  }
+  const summaryChunks = splitBySummaryBoundaries(normalized);
+  if (summaryChunks.length > 1) {
+    return summaryChunks;
+  }
+  return hasVisibleContent(normalized) ? [normalized.trim()] : [];
+}
+function looksLikeWatchStream(input) {
+  const normalized = normalizeWatchInput(input);
+  if (/\u001bc|\u001b\[2J(?:\u001b\[H)?/.test(normalized)) {
+    return splitWatchCycles(input).length > 1;
+  }
+  return /(watch(?:ing)?|waiting for file changes|rerunning|re-running)/i.test(normalized) && splitWatchCycles(input).length > 1;
+}
+function indentBlock(text) {
+  return text.split("\n").map((line) => line.length > 0 ? `  ${line}` : line).join("\n");
+}
+async function runGenericWatch(request, cycles) {
+  const rendered = [];
+  let previousSummary = null;
+  for (const [index, cycle] of cycles.entries()) {
+    const currentSummary = await runSift({
+      ...request,
+      stdin: cycle
+    });
+    if (index === 0) {
+      rendered.push(`- Cycle 1
+${indentBlock(currentSummary)}`);
+      previousSummary = currentSummary;
+      continue;
+    }
+    const changeSummary = await runSift({
+      ...request,
+      goal: "summarize",
+      format: "bullets",
+      policyName: void 0,
+      detail: void 0,
+      outputContract: void 0,
+      analysisContext: void 0,
+      fallbackJson: void 0,
+      question: "What changed since the previous cycle? Mention what resolved, what stayed, and the next best action.",
+      stdin: [
+        "Previous cycle summary:",
+        previousSummary ?? "",
+        "",
+        "Current cycle summary:",
+        currentSummary
+      ].join("\n")
+    });
+    rendered.push(
+      [`- Cycle ${index + 1}`, indentBlock(changeSummary), indentBlock(currentSummary)].join("\n")
+    );
+    previousSummary = currentSummary;
+  }
+  return rendered.join("\n\n");
+}
+async function runTestStatusWatch(request, cycles) {
+  const rendered = [];
+  const cyclePayloads = [];
+  let previousRun = null;
+  for (const [index, cycle] of cycles.entries()) {
+    const analysis = analyzeTestStatus(cycle);
+    let currentRun = createCachedTestStatusRun({
+      cwd: process.cwd(),
+      commandKey: `watch:${request.question}`,
+      commandPreview: `watch:${request.question}`,
+      detail: request.detail ?? "standard",
+      exitCode: analysis.failed > 0 || analysis.errors > 0 || analysis.collectionErrorCount ? 1 : 0,
+      rawOutput: cycle,
+      originalChars: cycle.length,
+      truncatedApplied: false,
+      analysis
+    });
+    const targetDelta = previousRun === null ? null : diffTestStatusTargets({
+      previous: previousRun,
+      current: currentRun
+    });
+    const diffLines = previousRun === null ? [] : diffTestStatusRuns({
+      previous: previousRun,
+      current: currentRun
+    }).lines;
+    const output = await runSift({
+      ...request,
+      stdin: cycle,
+      analysisContext: [
+        request.analysisContext,
+        "Watch context:",
+        "- Treat this as a redraw/change cycle, not a fresh full-suite baseline.",
+        ...previousRun === null ? [] : [
+          "- Prefer what changed, what resolved, and what still remains.",
+          "- Keep the current blocker and remaining failures in focus."
+        ]
+      ].join("\n"),
+      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)
+      }
     });
+    if (request.goal === "diagnose" && request.format === "json") {
+      cyclePayloads.push({
+        cycle: index + 1,
+        diagnosis: JSON.parse(output),
+        changes: diffLines
+      });
+    } else {
+      const block = [`- Cycle ${index + 1}`];
+      if (diffLines.length > 0) {
+        block.push(...diffLines.map((line) => `  ${line}`));
+      }
+      block.push(indentBlock(output));
+      rendered.push(block.join("\n"));
+    }
+    previousRun = currentRun;
+  }
+  if (request.goal === "diagnose" && request.format === "json") {
+    const lastDiagnosis = cyclePayloads.at(-1)?.diagnosis;
+    return JSON.stringify(
+      {
+        status: cyclePayloads.some(
+          (payload) => typeof payload.diagnosis === "object" && payload.diagnosis !== null && "status" in payload.diagnosis && payload.diagnosis.status === "insufficient"
+        ) ? "insufficient" : "ok",
+        cycles: cyclePayloads,
+        next_best_action: lastDiagnosis?.next_best_action ?? null
+      },
+      null,
+      2
+    );
+  }
+  return rendered.join("\n\n");
+}
+async function runWatch(request) {
+  const cycles = splitWatchCycles(request.stdin);
+  if (cycles.length <= 1) {
+    return runSift(request);
   }
+  if (request.goal === "diagnose" && request.format === "json" && request.policyName !== "test-status") {
+    throw new Error(
+      "`--goal diagnose --format json` is currently supported only for `test-status` watch flows."
+    );
+  }
+  if (request.policyName === "test-status") {
+    return runTestStatusWatch(request, cycles);
+  }
+  return runGenericWatch(request, cycles);
 }
 
 // src/core/exec.ts
@@ -992,9 +4097,13 @@ async function runExec(request) {
     throw new Error("Provide either --shell <command> or -- <program> [args...].");
   }
   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;
   if (request.config.runtime.verbose) {
     process.stderr.write(
-      `${pc2.dim("sift")} exec mode=${hasShellCommand ? "shell" : "argv"} command=${buildCommandPreview(request)}
+      `${pc2.dim("sift")} exec mode=${hasShellCommand ? "shell" : "argv"} command=${commandPreview}
 `
     );
   }
@@ -1003,10 +4112,11 @@ async function runExec(request) {
   let bypassed = false;
   let childStatus = null;
   let childSignal = null;
-  let childSpawnError = null;
   const child = hasShellCommand ? spawn(shellPath, ["-lc", request.shellCommand], {
+    cwd: commandCwd,
     stdio: ["inherit", "pipe", "pipe"]
   }) : spawn(request.command[0], request.command.slice(1), {
+    cwd: commandCwd,
     stdio: ["inherit", "pipe", "pipe"]
   });
   const handleChunk = (chunk) => {
@@ -1031,7 +4141,6 @@ async function runExec(request) {
   child.stderr.on("data", handleChunk);
   await new Promise((resolve, reject) => {
     child.on("error", (error) => {
-      childSpawnError = error;
       reject(error);
     });
     child.on("close", (status, signal) => {
@@ -1045,19 +4154,29 @@ async function runExec(request) {
     }
     throw new Error("Failed to start child process.");
   });
-  if (childSpawnError) {
-    throw childSpawnError;
-  }
   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;
   if (request.config.runtime.verbose) {
     process.stderr.write(
       `${pc2.dim("sift")} child_exit=${exitCode} captured_chars=${capture.getTotalChars()} capture_truncated=${capture.wasTruncated()}
 `
     );
   }
+  if (autoWatchDetected) {
+    process.stderr.write(`${pc2.dim("sift")} auto-watch=detected
+`);
+  }
   if (!bypassed) {
-    const execSuccessShortcut = getExecSuccessShortcut({
+    if (request.showRaw && capturedOutput.length > 0) {
+      process.stderr.write(capturedOutput);
+      if (!capturedOutput.endsWith("\n")) {
+        process.stderr.write("\n");
+      }
+    }
+    const execSuccessShortcut = useWatchFlow ? null : getExecSuccessShortcut({
       presetName: request.presetName,
       exitCode,
       capturedOutput
@@ -1073,10 +4192,115 @@ async function runExec(request) {
 `);
       return exitCode;
     }
-    const output = await runSift({
+    if (useWatchFlow) {
+      let output2 = await runWatch({
+        ...request,
+        stdin: capturedOutput
+      });
+      if (isInsufficientSignalOutput(output2)) {
+        output2 = buildInsufficientSignalOutput({
+          presetName: request.presetName,
+          originalLength: capture.getTotalChars(),
+          truncatedApplied: capture.wasTruncated(),
+          exitCode
+        });
+      }
+      process.stdout.write(`${output2}
+`);
+      return exitCode;
+    }
+    const analysis = shouldCacheTestStatus ? analyzeTestStatus(capturedOutput) : null;
+    let currentCachedRun = shouldCacheTestStatus && analysis ? createCachedTestStatusRun({
+      cwd: commandCwd,
+      commandKey: buildTestStatusCommandKey({
+        commandPreview,
+        shellCommand: request.shellCommand
+      }),
+      commandPreview,
+      command: request.command,
+      shellCommand: request.shellCommand,
+      detail: request.detail ?? "standard",
+      exitCode,
+      rawOutput: capturedOutput,
+      originalChars: capture.getTotalChars(),
+      truncatedApplied: capture.wasTruncated(),
+      analysis
+    }) : null;
+    const targetDelta = request.diff && !request.dryRun && previousCachedRun && currentCachedRun ? diffTestStatusTargets({
+      previous: previousCachedRun,
+      current: currentCachedRun
+    }) : null;
+    let output = await runSift({
       ...request,
-      stdin: capturedOutput
+      stdin: capturedOutput,
+      analysisContext: request.skipCacheWrite && 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 ? {
+        ...request.testStatusContext,
+        resolvedTests: targetDelta?.resolved ?? request.testStatusContext?.resolvedTests,
+        remainingTests: targetDelta?.remaining ?? currentCachedRun?.pytest?.failingNodeIds ?? request.testStatusContext?.remainingTests,
+        remainingSubsetAvailable: request.testStatusContext?.remainingSubsetAvailable ?? Boolean(
+          currentCachedRun?.pytest?.subsetCapable && (targetDelta?.remaining ?? currentCachedRun?.pytest?.failingNodeIds ?? []).length > 0
+        )
+      } : request.testStatusContext
     });
+    if (shouldCacheTestStatus) {
+      if (isInsufficientSignalOutput(output)) {
+        output = buildInsufficientSignalOutput({
+          presetName: request.presetName,
+          originalLength: capture.getTotalChars(),
+          truncatedApplied: capture.wasTruncated(),
+          exitCode
+        });
+      }
+      if (request.diff && !request.dryRun && previousCachedRun && currentCachedRun) {
+        const delta = diffTestStatusRuns({
+          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) {
+        try {
+          writeCachedTestStatusRun(currentCachedRun);
+        } catch (error) {
+          if (request.config.runtime.verbose) {
+            const reason = error instanceof Error ? error.message : "unknown_error";
+            process.stderr.write(`${pc2.dim("sift")} cache_write=failed reason=${reason}
+`);
+          }
+        }
+      }
+    } else if (isInsufficientSignalOutput(output)) {
+      output = buildInsufficientSignalOutput({
+        presetName: request.presetName,
+        originalLength: capture.getTotalChars(),
+        truncatedApplied: capture.wasTruncated(),
+        exitCode
+      });
+    }
     process.stdout.write(`${output}
 `);
     if (request.failOn && !request.dryRun && exitCode === 0 && supportsFailOnPreset(request.presetName) && evaluateGate({
@@ -1161,19 +4385,19 @@ var defaultConfig = {
 };
 
 // src/config/load.ts
-import fs from "fs";
-import path2 from "path";
+import fs2 from "fs";
+import path3 from "path";
 import YAML from "yaml";
 function findConfigPath(explicitPath) {
   if (explicitPath) {
-    const resolved = path2.resolve(explicitPath);
-    if (!fs.existsSync(resolved)) {
+    const resolved = path3.resolve(explicitPath);
+    if (!fs2.existsSync(resolved)) {
       throw new Error(`Config file not found: ${resolved}`);
     }
     return resolved;
   }
   for (const candidate of getDefaultConfigSearchPaths()) {
-    if (fs.existsSync(candidate)) {
+    if (fs2.existsSync(candidate)) {
       return candidate;
     }
   }
@@ -1184,7 +4408,7 @@ function loadRawConfig(explicitPath) {
   if (!configPath) {
     return {};
   }
-  const content = fs.readFileSync(configPath, "utf8");
+  const content = fs2.readFileSync(configPath, "utf8");
   return YAML.parse(content) ?? {};
 }
 
@@ -1238,17 +4462,17 @@ function resolveProviderApiKey(provider, baseUrl, env) {
 }
 
 // src/config/schema.ts
-import { z } from "zod";
-var providerNameSchema = z.enum(["openai", "openai-compatible"]);
-var outputFormatSchema = z.enum([
+import { z as z3 } from "zod";
+var providerNameSchema = z3.enum(["openai", "openai-compatible"]);
+var outputFormatSchema = z3.enum([
   "brief",
   "bullets",
   "json",
   "verdict"
 ]);
-var responseModeSchema = z.enum(["text", "json"]);
-var jsonResponseFormatModeSchema = z.enum(["auto", "on", "off"]);
-var promptPolicyNameSchema = z.enum([
+var responseModeSchema = z3.enum(["text", "json"]);
+var jsonResponseFormatModeSchema = z3.enum(["auto", "on", "off"]);
+var promptPolicyNameSchema = z3.enum([
   "test-status",
   "audit-critical",
   "diff-summary",
@@ -1258,41 +4482,41 @@ var promptPolicyNameSchema = z.enum([
   "typecheck-summary",
   "lint-failures"
 ]);
-var providerConfigSchema = z.object({
+var providerConfigSchema = z3.object({
   provider: providerNameSchema,
-  model: z.string().min(1),
-  baseUrl: z.string().url(),
-  apiKey: z.string().optional(),
+  model: z3.string().min(1),
+  baseUrl: z3.string().url(),
+  apiKey: z3.string().optional(),
   jsonResponseFormat: jsonResponseFormatModeSchema,
-  timeoutMs: z.number().int().positive(),
-  temperature: z.number().min(0).max(2),
-  maxOutputTokens: z.number().int().positive()
+  timeoutMs: z3.number().int().positive(),
+  temperature: z3.number().min(0).max(2),
+  maxOutputTokens: z3.number().int().positive()
 });
-var inputConfigSchema = z.object({
-  stripAnsi: z.boolean(),
-  redact: z.boolean(),
-  redactStrict: z.boolean(),
-  maxCaptureChars: z.number().int().positive(),
-  maxInputChars: z.number().int().positive(),
-  headChars: z.number().int().positive(),
-  tailChars: z.number().int().positive()
+var inputConfigSchema = z3.object({
+  stripAnsi: z3.boolean(),
+  redact: z3.boolean(),
+  redactStrict: z3.boolean(),
+  maxCaptureChars: z3.number().int().positive(),
+  maxInputChars: z3.number().int().positive(),
+  headChars: z3.number().int().positive(),
+  tailChars: z3.number().int().positive()
 });
-var runtimeConfigSchema = z.object({
-  rawFallback: z.boolean(),
-  verbose: z.boolean()
+var runtimeConfigSchema = z3.object({
+  rawFallback: z3.boolean(),
+  verbose: z3.boolean()
 });
-var presetDefinitionSchema = z.object({
-  question: z.string().min(1),
+var presetDefinitionSchema = z3.object({
+  question: z3.string().min(1),
   format: outputFormatSchema,
   policy: promptPolicyNameSchema.optional(),
-  outputContract: z.string().optional(),
-  fallbackJson: z.unknown().optional()
+  outputContract: z3.string().optional(),
+  fallbackJson: z3.unknown().optional()
 });
-var siftConfigSchema = z.object({
+var siftConfigSchema = z3.object({
   provider: providerConfigSchema,
   input: inputConfigSchema,
   runtime: runtimeConfigSchema,
-  presets: z.record(presetDefinitionSchema)
+  presets: z3.record(presetDefinitionSchema)
 });
 
 // src/config/resolve.ts
@@ -1386,6 +4610,12 @@ function resolveConfig(options = {}) {
   return siftConfigSchema.parse(merged);
 }
 export {
+  BoundedCapture,
+  buildCommandPreview,
+  getExecSuccessShortcut,
+  looksInteractivePrompt,
+  mergeDefined,
+  normalizeChildExitCode,
   resolveConfig,
   runExec,
   runSift