@bilalimamoglu/sift 0.2.2 → 0.2.3

package/dist/cli.js

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 
-// src/cli.ts
+// src/cli-app.ts
 import { createRequire } from "module";
 import { cac } from "cac";
 
@@ -375,18 +375,211 @@ function writeConfigFile(options) {
   return resolved;
 }
 
+// src/ui/presentation.ts
+import pc from "picocolors";
+function applyColor(enabled, formatter, value) {
+  return enabled ? formatter(value) : value;
+}
+function createPresentation(useColor) {
+  return {
+    useColor,
+    banner(_version) {
+      const mark = [
+        "    \\\\  //",
+        "     \\\\//",
+        "     |  |",
+        "      o"
+      ].map((line) => applyColor(useColor, pc.cyan, line)).join("\n");
+      const tagline = applyColor(useColor, pc.dim, "Trim the noise. Keep the signal.");
+      return `${mark}
+${tagline}`;
+    },
+    welcome(text) {
+      return useColor ? `${pc.bold(pc.cyan("Welcome to sift."))} ${text}` : `Welcome to sift. ${text}`;
+    },
+    success(text) {
+      return useColor ? `${pc.green("\u2713")} ${text}` : text;
+    },
+    warning(text) {
+      return useColor ? `${pc.yellow("!")} ${text}` : text;
+    },
+    error(text) {
+      return useColor ? `${pc.red("x")} ${text}` : text;
+    },
+    info(text) {
+      return useColor ? `${pc.cyan("\u2022")} ${text}` : text;
+    },
+    note(text) {
+      return applyColor(useColor, pc.dim, text);
+    },
+    section(text) {
+      return applyColor(useColor, (value) => pc.bold(pc.yellow(value)), text);
+    },
+    labelValue(label, value) {
+      return `${applyColor(useColor, (entry) => pc.bold(pc.cyan(entry)), label)}: ${value}`;
+    },
+    command(text) {
+      return applyColor(useColor, (value) => pc.bold(pc.cyan(value)), text);
+    }
+  };
+}
+
 // src/commands/config-setup.ts
 import fs3 from "fs";
 import path4 from "path";
+import { emitKeypressEvents } from "readline";
 import { createInterface } from "readline/promises";
