@bilalimamoglu/sift 0.3.0 → 0.3.2

package/dist/cli.js

@@ -136,6 +136,78 @@ var defaultConfig = {
   }
 };
 
+// src/config/native-provider.ts
+function getNativeProviderDefaults(provider) {
+  if (provider === "openrouter") {
+    return {
+      provider,
+      model: "openrouter/free",
+      baseUrl: "https://openrouter.ai/api/v1"
+    };
+  }
+  return {
+    provider,
+    model: defaultConfig.provider.model,
+    baseUrl: defaultConfig.provider.baseUrl
+  };
+}
+function getProfileProviderState(provider, profile) {
+  const defaults = getNativeProviderDefaults(provider);
+  return {
+    provider,
+    model: profile?.model ?? defaults.model,
+    baseUrl: profile?.baseUrl ?? defaults.baseUrl
+  };
+}
+function getStoredProviderProfile(config, provider) {
+  const existingProfile = config.providerProfiles?.[provider];
+  if (existingProfile) {
+    return existingProfile;
+  }
+  if (config.provider.provider !== provider) {
+    return void 0;
+  }
+  return {
+    model: config.provider.model,
+    baseUrl: config.provider.baseUrl,
+    apiKey: config.provider.apiKey || void 0
+  };
+}
+function setStoredProviderProfile(config, provider, profile) {
+  const providerProfiles = {
+    ...config.providerProfiles ?? {},
+    [provider]: profile
+  };
+  return {
+    ...config,
+    providerProfiles
+  };
+}
+function preserveActiveNativeProviderProfile(config) {
+  const provider = config.provider.provider;
+  if (provider !== "openai" && provider !== "openrouter") {
+    return config;
+  }
+  if (config.providerProfiles?.[provider]) {
+    return config;
+  }
+  return setStoredProviderProfile(config, provider, {
+    model: config.provider.model,
+    baseUrl: config.provider.baseUrl,
+    apiKey: config.provider.apiKey || void 0
+  });
+}
+function applyActiveProvider(config, provider, profile, apiKey) {
+  return {
+    ...config,
+    provider: {
+      ...config.provider,
+      ...getProfileProviderState(provider, profile),
+      apiKey
+    }
+  };
+}
+
 // src/config/provider-api-key.ts
 var OPENAI_COMPATIBLE_BASE_URL_ENV = [
   { prefix: "https://api.openai.com/", envName: "OPENAI_API_KEY" },
@@ -143,13 +215,16 @@ var OPENAI_COMPATIBLE_BASE_URL_ENV = [
   { prefix: "https://api.together.xyz/", envName: "TOGETHER_API_KEY" },
   { prefix: "https://api.groq.com/openai/", envName: "GROQ_API_KEY" }
 ];
+var NATIVE_PROVIDER_API_KEY_ENV = {
+  openai: "OPENAI_API_KEY",
+  openrouter: "OPENROUTER_API_KEY"
+};
 var PROVIDER_API_KEY_ENV = {
   anthropic: "ANTHROPIC_API_KEY",
   claude: "ANTHROPIC_API_KEY",
   groq: "GROQ_API_KEY",
-  openai: "OPENAI_API_KEY",
-  openrouter: "OPENROUTER_API_KEY",
-  together: "TOGETHER_API_KEY"
+  together: "TOGETHER_API_KEY",
+  ...NATIVE_PROVIDER_API_KEY_ENV
 };
 function normalizeBaseUrl(baseUrl) {
   if (!baseUrl) {
@@ -184,6 +259,9 @@ function resolveProviderApiKey(provider, baseUrl, env) {
   }
   return env.SIFT_PROVIDER_API_KEY;
 }
+function getNativeProviderApiKeyEnvName(provider) {
+  return NATIVE_PROVIDER_API_KEY_ENV[provider];
+}
 function getProviderApiKeyEnvNames(provider, baseUrl) {
   const envNames = ["SIFT_PROVIDER_API_KEY"];
   if (provider === "openai-compatible") {
@@ -205,7 +283,11 @@ function getProviderApiKeyEnvNames(provider, baseUrl) {
 
 // src/config/schema.ts
 import { z } from "zod";
-var providerNameSchema = z.enum(["openai", "openai-compatible"]);
+var providerNameSchema = z.enum([
+  "openai",
+  "openai-compatible",
+  "openrouter"
+]);
 var outputFormatSchema = z.enum([
   "brief",
   "bullets",
@@ -234,6 +316,15 @@ var providerConfigSchema = z.object({
   temperature: z.number().min(0).max(2),
   maxOutputTokens: z.number().int().positive()
 });
+var providerProfileSchema = z.object({
+  model: z.string().min(1).optional(),
+  baseUrl: z.string().url().optional(),
+  apiKey: z.string().optional()
+});
+var providerProfilesSchema = z.object({
+  openai: providerProfileSchema.optional(),
+  openrouter: providerProfileSchema.optional()
+}).optional();
 var inputConfigSchema = z.object({
   stripAnsi: z.boolean(),
   redact: z.boolean(),
@@ -258,10 +349,19 @@ var siftConfigSchema = z.object({
   provider: providerConfigSchema,
   input: inputConfigSchema,
   runtime: runtimeConfigSchema,
-  presets: z.record(presetDefinitionSchema)
+  presets: z.record(presetDefinitionSchema),
+  providerProfiles: providerProfilesSchema
 });
 
 // src/config/resolve.ts
+var PROVIDER_DEFAULT_OVERRIDES = {
+  openrouter: {
+    provider: {
+      model: "openrouter/free",
+      baseUrl: "https://openrouter.ai/api/v1"
+    }
+  }
+};
 function isRecord(value) {
   return Boolean(value) && typeof value === "object" && !Array.isArray(value);
 }
@@ -324,13 +424,32 @@ function buildCredentialEnvOverrides(env, context) {
     }
   };
 }
+function getBaseConfigForProvider(provider) {
+  return mergeDefined(defaultConfig, provider ? PROVIDER_DEFAULT_OVERRIDES[provider] : {});
+}
+function resolveProvisionalProvider(args) {
+  const provisional = mergeDefined(
+    mergeDefined(
+      mergeDefined(defaultConfig, args.fileConfig),
+      args.nonCredentialEnvConfig
+    ),
+    stripApiKey(args.cliOverrides) ?? {}
+  );
+  return provisional.provider.provider;
+}
 function resolveConfig(options = {}) {
   const env = options.env ?? process.env;
   const fileConfig = loadRawConfig(options.configPath);
   const nonCredentialEnvConfig = buildNonCredentialEnvOverrides(env);
+  const provisionalProvider = resolveProvisionalProvider({
+    fileConfig,
+    nonCredentialEnvConfig,
+    cliOverrides: options.cliOverrides
+  });
+  const baseConfig = getBaseConfigForProvider(provisionalProvider);
   const contextConfig = mergeDefined(
     mergeDefined(
-      mergeDefined(defaultConfig, fileConfig),
+      mergeDefined(baseConfig, fileConfig),
       nonCredentialEnvConfig
     ),
     stripApiKey(options.cliOverrides) ?? {}
@@ -342,7 +461,7 @@ function resolveConfig(options = {}) {
   const merged = mergeDefined(
     mergeDefined(
       mergeDefined(
-        mergeDefined(defaultConfig, fileConfig),
+        mergeDefined(baseConfig, fileConfig),
         nonCredentialEnvConfig
       ),
       credentialEnvConfig
@@ -387,6 +506,32 @@ function writeConfigFile(options) {
   return resolved;
 }
 
+// src/config/editable.ts
+import fs3 from "fs";
+import path4 from "path";
+function isRecord2(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function resolveEditableConfigPath(explicitPath) {
+  if (explicitPath) {
+    return path4.resolve(explicitPath);
+  }
+  return findConfigPath() ?? getDefaultGlobalConfigPath();
+}
+function loadEditableConfig(explicitPath) {
+  const resolvedPath = resolveEditableConfigPath(explicitPath);
+  const existed = fs3.existsSync(resolvedPath);
+  const rawConfig = existed ? loadRawConfig(resolvedPath) : {};
+  const config = siftConfigSchema.parse(
+    mergeDefined(defaultConfig, isRecord2(rawConfig) ? rawConfig : {})
+  );
+  return {
+    config,
+    existed,
+    resolvedPath
+  };
+}
+
 // src/ui/presentation.ts
 import pc from "picocolors";
 function applyColor(enabled, formatter, value) {
@@ -437,8 +582,7 @@ ${tagline}`;
 }
 
 // src/commands/config-setup.ts
-import fs3 from "fs";
-import path4 from "path";
+import path5 from "path";
 import { emitKeypressEvents } from "readline";
 import { createInterface } from "readline/promises";
 import { stderr as defaultStderr, stdin as defaultStdin2, stdout as defaultStdout } from "process";
@@ -636,59 +780,102 @@ function createTerminalIO() {
   };
 }
 function resolveSetupPath(targetPath) {
-  return targetPath ? path4.resolve(targetPath) : getDefaultGlobalConfigPath();
-}
-function buildOpenAISetupConfig(apiKey) {
-  return {
-    ...defaultConfig,
-    provider: {
-      ...defaultConfig.provider,
-      provider: "openai",
-      model: "gpt-5-nano",
-      baseUrl: "https://api.openai.com/v1",
-      apiKey
-    }
-  };
+  return targetPath ? path5.resolve(targetPath) : getDefaultGlobalConfigPath();
 }
 function getSetupPresenter(io) {
   return createPresentation(io.stdoutIsTTY);
 }
+function getProviderLabel(provider) {
+  return provider === "openrouter" ? "OpenRouter" : "OpenAI";
+}
 async function promptForProvider(io) {
   if (io.select) {
-    const choice = await io.select("Select provider for this machine", ["OpenAI"]);
+    const choice = await io.select("Select provider for this machine", [
+      "OpenAI",
+      "OpenRouter"
+    ]);
     if (choice === "OpenAI") {
       return "openai";
     }
+    if (choice === "OpenRouter") {
+      return "openrouter";
+    }
   }
   while (true) {
-    const answer = (await io.ask("Provider [OpenAI]: ")).trim().toLowerCase();
+    const answer = (await io.ask("Provider [OpenAI/OpenRouter]: ")).trim().toLowerCase();
     if (answer === "" || answer === "openai") {
       return "openai";
     }
-    io.error("Only OpenAI is supported in guided setup right now.\n");
+    if (answer === "openrouter") {
+      return "openrouter";
+    }
+    io.error("Only OpenAI and OpenRouter are supported in guided setup right now.\n");
   }
 }
-async function promptForApiKey(io) {
+async function promptForApiKey(io, provider) {
+  const providerLabel = getProviderLabel(provider);
+  const promptText = `Enter your ${providerLabel} API key (input hidden): `;
+  const visiblePromptText = `Enter your ${providerLabel} API key: `;
   while (true) {
-    const answer = (await (io.secret ? io.secret("Enter your OpenAI API key (input hidden): ") : io.ask("Enter your OpenAI API key: "))).trim();
+    const answer = (await (io.secret ? io.secret(promptText) : io.ask(visiblePromptText))).trim();
     if (answer.length > 0) {
       return answer;
     }
     io.error("API key cannot be empty.\n");
   }
 }
-async function promptForOverwrite(io, targetPath) {
+async function promptForApiKeyChoice(args) {
+  const providerLabel = getProviderLabel(args.provider);
+  if (!args.hasSavedKey && !args.hasEnvKey) {
+    return "override";
+  }
+  if (args.hasSavedKey && args.hasEnvKey) {
+    if (args.io.select) {
+      const choice = await args.io.select(
+        `Found both a saved ${providerLabel} API key and ${args.envName} in your environment`,
+        ["Use saved key", "Use env key", "Override"]
+      );
+      if (choice === "Use saved key") {
+        return "saved";
+      }
+      if (choice === "Use env key") {
+        return "env";
+      }
+    }
+    while (true) {
+      const answer = (await args.io.ask("API key choice [saved/env/override]: ")).trim().toLowerCase();
+      if (answer === "" || answer === "saved") {
+        return "saved";
+      }
+      if (answer === "env") {
+        return "env";
+      }
+      if (answer === "override") {
+        return "override";
+      }
+      args.io.error("Please answer saved, env, or override.\n");
+    }
+  }
+  const sourceLabel = args.hasSavedKey ? "saved key" : `${args.envName} from your environment`;
+  if (args.io.select) {
+    const choice = await args.io.select(
+      `Found an existing ${providerLabel} API key via ${sourceLabel}`,
+      ["Use existing key", "Override"]
+    );
+    if (choice === "Override") {
+      return "override";
+    }
+    return args.hasSavedKey ? "saved" : "env";
+  }
   while (true) {
-    const answer = (await io.ask(
-      `Config file already exists at ${targetPath}. Overwrite? [y/N]: `
-    )).trim().toLowerCase();
-    if (answer === "" || answer === "n" || answer === "no") {
-      return false;
+    const answer = (await args.io.ask("API key choice [existing/override]: ")).trim().toLowerCase();
+    if (answer === "" || answer === "existing") {
+      return args.hasSavedKey ? "saved" : "env";
     }
-    if (answer === "y" || answer === "yes") {
-      return true;
+    if (answer === "override") {
+      return "override";
     }
-    io.error("Please answer y or n.\n");
+    args.io.error("Please answer existing or override.\n");
   }
 }
 function writeSetupSuccess(io, writtenPath) {
@@ -722,10 +909,86 @@ ${ui.section("Try next")}
   io.write(`  ${ui.command("sift exec --preset test-status -- npm test")}
 `);
 }
+function writeProviderDefaults(io, provider) {
+  const ui = getSetupPresenter(io);
+  if (provider === "openrouter") {
+    io.write(`${ui.info("Using OpenRouter defaults for your first run.")}
+`);
+    io.write(`${ui.labelValue("Default model", "openrouter/free")}
+`);
+    io.write(`${ui.labelValue("Default base URL", "https://openrouter.ai/api/v1")}
+`);
+  } else {
+    io.write(`${ui.info("Using OpenAI defaults for your first run.")}
+`);
+    io.write(`${ui.labelValue("Default model", "gpt-5-nano")}
+`);
+    io.write(`${ui.labelValue("Default base URL", "https://api.openai.com/v1")}
+`);
+  }
+  io.write(
+    `${ui.note("Want to switch providers later? Run 'sift config use openai' or 'sift config use openrouter'.")}
+`
+  );
+  io.write(
+    `${ui.note("Want to inspect the active values first? Run 'sift config show --show-secrets'.")}
+`
+  );
+}
+function materializeProfile(provider, profile, apiKey) {
+  return {
+    ...getProfileProviderState(provider, profile),
+    ...apiKey !== void 0 ? { apiKey } : {}
+  };
+}
+function buildSetupConfig(args) {
+  const preservedConfig = preserveActiveNativeProviderProfile(args.config);
+  const storedProfile = getStoredProviderProfile(preservedConfig, args.provider);
+  if (args.apiKeyChoice === "saved") {
+    const profile2 = materializeProfile(
+      args.provider,
+      storedProfile,
+      storedProfile?.apiKey ?? ""
+    );
+    const configWithProfile2 = setStoredProviderProfile(
+      preservedConfig,
+      args.provider,
+      profile2
+    );
+    return applyActiveProvider(
+      configWithProfile2,
+      args.provider,
+      profile2,
+      profile2.apiKey ?? ""
+    );
+  }
+  if (args.apiKeyChoice === "env") {
+    const profile2 = storedProfile ? storedProfile : materializeProfile(args.provider, void 0);
+    const configWithProfile2 = storedProfile ? preservedConfig : setStoredProviderProfile(preservedConfig, args.provider, profile2);
+    return applyActiveProvider(configWithProfile2, args.provider, profile2, "");
+  }
+  const profile = materializeProfile(
+    args.provider,
+    storedProfile,
+    args.nextApiKey ?? ""
+  );
+  const configWithProfile = setStoredProviderProfile(
+    preservedConfig,
+    args.provider,
+    profile
+  );
+  return applyActiveProvider(
+    configWithProfile,
+    args.provider,
+    profile,
+    args.nextApiKey ?? ""
+  );
+}
 async function configSetup(options = {}) {
   void options.global;
   const io = options.io ?? createTerminalIO();
   const ui = getSetupPresenter(io);
+  const env = options.env ?? process.env;
   try {
     if (!io.stdinIsTTY || !io.stdoutIsTTY) {
       io.error(
@@ -736,39 +999,43 @@ async function configSetup(options = {}) {
     io.write(`${ui.welcome("Let's keep the expensive model for the interesting bits.")}
 `);
     const resolvedPath = resolveSetupPath(options.targetPath);
-    if (fs3.existsSync(resolvedPath)) {
-      const shouldOverwrite = await promptForOverwrite(io, resolvedPath);
-      if (!shouldOverwrite) {
-        io.write(`${ui.note("Aborted.")}
+    const { config: existingConfig, existed } = loadEditableConfig(resolvedPath);
+    if (existed) {
+      io.write(`${ui.info(`Updating existing config at ${resolvedPath}.`)}
 `);
-        return 1;
-      }
     }
-    await promptForProvider(io);
-    io.write(`${ui.info("Using OpenAI defaults for your first run.")}
-`);
-    io.write(`${ui.labelValue("Default model", "gpt-5-nano")}
-`);
-    io.write(`${ui.labelValue("Default base URL", "https://api.openai.com/v1")}
-`);
-    io.write(
-      `${ui.note(`Want to switch providers or tweak defaults later? Edit ${resolvedPath}.`)}
-`
-    );
-    io.write(
-      `${ui.note("Want to inspect the active values first? Run 'sift config show --show-secrets'.")}
-`
-    );
-    const apiKey = await promptForApiKey(io);
-    const config = buildOpenAISetupConfig(apiKey);
+    const provider = await promptForProvider(io);
+    writeProviderDefaults(io, provider);
+    const storedProfile = getStoredProviderProfile(existingConfig, provider);
+    const envName = getNativeProviderApiKeyEnvName(provider);
+    const apiKeyChoice = await promptForApiKeyChoice({
+      io,
+      provider,
+      envName,
+      hasSavedKey: Boolean(storedProfile?.apiKey),
+      hasEnvKey: Boolean(env[envName])
+    });
+    const nextApiKey = apiKeyChoice === "override" ? await promptForApiKey(io, provider) : void 0;
+    const config = buildSetupConfig({
+      config: existingConfig,
+      provider,
+      apiKeyChoice,
+      nextApiKey
+    });
     const writtenPath = writeConfigFile({
       targetPath: resolvedPath,
       config,
-      overwrite: true
+      overwrite: existed
     });
+    if (apiKeyChoice === "env") {
+      io.write(
+        `${ui.note(`Using ${envName} from the environment. No API key was written to config.`)}
+`
+      );
+    }
     writeSetupSuccess(io, writtenPath);
     const activeConfigPath = findConfigPath();
-    if (activeConfigPath && path4.resolve(activeConfigPath) !== path4.resolve(writtenPath)) {
+    if (activeConfigPath && path5.resolve(activeConfigPath) !== path5.resolve(writtenPath)) {
       writeOverrideWarning(io, activeConfigPath);
     }
     writeNextSteps(io);
@@ -798,18 +1065,18 @@ function maskConfigSecrets(value) {
   return output;
 }
 function configInit(targetPath, global = false) {
-  const path7 = writeExampleConfig({
+  const path8 = writeExampleConfig({
     targetPath,
     global
   });
   if (!process.stdout.isTTY) {
-    process.stdout.write(`${path7}
+    process.stdout.write(`${path8}
 `);
     return;
   }
   const ui = createPresentation(true);
   process.stdout.write(
-    `${ui.success(`${global ? "Machine-wide" : "Template"} config written to ${path7}`)}
+    `${ui.success(`${global ? "Machine-wide" : "Template"} config written to ${path8}`)}
 `
   );
 }
@@ -838,11 +1105,61 @@ function configValidate(configPath) {
   process.stdout.write(`${ui.success(message)}
 `);
 }
+function isNativeProviderName(value) {
+  return value === "openai" || value === "openrouter";
+}
+function configUse(provider, configPath, env = process.env) {
+  if (!isNativeProviderName(provider)) {
+    throw new Error(`Unsupported config provider: ${provider}`);
+  }
+  const { config, existed, resolvedPath } = loadEditableConfig(configPath);
+  const preservedConfig = preserveActiveNativeProviderProfile(config);
+  const storedProfile = getStoredProviderProfile(preservedConfig, provider);
+  const envName = getNativeProviderApiKeyEnvName(provider);
+  const envKey = env[envName];
+  if (!storedProfile?.apiKey && !envKey) {
+    throw new Error(
+      `No saved ${provider} API key or ${envName} found. Run 'sift config setup' first.`
+    );
+  }
+  const nextConfig = applyActiveProvider(
+    preservedConfig,
+    provider,
+    storedProfile,
+    storedProfile?.apiKey ?? ""
+  );
+  writeConfigFile({
+    targetPath: resolvedPath,
+    config: nextConfig,
+    overwrite: existed
+  });
+  const message = `Switched active provider to ${provider} (${resolvedPath}).`;
+  if (!process.stdout.isTTY) {
+    process.stdout.write(`${message}
+`);
+    if (!storedProfile?.apiKey && envKey) {
+      process.stdout.write(
+        `Using ${envName} from the environment. No API key was written to config.
+`
+      );
+    }
+    return;
+  }
+  const ui = createPresentation(true);
+  process.stdout.write(`${ui.success(message)}
+`);
+  if (!storedProfile?.apiKey && envKey) {
+    process.stdout.write(
+      `${ui.note(`Using ${envName} from the environment. No API key was written to config.`)}
+`
+    );
+  }
+}
 
 // src/commands/agent.ts
 import fs4 from "fs";
 import os2 from "os";
-import path5 from "path";
+import path6 from "path";
 import { createInterface as createInterface2 } from "readline/promises";
 import { stderr as defaultStderr2, stdin as defaultStdin3, stdout as defaultStdout2 } from "process";
 var AGENT_FILENAMES = {
@@ -907,14 +1224,14 @@ function normalizeAgentScope(value) {
 }
 function resolveAgentTargetPath(args) {
   if (args.targetPath) {
-    return path5.resolve(args.cwd ?? process.cwd(), args.targetPath);
+    return path6.resolve(args.cwd ?? process.cwd(), args.targetPath);
   }
   const scope = args.scope ?? "repo";
   if (scope === "global") {
     const homeDir = args.homeDir ?? os2.homedir();
     return args.agent === "codex" ? getDefaultCodexGlobalInstructionsPath(homeDir) : getDefaultClaudeGlobalInstructionsPath(homeDir);
   }
-  return path5.resolve(args.cwd ?? process.cwd(), AGENT_FILENAMES[args.agent]);
+  return path6.resolve(args.cwd ?? process.cwd(), AGENT_FILENAMES[args.agent]);
 }
 function getManagedBlockMarkers(agent) {
   return {
@@ -949,6 +1266,7 @@ function renderInstructionBody() {
     "- Start with `standard` text. Use diagnose JSON only when automation or machine branching truly needs it.",
     "- If `standard` already shows bucket-level root cause, anchor, and fix lines, trust it and report from it directly.",
     "- In that case, do not re-verify the same bucket with raw pytest; at most do one targeted source read before you edit.",
+    "- If `standard` still contains an unknown bucket or ends with `Decision: zoom`, do one deeper sift pass before raw traceback.",
     "- If you need a machine-readable diagnosis, use `sift exec --preset test-status --goal diagnose --format json -- <test command>` or the same shape with `sift rerun` / `sift watch --preset test-status`.",
     "- Diagnose JSON is summary-first by default. Add `--include-test-ids` only when you truly need the raw failing test IDs.",
     "- If diagnose JSON returns `read_targets.context_hint.start_line/end_line`, read only that small line range first.",
@@ -1478,7 +1796,7 @@ function readOptionalFile(targetPath) {
   return fs4.readFileSync(targetPath, "utf8");
 }
 function writeTextFileAtomic(targetPath, content) {
-  fs4.mkdirSync(path5.dirname(targetPath), { recursive: true });
+  fs4.mkdirSync(path6.dirname(targetPath), { recursive: true });
   const tempPath = `${targetPath}.tmp-${process.pid}-${Date.now()}`;
   fs4.writeFileSync(tempPath, content, "utf8");
   fs4.renameSync(tempPath, targetPath);
@@ -1512,7 +1830,7 @@ function runDoctor(config, configPath) {
   if (!config.provider.model) {
     problems.push("Missing provider.model");
   }
-  if ((config.provider.provider === "openai" || config.provider.provider === "openai-compatible") && !config.provider.apiKey) {
+  if ((config.provider.provider === "openai" || config.provider.provider === "openai-compatible" || config.provider.provider === "openrouter") && !config.provider.apiKey) {
     problems.push("Missing provider.apiKey");
     problems.push(
       `Set one of: ${getProviderApiKeyEnvNames(
@@ -1714,10 +2032,11 @@ async function buildOpenAICompatibleError(response) {
   return new Error(detail);
 }
 var OpenAICompatibleProvider = class {
-  name = "openai-compatible";
+  name;
   baseUrl;
   apiKey;
   constructor(options) {
+    this.name = options.name ?? "openai-compatible";
     this.baseUrl = options.baseUrl.replace(/\/$/, "");
     this.apiKey = options.apiKey;
   }
@@ -1793,13 +2112,20 @@ function createProvider(config) {
       apiKey: config.provider.apiKey
     });
   }
+  if (config.provider.provider === "openrouter") {
+    return new OpenAICompatibleProvider({
+      baseUrl: config.provider.baseUrl,
+      apiKey: config.provider.apiKey,
+      name: "openrouter"
+    });
+  }
   throw new Error(`Unsupported provider: ${config.provider.provider}`);
 }
 
 // src/core/testStatusDecision.ts
 import { z as z2 } from "zod";
 var TEST_STATUS_DIAGNOSE_JSON_CONTRACT = '{"status":"ok|insufficient","diagnosis_complete":boolean,"raw_needed":boolean,"additional_source_read_likely_low_value":boolean,"read_raw_only_if":string|null,"decision":"stop|zoom|read_source|read_raw","dominant_blocker_bucket_index":number|null,"provider_used":boolean,"provider_confidence":number|null,"provider_failed":boolean,"raw_slice_used":boolean,"raw_slice_strategy":"none|bucket_evidence|traceback_window|head_tail","resolved_summary":{"count":number,"families":[{"prefix":string,"count":number}]},"remaining_summary":{"count":number,"families":[{"prefix":string,"count":number}]},"remaining_subset_available":boolean,"main_buckets":[{"bucket_index":number,"label":string,"count":number,"root_cause":string,"evidence":string[],"bucket_confidence":number,"root_cause_confidence":number,"dominant":boolean,"secondary_visible_despite_blocker":boolean,"mini_diff":{"added_paths"?:number,"removed_models"?:number,"changed_task_mappings"?:number}|null}],"read_targets":[{"file":string,"line":number|null,"why":string,"bucket_index":number,"context_hint":{"start_line":number|null,"end_line":number|null,"search_hint":string|null}}],"next_best_action":{"code":"fix_dominant_blocker|read_source_for_bucket|read_raw_for_exact_traceback|insufficient_signal","bucket_index":number|null,"note":string},"resolved_tests"?:string[],"remaining_tests"?:string[]}';
-var TEST_STATUS_PROVIDER_SUPPLEMENT_JSON_CONTRACT = '{"diagnosis_complete":boolean,"raw_needed":boolean,"additional_source_read_likely_low_value":boolean,"read_raw_only_if":string|null,"decision":"stop|zoom|read_source|read_raw","provider_confidence":number|null,"next_best_action":{"code":"fix_dominant_blocker|read_source_for_bucket|read_raw_for_exact_traceback|insufficient_signal","bucket_index":number|null,"note":string}}';
+var TEST_STATUS_PROVIDER_SUPPLEMENT_JSON_CONTRACT = '{"diagnosis_complete":boolean,"raw_needed":boolean,"additional_source_read_likely_low_value":boolean,"read_raw_only_if":string|null,"decision":"stop|zoom|read_source|read_raw","provider_confidence":number|null,"bucket_supplements":[{"label":string,"count":number,"root_cause":string,"anchor":{"file":string|null,"line":number|null,"search_hint":string|null},"fix_hint":string|null,"confidence":number}],"next_best_action":{"code":"fix_dominant_blocker|read_source_for_bucket|read_raw_for_exact_traceback|insufficient_signal","bucket_index":number|null,"note":string}}';
 var nextBestActionSchema = z2.object({
   code: z2.enum([
     "fix_dominant_blocker",
@@ -1817,6 +2143,20 @@ var testStatusProviderSupplementSchema = z2.object({
   read_raw_only_if: z2.string().nullable(),
   decision: z2.enum(["stop", "zoom", "read_source", "read_raw"]),
   provider_confidence: z2.number().min(0).max(1).nullable(),
+  bucket_supplements: z2.array(
+    z2.object({
+      label: z2.string().min(1),
+      count: z2.number().int().positive(),
+      root_cause: z2.string().min(1),
+      anchor: z2.object({
+        file: z2.string().nullable(),
+        line: z2.number().int().nullable(),
+        search_hint: z2.string().nullable()
+      }),
+      fix_hint: z2.string().nullable(),
+      confidence: z2.number().min(0).max(1)
+    })
+  ).max(2),
   next_best_action: nextBestActionSchema
 });
 var testStatusDiagnoseContractSchema = z2.object({
@@ -1889,6 +2229,209 @@ var testStatusPublicDiagnoseContractSchema = testStatusDiagnoseContractSchema.om
 function parseTestStatusProviderSupplement(input) {
   return testStatusProviderSupplementSchema.parse(JSON.parse(input));
 }
+var extendedBucketSpecs = [
+  {
+    prefix: "snapshot mismatch:",
+    type: "snapshot_mismatch",
+    label: "snapshot mismatch",
+    genericTitle: "Snapshot mismatches",
+    defaultCoverage: "failed",
+    rootCauseConfidence: 0.84,
+    why: "it contains the failing snapshot expectation behind this bucket",
+    fix: "Update the snapshots if these output changes are intentional, then rerun the suite."
+  },
+  {
+    prefix: "timeout:",
+    type: "timeout_failure",
+    label: "timeout",
+    genericTitle: "Timeout failures",
+    defaultCoverage: "mixed",
+    rootCauseConfidence: 0.9,
+    why: "it contains the test or fixture that exceeded the timeout threshold",
+    fix: "Check for deadlocks, slow setup, or increase the timeout threshold before rerunning."
+  },
+  {
+    prefix: "permission:",
+    type: "permission_denied_failure",
+    label: "permission denied",
+    genericTitle: "Permission failures",
+    defaultCoverage: "error",
+    rootCauseConfidence: 0.85,
+    why: "it contains the file, socket, or port access that was denied",
+    fix: "Check file or port permissions in the CI environment before rerunning."
+  },
+  {
+    prefix: "async loop:",
+    type: "async_event_loop_failure",
+    label: "async event loop",
+    genericTitle: "Async event loop failures",
+    defaultCoverage: "mixed",
+    rootCauseConfidence: 0.88,
+    why: "it contains the async setup or coroutine that caused the event loop error",
+    fix: "Check event loop scope and pytest-asyncio configuration before rerunning."
+  },
+  {
+    prefix: "fixture teardown:",
+    type: "fixture_teardown_failure",
+    label: "fixture teardown",
+    genericTitle: "Fixture teardown failures",
+    defaultCoverage: "error",
+    rootCauseConfidence: 0.85,
+    why: "it contains the fixture teardown path that failed after the test body completed",
+    fix: "Inspect the teardown cleanup path and restore idempotent fixture cleanup before rerunning."
+  },
+  {
+    prefix: "db migration:",
+    type: "db_migration_failure",
+    label: "db migration",
+    genericTitle: "DB migration failures",
+    defaultCoverage: "error",
+    rootCauseConfidence: 0.9,
+    why: "it contains the migration or model definition behind the missing table or relation",
+    fix: "Run pending migrations or fix the expected model schema before rerunning."
+  },
+  {
+    prefix: "configuration:",
+    type: "configuration_error",
+    label: "configuration error",
+    genericTitle: "Configuration errors",
+    defaultCoverage: "error",
+    rootCauseConfidence: 0.95,
+    dominantPriority: 4,
+    dominantBlocker: true,
+    why: "it contains the pytest configuration or conftest setup error that blocks the run",
+    fix: "Fix the pytest configuration, CLI usage, or conftest import error before rerunning."
+  },
+  {
+    prefix: "xdist worker crash:",
+    type: "xdist_worker_crash",
+    label: "xdist worker crash",
+    genericTitle: "xdist worker crashes",
+    defaultCoverage: "error",
+    rootCauseConfidence: 0.92,
+    dominantPriority: 3,
+    why: "it contains the worker startup or shared-state path that crashed an xdist worker",
+    fix: "Check shared state, worker startup hooks, or resource contention between workers before rerunning."
+  },
+  {
+    prefix: "type error:",
+    type: "type_error_failure",
+    label: "type error",
+    genericTitle: "Type errors",
+    defaultCoverage: "mixed",
+    rootCauseConfidence: 0.8,
+    why: "it contains the call site or fixture value that triggered the type error",
+    fix: "Inspect the mismatched argument or object shape and rerun the full suite at standard."
+  },
+  {
+    prefix: "resource leak:",
+    type: "resource_leak_warning",
+    label: "resource leak",
+    genericTitle: "Resource leak warnings",
+    defaultCoverage: "mixed",
+    rootCauseConfidence: 0.74,
+    why: "it contains the warning source behind the leaked file, socket, or coroutine",
+    fix: "Close the leaked resource or suppress the warning only if the cleanup is intentional."
+  },
+  {
+    prefix: "django db access:",
+    type: "django_db_access_denied",
+    label: "django db access",
+    genericTitle: "Django DB access failures",
+    defaultCoverage: "error",
+    rootCauseConfidence: 0.95,
+    why: "it needs the @pytest.mark.django_db decorator or fixture permission to access the database",
+    fix: "Add @pytest.mark.django_db to the test or class before rerunning."
+  },
+  {
+    prefix: "network:",
+    type: "network_failure",
+    label: "network failure",
+    genericTitle: "Network failures",
+    defaultCoverage: "error",
+    rootCauseConfidence: 0.88,
+    dominantPriority: 2,
+    why: "it contains the host, URL, or TLS path behind the network failure",
+    fix: "Check DNS, outbound network access, retries, or TLS trust before rerunning."
+  },
+  {
+    prefix: "segfault:",
+    type: "subprocess_crash_segfault",
+    label: "segfault",
+    genericTitle: "Segfault crashes",
+    defaultCoverage: "mixed",
+    rootCauseConfidence: 0.8,
+    why: "it contains the subprocess or native extension path that crashed with SIGSEGV",
+    fix: "Inspect the native extension, subprocess boundary, or incompatible binary before rerunning."
+  },
+  {
+    prefix: "flaky:",
+    type: "flaky_test_detected",
+    label: "flaky test",
+    genericTitle: "Flaky test detections",
+    defaultCoverage: "mixed",
+    rootCauseConfidence: 0.72,
+    why: "it contains the rerun-prone test that behaved inconsistently across attempts",
+    fix: "Stabilize the nondeterministic test or fixture before relying on reruns."
+  },
+  {
+    prefix: "serialization:",
+    type: "serialization_encoding_failure",
+    label: "serialization or encoding",
+    genericTitle: "Serialization or encoding failures",
+    defaultCoverage: "mixed",
+    rootCauseConfidence: 0.78,
+    why: "it contains the serialization or decoding path behind the malformed payload",
+    fix: "Inspect the encoded payload, serializer, or fixture data before rerunning."
+  },
+  {
+    prefix: "file not found:",
+    type: "file_not_found_failure",
+    label: "file not found",
+    genericTitle: "Missing file failures",
+    defaultCoverage: "mixed",
+    rootCauseConfidence: 0.82,
+    why: "it contains the missing file path or fixture artifact required by the test",
+    fix: "Restore the missing file, fixture artifact, or working-directory assumption before rerunning."
+  },
+  {
+    prefix: "memory:",
+    type: "memory_error",
+    label: "memory error",
+    genericTitle: "Memory failures",
+    defaultCoverage: "mixed",
+    rootCauseConfidence: 0.78,
+    why: "it contains the allocation path that exhausted available memory",
+    fix: "Reduce memory pressure or investigate the large allocation before rerunning."
+  },
+  {
+    prefix: "deprecation as error:",
+    type: "deprecation_warning_as_error",
+    label: "deprecation as error",
+    genericTitle: "Deprecation warnings as errors",
+    defaultCoverage: "mixed",
+    rootCauseConfidence: 0.74,
+    why: "it contains the deprecated API or warning filter that is failing the test run",
+    fix: "Update the deprecated call site or relax the warning policy only if that is intentional."
+  },
+  {
+    prefix: "xfail strict:",
+    type: "xfail_strict_unexpected_pass",
+    label: "strict xfail unexpected pass",
+    genericTitle: "Strict xfail unexpected passes",
+    defaultCoverage: "failed",
+    rootCauseConfidence: 0.78,
+    why: "it contains the strict xfail case that unexpectedly passed",
+    fix: "Remove or update the strict xfail expectation if the test is now passing intentionally."
+  }
+];
+function findExtendedBucketSpec(reason) {
+  return extendedBucketSpecs.find((spec) => reason.startsWith(spec.prefix)) ?? null;
+}
+function extractReasonDetail(reason, prefix) {
+  const detail = reason.slice(prefix.length).trim();
+  return detail.length > 0 ? detail : null;
+}
 function formatCount(count, singular, plural = `${singular}s`) {
   return `${count} ${count === 1 ? singular : plural}`;
 }
@@ -1942,6 +2485,10 @@ function formatTargetSummary(summary) {
   return `count=${summary.count}; families=${families}`;
 }
 function classifyGenericBucketType(reason) {
+  const extended = findExtendedBucketSpec(reason);
+  if (extended) {
+    return extended.type;
+  }
   if (reason.startsWith("missing test env:")) {
     return "shared_environment_blocker";
   }
@@ -1968,14 +2515,77 @@ function classifyGenericBucketType(reason) {
   }
   return "unknown_failure";
 }
+function isUnknownBucket(bucket) {
+  return bucket.source === "unknown" || bucket.reason.startsWith("unknown ");
+}
+function classifyVisibleStatusForLabel(args) {
+  const isError = args.errorLabels.has(args.label);
+  const isFailed = args.failedLabels.has(args.label);
+  if (isError && isFailed) {
+    return "mixed";
+  }
+  if (isError) {
+    return "error";
+  }
+  if (isFailed) {
+    return "failed";
+  }
+  return "unknown";
+}
+function inferCoverageFromReason(reason) {
+  const extended = findExtendedBucketSpec(reason);
+  if (extended) {
+    return extended.defaultCoverage;
+  }
+  if (reason.startsWith("missing test env:") || reason.startsWith("fixture guard:") || reason.startsWith("service unavailable:") || reason.startsWith("db refused:") || reason.startsWith("auth bypass absent:") || reason.startsWith("missing module:")) {
+    return "error";
+  }
+  if (reason.startsWith("assertion failed:")) {
+    return "failed";
+  }
+  return "mixed";
+}
+function buildCoverageCounts(args) {
+  if (args.coverageKind === "error") {
+    return {
+      error: args.count,
+      failed: 0
+    };
+  }
+  if (args.coverageKind === "failed") {
+    return {
+      error: 0,
+      failed: args.count
+    };
+  }
+  return {
+    error: 0,
+    failed: 0
+  };
+}
 function buildGenericBuckets(analysis) {
   const buckets = [];
   const grouped = /* @__PURE__ */ new Map();
+  const errorLabels = new Set(analysis.visibleErrorLabels);
+  const failedLabels = new Set(analysis.visibleFailedLabels);
   const push = (reason, item) => {
-    const key = `${classifyGenericBucketType(reason)}:${reason}`;
+    const coverageKind = (() => {
+      const status = classifyVisibleStatusForLabel({
+        label: item.label,
+        errorLabels,
+        failedLabels
+      });
+      return status === "unknown" ? inferCoverageFromReason(reason) : status;
+    })();
+    const key = `${classifyGenericBucketType(reason)}:${coverageKind}:${reason}`;
     const existing = grouped.get(key);
     if (existing) {
       existing.count += 1;
+      if (coverageKind === "error") {
+        existing.coverage.error += 1;
+      } else if (coverageKind === "failed") {
+        existing.coverage.failed += 1;
+      }
       if (!existing.representativeItems.some((entry) => entry.label === item.label) && existing.representativeItems.length < 6) {
         existing.representativeItems.push(item);
       }
@@ -1987,19 +2597,30 @@ function buildGenericBuckets(analysis) {
       summaryLines: [],
       reason,
       count: 1,
-      confidence: reason.startsWith("assertion failed:") || /^[A-Z][A-Za-z]+(?:Error|Exception):/.test(reason) ? 0.74 : 0.62,
+      confidence: (() => {
+        const extended = findExtendedBucketSpec(reason);
+        if (extended) {
+          return Math.max(0.72, Math.min(extended.rootCauseConfidence, 0.82));
+        }
+        return 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"
+      overflowLabel: "failing tests/modules",
+      coverage: buildCoverageCounts({
+        count: 1,
+        coverageKind
+      }),
+      source: "heuristic"
     });
   };
   for (const item of [...analysis.collectionItems, ...analysis.inlineItems]) {
     push(item.reason, item);
   }
   for (const bucket of grouped.values()) {
-    const title = bucket.type === "assertion_failure" ? "Assertion failures" : bucket.type === "import_dependency_failure" ? "Import/dependency failures" : bucket.type === "collection_failure" ? "Collection or fixture failures" : "Runtime failures";
+    const title = findExtendedBucketSpec(bucket.reason)?.genericTitle ?? (bucket.type === "assertion_failure" || bucket.type === "snapshot_mismatch" ? "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);
@@ -2045,10 +2666,51 @@ function mergeBucketDetails(existing, incoming) {
       incoming.overflowCount,
       count - representativeItems.length
     ),
-    overflowLabel: existing.overflowLabel || incoming.overflowLabel
+    overflowLabel: existing.overflowLabel || incoming.overflowLabel,
+    labelOverride: existing.labelOverride ?? incoming.labelOverride,
+    coverage: {
+      error: Math.max(existing.coverage.error, incoming.coverage.error),
+      failed: Math.max(existing.coverage.failed, incoming.coverage.failed)
+    },
+    source: existing.source
+  };
+}
+function inferFailureBucketCoverage(bucket, analysis) {
+  const errorLabels = new Set(analysis.visibleErrorLabels);
+  const failedLabels = new Set(analysis.visibleFailedLabels);
+  let error = 0;
+  let failed = 0;
+  for (const item of bucket.representativeItems) {
+    const status = classifyVisibleStatusForLabel({
+      label: item.label,
+      errorLabels,
+      failedLabels
+    });
+    if (status === "error") {
+      error += 1;
+    } else if (status === "failed") {
+      failed += 1;
+    }
+  }
+  const claimed = bucket.countClaimed ?? bucket.countVisible;
+  if (bucket.type === "contract_snapshot_drift" || bucket.type === "assertion_failure" || bucket.type === "snapshot_mismatch") {
+    return {
+      error,
+      failed: Math.max(failed, claimed)
+    };
+  }
+  if (bucket.type === "shared_environment_blocker" || bucket.type === "import_dependency_failure" || bucket.type === "collection_failure" || bucket.type === "fixture_guard_failure" || bucket.type === "permission_denied_failure" || bucket.type === "fixture_teardown_failure" || bucket.type === "db_migration_failure" || bucket.type === "configuration_error" || bucket.type === "xdist_worker_crash" || bucket.type === "django_db_access_denied" || bucket.type === "network_failure" || bucket.type === "service_unavailable" || bucket.type === "db_connection_failure" || bucket.type === "auth_bypass_absent") {
+    return {
+      error: Math.max(error, claimed),
+      failed
+    };
+  }
+  return {
+    error,
+    failed
   };
 }
-function mergeBuckets(analysis) {
+function mergeBuckets(analysis, extraBuckets = []) {
   const mergedByIdentity = /* @__PURE__ */ new Map();
   const merged = [];
   const pushBucket = (bucket) => {
@@ -2077,7 +2739,9 @@ function mergeBuckets(analysis) {
     entities: [...bucket2.entities],
     hint: bucket2.hint,
     overflowCount: bucket2.overflowCount,
-    overflowLabel: bucket2.overflowLabel
+    overflowLabel: bucket2.overflowLabel,
+    coverage: inferFailureBucketCoverage(bucket2, analysis),
+    source: "heuristic"
   }))) {
     pushBucket(bucket);
   }
@@ -2101,12 +2765,19 @@ function mergeBuckets(analysis) {
       coveredLabels.add(item.label);
     }
   }
+  for (const bucket of extraBuckets) {
+    pushBucket(bucket);
+  }
   return merged;
 }
 function dominantBucketPriority(bucket) {
   if (bucket.reason.startsWith("missing test env:")) {
     return 5;
   }
+  const extended = findExtendedBucketSpec(bucket.reason);
+  if (extended?.dominantPriority !== void 0) {
+    return extended.dominantPriority;
+  }
   if (bucket.type === "shared_environment_blocker") {
     return 4;
   }
@@ -2116,6 +2787,9 @@ function dominantBucketPriority(bucket) {
   if (bucket.type === "collection_failure") {
     return 2;
   }
+  if (isUnknownBucket(bucket)) {
+    return 2;
+  }
   if (bucket.type === "contract_snapshot_drift") {
     return 1;
   }
@@ -2137,9 +2811,16 @@ function prioritizeBuckets(buckets) {
   });
 }
 function isDominantBlockerType(type) {
-  return type === "shared_environment_blocker" || type === "import_dependency_failure" || type === "collection_failure";
+  return type === "shared_environment_blocker" || type === "configuration_error" || type === "import_dependency_failure" || type === "collection_failure";
 }
 function labelForBucket(bucket) {
+  if (bucket.labelOverride) {
+    return bucket.labelOverride;
+  }
+  const extended = findExtendedBucketSpec(bucket.reason);
+  if (extended) {
+    return extended.label;
+  }
   if (bucket.reason.startsWith("missing test env:")) {
     return "missing test env";
   }
@@ -2173,21 +2854,40 @@ function labelForBucket(bucket) {
   if (bucket.type === "assertion_failure") {
     return "assertion failure";
   }
+  if (bucket.type === "snapshot_mismatch") {
+    return "snapshot mismatch";
+  }
   if (bucket.type === "collection_failure") {
     return "collection failure";
   }
   if (bucket.type === "runtime_failure") {
     return "runtime failure";
   }
+  if (bucket.reason.startsWith("unknown setup blocker:")) {
+    return "unknown setup blocker";
+  }
+  if (bucket.reason.startsWith("unknown failure family:")) {
+    return "unknown failure family";
+  }
   return "unknown failure";
 }
 function rootCauseConfidenceFor(bucket) {
+  if (isUnknownBucket(bucket)) {
+    return 0.52;
+  }
+  const extended = findExtendedBucketSpec(bucket.reason);
+  if (extended) {
+    return extended.rootCauseConfidence;
+  }
   if (bucket.reason.startsWith("missing test env:") || bucket.reason.startsWith("missing module:") || bucket.reason.startsWith("db refused:") || bucket.reason.startsWith("service unavailable:") || bucket.reason.startsWith("auth bypass absent:")) {
     return 0.95;
   }
   if (bucket.type === "contract_snapshot_drift") {
     return bucket.entities.length > 0 ? 0.92 : 0.76;
   }
+  if (bucket.source === "provider") {
+    return Math.max(0.6, Math.min(bucket.confidence, 0.82));
+  }
   return Math.max(0.6, Math.min(bucket.confidence, 0.88));
 }
 function buildBucketEvidence(bucket) {
@@ -2219,6 +2919,10 @@ function buildReadTargetWhy(args) {
   if (envVar) {
     return `it contains the ${envVar} setup guard`;
   }
+  const extended = findExtendedBucketSpec(args.bucket.reason);
+  if (extended) {
+    return extended.why;
+  }
   if (args.bucket.reason.startsWith("fixture guard:")) {
     return "it contains the fixture/setup guard behind this bucket";
   }
@@ -2231,6 +2935,12 @@ function buildReadTargetWhy(args) {
   if (args.bucket.reason.startsWith("auth bypass absent:")) {
     return "it contains the auth bypass setup behind this bucket";
   }
+  if (args.bucket.reason.startsWith("unknown setup blocker:")) {
+    return "it is the first anchored setup failure in this unknown bucket";
+  }
+  if (args.bucket.reason.startsWith("unknown failure family:")) {
+    return "it is the first anchored failing test in this unknown bucket";
+  }
   if (args.bucket.type === "contract_snapshot_drift") {
     if (args.bucketLabel === "route drift") {
       return "it maps to the visible route drift bucket";
@@ -2243,6 +2953,9 @@ function buildReadTargetWhy(args) {
     }
     return "it maps to the visible stale snapshot expectation";
   }
+  if (args.bucket.type === "snapshot_mismatch") {
+    return "it maps to the visible snapshot mismatch bucket";
+  }
   if (args.bucket.type === "import_dependency_failure") {
     return "it is the first visible failing module in this missing dependency bucket";
   }
@@ -2254,11 +2967,54 @@ function buildReadTargetWhy(args) {
   }
   return `it maps to the visible ${args.bucketLabel} bucket`;
 }
+function buildExtendedBucketSearchHint(bucket, anchor) {
+  const extended = findExtendedBucketSpec(bucket.reason);
+  if (!extended) {
+    return null;
+  }
+  const detail = extractReasonDetail(bucket.reason, extended.prefix);
+  if (!detail) {
+    return anchor.label.split("::")[1]?.trim() ?? anchor.label ?? null;
+  }
+  if (extended.type === "timeout_failure") {
+    const duration = detail.match(/>\s*([0-9]+(?:\.[0-9]+)?s?)/i)?.[1];
+    return duration ?? anchor.label.split("::")[1]?.trim() ?? detail;
+  }
+  if (extended.type === "db_migration_failure") {
+    const relation = detail.match(/\b(?:relation|table)\s+([A-Za-z0-9_.-]+)/i)?.[1];
+    return relation ?? detail;
+  }
+  if (extended.type === "network_failure") {
+    const url = detail.match(/\bhttps?:\/\/[^\s)'"`]+/i)?.[0];
+    const host = detail.match(/\b(?:[A-Za-z0-9-]+\.)+[A-Za-z]{2,}\b/)?.[0];
+    return url ?? host ?? detail;
+  }
+  if (extended.type === "xdist_worker_crash") {
+    return detail.match(/\bgw\d+\b/)?.[0] ?? detail;
+  }
+  if (extended.type === "fixture_teardown_failure") {
+    return detail.replace(/^of\s+/i, "") || anchor.label;
+  }
+  if (extended.type === "file_not_found_failure") {
+    const path8 = detail.match(/['"]([^'"]+)['"]/)?.[1];
+    return path8 ?? detail;
+  }
+  if (extended.type === "permission_denied_failure") {
+    const path8 = detail.match(/['"]([^'"]+)['"]/)?.[1];
+    const port = detail.match(/\bport\s+(\d+)\b/i)?.[1];
+    return path8 ?? (port ? `port ${port}` : detail);
+  }
+  return detail;
+}
 function buildReadTargetSearchHint(bucket, anchor) {
   const envVar = bucket.reason.match(/^missing test env:\s+([A-Z][A-Z0-9_]{2,})$/)?.[1];
   if (envVar) {
     return envVar;
   }
+  const extendedHint = buildExtendedBucketSearchHint(bucket, anchor);
+  if (extendedHint) {
+    return extendedHint;
+  }
   if (bucket.type === "contract_snapshot_drift") {
     return bucket.entities.find((value) => value.startsWith("/api/")) ?? bucket.entities[0] ?? null;
   }
@@ -2280,6 +3036,9 @@ function buildReadTargetSearchHint(bucket, anchor) {
   if (assertionText) {
     return assertionText;
   }
+  if (bucket.reason.startsWith("unknown ")) {
+    return anchor.reason;
+  }
   const fallbackLabel = anchor.label.split("::")[1]?.trim();
   return fallbackLabel || null;
 }
@@ -2339,6 +3098,12 @@ function buildConcreteNextNote(args) {
   if (args.nextBestAction.code === "read_source_for_bucket") {
     return lead;
   }
+  if (args.nextBestAction.code === "insufficient_signal") {
+    if (args.nextBestAction.note.startsWith("Provider follow-up failed")) {
+      return args.nextBestAction.note;
+    }
+    return `${lead} Then take one deeper sift pass before raw traceback.`;
+  }
   return args.nextBestAction.note;
 }
 function extractMiniDiff(input, bucket) {
@@ -2363,6 +3128,156 @@ function extractMiniDiff(input, bucket) {
     ...changedTaskMappings > 0 ? { changed_task_mappings: changedTaskMappings } : {}
   };
 }
+function inferSupplementCoverageKind(args) {
+  const extended = findExtendedBucketSpec(args.rootCause);
+  if (extended?.defaultCoverage === "error" || extended?.defaultCoverage === "failed") {
+    return extended.defaultCoverage;
+  }
+  const normalized = `${args.label} ${args.rootCause}`.toLowerCase();
+  if (/env|setup|fixture|import|dependency|service|db|database|auth bypass|collection|connection refused/.test(
+    normalized
+  )) {
+    return "error";
+  }
+  if (/snapshot|contract|drift|assertion|expected|actual|golden/.test(normalized)) {
+    return "failed";
+  }
+  if (args.remainingErrors > 0 && args.remainingFailed === 0) {
+    return "error";
+  }
+  return "failed";
+}
+function buildProviderSupplementBuckets(args) {
+  let remainingErrors = args.remainingErrors;
+  let remainingFailed = args.remainingFailed;
+  return args.supplements.flatMap((supplement) => {
+    const coverageKind = inferSupplementCoverageKind({
+      label: supplement.label,
+      rootCause: supplement.root_cause,
+      remainingErrors,
+      remainingFailed
+    });
+    const budget = coverageKind === "error" ? remainingErrors : remainingFailed;
+    const count = Math.max(0, Math.min(supplement.count, budget));
+    if (count === 0) {
+      return [];
+    }
+    if (coverageKind === "error") {
+      remainingErrors -= count;
+    } else {
+      remainingFailed -= count;
+    }
+    const representativeLabel = supplement.anchor.file ?? `${supplement.label} supplement`;
+    const representativeItem = {
+      label: representativeLabel,
+      reason: supplement.root_cause,
+      group: supplement.label,
+      file: supplement.anchor.file,
+      line: supplement.anchor.line,
+      anchor_kind: supplement.anchor.file && supplement.anchor.line !== null ? "traceback" : supplement.anchor.file ? "test_label" : supplement.anchor.search_hint ? "entity" : "none",
+      anchor_confidence: Math.max(0.4, Math.min(supplement.confidence, 0.82))
+    };
+    return [
+      {
+        type: classifyGenericBucketType(supplement.root_cause),
+        headline: `${supplement.label}: ${formatCount(count, "visible failure")} share ${supplement.root_cause}.`,
+        summaryLines: [
+          `${supplement.label}: ${formatCount(count, "visible failure")} share ${supplement.root_cause}.`
+        ],
+        reason: supplement.root_cause,
+        count,
+        confidence: Math.max(0.4, Math.min(supplement.confidence, 0.82)),
+        representativeItems: [representativeItem],
+        entities: supplement.anchor.search_hint ? [supplement.anchor.search_hint] : [],
+        hint: supplement.fix_hint ?? void 0,
+        overflowCount: Math.max(count - 1, 0),
+        overflowLabel: "failing tests/modules",
+        labelOverride: supplement.label,
+        coverage: buildCoverageCounts({
+          count,
+          coverageKind
+        }),
+        source: "provider"
+      }
+    ];
+  });
+}
+function pickUnknownAnchor(args) {
+  const fromStatusItems = args.kind === "error" ? args.analysis.visibleErrorItems[0] : null;
+  if (fromStatusItems) {
+    return {
+      label: fromStatusItems.label,
+      reason: fromStatusItems.reason,
+      group: fromStatusItems.group,
+      file: fromStatusItems.file,
+      line: fromStatusItems.line,
+      anchor_kind: fromStatusItems.anchor_kind,
+      anchor_confidence: fromStatusItems.anchor_confidence
+    };
+  }
+  const label = args.kind === "error" ? args.analysis.visibleErrorLabels[0] : args.analysis.visibleFailedLabels[0];
+  if (label) {
+    const normalizedLabel = normalizeTestId(label);
+    const fileMatch = normalizedLabel.match(/^([A-Za-z0-9_./-]+\.[A-Za-z0-9]+)\b/);
+    const file = fileMatch?.[1] ?? normalizedLabel.split("::")[0] ?? null;
+    return {
+      label,
+      reason: args.kind === "error" ? "setup failures share a repeated but unclassified pattern" : "failing tests share a repeated but unclassified pattern",
+      group: args.kind === "error" ? "unknown setup blocker" : "unknown failure family",
+      file: file && file !== label ? file : null,
+      line: null,
+      anchor_kind: file && file !== label ? "test_label" : "none",
+      anchor_confidence: file && file !== label ? 0.6 : 0
+    };
+  }
+  return null;
+}
+function buildUnknownBucket(args) {
+  if (args.count <= 0) {
+    return null;
+  }
+  const anchor = pickUnknownAnchor(args);
+  const isError = args.kind === "error";
+  const label = isError ? "unknown setup blocker" : "unknown failure family";
+  const reason = isError ? "unknown setup blocker: setup failures share a repeated but unclassified pattern" : "unknown failure family: failing tests share a repeated but unclassified pattern";
+  return {
+    type: "unknown_failure",
+    headline: `${label}: ${formatCount(args.count, "visible failure")} share a repeated but unclassified pattern.`,
+    summaryLines: [
+      `${label}: ${formatCount(args.count, "visible failure")} share a repeated but unclassified pattern.`
+    ],
+    reason,
+    count: args.count,
+    confidence: 0.45,
+    representativeItems: anchor ? [anchor] : [],
+    entities: [],
+    hint: isError ? "Take one deeper sift pass or inspect the first anchored setup failure." : "Take one deeper sift pass or inspect the first anchored failing test.",
+    overflowCount: Math.max(args.count - (anchor ? 1 : 0), 0),
+    overflowLabel: "failing tests/modules",
+    labelOverride: label,
+    coverage: buildCoverageCounts({
+      count: args.count,
+      coverageKind: isError ? "error" : "failed"
+    }),
+    source: "unknown"
+  };
+}
+function buildCoverageResiduals(args) {
+  const covered = args.buckets.reduce(
+    (totals, bucket) => ({
+      error: totals.error + bucket.coverage.error,
+      failed: totals.failed + bucket.coverage.failed
+    }),
+    {
+      error: 0,
+      failed: 0
+    }
+  );
+  return {
+    remainingErrors: Math.max(args.analysis.errors - Math.min(args.analysis.errors, covered.error), 0),
+    remainingFailed: Math.max(args.analysis.failed - Math.min(args.analysis.failed, covered.failed), 0)
+  };
+}
 function buildOutcomeLines(analysis) {
   if (analysis.noTestsCollected) {
     return ["- Tests did not run.", "- Collected 0 items."];
@@ -2461,6 +3376,10 @@ function buildStandardFixText(args) {
   if (args.bucket.hint) {
     return args.bucket.hint;
   }
+  const extended = findExtendedBucketSpec(args.bucket.reason);
+  if (extended) {
+    return extended.fix;
+  }
   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.`;
@@ -2481,9 +3400,18 @@ function buildStandardFixText(args) {
   if (args.bucket.reason.startsWith("auth bypass absent:")) {
     return "Restore the test auth bypass setup and rerun the full suite at standard.";
   }
+  if (args.bucket.reason.startsWith("unknown setup blocker:")) {
+    return "Take one deeper sift pass or inspect the first anchored setup failure before rerunning.";
+  }
+  if (args.bucket.reason.startsWith("unknown failure family:")) {
+    return "Take one deeper sift pass or inspect the first anchored failing test before rerunning.";
+  }
   if (args.bucket.type === "contract_snapshot_drift") {
     return "Review the visible drift and regenerate the contract snapshots if the changes are intentional.";
   }
+  if (args.bucket.type === "snapshot_mismatch") {
+    return "Update the snapshots if these output changes are intentional, then rerun the full suite at standard.";
+  }
   if (args.bucket.type === "assertion_failure") {
     return "Inspect the failing assertion and rerun the full suite at standard.";
   }
@@ -2577,7 +3505,35 @@ function renderVerbose(args) {
   return lines.join("\n");
 }
 function buildTestStatusDiagnoseContract(args) {
-  const buckets = prioritizeBuckets(mergeBuckets(args.analysis)).slice(0, 3);
+  const heuristicBuckets = mergeBuckets(args.analysis);
+  const preUnknownSimpleCollectionFailure = args.analysis.collectionErrorCount !== void 0 && args.analysis.collectionItems.length === 0 && heuristicBuckets.length === 0 && (args.providerBucketSupplements?.length ?? 0) === 0;
+  const heuristicResiduals = buildCoverageResiduals({
+    analysis: args.analysis,
+    buckets: heuristicBuckets
+  });
+  const providerSupplementBuckets = buildProviderSupplementBuckets({
+    supplements: args.providerBucketSupplements ?? [],
+    remainingErrors: heuristicResiduals.remainingErrors,
+    remainingFailed: heuristicResiduals.remainingFailed
+  });
+  const combinedBuckets = mergeBuckets(args.analysis, providerSupplementBuckets);
+  const residuals = buildCoverageResiduals({
+    analysis: args.analysis,
+    buckets: combinedBuckets
+  });
+  const unknownBuckets = preUnknownSimpleCollectionFailure ? [] : [
+    buildUnknownBucket({
+      analysis: args.analysis,
+      kind: "error",
+      count: residuals.remainingErrors
+    }),
+    buildUnknownBucket({
+      analysis: args.analysis,
+      kind: "failed",
+      count: residuals.remainingFailed
+    })
+  ].filter((bucket) => Boolean(bucket));
+  const buckets = prioritizeBuckets([...combinedBuckets, ...unknownBuckets]).slice(0, 3);
   const simpleCollectionFailure = args.analysis.collectionErrorCount !== void 0 && args.analysis.collectionItems.length === 0 && buckets.length === 0;
   const dominantBucket = buckets.map((bucket, index) => ({
     bucket,
@@ -2588,8 +3544,10 @@ function buildTestStatusDiagnoseContract(args) {
     }
     return right.bucket.confidence - left.bucket.confidence;
   })[0] ?? null;
-  const diagnosisComplete = args.analysis.failed === 0 && args.analysis.errors === 0 && args.analysis.passed > 0 || simpleCollectionFailure || buckets.length > 0 && (dominantBucket?.bucket.confidence ?? 0) >= 0.7;
-  const rawNeeded = buckets.length > 0 ? buckets.every((bucket) => bucket.confidence < 0.7) : !(args.analysis.failed === 0 && args.analysis.errors === 0 && args.analysis.passed > 0 || simpleCollectionFailure);
+  const hasUnknownBucket = buckets.some((bucket) => isUnknownBucket(bucket));
+  const hasConcreteCoverage = args.analysis.failed === 0 && args.analysis.errors === 0 ? true : residuals.remainingErrors === 0 && residuals.remainingFailed === 0;
+  const diagnosisComplete = args.analysis.failed === 0 && args.analysis.errors === 0 && args.analysis.passed > 0 || simpleCollectionFailure || buckets.length > 0 && hasConcreteCoverage && !hasUnknownBucket && (dominantBucket?.bucket.confidence ?? 0) >= 0.6;
+  const rawNeeded = buckets.length === 0 ? !(args.analysis.failed === 0 && args.analysis.errors === 0 && args.analysis.passed > 0 || simpleCollectionFailure) : !diagnosisComplete && !hasUnknownBucket && buckets.every((bucket) => bucket.confidence < 0.7);
   const dominantBlockerBucketIndex = dominantBucket && isDominantBlockerType(dominantBucket.bucket.type) ? dominantBucket.index + 1 : null;
   const readTargets = buildReadTargets({
     buckets,
@@ -2624,6 +3582,12 @@ function buildTestStatusDiagnoseContract(args) {
       bucket_index: null,
       note: "Inspect the collection traceback or setup code next; the run failed before tests executed."
     };
+  } else if (hasUnknownBucket) {
+    nextBestAction = {
+      code: "insufficient_signal",
+      bucket_index: dominantBucket ? dominantBucket.index + 1 : null,
+      note: "Take one deeper sift pass or inspect the first anchored failure before falling back to raw traceback."
+    };
   } else if (!diagnosisComplete) {
     nextBestAction = {
       code: rawNeeded ? "read_raw_for_exact_traceback" : "insufficient_signal",
@@ -2661,11 +3625,15 @@ function buildTestStatusDiagnoseContract(args) {
     read_targets: readTargets,
     next_best_action: nextBestAction
   };
+  const effectiveDiagnosisComplete = Boolean(args.contractOverrides?.diagnosis_complete ?? diagnosisComplete) && !hasUnknownBucket;
+  const requestedDecision = args.contractOverrides?.decision;
+  const effectiveDecision = hasUnknownBucket && requestedDecision && (requestedDecision === "stop" || requestedDecision === "read_source") ? "zoom" : requestedDecision;
   const effectiveNextBestAction = args.contractOverrides?.next_best_action ?? baseContract.next_best_action;
   const mergedContractWithoutDecision = {
     ...baseContract,
     ...args.contractOverrides,
-    status: args.contractOverrides?.diagnosis_complete ?? diagnosisComplete ? "ok" : "insufficient",
+    diagnosis_complete: effectiveDiagnosisComplete,
+    status: effectiveDiagnosisComplete ? "ok" : "insufficient",
     next_best_action: {
       ...effectiveNextBestAction,
       note: buildConcreteNextNote({
@@ -2679,7 +3647,7 @@ function buildTestStatusDiagnoseContract(args) {
   };
   const contract = testStatusDiagnoseContractSchema.parse({
     ...mergedContractWithoutDecision,
-    decision: args.contractOverrides?.decision ?? deriveDecision(mergedContractWithoutDecision)
+    decision: effectiveDecision ?? deriveDecision(mergedContractWithoutDecision)
   });
   return {
     contract,
@@ -2916,9 +3884,12 @@ function resolvePromptPolicy(args) {
         "Return only valid JSON.",
         `Use this exact contract: ${args.outputContract ?? TEST_STATUS_DIAGNOSE_JSON_CONTRACT}.`,
         "Treat the heuristic context as extraction guidance, but do not invent hidden failures.",
-        "Use the heuristic extract as the bucket truth unless the visible command output clearly disproves it.",
+        "Use the heuristic extract as the base bucket truth unless the visible command output clearly disproves it.",
+        "If some visible failure or error families remain unexplained, add at most 2 bucket_supplements for the residual families only.",
+        "Do not rewrite or delete heuristic buckets; only supplement missing residual coverage.",
+        "Keep bucket_supplement counts within the unexplained residual failures or errors.",
         "Identify the dominant blocker, remaining visible failure buckets, the decision, and the next best action.",
-        "Set diagnosis_complete to true only when the visible output is already sufficient to stop and act.",
+        "Set diagnosis_complete to true only when the visible output is already sufficient to stop and act and no unknown residual family remains.",
         "Set raw_needed to true only when exact traceback lines are still required.",
         "Set provider_confidence to a number between 0 and 1, or null only when confidence cannot be estimated."
       ] : [
@@ -3099,6 +4070,63 @@ function getCount(input, label) {
   const lastMatch = matches.at(-1);
   return lastMatch ? Number(lastMatch[1]) : 0;
 }
+function detectTestRunner(input) {
+  if (/^\s*Test Files?\s+(?:\d+\s+failed\s*\|\s*)?\d+\s+passed/m.test(input) || /^\s*Tests?\s+(?:\d+\s+failed\s*\|\s*)?\d+\s+passed/m.test(input) || /^\s*Snapshots?\s+(?:\d+\s+failed\s*\|\s*)?\d+\s+passed/m.test(input) || /⎯{2,}\s+Failed Tests?\s+\d+\s+⎯{2,}/.test(input)) {
+    return "vitest";
+  }
+  if (/^\s*Test Suites:\s+\d+\s+failed,\s+\d+\s+passed(?:,\s+\d+\s+total)?/m.test(input) || /^\s*Tests:\s+\d+\s+failed,\s+\d+\s+passed(?:,\s+\d+\s+total)?/m.test(input)) {
+    return "jest";
+  }
+  if (/\bpytest\b/i.test(input) || /^\s*=+.*\b\d+\s+failed\b.*=+\s*$/m.test(input) || /\bcollected\s+\d+\s+items\b/i.test(input)) {
+    return "pytest";
+  }
+  return "unknown";
+}
+function extractVitestLineCount(input, label, metric) {
+  const matcher = new RegExp(`^\\s*${label}\\s+(.+)$`, "gmi");
+  const lines = [...input.matchAll(matcher)];
+  const line = lines.at(-1)?.[1];
+  if (!line) {
+    return null;
+  }
+  const metricMatch = line.match(new RegExp(`(\\d+)\\s+${metric}`, "i"));
+  return metricMatch ? Number(metricMatch[1]) : null;
+}
+function extractJestLineCount(input, label, metric) {
+  const matcher = new RegExp(`^\\s*${label}:\\s+(.+)$`, "gmi");
+  const lines = [...input.matchAll(matcher)];
+  const line = lines.at(-1)?.[1];
+  if (!line) {
+    return null;
+  }
+  const metricMatch = line.match(new RegExp(`(\\d+)\\s+${metric}`, "i"));
+  return metricMatch ? Number(metricMatch[1]) : null;
+}
+function extractTestStatusCounts(input, runner) {
+  if (runner === "vitest") {
+    return {
+      passed: extractVitestLineCount(input, "Tests?", "passed") ?? getCount(input, "passed"),
+      failed: extractVitestLineCount(input, "Tests?", "failed") ?? getCount(input, "failed"),
+      errors: extractVitestLineCount(input, "Errors?", "error") ?? extractVitestLineCount(input, "Errors?", "errors") ?? Math.max(getCount(input, "errors"), getCount(input, "error")),
+      skipped: extractVitestLineCount(input, "Tests?", "skipped") ?? getCount(input, "skipped"),
+      snapshotFailures: extractVitestLineCount(input, "Snapshots?", "failed") ?? void 0
+    };
+  }
+  if (runner === "jest") {
+    return {
+      passed: extractJestLineCount(input, "Tests", "passed") ?? getCount(input, "passed"),
+      failed: extractJestLineCount(input, "Tests", "failed") ?? getCount(input, "failed"),
+      errors: Math.max(getCount(input, "errors"), getCount(input, "error")),
+      skipped: extractJestLineCount(input, "Tests", "skipped") ?? getCount(input, "skipped")
+    };
+  }
+  return {
+    passed: getCount(input, "passed"),
+    failed: getCount(input, "failed"),
+    errors: Math.max(getCount(input, "errors"), getCount(input, "error")),
+    skipped: getCount(input, "skipped")
+  };
+}
 function formatCount2(count, singular, plural = `${singular}s`) {
   return `${count} ${count === 1 ? singular : plural}`;
 }
@@ -3131,7 +4159,8 @@ function normalizeAnchorFile(value) {
   return value.replace(/\\/g, "/").trim();
 }
 function inferFileFromLabel(label) {
-  const candidate = cleanFailureLabel(label).split("::")[0]?.trim();
+  const cleaned = cleanFailureLabel(label);
+  const candidate = cleaned.split("::")[0]?.split(" > ")[0]?.trim();
   if (!candidate) {
     return null;
   }
@@ -3186,6 +4215,15 @@ function parseObservedAnchor(line) {
       anchor_confidence: 0.92
     };
   }
+  const vitestTraceback = normalized.match(/^\s*❯\s+([^:\s][^:]*\.[A-Za-z0-9]+):(\d+)(?::\d+)?/);
+  if (vitestTraceback) {
+    return {
+      file: normalizeAnchorFile(vitestTraceback[1]),
+      line: Number(vitestTraceback[2]),
+      anchor_kind: "traceback",
+      anchor_confidence: 1
+    };
+  }
   return null;
 }
 function resolveAnchorForLabel(args) {
@@ -3202,96 +4240,362 @@ 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("configuration:")) {
+    return 6;
+  }
   if (reason.startsWith("missing test env:")) {
     return 6;
   }
-  if (reason.startsWith("missing module:")) {
-    return 5;
+  if (reason.startsWith("missing module:")) {
+    return 5;
+  }
+  if (reason.startsWith("snapshot mismatch:")) {
+    return 4;
+  }
+  if (reason.startsWith("assertion failed:")) {
+    return 4;
+  }
+  if (reason.startsWith("timeout:") || reason.startsWith("async loop:") || reason.startsWith("django db access:") || reason.startsWith("db migration:")) {
+    return 3;
+  }
+  if (reason.startsWith("permission:") || reason.startsWith("xdist worker crash:") || reason.startsWith("network:") || reason.startsWith("segfault:") || reason.startsWith("memory:") || reason.startsWith("type error:") || reason.startsWith("serialization:") || reason.startsWith("file not found:") || reason.startsWith("deprecation as error:") || reason.startsWith("xfail strict:") || reason.startsWith("resource leak:") || reason.startsWith("flaky:") || reason.startsWith("fixture teardown:")) {
+    return 2;
+  }
+  if (/^[A-Z][A-Za-z]+(?:Error|Exception):/.test(reason)) {
+    return 3;
+  }
+  if (reason === "import error during collection") {
+    return 2;
+  }
+  return 1;
+}
+function buildClassifiedReason(prefix, detail) {
+  return `${prefix}: ${detail}`.slice(0, 120);
+}
+function buildExcerptDetail(value, fallback) {
+  const trimmed = value.trim().replace(/\s+/g, " ");
+  return trimmed.length > 0 ? trimmed : fallback;
+}
+function sharedBlockerThreshold(reason) {
+  return reason.startsWith("configuration:") ? 1 : 3;
+}
+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)/
+  );
+  if (fallbackMatch) {
+    return fallbackMatch[1];
+  }
+  const leadingEnvMatch = normalized.match(
+    /\b([A-Z][A-Z0-9_]{2,})\b(?=[^.\n]{0,80}\b(?:is\s+)?(?:missing|unset|not set|not configured|required)\b)/
+  );
+  if (leadingEnvMatch) {
+    return leadingEnvMatch[1];
+  }
+  const trailingEnvMatch = normalized.match(
+    /\b(?:missing|unset|not set|not configured|required)\b[^.\n]{0,80}\b([A-Z][A-Z0-9_]{2,})\b/
+  );
+  if (trailingEnvMatch) {
+    return trailingEnvMatch[1];
+  }
+  const validationEnvMatch = normalized.match(
+    /\bValidationError\b[^.\n]{0,120}\b([A-Z][A-Z0-9_]{2,})\b/
+  );
+  return validationEnvMatch?.[1] ?? null;
+}
+function classifyFailureReason(line, options) {
+  const normalized = line.trim().replace(/^[A-Z]\s+/, "");
+  if (normalized.length === 0) {
+    return null;
+  }
+  if (isLowValueInternalReason(normalized)) {
+    return null;
+  }
+  if (/^([A-Za-z0-9_./-]+\.[A-Za-z0-9]+):\d+(?::\d+)?:\s+in\b/.test(normalized) || /^([^:\s][^:]*\.[A-Za-z0-9]+):\d+(?::\d+)?:\s+in\b/.test(normalized) || /^File\s+"[^"]+",\s+line\s+\d+/.test(normalized)) {
+    return null;
+  }
+  const envBlocker = extractEnvBlockerName(normalized);
+  if (envBlocker) {
+    return {
+      reason: `missing test env: ${envBlocker}`,
+      group: "DB-backed tests are blocked by missing test environment configuration"
+    };
+  }
+  const missingEnv = normalized.match(
+    /\b(?:environment variable|env(?:ironment)? var(?:iable)?|missing required env(?:ironment)? variable)\s+([A-Z][A-Z0-9_]{2,})\b/
+  );
+  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 (/(ECONNREFUSED|ConnectionRefusedError|connection refused)/i.test(normalized)) {
+    return {
+      reason: "service unavailable: dependency connection was refused",
+      group: "service availability failures"
+    };
+  }
+  if (/(503\b|service unavailable|temporarily unavailable)/i.test(normalized)) {
+    return {
+      reason: "service unavailable: dependency service is unavailable",
+      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 snapshotMismatch = normalized.match(
+    /((?:Error:\s*)?Snapshot\b.+\bmismatched\b[^$]*|Snapshot comparison failed[^$]*)/i
+  );
+  if (snapshotMismatch) {
+    return {
+      reason: buildClassifiedReason(
+        "snapshot mismatch",
+        buildExcerptDetail(snapshotMismatch[1] ?? normalized, "snapshot output changed")
+      ),
+      group: "snapshot mismatches"
+    };
+  }
+  const timeoutFailure = normalized.match(
+    /(Failed:\s*Timeout\s*>[^,;]+|asyncio\.exceptions\.TimeoutError:\s*.+|TimeoutError:\s*.+|(?:Test|Hook)\s+timed out in\s+\d+(?:\.\d+)?m?s[^$]*|(?:\[vitest-(?:worker|pool)\]:\s*)?Timeout[^$]*)$/i
+  );
+  if (timeoutFailure) {
+    return {
+      reason: buildClassifiedReason(
+        "timeout",
+        buildExcerptDetail(timeoutFailure[1] ?? normalized, "test exceeded timeout threshold")
+      ),
+      group: "timeout failures"
+    };
+  }
+  const asyncLoopFailure = normalized.match(
+    /(Event loop is closed|no current event loop|coroutine .* was never awaited|coroutine was never awaited)/i
+  );
+  if (asyncLoopFailure) {
+    return {
+      reason: buildClassifiedReason(
+        "async loop",
+        buildExcerptDetail(asyncLoopFailure[1] ?? normalized, "async event loop failure")
+      ),
+      group: "async event loop failures"
+    };
+  }
+  const permissionFailure = normalized.match(
+    /(PermissionError:\s*\[Errno 13\][^$]*|Address already in use)/i
+  );
+  if (permissionFailure) {
+    return {
+      reason: buildClassifiedReason(
+        "permission",
+        buildExcerptDetail(permissionFailure[1] ?? normalized, "permission denied or resource locked")
+      ),
+      group: "permission or locked resource failures"
+    };
+  }
+  const xdistWorkerCrash = normalized.match(
+    /(worker ['"][^'"]+['"] crashed|node down:\s*[^,;]+|WorkerLost[^,;]*|Worker exited unexpectedly[^,;]*|worker exited unexpectedly[^,;]*)/i
+  );
+  if (xdistWorkerCrash) {
+    return {
+      reason: buildClassifiedReason(
+        "xdist worker crash",
+        buildExcerptDetail(xdistWorkerCrash[1] ?? normalized, "pytest-xdist worker crashed")
+      ),
+      group: "xdist worker crashes"
+    };
+  }
+  if (/Worker terminated due to reaching memory limit/i.test(normalized)) {
+    return {
+      reason: "memory: Worker terminated due to reaching memory limit",
+      group: "memory exhaustion failures"
+    };
+  }
+  if (/Database access not allowed, use the ["']django_db["'] mark/i.test(normalized)) {
+    return {
+      reason: 'django db access: Database access not allowed, use the "django_db" mark',
+      group: "django database marker failures"
+    };
+  }
+  const networkFailure = normalized.match(
+    /(Max retries exceeded[^,;]*|gaierror[^,;]*|SSLCertVerificationError[^,;]*|Network is unreachable)/i
+  );
+  if (networkFailure) {
+    return {
+      reason: buildClassifiedReason(
+        "network",
+        buildExcerptDetail(networkFailure[1] ?? normalized, "network dependency failure")
+      ),
+      group: "network dependency failures"
+    };
   }
-  if (reason.startsWith("assertion failed:")) {
-    return 4;
+  const relationMigration = normalized.match(/relation ["'`]([^"'`]+)["'`] does not exist/i);
+  if (relationMigration) {
+    return {
+      reason: buildClassifiedReason("db migration", `relation ${relationMigration[1]} does not exist`),
+      group: "database migration or schema failures"
+    };
   }
-  if (/^[A-Z][A-Za-z]+(?:Error|Exception):/.test(reason)) {
-    return 3;
+  const noSuchTable = normalized.match(/no such table(?::)?\s*([A-Za-z0-9_.-]+)/i);
+  if (noSuchTable) {
+    return {
+      reason: buildClassifiedReason("db migration", `no such table ${noSuchTable[1]}`),
+      group: "database migration or schema failures"
+    };
   }
-  if (reason === "import error during collection") {
-    return 2;
+  if (/InconsistentMigrationHistory/i.test(normalized)) {
+    return {
+      reason: "db migration: InconsistentMigrationHistory",
+      group: "database migration or schema failures"
+    };
   }
-  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];
+  if (/(Segmentation fault|SIGSEGV|\bexit 139\b)/i.test(normalized)) {
+    return {
+      reason: buildClassifiedReason(
+        "segfault",
+        buildExcerptDetail(normalized, "subprocess crashed with SIGSEGV")
+      ),
+      group: "subprocess crash failures"
+    };
   }
-  const fallbackMatch = normalized.match(
-    /\b([A-Z][A-Z0-9_]{2,})\b(?=[^.\n]*DB-isolated tests)/
-  );
-  return fallbackMatch?.[1] ?? null;
-}
-function classifyFailureReason(line, options) {
-  const normalized = line.trim().replace(/^[A-Z]\s+/, "");
-  if (normalized.length === 0) {
-    return null;
+  if (/(MemoryError\b|\bexit 137\b|OOMKilled|OutOfMemory)/i.test(normalized)) {
+    return {
+      reason: buildClassifiedReason(
+        "memory",
+        buildExcerptDetail(normalized, "process exhausted available memory")
+      ),
+      group: "memory exhaustion failures"
+    };
   }
-  if (isLowValueInternalReason(normalized)) {
-    return null;
+  const typeErrorFailure = normalized.match(/TypeError:\s*(.+)$/i);
+  if (typeErrorFailure) {
+    return {
+      reason: buildClassifiedReason(
+        "type error",
+        buildExcerptDetail(typeErrorFailure[1] ?? normalized, "TypeError")
+      ),
+      group: "type errors"
+    };
   }
-  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 serializationFailure = normalized.match(
+    /\b(UnicodeDecodeError|JSONDecodeError|PicklingError):\s*(.+)$/i
+  );
+  if (serializationFailure) {
+    return {
+      reason: buildClassifiedReason(
+        "serialization",
+        `${serializationFailure[1]}: ${buildExcerptDetail(serializationFailure[2] ?? "", serializationFailure[1] ?? "serialization failure")}`
+      ),
+      group: "serialization and encoding failures"
+    };
   }
-  const envBlocker = extractEnvBlockerName(normalized);
-  if (envBlocker) {
+  const fileNotFoundFailure = normalized.match(/FileNotFoundError:\s*(.+)$/i);
+  if (fileNotFoundFailure) {
     return {
-      reason: `missing test env: ${envBlocker}`,
-      group: "DB-backed tests are blocked by missing test environment configuration"
+      reason: buildClassifiedReason(
+        "file not found",
+        buildExcerptDetail(fileNotFoundFailure[1] ?? normalized, "missing file during test execution")
+      ),
+      group: "missing file failures"
     };
   }
-  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
+  const deprecationFailure = normalized.match(
+    /\b(DeprecationWarning|FutureWarning|PytestRemovedIn9Warning):\s*(.+)$/i
   );
-  if (missingEnv) {
+  if (deprecationFailure) {
     return {
-      reason: `missing test env: ${missingEnv[1]}`,
-      group: "tests are blocked by missing environment configuration"
+      reason: buildClassifiedReason(
+        "deprecation as error",
+        `${deprecationFailure[1]}: ${buildExcerptDetail(deprecationFailure[2] ?? "", deprecationFailure[1] ?? "warning treated as error")}`
+      ),
+      group: "warnings treated as errors"
     };
   }
-  const keyErrorEnv = normalized.match(/KeyError:\s*['"]([A-Z][A-Z0-9_]{2,})['"]/);
-  if (keyErrorEnv) {
+  const strictXfail = normalized.match(/XPASS\(strict\)\s*:?\s*(.+)?$/i);
+  if (strictXfail) {
     return {
-      reason: `missing test env: ${keyErrorEnv[1]}`,
-      group: "tests are blocked by missing environment configuration"
+      reason: buildClassifiedReason(
+        "xfail strict",
+        buildExcerptDetail(strictXfail[1] ?? normalized, "strict xfail unexpectedly passed")
+      ),
+      group: "strict xfail expectation failures"
     };
   }
-  const fixtureGuard = normalized.match(
-    /(?:FixtureLookupError|fixture guard|requires fixture)\b[^A-Za-z0-9_'-]*([a-z_][a-z0-9_]*)?/i
+  const resourceLeak = normalized.match(
+    /(PytestUnraisableExceptionWarning[^,;]*|ResourceWarning:\s*unclosed[^,;]*)/i
   );
-  if (fixtureGuard) {
+  if (resourceLeak) {
     return {
-      reason: `fixture guard: ${fixtureGuard[1] ?? "required fixture unavailable"}`.trim(),
-      group: "fixture guards or setup gates"
+      reason: buildClassifiedReason(
+        "resource leak",
+        buildExcerptDetail(resourceLeak[1] ?? normalized, "resource leak warning promoted to failure")
+      ),
+      group: "resource leak warnings"
     };
   }
-  if (/(ECONNREFUSED|ConnectionRefusedError|connection refused|could not connect to server)/i.test(
-    normalized
-  ) && /(postgres|database|db|5432)/i.test(normalized)) {
+  const flakyFailure = normalized.match(/\b(RERUN|[0-9]+\s+rerun|Flaky test passed)\b[^$]*/i);
+  if (flakyFailure) {
     return {
-      reason: "db refused: database connection was refused",
-      group: "database connectivity failures"
+      reason: buildClassifiedReason(
+        "flaky",
+        buildExcerptDetail(flakyFailure[0] ?? normalized, "test required reruns before passing")
+      ),
+      group: "flaky test detections"
     };
   }
-  if (/(503\b|service unavailable|temporarily unavailable)/i.test(normalized)) {
+  const teardownFailure = normalized.match(/ERROR at teardown of\s+(.+)$/i);
+  if (teardownFailure) {
     return {
-      reason: "service unavailable: dependency service is unavailable",
-      group: "service availability failures"
+      reason: buildClassifiedReason(
+        "fixture teardown",
+        buildExcerptDetail(teardownFailure[1] ?? normalized, "fixture teardown failed")
+      ),
+      group: "fixture teardown failures"
     };
   }
-  if (/(auth bypass|test auth|bypass token)/i.test(normalized) && /(missing|absent|not configured|not set|unavailable)/i.test(normalized)) {
+  const configurationFailure = normalized.match(
+    /(INTERNALERROR>.+|ConftestImportFailure[^,;]*|UsageError:\s*.+|ERROR:\s*usage:\s*.+|pytest:\s*error:\s*.+|Cannot use import statement outside a module[^$]*|Named export.+not found.+CommonJS[^$]*|failed to load config from.+|localStorage is not available[^$]*|No test suite found in file.+|No test found in suite.+)$/i
+  );
+  if (configurationFailure) {
     return {
-      reason: "auth bypass absent: test auth bypass is missing",
-      group: "authentication test setup failures"
+      reason: buildClassifiedReason(
+        "configuration",
+        buildExcerptDetail(configurationFailure[1] ?? normalized, "test configuration error")
+      ),
+      group: "test configuration failures"
     };
   }
   const pythonMissingModule = normalized.match(
@@ -3310,6 +4614,20 @@ function classifyFailureReason(line, options) {
       group: options.duringCollection ? "import/dependency errors during collection" : "missing dependency/module errors"
     };
   }
+  const importResolutionFailure = normalized.match(/Failed to resolve import ['"]([^'"]+)['"]/i);
+  if (importResolutionFailure) {
+    return {
+      reason: `missing module: ${importResolutionFailure[1]}`,
+      group: options.duringCollection ? "import/dependency errors during collection" : "missing dependency/module errors"
+    };
+  }
+  const esmModuleFailure = normalized.match(/ERR_MODULE_NOT_FOUND[^'"`]*['"`]([^'"`]+)['"`]/i) ?? normalized.match(/Cannot find package ['"`]([^'"`]+)['"`]/i);
+  if (esmModuleFailure) {
+    return {
+      reason: `missing module: ${esmModuleFailure[1]}`,
+      group: options.duringCollection ? "import/dependency errors during collection" : "missing dependency/module errors"
+    };
+  }
   const assertionFailure = normalized.match(/AssertionError:\s*(.+)$/i);
   if (assertionFailure) {
     return {
@@ -3317,6 +4635,16 @@ function classifyFailureReason(line, options) {
       group: "assertion failures"
     };
   }
+  const vitestUnhandled = normalized.match(/Vitest caught\s+\d+\s+unhandled errors?/i);
+  if (vitestUnhandled) {
+    return {
+      reason: `RuntimeError: ${buildExcerptDetail(vitestUnhandled[0] ?? normalized, "Vitest caught unhandled errors")}`.slice(
+        0,
+        120
+      ),
+      group: "runtime failures"
+    };
+  }
   const genericError = normalized.match(/\b([A-Z][A-Za-z]+(?:Error|Exception)):\s*(.+)$/);
   if (genericError) {
     const errorType = genericError[1];
@@ -3361,6 +4689,125 @@ function chooseStrongestFailureItems(items) {
   }
   return order.map((label) => strongest.get(label));
 }
+function extractJsTestFile(value) {
+  const match = value.match(/([A-Za-z0-9_./-]+\.(?:test|spec)\.[cm]?[jt]sx?)/i);
+  return match ? normalizeAnchorFile(match[1]) : null;
+}
+function normalizeJsFailureLabel(label) {
+  return cleanFailureLabel(label).replace(/^[❯×]\s*/, "").replace(/\s+\[[^\]]+\]\s*$/, "").replace(/\s+/g, " ").trim();
+}
+function classifyFailureLines(args) {
+  let observedAnchor = null;
+  let strongest = null;
+  for (const line of args.lines) {
+    observedAnchor = parseObservedAnchor(line) ?? observedAnchor;
+    const classification = classifyFailureReason(line, {
+      duringCollection: args.duringCollection
+    });
+    if (!classification) {
+      continue;
+    }
+    const score = scoreFailureReason(classification.reason);
+    if (!strongest || score > strongest.score) {
+      strongest = {
+        classification,
+        score,
+        observedAnchor: parseObservedAnchor(line) ?? observedAnchor
+      };
+    }
+  }
+  if (!strongest) {
+    return null;
+  }
+  return {
+    classification: strongest.classification,
+    observedAnchor: strongest.observedAnchor ?? observedAnchor
+  };
+}
+function collectJsFailureBlocks(input) {
+  const blocks = [];
+  let current = null;
+  let section = null;
+  let currentFile = null;
+  const flushCurrent = () => {
+    if (!current) {
+      return;
+    }
+    blocks.push(current);
+    current = null;
+  };
+  for (const rawLine of input.split("\n")) {
+    const line = rawLine.trimEnd();
+    const trimmed = line.trim();
+    if (/⎯{2,}\s+Failed Tests?\s+\d+\s+⎯{2,}/.test(line)) {
+      flushCurrent();
+      section = "failed_tests";
+      continue;
+    }
+    if (/⎯{2,}\s+Failed Suites?\s+\d+\s+⎯{2,}/.test(line)) {
+      flushCurrent();
+      section = "failed_suites";
+      continue;
+    }
+    if (section && /^⎯{2,}.+⎯{2,}\s*$/.test(line)) {
+      flushCurrent();
+      section = null;
+      continue;
+    }
+    const progress = line.match(
+      /^(.+?\.(?:test|spec)\.[cm]?[jt]sx?(?:\s+>.+?)?)\s+(FAILED|ERROR)\s+\[[^\]]+\]\s*$/
+    );
+    if (progress) {
+      flushCurrent();
+      const label = normalizeJsFailureLabel(progress[1]);
+      current = {
+        label,
+        status: progress[2] === "ERROR" ? "error" : "failed",
+        detailLines: []
+      };
+      currentFile = extractJsTestFile(label);
+      continue;
+    }
+    const failHeader = line.match(/^\s*FAIL\s+(.+)$/);
+    if (failHeader) {
+      const label = normalizeJsFailureLabel(failHeader[1]);
+      if (extractJsTestFile(label)) {
+        flushCurrent();
+        current = {
+          label,
+          status: section === "failed_suites" || !label.includes(" > ") ? "error" : "failed",
+          detailLines: []
+        };
+        currentFile = extractJsTestFile(label);
+        continue;
+      }
+    }
+    const failedTest = line.match(/^\s*×\s+(.+)$/);
+    if (failedTest && (section === "failed_tests" || extractJsTestFile(failedTest[1]))) {
+      flushCurrent();
+      const candidate = normalizeJsFailureLabel(failedTest[1]);
+      const file = extractJsTestFile(candidate) ?? currentFile;
+      const label = file && !extractJsTestFile(candidate) ? `${file} > ${candidate}` : candidate;
+      current = {
+        label,
+        status: "failed",
+        detailLines: []
+      };
+      currentFile = extractJsTestFile(label) ?? currentFile;
+      continue;
+    }
+    if (/^\s*(?:Tests?|Snapshots?|Test Files?|Test Suites?)\b/.test(line)) {
+      flushCurrent();
+      section = null;
+      continue;
+    }
+    if (current && trimmed.length > 0) {
+      current.detailLines.push(line);
+    }
+  }
+  flushCurrent();
+  return blocks;
+}
 function collectCollectionFailureItems(input) {
   const items = [];
   const lines = input.split("\n");
@@ -3368,6 +4815,24 @@ function collectCollectionFailureItems(input) {
   let pendingGenericReason = null;
   let currentAnchor = null;
   for (const line of lines) {
+    const standaloneCollectionLabel = line.match(/No test suite found in file\s+(.+)$/i)?.[1] ?? line.match(/No test found in suite\s+(.+)$/i)?.[1] ?? line.match(/failed to load config from\s+(.+)$/i)?.[1];
+    if (standaloneCollectionLabel) {
+      const classification2 = classifyFailureReason(line, {
+        duringCollection: true
+      });
+      if (classification2) {
+        pushFocusedFailureItem(items, {
+          label: cleanFailureLabel(standaloneCollectionLabel),
+          reason: classification2.reason,
+          group: classification2.group,
+          ...resolveAnchorForLabel({
+            label: cleanFailureLabel(standaloneCollectionLabel),
+            observedAnchor: parseObservedAnchor(line)
+          })
+        });
+      }
+      continue;
+    }
     const collecting = line.match(/^_+\s+ERROR collecting\s+(.+?)\s+_+\s*$/);
     if (collecting) {
       if (currentLabel && pendingGenericReason) {
@@ -3456,6 +4921,24 @@ function collectInlineFailureItems(input) {
       })
     });
   }
+  for (const block of collectJsFailureBlocks(input)) {
+    const resolved = classifyFailureLines({
+      lines: block.detailLines,
+      duringCollection: block.status === "error"
+    });
+    if (!resolved) {
+      continue;
+    }
+    pushFocusedFailureItem(items, {
+      label: block.label,
+      reason: resolved.classification.reason,
+      group: resolved.classification.group,
+      ...resolveAnchorForLabel({
+        label: block.label,
+        observedAnchor: resolved.observedAnchor
+      })
+    });
+  }
   return items;
 }
 function collectInlineFailureItemsWithStatus(input) {
@@ -3490,16 +4973,42 @@ function collectInlineFailureItemsWithStatus(input) {
       })
     });
   }
+  for (const block of collectJsFailureBlocks(input)) {
+    const resolved = classifyFailureLines({
+      lines: block.detailLines,
+      duringCollection: block.status === "error"
+    });
+    if (!resolved) {
+      continue;
+    }
+    items.push({
+      label: block.label,
+      reason: resolved.classification.reason,
+      group: resolved.classification.group,
+      status: block.status,
+      ...resolveAnchorForLabel({
+        label: block.label,
+        observedAnchor: resolved.observedAnchor
+      })
+    });
+  }
   return items;
 }
 function collectStandaloneErrorClassifications(input) {
   const classifications = [];
   for (const line of input.split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed) {
+      continue;
+    }
     const standalone = line.match(/^\s*E\s+(.+)$/);
-    if (!standalone) {
+    const candidate = standalone?.[1] ?? (/^(INTERNALERROR>|ConftestImportFailure\b|UsageError:|ERROR:\s*usage:|pytest:\s*error:)/i.test(
+      trimmed
+    ) ? trimmed : null);
+    if (!candidate) {
       continue;
     }
-    const classification = classifyFailureReason(standalone[1], {
+    const classification = classifyFailureReason(candidate, {
       duringCollection: false
     });
     if (!classification || classification.reason === "import error during collection") {
@@ -3615,6 +5124,9 @@ function collectFailureLabels(input) {
       pushLabel(summary[2], summary[1] === "FAILED" ? "failed" : "error");
     }
   }
+  for (const block of collectJsFailureBlocks(input)) {
+    pushLabel(block.label, block.status);
+  }
   return labels;
 }
 function classifyBucketTypeFromReason(reason) {
@@ -3624,6 +5136,60 @@ function classifyBucketTypeFromReason(reason) {
   if (reason.startsWith("fixture guard:")) {
     return "fixture_guard_failure";
   }
+  if (reason.startsWith("timeout:")) {
+    return "timeout_failure";
+  }
+  if (reason.startsWith("permission:")) {
+    return "permission_denied_failure";
+  }
+  if (reason.startsWith("async loop:")) {
+    return "async_event_loop_failure";
+  }
+  if (reason.startsWith("fixture teardown:")) {
+    return "fixture_teardown_failure";
+  }
+  if (reason.startsWith("db migration:")) {
+    return "db_migration_failure";
+  }
+  if (reason.startsWith("configuration:")) {
+    return "configuration_error";
+  }
+  if (reason.startsWith("xdist worker crash:")) {
+    return "xdist_worker_crash";
+  }
+  if (reason.startsWith("type error:")) {
+    return "type_error_failure";
+  }
+  if (reason.startsWith("resource leak:")) {
+    return "resource_leak_warning";
+  }
+  if (reason.startsWith("django db access:")) {
+    return "django_db_access_denied";
+  }
+  if (reason.startsWith("network:")) {
+    return "network_failure";
+  }
+  if (reason.startsWith("segfault:")) {
+    return "subprocess_crash_segfault";
+  }
+  if (reason.startsWith("flaky:")) {
+    return "flaky_test_detected";
+  }
+  if (reason.startsWith("serialization:")) {
+    return "serialization_encoding_failure";
+  }
+  if (reason.startsWith("file not found:")) {
+    return "file_not_found_failure";
+  }
+  if (reason.startsWith("memory:")) {
+    return "memory_error";
+  }
+  if (reason.startsWith("deprecation as error:")) {
+    return "deprecation_warning_as_error";
+  }
+  if (reason.startsWith("xfail strict:")) {
+    return "xfail_strict_unexpected_pass";
+  }
   if (reason.startsWith("service unavailable:")) {
     return "service_unavailable";
   }
@@ -3633,6 +5199,9 @@ function classifyBucketTypeFromReason(reason) {
   if (reason.startsWith("auth bypass absent:")) {
     return "auth_bypass_absent";
   }
+  if (reason.startsWith("snapshot mismatch:")) {
+    return "snapshot_mismatch";
+  }
   if (reason.startsWith("missing module:")) {
     return "import_dependency_failure";
   }
@@ -3645,9 +5214,6 @@ function classifyBucketTypeFromReason(reason) {
   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);
@@ -3662,7 +5228,7 @@ function synthesizeSharedBlockerBucket(args) {
       items: [item]
     });
   }
-  const top = [...visibleReasonGroups.entries()].filter(([, entry]) => entry.count >= 3).sort((left, right) => right[1].count - left[1].count)[0];
+  const top = [...visibleReasonGroups.entries()].filter(([reason, entry]) => entry.count >= sharedBlockerThreshold(reason)).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);
@@ -3675,7 +5241,7 @@ function synthesizeSharedBlockerBucket(args) {
       group: classification.group
     });
   }
-  const standaloneTop = [...standaloneReasonGroups.entries()].filter(([, entry]) => entry.count >= 3).sort((left, right) => right[1].count - left[1].count)[0];
+  const standaloneTop = [...standaloneReasonGroups.entries()].filter(([reason, entry]) => entry.count >= sharedBlockerThreshold(reason)).sort((left, right) => right[1].count - left[1].count)[0];
   const visibleTopReason = top?.[0];
   const visibleTopStats = top?.[1];
   const standaloneTopReason = standaloneTop?.[0];
@@ -3714,6 +5280,12 @@ function synthesizeSharedBlockerBucket(args) {
   let hint;
   if (envVar) {
     hint = `Set ${envVar} (or pass --pgtest-dsn) before rerunning DB-isolated tests.`;
+  } else if (effectiveReason.startsWith("configuration:")) {
+    hint = "Fix the pytest configuration or conftest import error before rerunning the suite.";
+  } else if (effectiveReason.startsWith("xdist worker crash:")) {
+    hint = "Check shared state, worker startup, or resource contention between xdist workers before rerunning.";
+  } else if (effectiveReason.startsWith("network:")) {
+    hint = "Restore DNS, TLS, or outbound network access for the affected dependency before rerunning.";
   } 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:")) {
@@ -3728,6 +5300,12 @@ function synthesizeSharedBlockerBucket(args) {
   let headline;
   if (envVar) {
     headline = `Shared blocker: ${atLeastPrefix}${countText} errors require ${envVar} for DB-isolated tests.`;
+  } else if (effectiveReason.startsWith("configuration:")) {
+    headline = `Shared blocker: ${atLeastPrefix}${countText} visible failure${countText === 1 ? "" : "s"} are caused by a pytest configuration error.`;
+  } else if (effectiveReason.startsWith("xdist worker crash:")) {
+    headline = `Shared blocker: ${atLeastPrefix}${countText} errors are caused by xdist worker crashes.`;
+  } else if (effectiveReason.startsWith("network:")) {
+    headline = `Shared blocker: ${atLeastPrefix}${countText} errors are caused by a network dependency failure.`;
   } 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:")) {
@@ -3758,22 +5336,28 @@ function synthesizeSharedBlockerBucket(args) {
   };
 }
 function synthesizeImportDependencyBucket(args) {
-  if (args.errors === 0) {
-    return null;
-  }
-  const importItems = args.visibleErrorItems.filter((item) => item.reason.startsWith("missing module:"));
-  if (importItems.length < 2) {
+  const visibleImportItems = args.visibleErrorItems.filter(
+    (item) => item.reason.startsWith("missing module:")
+  );
+  const inlineImportItems = chooseStrongestFailureItems(
+    args.inlineItems.filter((item) => item.reason.startsWith("missing module:"))
+  );
+  const importItems = visibleImportItems.length > 0 ? visibleImportItems : inlineImportItems.map((item) => ({
+    ...item,
+    status: "failed"
+  }));
+  if (importItems.length === 0) {
     return null;
   }
   const allVisibleErrorsAreImportRelated = args.visibleErrorItems.length > 0 && args.visibleErrorItems.every((item) => item.reason.startsWith("missing module:"));
-  const countClaimed = allVisibleErrorsAreImportRelated && importItems.length >= 3 && args.errors >= importItems.length ? args.errors : void 0;
+  const countClaimed = allVisibleErrorsAreImportRelated && importItems.length >= 2 && args.errors >= importItems.length ? args.errors : void 0;
   const modules = Array.from(
     new Set(
       importItems.map((item) => item.reason.replace("missing module:", "").trim()).filter(Boolean)
     )
   ).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 headline = countClaimed ? `Import/dependency blocker: ${headlineCount} errors are caused by missing dependencies during test collection.` : `Import/dependency blocker: at least ${headlineCount} visible failure${headlineCount === 1 ? "" : "s"} are caused by missing dependencies during test collection.`;
   const summaryLines = [headline];
   if (modules.length > 0) {
     summaryLines.push(`Missing modules include ${modules.join(", ")}.`);
@@ -3783,7 +5367,7 @@ function synthesizeImportDependencyBucket(args) {
     headline,
     countVisible: importItems.length,
     countClaimed,
-    reason: "missing dependencies during test collection",
+    reason: modules.length === 1 ? `missing module: ${modules[0]}` : "missing dependencies during test collection",
     representativeItems: importItems.slice(0, 4).map((item) => ({
       label: item.label,
       reason: item.reason,
@@ -3802,7 +5386,7 @@ function synthesizeImportDependencyBucket(args) {
   };
 }
 function isContractDriftLabel(label) {
-  return /(freeze|snapshot|contract|manifest|openapi)/i.test(label);
+  return /(freeze|contract|manifest|openapi|golden)/i.test(label);
 }
 function looksLikeTaskKey(value) {
   return /^[a-z]+(?:_[a-z0-9]+)+$/i.test(value) && !value.startsWith("/api/");
@@ -3864,7 +5448,7 @@ function extractContractDriftEntities(input) {
 }
 function buildContractRepresentativeReason(args) {
   if (/openapi/i.test(args.label) && args.entities.apiPaths.length > 0) {
-    const nextPath = args.entities.apiPaths.find((path7) => !args.usedPaths.has(path7)) ?? args.entities.apiPaths[0];
+    const nextPath = args.entities.apiPaths.find((path8) => !args.usedPaths.has(path8)) ?? args.entities.apiPaths[0];
     args.usedPaths.add(nextPath);
     return `added path: ${nextPath}`;
   }
@@ -3933,13 +5517,67 @@ function synthesizeContractDriftBucket(args) {
     overflowLabel: "changed entities"
   };
 }
+function synthesizeSnapshotMismatchBucket(args) {
+  const snapshotItems = chooseStrongestFailureItems(
+    args.inlineItems.filter((item) => item.reason.startsWith("snapshot mismatch:"))
+  );
+  if (snapshotItems.length === 0) {
+    return null;
+  }
+  const countClaimed = args.snapshotFailures && args.snapshotFailures >= snapshotItems.length ? args.snapshotFailures : void 0;
+  const countText = countClaimed ?? snapshotItems.length;
+  const summaryLines = [
+    `Snapshot mismatches: ${formatCount2(countText, "snapshot expectation")} ${countText === 1 ? "is" : "are"} out of date with current output.`
+  ];
+  return {
+    type: "snapshot_mismatch",
+    headline: summaryLines[0],
+    countVisible: snapshotItems.length,
+    countClaimed,
+    reason: "snapshot mismatch: snapshot expectations differ from current output",
+    representativeItems: snapshotItems.slice(0, 4),
+    entities: snapshotItems.map((item) => item.label.split(" > ").slice(1).join(" > ").trim() || item.label).slice(0, 6),
+    hint: "Update the snapshots if these output changes are intentional.",
+    confidence: countClaimed ? 0.92 : 0.8,
+    summaryLines,
+    overflowCount: Math.max((countClaimed ?? snapshotItems.length) - Math.min(snapshotItems.length, 4), 0),
+    overflowLabel: "snapshot failures"
+  };
+}
+function synthesizeTimeoutBucket(args) {
+  const timeoutItems = chooseStrongestFailureItems(
+    args.inlineItems.filter((item) => item.reason.startsWith("timeout:"))
+  );
+  if (timeoutItems.length === 0) {
+    return null;
+  }
+  const summaryLines = [
+    `Timeout failures: ${formatCount2(timeoutItems.length, "test")} exceeded the configured timeout threshold.`
+  ];
+  return {
+    type: "timeout_failure",
+    headline: summaryLines[0],
+    countVisible: timeoutItems.length,
+    countClaimed: timeoutItems.length,
+    reason: timeoutItems.length === 1 ? timeoutItems[0].reason : "timeout: tests exceeded the configured timeout threshold",
+    representativeItems: timeoutItems.slice(0, 4),
+    entities: timeoutItems.map((item) => item.label.split(" > ").slice(1).join(" > ").trim() || item.label).slice(0, 6),
+    hint: "Check for deadlocks, slow setup, or increase the timeout threshold before rerunning.",
+    confidence: 0.84,
+    summaryLines,
+    overflowCount: Math.max(timeoutItems.length - Math.min(timeoutItems.length, 4), 0),
+    overflowLabel: "timeout failures"
+  };
+}
 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 runner = detectTestRunner(input);
+  const counts = extractTestStatusCounts(input, runner);
+  const passed = counts.passed;
+  const failed = counts.failed;
+  const errors = counts.errors;
+  const skipped = counts.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 noTestsCollected = /\bcollected\s+0\s+items\b/i.test(input) || /\bno tests ran\b/i.test(input) || /No test suite found in file/i.test(input) || /No test found in suite/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));
@@ -3966,7 +5604,8 @@ function analyzeTestStatus(input) {
   if (!sharedBlocker) {
     const importDependencyBucket = synthesizeImportDependencyBucket({
       errors,
-      visibleErrorItems
+      visibleErrorItems,
+      inlineItems
     });
     if (importDependencyBucket) {
       buckets.push(importDependencyBucket);
@@ -3979,11 +5618,26 @@ function analyzeTestStatus(input) {
   if (contractDrift) {
     buckets.push(contractDrift);
   }
+  const snapshotMismatch = synthesizeSnapshotMismatchBucket({
+    inlineItems,
+    snapshotFailures: counts.snapshotFailures
+  });
+  if (snapshotMismatch) {
+    buckets.push(snapshotMismatch);
+  }
+  const timeoutBucket = synthesizeTimeoutBucket({
+    inlineItems
+  });
+  if (timeoutBucket) {
+    buckets.push(timeoutBucket);
+  }
   return {
+    runner,
     passed,
     failed,
     errors,
     skipped,
+    snapshotFailures: counts.snapshotFailures,
     noTestsCollected,
     interrupted,
     collectionErrorCount: collectionErrors ? Number(collectionErrors[1]) : void 0,
@@ -4495,6 +6149,7 @@ function buildGenericRawSlice(args) {
 
 // src/core/run.ts
 var RETRY_DELAY_MS = 300;
+var PROVIDER_PENDING_NOTICE_DELAY_MS = 150;
 function estimateTokenCount(text) {
   return Math.max(1, Math.ceil(text.length / 4));
 }
@@ -4515,6 +6170,8 @@ function logVerboseTestStatusTelemetry(args) {
     `${pc2.dim("sift")} diagnosis_complete_at_layer=${getDiagnosisCompleteAtLayer(args.contract)}`,
     `${pc2.dim("sift")} heuristic_short_circuit=${!args.contract.provider_used && args.contract.diagnosis_complete && !args.contract.raw_needed && !args.contract.provider_failed}`,
     `${pc2.dim("sift")} raw_input_chars=${args.request.stdin.length}`,
+    `${pc2.dim("sift")} heuristic_input_chars=${args.heuristicInputChars}`,
+    `${pc2.dim("sift")} heuristic_input_truncated=${args.heuristicInputTruncated}`,
     `${pc2.dim("sift")} prepared_input_chars=${args.prepared.meta.finalLength}`,
     `${pc2.dim("sift")} raw_slice_chars=${args.rawSliceChars ?? 0}`,
     `${pc2.dim("sift")} provider_input_chars=${args.providerInputChars ?? 0}`,
@@ -4556,6 +6213,7 @@ function buildDryRunOutput(args) {
       responseMode: args.responseMode,
       policy: args.request.policyName ?? null,
       heuristicOutput: args.heuristicOutput ?? null,
+      heuristicInput: args.heuristicInput,
       input: {
         originalLength: args.prepared.meta.originalLength,
         finalLength: args.prepared.meta.finalLength,
@@ -4572,6 +6230,25 @@ function buildDryRunOutput(args) {
 async function delay(ms) {
   await new Promise((resolve) => setTimeout(resolve, ms));
 }
+function startProviderPendingNotice() {
+  if (!process.stderr.isTTY) {
+    return () => {
+    };
+  }
+  const message = "sift waiting for provider...";
+  let shown = false;
+  const timer = setTimeout(() => {
+    shown = true;
+    process.stderr.write(`${message}\r`);
+  }, PROVIDER_PENDING_NOTICE_DELAY_MS);
+  return () => {
+    clearTimeout(timer);
+    if (!shown) {
+      return;
+    }
+    process.stderr.write(`\r${" ".repeat(message.length)}\r`);
+  };
+}
 function withInsufficientHint(args) {
   if (!isInsufficientSignalOutput(args.output)) {
     return args.output;
@@ -4592,22 +6269,27 @@ async function generateWithRetry(args) {
     responseMode: args.responseMode,
     jsonResponseFormat: args.request.config.provider.jsonResponseFormat
   });
+  const stopPendingNotice = startProviderPendingNotice();
   try {
-    return await generate();
-  } catch (error) {
-    const reason = error instanceof Error ? error.message : "unknown_error";
-    if (!isRetriableReason(reason)) {
-      throw error;
-    }
-    if (args.request.config.runtime.verbose) {
-      process.stderr.write(
-        `${pc2.dim("sift")} retry=1 reason=${reason} delay_ms=${RETRY_DELAY_MS}
+    try {
+      return await generate();
+    } catch (error) {
+      const reason = error instanceof Error ? error.message : "unknown_error";
+      if (!isRetriableReason(reason)) {
+        throw error;
+      }
+      if (args.request.config.runtime.verbose) {
+        process.stderr.write(
+          `${pc2.dim("sift")} retry=1 reason=${reason} delay_ms=${RETRY_DELAY_MS}
 `
-      );
+        );
+      }
+      await delay(RETRY_DELAY_MS);
     }
-    await delay(RETRY_DELAY_MS);
+    return await generate();
+  } finally {
+    stopPendingNotice();
   }
-  return generate();
 }
 function hasRecognizableTestStatusSignal(input) {
   const analysis = analyzeTestStatus(input);
@@ -4662,11 +6344,22 @@ function buildTestStatusProviderFailureDecision(args) {
 }
 async function runSift(request) {
   const prepared = prepareInput(request.stdin, request.config.input);
+  const heuristicInput = prepared.redacted;
+  const heuristicInputTruncated = false;
+  const heuristicPrepared = {
+    ...prepared,
+    truncated: heuristicInput,
+    meta: {
+      ...prepared.meta,
+      finalLength: heuristicInput.length,
+      truncatedApplied: heuristicInputTruncated
+    }
+  };
   const provider = createProvider(request.config);
-  const hasTestStatusSignal = request.policyName === "test-status" && hasRecognizableTestStatusSignal(prepared.truncated);
-  const testStatusAnalysis = hasTestStatusSignal ? analyzeTestStatus(prepared.truncated) : null;
+  const hasTestStatusSignal = request.policyName === "test-status" && hasRecognizableTestStatusSignal(heuristicInput);
+  const testStatusAnalysis = hasTestStatusSignal ? analyzeTestStatus(heuristicInput) : null;
   const testStatusDecision = hasTestStatusSignal && testStatusAnalysis ? buildTestStatusDiagnoseContract({
-    input: prepared.truncated,
+    input: heuristicInput,
     analysis: testStatusAnalysis,
     resolvedTests: request.testStatusContext?.resolvedTests,
     remainingTests: request.testStatusContext?.remainingTests
@@ -4681,7 +6374,7 @@ async function runSift(request) {
 `
     );
   }
-  const heuristicOutput = request.policyName === "test-status" ? testStatusDecision?.contract.diagnosis_complete ? testStatusHeuristicOutput : null : applyHeuristicPolicy(request.policyName, prepared.truncated, request.detail);
+  const heuristicOutput = request.policyName === "test-status" ? testStatusDecision?.contract.diagnosis_complete ? testStatusHeuristicOutput : null : applyHeuristicPolicy(request.policyName, heuristicInput, request.detail);
   if (heuristicOutput) {
     if (request.config.runtime.verbose) {
       process.stderr.write(`${pc2.dim("sift")} heuristic=${request.policyName}
@@ -4691,7 +6384,7 @@ async function runSift(request) {
       question: request.question,
       format: request.format,
       goal: request.goal,
-      input: prepared.truncated,
+      input: heuristicInput,
       detail: request.detail,
       policyName: request.policyName,
       outputContract: request.policyName === "test-status" && request.goal === "diagnose" && request.format === "json" ? request.outputContract ?? TEST_STATUS_DIAGNOSE_JSON_CONTRACT : request.outputContract,
@@ -4711,6 +6404,11 @@ async function runSift(request) {
         prompt: heuristicPrompt.prompt,
         responseMode: heuristicPrompt.responseMode,
         prepared,
+        heuristicInput: {
+          length: heuristicInput.length,
+          truncatedApplied: heuristicInputTruncated,
+          strategy: "full-redacted"
+        },
         heuristicOutput,
         strategy: "heuristic"
       });
@@ -4724,6 +6422,8 @@ async function runSift(request) {
       logVerboseTestStatusTelemetry({
         request,
         prepared,
+        heuristicInputChars: heuristicInput.length,
+        heuristicInputTruncated,
         contract: testStatusDecision.contract,
         finalOutput
       });
@@ -4775,6 +6475,11 @@ async function runSift(request) {
         prompt: prompt.prompt,
         responseMode: prompt.responseMode,
         prepared: providerPrepared2,
+        heuristicInput: {
+          length: heuristicInput.length,
+          truncatedApplied: heuristicInputTruncated,
+          strategy: "full-redacted"
+        },
         heuristicOutput: testStatusHeuristicOutput,
         strategy: "hybrid"
       });
@@ -4788,10 +6493,11 @@ async function runSift(request) {
       });
       const supplement = parseTestStatusProviderSupplement(result.text);
       const mergedDecision = buildTestStatusDiagnoseContract({
-        input: prepared.truncated,
+        input: heuristicInput,
         analysis: testStatusAnalysis,
         resolvedTests: request.testStatusContext?.resolvedTests,
         remainingTests: request.testStatusContext?.remainingTests,
+        providerBucketSupplements: supplement.bucket_supplements,
         contractOverrides: {
           diagnosis_complete: supplement.diagnosis_complete,
           raw_needed: supplement.raw_needed,
@@ -4813,6 +6519,8 @@ async function runSift(request) {
       logVerboseTestStatusTelemetry({
         request,
         prepared,
+        heuristicInputChars: heuristicInput.length,
+        heuristicInputTruncated,
         contract: mergedDecision.contract,
         finalOutput,
         rawSliceChars: rawSlice.text.length,
@@ -4825,7 +6533,7 @@ async function runSift(request) {
       const failureDecision = buildTestStatusProviderFailureDecision({
         request,
         baseDecision: testStatusDecision,
-        input: prepared.truncated,
+        input: heuristicInput,
         analysis: testStatusAnalysis,
         reason,
         rawSliceUsed: rawSlice.used,
@@ -4846,6 +6554,8 @@ async function runSift(request) {
       logVerboseTestStatusTelemetry({
         request,
         prepared,
+        heuristicInputChars: heuristicInput.length,
+        heuristicInputTruncated,
         contract: failureDecision.contract,
         finalOutput,
         rawSliceChars: rawSlice.text.length,
@@ -4884,6 +6594,11 @@ async function runSift(request) {
       prompt: providerPrompt.prompt,
       responseMode: providerPrompt.responseMode,
       prepared: providerPrepared,
+      heuristicInput: {
+        length: heuristicInput.length,
+        truncatedApplied: heuristicInputTruncated,
+        strategy: "full-redacted"
+      },
       heuristicOutput: testStatusDecision ? testStatusHeuristicOutput : null,
       strategy: testStatusDecision ? "hybrid" : "provider"
     });
@@ -4925,16 +6640,35 @@ async function runSift(request) {
 
 // src/core/testStatusState.ts
 import fs5 from "fs";
-import path6 from "path";
+import path7 from "path";
 import { z as z3 } from "zod";
 var detailSchema = z3.enum(["standard", "focused", "verbose"]);
 var failureBucketTypeSchema = z3.enum([
   "shared_environment_blocker",
   "fixture_guard_failure",
+  "timeout_failure",
+  "permission_denied_failure",
+  "async_event_loop_failure",
+  "fixture_teardown_failure",
+  "db_migration_failure",
+  "configuration_error",
+  "xdist_worker_crash",
+  "type_error_failure",
+  "resource_leak_warning",
+  "django_db_access_denied",
+  "network_failure",
+  "subprocess_crash_segfault",
+  "flaky_test_detected",
+  "serialization_encoding_failure",
+  "file_not_found_failure",
+  "memory_error",
+  "deprecation_warning_as_error",
+  "xfail_strict_unexpected_pass",
   "service_unavailable",
   "db_connection_failure",
   "auth_bypass_absent",
   "contract_snapshot_drift",
+  "snapshot_mismatch",
   "import_dependency_failure",
   "collection_failure",
   "assertion_failure",
@@ -5036,7 +6770,7 @@ function buildBucketSignature(bucket) {
   ]);
 }
 function basenameMatches(value, matcher) {
-  return matcher.test(path6.basename(value));
+  return matcher.test(path7.basename(value));
 }
 function isPytestExecutable(value) {
   return basenameMatches(value, /^pytest(?:\.exe)?$/i);
@@ -5230,7 +6964,7 @@ function tryReadCachedTestStatusRun(statePath = getDefaultTestStatusStatePath())
   }
 }
 function writeCachedTestStatusRun(state, statePath = getDefaultTestStatusStatePath()) {
-  fs5.mkdirSync(path6.dirname(statePath), {
+  fs5.mkdirSync(path7.dirname(statePath), {
     recursive: true
   });
   fs5.writeFileSync(statePath, `${JSON.stringify(state, null, 2)}
@@ -6039,6 +7773,7 @@ var defaultCliDeps = {
   configInit,
   configSetup,
   configShow,
+  configUse,
   configValidate,
   runDoctor,
   listPresets,
@@ -6143,9 +7878,12 @@ function shouldKeepPresetPolicy(args) {
   return args.requestedFormat === void 0 || args.requestedFormat === args.presetFormat;
 }
 function applySharedOptions(command) {
-  return command.option("--provider <provider>", "Provider: openai | openai-compatible").option("--model <model>", "Model name").option("--base-url <url>", "Provider base URL").option(
+  return command.option(
+    "--provider <provider>",
+    "Provider: openai | openai-compatible | openrouter"
+  ).option("--model <model>", "Model name").option("--base-url <url>", "Provider base URL").option(
     "--api-key <key>",
-    "Provider API key (or set OPENAI_API_KEY for provider=openai; use SIFT_PROVIDER_API_KEY or endpoint-native envs for openai-compatible)"
+    "Provider API key (or set OPENAI_API_KEY for provider=openai, OPENROUTER_API_KEY for provider=openrouter; use SIFT_PROVIDER_API_KEY or endpoint-native envs for openai-compatible)"
   ).option(
     "--json-response-format <mode>",
     "JSON response format mode: auto | on | off"
@@ -6690,10 +8428,10 @@ function createCliApp(args = {}) {
     }
     throw new Error(`Unknown agent action: ${action}`);
   });
-  cli.command("config <action>", "Config commands: setup | init | show | validate").usage("config <setup|init|show|validate> [options]").example("config setup").example("config setup --global").example("config setup --path ~/.config/sift/config.yaml").example("config init").example("config init --global").example("config show").example("config validate --config ./sift.config.yaml").option("--path <path>", "Target config path for init or setup").option(
+  cli.command("config <action> [provider]", "Config commands: setup | init | show | validate | use").usage("config <setup|init|show|validate|use> [provider] [options]").example("config setup").example("config setup --global").example("config setup --path ~/.config/sift/config.yaml").example("config init").example("config init --global").example("config use openrouter").example("config show").example("config validate --config ./sift.config.yaml").option("--path <path>", "Target config path for init or setup").option(
     "--global",
     "Use the machine-wide config path (~/.config/sift/config.yaml) for init or setup"
-  ).option("--config <path>", "Path to config file").option("--show-secrets", "Show secret values in config show").action(async (action, options) => {
+  ).option("--config <path>", "Path to config file").option("--show-secrets", "Show secret values in config show").action(async (action, provider, options) => {
     if (action === "setup") {
       process.exitCode = await deps.configSetup({
         targetPath: options.path,
@@ -6716,6 +8454,13 @@ function createCliApp(args = {}) {
       deps.configValidate(options.config);
       return;
     }
+    if (action === "use") {
+      if (!provider) {
+        throw new Error("Missing provider name.");
+      }
+      deps.configUse(provider, options.config, env);
+      return;
+    }
     throw new Error(`Unknown config action: ${action}`);
   });
   cli.command("doctor", "Check which config is active and whether local setup looks complete").usage("doctor [options]").option("--config <path>", "Path to config file").action((options) => {