@bilalimamoglu/sift 0.2.3 → 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 [
@@ -53,539 +59,955 @@ function evaluateGate(args) {
   return { shouldFail: false };
 }
 
-// src/core/insufficient.ts
-function isInsufficientSignalOutput(output) {
-  const trimmed = output.trim();
-  return trimmed === INSUFFICIENT_SIGNAL_TEXT || trimmed.startsWith(`${INSUFFICIENT_SIGNAL_TEXT}
-Hint:`);
+// 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 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}`;
+function formatCount(count, singular, plural = `${singular}s`) {
+  return `${count} ${count === 1 ? singular : plural}`;
 }
-
-// src/core/run.ts
-import pc from "picocolors";
-
-// src/providers/systemInstruction.ts
-var REDUCTION_SYSTEM_INSTRUCTION = "You reduce noisy command output into compact answers for agents and automation.";
-
-// src/providers/openai.ts
-function usesNativeJsonResponseFormat(mode) {
-  return mode !== "off";
+function unique(values) {
+  return [...new Set(values)];
 }
-function extractResponseText(payload) {
-  if (typeof payload?.output_text === "string") {
-    return payload.output_text.trim();
+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];
   }
-  if (!Array.isArray(payload?.output)) {
-    return "";
+  const filePart = normalized.split("::")[0]?.trim() ?? "";
+  if (!filePart.includes("/")) {
+    return "other";
   }
-  return payload.output.flatMap((item) => Array.isArray(item?.content) ? item.content : []).map((item) => item?.type === "output_text" ? item.text : "").filter((text) => typeof text === "string" && text.trim().length > 0).join("").trim();
+  const segments = filePart.replace(/^\/+/, "").split("/").filter(Boolean);
+  if (segments.length === 0) {
+    return "other";
+  }
+  return `${segments[0]}/`;
 }
-async function buildOpenAIError(response) {
-  let detail = `Provider returned HTTP ${response.status}`;
-  try {
-    const data = await response.json();
-    const message = data?.error?.message;
-    if (typeof message === "string" && message.trim().length > 0) {
-      detail = `${detail}: ${message.trim()}`;
+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;
     }
-  } catch {
+    return left.prefix.localeCompare(right.prefix);
+  }).slice(0, 5);
+  return {
+    count: values.length,
+    families
+  };
+}
+function formatTargetSummary(summary) {
+  if (summary.count === 0) {
+    return "count=0";
   }
-  return new Error(detail);
+  const families = summary.families.length > 0 ? summary.families.map((family) => `${family.prefix}${family.count}`).join(", ") : "none";
+  return `count=${summary.count}; families=${families}`;
 }
-var OpenAIProvider = class {
-  name = "openai";
-  baseUrl;
-  apiKey;
-  constructor(options) {
-    this.baseUrl = options.baseUrl.replace(/\/$/, "");
-    this.apiKey = options.apiKey;
+function classifyGenericBucketType(reason) {
+  if (reason.startsWith("missing test env:")) {
+    return "shared_environment_blocker";
   }
-  async generate(input) {
-    const controller = new AbortController();
-    const timeout = setTimeout(() => controller.abort(), input.timeoutMs);
-    try {
-      const url = new URL("responses", `${this.baseUrl}/`);
-      const response = await fetch(url, {
-        method: "POST",
-        signal: controller.signal,
-        headers: {
-          "content-type": "application/json",
-          ...this.apiKey ? { authorization: `Bearer ${this.apiKey}` } : {}
-        },
-        body: JSON.stringify({
-          model: input.model,
-          instructions: REDUCTION_SYSTEM_INSTRUCTION,
-          input: input.prompt,
-          reasoning: {
-            effort: "minimal"
-          },
-          text: {
-            verbosity: "low",
-            ...input.responseMode === "json" && usesNativeJsonResponseFormat(input.jsonResponseFormat) ? {
-              format: {
-                type: "json_object"
-              }
-            } : {}
-          },
-          max_output_tokens: input.maxOutputTokens
-        })
-      });
-      if (!response.ok) {
-        throw await buildOpenAIError(response);
-      }
-      const data = await response.json();
-      const text = extractResponseText(data);
-      if (!text) {
-        throw new Error("Provider returned an empty response");
-      }
-      const result = {
-        text,
-        usage: data?.usage ? {
-          inputTokens: data.usage.input_tokens,
-          outputTokens: data.usage.output_tokens,
-          totalTokens: data.usage.total_tokens
-        } : 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;
-    }
+  if (reason.startsWith("fixture guard:")) {
+    return "collection_failure";
   }
-};
-
-// src/providers/openaiCompatible.ts
-function supportsNativeJsonResponseFormat(baseUrl, mode) {
-  if (mode === "off") {
-    return false;
+  if (reason.startsWith("service unavailable:")) {
+    return "runtime_failure";
   }
-  if (mode === "on") {
-    return true;
+  if (reason.startsWith("db refused:")) {
+    return "runtime_failure";
   }
-  return /^https:\/\/api\.openai\.com(?:\/|$)/i.test(baseUrl);
-}
-function extractMessageText(payload) {
-  const content = payload?.choices?.[0]?.message?.content;
-  if (typeof content === "string") {
-    return content;
+  if (reason.startsWith("auth bypass absent:")) {
+    return "runtime_failure";
   }
-  if (Array.isArray(content)) {
-    return content.map((item) => typeof item?.text === "string" ? item.text : "").join("").trim();
+  if (reason.startsWith("missing module:")) {
+    return "import_dependency_failure";
   }
-  return "";
+  if (reason.startsWith("assertion failed:")) {
+    return "assertion_failure";
+  }
+  if (/^[A-Z][A-Za-z]+(?:Error|Exception):/.test(reason)) {
+    return "runtime_failure";
+  }
+  return "unknown_failure";
 }
-async function buildOpenAICompatibleError(response) {
-  let detail = `Provider returned HTTP ${response.status}`;
-  try {
-    const data = await response.json();
-    const message = data?.error?.message;
-    if (typeof message === "string" && message.trim().length > 0) {
-      detail = `${detail}: ${message.trim()}`;
+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;
     }
-  } catch {
+    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);
   }
-  return new Error(detail);
+  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);
 }
-var OpenAICompatibleProvider = class {
-  name = "openai-compatible";
-  baseUrl;
-  apiKey;
-  constructor(options) {
-    this.baseUrl = options.baseUrl.replace(/\/$/, "");
-    this.apiKey = options.apiKey;
+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);
   }
-  async generate(input) {
-    const controller = new AbortController();
-    const timeout = setTimeout(() => controller.abort(), input.timeoutMs);
-    try {
-      const url = new URL("chat/completions", `${this.baseUrl}/`);
-      const response = await fetch(url, {
-        method: "POST",
-        signal: controller.signal,
-        headers: {
-          "content-type": "application/json",
-          ...this.apiKey ? { authorization: `Bearer ${this.apiKey}` } : {}
-        },
-        body: JSON.stringify({
-          model: input.model,
-          temperature: input.temperature,
-          max_tokens: input.maxOutputTokens,
-          ...input.responseMode === "json" && supportsNativeJsonResponseFormat(this.baseUrl, input.jsonResponseFormat) ? { response_format: { type: "json_object" } } : {},
-          messages: [
-            {
-              role: "system",
-              content: REDUCTION_SYSTEM_INSTRUCTION
-            },
-            {
-              role: "user",
-              content: input.prompt
-            }
-          ]
-        })
-      });
-      if (!response.ok) {
-        throw await buildOpenAICompatibleError(response);
-      }
-      const data = await response.json();
-      const text = extractMessageText(data);
-      if (!text.trim()) {
-        throw new Error("Provider returned an empty response");
-      }
-      const result = {
-        text,
-        usage: data?.usage ? {
-          inputTokens: data.usage.prompt_tokens,
-          outputTokens: data.usage.completion_tokens,
-          totalTokens: data.usage.total_tokens
-        } : void 0,
-        raw: data
-      };
-      clearTimeout(timeout);
-      return result;
-    } catch (error) {
-      clearTimeout(timeout);
-      if (error.name === "AbortError") {
-        throw new Error("Provider request timed out");
+  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;
       }
-      throw error;
+      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);
   }
-};
-
-// src/providers/factory.ts
-function createProvider(config) {
-  if (config.provider.provider === "openai") {
-    return new OpenAIProvider({
-      baseUrl: config.provider.baseUrl,
-      apiKey: config.provider.apiKey
-    });
-  }
-  if (config.provider.provider === "openai-compatible") {
-    return new OpenAICompatibleProvider({
-      baseUrl: config.provider.baseUrl,
-      apiKey: config.provider.apiKey
+  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);
+    }
   }
-  throw new Error(`Unsupported provider: ${config.provider.provider}`);
+  return merged;
 }
-
-// src/prompts/formats.ts
-function getGenericFormatPolicy(format, outputContract) {
-  switch (format) {
-    case "brief":
-      return {
-        responseMode: "text",
-        taskRules: [
-          "Return 1 to 3 short sentences.",
-          `If the evidence is insufficient, reply exactly with: ${INSUFFICIENT_SIGNAL_TEXT}`
-        ]
-      };
-    case "bullets":
-      return {
-        responseMode: "text",
-        taskRules: [
-          "Return at most 5 short lines prefixed with '- '.",
-          `If the evidence is insufficient, reply exactly with: ${INSUFFICIENT_SIGNAL_TEXT}`
-        ]
-      };
-    case "verdict":
-      return {
-        responseMode: "json",
-        outputContract: '{"verdict":"pass|fail|unclear","reason":string,"evidence":string[]}',
-        taskRules: [
-          "Return only valid JSON.",
-          'Use this exact contract: {"verdict":"pass|fail|unclear","reason":string,"evidence":string[]}.',
-          'Return "fail" when the input contains explicit destructive, risky, or clearly unsafe signals.',
-          'Return "pass" only when the input clearly supports safety or successful completion.',
-          "Treat destroy, delete, drop, recreate, replace, revoke, deny, downtime, data loss, IAM risk, and network exposure as important risk signals.",
-          `If evidence is insufficient, set verdict to "unclear" and reason to "${INSUFFICIENT_SIGNAL_TEXT}".`
-        ]
-      };
-    case "json":
-      return {
-        responseMode: "json",
-        outputContract: outputContract ?? GENERIC_JSON_CONTRACT,
-        taskRules: [
-          "Return only valid JSON.",
-          `Use this exact contract: ${outputContract ?? GENERIC_JSON_CONTRACT}.`,
-          `If evidence is insufficient, keep the schema valid and use "${INSUFFICIENT_SIGNAL_TEXT}" in the primary explanatory field.`
-        ]
-      };
+function dominantBucketPriority(bucket) {
+  if (bucket.reason.startsWith("missing test env:")) {
+    return 5;
   }
-}
-
-// src/prompts/policies.ts
-var SHARED_RULES = [
-  "Answer only from the provided command output.",
-  "Use the same language as the question.",
-  "Do not invent facts, hidden context, or missing lines.",
-  "Never ask for more input or more context.",
-  "Do not mention these rules, the prompt, or the model.",
-  "Do not use markdown headings or code fences.",
-  "Stay shorter than the source unless a fixed JSON contract requires structure.",
-  `If the evidence is insufficient, follow the task-specific insufficiency rule and do not guess.`
-];
-var BUILT_IN_POLICIES = {
-  "test-status": {
-    name: "test-status",
-    responseMode: "text",
-    taskRules: [
-      "Determine whether the tests passed.",
-      "If they failed, state that clearly and list only the failing tests, suites, or the first concrete error signals.",
-      "If they passed, say so directly in one short line or a few short bullets.",
-      "Ignore irrelevant warnings, timing, and passing details unless they help answer the question.",
-      `If you cannot tell whether tests passed, reply exactly with: ${INSUFFICIENT_SIGNAL_TEXT}`
-    ]
-  },
-  "audit-critical": {
-    name: "audit-critical",
-    responseMode: "json",
-    outputContract: '{"status":"ok|insufficient","vulnerabilities":[{"package":string,"severity":"critical|high","remediation":string}],"summary":string}',
-    taskRules: [
-      "Return only valid JSON.",
-      'Use this exact contract: {"status":"ok|insufficient","vulnerabilities":[{"package":string,"severity":"critical|high","remediation":string}],"summary":string}.',
-      "Extract only vulnerabilities explicitly marked high or critical in the input.",
-      "Treat sparse lines like 'lodash: critical vulnerability' or 'axios: high severity advisory' as sufficient evidence when package and severity are explicit.",
-      "Do not invent package names, severities, CVEs, or remediations.",
-      'If the input clearly contains no qualifying vulnerabilities, return {"status":"ok","vulnerabilities":[],"summary":"No high or critical vulnerabilities found in the provided input."}.',
-      `If the input does not provide enough evidence to determine vulnerability status, return status "insufficient" and use "${INSUFFICIENT_SIGNAL_TEXT}" in summary.`
-    ]
-  },
-  "diff-summary": {
-    name: "diff-summary",
-    responseMode: "json",
-    outputContract: '{"status":"ok|insufficient","answer":string,"evidence":string[],"risks":string[]}',
-    taskRules: [
-      "Return only valid JSON.",
-      'Use this exact contract: {"status":"ok|insufficient","answer":string,"evidence":string[],"risks":string[]}.',
-      "Summarize what changed at a high level, grounded only in the visible diff or output.",
-      "Evidence should cite the most important visible files, modules, resources, or actions.",
-      "Risks should include migrations, config changes, security changes, destructive actions, or unknown impact when visible.",
-      `If the change signal is incomplete, return status "insufficient" and use "${INSUFFICIENT_SIGNAL_TEXT}" in answer.`
-    ]
-  },
-  "build-failure": {
-    name: "build-failure",
-    responseMode: "text",
-    taskRules: [
-      "Identify the most likely root cause of the build failure.",
-      "Give the first concrete fix or next step in the same answer.",
-      "Keep the response to 1 or 2 short sentences.",
-      `If the root cause is not visible, reply exactly with: ${INSUFFICIENT_SIGNAL_TEXT}`
-    ]
-  },
-  "log-errors": {
-    name: "log-errors",
-    responseMode: "text",
-    taskRules: [
-      "Return at most 5 short bullet points.",
-      "Extract only the most relevant error or failure signals.",
-      "Prefer recurring or top-level errors over long stack traces.",
-      "Do not dump full traces unless a single trace line is the key signal.",
-      `If there is no clear error signal, reply exactly with: ${INSUFFICIENT_SIGNAL_TEXT}`
-    ]
-  },
-  "typecheck-summary": {
-    name: "typecheck-summary",
-    responseMode: "text",
-    taskRules: [
-      "Return at most 5 short bullet points.",
-      "Determine whether the typecheck failed or passed.",
-      "Group repeated diagnostics into root-cause buckets instead of echoing many duplicate lines.",
-      "Mention the first concrete files, symbols, or error categories to fix when they are visible.",
-      "Prefer compiler or type-system errors over timing, progress, or summary noise.",
-      "If the output clearly indicates success, say that briefly and do not add extra bullets.",
-      `If you cannot tell whether the typecheck failed, reply exactly with: ${INSUFFICIENT_SIGNAL_TEXT}`
-    ]
-  },
-  "lint-failures": {
-    name: "lint-failures",
-    responseMode: "text",
-    taskRules: [
-      "Return at most 5 short bullet points.",
-      "Determine whether lint failed or whether there are no blocking lint failures.",
-      "Group repeated rule violations instead of listing the same rule many times.",
-      "Mention the top offending files and rule names when they are visible.",
-      "Distinguish blocking failures from warnings only when that distinction is clearly visible in the input.",
-      "Do not invent autofixability; only mention autofix or --fix support when the tool output explicitly says so.",
-      "If the output clearly indicates success or no blocking failures, say that briefly and stop.",
-      `If there is not enough evidence to determine the lint result, reply exactly with: ${INSUFFICIENT_SIGNAL_TEXT}`
-    ]
-  },
-  "infra-risk": {
-    name: "infra-risk",
-    responseMode: "json",
-    outputContract: '{"verdict":"pass|fail|unclear","reason":string,"evidence":string[]}',
-    taskRules: [
-      "Return only valid JSON.",
-      'Use this exact contract: {"verdict":"pass|fail|unclear","reason":string,"evidence":string[]}.',
-      'Return "fail" when the input contains explicit destructive or clearly risky signals such as destroy, delete, drop, recreate, replace, revoke, deny, downtime, data loss, IAM risk, or network exposure.',
-      'Treat short plan summaries like "1 to destroy" or "resources to destroy" as enough evidence for "fail".',
-      'Return "pass" only when the input clearly shows no risky changes or explicitly safe behavior.',
-      'Return "unclear" when the input is incomplete, ambiguous, or does not show enough evidence to judge safety.',
-      "Evidence should contain the shortest concrete lines or phrases that justify the verdict."
-    ]
+  if (bucket.type === "shared_environment_blocker") {
+    return 4;
   }
-};
-function resolvePromptPolicy(args) {
-  if (args.policyName) {
-    const policy = BUILT_IN_POLICIES[args.policyName];
-    return {
-      ...policy,
-      sharedRules: SHARED_RULES
-    };
+  if (bucket.type === "import_dependency_failure") {
+    return 3;
   }
-  const genericPolicy = getGenericFormatPolicy(args.format, args.outputContract);
-  return {
-    name: `generic-${args.format}`,
-    responseMode: genericPolicy.responseMode,
-    outputContract: genericPolicy.outputContract,
-    sharedRules: SHARED_RULES,
-    taskRules: genericPolicy.taskRules
-  };
+  if (bucket.type === "collection_failure") {
+    return 2;
+  }
+  if (bucket.type === "contract_snapshot_drift") {
+    return 1;
+  }
+  return 0;
 }
-
-// src/prompts/buildPrompt.ts
-function buildPrompt(args) {
-  const policy = resolvePromptPolicy({
-    format: args.format,
-    policyName: args.policyName,
-    outputContract: args.outputContract
+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);
   });
-  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}`),
-    "",
-    `Task policy: ${policy.name}`,
-    ...policy.taskRules.map((rule) => `- ${rule}`),
-    ...detailRules.map((rule) => `- ${rule}`),
-    ...policy.outputContract ? ["", `Output contract: ${policy.outputContract}`] : [],
-    "",
-    `Question: ${args.question}`,
-    "",
-    "Command output:",
-    '"""',
-    args.input,
-    '"""'
-  ].join("\n");
-  return {
-    prompt,
-    responseMode: policy.responseMode
-  };
-}
-
-// src/core/quality.ts
-var META_PATTERNS = [
-  /please provide/i,
-  /need more (?:input|context|information|details)/i,
-  /provided command output/i,
-  /based on the provided/i,
-  /as an ai/i,
-  /here(?:'s| is) (?:the )?(?:json|answer)/i,
-  /cannot determine without/i
-];
-function normalizeForComparison(input) {
-  return input.replace(/\r\n/g, "\n").replace(/\r/g, "\n").replace(/\s+/g, " ").trim();
 }
-function isRetriableReason(reason) {
-  return /timed out|http 408|http 409|http 425|http 429|http 5\d\d|network/i.test(
-    reason.toLowerCase()
-  );
+function isDominantBlockerType(type) {
+  return type === "shared_environment_blocker" || type === "import_dependency_failure" || type === "collection_failure";
 }
-function looksLikeRejectedModelOutput(args) {
-  const source = normalizeForComparison(args.source);
-  const candidate = normalizeForComparison(args.candidate);
-  if (!candidate) {
-    return true;
+function labelForBucket(bucket) {
+  if (bucket.reason.startsWith("missing test env:")) {
+    return "missing test env";
   }
-  if (candidate === INSUFFICIENT_SIGNAL_TEXT) {
-    return false;
+  if (bucket.reason.startsWith("fixture guard:")) {
+    return "fixture guard";
   }
-  if (candidate.includes("```")) {
-    return true;
+  if (bucket.reason.startsWith("service unavailable:")) {
+    return "service unavailable";
   }
-  if (META_PATTERNS.some((pattern) => pattern.test(candidate))) {
-    return true;
+  if (bucket.reason.startsWith("db refused:")) {
+    return "db refused";
   }
-  if (args.responseMode === "json") {
-    const trimmed = args.candidate.trim();
-    if (!trimmed.startsWith("{") && !trimmed.startsWith("[")) {
-      return true;
-    }
+  if (bucket.reason.startsWith("auth bypass absent:")) {
+    return "auth bypass absent";
   }
-  if (source.length >= 800 && candidate.length > source.length * 0.8) {
-    return true;
+  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 (source.length > 0 && source.length < 800 && candidate.length > source.length + 160) {
-    return true;
+  if (bucket.type === "import_dependency_failure") {
+    return "import dependency failure";
   }
-  return false;
+  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";
 }
-
-// src/core/fallback.ts
-var RAW_FALLBACK_SLICE = 1200;
-function buildStructuredError(reason) {
+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 {
-    status: "error",
-    reason,
-    retriable: isRetriableReason(reason)
+    start_line: null,
+    end_line: null,
+    search_hint: buildReadTargetSearchHint(args.bucket, args.anchor)
   };
 }
-function buildFallbackOutput(args) {
-  if (args.format === "verdict") {
-    return JSON.stringify(
+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 [
       {
-        ...buildStructuredError(args.reason),
-        verdict: "unclear",
-        reason: `Sift fallback: ${args.reason}`,
-        evidence: []
-      },
-      null,
-      2
+        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 (args.format === "json") {
-    return JSON.stringify(buildStructuredError(args.reason), null, 2);
+  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")}.`
+    );
   }
-  const prefix = `Sift fallback triggered (${args.reason}).`;
-  if (!args.rawFallback) {
-    return prefix;
+  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}`);
+    }
   }
-  return [prefix, "", args.rawInput.slice(-RAW_FALLBACK_SLICE)].join("\n");
+  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
@@ -610,7 +1032,7 @@ function getCount(input, label) {
   const lastMatch = matches.at(-1);
   return lastMatch ? Number(lastMatch[1]) : 0;
 }
-function formatCount(count, singular, plural = `${singular}s`) {
+function formatCount2(count, singular, plural = `${singular}s`) {
   return `${count} ${count === 1 ? singular : plural}`;
 }
 function countPattern(input, matcher) {
@@ -630,6 +1052,78 @@ function collectUniqueMatches(input, matcher, limit = 6) {
   }
   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, "");
 }
@@ -641,6 +1135,9 @@ function isLowValueInternalReason(normalized) {
   ) || /\bpython\.py:\d+:\s+in\s+importtestmodule\b/i.test(normalized) || /\bpython\.py:\d+:\s+in\s+import_path\b/i.test(normalized);
 }
 function scoreFailureReason(reason) {
+  if (reason.startsWith("missing test env:")) {
+    return 6;
+  }
   if (reason.startsWith("missing module:")) {
     return 5;
   }
@@ -655,6 +1152,18 @@ function scoreFailureReason(reason) {
   }
   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) {
@@ -663,6 +1172,61 @@ function classifyFailureReason(line, options) {
   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
   );
@@ -735,26 +1299,31 @@ function collectCollectionFailureItems(input) {
   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) {
-        pushFocusedFailureItem(
-          items,
-          {
-            label: currentLabel,
-            reason: pendingGenericReason.reason,
-            group: pendingGenericReason.group
-          }
-        );
+        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
     });
@@ -765,26 +1334,31 @@ function collectCollectionFailureItems(input) {
       pendingGenericReason = classification;
       continue;
     }
-    pushFocusedFailureItem(
-      items,
-      {
-        label: currentLabel,
-        reason: classification.reason,
-        group: classification.group
-      }
-    );
+    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) {
-    pushFocusedFailureItem(
-      items,
-      {
-        label: currentLabel,
-        reason: pendingGenericReason.reason,
-        group: pendingGenericReason.group
-      }
-    );
+    const anchor = resolveAnchorForLabel({
+      label: currentLabel,
+      observedAnchor: currentAnchor
+    });
+    pushFocusedFailureItem(items, {
+      label: currentLabel,
+      reason: pendingGenericReason.reason,
+      group: pendingGenericReason.group,
+      ...anchor
+    });
   }
   return items;
 }
@@ -795,54 +1369,95 @@ function collectInlineFailureItems(input) {
     if (!inlineFailure) {
       continue;
     }
+    const cleanedLabel = cleanFailureLabel(inlineFailure[2]);
+    if (!cleanedLabel) {
+      continue;
+    }
     const classification = classifyFailureReason(inlineFailure[3], {
       duringCollection: false
     });
     if (!classification) {
       continue;
     }
-    pushFocusedFailureItem(
-      items,
-      {
-        label: cleanFailureLabel(inlineFailure[2]),
-        reason: classification.reason,
-        group: classification.group
-      }
-    );
+    pushFocusedFailureItem(items, {
+      label: cleanedLabel,
+      reason: classification.reason,
+      group: classification.group,
+      ...resolveAnchorForLabel({
+        label: cleanedLabel,
+        observedAnchor: parseObservedAnchor(inlineFailure[3])
+      })
+    });
   }
   return items;
 }
-function formatFocusedFailureGroups(args) {
-  const maxGroups = args.maxGroups ?? 3;
-  const maxPerGroup = args.maxPerGroup ?? 6;
-  const grouped = /* @__PURE__ */ new Map();
-  for (const item of args.items) {
-    const entries = grouped.get(item.group) ?? [];
-    entries.push(item);
-    grouped.set(item.group, entries);
-  }
-  const lines = [];
-  const visibleGroups = [...grouped.entries()].slice(0, maxGroups);
-  for (const [group, entries] of visibleGroups) {
-    lines.push(`- ${group}`);
-    for (const item of entries.slice(0, maxPerGroup)) {
-      lines.push(`  - ${item.label} -> ${item.reason}`);
-    }
-    const remaining = entries.length - Math.min(entries.length, maxPerGroup);
-    if (remaining > 0) {
-      lines.push(`  - and ${remaining} more failing ${args.remainderLabel}`);
-    }
+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)
+      })
+    });
   }
-  const hiddenGroups = grouped.size - visibleGroups.length;
-  if (hiddenGroups > 0) {
-    lines.push(`- and ${hiddenGroups} more error group${hiddenGroups === 1 ? "" : "s"}`);
+  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 lines;
+  return classifications;
 }
-function formatVerboseFailureItems(args) {
-  return chooseStrongestFailureItems(args.items).map(
-    (item) => `- ${item.label} -> ${item.reason}`
-  );
+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(
@@ -863,236 +1478,1162 @@ function summarizeRepeatedTestCauses(input, options) {
     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 (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 (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);
+  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;
+  }
+  if (policyName === "audit-critical") {
+    return auditCriticalHeuristic(input);
+  }
+  if (policyName === "infra-risk") {
+    return infraRiskHeuristic(input);
+  }
+  if (policyName === "test-status") {
+    return testStatusHeuristic(input, detail);
+  }
+  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
+import pc from "picocolors";
+
+// src/providers/systemInstruction.ts
+var REDUCTION_SYSTEM_INSTRUCTION = "You reduce noisy command output into compact answers for agents and automation.";
+
+// src/providers/openai.ts
+function usesNativeJsonResponseFormat(mode) {
+  return mode !== "off";
+}
+function extractResponseText(payload) {
+  if (typeof payload?.output_text === "string") {
+    return payload.output_text.trim();
+  }
+  if (!Array.isArray(payload?.output)) {
+    return "";
+  }
+  return payload.output.flatMap((item) => Array.isArray(item?.content) ? item.content : []).map((item) => item?.type === "output_text" ? item.text : "").filter((text) => typeof text === "string" && text.trim().length > 0).join("").trim();
+}
+async function buildOpenAIError(response) {
+  let detail = `Provider returned HTTP ${response.status}`;
+  try {
+    const data = await response.json();
+    const message = data?.error?.message;
+    if (typeof message === "string" && message.trim().length > 0) {
+      detail = `${detail}: ${message.trim()}`;
+    }
+  } catch {
+  }
+  return new Error(detail);
+}
+var OpenAIProvider = class {
+  name = "openai";
+  baseUrl;
+  apiKey;
+  constructor(options) {
+    this.baseUrl = options.baseUrl.replace(/\/$/, "");
+    this.apiKey = options.apiKey;
+  }
+  async generate(input) {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), input.timeoutMs);
+    try {
+      const url = new URL("responses", `${this.baseUrl}/`);
+      const response = await fetch(url, {
+        method: "POST",
+        signal: controller.signal,
+        headers: {
+          "content-type": "application/json",
+          ...this.apiKey ? { authorization: `Bearer ${this.apiKey}` } : {}
+        },
+        body: JSON.stringify({
+          model: input.model,
+          instructions: REDUCTION_SYSTEM_INSTRUCTION,
+          input: input.prompt,
+          reasoning: {
+            effort: "minimal"
+          },
+          text: {
+            verbosity: "low",
+            ...input.responseMode === "json" && usesNativeJsonResponseFormat(input.jsonResponseFormat) ? {
+              format: {
+                type: "json_object"
+              }
+            } : {}
+          },
+          max_output_tokens: input.maxOutputTokens
+        })
+      });
+      if (!response.ok) {
+        throw await buildOpenAIError(response);
+      }
+      const data = await response.json();
+      const text = extractResponseText(data);
+      if (!text) {
+        throw new Error("Provider returned an empty response");
+      }
+      const result = {
+        text,
+        usage: data?.usage ? {
+          inputTokens: data.usage.input_tokens,
+          outputTokens: data.usage.output_tokens,
+          totalTokens: data.usage.total_tokens
+        } : 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;
+    }
+  }
+};
+
+// src/providers/openaiCompatible.ts
+function supportsNativeJsonResponseFormat(baseUrl, mode) {
+  if (mode === "off") {
+    return false;
+  }
+  if (mode === "on") {
+    return true;
+  }
+  return /^https:\/\/api\.openai\.com(?:\/|$)/i.test(baseUrl);
+}
+function extractMessageText(payload) {
+  const content = payload?.choices?.[0]?.message?.content;
+  if (typeof content === "string") {
+    return content;
+  }
+  if (Array.isArray(content)) {
+    return content.map((item) => typeof item?.text === "string" ? item.text : "").join("").trim();
+  }
+  return "";
+}
+async function buildOpenAICompatibleError(response) {
+  let detail = `Provider returned HTTP ${response.status}`;
+  try {
+    const data = await response.json();
+    const message = data?.error?.message;
+    if (typeof message === "string" && message.trim().length > 0) {
+      detail = `${detail}: ${message.trim()}`;
+    }
+  } catch {
+  }
+  return new Error(detail);
+}
+var OpenAICompatibleProvider = class {
+  name = "openai-compatible";
+  baseUrl;
+  apiKey;
+  constructor(options) {
+    this.baseUrl = options.baseUrl.replace(/\/$/, "");
+    this.apiKey = options.apiKey;
+  }
+  async generate(input) {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), input.timeoutMs);
+    try {
+      const url = new URL("chat/completions", `${this.baseUrl}/`);
+      const response = await fetch(url, {
+        method: "POST",
+        signal: controller.signal,
+        headers: {
+          "content-type": "application/json",
+          ...this.apiKey ? { authorization: `Bearer ${this.apiKey}` } : {}
+        },
+        body: JSON.stringify({
+          model: input.model,
+          temperature: input.temperature,
+          max_tokens: input.maxOutputTokens,
+          ...input.responseMode === "json" && supportsNativeJsonResponseFormat(this.baseUrl, input.jsonResponseFormat) ? { response_format: { type: "json_object" } } : {},
+          messages: [
+            {
+              role: "system",
+              content: REDUCTION_SYSTEM_INSTRUCTION
+            },
+            {
+              role: "user",
+              content: input.prompt
+            }
+          ]
+        })
+      });
+      if (!response.ok) {
+        throw await buildOpenAICompatibleError(response);
+      }
+      const data = await response.json();
+      const text = extractMessageText(data);
+      if (!text.trim()) {
+        throw new Error("Provider returned an empty response");
+      }
+      const result = {
+        text,
+        usage: data?.usage ? {
+          inputTokens: data.usage.prompt_tokens,
+          outputTokens: data.usage.completion_tokens,
+          totalTokens: data.usage.total_tokens
+        } : 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;
+    }
+  }
+};
+
+// src/providers/factory.ts
+function createProvider(config) {
+  if (config.provider.provider === "openai") {
+    return new OpenAIProvider({
+      baseUrl: config.provider.baseUrl,
+      apiKey: config.provider.apiKey
+    });
+  }
+  if (config.provider.provider === "openai-compatible") {
+    return new OpenAICompatibleProvider({
+      baseUrl: config.provider.baseUrl,
+      apiKey: config.provider.apiKey
+    });
+  }
+  throw new Error(`Unsupported provider: ${config.provider.provider}`);
+}
+
+// src/prompts/formats.ts
+function getGenericFormatPolicy(format, outputContract) {
+  switch (format) {
+    case "brief":
+      return {
+        responseMode: "text",
+        taskRules: [
+          "Return 1 to 3 short sentences.",
+          `If the evidence is insufficient, reply exactly with: ${INSUFFICIENT_SIGNAL_TEXT}`
+        ]
+      };
+    case "bullets":
+      return {
+        responseMode: "text",
+        taskRules: [
+          "Return at most 5 short lines prefixed with '- '.",
+          `If the evidence is insufficient, reply exactly with: ${INSUFFICIENT_SIGNAL_TEXT}`
+        ]
+      };
+    case "verdict":
+      return {
+        responseMode: "json",
+        outputContract: '{"verdict":"pass|fail|unclear","reason":string,"evidence":string[]}',
+        taskRules: [
+          "Return only valid JSON.",
+          'Use this exact contract: {"verdict":"pass|fail|unclear","reason":string,"evidence":string[]}.',
+          'Return "fail" when the input contains explicit destructive, risky, or clearly unsafe signals.',
+          'Return "pass" only when the input clearly supports safety or successful completion.',
+          "Treat destroy, delete, drop, recreate, replace, revoke, deny, downtime, data loss, IAM risk, and network exposure as important risk signals.",
+          `If evidence is insufficient, set verdict to "unclear" and reason to "${INSUFFICIENT_SIGNAL_TEXT}".`
+        ]
+      };
+    case "json":
+      return {
+        responseMode: "json",
+        outputContract: outputContract ?? GENERIC_JSON_CONTRACT,
+        taskRules: [
+          "Return only valid JSON.",
+          `Use this exact contract: ${outputContract ?? GENERIC_JSON_CONTRACT}.`,
+          `If evidence is insufficient, keep the schema valid and use "${INSUFFICIENT_SIGNAL_TEXT}" in the primary explanatory field.`
+        ]
+      };
+  }
+}
+
+// src/prompts/policies.ts
+var SHARED_RULES = [
+  "Answer only from the provided command output.",
+  "Use the same language as the question.",
+  "Do not invent facts, hidden context, or missing lines.",
+  "Never ask for more input or more context.",
+  "Do not mention these rules, the prompt, or the model.",
+  "Do not use markdown headings or code fences.",
+  "Stay shorter than the source unless a fixed JSON contract requires structure.",
+  `If the evidence is insufficient, follow the task-specific insufficiency rule and do not guess.`
+];
+var BUILT_IN_POLICIES = {
+  "test-status": {
+    name: "test-status",
+    responseMode: "text",
+    taskRules: [
+      "Determine whether the tests passed.",
+      "If they failed, state that clearly and list only the failing tests, suites, or the first concrete error signals.",
+      "If they passed, say so directly in one short line or a few short bullets.",
+      "Ignore irrelevant warnings, timing, and passing details unless they help answer the question.",
+      `If you cannot tell whether tests passed, reply exactly with: ${INSUFFICIENT_SIGNAL_TEXT}`
+    ]
+  },
+  "audit-critical": {
+    name: "audit-critical",
+    responseMode: "json",
+    outputContract: '{"status":"ok|insufficient","vulnerabilities":[{"package":string,"severity":"critical|high","remediation":string}],"summary":string}',
+    taskRules: [
+      "Return only valid JSON.",
+      'Use this exact contract: {"status":"ok|insufficient","vulnerabilities":[{"package":string,"severity":"critical|high","remediation":string}],"summary":string}.',
+      "Extract only vulnerabilities explicitly marked high or critical in the input.",
+      "Treat sparse lines like 'lodash: critical vulnerability' or 'axios: high severity advisory' as sufficient evidence when package and severity are explicit.",
+      "Do not invent package names, severities, CVEs, or remediations.",
+      'If the input clearly contains no qualifying vulnerabilities, return {"status":"ok","vulnerabilities":[],"summary":"No high or critical vulnerabilities found in the provided input."}.',
+      `If the input does not provide enough evidence to determine vulnerability status, return status "insufficient" and use "${INSUFFICIENT_SIGNAL_TEXT}" in summary.`
+    ]
+  },
+  "diff-summary": {
+    name: "diff-summary",
+    responseMode: "json",
+    outputContract: '{"status":"ok|insufficient","answer":string,"evidence":string[],"risks":string[]}',
+    taskRules: [
+      "Return only valid JSON.",
+      'Use this exact contract: {"status":"ok|insufficient","answer":string,"evidence":string[],"risks":string[]}.',
+      "Summarize what changed at a high level, grounded only in the visible diff or output.",
+      "Evidence should cite the most important visible files, modules, resources, or actions.",
+      "Risks should include migrations, config changes, security changes, destructive actions, or unknown impact when visible.",
+      `If the change signal is incomplete, return status "insufficient" and use "${INSUFFICIENT_SIGNAL_TEXT}" in answer.`
+    ]
+  },
+  "build-failure": {
+    name: "build-failure",
+    responseMode: "text",
+    taskRules: [
+      "Identify the most likely root cause of the build failure.",
+      "Give the first concrete fix or next step in the same answer.",
+      "Keep the response to 1 or 2 short sentences.",
+      `If the root cause is not visible, reply exactly with: ${INSUFFICIENT_SIGNAL_TEXT}`
+    ]
+  },
+  "log-errors": {
+    name: "log-errors",
+    responseMode: "text",
+    taskRules: [
+      "Return at most 5 short bullet points.",
+      "Extract only the most relevant error or failure signals.",
+      "Prefer recurring or top-level errors over long stack traces.",
+      "Do not dump full traces unless a single trace line is the key signal.",
+      `If there is no clear error signal, reply exactly with: ${INSUFFICIENT_SIGNAL_TEXT}`
+    ]
+  },
+  "typecheck-summary": {
+    name: "typecheck-summary",
+    responseMode: "text",
+    taskRules: [
+      "Return at most 5 short bullet points.",
+      "Determine whether the typecheck failed or passed.",
+      "Group repeated diagnostics into root-cause buckets instead of echoing many duplicate lines.",
+      "Mention the first concrete files, symbols, or error categories to fix when they are visible.",
+      "Prefer compiler or type-system errors over timing, progress, or summary noise.",
+      "If the output clearly indicates success, say that briefly and do not add extra bullets.",
+      `If you cannot tell whether the typecheck failed, reply exactly with: ${INSUFFICIENT_SIGNAL_TEXT}`
+    ]
+  },
+  "lint-failures": {
+    name: "lint-failures",
+    responseMode: "text",
+    taskRules: [
+      "Return at most 5 short bullet points.",
+      "Determine whether lint failed or whether there are no blocking lint failures.",
+      "Group repeated rule violations instead of listing the same rule many times.",
+      "Mention the top offending files and rule names when they are visible.",
+      "Distinguish blocking failures from warnings only when that distinction is clearly visible in the input.",
+      "Do not invent autofixability; only mention autofix or --fix support when the tool output explicitly says so.",
+      "If the output clearly indicates success or no blocking failures, say that briefly and stop.",
+      `If there is not enough evidence to determine the lint result, reply exactly with: ${INSUFFICIENT_SIGNAL_TEXT}`
+    ]
+  },
+  "infra-risk": {
+    name: "infra-risk",
+    responseMode: "json",
+    outputContract: '{"verdict":"pass|fail|unclear","reason":string,"evidence":string[]}',
+    taskRules: [
+      "Return only valid JSON.",
+      'Use this exact contract: {"verdict":"pass|fail|unclear","reason":string,"evidence":string[]}.',
+      'Return "fail" when the input contains explicit destructive or clearly risky signals such as destroy, delete, drop, recreate, replace, revoke, deny, downtime, data loss, IAM risk, or network exposure.',
+      'Treat short plan summaries like "1 to destroy" or "resources to destroy" as enough evidence for "fail".',
+      'Return "pass" only when the input clearly shows no risky changes or explicitly safe behavior.',
+      'Return "unclear" when the input is incomplete, ambiguous, or does not show enough evidence to judge safety.',
+      "Evidence should contain the shortest concrete lines or phrases that justify the verdict."
+    ]
+  }
+};
+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 {
+      ...policy,
+      sharedRules: SHARED_RULES
+    };
+  }
+  const genericPolicy = getGenericFormatPolicy(args.format, args.outputContract);
+  return {
+    name: `generic-${args.format}`,
+    responseMode: genericPolicy.responseMode,
+    outputContract: genericPolicy.outputContract,
+    sharedRules: SHARED_RULES,
+    taskRules: genericPolicy.taskRules
+  };
+}
+
+// src/prompts/buildPrompt.ts
+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}`,
+    "",
+    "Command output:",
+    '"""',
+    args.input,
+    '"""'
+  ].join("\n");
+  return {
+    prompt,
+    responseMode: policy.responseMode
+  };
+}
+
+// src/core/quality.ts
+var META_PATTERNS = [
+  /please provide/i,
+  /need more (?:input|context|information|details)/i,
+  /provided command output/i,
+  /based on the provided/i,
+  /as an ai/i,
+  /here(?:'s| is) (?:the )?(?:json|answer)/i,
+  /cannot determine without/i
+];
+function normalizeForComparison(input) {
+  return input.replace(/\r\n/g, "\n").replace(/\r/g, "\n").replace(/\s+/g, " ").trim();
+}
+function isRetriableReason(reason) {
+  return /timed out|http 408|http 409|http 425|http 429|http 5\d\d|network/i.test(
+    reason.toLowerCase()
+  );
 }
-function testStatusHeuristic(input, detail = "standard") {
-  const normalized = input.trim();
-  if (normalized === "") {
-    return null;
+function looksLikeRejectedModelOutput(args) {
+  const source = normalizeForComparison(args.source);
+  const candidate = normalizeForComparison(args.candidate);
+  if (!candidate) {
+    return true;
   }
-  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 inlineItems = collectInlineFailureItems(input);
-  if (collectionErrors) {
-    const count = Number(collectionErrors[1]);
-    const items = chooseStrongestFailureItems(collectCollectionFailureItems(input));
-    if (detail === "verbose") {
-      if (items.length > 0) {
-        return [
-          "- Tests did not complete.",
-          `- ${formatCount(count, "error")} occurred during collection.`,
-          ...formatVerboseFailureItems({
-            items
-          })
-        ].join("\n");
-      }
-    }
-    if (detail === "focused") {
-      if (items.length > 0) {
-        const groupedLines = formatFocusedFailureGroups({
-          items,
-          remainderLabel: "modules"
-        });
-        if (groupedLines.length > 0) {
-          return [
-            "- Tests did not complete.",
-            `- ${formatCount(count, "error")} occurred during collection.`,
-            ...groupedLines
-          ].join("\n");
-        }
-      }
-    }
-    const causes = summarizeRepeatedTestCauses(input, {
-      duringCollection: true
-    });
-    return [
-      "- Tests did not complete.",
-      `- ${formatCount(count, "error")} occurred during collection.`,
-      ...causes
-    ].join("\n");
+  if (candidate === INSUFFICIENT_SIGNAL_TEXT) {
+    return false;
   }
-  if (noTestsCollected) {
-    return ["- Tests did not run.", "- Collected 0 items."].join("\n");
+  if (candidate.includes("```")) {
+    return true;
   }
-  if (interrupted && failed === 0 && errors === 0) {
-    return "- Test run was interrupted.";
+  if (META_PATTERNS.some((pattern) => pattern.test(candidate))) {
+    return true;
   }
-  if (failed === 0 && errors === 0 && passed > 0) {
-    const details = [formatCount(passed, "test")];
-    if (skipped > 0) {
-      details.push(formatCount(skipped, "skip"));
+  if (args.responseMode === "json") {
+    const trimmed = args.candidate.trim();
+    if (!trimmed.startsWith("{") && !trimmed.startsWith("[")) {
+      return true;
     }
-    return [
-      "- Tests passed.",
-      `- ${details.join(", ")}.`
-    ].join("\n");
   }
-  if (failed > 0 || errors > 0 || inlineItems.length > 0) {
-    const summarizedInlineItems = chooseStrongestFailureItems(inlineItems);
-    if (detail === "verbose") {
-      if (summarizedInlineItems.length > 0) {
-        const detailLines2 = [];
-        if (failed > 0) {
-          detailLines2.push(`- ${formatCount(failed, "test")} failed.`);
-        }
-        if (errors > 0) {
-          detailLines2.push(`- ${formatCount(errors, "error")} occurred.`);
-        }
-        return [
-          "- Tests did not pass.",
-          ...detailLines2,
-          ...formatVerboseFailureItems({
-            items: summarizedInlineItems
-          })
-        ].join("\n");
-      }
-    }
-    if (detail === "focused") {
-      if (summarizedInlineItems.length > 0) {
-        const detailLines2 = [];
-        if (failed > 0) {
-          detailLines2.push(`- ${formatCount(failed, "test")} failed.`);
-        }
-        if (errors > 0) {
-          detailLines2.push(`- ${formatCount(errors, "error")} occurred.`);
-        }
-        return [
-          "- Tests did not pass.",
-          ...detailLines2,
-          ...formatFocusedFailureGroups({
-            items: summarizedInlineItems,
-            remainderLabel: "tests or modules"
-          })
-        ].join("\n");
-      }
-    }
-    const detailLines = [];
-    const causes = summarizeRepeatedTestCauses(input, {
-      duringCollection: false
-    });
-    if (failed > 0) {
-      detailLines.push(`- ${formatCount(failed, "test")} failed.`);
-    }
-    if (errors > 0) {
-      detailLines.push(`- ${formatCount(errors, "error")} occurred.`);
-    }
-    const evidence = input.split("\n").map((line) => line.trim()).filter((line) => /\b(FAILED|ERROR)\b/.test(line)).slice(0, 3).map((line) => `- ${line}`);
-    return ["- Tests did not pass.", ...detailLines, ...causes, ...evidence].join("\n");
+  if (source.length >= 800 && candidate.length > source.length * 0.8) {
+    return true;
   }
-  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;
+  if (source.length > 0 && source.length < 800 && candidate.length > source.length + 160) {
+    return true;
   }
-  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
-  );
+  return false;
 }
-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) {
+
+// src/core/fallback.ts
+var RAW_FALLBACK_SLICE = 1200;
+function buildStructuredError(reason) {
+  return {
+    status: "error",
+    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) {
+  if (args.format === "verdict") {
     return JSON.stringify(
       {
-        verdict: "pass",
-        reason: "The provided input explicitly indicates no risky infrastructure changes.",
-        evidence: safeEvidence
+        ...buildStructuredError(args.reason),
+        verdict: "unclear",
+        reason: `Sift fallback: ${args.reason}`,
+        evidence: []
       },
       null,
       2
     );
   }
-  return null;
-}
-function applyHeuristicPolicy(policyName, input, detail) {
-  if (!policyName) {
-    return null;
-  }
-  if (policyName === "audit-critical") {
-    return auditCriticalHeuristic(input);
-  }
-  if (policyName === "infra-risk") {
-    return infraRiskHeuristic(input);
+  if (args.format === "json") {
+    return JSON.stringify(buildStructuredError(args.reason), null, 2);
   }
-  if (policyName === "test-status") {
-    return testStatusHeuristic(input, detail);
+  const prefix = `Sift fallback triggered (${args.reason}).`;
+  const rawHint = "Raw may still be needed because provider follow-up failed.";
+  if (!args.rawFallback) {
+    return `${prefix} ${rawHint}`;
   }
-  return null;
+  return [prefix, rawHint, "", args.rawInput.slice(-RAW_FALLBACK_SLICE)].join("\n");
 }
 
 // src/core/redact.ts
@@ -1195,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();
@@ -1212,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,
@@ -1278,77 +3108,303 @@ async function generateWithRetry(args) {
   }
   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;
+  }
+  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,
-    detail: request.detail,
-    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,
-    request.detail
-  );
+  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,
-        responseMode,
+        prompt: heuristicPrompt.prompt,
+        responseMode: heuristicPrompt.responseMode,
         prepared,
-        heuristicOutput
+        heuristicOutput,
+        strategy: "heuristic"
       });
     }
-    return withInsufficientHint({
+    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: 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,
+        contract: failureDecision.contract,
+        finalOutput,
+        rawSliceChars: rawSlice.text.length,
+        providerInputChars: providerPrepared2.truncated.length
+      });
+      return finalOutput;
+    }
   }
+  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 withInsufficientHint({
-      output: normalizeOutput(result.text, responseMode),
+      output: normalizeOutput(result.text, providerPrompt.responseMode),
       request,
-      prepared
+      prepared: providerPrepared
     });
   } catch (error) {
     const reason = error instanceof Error ? error.message : "unknown_error";
@@ -1356,14 +3412,595 @@ async function runSift(request) {
       output: buildFallbackOutput({
         format: request.format,
         reason,
-        rawInput: prepared.truncated,
+        rawInput: providerPrepared.truncated,
         rawFallback: request.config.runtime.rawFallback,
         jsonFallback: request.fallbackJson
       }),
       request,
-      prepared
+      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
@@ -1460,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}
 `
     );
   }
@@ -1472,8 +4113,10 @@ async function runExec(request) {
   let childStatus = null;
   let childSignal = 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) => {
@@ -1513,12 +4156,19 @@ async function runExec(request) {
   });
   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) {
     if (request.showRaw && capturedOutput.length > 0) {
       process.stderr.write(capturedOutput);
@@ -1526,7 +4176,7 @@ async function runExec(request) {
         process.stderr.write("\n");
       }
     }
-    const execSuccessShortcut = getExecSuccessShortcut({
+    const execSuccessShortcut = useWatchFlow ? null : getExecSuccessShortcut({
       presetName: request.presetName,
       exitCode,
       capturedOutput
@@ -1542,11 +4192,108 @@ async function runExec(request) {
 `);
       return exitCode;
     }
+    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 (isInsufficientSignalOutput(output)) {
+    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(),
@@ -1638,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;
     }
   }
@@ -1661,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) ?? {};
 }
 
@@ -1715,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",
@@ -1735,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