-import { clearLine, cursorTo, emitKeypressEvents, moveCursor } from "readline";
-import { stdin as defaultStdin, stdout as defaultStdout, stderr as defaultStderr } from "process";
+import { stderr as defaultStderr, stdin as defaultStdin2, stdout as defaultStdout } from "process";
+
+// src/ui/terminal.ts
+import { execFileSync } from "child_process";
+import { clearScreenDown, cursorTo, moveCursor } from "readline";
+import { stdin as defaultStdin } from "process";
+function setPosixEcho(enabled) {
+  const command = enabled ? "echo" : "-echo";
+  try {
+    execFileSync("sh", ["-c", `stty ${command} < /dev/tty`], {
+      stdio: ["inherit", "inherit", "ignore"]
+    });
+    return;
+  } catch {
+  }
+  try {
+    execFileSync("stty", [command], {
+      stdio: ["inherit", "inherit", "ignore"]
+    });
+  } catch {
+  }
+}
+function renderSelectionBlock(args) {
+  return [
+    `${args.prompt} (use \u2191/\u2193 and Enter)`,
+    ...args.options.map(
+      (option, index) => `${index === args.selectedIndex ? "\u203A" : " "} ${option}${index === args.selectedIndex ? " (selected)" : ""}`
+    )
+  ];
+}
+async function promptSelect(args) {
+  const { input, output, prompt, options } = args;
+  const stream = output;
+  const selectedLabel = args.selectedLabel ?? prompt;
+  let index = 0;
+  let previousLineCount = 0;
+  const render = () => {
+    if (previousLineCount > 0) {
+      moveCursor(stream, 0, -previousLineCount);
+      cursorTo(stream, 0);
+      clearScreenDown(stream);
+    }
+    const lines = renderSelectionBlock({
+      prompt,
+      options,
+      selectedIndex: index
+    });
+    output.write(`${lines.join("\n")}
+`);
+    previousLineCount = lines.length;
+  };
+  const cleanup = (selected) => {
+    if (previousLineCount > 0) {
+      moveCursor(stream, 0, -previousLineCount);
+      cursorTo(stream, 0);
+      clearScreenDown(stream);
+    }
+    if (selected) {
+      output.write(`${selectedLabel}: ${selected}
+`);
+    }
+  };
+  input.resume();
+  const wasRaw = Boolean(input.isRaw);
+  input.setRawMode?.(true);
+  render();
+  return await new Promise((resolve, reject) => {
+    const onKeypress = (_value, key) => {
+      if (key.ctrl && key.name === "c") {
+        input.off("keypress", onKeypress);
+        cleanup();
+        input.setRawMode?.(wasRaw);
+        input.pause?.();
+        reject(new Error("Aborted."));
+        return;
+      }
+      if (key.name === "up") {
+        index = index === 0 ? options.length - 1 : index - 1;
+        render();
+        return;
+      }
+      if (key.name === "down") {
+        index = (index + 1) % options.length;
+        render();
+        return;
+      }
+      if (key.name === "return" || key.name === "enter") {
+        const selected = options[index] ?? options[0] ?? "";
+        input.off("keypress", onKeypress);
+        cleanup(selected);
+        input.setRawMode?.(wasRaw);
+        input.pause?.();
+        resolve(selected);
+      }
+    };
+    input.on("keypress", onKeypress);
+  });
+}
+async function promptSecret(args) {
+  const { input, output, prompt } = args;
+  let value = "";
+  const shouldToggleEcho = process.platform !== "win32" && input === defaultStdin && Boolean(defaultStdin.isTTY);
+  output.write(prompt);
+  input.resume();
+  const wasRaw = Boolean(input.isRaw);
+  input.setRawMode?.(true);
+  if (shouldToggleEcho) {
+    setPosixEcho(false);
+  }
+  return await new Promise((resolve, reject) => {
+    const restoreInputState = () => {
+      input.setRawMode?.(wasRaw);
+      input.pause?.();
+      if (shouldToggleEcho) {
+        setPosixEcho(true);
+      }
+    };
+    const onKeypress = (chunk, key) => {
+      if (key.ctrl && key.name === "c") {
+        input.off("keypress", onKeypress);
+        restoreInputState();
+        output.write("\n");
+        reject(new Error("Aborted."));
+        return;
+      }
+      if (key.name === "return" || key.name === "enter") {
+        input.off("keypress", onKeypress);
+        restoreInputState();
+        output.write("\n");
+        resolve(value);
+        return;
+      }
+      if (key.name === "backspace" || key.name === "delete") {
+        value = value.slice(0, -1);
+        return;
+      }
+      if (!key.ctrl && chunk.length > 0) {
+        value += chunk;
+      }
+    };
+    input.on("keypress", onKeypress);
+  });
+}
+
+// src/commands/config-setup.ts
 function createTerminalIO() {
   let rl;
   function getInterface() {
     if (!rl) {
       rl = createInterface({
-        input: defaultStdin,
+        input: defaultStdin2,
         output: defaultStdout,
         terminal: true
       });
@@ -394,69 +587,31 @@ function createTerminalIO() {
     return rl;
   }
   async function select(prompt, options) {
-    const input = defaultStdin;
-    const output = defaultStdout;
-    const promptLine = `${prompt} (use \u2191/\u2193 and Enter)`;
-    let index = 0;
-    const lineCount = options.length + 1;
-    emitKeypressEvents(input);
-    input.resume();
-    const wasRaw = input.isTTY ? input.isRaw : false;
-    input.setRawMode?.(true);
-    const render = () => {
-      cursorTo(output, 0);
-      clearLine(output, 0);
-      output.write(`${promptLine}
-`);
-      for (let optionIndex = 0; optionIndex < options.length; optionIndex += 1) {
-        clearLine(output, 0);
-        output.write(`${optionIndex === index ? "\u203A" : " "} ${options[optionIndex]}
-`);
-      }
-      moveCursor(output, 0, -lineCount);
-    };
-    render();
-    return await new Promise((resolve, reject) => {
-      const onKeypress = (_value, key) => {
-        if (key.ctrl && key.name === "c") {
-          cleanup();
-          reject(new Error("Aborted."));
-          return;
-        }
-        if (key.name === "up") {
-          index = index === 0 ? options.length - 1 : index - 1;
-          render();
-          return;
-        }
-        if (key.name === "down") {
-          index = (index + 1) % options.length;
-          render();
-          return;
-        }
-        if (key.name === "return" || key.name === "enter") {
-          const selected = options[index] ?? options[0];
-          cleanup();
-          resolve(selected ?? "OpenAI");
-        }
-      };
-      const cleanup = () => {
-        input.off("keypress", onKeypress);
-        moveCursor(output, 0, lineCount);
-        cursorTo(output, 0);
-        clearLine(output, 0);
-        output.write("\n");
-        input.setRawMode?.(Boolean(wasRaw));
-      };
-      input.on("keypress", onKeypress);
+    emitKeypressEvents(defaultStdin2);
+    return await promptSelect({
+      input: defaultStdin2,
+      output: defaultStdout,
+      prompt,
+      options,
+      selectedLabel: "Provider"
+    });
+  }
+  async function secret(prompt) {
+    emitKeypressEvents(defaultStdin2);
+    return await promptSecret({
+      input: defaultStdin2,
+      output: defaultStdout,
+      prompt
     });
   }
   return {
-    stdinIsTTY: Boolean(defaultStdin.isTTY),
+    stdinIsTTY: Boolean(defaultStdin2.isTTY),
     stdoutIsTTY: Boolean(defaultStdout.isTTY),
     ask(prompt) {
       return getInterface().question(prompt);
     },
     select,
+    secret,
     write(message) {
       defaultStdout.write(message);
     },
@@ -483,9 +638,12 @@ function buildOpenAISetupConfig(apiKey) {
     }
   };
 }
+function getSetupPresenter(io) {
+  return createPresentation(io.stdoutIsTTY);
+}
 async function promptForProvider(io) {
   if (io.select) {
-    const choice = await io.select("Select provider", ["OpenAI"]);
+    const choice = await io.select("Select provider for this machine", ["OpenAI"]);
     if (choice === "OpenAI") {
       return "openai";
     }
@@ -500,7 +658,7 @@ async function promptForProvider(io) {
 }
 async function promptForApiKey(io) {
   while (true) {
-    const answer = (await io.ask("Enter your OpenAI API key: ")).trim();
+    const answer = (await (io.secret ? io.secret("Enter your OpenAI API key (input hidden): ") : io.ask("Enter your OpenAI API key: "))).trim();
     if (answer.length > 0) {
       return answer;
     }
@@ -521,9 +679,41 @@ async function promptForOverwrite(io, targetPath) {
     io.error("Please answer y or n.\n");
   }
 }
+function writeSetupSuccess(io, writtenPath) {
+  const ui = getSetupPresenter(io);
+  io.write(`
+${ui.success("You're set.")}
+`);
+  io.write(`${ui.info(`Machine-wide config: ${writtenPath}`)}
+`);
+  io.write(`${ui.note("sift is ready to use from any terminal on this machine.")}
+`);
+  io.write(
+    `${ui.note("A repo-local sift.config.yaml can still override it when a project needs its own settings.")}
+`
+  );
+}
+function writeOverrideWarning(io, activeConfigPath) {
+  const ui = getSetupPresenter(io);
+  io.write(
+    `${ui.warning(`Heads-up: ${activeConfigPath} currently overrides this machine-wide config in this directory.`)}
+`
+  );
+}
+function writeNextSteps(io) {
+  const ui = getSetupPresenter(io);
+  io.write(`
+${ui.section("Try next")}
+`);
+  io.write(`  ${ui.command("sift doctor")}
+`);
+  io.write(`  ${ui.command("sift exec --preset test-status -- pytest")}
+`);
+}
 async function configSetup(options = {}) {
   void options.global;
   const io = options.io ?? createTerminalIO();
+  const ui = getSetupPresenter(io);
   try {
     if (!io.stdinIsTTY || !io.stdoutIsTTY) {
       io.error(
@@ -531,24 +721,31 @@ async function configSetup(options = {}) {
       );
       return 1;
     }
+    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("Aborted.\n");
+        io.write(`${ui.note("Aborted.")}
+`);
         return 1;
       }
     }
-    const provider = await promptForProvider(io);
-    if (provider !== "openai") {
-      io.error("Unsupported provider selection.\n");
-      return 1;
-    }
-    io.write("Using OpenAI defaults.\n");
-    io.write("Default model: gpt-5-nano\n");
-    io.write("Default base URL: https://api.openai.com/v1\n");
+    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(
-      "You can change these later by editing the config file or running 'sift config show --show-secrets'.\n"
+      `${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);
@@ -557,21 +754,12 @@ async function configSetup(options = {}) {
       config,
       overwrite: true
     });
-    io.write(`Wrote ${writtenPath}
-`);
-    io.write(
-      "This is your machine-wide default config. Repo-local sift.config.yaml can still override it later.\n"
-    );
+    writeSetupSuccess(io, writtenPath);
     const activeConfigPath = findConfigPath();
     if (activeConfigPath && path4.resolve(activeConfigPath) !== path4.resolve(writtenPath)) {
-      io.write(
-        `Note: ${activeConfigPath} currently overrides this machine-wide config in the current directory.
-`
-      );
+      writeOverrideWarning(io, activeConfigPath);
     }
-    io.write("Try:\n");
-    io.write("  sift doctor\n");
-    io.write("  sift exec --preset test-status -- pytest\n");
+    writeNextSteps(io);
     return 0;
   } finally {
     io.close?.();
@@ -602,8 +790,16 @@ function configInit(targetPath, global = false) {
     targetPath,
     global
   });
-  process.stdout.write(`${path5}
+  if (!process.stdout.isTTY) {
+    process.stdout.write(`${path5}
 `);
+    return;
+  }
+  const ui = createPresentation(true);
+  process.stdout.write(
+    `${ui.success(`${global ? "Machine-wide" : "Template"} config written to ${path5}`)}
+`
+  );
 }
 function configShow(configPath, showSecrets = false) {
   const config = resolveConfig({
@@ -620,25 +816,32 @@ function configValidate(configPath) {
     env: process.env
   });
   const resolvedPath = findConfigPath(configPath);
-  process.stdout.write(
-    `Resolved config is valid${resolvedPath ? ` (${resolvedPath})` : " (using defaults)"}.
-`
-  );
+  const message = `Resolved config is valid${resolvedPath ? ` (${resolvedPath})` : " (using defaults)"}.`;
+  if (!process.stdout.isTTY) {
+    process.stdout.write(`${message}
+`);
+    return;
+  }
+  const ui = createPresentation(true);
+  process.stdout.write(`${ui.success(message)}
+`);
 }
 
 // src/commands/doctor.ts
 function runDoctor(config, configPath) {
+  const ui = createPresentation(Boolean(process.stdout.isTTY));
   const lines = [
     "sift doctor",
+    "A quick check for your local setup.",
     "mode: local config completeness check",
-    `configPath: ${configPath ?? "(defaults only)"}`,
-    `provider: ${config.provider.provider}`,
-    `model: ${config.provider.model}`,
-    `baseUrl: ${config.provider.baseUrl}`,
-    `apiKey: ${config.provider.apiKey ? "set" : "not set"}`,
-    `maxCaptureChars: ${config.input.maxCaptureChars}`,
-    `maxInputChars: ${config.input.maxInputChars}`,
-    `rawFallback: ${config.runtime.rawFallback}`
+    ui.labelValue("configPath", configPath ?? "(defaults only)"),
+    ui.labelValue("provider", config.provider.provider),
+    ui.labelValue("model", config.provider.model),
+    ui.labelValue("baseUrl", config.provider.baseUrl),
+    ui.labelValue("apiKey", config.provider.apiKey ? "set" : "not set"),
+    ui.labelValue("maxCaptureChars", String(config.input.maxCaptureChars)),
+    ui.labelValue("maxInputChars", String(config.input.maxInputChars)),
+    ui.labelValue("rawFallback", String(config.runtime.rawFallback))
   ];
   process.stdout.write(`${lines.join("\n")}
 `);
@@ -659,8 +862,16 @@ function runDoctor(config, configPath) {
     );
   }
   if (problems.length > 0) {
-    process.stderr.write(`${problems.join("\n")}
+    if (process.stderr.isTTY) {
+      const errorUi = createPresentation(true);
+      process.stderr.write(
+        `${problems.map((problem) => errorUi.error(problem)).join("\n")}
+`
+      );
+    } else {
+      process.stderr.write(`${problems.join("\n")}
 `);
+    }
     return 1;
   }
   return 0;
@@ -689,7 +900,7 @@ function showPreset(config, name, includeInternal = false) {
 // src/core/exec.ts
 import { spawn } from "child_process";
 import { constants as osConstants } from "os";
-import pc2 from "picocolors";
+import pc3 from "picocolors";
 
 // src/core/gate.ts
 var FAIL_ON_SUPPORTED_PRESETS = /* @__PURE__ */ new Set(["infra-risk", "audit-critical"]);
@@ -738,8 +949,31 @@ function evaluateGate(args) {
   return { shouldFail: false };
 }
 
+// src/core/insufficient.ts
+function isInsufficientSignalOutput(output) {
+  const trimmed = output.trim();
+  return trimmed === INSUFFICIENT_SIGNAL_TEXT || trimmed.startsWith(`${INSUFFICIENT_SIGNAL_TEXT}
+Hint:`);
+}
+function buildInsufficientSignalOutput(input) {
+  let hint;
+  if (input.originalLength === 0) {
+    hint = "Hint: no command output was captured.";
+  } else if (input.truncatedApplied) {
+    hint = "Hint: captured output was truncated before a clear summary was found.";
+  } else if (input.presetName === "test-status" && input.exitCode === 0) {
+    hint = "Hint: command succeeded, but no recognizable test summary was found.";
+  } else if (input.presetName === "test-status" && typeof input.exitCode === "number") {
+    hint = "Hint: command failed, but the captured output did not include a recognizable test summary.";
+  } else {
+    hint = "Hint: the captured output did not contain a clear answer for this preset.";
+  }
+  return `${INSUFFICIENT_SIGNAL_TEXT}
+${hint}`;
+}
+
 // src/core/run.ts
-import pc from "picocolors";
+import pc2 from "picocolors";
 
 // src/providers/systemInstruction.ts
 var REDUCTION_SYSTEM_INSTRUCTION = "You reduce noisy command output into compact answers for agents and automation.";
@@ -815,7 +1049,7 @@ var OpenAIProvider = class {
       if (!text) {
         throw new Error("Provider returned an empty response");
       }
-      return {
+      const result = {
         text,
         usage: data?.usage ? {
           inputTokens: data.usage.input_tokens,
@@ -824,13 +1058,14 @@ var OpenAIProvider = class {
         } : void 0,
         raw: data
       };
+      clearTimeout(timeout);
+      return result;
     } catch (error) {
+      clearTimeout(timeout);
       if (error.name === "AbortError") {
         throw new Error("Provider request timed out");
       }
       throw error;
-    } finally {
-      clearTimeout(timeout);
     }
   }
 };
@@ -912,7 +1147,7 @@ var OpenAICompatibleProvider = class {
       if (!text.trim()) {
         throw new Error("Provider returned an empty response");
       }
-      return {
+      const result = {
         text,
         usage: data?.usage ? {
           inputTokens: data.usage.prompt_tokens,
@@ -921,13 +1156,14 @@ var OpenAICompatibleProvider = class {
         } : void 0,
         raw: data
       };
+      clearTimeout(timeout);
+      return result;
     } catch (error) {
+      clearTimeout(timeout);
       if (error.name === "AbortError") {
         throw new Error("Provider request timed out");
       }
       throw error;
-    } finally {
-      clearTimeout(timeout);
     }
   }
 };
@@ -1132,6 +1368,19 @@ function buildPrompt(args) {
     policyName: args.policyName,
     outputContract: args.outputContract
   });
+  const detailRules = args.policyName === "test-status" && args.detail === "focused" ? [
+    "Use a focused failure view.",
+    "When the output clearly maps failures to specific tests or modules, group them by dominant error type first.",
+    "Within each error group, prefer compact bullets in the form '- test-or-module -> dominant reason'.",
+    "Cap focused entries at 6 per error group and end with '- and N more failing modules' if more clear mappings are visible.",
+    "If per-test or per-module mapping is unclear, fall back to grouped root causes instead of guessing."
+  ] : args.policyName === "test-status" && args.detail === "verbose" ? [
+    "Use a verbose failure view.",
+    "When the output clearly maps failures to specific tests or modules, list each visible failing test or module on its own line in the form '- test-or-module -> normalized reason'.",
+    "Preserve the original file or module order when the mapping is visible.",
+    "Prefer concrete normalized reasons such as missing modules or assertion failures over traceback plumbing.",
+    "If per-test or per-module mapping is unclear, fall back to the focused grouped-cause view instead of guessing."
+  ] : [];
   const prompt = [
     "You are Sift, a CLI output reduction assistant for downstream agents and automation.",
     "Hard rules:",
@@ -1139,6 +1388,7 @@ function buildPrompt(args) {
     "",
     `Task policy: ${policy.name}`,
     ...policy.taskRules.map((rule) => `- ${rule}`),
+    ...detailRules.map((rule) => `- ${rule}`),
     ...policy.outputContract ? ["", `Output contract: ${policy.outputContract}`] : [],
     "",
     `Question: ${args.question}`,
@@ -1251,6 +1501,410 @@ function inferPackage(line) {
 function inferRemediation(pkg2) {
   return `Upgrade ${pkg2} to a patched version.`;
 }
+function getCount(input, label) {
+  const matches = [...input.matchAll(new RegExp(`(\\d+)\\s+${label}`, "gi"))];
+  const lastMatch = matches.at(-1);
+  return lastMatch ? Number(lastMatch[1]) : 0;
+}
+function formatCount(count, singular, plural = `${singular}s`) {
+  return `${count} ${count === 1 ? singular : plural}`;
+}
+function countPattern(input, matcher) {
+  return [...input.matchAll(matcher)].length;
+}
+function collectUniqueMatches(input, matcher, limit = 6) {
+  const values = [];
+  for (const match of input.matchAll(matcher)) {
+    const candidate = match[1]?.trim();
+    if (!candidate || values.includes(candidate)) {
+      continue;
+    }
+    values.push(candidate);
+    if (values.length >= limit) {
+      break;
+    }
+  }
+  return values;
+}
+function cleanFailureLabel(label) {
+  return label.trim().replace(/^['"]|['"]$/g, "");
+}
+function isLowValueInternalReason(normalized) {
+  return /^Hint:\s+make sure your test modules\/packages have valid Python names\.?$/i.test(
+    normalized
+  ) || /^Traceback\b/i.test(normalized) || /^return _bootstrap\._gcd_import/i.test(normalized) || /(?:^|[/\\])(?:site-packages[/\\])?_pytest(?:[/\\]|$)/i.test(normalized) || /(?:^|[/\\])importlib[/\\]__init__\.py:\d+:\s+in\s+import_module\b/i.test(
+    normalized
+  ) || /\bpython\.py:\d+:\s+in\s+importtestmodule\b/i.test(normalized) || /\bpython\.py:\d+:\s+in\s+import_path\b/i.test(normalized);
+}
+function scoreFailureReason(reason) {
+  if (reason.startsWith("missing module:")) {
+    return 5;
+  }
+  if (reason.startsWith("assertion failed:")) {
+    return 4;
+  }
+  if (/^[A-Z][A-Za-z]+(?:Error|Exception):/.test(reason)) {
+    return 3;
+  }
+  if (reason === "import error during collection") {
+    return 2;
+  }
+  return 1;
+}
+function classifyFailureReason(line, options) {
+  const normalized = line.trim().replace(/^[A-Z]\s+/, "");
+  if (normalized.length === 0) {
+    return null;
+  }
+  if (isLowValueInternalReason(normalized)) {
+    return null;
+  }
+  const pythonMissingModule = normalized.match(
+    /ModuleNotFoundError:\s+No module named ['"]([^'"]+)['"]/i
+  );
+  if (pythonMissingModule) {
+    return {
+      reason: `missing module: ${pythonMissingModule[1]}`,
+      group: options.duringCollection ? "import/dependency errors during collection" : "missing dependency/module errors"
+    };
+  }
+  const nodeMissingModule = normalized.match(/Cannot find module ['"]([^'"]+)['"]/i);
+  if (nodeMissingModule) {
+    return {
+      reason: `missing module: ${nodeMissingModule[1]}`,
+      group: options.duringCollection ? "import/dependency errors during collection" : "missing dependency/module errors"
+    };
+  }
+  const assertionFailure = normalized.match(/AssertionError:\s*(.+)$/i);
+  if (assertionFailure) {
+    return {
+      reason: `assertion failed: ${assertionFailure[1]}`.slice(0, 120),
+      group: "assertion failures"
+    };
+  }
+  const genericError = normalized.match(/\b([A-Z][A-Za-z]+(?:Error|Exception)):\s*(.+)$/);
+  if (genericError) {
+    const errorType = genericError[1];
+    return {
+      reason: `${errorType}: ${genericError[2]}`.slice(0, 120),
+      group: options.duringCollection && errorType === "ImportError" ? "import/dependency errors during collection" : `${errorType} failures`
+    };
+  }
+  if (/ImportError while importing test module/i.test(normalized)) {
+    return {
+      reason: "import error during collection",
+      group: "import/dependency errors during collection"
+    };
+  }
+  if (!/[A-Za-z]/.test(normalized)) {
+    return null;
+  }
+  return {
+    reason: normalized.slice(0, 120),
+    group: options.duringCollection ? "collection/import errors" : "other failures"
+  };
+}
+function pushFocusedFailureItem(items, candidate) {
+  if (items.some((item) => item.label === candidate.label && item.reason === candidate.reason)) {
+    return;
+  }
+  items.push(candidate);
+}
+function chooseStrongestFailureItems(items) {
+  const strongest = /* @__PURE__ */ new Map();
+  const order = [];
+  for (const item of items) {
+    const existing = strongest.get(item.label);
+    if (!existing) {
+      strongest.set(item.label, item);
+      order.push(item.label);
+      continue;
+    }
+    if (scoreFailureReason(item.reason) > scoreFailureReason(existing.reason)) {
+      strongest.set(item.label, item);
+    }
+  }
+  return order.map((label) => strongest.get(label));
+}
+function collectCollectionFailureItems(input) {
+  const items = [];
+  const lines = input.split("\n");
+  let currentLabel = null;
+  let pendingGenericReason = null;
+  for (const line of lines) {
+    const collecting = line.match(/^_+\s+ERROR collecting\s+(.+?)\s+_+\s*$/);
+    if (collecting) {
+      if (currentLabel && pendingGenericReason) {
+        pushFocusedFailureItem(
+          items,
+          {
+            label: currentLabel,
+            reason: pendingGenericReason.reason,
+            group: pendingGenericReason.group
+          }
+        );
+      }
+      currentLabel = cleanFailureLabel(collecting[1]);
+      pendingGenericReason = null;
+      continue;
+    }
+    if (!currentLabel) {
+      continue;
+    }
+    const classification = classifyFailureReason(line, {
+      duringCollection: true
+    });
+    if (!classification) {
+      continue;
+    }
+    if (classification.reason === "import error during collection") {
+      pendingGenericReason = classification;
+      continue;
+    }
+    pushFocusedFailureItem(
+      items,
+      {
+        label: currentLabel,
+        reason: classification.reason,
+        group: classification.group
+      }
+    );
+    currentLabel = null;
+    pendingGenericReason = null;
+  }
+  if (currentLabel && pendingGenericReason) {
+    pushFocusedFailureItem(
+      items,
+      {
+        label: currentLabel,
+        reason: pendingGenericReason.reason,
+        group: pendingGenericReason.group
+      }
+    );
+  }
+  return items;
+}
+function collectInlineFailureItems(input) {
+  const items = [];
+  for (const line of input.split("\n")) {
+    const inlineFailure = line.match(/^(FAILED|ERROR)\s+(.+?)\s+-\s+(.+)$/);
+    if (!inlineFailure) {
+      continue;
+    }
+    const classification = classifyFailureReason(inlineFailure[3], {
+      duringCollection: false
+    });
+    if (!classification) {
+      continue;
+    }
+    pushFocusedFailureItem(
+      items,
+      {
+        label: cleanFailureLabel(inlineFailure[2]),
+        reason: classification.reason,
+        group: classification.group
+      }
+    );
+  }
+  return items;
+}
+function formatFocusedFailureGroups(args) {
+  const maxGroups = args.maxGroups ?? 3;
+  const maxPerGroup = args.maxPerGroup ?? 6;
+  const grouped = /* @__PURE__ */ new Map();
+  for (const item of args.items) {
+    const entries = grouped.get(item.group) ?? [];
+    entries.push(item);
+    grouped.set(item.group, entries);
+  }
+  const lines = [];
+  const visibleGroups = [...grouped.entries()].slice(0, maxGroups);
+  for (const [group, entries] of visibleGroups) {
+    lines.push(`- ${group}`);
+    for (const item of entries.slice(0, maxPerGroup)) {
+      lines.push(`  - ${item.label} -> ${item.reason}`);
+    }
+    const remaining = entries.length - Math.min(entries.length, maxPerGroup);
+    if (remaining > 0) {
+      lines.push(`  - and ${remaining} more failing ${args.remainderLabel}`);
+    }
+  }
+  const hiddenGroups = grouped.size - visibleGroups.length;
+  if (hiddenGroups > 0) {
+    lines.push(`- and ${hiddenGroups} more error group${hiddenGroups === 1 ? "" : "s"}`);
+  }
+  return lines;
+}
+function formatVerboseFailureItems(args) {
+  return chooseStrongestFailureItems(args.items).map(
+    (item) => `- ${item.label} -> ${item.reason}`
+  );
+}
+function summarizeRepeatedTestCauses(input, options) {
+  const pythonMissingModules = collectUniqueMatches(
+    input,
+    /ModuleNotFoundError:\s+No module named ['"]([^'"]+)['"]/gi
+  );
+  const nodeMissingModules = collectUniqueMatches(
+    input,
+    /Cannot find module ['"]([^'"]+)['"]/gi
+  );
+  const missingModules = [...pythonMissingModules];
+  for (const moduleName of nodeMissingModules) {
+    if (!missingModules.includes(moduleName)) {
+      missingModules.push(moduleName);
+    }
+  }
+  const missingModuleHits = countPattern(
+    input,
+    /ModuleNotFoundError:\s+No module named ['"]([^'"]+)['"]/gi
+  ) + countPattern(input, /Cannot find module ['"]([^'"]+)['"]/gi);
+  const importCollectionHits = countPattern(input, /ImportError while importing test module/gi) + countPattern(input, /^\s*_+\s+ERROR collecting\b/gim);
+  const genericErrorTypes = collectUniqueMatches(
+    input,
+    /\b((?:Assertion|Import|Type|Value|Runtime|Reference|Key|Attribute)[A-Za-z]*Error)\b/gi,
+    4
+  );
+  const bullets = [];
+  if (options.duringCollection && (importCollectionHits >= 2 || missingModuleHits >= 2) || !options.duringCollection && missingModuleHits >= 2) {
+    bullets.push(
+      options.duringCollection ? "- Most failures are import/dependency errors during test collection." : "- Most failures are import/dependency errors."
+    );
+  }
+  if (missingModules.length > 1) {
+    bullets.push(`- Missing modules include ${missingModules.join(", ")}.`);
+  } else if (missingModules.length === 1 && missingModuleHits >= 2) {
+    bullets.push(`- Missing module repeated across failures: ${missingModules[0]}.`);
+  }
+  if (bullets.length < 2 && genericErrorTypes.length >= 2) {
+    bullets.push(`- Repeated error types include ${genericErrorTypes.join(", ")}.`);
+  }
+  return bullets.slice(0, 2);
+}
+function testStatusHeuristic(input, detail = "standard") {
+  const normalized = input.trim();
+  if (normalized === "") {
+    return null;
+  }
+  const passed = getCount(input, "passed");
+  const failed = getCount(input, "failed");
+  const errors = Math.max(
+    getCount(input, "errors"),
+    getCount(input, "error")
+  );
+  const skipped = getCount(input, "skipped");
+  const collectionErrors = input.match(/(\d+)\s+errors?\s+during collection/i);
+  const noTestsCollected = /\bcollected\s+0\s+items\b/i.test(input) || /\bno tests ran\b/i.test(input);
+  const interrupted = /\binterrupted\b/i.test(input) || /\bKeyboardInterrupt\b/i.test(input);
+  const inlineItems = collectInlineFailureItems(input);
+  if (collectionErrors) {
+    const count = Number(collectionErrors[1]);
+    const items = chooseStrongestFailureItems(collectCollectionFailureItems(input));
+    if (detail === "verbose") {
+      if (items.length > 0) {
+        return [
+          "- Tests did not complete.",
+          `- ${formatCount(count, "error")} occurred during collection.`,
+          ...formatVerboseFailureItems({
+            items
+          })
+        ].join("\n");
+      }
+    }
+    if (detail === "focused") {
+      if (items.length > 0) {
+        const groupedLines = formatFocusedFailureGroups({
+          items,
+          remainderLabel: "modules"
+        });
+        if (groupedLines.length > 0) {
+          return [
+            "- Tests did not complete.",
+            `- ${formatCount(count, "error")} occurred during collection.`,
+            ...groupedLines
+          ].join("\n");
+        }
+      }
+    }
+    const causes = summarizeRepeatedTestCauses(input, {
+      duringCollection: true
+    });
+    return [
+      "- Tests did not complete.",
+      `- ${formatCount(count, "error")} occurred during collection.`,
+      ...causes
+    ].join("\n");
+  }
+  if (noTestsCollected) {
+    return ["- Tests did not run.", "- Collected 0 items."].join("\n");
+  }
+  if (interrupted && failed === 0 && errors === 0) {
+    return "- Test run was interrupted.";
+  }
+  if (failed === 0 && errors === 0 && passed > 0) {
+    const details = [formatCount(passed, "test")];
+    if (skipped > 0) {
+      details.push(formatCount(skipped, "skip"));
+    }
+    return [
+      "- Tests passed.",
+      `- ${details.join(", ")}.`
+    ].join("\n");
+  }
+  if (failed > 0 || errors > 0 || inlineItems.length > 0) {
+    const summarizedInlineItems = chooseStrongestFailureItems(inlineItems);
+    if (detail === "verbose") {
+      if (summarizedInlineItems.length > 0) {
+        const detailLines2 = [];
+        if (failed > 0) {
+          detailLines2.push(`- ${formatCount(failed, "test")} failed.`);
+        }
+        if (errors > 0) {
+          detailLines2.push(`- ${formatCount(errors, "error")} occurred.`);
+        }
+        return [
+          "- Tests did not pass.",
+          ...detailLines2,
+          ...formatVerboseFailureItems({
+            items: summarizedInlineItems
+          })
+        ].join("\n");
+      }
+    }
+    if (detail === "focused") {
+      if (summarizedInlineItems.length > 0) {
+        const detailLines2 = [];
+        if (failed > 0) {
+          detailLines2.push(`- ${formatCount(failed, "test")} failed.`);
+        }
+        if (errors > 0) {
+          detailLines2.push(`- ${formatCount(errors, "error")} occurred.`);
+        }
+        return [
+          "- Tests did not pass.",
+          ...detailLines2,
+          ...formatFocusedFailureGroups({
+            items: summarizedInlineItems,
+            remainderLabel: "tests or modules"
+          })
+        ].join("\n");
+      }
+    }
+    const detailLines = [];
+    const causes = summarizeRepeatedTestCauses(input, {
+      duringCollection: false
+    });
+    if (failed > 0) {
+      detailLines.push(`- ${formatCount(failed, "test")} failed.`);
+    }
+    if (errors > 0) {
+      detailLines.push(`- ${formatCount(errors, "error")} occurred.`);
+    }
+    const evidence = input.split("\n").map((line) => line.trim()).filter((line) => /\b(FAILED|ERROR)\b/.test(line)).slice(0, 3).map((line) => `- ${line}`);
+    return ["- Tests did not pass.", ...detailLines, ...causes, ...evidence].join("\n");
+  }
+  return null;
+}
 function auditCriticalHeuristic(input) {
   const vulnerabilities = input.split("\n").map((line) => line.trim()).filter(Boolean).map((line) => {
     if (!/\b(critical|high)\b/i.test(line)) {
@@ -1321,7 +1975,7 @@ function infraRiskHeuristic(input) {
   }
   return null;
 }
-function applyHeuristicPolicy(policyName, input) {
+function applyHeuristicPolicy(policyName, input, detail) {
   if (!policyName) {
     return null;
   }
@@ -1331,6 +1985,9 @@ function applyHeuristicPolicy(policyName, input) {
   if (policyName === "infra-risk") {
     return infraRiskHeuristic(input);
   }
+  if (policyName === "test-status") {
+    return testStatusHeuristic(input, detail);
+  }
   return null;
 }
 
@@ -1460,6 +2117,7 @@ function buildDryRunOutput(args) {
       },
       question: args.request.question,
       format: args.request.format,
+      detail: args.request.detail ?? null,
       responseMode: args.responseMode,
       policy: args.request.policyName ?? null,
       heuristicOutput: args.heuristicOutput ?? null,
@@ -1479,35 +2137,42 @@ function buildDryRunOutput(args) {
 async function delay(ms) {
   await new Promise((resolve) => setTimeout(resolve, ms));
 }
+function withInsufficientHint(args) {
+  if (!isInsufficientSignalOutput(args.output)) {
+    return args.output;
+  }
+  return buildInsufficientSignalOutput({
+    presetName: args.request.presetName,
+    originalLength: args.prepared.meta.originalLength,
+    truncatedApplied: args.prepared.meta.truncatedApplied
+  });
+}
 async function generateWithRetry(args) {
-  let lastError;
-  for (let attempt = 0; attempt < 2; attempt += 1) {
-    try {
-      return await args.provider.generate({
-        model: args.request.config.provider.model,
-        prompt: args.prompt,
-        temperature: args.request.config.provider.temperature,
-        maxOutputTokens: args.request.config.provider.maxOutputTokens,
-        timeoutMs: args.request.config.provider.timeoutMs,
-        responseMode: args.responseMode,
-        jsonResponseFormat: args.request.config.provider.jsonResponseFormat
-      });
-    } catch (error) {
-      lastError = error;
-      const reason = error instanceof Error ? error.message : "unknown_error";
-      if (attempt > 0 || !isRetriableReason(reason)) {
-        throw error;
-      }
-      if (args.request.config.runtime.verbose) {
-        process.stderr.write(
-          `${pc.dim("sift")} retry=1 reason=${reason} delay_ms=${RETRY_DELAY_MS}
+  const generate = () => args.provider.generate({
+    model: args.request.config.provider.model,
+    prompt: args.prompt,
+    temperature: args.request.config.provider.temperature,
+    maxOutputTokens: args.request.config.provider.maxOutputTokens,
+    timeoutMs: args.request.config.provider.timeoutMs,
+    responseMode: args.responseMode,
+    jsonResponseFormat: args.request.config.provider.jsonResponseFormat
+  });
+  try {
+    return await generate();
+  } catch (error) {
+    const reason = error instanceof Error ? error.message : "unknown_error";
+    if (!isRetriableReason(reason)) {
+      throw error;
+    }
+    if (args.request.config.runtime.verbose) {
+      process.stderr.write(
+        `${pc2.dim("sift")} retry=1 reason=${reason} delay_ms=${RETRY_DELAY_MS}
 `
-        );
-      }
-      await delay(RETRY_DELAY_MS);
+      );
     }
+    await delay(RETRY_DELAY_MS);
   }
-  throw lastError instanceof Error ? lastError : new Error("unknown_error");
+  return generate();
 }
 async function runSift(request) {
   const prepared = prepareInput(request.stdin, request.config.input);
@@ -1515,23 +2180,25 @@ async function runSift(request) {
     question: request.question,
     format: request.format,
     input: prepared.truncated,
+    detail: request.detail,
     policyName: request.policyName,
     outputContract: request.outputContract
   });
   const provider = createProvider(request.config);
   if (request.config.runtime.verbose) {
     process.stderr.write(
-      `${pc.dim("sift")} provider=${provider.name} model=${request.config.provider.model} base_url=${request.config.provider.baseUrl} input_chars=${prepared.meta.finalLength}
+      `${pc2.dim("sift")} provider=${provider.name} model=${request.config.provider.model} base_url=${request.config.provider.baseUrl} input_chars=${prepared.meta.finalLength}
 `
     );
   }
   const heuristicOutput = applyHeuristicPolicy(
     request.policyName,
-    prepared.truncated
+    prepared.truncated,
+    request.detail
   );
   if (heuristicOutput) {
     if (request.config.runtime.verbose) {
-      process.stderr.write(`${pc.dim("sift")} heuristic=${request.policyName}
+      process.stderr.write(`${pc2.dim("sift")} heuristic=${request.policyName}
 `);
     }
     if (request.dryRun) {
@@ -1544,7 +2211,11 @@ async function runSift(request) {
         heuristicOutput
       });
     }
-    return heuristicOutput;
+    return withInsufficientHint({
+      output: heuristicOutput,
+      request,
+      prepared
+    });
   }
   if (request.dryRun) {
     return buildDryRunOutput({
@@ -1570,15 +2241,23 @@ async function runSift(request) {
     })) {
       throw new Error("Model output rejected by quality gate");
     }
-    return normalizeOutput(result.text, responseMode);
+    return withInsufficientHint({
+      output: normalizeOutput(result.text, responseMode),
+      request,
+      prepared
+    });
   } catch (error) {
     const reason = error instanceof Error ? error.message : "unknown_error";
-    return buildFallbackOutput({
-      format: request.format,
-      reason,
-      rawInput: prepared.truncated,
-      rawFallback: request.config.runtime.rawFallback,
-      jsonFallback: request.fallbackJson
+    return withInsufficientHint({
+      output: buildFallbackOutput({
+        format: request.format,
+        reason,
+        rawInput: prepared.truncated,
+        rawFallback: request.config.runtime.rawFallback,
+        jsonFallback: request.fallbackJson
+      }),
+      request,
+      prepared
     });
   }
 }
@@ -1679,7 +2358,7 @@ async function runExec(request) {
   const shellPath = process.env.SHELL || "/bin/bash";
   if (request.config.runtime.verbose) {
     process.stderr.write(
-      `${pc2.dim("sift")} exec mode=${hasShellCommand ? "shell" : "argv"} command=${buildCommandPreview(request)}
+      `${pc3.dim("sift")} exec mode=${hasShellCommand ? "shell" : "argv"} command=${buildCommandPreview(request)}
 `
     );
   }
@@ -1688,7 +2367,6 @@ async function runExec(request) {
   let bypassed = false;
   let childStatus = null;
   let childSignal = null;
-  let childSpawnError = null;
   const child = hasShellCommand ? spawn(shellPath, ["-lc", request.shellCommand], {
     stdio: ["inherit", "pipe", "pipe"]
   }) : spawn(request.command[0], request.command.slice(1), {
@@ -1707,7 +2385,7 @@ async function runExec(request) {
     }
     bypassed = true;
     if (request.config.runtime.verbose) {
-      process.stderr.write(`${pc2.dim("sift")} bypass=interactive-prompt
+      process.stderr.write(`${pc3.dim("sift")} bypass=interactive-prompt
 `);
     }
     process.stderr.write(capture.render());
@@ -1716,7 +2394,6 @@ async function runExec(request) {
   child.stderr.on("data", handleChunk);
   await new Promise((resolve, reject) => {
     child.on("error", (error) => {
-      childSpawnError = error;
       reject(error);
     });
     child.on("close", (status, signal) => {
@@ -1730,18 +2407,21 @@ async function runExec(request) {
     }
     throw new Error("Failed to start child process.");
   });
-  if (childSpawnError) {
-    throw childSpawnError;
-  }
   const exitCode = normalizeChildExitCode(childStatus, childSignal);
   const capturedOutput = capture.render();
   if (request.config.runtime.verbose) {
     process.stderr.write(
-      `${pc2.dim("sift")} child_exit=${exitCode} captured_chars=${capture.getTotalChars()} capture_truncated=${capture.wasTruncated()}
+      `${pc3.dim("sift")} child_exit=${exitCode} captured_chars=${capture.getTotalChars()} capture_truncated=${capture.wasTruncated()}
 `
     );
   }
   if (!bypassed) {
+    if (request.showRaw && capturedOutput.length > 0) {
+      process.stderr.write(capturedOutput);
+      if (!capturedOutput.endsWith("\n")) {
+        process.stderr.write("\n");
+      }
+    }
     const execSuccessShortcut = getExecSuccessShortcut({
       presetName: request.presetName,
       exitCode,
@@ -1750,7 +2430,7 @@ async function runExec(request) {
     if (execSuccessShortcut && !request.dryRun) {
       if (request.config.runtime.verbose) {
         process.stderr.write(
-          `${pc2.dim("sift")} exec_shortcut=${request.presetName}
+          `${pc3.dim("sift")} exec_shortcut=${request.presetName}
 `
         );
       }
@@ -1758,10 +2438,18 @@ async function runExec(request) {
 `);
       return exitCode;
     }
-    const output = await runSift({
+    let output = await runSift({
       ...request,
       stdin: capturedOutput
     });
+    if (isInsufficientSignalOutput(output)) {
+      output = buildInsufficientSignalOutput({
+        presetName: request.presetName,
+        originalLength: capture.getTotalChars(),
+        truncatedApplied: capture.wasTruncated(),
+        exitCode
+      });
+    }
     process.stdout.write(`${output}
 `);
     if (request.failOn && !request.dryRun && exitCode === 0 && supportsFailOnPreset(request.presetName) && evaluateGate({
@@ -1795,16 +2483,27 @@ function getPreset(config, name) {
   return preset;
 }
 
-// src/cli.ts
+// src/cli-app.ts
 var require2 = createRequire(import.meta.url);
 var pkg = require2("../package.json");
-var cli = cac("sift");
-var HELP_BANNER = [
-  "   \\\\  //",
-  "    \\\\//",
-  "     ||",
-  "     o"
-].join("\n");
+var defaultCliDeps = {
+  configInit,
+  configSetup,
+  configShow,
+  configValidate,
+  runDoctor,
+  listPresets,
+  showPreset,
+  resolveConfig,
+  findConfigPath,
+  runExec,
+  assertSupportedFailOnFormat,
+  assertSupportedFailOnPreset,
+  evaluateGate,
+  readStdin,
+  runSift,
+  getPreset
+};
 function toNumber(value) {
   if (value === void 0 || value === null || value === "") {
     return void 0;
@@ -1849,44 +2548,32 @@ function applySharedOptions(command) {
   ).option(
     "--json-response-format <mode>",
     "JSON response format mode: auto | on | off"
-  ).option("--timeout-ms <ms>", "Request timeout in milliseconds").option("--format <format>", "brief | bullets | json | verdict").option("--max-capture-chars <n>", "Maximum raw child output chars kept in memory").option("--max-input-chars <n>", "Maximum input chars sent to the model").option("--head-chars <n>", "Head chars to preserve during truncation").option("--tail-chars <n>", "Tail chars to preserve during truncation").option("--strip-ansi", "Force ANSI stripping").option("--redact", "Enable standard redaction").option("--redact-strict", "Enable strict redaction").option("--raw-fallback", "Enable raw fallback text output").option("--dry-run", "Show the reduced input and prompt without calling the provider").option(
+  ).option("--timeout-ms <ms>", "Request timeout in milliseconds").option("--format <format>", "brief | bullets | json | verdict").option(
+    "--detail <mode>",
+    "Detail level for supported presets: standard | focused | verbose"
+  ).option("--max-capture-chars <n>", "Maximum raw child output chars kept in memory").option("--max-input-chars <n>", "Maximum input chars sent to the model").option("--head-chars <n>", "Head chars to preserve during truncation").option("--tail-chars <n>", "Tail chars to preserve during truncation").option("--strip-ansi", "Force ANSI stripping").option("--redact", "Enable standard redaction").option("--redact-strict", "Enable strict redaction").option("--raw-fallback", "Enable raw fallback text output").option("--dry-run", "Show the reduced input and prompt without calling the provider").option("--show-raw", "Print the captured raw input to stderr for debugging").option(
     "--fail-on",
     "Fail with exit code 1 when a supported built-in preset produces a blocking result"
   ).option("--config <path>", "Path to config file").option("--verbose", "Enable verbose stderr logging");
 }
-async function executeRun(args) {
-  if (Boolean(args.options.failOn)) {
-    assertSupportedFailOnPreset(args.presetName);
-    assertSupportedFailOnFormat({
-      presetName: args.presetName,
-      format: args.format
-    });
+function normalizeDetail(value) {
+  if (value === void 0 || value === null || value === "") {
+    return void 0;
   }
-  const config = resolveConfig({
-    configPath: args.options.config,
-    env: process.env,
-    cliOverrides: buildCliOverrides(args.options)
-  });
-  const stdin = await readStdin();
-  const output = await runSift({
-    question: args.question,
-    format: args.format,
-    stdin,
-    config,
-    dryRun: Boolean(args.options.dryRun),
-    presetName: args.presetName,
-    policyName: args.policyName,
-    outputContract: args.outputContract,
-    fallbackJson: args.fallbackJson
-  });
-  process.stdout.write(`${output}
-`);
-  if (Boolean(args.options.failOn) && !Boolean(args.options.dryRun) && args.presetName && evaluateGate({
-    presetName: args.presetName,
-    output
-  }).shouldFail) {
-    process.exitCode = 1;
+  if (value === "standard" || value === "focused" || value === "verbose") {
+    return value;
+  }
+  throw new Error("Invalid --detail value. Use standard, focused, or verbose.");
+}
+function resolveDetail(args) {
+  const requested = normalizeDetail(args.options.detail);
+  if (!requested) {
+    return args.presetName === "test-status" ? "standard" : void 0;
+  }
+  if (args.presetName !== "test-status") {
+    throw new Error("--detail is supported only with --preset test-status.");
   }
+  return requested;
 }
 function extractExecCommand(options) {
   const passthrough = Array.isArray(options["--"]) ? options["--"].map((value) => String(value)) : [];
@@ -1902,180 +2589,278 @@ function extractExecCommand(options) {
     shellCommand
   };
 }
-async function executeExec(args) {
-  if (Boolean(args.options.failOn)) {
-    assertSupportedFailOnPreset(args.presetName);
-    assertSupportedFailOnFormat({
-      presetName: args.presetName,
-      format: args.format
+function cleanHelpSectionBody(body, escapedVersion) {
+  return body.replace(
+    new RegExp(`(^|\\n)sift/${escapedVersion}\\n\\n?`, "g"),
+    "\n"
+  );
+}
+function createCliApp(args = {}) {
+  const deps = {
+    ...defaultCliDeps,
+    ...args.deps
+  };
+  const env = args.env ?? process.env;
+  const stdout = args.stdout ?? process.stdout;
+  const stderr = args.stderr ?? process.stderr;
+  const version = args.version ?? pkg.version;
+  const cli = cac("sift");
+  const ui = createPresentation(Boolean(stdout.isTTY));
+  const escapedVersion = version.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  async function executeRun(input) {
+    if (Boolean(input.options.failOn)) {
+      deps.assertSupportedFailOnPreset(input.presetName);
+      deps.assertSupportedFailOnFormat({
+        presetName: input.presetName,
+        format: input.format
+      });
+    }
+    const config = deps.resolveConfig({
+      configPath: input.options.config,
+      env,
+      cliOverrides: buildCliOverrides(input.options)
     });
+    const stdin = await deps.readStdin();
+    if (Boolean(input.options.showRaw) && stdin.length > 0) {
+      stderr.write(stdin);
+      if (!stdin.endsWith("\n")) {
+        stderr.write("\n");
+      }
+    }
+    const output = await deps.runSift({
+      question: input.question,
+      format: input.format,
+      stdin,
+      config,
+      dryRun: Boolean(input.options.dryRun),
+      showRaw: Boolean(input.options.showRaw),
+      detail: input.detail,
+      presetName: input.presetName,
+      policyName: input.policyName,
+      outputContract: input.outputContract,
+      fallbackJson: input.fallbackJson
+    });
+    stdout.write(`${output}
+`);
+    if (Boolean(input.options.failOn) && !Boolean(input.options.dryRun) && input.presetName && deps.evaluateGate({
+      presetName: input.presetName,
+      output
+    }).shouldFail) {
+      process.exitCode = 1;
+    }
   }
-  const config = resolveConfig({
-    configPath: args.options.config,
-    env: process.env,
-    cliOverrides: buildCliOverrides(args.options)
-  });
-  const command = extractExecCommand(args.options);
-  process.exitCode = await runExec({
-    question: args.question,
-    format: args.format,
-    config,
-    dryRun: Boolean(args.options.dryRun),
-    failOn: Boolean(args.options.failOn),
-    presetName: args.presetName,
-    policyName: args.policyName,
-    outputContract: args.outputContract,
-    fallbackJson: args.fallbackJson,
-    ...command
-  });
-}
-applySharedOptions(
-  cli.command("preset <name>", "Run a named preset against piped CLI output")
-).usage("preset <name> [options]").example("preset test-status < test-output.txt").action(async (name, options) => {
-  const config = resolveConfig({
-    configPath: options.config,
-    env: process.env,
-    cliOverrides: buildCliOverrides(options)
-  });
-  const preset = getPreset(config, name);
-  await executeRun({
-    question: preset.question,
-    format: options.format ?? preset.format,
-    presetName: name,
-    policyName: options.format === void 0 || options.format === preset.format ? preset.policy : void 0,
-    options,
-    outputContract: preset.outputContract,
-    fallbackJson: preset.fallbackJson
-  });
-});
-applySharedOptions(
-  cli.command("exec [question]", "Run a command and reduce its output").allowUnknownOptions()
-).usage("exec [question] [options] -- <program> [args...]").example('exec "what changed?" -- git diff').example("exec --preset test-status -- pytest").example('exec --preset infra-risk --shell "terraform plan"').option("--shell <command>", "Execute a shell command string instead of argv mode").option("--preset <name>", "Run a named preset in exec mode").action(async (question, options) => {
-  if (question === "preset") {
-    throw new Error("Use 'sift exec --preset <name> -- <program> ...' instead.");
-  }
-  const presetName = typeof options.preset === "string" && options.preset.length > 0 ? options.preset : void 0;
-  if (presetName) {
-    if (question) {
-      throw new Error("Use either a freeform question or --preset <name>, not both.");
-    }
-    const preset = getPreset(
-      resolveConfig({
-        configPath: options.config,
-        env: process.env,
-        cliOverrides: buildCliOverrides(options)
-      }),
-      presetName
-    );
-    await executeExec({
+  async function executeExec(input) {
+    if (Boolean(input.options.failOn)) {
+      deps.assertSupportedFailOnPreset(input.presetName);
+      deps.assertSupportedFailOnFormat({
+        presetName: input.presetName,
+        format: input.format
+      });
+    }
+    const config = deps.resolveConfig({
+      configPath: input.options.config,
+      env,
+      cliOverrides: buildCliOverrides(input.options)
+    });
+    const command = extractExecCommand(input.options);
+    process.exitCode = await deps.runExec({
+      question: input.question,
+      format: input.format,
+      config,
+      dryRun: Boolean(input.options.dryRun),
+      failOn: Boolean(input.options.failOn),
+      showRaw: Boolean(input.options.showRaw),
+      detail: input.detail,
+      presetName: input.presetName,
+      policyName: input.policyName,
+      outputContract: input.outputContract,
+      fallbackJson: input.fallbackJson,
+      ...command
+    });
+  }
+  applySharedOptions(
+    cli.command("preset <name>", "Run a named preset against piped output")
+  ).usage("preset <name> [options]").example("preset test-status < test-output.txt").action(async (name, options) => {
+    const config = deps.resolveConfig({
+      configPath: options.config,
+      env,
+      cliOverrides: buildCliOverrides(options)
+    });
+    const preset = deps.getPreset(config, name);
+    await executeRun({
       question: preset.question,
       format: options.format ?? preset.format,
-      presetName,
+      presetName: name,
+      detail: resolveDetail({
+        presetName: name,
+        options
+      }),
       policyName: options.format === void 0 || options.format === preset.format ? preset.policy : void 0,
       options,
       outputContract: preset.outputContract,
       fallbackJson: preset.fallbackJson
     });
-    return;
-  }
-  if (!question) {
-    throw new Error("Missing question or preset.");
-  }
-  const format = options.format ?? "brief";
-  await executeExec({
-    question,
-    format,
-    options
   });
-});
-cli.command(
-  "config <action>",
-  "Config commands: setup | init | show | validate (show/validate use resolved runtime config)"
-).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(
-  "--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) => {
-  if (action === "setup") {
-    process.exitCode = await configSetup({
-      targetPath: options.path,
-      global: Boolean(options.global)
+  applySharedOptions(
+    cli.command("exec [question]", "Run a command and shrink its output for the model").allowUnknownOptions()
+  ).usage("exec [question] [options] -- <program> [args...]").example('exec "what changed?" -- git diff').example("exec --preset test-status -- pytest").example('exec --preset infra-risk --shell "terraform plan"').option("--shell <command>", "Execute a shell command string instead of argv mode").option("--preset <name>", "Run a named preset in exec mode").action(async (question, options) => {
+    if (question === "preset") {
+      throw new Error("Use 'sift exec --preset <name> -- <program> ...' instead.");
+    }
+    const presetName = typeof options.preset === "string" && options.preset.length > 0 ? options.preset : void 0;
+    if (presetName) {
+      if (question) {
+        throw new Error("Use either a freeform question or --preset <name>, not both.");
+      }
+      const preset = deps.getPreset(
+        deps.resolveConfig({
+          configPath: options.config,
+          env,
+          cliOverrides: buildCliOverrides(options)
+        }),
+        presetName
+      );
+      await executeExec({
+        question: preset.question,
+        format: options.format ?? preset.format,
+        presetName,
+        detail: resolveDetail({
+          presetName,
+          options
+        }),
+        policyName: options.format === void 0 || options.format === preset.format ? preset.policy : void 0,
+        options,
+        outputContract: preset.outputContract,
+        fallbackJson: preset.fallbackJson
+      });
+      return;
+    }
+    if (!question) {
+      throw new Error("Missing question or preset.");
+    }
+    const format = options.format ?? "brief";
+    await executeExec({
+      question,
+      format,
+      detail: resolveDetail({
+        options
+      }),
+      options
     });
-    return;
-  }
-  if (action === "init") {
-    configInit(
-      options.path,
-      Boolean(options.global)
-    );
-    return;
-  }
-  if (action === "show") {
-    configShow(
-      options.config,
-      Boolean(options.showSecrets)
-    );
-    return;
-  }
-  if (action === "validate") {
-    configValidate(options.config);
-    return;
-  }
-  throw new Error(`Unknown config action: ${action}`);
-});
-cli.command("doctor", "Check local runtime config completeness").usage("doctor [options]").option("--config <path>", "Path to config file").action((options) => {
-  const configPath = findConfigPath(options.config);
-  const config = resolveConfig({
-    configPath: options.config,
-    env: process.env
   });
-  process.exitCode = runDoctor(config, configPath);
-});
-cli.command("presets <action> [name]", "Preset commands: list | show").usage("presets <list|show> [name] [options]").example("presets list").example("presets show infra-risk").option("--config <path>", "Path to config file").option("--internal", "Show internal preset fields in presets show").action((action, name, options) => {
-  const config = resolveConfig({
-    configPath: options.config,
-    env: process.env
+  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(
+    "--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) => {
+    if (action === "setup") {
+      process.exitCode = await deps.configSetup({
+        targetPath: options.path,
+        global: Boolean(options.global)
+      });
+      return;
+    }
+    if (action === "init") {
+      deps.configInit(options.path, Boolean(options.global));
+      return;
+    }
+    if (action === "show") {
+      deps.configShow(
+        options.config,
+        Boolean(options.showSecrets)
+      );
+      return;
+    }
+    if (action === "validate") {
+      deps.configValidate(options.config);
+      return;
+    }
+    throw new Error(`Unknown config action: ${action}`);
   });
-  if (action === "list") {
-    listPresets(config);
-    return;
-  }
-  if (action === "show") {
-    if (!name) {
-      throw new Error("Missing preset name.");
+  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) => {
+    const configPath = deps.findConfigPath(options.config);
+    const config = deps.resolveConfig({
+      configPath: options.config,
+      env
+    });
+    process.exitCode = deps.runDoctor(config, configPath);
+  });
+  cli.command("presets <action> [name]", "Preset commands: list | show").usage("presets <list|show> [name] [options]").example("presets list").example("presets show infra-risk").option("--config <path>", "Path to config file").option("--internal", "Show internal preset fields in presets show").action((action, name, options) => {
+    const config = deps.resolveConfig({
+      configPath: options.config,
+      env
+    });
+    if (action === "list") {
+      deps.listPresets(config);
+      return;
     }
-    showPreset(config, name, Boolean(options.internal));
-    return;
-  }
-  throw new Error(`Unknown presets action: ${action}`);
-});
-applySharedOptions(
-  cli.command("[question]", "Ask a freeform question about piped CLI output")
-).action(async (question, options) => {
-  if (!question) {
-    throw new Error("Missing question.");
-  }
-  const format = options.format ?? "brief";
-  await executeRun({
-    question,
-    format,
-    options
+    if (action === "show") {
+      if (!name) {
+        throw new Error("Missing preset name.");
+      }
+      deps.showPreset(config, name, Boolean(options.internal));
+      return;
+    }
+    throw new Error(`Unknown presets action: ${action}`);
   });
-});
-cli.help((sections) => [
-  {
-    body: `${HELP_BANNER}
+  applySharedOptions(cli.command("[question]", "Ask a question about piped output")).action(
+    async (question, options) => {
+      if (!question) {
+        throw new Error("Missing question.");
+      }
+      const format = options.format ?? "brief";
+      await executeRun({
+        question,
+        format,
+        detail: resolveDetail({
+          options
+        }),
+        options
+      });
+    }
+  );
+  cli.help((sections) => {
+    const cleanedSections = sections.map((section) => ({
+      ...section,
+      body: cleanHelpSectionBody(section.body, escapedVersion)
+    }));
+    return [
+      {
+        body: `${ui.banner(version)}
 `
-  },
-  ...sections
-]);
-cli.version(pkg.version);
-async function main() {
-  cli.parse(process.argv, { run: false });
+      },
+      {
+        title: ui.section("Quick start"),
+        body: [
+          `  ${ui.command("sift config setup")}`,
+          `  ${ui.command("sift exec --preset test-status -- pytest")}`,
+          `  ${ui.command("sift exec --preset test-status --show-raw -- pytest")}`,
+          `  ${ui.command('sift exec "what changed?" -- git diff')}`
+        ].join("\n")
+      },
+      ...cleanedSections
+    ];
+  });
+  cli.version(version);
+  return cli;
+}
+async function runCli(args = {}) {
+  const cli = createCliApp(args);
+  cli.parse(args.argv ?? process.argv, { run: false });
   await cli.runMatchedCommand();
 }
-main().catch((error) => {
+function handleCliError(error, stderr = process.stderr) {
   const message = error instanceof Error ? error.message : "Unexpected error.";
-  process.stderr.write(`${message}
+  if (stderr.isTTY) {
+    stderr.write(`${createPresentation(true).error(message)}
+`);
+  } else {
+    stderr.write(`${message}
 `);
+  }
   process.exitCode = 1;
+}
+
+// src/cli.ts
+runCli().catch((error) => {
+  handleCliError(error);
 });